1 #include "otsdaq-core/FECore/FEVInterfacesManager.h"
2 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
3 #include "otsdaq-core/Macros/CoutMacros.h"
4 #include "otsdaq-core/MessageFacility/MessageFacility.h"
5 #include "otsdaq-core/PluginMakers/MakeInterface.h"
7 #include "artdaq-core/Utilities/configureMessageFacility.hh"
8 #include "artdaq/BuildInfo/GetPackageBuildInfo.hh"
9 #include "fhiclcpp/make_ParameterSet.h"
10 #include "messagefacility/MessageLogger/MessageLogger.h"
19 FEVInterfacesManager::FEVInterfacesManager(
21 const std::string& supervisorConfigurationPath)
22 :
Configurable(theXDAQContextConfigTree, supervisorConfigurationPath)
25 __CFG_COUT__ <<
"Constructed." << __E__;
29 FEVInterfacesManager::~FEVInterfacesManager(
void)
32 __CFG_COUT__ <<
"Destructed." << __E__;
36 void FEVInterfacesManager::init(
void) {}
39 void FEVInterfacesManager::destroy(
void)
41 for(
auto& it : theFEInterfaces_)
44 theFEInterfaces_.clear();
45 theFENamesByPriority_.clear();
49 void FEVInterfacesManager::createInterfaces(
void)
51 const std::string COL_NAME_feGroupLink =
"LinkToFEInterfaceTable";
52 const std::string COL_NAME_feTypeLink =
"LinkToFETypeTable";
53 const std::string COL_NAME_fePlugin =
"FEInterfacePluginName";
55 __CFG_COUT__ <<
"Path: " << theConfigurationPath_ +
"/" + COL_NAME_feGroupLink
62 theXDAQContextConfigTree_.getBackNode(theConfigurationPath_, 1);
63 __CFG_COUTV__(appNode.getValueAsString());
67 Configurable::getSelfNode().getNode(COL_NAME_feGroupLink);
69 std::vector<std::pair<std::string, ConfigurationTree>> feChildren =
70 feGroupLinkNode.getChildren();
73 theFENamesByPriority_ =
74 feGroupLinkNode.getChildrenNames(
true ,
true );
75 __CFG_COUTV__(StringMacros::vectorToString(theFENamesByPriority_));
77 for(
const auto& interface : feChildren)
81 if(!interface.second.getNode(TableViewColumnInfo::COL_NAME_STATUS)
87 __CFG_COUT_INFO__ <<
"Ignoring FE Status since Status column is missing!"
92 <<
"Interface Plugin Name: "
93 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
95 __CFG_COUT__ <<
"Interface Name: " << interface.first << __E__;
96 __CFG_COUT__ <<
"XDAQContext Node: " << theXDAQContextConfigTree_ << __E__;
97 __CFG_COUT__ <<
"Path to configuration: "
98 << (theConfigurationPath_ +
"/" + COL_NAME_feGroupLink +
"/" +
99 interface.first +
"/" + COL_NAME_feTypeLink)
104 theFEInterfaces_[interface.first] = makeInterface(
105 interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>(),
107 theXDAQContextConfigTree_,
108 (theConfigurationPath_ +
"/" + COL_NAME_feGroupLink +
"/" +
109 interface.first +
"/" + COL_NAME_feTypeLink));
113 theFEInterfaces_[interface.first]->VStateMachine::parentSupervisor_ =
114 VStateMachine::parentSupervisor_;
115 theFEInterfaces_[interface.first]->parentInterfaceManager_ =
this;
117 catch(
const cet::exception& e)
120 <<
"Failed to instantiate plugin named '" << interface.first
122 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
123 <<
"' due to the following error: \n"
124 << e.what() << __E__;
125 __MOUT_ERR__ << ss.str();
128 catch(
const std::runtime_error& e)
131 <<
"Failed to instantiate plugin named '" << interface.first
133 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
134 <<
"' due to the following error: \n"
135 << e.what() << __E__;
136 __MOUT_ERR__ << ss.str();
142 <<
"Failed to instantiate plugin named '" << interface.first
144 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
145 <<
"' due to an unknown error." << __E__;
146 __MOUT_ERR__ << ss.str();
151 __CFG_COUT__ <<
"Done creating interfaces" << __E__;
155 void FEVInterfacesManager::configure(
void)
157 const std::string transitionName =
"Configuring";
159 __CFG_COUT__ << transitionName <<
" FEVInterfacesManager " << __E__;
162 if(VStateMachine::getIterationIndex() == 0 &&
163 VStateMachine::getSubIterationIndex() == 0)
168 preStateMachineExecutionLoop();
169 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
172 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
173 i != subIterationWorkStateMachineIndex_)
176 const std::string& name = theFENamesByPriority_[i];
179 fe = getFEInterfaceP(name);
181 if(stateMachinesIterationDone_[name])
184 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
185 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
186 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
188 preStateMachineExecution(i);
190 postStateMachineExecution(i);
194 fe->configureSlowControls();
195 fe->startSlowControlsWorkLooop();
197 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
198 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
199 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
201 postStateMachineExecutionLoop();
203 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
207 void FEVInterfacesManager::halt(
void)
209 const std::string transitionName =
"Halting";
212 preStateMachineExecutionLoop();
213 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
216 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
217 i != subIterationWorkStateMachineIndex_)
220 const std::string& name = theFENamesByPriority_[i];
222 fe = getFEInterfaceP(name);
224 if(stateMachinesIterationDone_[name])
227 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
228 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
229 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
231 preStateMachineExecution(i);
241 <<
"An error occurred while halting the front-end workloop for '" << name
242 <<
",' ignoring." << __E__;
248 fe->stopSlowControlsWorkLooop();
252 __CFG_COUT_WARN__ <<
"An error occurred while halting the Slow Controls "
253 "front-end workloop for '"
254 << name <<
",' ignoring." << __E__;
264 __CFG_COUT_WARN__ <<
"An error occurred while halting the front-end '" << name
265 <<
",' ignoring." << __E__;
268 postStateMachineExecution(i);
270 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
271 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
272 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
274 postStateMachineExecutionLoop();
279 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
283 void FEVInterfacesManager::pause(
void)
285 const std::string transitionName =
"Pausing";
288 preStateMachineExecutionLoop();
289 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
292 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
293 i != subIterationWorkStateMachineIndex_)
296 const std::string& name = theFENamesByPriority_[i];
298 fe = getFEInterfaceP(name);
300 if(stateMachinesIterationDone_[name])
303 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
304 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
305 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
307 preStateMachineExecution(i);
310 postStateMachineExecution(i);
312 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
313 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
314 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
316 postStateMachineExecutionLoop();
318 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
322 void FEVInterfacesManager::resume(
void)
324 const std::string transitionName =
"Resuming";
327 preStateMachineExecutionLoop();
328 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
331 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
332 i != subIterationWorkStateMachineIndex_)
335 const std::string& name = theFENamesByPriority_[i];
339 if(stateMachinesIterationDone_[name])
342 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
343 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
344 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
346 preStateMachineExecution(i);
349 if(postStateMachineExecution(i))
352 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
353 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
354 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
356 postStateMachineExecutionLoop();
358 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
363 void FEVInterfacesManager::start(std::string runNumber)
365 const std::string transitionName =
"Starting";
368 preStateMachineExecutionLoop();
369 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
372 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
373 i != subIterationWorkStateMachineIndex_)
376 const std::string& name = theFENamesByPriority_[i];
378 fe = getFEInterfaceP(name);
380 if(stateMachinesIterationDone_[name])
383 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
384 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
385 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
387 preStateMachineExecution(i);
388 fe->start(runNumber);
390 if(postStateMachineExecution(i))
393 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
394 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
395 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
397 postStateMachineExecutionLoop();
399 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
404 void FEVInterfacesManager::stop(
void)
406 const std::string transitionName =
"Starting";
409 preStateMachineExecutionLoop();
410 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
413 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
414 i != subIterationWorkStateMachineIndex_)
417 const std::string& name = theFENamesByPriority_[i];
419 fe = getFEInterfaceP(name);
421 if(stateMachinesIterationDone_[name])
424 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
425 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
426 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
428 preStateMachineExecution(i);
431 postStateMachineExecution(i);
433 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
434 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
435 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
437 postStateMachineExecutionLoop();
439 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
445 FEVInterface* FEVInterfacesManager::getFEInterfaceP(
const std::string& interfaceID)
449 return theFEInterfaces_.at(interfaceID).get();
453 __CFG_SS__ <<
"Interface ID '" << interfaceID
454 <<
"' not found in configured interfaces." << __E__;
461 const FEVInterface& FEVInterfacesManager::getFEInterface(
462 const std::string& interfaceID)
const
466 return *(theFEInterfaces_.at(interfaceID));
470 __CFG_SS__ <<
"Interface ID '" << interfaceID
471 <<
"' not found in configured interfaces." << __E__;
480 void FEVInterfacesManager::universalRead(
const std::string& interfaceID,
484 getFEInterfaceP(interfaceID)->universalRead(address, returnValue);
490 unsigned int FEVInterfacesManager::getInterfaceUniversalAddressSize(
491 const std::string& interfaceID)
493 return getFEInterfaceP(interfaceID)->getUniversalAddressSize();
499 unsigned int FEVInterfacesManager::getInterfaceUniversalDataSize(
500 const std::string& interfaceID)
502 return getFEInterfaceP(interfaceID)->getUniversalDataSize();
508 void FEVInterfacesManager::universalWrite(
const std::string& interfaceID,
512 getFEInterfaceP(interfaceID)->universalWrite(address, writeValue);
520 std::string FEVInterfacesManager::getFEListString(
const std::string& supervisorLid)
522 std::string retList =
"";
524 for(
const auto& it : theFEInterfaces_)
526 __CFG_COUT__ <<
"FE name = " << it.first << __E__;
528 retList += it.second->getInterfaceType() +
":" + supervisorLid +
":" +
529 it.second->getInterfaceUID() +
"\n";
552 const std::string& interfaceID,
553 const std::string& macroName,
554 const std::string& macroString,
555 const bool enableSavingOutput,
556 const std::string& outputFilePath,
557 const std::string& outputFileRadix,
558 const std::string& inputArgs)
560 if(requester !=
"iterator")
562 __CFG_SS__ <<
"Invalid requester '" << requester <<
"'" << __E__;
566 __CFG_COUT__ <<
"Starting multi-dimensional Macro '" << macroName
567 <<
"' for interface '" << interfaceID <<
".'" << __E__;
569 __CFG_COUTV__(macroString);
571 __CFG_COUTV__(inputArgs);
575 std::lock_guard<std::mutex> lock(macroMultiDimensionalDoneMutex_);
577 if(macroMultiDimensionalStatusMap_.find(interfaceID) !=
578 macroMultiDimensionalStatusMap_.end())
580 __SS__ <<
"Failed to start multi-dimensional Macro '" << macroName
581 <<
"' for interface '" << interfaceID
582 <<
"' - this interface already has an active Macro launch!" << __E__;
585 macroMultiDimensionalStatusMap_.emplace(std::make_pair(interfaceID,
"Active"));
591 const std::string interfaceID,
592 const std::string macroName,
593 const std::string macroString,
594 const bool enableSavingOutput,
595 const std::string outputFilePath,
596 const std::string outputFileRadix,
597 const std::string inputArgsStr) {
600 std::string mfSubject_ =
"threadMultiD-" + macroName;
601 __GEN_COUT__ <<
"Thread started." << __E__;
603 std::string statusResult =
"Done";
617 FILE* outputFilePointer = 0;
618 if(enableSavingOutput)
620 std::string filename = outputFilePath +
"/" + outputFileRadix +
621 macroName +
"_" + std::to_string(time(0)) +
623 __GEN_COUT__ <<
"Opening file... " << filename << __E__;
625 outputFilePointer = fopen(filename.c_str(),
"w");
626 if(!outputFilePointer)
628 __GEN_SS__ <<
"Failed to open output file: " << filename << __E__;
635 __GEN_COUTV__(inputArgsStr);
655 std::vector<
unsigned long > dimensionIterations,
656 dimensionIterationCnt;
658 using longParamMap_t = std::map<
661 std::pair<
long ,
long >>>;
663 std::vector<longParamMap_t> longDimensionParameters;
668 std::map<std::string , uint64_t > variableMap;
673 for(
const auto& inputArgName : macro.namesOfInputArguments_)
675 std::pair<std::string /*name*/, uint64_t /*value*/>(inputArgName,
677 for(
const auto& outputArgName : macro.namesOfOutputArguments_)
679 std::pair<std::string /*name*/, uint64_t /*value*/>(outputArgName,
686 dimensionIterations.push_back(2);
687 dimensionIterations.push_back(4);
689 longDimensionParameters.push_back(longParamMap_t());
690 longDimensionParameters.push_back(longParamMap_t());
692 longDimensionParameters.back().emplace(std::make_pair(
696 std::make_pair(3 , 4 ))));
699 std::vector<std::string> dimensionArgs;
700 StringMacros::getVectorFromString(
701 inputArgsStr, dimensionArgs, {
';'} );
703 __GEN_COUTV__(dimensionArgs.size());
706 if(dimensionArgs.size() == 0)
711 dimensionIterations.push_back(1);
712 longDimensionParameters.push_back(longParamMap_t());
715 for(
unsigned int d = 0; d < dimensionArgs.size(); ++d)
720 std::vector<std::string> args;
721 StringMacros::getVectorFromString(
722 dimensionArgs[d], args, {
','} );
730 __GEN_SS__ <<
"Invalid dimensional arguments! "
731 <<
"Need number of iterations at dimension " << d
736 unsigned long numOfIterations;
737 StringMacros::getNumber(args[0], numOfIterations);
738 __GEN_COUT__ <<
"Dimension " << d
739 <<
" numOfIterations=" << numOfIterations << __E__;
743 dimensionIterations.push_back(numOfIterations);
744 longDimensionParameters.push_back(longParamMap_t());
748 for(
unsigned int a = 1; a < args.size(); ++a)
750 std::vector<std::string> argPieces;
751 StringMacros::getVectorFromString(
752 args[a], argPieces, {
':'} );
754 __GEN_COUTV__(StringMacros::vectorToString(argPieces));
758 if(argPieces.size() != 3)
760 __GEN_SS__ <<
"Invalid argument pieces! Should be size "
762 << argPieces.size() << __E__;
763 ss << StringMacros::vectorToString(argPieces);
769 if((argPieces[1].size() &&
770 (argPieces[1][argPieces[1].size() - 1] ==
'f' ||
771 argPieces[1].find(
'.') != std::string::npos)) ||
772 (argPieces[2].size() &&
773 (argPieces[2][argPieces[2].size() - 1] ==
'f' ||
774 argPieces[2].find(
'.') != std::string::npos)))
778 double startValue = strtod(argPieces[1].c_str(), 0);
779 double stepSize = strtod(argPieces[2].c_str(), 0);
781 __GEN_COUTV__(startValue);
782 __GEN_COUTV__(stepSize);
785 <<
"Error! Only integer aruments allowed for Macros. "
786 <<
"Double style arugment found: " << argPieces[0]
787 <<
"' := " << startValue <<
", " << stepSize << __E__;
808 StringMacros::getNumber(argPieces[1], startValue);
809 StringMacros::getNumber(argPieces[2], stepSize);
811 __GEN_COUTV__(startValue);
812 __GEN_COUTV__(stepSize);
814 __GEN_COUT__ <<
"Creating long argument '" << argPieces[0]
815 <<
"' := " << startValue <<
", " << stepSize
818 longDimensionParameters.back().emplace(std::make_pair(
822 std::make_pair(startValue ,
830 if(dimensionIterations.size() != longDimensionParameters.size())
832 __GEN_SS__ <<
"Impossible vector size mismatch! "
833 << dimensionIterations.size() <<
" - "
834 << longDimensionParameters.size() << __E__;
840 std::stringstream outSS;
842 outSS <<
"\n==========================\n" << __E__;
843 outSS <<
"Macro '" << macro.macroName_
844 <<
"' multi-dimensional scan..." << __E__;
845 outSS <<
"\t" << StringMacros::getTimestampString() << __E__;
846 outSS <<
"\t" << dimensionIterations.size()
847 <<
" dimensions defined." << __E__;
848 for(
unsigned int i = 0; i < dimensionIterations.size(); ++i)
851 <<
"dimension[" << i <<
"] has "
852 << dimensionIterations[i] <<
" iterations and "
853 << (longDimensionParameters[i].size()) <<
" arguments."
856 for(
auto& param : longDimensionParameters[i])
858 <<
"'" << param.first <<
"' of type long with "
859 <<
"initial value and step value [decimal] = "
860 <<
"\t" << param.second.second.first <<
" & "
861 << param.second.second.second << __E__;
864 outSS <<
"\nInput argument names:" << __E__;
865 for(
const auto& inputArgName : macro.namesOfInputArguments_)
866 outSS <<
"\t" << inputArgName << __E__;
867 outSS <<
"\nOutput argument names:" << __E__;
868 for(
const auto& outputArgName : macro.namesOfOutputArguments_)
869 outSS <<
"\t" << outputArgName << __E__;
871 outSS <<
"\n==========================\n" << __E__;
875 __GEN_COUT__ <<
"\n" << outSS.str();
876 if(outputFilePointer)
877 fprintf(outputFilePointer, outSS.str().c_str());
880 unsigned int iterationCount = 0;
888 std::function<void(
const unsigned int
890 localRecurse = [&dimensionIterations,
891 &dimensionIterationCnt,
893 &longDimensionParameters,
898 &localRecurse](
const unsigned int dimension) {
901 std::string mfSubject_ =
"multiD-" + std::to_string(dimension) +
902 "-" + macro.macroName_;
903 __GEN_COUTV__(dimension);
905 if(dimension >= dimensionIterations.size())
907 __GEN_COUT__ <<
"Iteration count: " << iterationCount++
909 __GEN_COUT__ <<
"Launching Macro '" << macro.macroName_
920 for(
unsigned int j = 0; j < dimensionIterations.size();
923 for(
auto& longParam : longDimensionParameters[j])
926 <<
"Assigning argIn '" << longParam.first
927 <<
"' to current long value '"
928 << longParam.second.first
929 <<
"' from dimension " << j <<
" parameter."
931 variableMap.at(longParam.first) =
932 longParam.second.first;
940 std::stringstream outSS;
942 outSS <<
"\n---------------\n" << __E__;
943 outSS <<
"Macro '" << macro.macroName_
944 <<
"' execution..." << __E__;
946 <<
"iteration " << iterationCount << __E__;
947 for(
unsigned int i = 0;
948 i < dimensionIterationCnt.size();
952 <<
"] index := " << dimensionIterationCnt[i]
957 <<
"Input arguments (count: "
958 << macro.namesOfInputArguments_.size()
960 for(
auto& argIn : macro.namesOfInputArguments_)
961 outSS <<
"\t\t" << argIn <<
" = "
962 << variableMap.at(argIn) << __E__;
967 __GEN_COUT__ <<
"\n" << outSS.str();
968 if(outputFilePointer)
969 fprintf(outputFilePointer, outSS.str().c_str());
973 fe->runMacro(macro, variableMap);
975 __GEN_COUT__ <<
"Macro complete!" << __E__;
979 std::stringstream outSS;
983 <<
"Output arguments (count: "
984 << macro.namesOfOutputArguments_.size()
986 for(
auto& argOut : macro.namesOfOutputArguments_)
987 outSS <<
"\t\t" << argOut <<
" = "
988 << variableMap.at(argOut) << __E__;
992 __GEN_COUT__ <<
"\n" << outSS.str();
993 if(outputFilePointer)
994 fprintf(outputFilePointer, outSS.str().c_str());
1001 if(dimension >= dimensionIterationCnt.size())
1002 dimensionIterationCnt.push_back(0);
1005 __GEN_COUT__ <<
"\n"
1006 <<
"======================================" << __E__
1007 <<
"dimension[" << dimension
1008 <<
"] number of iterations := "
1009 << dimensionIterations[dimension] << __E__;
1014 for(
auto& longPair : longDimensionParameters[dimension])
1016 longPair.second.first =
1017 longPair.second.second.first;
1019 <<
"arg '" << longPair.first
1020 <<
"' current value: " << longPair.second.first
1027 for(dimensionIterationCnt[dimension] =
1029 dimensionIterationCnt[dimension] <
1030 dimensionIterations[dimension];
1031 ++dimensionIterationCnt[dimension])
1033 __GEN_COUT__ <<
"dimension[" << dimension <<
"] index := "
1034 << dimensionIterationCnt[dimension] << __E__;
1036 localRecurse(dimension + 1);
1041 for(
auto& longPair : longDimensionParameters[dimension])
1043 longPair.second.first +=
1044 longPair.second.second.second;
1046 <<
"arg '" << longPair.first
1047 <<
"' current value: " << longPair.second.first
1054 __GEN_COUT__ <<
"Completed dimension[" << dimension
1055 <<
"] number of iterations := "
1056 << dimensionIterationCnt[dimension] <<
" of "
1057 << dimensionIterations[dimension] << __E__;
1064 if(outputFilePointer)
1065 fclose(outputFilePointer);
1067 catch(
const std::runtime_error& e)
1069 __SS__ <<
"Error executing multi-dimensional Macro: " << e.what()
1071 statusResult = ss.str();
1075 __SS__ <<
"Unknown error executing multi-dimensional Macro. " << __E__;
1076 statusResult = ss.str();
1079 __COUTV__(statusResult);
1082 std::lock_guard<std::mutex> lock(feMgr->macroMultiDimensionalDoneMutex_);
1084 feMgr->macroMultiDimensionalStatusMap_[interfaceID] = statusResult;
1098 __CFG_COUT__ <<
"Started multi-dimensional Macro '" << macroName
1099 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1120 void FEVInterfacesManager::startFEMacroMultiDimensional(
1121 const std::string& requester,
1122 const std::string& interfaceID,
1123 const std::string& feMacroName,
1124 const bool enableSavingOutput,
1125 const std::string& outputFilePath,
1126 const std::string& outputFileRadix,
1127 const std::string& inputArgs)
1129 if(requester !=
"iterator")
1131 __CFG_SS__ <<
"Invalid requester '" << requester <<
"'" << __E__;
1135 __CFG_COUT__ <<
"Starting multi-dimensional FE Macro '" << feMacroName
1136 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1137 __CFG_COUTV__(inputArgs);
1141 std::lock_guard<std::mutex> lock(macroMultiDimensionalDoneMutex_);
1143 if(macroMultiDimensionalStatusMap_.find(interfaceID) !=
1144 macroMultiDimensionalStatusMap_.end())
1146 __SS__ <<
"Failed to start multi-dimensional FE Macro '" << feMacroName
1147 <<
"' for interface '" << interfaceID
1148 <<
"' - this interface already has an active FE Macro launch!"
1152 macroMultiDimensionalStatusMap_.emplace(std::make_pair(interfaceID,
"Active"));
1158 const std::string interfaceID,
1159 const std::string feMacroName,
1160 const bool enableSavingOutput,
1161 const std::string outputFilePath,
1162 const std::string outputFileRadix,
1163 const std::string inputArgsStr) {
1166 std::string mfSubject_ =
"threadMultiD-" + feMacroName;
1167 __GEN_COUT__ <<
"Thread started." << __E__;
1169 std::string statusResult =
"Done";
1175 FEVInterface* fe = feMgr->getFEInterfaceP(interfaceID);
1178 auto FEMacroIt = fe->getMapOfFEMacroFunctions().find(feMacroName);
1179 if(FEMacroIt == fe->getMapOfFEMacroFunctions().end())
1181 __GEN_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '"
1182 << interfaceID <<
"' was not found!" << __E__;
1189 FILE* outputFilePointer = 0;
1190 if(enableSavingOutput)
1192 std::string filename = outputFilePath +
"/" + outputFileRadix +
1193 feMacroName +
"_" + std::to_string(time(0)) +
1195 __GEN_COUT__ <<
"Opening file... " << filename << __E__;
1197 outputFilePointer = fopen(filename.c_str(),
"w");
1198 if(!outputFilePointer)
1200 __GEN_SS__ <<
"Failed to open output file: " << filename << __E__;
1207 __GEN_COUTV__(inputArgsStr);
1227 std::vector<
unsigned long > dimensionIterations,
1228 dimensionIterationCnt;
1230 using longParamMap_t = std::map<
1233 std::pair<
long ,
long >>>;
1234 using doubleParamMap_t =
1235 std::map<std::string ,
1240 std::vector<longParamMap_t> longDimensionParameters;
1241 std::vector<doubleParamMap_t> doubleDimensionParameters;
1243 std::vector<FEVInterface::frontEndMacroArg_t> argsIn;
1244 std::vector<FEVInterface::frontEndMacroArg_t> argsOut;
1246 for(
unsigned int i = 0; i < feMacro.namesOfInputArguments_.size(); ++i)
1247 argsIn.push_back(std::make_pair(
1248 feMacro.namesOfInputArguments_[i],
1250 for(
unsigned int i = 0; i < feMacro.namesOfOutputArguments_.size(); ++i)
1253 feMacro.namesOfOutputArguments_[i],
1260 argsIn.push_back(std::make_pair(
"myOtherArg",
"3"));
1262 dimensionIterations.push_back(2);
1263 dimensionIterations.push_back(4);
1265 longDimensionParameters.push_back(longParamMap_t());
1266 longDimensionParameters.push_back(longParamMap_t());
1268 doubleDimensionParameters.push_back(doubleParamMap_t());
1269 doubleDimensionParameters.push_back(doubleParamMap_t());
1271 longDimensionParameters.back().emplace(std::make_pair(
1275 std::make_pair(3 , 4 ))));
1278 std::vector<std::string> dimensionArgs;
1279 StringMacros::getVectorFromString(
1280 inputArgsStr, dimensionArgs, {
';'} );
1282 __GEN_COUTV__(dimensionArgs.size());
1285 if(dimensionArgs.size() == 0)
1290 dimensionIterations.push_back(1);
1291 longDimensionParameters.push_back(longParamMap_t());
1292 doubleDimensionParameters.push_back(doubleParamMap_t());
1295 for(
unsigned int d = 0; d < dimensionArgs.size(); ++d)
1300 std::vector<std::string> args;
1301 StringMacros::getVectorFromString(
1302 dimensionArgs[d], args, {
','} );
1308 if(args.size() == 0)
1310 __GEN_SS__ <<
"Invalid dimensional arguments! "
1311 <<
"Need number of iterations at dimension " << d
1316 unsigned long numOfIterations;
1317 StringMacros::getNumber(args[0], numOfIterations);
1318 __GEN_COUT__ <<
"Dimension " << d
1319 <<
" numOfIterations=" << numOfIterations << __E__;
1323 dimensionIterations.push_back(numOfIterations);
1324 longDimensionParameters.push_back(longParamMap_t());
1325 doubleDimensionParameters.push_back(doubleParamMap_t());
1329 for(
unsigned int a = 1; a < args.size(); ++a)
1331 std::vector<std::string> argPieces;
1332 StringMacros::getVectorFromString(
1333 args[a], argPieces, {
':'} );
1335 __GEN_COUTV__(StringMacros::vectorToString(argPieces));
1339 if(argPieces.size() != 3)
1341 __GEN_SS__ <<
"Invalid argument pieces! Should be size "
1343 << argPieces.size() << __E__;
1344 ss << StringMacros::vectorToString(argPieces);
1350 if((argPieces[1].size() &&
1351 (argPieces[1][argPieces[1].size() - 1] ==
'f' ||
1352 argPieces[1].find(
'.') != std::string::npos)) ||
1353 (argPieces[2].size() &&
1354 (argPieces[2][argPieces[2].size() - 1] ==
'f' ||
1355 argPieces[2].find(
'.') != std::string::npos)))
1360 double startValue = strtod(argPieces[1].c_str(), 0);
1361 double stepSize = strtod(argPieces[2].c_str(), 0);
1363 __GEN_COUTV__(startValue);
1364 __GEN_COUTV__(stepSize);
1366 __GEN_COUT__ <<
"Creating double argument '"
1367 << argPieces[0] <<
"' := " << startValue
1368 <<
", " << stepSize << __E__;
1370 doubleDimensionParameters.back().emplace(std::make_pair(
1374 std::make_pair(startValue ,
1382 long int startValue;
1385 StringMacros::getNumber(argPieces[1], startValue);
1386 StringMacros::getNumber(argPieces[2], stepSize);
1388 __GEN_COUTV__(startValue);
1389 __GEN_COUTV__(stepSize);
1391 __GEN_COUT__ <<
"Creating long argument '" << argPieces[0]
1392 <<
"' := " << startValue <<
", " << stepSize
1395 longDimensionParameters.back().emplace(std::make_pair(
1399 std::make_pair(startValue ,
1407 if(dimensionIterations.size() != longDimensionParameters.size() ||
1408 dimensionIterations.size() != doubleDimensionParameters.size())
1410 __GEN_SS__ <<
"Impossible vector size mismatch! "
1411 << dimensionIterations.size() <<
" - "
1412 << longDimensionParameters.size() <<
" - "
1413 << doubleDimensionParameters.size() << __E__;
1419 std::stringstream outSS;
1421 outSS <<
"\n==========================\n" << __E__;
1422 outSS <<
"FEMacro '" << feMacro.feMacroName_
1423 <<
"' multi-dimensional scan..." << __E__;
1424 outSS <<
"\t" << StringMacros::getTimestampString() << __E__;
1425 outSS <<
"\t" << dimensionIterations.size()
1426 <<
" dimensions defined." << __E__;
1427 for(
unsigned int i = 0; i < dimensionIterations.size(); ++i)
1430 <<
"dimension[" << i <<
"] has "
1431 << dimensionIterations[i] <<
" iterations and "
1432 << (longDimensionParameters[i].size() +
1433 doubleDimensionParameters[i].size())
1434 <<
" arguments." << __E__;
1436 for(
auto& param : longDimensionParameters[i])
1438 <<
"'" << param.first <<
"' of type long with "
1439 <<
"initial value and step value [decimal] = "
1440 <<
"\t" << param.second.second.first <<
" & "
1441 << param.second.second.second << __E__;
1443 for(
auto& param : doubleDimensionParameters[i])
1445 <<
"'" << param.first <<
"' of type double with "
1446 <<
"initial value and step value = "
1447 <<
"\t" << param.second.second.first <<
" & "
1448 << param.second.second.second << __E__;
1451 outSS <<
"\nHere are the identified input arguments:" << __E__;
1452 for(
unsigned int i = 0; i < feMacro.namesOfInputArguments_.size();
1454 outSS <<
"\t" << feMacro.namesOfInputArguments_[i] << __E__;
1455 outSS <<
"\nHere are the identified input arguments:" << __E__;
1456 for(
unsigned int i = 0;
1457 i < feMacro.namesOfOutputArguments_.size();
1459 outSS <<
"\t" << feMacro.namesOfOutputArguments_[i] << __E__;
1461 outSS <<
"\n==========================\n" << __E__;
1465 __GEN_COUT__ <<
"\n" << outSS.str();
1466 if(outputFilePointer)
1467 fprintf(outputFilePointer, outSS.str().c_str());
1470 unsigned int iterationCount = 0;
1478 std::function<void(
const unsigned int
1480 localRecurse = [&dimensionIterations,
1481 &dimensionIterationCnt,
1483 &longDimensionParameters,
1484 &doubleDimensionParameters,
1490 &localRecurse](
const unsigned int dimension) {
1493 std::string mfSubject_ =
"multiD-" + std::to_string(dimension) +
1494 "-" + feMacro.feMacroName_;
1495 __GEN_COUTV__(dimension);
1497 if(dimension >= dimensionIterations.size())
1499 __GEN_COUT__ <<
"Iteration count: " << iterationCount++
1501 __GEN_COUT__ <<
"Launching FE Macro '" << feMacro.feMacroName_
1502 <<
"' ..." << __E__;
1513 for(
unsigned int i = 0; i < argsIn.size(); ++i)
1515 foundAsLong =
false;
1516 for(
unsigned int j = 0; j < dimensionIterations.size();
1520 longDimensionParameters[j].find(argsIn[i].first);
1521 if(longIt == longDimensionParameters[j].end())
1525 __GEN_COUT__ <<
"Assigning argIn '" << argsIn[i].first
1526 <<
"' to current long value '"
1527 << longIt->second.first
1528 <<
"' from dimension " << j
1529 <<
" parameter." << __E__;
1531 std::to_string(longIt->second.first);
1538 for(
unsigned int j = 0; j < dimensionIterations.size();
1541 auto doubleIt = doubleDimensionParameters[j].find(
1543 if(doubleIt == doubleDimensionParameters[j].end())
1547 __GEN_COUT__ <<
"Assigning argIn '" << argsIn[i].first
1548 <<
"' to current double value '"
1549 << doubleIt->second.first
1550 <<
"' from dimension " << j
1551 <<
" parameter." << __E__;
1553 std::to_string(doubleIt->second.first);
1558 __GEN_SS__ <<
"ArgIn '" << argsIn[i].first
1559 <<
"' was not assigned a value "
1560 <<
"by any dimensional loop parameter sets. "
1561 "This is illegal. FEMacro '"
1562 << feMacro.feMacroName_ <<
"' requires '"
1564 <<
"' as an input argument. Either remove the "
1565 "input argument from this FEMacro, "
1566 <<
"or define a value as a dimensional loop "
1573 (fe->*(feMacro.macroFunction_))(feMacro, argsIn, argsOut);
1575 __GEN_COUT__ <<
"FE Macro complete!" << __E__;
1579 std::stringstream outSS;
1581 outSS <<
"\n---------------\n" << __E__;
1582 outSS <<
"FEMacro '" << feMacro.feMacroName_
1583 <<
"' execution..." << __E__;
1585 <<
"iteration " << iterationCount << __E__;
1586 for(
unsigned int i = 0;
1587 i < dimensionIterationCnt.size();
1590 <<
"dimension[" << i
1591 <<
"] index := " << dimensionIterationCnt[i]
1596 <<
"Input arguments (count: " << argsIn.size()
1598 for(
auto& argIn : argsIn)
1599 outSS <<
"\t\t" << argIn.first <<
" = "
1600 << argIn.second << __E__;
1604 <<
"Output arguments (count: " << argsOut.size()
1606 for(
auto& argOut : argsOut)
1607 outSS <<
"\t\t" << argOut.first <<
" = "
1608 << argOut.second << __E__;
1612 __GEN_COUT__ <<
"\n" << outSS.str();
1613 if(outputFilePointer)
1614 fprintf(outputFilePointer, outSS.str().c_str());
1621 if(dimension >= dimensionIterationCnt.size())
1622 dimensionIterationCnt.push_back(0);
1625 __GEN_COUT__ <<
"\n"
1626 <<
"======================================" << __E__
1627 <<
"dimension[" << dimension
1628 <<
"] number of iterations := "
1629 << dimensionIterations[dimension] << __E__;
1634 for(
auto& longPair : longDimensionParameters[dimension])
1636 longPair.second.first =
1637 longPair.second.second.first;
1639 <<
"arg '" << longPair.first
1640 <<
"' current value: " << longPair.second.first
1644 for(
auto& doublePair : doubleDimensionParameters[dimension])
1646 doublePair.second.first =
1647 doublePair.second.second.first;
1649 <<
"arg '" << doublePair.first
1650 <<
"' current value: " << doublePair.second.first
1656 for(dimensionIterationCnt[dimension] =
1658 dimensionIterationCnt[dimension] <
1659 dimensionIterations[dimension];
1660 ++dimensionIterationCnt[dimension])
1662 __GEN_COUT__ <<
"dimension[" << dimension <<
"] index := "
1663 << dimensionIterationCnt[dimension] << __E__;
1665 localRecurse(dimension + 1);
1670 for(
auto& longPair : longDimensionParameters[dimension])
1672 longPair.second.first +=
1673 longPair.second.second.second;
1675 <<
"arg '" << longPair.first
1676 <<
"' current value: " << longPair.second.first
1680 for(
auto& doublePair :
1681 doubleDimensionParameters[dimension])
1683 doublePair.second.first +=
1684 doublePair.second.second.second;
1687 <<
"arg '" << doublePair.first
1688 <<
"' current value: " << doublePair.second.first
1694 __GEN_COUT__ <<
"Completed dimension[" << dimension
1695 <<
"] number of iterations := "
1696 << dimensionIterationCnt[dimension] <<
" of "
1697 << dimensionIterations[dimension] << __E__;
1704 if(outputFilePointer)
1705 fclose(outputFilePointer);
1707 catch(
const std::runtime_error& e)
1709 __SS__ <<
"Error executing multi-dimensional FE Macro: " << e.what()
1711 statusResult = ss.str();
1715 __SS__ <<
"Unknown error executing multi-dimensional FE Macro. " << __E__;
1716 statusResult = ss.str();
1719 __COUTV__(statusResult);
1722 std::lock_guard<std::mutex> lock(feMgr->macroMultiDimensionalDoneMutex_);
1724 feMgr->macroMultiDimensionalStatusMap_[interfaceID] = statusResult;
1737 __CFG_COUT__ <<
"Started multi-dimensional FE Macro '" << feMacroName
1738 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1749 bool FEVInterfacesManager::checkMacroMultiDimensional(
const std::string& interfaceID,
1750 const std::string& macroName)
1754 std::lock_guard<std::mutex> lock(macroMultiDimensionalDoneMutex_);
1756 auto statusIt = macroMultiDimensionalStatusMap_.find(interfaceID);
1757 if(statusIt == macroMultiDimensionalStatusMap_.end())
1759 __CFG_SS__ <<
"Status missing for multi-dimensional launch of Macro '"
1760 << macroName <<
"' for interface '" << interfaceID <<
".'" << __E__;
1763 else if(statusIt->second ==
"Done")
1765 __CFG_COUT__ <<
"Completed multi-dimensional launch of Macro '" << macroName
1766 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1769 macroMultiDimensionalStatusMap_.erase(statusIt);
1772 else if(statusIt->second ==
"Active")
1774 __CFG_COUT__ <<
"Still running multi-dimensional launch of Macro '" << macroName
1775 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1780 __CFG_SS__ <<
"Error occured during multi-dimensional launch of Macro '" << macroName
1781 <<
"' for interface '" << interfaceID <<
"':" << statusIt->second << __E__;
1798 void FEVInterfacesManager::runFEMacroByFE(
const std::string& callingInterfaceID,
1799 const std::string& interfaceID,
1800 const std::string& feMacroName,
1801 const std::string& inputArgs,
1802 std::string& outputArgs)
1804 __CFG_COUTV__(callingInterfaceID);
1810 auto FEMacroIt = fe->getMapOfFEMacroFunctions().find(feMacroName);
1811 if(FEMacroIt == fe->getMapOfFEMacroFunctions().end())
1813 __CFG_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '" << interfaceID
1814 <<
"' was not found!" << __E__;
1815 __CFG_COUT_ERR__ <<
"\n" << ss.str();
1819 auto& feMacro = FEMacroIt->second;
1821 std::set<std::string> allowedFEsSet;
1822 StringMacros::getSetFromString(feMacro.allowedCallingFrontEnds_, allowedFEsSet);
1825 if(!StringMacros::inWildCardSet(callingInterfaceID, allowedFEsSet))
1827 __CFG_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '" << interfaceID
1828 <<
"' does not allow access to calling interfaceID '"
1829 << callingInterfaceID
1830 <<
"!' Did the interface add the calling interfaceID "
1831 <<
"to the access list when registering the front-end macro." << __E__;
1832 __CFG_COUT_ERR__ <<
"\n" << ss.str();
1841 for(
unsigned int i = 0; i < feMacro.namesOfOutputArguments_.size(); ++i)
1842 outputArgs += (i ?
"," :
"") + feMacro.namesOfOutputArguments_[i];
1844 __CFG_COUTV__(outputArgs);
1846 runFEMacro(interfaceID, feMacro, inputArgs, outputArgs);
1848 __CFG_COUTV__(outputArgs);
1863 void FEVInterfacesManager::runMacro(
const std::string& interfaceID,
1864 const std::string& macroObjectString,
1865 const std::string& inputArgs,
1866 std::string& outputArgs)
1877 std::vector<FEVInterface::frontEndMacroArg_t> argsIn;
1879 std::istringstream inputStream(inputArgs);
1880 std::string splitVal, argName, argValue;
1881 while(getline(inputStream, splitVal,
';'))
1883 std::istringstream pairInputStream(splitVal);
1884 getline(pairInputStream, argName,
',');
1885 getline(pairInputStream, argValue,
',');
1886 argsIn.push_back(std::make_pair(argName, argValue));
1891 if(macro.namesOfInputArguments_.size() != argsIn.size())
1893 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1894 <<
"' was attempted on interfaceID '" << interfaceID
1895 <<
"' with a mismatch in"
1896 <<
" number of input arguments. " << argsIn.size() <<
" were given. "
1897 << macro.namesOfInputArguments_.size() <<
" expected." << __E__;
1900 for(
unsigned int i = 0; i < argsIn.size(); ++i)
1901 if(macro.namesOfInputArguments_.find(argsIn[i].first) ==
1902 macro.namesOfInputArguments_.end())
1904 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1905 <<
"' was attempted on interfaceID '" << interfaceID
1906 <<
"' with a mismatch in"
1907 <<
" a name of an input argument. " << argsIn[i].first
1908 <<
" was given. Expected: "
1909 << StringMacros::setToString(macro.namesOfInputArguments_)
1916 std::vector<std::string> returnStrings;
1917 std::vector<FEVInterface::frontEndMacroArg_t> argsOut;
1920 std::istringstream inputStream(outputArgs);
1921 std::string argName;
1922 while(getline(inputStream, argName,
','))
1924 __CFG_COUT__ <<
"argName " << argName << __E__;
1926 returnStrings.push_back(
"DEFAULT");
1927 argsOut.push_back(FEVInterface::frontEndMacroArg_t(
1928 argName, returnStrings[returnStrings.size() - 1]));
1937 if(macro.namesOfOutputArguments_.size() != argsOut.size())
1939 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1940 <<
"' was attempted on interfaceID '" << interfaceID
1941 <<
"' with a mismatch in"
1942 <<
" number of output arguments. " << argsOut.size() <<
" were given. "
1943 << macro.namesOfOutputArguments_.size() <<
" expected." << __E__;
1947 for(
unsigned int i = 0; i < argsOut.size(); ++i)
1948 if(macro.namesOfOutputArguments_.find(argsOut[i].first) ==
1949 macro.namesOfOutputArguments_.end())
1951 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1952 <<
"' was attempted on interfaceID '" << interfaceID
1953 <<
"' with a mismatch in"
1954 <<
" a name of an output argument. " << argsOut[i].first
1955 <<
" were given. Expected: "
1956 << StringMacros::setToString(macro.namesOfOutputArguments_)
1962 __CFG_COUT__ <<
"# of input args = " << argsIn.size() << __E__;
1964 std::map<std::string , uint64_t > variableMap;
1966 for(
const auto& outputArgName : macro.namesOfOutputArguments_)
1967 variableMap.emplace(
1968 std::pair<std::string /*name*/, uint64_t /*value*/>(outputArgName, 0));
1969 for(
const auto& inputArgName : macro.namesOfInputArguments_)
1970 variableMap.emplace(
1971 std::pair<std::string /*name*/, uint64_t /*value*/>(inputArgName, 0));
1973 for(
auto& argIn : argsIn)
1975 __CFG_COUT__ << argIn.first <<
": " << argIn.second << __E__;
1976 StringMacros::getNumber(argIn.second, variableMap.at(argIn.first));
1979 fe->runMacro(macro, variableMap);
1981 __CFG_COUT__ <<
"MacroMaker Macro complete!" << __E__;
1983 __CFG_COUT__ <<
"# of output args = " << argsOut.size() << __E__;
1984 for(
auto& arg : argsOut)
1986 std::stringstream numberSs;
1987 numberSs << std::dec << variableMap.at(arg.first) <<
" (0x" << std::hex
1988 << variableMap.at(arg.first) <<
")" << std::dec;
1989 arg.second = numberSs.str();
1990 __CFG_COUT__ << arg.first <<
": " << arg.second << __E__;
1995 for(
unsigned int i = 0; i < argsOut.size(); ++i)
1999 outputArgs += argsOut[i].first +
"," + argsOut[i].second;
2002 __CFG_COUT__ <<
"outputArgs = " << outputArgs << __E__;
2017 void FEVInterfacesManager::runFEMacro(
const std::string& interfaceID,
2018 const std::string& feMacroName,
2019 const std::string& inputArgs,
2020 std::string& outputArgs)
2026 auto FEMacroIt = fe->getMapOfFEMacroFunctions().find(feMacroName);
2027 if(FEMacroIt == fe->getMapOfFEMacroFunctions().end())
2029 __CFG_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '" << interfaceID
2030 <<
"' was not found!" << __E__;
2031 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2035 runFEMacro(interfaceID, FEMacroIt->second, inputArgs, outputArgs);
2050 void FEVInterfacesManager::runFEMacro(
const std::string& interfaceID,
2052 const std::string& inputArgs,
2053 std::string& outputArgs)
2057 std::vector<FEVInterface::frontEndMacroArg_t> argsIn;
2059 std::istringstream inputStream(inputArgs);
2060 std::string splitVal, argName, argValue;
2061 while(getline(inputStream, splitVal,
';'))
2063 std::istringstream pairInputStream(splitVal);
2064 getline(pairInputStream, argName,
',');
2065 getline(pairInputStream, argValue,
',');
2066 argsIn.push_back(std::make_pair(argName, argValue));
2071 if(feMacro.namesOfInputArguments_.size() != argsIn.size())
2073 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2074 << interfaceID <<
"' was attempted with a mismatch in"
2075 <<
" number of input arguments. " << argsIn.size() <<
" were given. "
2076 << feMacro.namesOfInputArguments_.size() <<
" expected." << __E__;
2077 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2080 for(
unsigned int i = 0; i < argsIn.size(); ++i)
2081 if(argsIn[i].first != feMacro.namesOfInputArguments_[i])
2083 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2084 << interfaceID <<
"' was attempted with a mismatch in"
2085 <<
" a name of an input argument. " << argsIn[i].first
2086 <<
" was given. " << feMacro.namesOfInputArguments_[i]
2087 <<
" expected." << __E__;
2088 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2093 std::vector<std::string> returnStrings;
2094 std::vector<FEVInterface::frontEndMacroArg_t> argsOut;
2097 std::istringstream inputStream(outputArgs);
2098 std::string argName;
2099 while(getline(inputStream, argName,
','))
2101 __CFG_COUT__ <<
"argName " << argName << __E__;
2103 returnStrings.push_back(
"DEFAULT");
2104 argsOut.push_back(FEVInterface::frontEndMacroArg_t(
2105 argName, returnStrings[returnStrings.size() - 1]));
2108 __CFG_COUT__ << (uint64_t) & (returnStrings[returnStrings.size() - 1])
2114 if(feMacro.namesOfOutputArguments_.size() != argsOut.size())
2116 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2117 << interfaceID <<
"' was attempted with a mismatch in"
2118 <<
" number of output arguments. " << argsOut.size() <<
" were given. "
2119 << feMacro.namesOfOutputArguments_.size() <<
" expected." << __E__;
2120 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2123 for(
unsigned int i = 0; i < argsOut.size(); ++i)
2124 if(argsOut[i].first != feMacro.namesOfOutputArguments_[i])
2126 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2127 << interfaceID <<
"' was attempted with a mismatch in"
2128 <<
" a name of an output argument. " << argsOut[i].first
2129 <<
" were given. " << feMacro.namesOfOutputArguments_[i]
2130 <<
" expected." << __E__;
2131 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2135 __CFG_COUT__ <<
"# of input args = " << argsIn.size() << __E__;
2136 for(
auto& argIn : argsIn)
2137 __CFG_COUT__ << argIn.first <<
": " << argIn.second << __E__;
2145 __MOUT__ <<
"Launching FE Macro '" << feMacro.feMacroName_ <<
"' ..." << __E__;
2146 __CFG_COUT__ <<
"Launching FE Macro '" << feMacro.feMacroName_ <<
"' ..." << __E__;
2149 (getFEInterfaceP(interfaceID)->*(feMacro.macroFunction_))(feMacro, argsIn, argsOut);
2151 __CFG_COUT__ <<
"FE Macro complete!" << __E__;
2153 __CFG_COUT__ <<
"# of output args = " << argsOut.size() << __E__;
2154 for(
const auto& arg : argsOut)
2155 __CFG_COUT__ << arg.first <<
": " << arg.second << __E__;
2158 if(feMacro.namesOfOutputArguments_.size() != argsOut.size())
2160 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2162 <<
"' was attempted but the FE macro "
2163 "manipulated the output arguments vector. It is illegal "
2164 "to add or remove output vector name/value pairs."
2166 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2172 for(
unsigned int i = 0; i < argsOut.size(); ++i)
2182 if(StringMacros::getNumber(argsOut[i].second, tmpNumber))
2184 std::stringstream outNumberSs;
2185 outNumberSs << std::dec << tmpNumber <<
" (0x" << std::hex << tmpNumber
2187 outputArgs += argsOut[i].first +
"," + outNumberSs.str();
2195 outputArgs += argsOut[i].first +
"," + argsOut[i].second;
2198 __CFG_COUT__ <<
"outputArgs = " << outputArgs << __E__;
2210 std::string FEVInterfacesManager::getFEMacrosString(
const std::string& supervisorName,
2211 const std::string& supervisorLid)
2213 std::string retList =
"";
2215 for(
const auto& it : theFEInterfaces_)
2217 __CFG_COUT__ <<
"FE interface UID = " << it.first << __E__;
2219 retList += supervisorName +
":" + supervisorLid +
":" +
2220 it.second->getInterfaceType() +
":" + it.second->getInterfaceUID();
2222 for(
const auto& macroPair : it.second->getMapOfFEMacroFunctions())
2224 __CFG_COUT__ <<
"FE Macro name = " << macroPair.first << __E__;
2225 retList +=
":" + macroPair.first +
":" +
2226 std::to_string(macroPair.second.requiredUserPermissions_) +
":" +
2227 std::to_string(macroPair.second.namesOfInputArguments_.size());
2228 for(
const auto& name : macroPair.second.namesOfInputArguments_)
2229 retList +=
":" + name;
2232 ":" + std::to_string(macroPair.second.namesOfOutputArguments_.size());
2233 for(
const auto& name : macroPair.second.namesOfOutputArguments_)
2234 retList +=
":" + name;
2243 bool FEVInterfacesManager::allFEWorkloopsAreDone(
void)
2245 bool allFEWorkloopsAreDone =
true;
2248 for(
const auto& FEInterface : theFEInterfaces_)
2250 isActive = FEInterface.second->WorkLoop::isActive();
2252 __CFG_COUT__ << FEInterface.second->getInterfaceUID() <<
" of type "
2253 << FEInterface.second->getInterfaceType() <<
": \t"
2254 <<
"workLoop_->isActive() " << (isActive ?
"yes" :
"no") << __E__;
2258 allFEWorkloopsAreDone =
false;
2263 return allFEWorkloopsAreDone;
2267 void FEVInterfacesManager::preStateMachineExecutionLoop(
void)
2269 VStateMachine::clearIterationWork();
2270 VStateMachine::clearSubIterationWork();
2272 stateMachinesIterationWorkCount_ = 0;
2274 __CFG_COUT__ <<
"Number of front ends to transition: " << theFENamesByPriority_.size()
2277 if(VStateMachine::getIterationIndex() == 0 &&
2278 VStateMachine::getSubIterationIndex() == 0)
2282 subIterationWorkStateMachineIndex_ = -1;
2284 stateMachinesIterationDone_.clear();
2285 for(
const auto& FEPair : theFEInterfaces_)
2286 stateMachinesIterationDone_[FEPair.first] =
false;
2289 __CFG_COUT__ <<
"Iteration " << VStateMachine::getIterationIndex() <<
"."
2290 << VStateMachine::getSubIterationIndex() <<
"("
2291 << subIterationWorkStateMachineIndex_ <<
")" << __E__;
2295 void FEVInterfacesManager::preStateMachineExecution(
unsigned int i)
2297 if(i >= theFENamesByPriority_.size())
2299 __CFG_SS__ <<
"FE Interface " << i <<
" not found!" << __E__;
2303 const std::string& name = theFENamesByPriority_[i];
2307 fe->VStateMachine::setIterationIndex(VStateMachine::getIterationIndex());
2308 fe->VStateMachine::setSubIterationIndex(VStateMachine::getSubIterationIndex());
2310 fe->VStateMachine::clearIterationWork();
2311 fe->VStateMachine::clearSubIterationWork();
2313 __CFG_COUT__ <<
"theStateMachineImplementation Iteration "
2314 << fe->VStateMachine::getIterationIndex() <<
"."
2315 << fe->VStateMachine::getSubIterationIndex() << __E__;
2321 bool FEVInterfacesManager::postStateMachineExecution(
unsigned int i)
2323 if(i >= theFENamesByPriority_.size())
2325 __CFG_SS__ <<
"FE Interface index " << i <<
" not found!" << __E__;
2329 const std::string& name = theFENamesByPriority_[i];
2334 if(fe->VStateMachine::getSubIterationWork())
2336 subIterationWorkStateMachineIndex_ = i;
2337 VStateMachine::indicateSubIterationWork();
2339 __CFG_COUT__ <<
"FE Interface '" << name
2340 <<
"' is flagged for another sub-iteration..." << __E__;
2345 subIterationWorkStateMachineIndex_ = -1;
2347 bool& stateMachineDone = stateMachinesIterationDone_[name];
2348 stateMachineDone = !fe->VStateMachine::getIterationWork();
2350 if(!stateMachineDone)
2352 __CFG_COUT__ <<
"FE Interface '" << name
2353 <<
"' is flagged for another iteration..." << __E__;
2354 VStateMachine::indicateIterationWork();
2356 ++stateMachinesIterationWorkCount_;
2364 void FEVInterfacesManager::postStateMachineExecutionLoop(
void)
2366 if(VStateMachine::getSubIterationWork())
2367 __CFG_COUT__ <<
"FE Interface state machine implementation "
2368 << subIterationWorkStateMachineIndex_
2369 <<
" is flagged for another sub-iteration..." << __E__;
2370 else if(VStateMachine::getIterationWork())
2371 __CFG_COUT__ << stateMachinesIterationWorkCount_
2372 <<
" FE Interface state machine implementation(s) flagged for "
2373 "another iteration..."
2376 __CFG_COUT__ <<
"Done transitioning all state machine implementations..."
void startMacroMultiDimensional(const std::string &requester, const std::string &interfaceID, const std::string ¯oName, const std::string ¯oString, const bool enableSavingOutput, const std::string &outputFilePath, const std::string &outputFileRadix, const std::string &inputArgs)