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());
65 auto fes = appNode.getNode(
"LinkToSupervisorTable")
66 .getNode(
"LinkToFEInterfaceTable")
67 .getChildrenNames(
true ,
true );
68 __CFG_COUTV__(StringMacros::vectorToString(fes));
72 Configurable::getSelfNode().getNode(COL_NAME_feGroupLink);
74 std::vector<std::pair<std::string, ConfigurationTree>> feChildren =
75 feGroupLinkNode.getChildren();
78 theFENamesByPriority_ =
79 feGroupLinkNode.getChildrenNames(
true ,
true );
80 __CFG_COUTV__(StringMacros::vectorToString(theFENamesByPriority_));
82 for(
const auto& interface : feChildren)
86 if(!interface.second.getNode(TableViewColumnInfo::COL_NAME_STATUS)
92 __CFG_COUT_INFO__ <<
"Ignoring FE Status since Status column is missing!"
97 <<
"Interface Plugin Name: "
98 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
100 __CFG_COUT__ <<
"Interface Name: " << interface.first << __E__;
101 __CFG_COUT__ <<
"XDAQContext Node: " << theXDAQContextConfigTree_ << __E__;
102 __CFG_COUT__ <<
"Path to configuration: "
103 << (theConfigurationPath_ +
"/" + COL_NAME_feGroupLink +
"/" +
104 interface.first +
"/" + COL_NAME_feTypeLink)
109 theFEInterfaces_[interface.first] = makeInterface(
110 interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>(),
112 theXDAQContextConfigTree_,
113 (theConfigurationPath_ +
"/" + COL_NAME_feGroupLink +
"/" +
114 interface.first +
"/" + COL_NAME_feTypeLink));
118 theFEInterfaces_[interface.first]->VStateMachine::parentSupervisor_ =
119 VStateMachine::parentSupervisor_;
120 theFEInterfaces_[interface.first]->parentInterfaceManager_ =
this;
122 catch(
const cet::exception& e)
125 <<
"Failed to instantiate plugin named '" << interface.first
127 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
128 <<
"' due to the following error: \n"
129 << e.what() << __E__;
130 __MOUT_ERR__ << ss.str();
133 catch(
const std::runtime_error& e)
136 <<
"Failed to instantiate plugin named '" << interface.first
138 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
139 <<
"' due to the following error: \n"
140 << e.what() << __E__;
141 __MOUT_ERR__ << ss.str();
147 <<
"Failed to instantiate plugin named '" << interface.first
149 << interface.second.getNode(COL_NAME_fePlugin).getValue<std::string>()
150 <<
"' due to an unknown error." << __E__;
151 __MOUT_ERR__ << ss.str();
156 __CFG_COUT__ <<
"Done creating interfaces" << __E__;
160 void FEVInterfacesManager::configure(
void)
162 const std::string transitionName =
"Configuring";
164 __CFG_COUT__ << transitionName <<
" FEVInterfacesManager " << __E__;
167 if(VStateMachine::getIterationIndex() == 0 &&
168 VStateMachine::getSubIterationIndex() == 0)
173 preStateMachineExecutionLoop();
174 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
177 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
178 i != subIterationWorkStateMachineIndex_)
181 const std::string& name = theFENamesByPriority_[i];
184 fe = getFEInterfaceP(name);
186 if(stateMachinesIterationDone_[name])
189 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
190 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
191 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
193 preStateMachineExecution(i);
195 postStateMachineExecution(i);
199 fe->configureSlowControls();
200 fe->startSlowControlsWorkLooop();
202 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
203 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
204 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
206 postStateMachineExecutionLoop();
208 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
212 void FEVInterfacesManager::halt(
void)
214 const std::string transitionName =
"Halting";
217 preStateMachineExecutionLoop();
218 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
221 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
222 i != subIterationWorkStateMachineIndex_)
225 const std::string& name = theFENamesByPriority_[i];
227 fe = getFEInterfaceP(name);
229 if(stateMachinesIterationDone_[name])
232 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
233 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
234 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
236 preStateMachineExecution(i);
246 <<
"An error occurred while halting the front-end workloop for '" << name
247 <<
",' ignoring." << __E__;
253 fe->stopSlowControlsWorkLooop();
257 __CFG_COUT_WARN__ <<
"An error occurred while halting the Slow Controls "
258 "front-end workloop for '"
259 << name <<
",' ignoring." << __E__;
269 __CFG_COUT_WARN__ <<
"An error occurred while halting the front-end '" << name
270 <<
",' ignoring." << __E__;
273 postStateMachineExecution(i);
275 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
276 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
277 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
279 postStateMachineExecutionLoop();
284 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
288 void FEVInterfacesManager::pause(
void)
290 const std::string transitionName =
"Pausing";
293 preStateMachineExecutionLoop();
294 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
297 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
298 i != subIterationWorkStateMachineIndex_)
301 const std::string& name = theFENamesByPriority_[i];
303 fe = getFEInterfaceP(name);
305 if(stateMachinesIterationDone_[name])
308 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
309 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
310 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
312 preStateMachineExecution(i);
315 postStateMachineExecution(i);
317 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
318 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
319 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
321 postStateMachineExecutionLoop();
323 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
327 void FEVInterfacesManager::resume(
void)
329 const std::string transitionName =
"Resuming";
332 preStateMachineExecutionLoop();
333 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
336 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
337 i != subIterationWorkStateMachineIndex_)
340 const std::string& name = theFENamesByPriority_[i];
344 if(stateMachinesIterationDone_[name])
347 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
348 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
349 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
351 preStateMachineExecution(i);
354 if(postStateMachineExecution(i))
357 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
358 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
359 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
361 postStateMachineExecutionLoop();
363 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
368 void FEVInterfacesManager::start(std::string runNumber)
370 const std::string transitionName =
"Starting";
373 preStateMachineExecutionLoop();
374 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
377 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
378 i != subIterationWorkStateMachineIndex_)
381 const std::string& name = theFENamesByPriority_[i];
383 fe = getFEInterfaceP(name);
385 if(stateMachinesIterationDone_[name])
388 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
389 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
390 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
392 preStateMachineExecution(i);
393 fe->start(runNumber);
395 if(postStateMachineExecution(i))
398 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
399 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
400 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
402 postStateMachineExecutionLoop();
404 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
409 void FEVInterfacesManager::stop(
void)
411 const std::string transitionName =
"Starting";
414 preStateMachineExecutionLoop();
415 for(
unsigned int i = 0; i < theFENamesByPriority_.size(); ++i)
418 if(subIterationWorkStateMachineIndex_ != (
unsigned int)-1 &&
419 i != subIterationWorkStateMachineIndex_)
422 const std::string& name = theFENamesByPriority_[i];
424 fe = getFEInterfaceP(name);
426 if(stateMachinesIterationDone_[name])
429 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
430 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
431 __CFG_COUT__ << transitionName <<
" interface " << name << __E__;
433 preStateMachineExecution(i);
436 postStateMachineExecution(i);
438 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
439 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
440 __CFG_COUT__ <<
"Done " << transitionName <<
" interface " << name << __E__;
442 postStateMachineExecutionLoop();
444 __CFG_COUT__ <<
"Done " << transitionName <<
" all interfaces." << __E__;
450 FEVInterface* FEVInterfacesManager::getFEInterfaceP(
const std::string& interfaceID)
454 return theFEInterfaces_.at(interfaceID).get();
458 __CFG_SS__ <<
"Interface ID '" << interfaceID
459 <<
"' not found in configured interfaces." << __E__;
466 const FEVInterface& FEVInterfacesManager::getFEInterface(
467 const std::string& interfaceID)
const
471 return *(theFEInterfaces_.at(interfaceID));
475 __CFG_SS__ <<
"Interface ID '" << interfaceID
476 <<
"' not found in configured interfaces." << __E__;
485 void FEVInterfacesManager::universalRead(
const std::string& interfaceID,
489 getFEInterfaceP(interfaceID)->universalRead(address, returnValue);
495 unsigned int FEVInterfacesManager::getInterfaceUniversalAddressSize(
496 const std::string& interfaceID)
498 return getFEInterfaceP(interfaceID)->getUniversalAddressSize();
504 unsigned int FEVInterfacesManager::getInterfaceUniversalDataSize(
505 const std::string& interfaceID)
507 return getFEInterfaceP(interfaceID)->getUniversalDataSize();
513 void FEVInterfacesManager::universalWrite(
const std::string& interfaceID,
517 getFEInterfaceP(interfaceID)->universalWrite(address, writeValue);
525 std::string FEVInterfacesManager::getFEListString(
const std::string& supervisorLid)
527 std::string retList =
"";
529 for(
const auto& it : theFEInterfaces_)
531 __CFG_COUT__ <<
"FE name = " << it.first << __E__;
533 retList += it.second->getInterfaceType() +
":" + supervisorLid +
":" +
534 it.second->getInterfaceUID() +
"\n";
557 const std::string& interfaceID,
558 const std::string& macroName,
559 const std::string& macroString,
560 const bool enableSavingOutput,
561 const std::string& outputFilePath,
562 const std::string& outputFileRadix,
563 const std::string& inputArgs)
565 if(requester !=
"iterator")
567 __CFG_SS__ <<
"Invalid requester '" << requester <<
"'" << __E__;
571 __CFG_COUT__ <<
"Starting multi-dimensional Macro '" << macroName
572 <<
"' for interface '" << interfaceID <<
".'" << __E__;
574 __CFG_COUTV__(macroString);
576 __CFG_COUTV__(inputArgs);
580 std::lock_guard<std::mutex> lock(macroMultiDimensionalDoneMutex_);
582 if(macroMultiDimensionalStatusMap_.find(interfaceID) !=
583 macroMultiDimensionalStatusMap_.end())
585 __SS__ <<
"Failed to start multi-dimensional Macro '" << macroName
586 <<
"' for interface '" << interfaceID
587 <<
"' - this interface already has an active Macro launch!" << __E__;
590 macroMultiDimensionalStatusMap_.emplace(std::make_pair(interfaceID,
"Active"));
596 const std::string interfaceID,
597 const std::string macroName,
598 const std::string macroString,
599 const bool enableSavingOutput,
600 const std::string outputFilePath,
601 const std::string outputFileRadix,
602 const std::string inputArgsStr) {
605 std::string mfSubject_ =
"threadMultiD-" + macroName;
606 __GEN_COUT__ <<
"Thread started." << __E__;
608 std::string statusResult =
"Done";
622 FILE* outputFilePointer = 0;
623 if(enableSavingOutput)
625 std::string filename = outputFilePath +
"/" + outputFileRadix +
626 macroName +
"_" + std::to_string(time(0)) +
628 __GEN_COUT__ <<
"Opening file... " << filename << __E__;
630 outputFilePointer = fopen(filename.c_str(),
"w");
631 if(!outputFilePointer)
633 __GEN_SS__ <<
"Failed to open output file: " << filename << __E__;
640 __GEN_COUTV__(inputArgsStr);
660 std::vector<
unsigned long > dimensionIterations,
661 dimensionIterationCnt;
663 using longParamMap_t = std::map<
666 std::pair<
long ,
long >>>;
668 std::vector<longParamMap_t> longDimensionParameters;
673 std::map<std::string , uint64_t > variableMap;
678 for(
const auto& inputArgName : macro.namesOfInputArguments_)
680 std::pair<std::string /*name*/, uint64_t /*value*/>(inputArgName,
682 for(
const auto& outputArgName : macro.namesOfOutputArguments_)
684 std::pair<std::string /*name*/, uint64_t /*value*/>(outputArgName,
691 dimensionIterations.push_back(2);
692 dimensionIterations.push_back(4);
694 longDimensionParameters.push_back(longParamMap_t());
695 longDimensionParameters.push_back(longParamMap_t());
697 longDimensionParameters.back().emplace(std::make_pair(
701 std::make_pair(3 , 4 ))));
704 std::vector<std::string> dimensionArgs;
705 StringMacros::getVectorFromString(
706 inputArgsStr, dimensionArgs, {
';'} );
708 __GEN_COUTV__(dimensionArgs.size());
711 if(dimensionArgs.size() == 0)
716 dimensionIterations.push_back(1);
717 longDimensionParameters.push_back(longParamMap_t());
720 for(
unsigned int d = 0; d < dimensionArgs.size(); ++d)
725 std::vector<std::string> args;
726 StringMacros::getVectorFromString(
727 dimensionArgs[d], args, {
','} );
735 __GEN_SS__ <<
"Invalid dimensional arguments! "
736 <<
"Need number of iterations at dimension " << d
741 unsigned long numOfIterations;
742 StringMacros::getNumber(args[0], numOfIterations);
743 __GEN_COUT__ <<
"Dimension " << d
744 <<
" numOfIterations=" << numOfIterations << __E__;
748 dimensionIterations.push_back(numOfIterations);
749 longDimensionParameters.push_back(longParamMap_t());
753 for(
unsigned int a = 1; a < args.size(); ++a)
755 std::vector<std::string> argPieces;
756 StringMacros::getVectorFromString(
757 args[a], argPieces, {
':'} );
759 __GEN_COUTV__(StringMacros::vectorToString(argPieces));
763 if(argPieces.size() != 3)
765 __GEN_SS__ <<
"Invalid argument pieces! Should be size "
767 << argPieces.size() << __E__;
768 ss << StringMacros::vectorToString(argPieces);
774 if((argPieces[1].size() &&
775 (argPieces[1][argPieces[1].size() - 1] ==
'f' ||
776 argPieces[1].find(
'.') != std::string::npos)) ||
777 (argPieces[2].size() &&
778 (argPieces[2][argPieces[2].size() - 1] ==
'f' ||
779 argPieces[2].find(
'.') != std::string::npos)))
783 double startValue = strtod(argPieces[1].c_str(), 0);
784 double stepSize = strtod(argPieces[2].c_str(), 0);
786 __GEN_COUTV__(startValue);
787 __GEN_COUTV__(stepSize);
790 <<
"Error! Only integer aruments allowed for Macros. "
791 <<
"Double style arugment found: " << argPieces[0]
792 <<
"' := " << startValue <<
", " << stepSize << __E__;
813 StringMacros::getNumber(argPieces[1], startValue);
814 StringMacros::getNumber(argPieces[2], stepSize);
816 __GEN_COUTV__(startValue);
817 __GEN_COUTV__(stepSize);
819 __GEN_COUT__ <<
"Creating long argument '" << argPieces[0]
820 <<
"' := " << startValue <<
", " << stepSize
823 longDimensionParameters.back().emplace(std::make_pair(
827 std::make_pair(startValue ,
835 if(dimensionIterations.size() != longDimensionParameters.size())
837 __GEN_SS__ <<
"Impossible vector size mismatch! "
838 << dimensionIterations.size() <<
" - "
839 << longDimensionParameters.size() << __E__;
845 std::stringstream outSS;
847 outSS <<
"\n==========================\n" << __E__;
848 outSS <<
"Macro '" << macro.macroName_
849 <<
"' multi-dimensional scan..." << __E__;
850 outSS <<
"\t" << StringMacros::getTimestampString() << __E__;
851 outSS <<
"\t" << dimensionIterations.size()
852 <<
" dimensions defined." << __E__;
853 for(
unsigned int i = 0; i < dimensionIterations.size(); ++i)
856 <<
"dimension[" << i <<
"] has "
857 << dimensionIterations[i] <<
" iterations and "
858 << (longDimensionParameters[i].size()) <<
" arguments."
861 for(
auto& param : longDimensionParameters[i])
863 <<
"'" << param.first <<
"' of type long with "
864 <<
"initial value and step value [decimal] = "
865 <<
"\t" << param.second.second.first <<
" & "
866 << param.second.second.second << __E__;
869 outSS <<
"\nInput argument names:" << __E__;
870 for(
const auto& inputArgName : macro.namesOfInputArguments_)
871 outSS <<
"\t" << inputArgName << __E__;
872 outSS <<
"\nOutput argument names:" << __E__;
873 for(
const auto& outputArgName : macro.namesOfOutputArguments_)
874 outSS <<
"\t" << outputArgName << __E__;
876 outSS <<
"\n==========================\n" << __E__;
880 __GEN_COUT__ <<
"\n" << outSS.str();
881 if(outputFilePointer)
882 fprintf(outputFilePointer, outSS.str().c_str());
885 unsigned int iterationCount = 0;
893 std::function<void(
const unsigned int
895 localRecurse = [&dimensionIterations,
896 &dimensionIterationCnt,
898 &longDimensionParameters,
903 &localRecurse](
const unsigned int dimension) {
906 std::string mfSubject_ =
"multiD-" + std::to_string(dimension) +
907 "-" + macro.macroName_;
908 __GEN_COUTV__(dimension);
910 if(dimension >= dimensionIterations.size())
912 __GEN_COUT__ <<
"Iteration count: " << iterationCount++
914 __GEN_COUT__ <<
"Launching Macro '" << macro.macroName_
925 for(
unsigned int j = 0; j < dimensionIterations.size();
928 for(
auto& longParam : longDimensionParameters[j])
931 <<
"Assigning argIn '" << longParam.first
932 <<
"' to current long value '"
933 << longParam.second.first
934 <<
"' from dimension " << j <<
" parameter."
936 variableMap.at(longParam.first) =
937 longParam.second.first;
945 std::stringstream outSS;
947 outSS <<
"\n---------------\n" << __E__;
948 outSS <<
"Macro '" << macro.macroName_
949 <<
"' execution..." << __E__;
951 <<
"iteration " << iterationCount << __E__;
952 for(
unsigned int i = 0;
953 i < dimensionIterationCnt.size();
957 <<
"] index := " << dimensionIterationCnt[i]
962 <<
"Input arguments (count: "
963 << macro.namesOfInputArguments_.size()
965 for(
auto& argIn : macro.namesOfInputArguments_)
966 outSS <<
"\t\t" << argIn <<
" = "
967 << variableMap.at(argIn) << __E__;
972 __GEN_COUT__ <<
"\n" << outSS.str();
973 if(outputFilePointer)
974 fprintf(outputFilePointer, outSS.str().c_str());
978 fe->runMacro(macro, variableMap);
980 __GEN_COUT__ <<
"Macro complete!" << __E__;
984 std::stringstream outSS;
988 <<
"Output arguments (count: "
989 << macro.namesOfOutputArguments_.size()
991 for(
auto& argOut : macro.namesOfOutputArguments_)
992 outSS <<
"\t\t" << argOut <<
" = "
993 << variableMap.at(argOut) << __E__;
997 __GEN_COUT__ <<
"\n" << outSS.str();
998 if(outputFilePointer)
999 fprintf(outputFilePointer, outSS.str().c_str());
1006 if(dimension >= dimensionIterationCnt.size())
1007 dimensionIterationCnt.push_back(0);
1010 __GEN_COUT__ <<
"\n"
1011 <<
"======================================" << __E__
1012 <<
"dimension[" << dimension
1013 <<
"] number of iterations := "
1014 << dimensionIterations[dimension] << __E__;
1019 for(
auto& longPair : longDimensionParameters[dimension])
1021 longPair.second.first =
1022 longPair.second.second.first;
1024 <<
"arg '" << longPair.first
1025 <<
"' current value: " << longPair.second.first
1032 for(dimensionIterationCnt[dimension] =
1034 dimensionIterationCnt[dimension] <
1035 dimensionIterations[dimension];
1036 ++dimensionIterationCnt[dimension])
1038 __GEN_COUT__ <<
"dimension[" << dimension <<
"] index := "
1039 << dimensionIterationCnt[dimension] << __E__;
1041 localRecurse(dimension + 1);
1046 for(
auto& longPair : longDimensionParameters[dimension])
1048 longPair.second.first +=
1049 longPair.second.second.second;
1051 <<
"arg '" << longPair.first
1052 <<
"' current value: " << longPair.second.first
1059 __GEN_COUT__ <<
"Completed dimension[" << dimension
1060 <<
"] number of iterations := "
1061 << dimensionIterationCnt[dimension] <<
" of "
1062 << dimensionIterations[dimension] << __E__;
1069 if(outputFilePointer)
1070 fclose(outputFilePointer);
1072 catch(
const std::runtime_error& e)
1074 __SS__ <<
"Error executing multi-dimensional Macro: " << e.what()
1076 statusResult = ss.str();
1080 __SS__ <<
"Unknown error executing multi-dimensional Macro. " << __E__;
1081 statusResult = ss.str();
1084 __COUTV__(statusResult);
1087 std::lock_guard<std::mutex> lock(feMgr->macroMultiDimensionalDoneMutex_);
1089 feMgr->macroMultiDimensionalStatusMap_[interfaceID] = statusResult;
1103 __CFG_COUT__ <<
"Started multi-dimensional Macro '" << macroName
1104 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1125 void FEVInterfacesManager::startFEMacroMultiDimensional(
1126 const std::string& requester,
1127 const std::string& interfaceID,
1128 const std::string& feMacroName,
1129 const bool enableSavingOutput,
1130 const std::string& outputFilePath,
1131 const std::string& outputFileRadix,
1132 const std::string& inputArgs)
1134 if(requester !=
"iterator")
1136 __CFG_SS__ <<
"Invalid requester '" << requester <<
"'" << __E__;
1140 __CFG_COUT__ <<
"Starting multi-dimensional FE Macro '" << feMacroName
1141 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1142 __CFG_COUTV__(inputArgs);
1146 std::lock_guard<std::mutex> lock(macroMultiDimensionalDoneMutex_);
1148 if(macroMultiDimensionalStatusMap_.find(interfaceID) !=
1149 macroMultiDimensionalStatusMap_.end())
1151 __SS__ <<
"Failed to start multi-dimensional FE Macro '" << feMacroName
1152 <<
"' for interface '" << interfaceID
1153 <<
"' - this interface already has an active FE Macro launch!"
1157 macroMultiDimensionalStatusMap_.emplace(std::make_pair(interfaceID,
"Active"));
1163 const std::string interfaceID,
1164 const std::string feMacroName,
1165 const bool enableSavingOutput,
1166 const std::string outputFilePath,
1167 const std::string outputFileRadix,
1168 const std::string inputArgsStr) {
1171 std::string mfSubject_ =
"threadMultiD-" + feMacroName;
1172 __GEN_COUT__ <<
"Thread started." << __E__;
1174 std::string statusResult =
"Done";
1180 FEVInterface* fe = feMgr->getFEInterfaceP(interfaceID);
1183 auto FEMacroIt = fe->getMapOfFEMacroFunctions().find(feMacroName);
1184 if(FEMacroIt == fe->getMapOfFEMacroFunctions().end())
1186 __GEN_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '"
1187 << interfaceID <<
"' was not found!" << __E__;
1194 FILE* outputFilePointer = 0;
1195 if(enableSavingOutput)
1197 std::string filename = outputFilePath +
"/" + outputFileRadix +
1198 feMacroName +
"_" + std::to_string(time(0)) +
1200 __GEN_COUT__ <<
"Opening file... " << filename << __E__;
1202 outputFilePointer = fopen(filename.c_str(),
"w");
1203 if(!outputFilePointer)
1205 __GEN_SS__ <<
"Failed to open output file: " << filename << __E__;
1212 __GEN_COUTV__(inputArgsStr);
1232 std::vector<
unsigned long > dimensionIterations,
1233 dimensionIterationCnt;
1235 using longParamMap_t = std::map<
1238 std::pair<
long ,
long >>>;
1239 using doubleParamMap_t =
1240 std::map<std::string ,
1245 std::vector<longParamMap_t> longDimensionParameters;
1246 std::vector<doubleParamMap_t> doubleDimensionParameters;
1248 std::vector<FEVInterface::frontEndMacroArg_t> argsIn;
1249 std::vector<FEVInterface::frontEndMacroArg_t> argsOut;
1251 for(
unsigned int i = 0; i < feMacro.namesOfInputArguments_.size(); ++i)
1252 argsIn.push_back(std::make_pair(
1253 feMacro.namesOfInputArguments_[i],
1255 for(
unsigned int i = 0; i < feMacro.namesOfOutputArguments_.size(); ++i)
1258 feMacro.namesOfOutputArguments_[i],
1265 argsIn.push_back(std::make_pair(
"myOtherArg",
"3"));
1267 dimensionIterations.push_back(2);
1268 dimensionIterations.push_back(4);
1270 longDimensionParameters.push_back(longParamMap_t());
1271 longDimensionParameters.push_back(longParamMap_t());
1273 doubleDimensionParameters.push_back(doubleParamMap_t());
1274 doubleDimensionParameters.push_back(doubleParamMap_t());
1276 longDimensionParameters.back().emplace(std::make_pair(
1280 std::make_pair(3 , 4 ))));
1283 std::vector<std::string> dimensionArgs;
1284 StringMacros::getVectorFromString(
1285 inputArgsStr, dimensionArgs, {
';'} );
1287 __GEN_COUTV__(dimensionArgs.size());
1290 if(dimensionArgs.size() == 0)
1295 dimensionIterations.push_back(1);
1296 longDimensionParameters.push_back(longParamMap_t());
1297 doubleDimensionParameters.push_back(doubleParamMap_t());
1300 for(
unsigned int d = 0; d < dimensionArgs.size(); ++d)
1305 std::vector<std::string> args;
1306 StringMacros::getVectorFromString(
1307 dimensionArgs[d], args, {
','} );
1313 if(args.size() == 0)
1315 __GEN_SS__ <<
"Invalid dimensional arguments! "
1316 <<
"Need number of iterations at dimension " << d
1321 unsigned long numOfIterations;
1322 StringMacros::getNumber(args[0], numOfIterations);
1323 __GEN_COUT__ <<
"Dimension " << d
1324 <<
" numOfIterations=" << numOfIterations << __E__;
1328 dimensionIterations.push_back(numOfIterations);
1329 longDimensionParameters.push_back(longParamMap_t());
1330 doubleDimensionParameters.push_back(doubleParamMap_t());
1334 for(
unsigned int a = 1; a < args.size(); ++a)
1336 std::vector<std::string> argPieces;
1337 StringMacros::getVectorFromString(
1338 args[a], argPieces, {
':'} );
1340 __GEN_COUTV__(StringMacros::vectorToString(argPieces));
1344 if(argPieces.size() != 3)
1346 __GEN_SS__ <<
"Invalid argument pieces! Should be size "
1348 << argPieces.size() << __E__;
1349 ss << StringMacros::vectorToString(argPieces);
1355 if((argPieces[1].size() &&
1356 (argPieces[1][argPieces[1].size() - 1] ==
'f' ||
1357 argPieces[1].find(
'.') != std::string::npos)) ||
1358 (argPieces[2].size() &&
1359 (argPieces[2][argPieces[2].size() - 1] ==
'f' ||
1360 argPieces[2].find(
'.') != std::string::npos)))
1365 double startValue = strtod(argPieces[1].c_str(), 0);
1366 double stepSize = strtod(argPieces[2].c_str(), 0);
1368 __GEN_COUTV__(startValue);
1369 __GEN_COUTV__(stepSize);
1371 __GEN_COUT__ <<
"Creating double argument '"
1372 << argPieces[0] <<
"' := " << startValue
1373 <<
", " << stepSize << __E__;
1375 doubleDimensionParameters.back().emplace(std::make_pair(
1379 std::make_pair(startValue ,
1387 long int startValue;
1390 StringMacros::getNumber(argPieces[1], startValue);
1391 StringMacros::getNumber(argPieces[2], stepSize);
1393 __GEN_COUTV__(startValue);
1394 __GEN_COUTV__(stepSize);
1396 __GEN_COUT__ <<
"Creating long argument '" << argPieces[0]
1397 <<
"' := " << startValue <<
", " << stepSize
1400 longDimensionParameters.back().emplace(std::make_pair(
1404 std::make_pair(startValue ,
1412 if(dimensionIterations.size() != longDimensionParameters.size() ||
1413 dimensionIterations.size() != doubleDimensionParameters.size())
1415 __GEN_SS__ <<
"Impossible vector size mismatch! "
1416 << dimensionIterations.size() <<
" - "
1417 << longDimensionParameters.size() <<
" - "
1418 << doubleDimensionParameters.size() << __E__;
1424 std::stringstream outSS;
1426 outSS <<
"\n==========================\n" << __E__;
1427 outSS <<
"FEMacro '" << feMacro.feMacroName_
1428 <<
"' multi-dimensional scan..." << __E__;
1429 outSS <<
"\t" << StringMacros::getTimestampString() << __E__;
1430 outSS <<
"\t" << dimensionIterations.size()
1431 <<
" dimensions defined." << __E__;
1432 for(
unsigned int i = 0; i < dimensionIterations.size(); ++i)
1435 <<
"dimension[" << i <<
"] has "
1436 << dimensionIterations[i] <<
" iterations and "
1437 << (longDimensionParameters[i].size() +
1438 doubleDimensionParameters[i].size())
1439 <<
" arguments." << __E__;
1441 for(
auto& param : longDimensionParameters[i])
1443 <<
"'" << param.first <<
"' of type long with "
1444 <<
"initial value and step value [decimal] = "
1445 <<
"\t" << param.second.second.first <<
" & "
1446 << param.second.second.second << __E__;
1448 for(
auto& param : doubleDimensionParameters[i])
1450 <<
"'" << param.first <<
"' of type double with "
1451 <<
"initial value and step value = "
1452 <<
"\t" << param.second.second.first <<
" & "
1453 << param.second.second.second << __E__;
1456 outSS <<
"\nHere are the identified input arguments:" << __E__;
1457 for(
unsigned int i = 0; i < feMacro.namesOfInputArguments_.size();
1459 outSS <<
"\t" << feMacro.namesOfInputArguments_[i] << __E__;
1460 outSS <<
"\nHere are the identified input arguments:" << __E__;
1461 for(
unsigned int i = 0;
1462 i < feMacro.namesOfOutputArguments_.size();
1464 outSS <<
"\t" << feMacro.namesOfOutputArguments_[i] << __E__;
1466 outSS <<
"\n==========================\n" << __E__;
1470 __GEN_COUT__ <<
"\n" << outSS.str();
1471 if(outputFilePointer)
1472 fprintf(outputFilePointer, outSS.str().c_str());
1475 unsigned int iterationCount = 0;
1483 std::function<void(
const unsigned int
1485 localRecurse = [&dimensionIterations,
1486 &dimensionIterationCnt,
1488 &longDimensionParameters,
1489 &doubleDimensionParameters,
1495 &localRecurse](
const unsigned int dimension) {
1498 std::string mfSubject_ =
"multiD-" + std::to_string(dimension) +
1499 "-" + feMacro.feMacroName_;
1500 __GEN_COUTV__(dimension);
1502 if(dimension >= dimensionIterations.size())
1504 __GEN_COUT__ <<
"Iteration count: " << iterationCount++
1506 __GEN_COUT__ <<
"Launching FE Macro '" << feMacro.feMacroName_
1507 <<
"' ..." << __E__;
1518 for(
unsigned int i = 0; i < argsIn.size(); ++i)
1520 foundAsLong =
false;
1521 for(
unsigned int j = 0; j < dimensionIterations.size();
1525 longDimensionParameters[j].find(argsIn[i].first);
1526 if(longIt == longDimensionParameters[j].end())
1530 __GEN_COUT__ <<
"Assigning argIn '" << argsIn[i].first
1531 <<
"' to current long value '"
1532 << longIt->second.first
1533 <<
"' from dimension " << j
1534 <<
" parameter." << __E__;
1536 std::to_string(longIt->second.first);
1543 for(
unsigned int j = 0; j < dimensionIterations.size();
1546 auto doubleIt = doubleDimensionParameters[j].find(
1548 if(doubleIt == doubleDimensionParameters[j].end())
1552 __GEN_COUT__ <<
"Assigning argIn '" << argsIn[i].first
1553 <<
"' to current double value '"
1554 << doubleIt->second.first
1555 <<
"' from dimension " << j
1556 <<
" parameter." << __E__;
1558 std::to_string(doubleIt->second.first);
1563 __GEN_SS__ <<
"ArgIn '" << argsIn[i].first
1564 <<
"' was not assigned a value "
1565 <<
"by any dimensional loop parameter sets. "
1566 "This is illegal. FEMacro '"
1567 << feMacro.feMacroName_ <<
"' requires '"
1569 <<
"' as an input argument. Either remove the "
1570 "input argument from this FEMacro, "
1571 <<
"or define a value as a dimensional loop "
1578 (fe->*(feMacro.macroFunction_))(feMacro, argsIn, argsOut);
1580 __GEN_COUT__ <<
"FE Macro complete!" << __E__;
1584 std::stringstream outSS;
1586 outSS <<
"\n---------------\n" << __E__;
1587 outSS <<
"FEMacro '" << feMacro.feMacroName_
1588 <<
"' execution..." << __E__;
1590 <<
"iteration " << iterationCount << __E__;
1591 for(
unsigned int i = 0;
1592 i < dimensionIterationCnt.size();
1595 <<
"dimension[" << i
1596 <<
"] index := " << dimensionIterationCnt[i]
1601 <<
"Input arguments (count: " << argsIn.size()
1603 for(
auto& argIn : argsIn)
1604 outSS <<
"\t\t" << argIn.first <<
" = "
1605 << argIn.second << __E__;
1609 <<
"Output arguments (count: " << argsOut.size()
1611 for(
auto& argOut : argsOut)
1612 outSS <<
"\t\t" << argOut.first <<
" = "
1613 << argOut.second << __E__;
1617 __GEN_COUT__ <<
"\n" << outSS.str();
1618 if(outputFilePointer)
1619 fprintf(outputFilePointer, outSS.str().c_str());
1626 if(dimension >= dimensionIterationCnt.size())
1627 dimensionIterationCnt.push_back(0);
1630 __GEN_COUT__ <<
"\n"
1631 <<
"======================================" << __E__
1632 <<
"dimension[" << dimension
1633 <<
"] number of iterations := "
1634 << dimensionIterations[dimension] << __E__;
1639 for(
auto& longPair : longDimensionParameters[dimension])
1641 longPair.second.first =
1642 longPair.second.second.first;
1644 <<
"arg '" << longPair.first
1645 <<
"' current value: " << longPair.second.first
1649 for(
auto& doublePair : doubleDimensionParameters[dimension])
1651 doublePair.second.first =
1652 doublePair.second.second.first;
1654 <<
"arg '" << doublePair.first
1655 <<
"' current value: " << doublePair.second.first
1661 for(dimensionIterationCnt[dimension] =
1663 dimensionIterationCnt[dimension] <
1664 dimensionIterations[dimension];
1665 ++dimensionIterationCnt[dimension])
1667 __GEN_COUT__ <<
"dimension[" << dimension <<
"] index := "
1668 << dimensionIterationCnt[dimension] << __E__;
1670 localRecurse(dimension + 1);
1675 for(
auto& longPair : longDimensionParameters[dimension])
1677 longPair.second.first +=
1678 longPair.second.second.second;
1680 <<
"arg '" << longPair.first
1681 <<
"' current value: " << longPair.second.first
1685 for(
auto& doublePair :
1686 doubleDimensionParameters[dimension])
1688 doublePair.second.first +=
1689 doublePair.second.second.second;
1692 <<
"arg '" << doublePair.first
1693 <<
"' current value: " << doublePair.second.first
1699 __GEN_COUT__ <<
"Completed dimension[" << dimension
1700 <<
"] number of iterations := "
1701 << dimensionIterationCnt[dimension] <<
" of "
1702 << dimensionIterations[dimension] << __E__;
1709 if(outputFilePointer)
1710 fclose(outputFilePointer);
1712 catch(
const std::runtime_error& e)
1714 __SS__ <<
"Error executing multi-dimensional FE Macro: " << e.what()
1716 statusResult = ss.str();
1720 __SS__ <<
"Unknown error executing multi-dimensional FE Macro. " << __E__;
1721 statusResult = ss.str();
1724 __COUTV__(statusResult);
1727 std::lock_guard<std::mutex> lock(feMgr->macroMultiDimensionalDoneMutex_);
1729 feMgr->macroMultiDimensionalStatusMap_[interfaceID] = statusResult;
1742 __CFG_COUT__ <<
"Started multi-dimensional FE Macro '" << feMacroName
1743 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1754 bool FEVInterfacesManager::checkMacroMultiDimensional(
const std::string& interfaceID,
1755 const std::string& macroName)
1759 std::lock_guard<std::mutex> lock(macroMultiDimensionalDoneMutex_);
1761 auto statusIt = macroMultiDimensionalStatusMap_.find(interfaceID);
1762 if(statusIt == macroMultiDimensionalStatusMap_.end())
1764 __CFG_SS__ <<
"Status missing for multi-dimensional launch of Macro '"
1765 << macroName <<
"' for interface '" << interfaceID <<
".'" << __E__;
1768 else if(statusIt->second ==
"Done")
1770 __CFG_COUT__ <<
"Completed multi-dimensional launch of Macro '" << macroName
1771 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1774 macroMultiDimensionalStatusMap_.erase(statusIt);
1777 else if(statusIt->second ==
"Active")
1779 __CFG_COUT__ <<
"Still running multi-dimensional launch of Macro '" << macroName
1780 <<
"' for interface '" << interfaceID <<
".'" << __E__;
1785 __CFG_SS__ <<
"Error occured during multi-dimensional launch of Macro '" << macroName
1786 <<
"' for interface '" << interfaceID <<
"':" << statusIt->second << __E__;
1803 void FEVInterfacesManager::runFEMacroByFE(
const std::string& callingInterfaceID,
1804 const std::string& interfaceID,
1805 const std::string& feMacroName,
1806 const std::string& inputArgs,
1807 std::string& outputArgs)
1809 __CFG_COUTV__(callingInterfaceID);
1815 auto FEMacroIt = fe->getMapOfFEMacroFunctions().find(feMacroName);
1816 if(FEMacroIt == fe->getMapOfFEMacroFunctions().end())
1818 __CFG_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '" << interfaceID
1819 <<
"' was not found!" << __E__;
1820 __CFG_COUT_ERR__ <<
"\n" << ss.str();
1824 auto& feMacro = FEMacroIt->second;
1826 std::set<std::string> allowedFEsSet;
1827 StringMacros::getSetFromString(feMacro.allowedCallingFrontEnds_, allowedFEsSet);
1830 if(!StringMacros::inWildCardSet(callingInterfaceID, allowedFEsSet))
1832 __CFG_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '" << interfaceID
1833 <<
"' does not allow access to calling interfaceID '"
1834 << callingInterfaceID
1835 <<
"!' Did the interface add the calling interfaceID "
1836 <<
"to the access list when registering the front-end macro." << __E__;
1837 __CFG_COUT_ERR__ <<
"\n" << ss.str();
1846 for(
unsigned int i = 0; i < feMacro.namesOfOutputArguments_.size(); ++i)
1847 outputArgs += (i ?
"," :
"") + feMacro.namesOfOutputArguments_[i];
1849 __CFG_COUTV__(outputArgs);
1851 runFEMacro(interfaceID, feMacro, inputArgs, outputArgs);
1853 __CFG_COUTV__(outputArgs);
1868 void FEVInterfacesManager::runMacro(
const std::string& interfaceID,
1869 const std::string& macroObjectString,
1870 const std::string& inputArgs,
1871 std::string& outputArgs)
1882 std::vector<FEVInterface::frontEndMacroArg_t> argsIn;
1884 std::istringstream inputStream(inputArgs);
1885 std::string splitVal, argName, argValue;
1886 while(getline(inputStream, splitVal,
';'))
1888 std::istringstream pairInputStream(splitVal);
1889 getline(pairInputStream, argName,
',');
1890 getline(pairInputStream, argValue,
',');
1891 argsIn.push_back(std::make_pair(argName, argValue));
1896 if(macro.namesOfInputArguments_.size() != argsIn.size())
1898 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1899 <<
"' was attempted on interfaceID '" << interfaceID
1900 <<
"' with a mismatch in"
1901 <<
" number of input arguments. " << argsIn.size() <<
" were given. "
1902 << macro.namesOfInputArguments_.size() <<
" expected." << __E__;
1905 for(
unsigned int i = 0; i < argsIn.size(); ++i)
1906 if(macro.namesOfInputArguments_.find(argsIn[i].first) ==
1907 macro.namesOfInputArguments_.end())
1909 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1910 <<
"' was attempted on interfaceID '" << interfaceID
1911 <<
"' with a mismatch in"
1912 <<
" a name of an input argument. " << argsIn[i].first
1913 <<
" was given. Expected: "
1914 << StringMacros::setToString(macro.namesOfInputArguments_)
1921 std::vector<std::string> returnStrings;
1922 std::vector<FEVInterface::frontEndMacroArg_t> argsOut;
1925 std::istringstream inputStream(outputArgs);
1926 std::string argName;
1927 while(getline(inputStream, argName,
','))
1929 __CFG_COUT__ <<
"argName " << argName << __E__;
1931 returnStrings.push_back(
"DEFAULT");
1932 argsOut.push_back(FEVInterface::frontEndMacroArg_t(
1933 argName, returnStrings[returnStrings.size() - 1]));
1942 if(macro.namesOfOutputArguments_.size() != argsOut.size())
1944 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1945 <<
"' was attempted on interfaceID '" << interfaceID
1946 <<
"' with a mismatch in"
1947 <<
" number of output arguments. " << argsOut.size() <<
" were given. "
1948 << macro.namesOfOutputArguments_.size() <<
" expected." << __E__;
1952 for(
unsigned int i = 0; i < argsOut.size(); ++i)
1953 if(macro.namesOfOutputArguments_.find(argsOut[i].first) ==
1954 macro.namesOfOutputArguments_.end())
1956 __CFG_SS__ <<
"MacroMaker Macro '" << macro.macroName_
1957 <<
"' was attempted on interfaceID '" << interfaceID
1958 <<
"' with a mismatch in"
1959 <<
" a name of an output argument. " << argsOut[i].first
1960 <<
" were given. Expected: "
1961 << StringMacros::setToString(macro.namesOfOutputArguments_)
1967 __CFG_COUT__ <<
"# of input args = " << argsIn.size() << __E__;
1969 std::map<std::string , uint64_t > variableMap;
1971 for(
const auto& outputArgName : macro.namesOfOutputArguments_)
1972 variableMap.emplace(
1973 std::pair<std::string /*name*/, uint64_t /*value*/>(outputArgName, 0));
1974 for(
const auto& inputArgName : macro.namesOfInputArguments_)
1975 variableMap.emplace(
1976 std::pair<std::string /*name*/, uint64_t /*value*/>(inputArgName, 0));
1978 for(
auto& argIn : argsIn)
1980 __CFG_COUT__ << argIn.first <<
": " << argIn.second << __E__;
1981 StringMacros::getNumber(argIn.second, variableMap.at(argIn.first));
1984 fe->runMacro(macro, variableMap);
1986 __CFG_COUT__ <<
"MacroMaker Macro complete!" << __E__;
1988 __CFG_COUT__ <<
"# of output args = " << argsOut.size() << __E__;
1989 for(
auto& arg : argsOut)
1991 std::stringstream numberSs;
1992 numberSs << std::dec << variableMap.at(arg.first) <<
" (0x" << std::hex
1993 << variableMap.at(arg.first) <<
")" << std::dec;
1994 arg.second = numberSs.str();
1995 __CFG_COUT__ << arg.first <<
": " << arg.second << __E__;
2000 for(
unsigned int i = 0; i < argsOut.size(); ++i)
2004 outputArgs += argsOut[i].first +
"," + argsOut[i].second;
2007 __CFG_COUT__ <<
"outputArgs = " << outputArgs << __E__;
2022 void FEVInterfacesManager::runFEMacro(
const std::string& interfaceID,
2023 const std::string& feMacroName,
2024 const std::string& inputArgs,
2025 std::string& outputArgs)
2031 auto FEMacroIt = fe->getMapOfFEMacroFunctions().find(feMacroName);
2032 if(FEMacroIt == fe->getMapOfFEMacroFunctions().end())
2034 __CFG_SS__ <<
"FE Macro '" << feMacroName <<
"' of interfaceID '" << interfaceID
2035 <<
"' was not found!" << __E__;
2036 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2040 runFEMacro(interfaceID, FEMacroIt->second, inputArgs, outputArgs);
2055 void FEVInterfacesManager::runFEMacro(
const std::string& interfaceID,
2057 const std::string& inputArgs,
2058 std::string& outputArgs)
2062 std::vector<FEVInterface::frontEndMacroArg_t> argsIn;
2064 std::istringstream inputStream(inputArgs);
2065 std::string splitVal, argName, argValue;
2066 while(getline(inputStream, splitVal,
';'))
2068 std::istringstream pairInputStream(splitVal);
2069 getline(pairInputStream, argName,
',');
2070 getline(pairInputStream, argValue,
',');
2071 argsIn.push_back(std::make_pair(argName, argValue));
2076 if(feMacro.namesOfInputArguments_.size() != argsIn.size())
2078 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2079 << interfaceID <<
"' was attempted with a mismatch in"
2080 <<
" number of input arguments. " << argsIn.size() <<
" were given. "
2081 << feMacro.namesOfInputArguments_.size() <<
" expected." << __E__;
2082 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2085 for(
unsigned int i = 0; i < argsIn.size(); ++i)
2086 if(argsIn[i].first != feMacro.namesOfInputArguments_[i])
2088 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2089 << interfaceID <<
"' was attempted with a mismatch in"
2090 <<
" a name of an input argument. " << argsIn[i].first
2091 <<
" was given. " << feMacro.namesOfInputArguments_[i]
2092 <<
" expected." << __E__;
2093 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2098 std::vector<std::string> returnStrings;
2099 std::vector<FEVInterface::frontEndMacroArg_t> argsOut;
2102 std::istringstream inputStream(outputArgs);
2103 std::string argName;
2104 while(getline(inputStream, argName,
','))
2106 __CFG_COUT__ <<
"argName " << argName << __E__;
2108 returnStrings.push_back(
"DEFAULT");
2109 argsOut.push_back(FEVInterface::frontEndMacroArg_t(
2110 argName, returnStrings[returnStrings.size() - 1]));
2113 __CFG_COUT__ << (uint64_t) & (returnStrings[returnStrings.size() - 1])
2119 if(feMacro.namesOfOutputArguments_.size() != argsOut.size())
2121 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2122 << interfaceID <<
"' was attempted with a mismatch in"
2123 <<
" number of output arguments. " << argsOut.size() <<
" were given. "
2124 << feMacro.namesOfOutputArguments_.size() <<
" expected." << __E__;
2125 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2128 for(
unsigned int i = 0; i < argsOut.size(); ++i)
2129 if(argsOut[i].first != feMacro.namesOfOutputArguments_[i])
2131 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2132 << interfaceID <<
"' was attempted with a mismatch in"
2133 <<
" a name of an output argument. " << argsOut[i].first
2134 <<
" were given. " << feMacro.namesOfOutputArguments_[i]
2135 <<
" expected." << __E__;
2136 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2140 __CFG_COUT__ <<
"# of input args = " << argsIn.size() << __E__;
2141 for(
auto& argIn : argsIn)
2142 __CFG_COUT__ << argIn.first <<
": " << argIn.second << __E__;
2150 __MOUT__ <<
"Launching FE Macro '" << feMacro.feMacroName_ <<
"' ..." << __E__;
2151 __CFG_COUT__ <<
"Launching FE Macro '" << feMacro.feMacroName_ <<
"' ..." << __E__;
2154 (getFEInterfaceP(interfaceID)->*(feMacro.macroFunction_))(feMacro, argsIn, argsOut);
2156 __CFG_COUT__ <<
"FE Macro complete!" << __E__;
2158 __CFG_COUT__ <<
"# of output args = " << argsOut.size() << __E__;
2159 for(
const auto& arg : argsOut)
2160 __CFG_COUT__ << arg.first <<
": " << arg.second << __E__;
2163 if(feMacro.namesOfOutputArguments_.size() != argsOut.size())
2165 __CFG_SS__ <<
"FE Macro '" << feMacro.feMacroName_ <<
"' of interfaceID '"
2167 <<
"' was attempted but the FE macro "
2168 "manipulated the output arguments vector. It is illegal "
2169 "to add or remove output vector name/value pairs."
2171 __CFG_COUT_ERR__ <<
"\n" << ss.str();
2177 for(
unsigned int i = 0; i < argsOut.size(); ++i)
2187 if(StringMacros::getNumber(argsOut[i].second, tmpNumber))
2189 std::stringstream outNumberSs;
2190 outNumberSs << std::dec << tmpNumber <<
" (0x" << std::hex << tmpNumber
2192 outputArgs += argsOut[i].first +
"," + outNumberSs.str();
2200 outputArgs += argsOut[i].first +
"," + argsOut[i].second;
2203 __CFG_COUT__ <<
"outputArgs = " << outputArgs << __E__;
2215 std::string FEVInterfacesManager::getFEMacrosString(
const std::string& supervisorName,
2216 const std::string& supervisorLid)
2218 std::string retList =
"";
2220 for(
const auto& it : theFEInterfaces_)
2222 __CFG_COUT__ <<
"FE interface UID = " << it.first << __E__;
2224 retList += supervisorName +
":" + supervisorLid +
":" +
2225 it.second->getInterfaceType() +
":" + it.second->getInterfaceUID();
2227 for(
const auto& macroPair : it.second->getMapOfFEMacroFunctions())
2229 __CFG_COUT__ <<
"FE Macro name = " << macroPair.first << __E__;
2230 retList +=
":" + macroPair.first +
":" +
2231 std::to_string(macroPair.second.requiredUserPermissions_) +
":" +
2232 std::to_string(macroPair.second.namesOfInputArguments_.size());
2233 for(
const auto& name : macroPair.second.namesOfInputArguments_)
2234 retList +=
":" + name;
2237 ":" + std::to_string(macroPair.second.namesOfOutputArguments_.size());
2238 for(
const auto& name : macroPair.second.namesOfOutputArguments_)
2239 retList +=
":" + name;
2248 bool FEVInterfacesManager::allFEWorkloopsAreDone(
void)
2250 bool allFEWorkloopsAreDone =
true;
2253 for(
const auto& FEInterface : theFEInterfaces_)
2255 isActive = FEInterface.second->WorkLoop::isActive();
2257 __CFG_COUT__ << FEInterface.second->getInterfaceUID() <<
" of type "
2258 << FEInterface.second->getInterfaceType() <<
": \t"
2259 <<
"workLoop_->isActive() " << (isActive ?
"yes" :
"no") << __E__;
2263 allFEWorkloopsAreDone =
false;
2268 return allFEWorkloopsAreDone;
2272 void FEVInterfacesManager::preStateMachineExecutionLoop(
void)
2274 VStateMachine::clearIterationWork();
2275 VStateMachine::clearSubIterationWork();
2277 stateMachinesIterationWorkCount_ = 0;
2279 __CFG_COUT__ <<
"Number of front ends to transition: " << theFENamesByPriority_.size()
2282 if(VStateMachine::getIterationIndex() == 0 &&
2283 VStateMachine::getSubIterationIndex() == 0)
2287 subIterationWorkStateMachineIndex_ = -1;
2289 stateMachinesIterationDone_.clear();
2290 for(
const auto& FEPair : theFEInterfaces_)
2291 stateMachinesIterationDone_[FEPair.first] =
false;
2294 __CFG_COUT__ <<
"Iteration " << VStateMachine::getIterationIndex() <<
"."
2295 << VStateMachine::getSubIterationIndex() <<
"("
2296 << subIterationWorkStateMachineIndex_ <<
")" << __E__;
2300 void FEVInterfacesManager::preStateMachineExecution(
unsigned int i)
2302 if(i >= theFENamesByPriority_.size())
2304 __CFG_SS__ <<
"FE Interface " << i <<
" not found!" << __E__;
2308 const std::string& name = theFENamesByPriority_[i];
2312 fe->VStateMachine::setIterationIndex(VStateMachine::getIterationIndex());
2313 fe->VStateMachine::setSubIterationIndex(VStateMachine::getSubIterationIndex());
2315 fe->VStateMachine::clearIterationWork();
2316 fe->VStateMachine::clearSubIterationWork();
2318 __CFG_COUT__ <<
"theStateMachineImplementation Iteration "
2319 << fe->VStateMachine::getIterationIndex() <<
"."
2320 << fe->VStateMachine::getSubIterationIndex() << __E__;
2326 bool FEVInterfacesManager::postStateMachineExecution(
unsigned int i)
2328 if(i >= theFENamesByPriority_.size())
2330 __CFG_SS__ <<
"FE Interface index " << i <<
" not found!" << __E__;
2334 const std::string& name = theFENamesByPriority_[i];
2339 if(fe->VStateMachine::getSubIterationWork())
2341 subIterationWorkStateMachineIndex_ = i;
2342 VStateMachine::indicateSubIterationWork();
2344 __CFG_COUT__ <<
"FE Interface '" << name
2345 <<
"' is flagged for another sub-iteration..." << __E__;
2350 subIterationWorkStateMachineIndex_ = -1;
2352 bool& stateMachineDone = stateMachinesIterationDone_[name];
2353 stateMachineDone = !fe->VStateMachine::getIterationWork();
2355 if(!stateMachineDone)
2357 __CFG_COUT__ <<
"FE Interface '" << name
2358 <<
"' is flagged for another iteration..." << __E__;
2359 VStateMachine::indicateIterationWork();
2361 ++stateMachinesIterationWorkCount_;
2369 void FEVInterfacesManager::postStateMachineExecutionLoop(
void)
2371 if(VStateMachine::getSubIterationWork())
2372 __CFG_COUT__ <<
"FE Interface state machine implementation "
2373 << subIterationWorkStateMachineIndex_
2374 <<
" is flagged for another sub-iteration..." << __E__;
2375 else if(VStateMachine::getIterationWork())
2376 __CFG_COUT__ << stateMachinesIterationWorkCount_
2377 <<
" FE Interface state machine implementation(s) flagged for "
2378 "another iteration..."
2381 __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)