Gambit::DRes::DependencyResolver Class Reference

Main dependency resolver. More...

#include <depresolver.hpp>

Collaboration diagram for Gambit::DRes::DependencyResolver:

Public Member Functions
	DependencyResolver (const gambit_core &, const Models::ModelFunctorClaw &, const IniParser::IniFile &, const Utils::type_equivalency &, Printers::BasePrinter &)
	Constructor, provide module and backend functor lists. More...
void	doResolution ()
	The dependency resolution. More...
void	printFunctorList ()
	Pretty print module functor information. More...
void	printFunctorEvalOrder (bool toterminal=false)
	Pretty print function evaluation order. More...
std::vector< VertexID >	getObsLikeOrder ()
	Retrieve the order in which target vertices are to be evaluated. More...
void	calcObsLike (VertexID)
	Calculate a single target vertex. More...
void	printObsLike (VertexID, const int)
	Print a single target vertex. More...
bool	printTiming ()
	Getter for print_timing flag (used by LikelihoodContainer) More...
functor *	get_functor (VertexID)
	Get the functor corresponding to a single VertexID. More...
str	checkTypeMatch (VertexID, const str &, const std::vector< str > &)
	Ensure that the type of a given vertex is equivalent to at least one of a provided list, and return the matching list entry. More...
template<typename TYPE >
TYPE	getObsLike (VertexID vertex)
	Return the result of a functor. More...
const IniParser::ObservableType *	getIniEntry (VertexID)
void	invalidatePointAt (VertexID, bool)
void	resetAll ()

Static Public Member Functions
static MasterGraphType	cullInactiveFunctors (MasterGraphType &)
	Helper function that returns a new graph with all inactive vertices removed. More...

Private Member Functions
void	addFunctors ()
	Adds list of functor pointers to master graph. More...
str	printGenericFunctorList (const std::vector< functor *> &)
	Pretty print backend functor information. More...
str	printGenericFunctorList (const std::vector< VertexID > &)
str	printQuantityToBeResolved (const sspair &quantity, const DRes::VertexID &vertex)
	Print quantity to be resolved. More...
void	initialisePrinter ()
	Initialise the printer object with a list of functors for it to expect to be printed. More...
void	makeFunctorsModelCompatible ()
	Deactivate functors that are not allowed to be used with the model(s) being scanned. More...
boost::tuple< const IniParser::ObservableType *, DRes::VertexID >	resolveDependency (DRes::VertexID toVertex, sspair quantity)
	Resolution of individual module function dependencies. More...
DRes::VertexID	resolveDependencyFromRules (const DRes::VertexID &toVertex, const sspair &quantity)
	Resolution of individual module function dependencies. More...
Options	collectIniOptions (const DRes::VertexID &vertex)
	Derive options from ini-entries. More...
Options	collectSubCaps (const DRes::VertexID &vertex)
	Collect sub-capabilities. More...
void	generateTree (std::queue< QueueEntry > parQueue)
	Generate full dependency tree. More...
void	fillParQueue (std::queue< QueueEntry > *parQueue, DRes::VertexID vertex)
	Helper functions/arrays. More...
std::list< VertexID >	run_topological_sort ()
	Topological sort. More...
void	resolveVertexBackend (VertexID)
	Main function for resolution of backend requirements. More...
functor *	solveRequirement (std::set< sspair >, const IniParser::ObservableType *, VertexID, std::vector< functor *>, bool, str group="none")
	Find backend function matching any one of a number of capability-type pairs. More...
void	resolveRequirement (functor *, VertexID)
	Resolve a specific backend requirement. More...
std::vector< DRes::VertexID >	closestCandidateForModel (std::vector< DRes::VertexID > candidates)
	Find candidate functions that are tailor made for models that are scanned over. More...
const IniParser::ObservableType *	findIniEntry (sspair quantity, const IniParser::ObservablesType &, const str &)
	Find entries (comparison of inifile entry with quantity or functor) More...
const IniParser::ObservableType *	findIniEntry (DRes::VertexID toVertex, const IniParser::ObservablesType &, const str &)
	Find rules entry that matches vertex. More...

Private Attributes
const gambit_core *	boundCore
	Core to which this dependency resolver is bound. More...
const Models::ModelFunctorClaw *	boundClaw
	Model claw to which this dependency resolver is bound. More...
const IniParser::IniFile *	boundIniFile
	ini file to which this dependency resolver is bound More...
const Utils::type_equivalency *	boundTEs
	Type equivalency object to which this dependency resolver is bound. More...
Printers::BasePrinter *	boundPrinter
	Printer object to which this dependency resolver is bound. More...
std::vector< OutputVertexInfo >	outputVertexInfos
	Output Vertex Infos. More...
MasterGraphType	masterGraph
	The central boost graph object. More...
std::list< VertexID >	function_order
	Saved calling order for functions. More...
std::map< VertexID, std::vector< VertexID > >	SortedParentVertices
	Saved calling order for functions required to compute single ObsLike entries. More...
std::map< VertexID, std::set< VertexID > >	loopManagerMap
	Temporary map for loop manager -> list of nested functions. More...
std::map< VertexID, std::set< VertexID > >	edges_to_force_on_manager
	Map from nested function -> list of fulfilled dependencies that need to be passed on to its loop manager when it is selected. More...
IndexMap	index
	Indices associated with graph vertices (used by printers to identify functors) More...
const str	activeFunctorGraphFile
	Output filename for graph of active functors. More...
bool	print_timing = false
	Global flag for triggering printing of timing data. More...
bool	print_unitcube = false
	Global flag for triggering printing of unitCubeParameters. More...

Detailed Description

Main dependency resolver.

Definition at line 117 of file depresolver.hpp.

Constructor & Destructor Documentation

DependencyResolver()

Gambit::DRes::DependencyResolver::DependencyResolver	(	const gambit_core &	core,
		const Models::ModelFunctorClaw &	claw,
		const IniParser::IniFile &	iniFile,
		const Utils::type_equivalency &	equiv_classes,
		Printers::BasePrinter &	printer
	)

Constructor, provide module and backend functor lists.

Definition at line 308 of file depresolver.cpp.

References addFunctors(), boundTEs, Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::Utils::type_equivalency::equivalency_classes, and Gambit::logger().

     : boundCore(&core),
       boundClaw(&claw),
       boundIniFile(&iniFile),
       boundTEs(&equiv_classes),
       boundPrinter(&printer),
       index(get(vertex_index,masterGraph)),
       activeFunctorGraphFile(Utils::runtime_scratch()+"GAMBIT_active_functor_graph.gv")
    {
      addFunctors();
      logger() << LogTags::dependency_resolver << endl;
      logger() << "#######################################"   << endl;
      logger() << "#  List of Type Equivalency Classes   #"   << endl;
      logger() << "#######################################";
      for (std::set<std::set<str> >::const_iterator it = boundTEs->equivalency_classes.begin(); it != boundTEs->equivalency_classes.end(); ++it)
      {
        logger() << endl << *it;
      }
      logger() << EOM;
    }

Here is the call graph for this function:

Member Function Documentation

addFunctors()

void Gambit::DRes::DependencyResolver::addFunctors ( )

private

Adds list of functor pointers to master graph.

Definition at line 806 of file depresolver.cpp.

References boundCore, Gambit::gambit_core::getModuleFunctors(), Gambit::gambit_core::getPrimaryModelFunctors(), and masterGraph.

Referenced by DependencyResolver().

    {
      // Add primary model functors to masterGraph
      for (std::vector<primary_model_functor *>::const_iterator
          it  = boundCore->getPrimaryModelFunctors().begin();
          it != boundCore->getPrimaryModelFunctors().end();
          ++it)
      {
        // Ignore functors with status set to 0 or less in order to ignore primary_model_functors
        // that are not to be used for the scan.
        if ( (*it)->status() > 0 )
        {
          boost::add_vertex(*it, this->masterGraph);
        }
      }
      // Add module functors to masterGraph
      for (std::vector<functor *>::const_iterator
          it  = boundCore->getModuleFunctors().begin();
          it != boundCore->getModuleFunctors().end();
          ++it)
      {
          boost::add_vertex(*it, this->masterGraph);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

calcObsLike()

void Gambit::DRes::DependencyResolver::calcObsLike

(

VertexID

vertex

)

Calculate a single target vertex.

Definition at line 629 of file depresolver.cpp.

References boundCore, boundIniFile, Gambit::core_error(), Gambit::LogTags::debug, Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::gambit_core::get_outprec(), Gambit::IniParser::Parser::getValueOrDef(), Gambit::LogTags::info, LOCAL_INFO, Gambit::logger(), masterGraph, and SortedParentVertices.

Referenced by Gambit::Likelihood_Container::main().

    {
      if (SortedParentVertices.find(vertex) == SortedParentVertices.end())
        core_error().raise(LOCAL_INFO, "Tried to calculate a function not in or not at top of dependency graph.");
      std::vector<VertexID> order = SortedParentVertices.at(vertex);

      for (std::vector<VertexID>::iterator it = order.begin(); it != order.end(); ++it)
      {
        std::ostringstream ss;
        ss << "Calling " << masterGraph[*it]->name() << " from " << masterGraph[*it]->origin() << "...";
        logger() << LogTags::dependency_resolver << LogTags::info << LogTags::debug << ss.str() << EOM;
        masterGraph[*it]->calculate();
        if (boundIniFile->getValueOrDef<bool>(
              false, "dependency_resolution", "log_runtime") )
        {
          double T = masterGraph[*it]->getRuntimeAverage();
          logger() << LogTags::dependency_resolver << LogTags::info <<
            "Runtime, averaged over multiple calls [s]: " << T << EOM;
        }
        invalid_point_exception* e = masterGraph[*it]->retrieve_invalid_point_exception();
        if (e != NULL) throw(*e);
      }
      // Reset the cout output precision, in case any backends have messed with it during the ObsLike evaluation.
      cout << std::setprecision(boundCore->get_outprec());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

checkTypeMatch()

str Gambit::DRes::DependencyResolver::checkTypeMatch	(	VertexID	vertex,
		const str &	purpose,
		const std::vector< str > &	types
	)

Ensure that the type of a given vertex is equivalent to at least one of a provided list, and return the matching list entry.

Definition at line 700 of file depresolver.cpp.

References boundTEs, Gambit::core_error(), LOCAL_INFO, masterGraph, and Gambit::DRes::typeComp().

Referenced by Gambit::Likelihood_Container::Likelihood_Container().

    {
      for (auto it = types.begin(); it != types.end(); ++it)
      {
        if (typeComp(*it, masterGraph[vertex]->type(), *boundTEs, false)) return *it;
      }
      std::stringstream msg;
      msg << "All quantities with purpose \"" << purpose << "\" in your yaml file must have one " << endl
          << "of the following types: " << endl << "  " << types << endl
          << "You have tried to assign this purpose to " << masterGraph[vertex]->origin() << "::"
          << masterGraph[vertex]->name() << "," << endl << "which has capability: " << endl
          << "  " << masterGraph[vertex]->capability() << endl << "and result type: " << endl
          << "  [" << masterGraph[vertex]->type() << "]" << endl << "Please assign a different purpose to this entry.";
      core_error().raise(LOCAL_INFO, msg.str());
      return "If you make core errors non-fatal you deserve what you get.";
    }

Here is the call graph for this function:

Here is the caller graph for this function:

closestCandidateForModel()

std::vector< DRes::VertexID > Gambit::DRes::DependencyResolver::closestCandidateForModel ( std::vector< DRes::VertexID >  candidates )

private

Find candidate functions that are tailor made for models that are scanned over.

Definition at line 925 of file depresolver.cpp.

References boundClaw, Gambit::Models::ModelFunctorClaw::get_activemodels(), Gambit::Models::ModelFunctorClaw::get_parent(), and masterGraph.

Referenced by resolveDependencyFromRules().

    {
      // In case of doubt (and if not explicitely disabled in the ini-file), prefer functors
      // that are more specifically tailored for the model being scanned. Do not consider functors
      // that are accessible via INTERPRET_AS_X links, as these are all considered to be equally 'far'
      // from the model being scanned, with the 'distance' being one step further than the most distant
      // ancestor.

      // Work up the model ancestry one step at a time, and stop as soon as one or more valid model-specific functors is
      // found at a given level in the hierarchy.
      std::vector<DRes::VertexID> newCandidates;
      std::set<str> s = boundClaw->get_activemodels();
      std::vector<str> parentModelList(s.begin(), s.end());
      while (newCandidates.size() == 0 and not parentModelList.empty())
      {
        for (std::vector<str>::iterator mit = parentModelList.begin(); mit != parentModelList.end(); ++mit)
        {
          // Test each vertex candidate to see if it has been explicitly set up to work with the model *mit
          for (std::vector<DRes::VertexID>::iterator it = candidates.begin(); it != candidates.end(); ++it)
          {
            if ( masterGraph[*it]->modelExplicitlyAllowed(*mit) ) newCandidates.push_back(*it);
          }
          // Step up a level in the model hierarchy for this model.
          *mit = boundClaw->get_parent(*mit);
        }
        parentModelList.erase(std::remove(parentModelList.begin(), parentModelList.end(), "none"), parentModelList.end());
      }
      if (newCandidates.size() != 0)
        return newCandidates;
      else
        return candidates;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

collectIniOptions()

Options Gambit::DRes::DependencyResolver::collectIniOptions ( const DRes::VertexID &  vertex )

private

Derive options from ini-entries.

Collect ini options.

Definition at line 959 of file depresolver.cpp.

References boundIniFile, boundTEs, Gambit::DRes::dependency_resolver_error(), Gambit::DRes::getEntryLevelForOptions(), Gambit::IniParser::IniFile::getRules(), LOCAL_INFO, masterGraph, and Gambit::DRes::moduleFuncMatchesIniEntry().

Referenced by generateTree().

    {
      YAML::Node nodes;
      YAML::Node zlevels;

      #ifdef DEPRES_DEBUG
        cout << "Searching options for " << masterGraph[vertex]->capability() << endl;
      #endif

      const IniParser::ObservablesType & entries = boundIniFile->getRules();
      for (IniParser::ObservablesType::const_iterator it =
          entries.begin(); it != entries.end(); ++it)
      {
        if (moduleFuncMatchesIniEntry(masterGraph[vertex], *it, *boundTEs))
        {
          #ifdef DEPRES_DEBUG
            cout << "Getting option from: " << it->capability << " " << it->type << endl;
          #endif
          for (auto jt = it->options.begin(); jt != it->options.end(); ++jt)
          {
            if ( not nodes[jt->first.as<std::string>()] )
            {
              #ifdef DEPRES_DEBUG
                cout << jt->first.as<std::string>() << ": " << jt->second << endl;
              #endif
              nodes[jt->first.as<std::string>()] = jt->second;
              zlevels[jt->first.as<std::string>()] = getEntryLevelForOptions(*it);
            }
            else
            {
              if ( zlevels[jt->first.as<std::string>()].as<int>() < getEntryLevelForOptions(*it) )
              {
                #ifdef DEPRES_DEBUG
                  cout << "Replaced : " << jt->first.as<std::string>() << ": " << jt->second << endl;
                #endif
                zlevels[jt->first.as<std::string>()] = getEntryLevelForOptions(*it);
                nodes[jt->first.as<std::string>()] = jt->second;
              }
              else if ( zlevels[jt->first.as<std::string>()].as<int>() == getEntryLevelForOptions(*it) )
              {
                std::ostringstream errmsg;
                errmsg << "ERROR! Multiple option entries with same level for key: " << jt->first.as<std::string>();
                dependency_resolver_error().raise(LOCAL_INFO,errmsg.str());
              }
            }
          }
        }
      }
      return Options(nodes);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

collectSubCaps()

Options Gambit::DRes::DependencyResolver::collectSubCaps ( const DRes::VertexID &  vertex )

private

Collect sub-capabilities.

Definition at line 1011 of file depresolver.cpp.

References boundIniFile, boundTEs, Gambit::DRes::dependency_resolver_error(), Gambit::IniParser::IniFile::getObservables(), LOCAL_INFO, masterGraph, and Gambit::DRes::moduleFuncMatchesIniEntry().

Referenced by generateTree().

    {
      #ifdef DEPRES_DEBUG
        cout << "Searching for subcaps of " << masterGraph[vertex]->capability() << endl;
      #endif

      YAML::Node nodes;
      const IniParser::ObservablesType& entries = boundIniFile->getObservables();

      // Iterate over the ObsLikes entries
      for (auto it = entries.begin(); it != entries.end(); ++it)
      {
        // Select only those entries that match the current graph vertex (i.e. module function)
        if (moduleFuncMatchesIniEntry(masterGraph[vertex], *it, *boundTEs) and not it->subcaps.IsNull())
        {
          #ifdef DEPRES_DEBUG
            cout << "Found subcaps for " << it->capability << " " << it->type << " " << it->module << ":" << endl;
          #endif
          // The user has given just a single entry as a subcap
          if (it->subcaps.IsScalar())
          {
            str key = it->subcaps.as<str>();
            if (nodes[key]) dependency_resolver_error().raise(LOCAL_INFO,"Duplicate sub-capability for " + key + ".");
            nodes[key] = YAML::Node();
          }
          // The user has passed a simple list of subcaps
          else if (it->subcaps.IsSequence())
          {
            for (auto jt = it->subcaps.begin(); jt != it->subcaps.end(); ++jt)
            {
              if (not jt->IsScalar())
               dependency_resolver_error().raise(LOCAL_INFO,"Attempt to pass map using sequence syntax for subcaps of "+it->capability+".");
              str key = jt->as<str>();
              if (nodes[key]) dependency_resolver_error().raise(LOCAL_INFO,"Duplicate sub-capability for " + key + ".");
              nodes[key] = YAML::Node();
            }
          }
          // The user has passed some more complicated subcap structure than just a list of strings
          else if (it->subcaps.IsMap())
          {
            for (auto jt = it->subcaps.begin(); jt != it->subcaps.end(); ++jt)
            {
              str key = jt->first.as<str>();
              if (nodes[key]) dependency_resolver_error().raise(LOCAL_INFO,"Duplicate sub-capability for " + key + ".");
              nodes[key] = jt->second.as<YAML::Node>();
            }
          }
          #ifdef DEPRES_DEBUG
            cout << nodes << endl;
          #endif
        }
      }
      return Options(nodes);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

cullInactiveFunctors()

static MasterGraphType Gambit::DRes::DependencyResolver::cullInactiveFunctors ( MasterGraphType &  )

static

Helper function that returns a new graph with all inactive vertices removed.

doResolution()

void Gambit::DRes::DependencyResolver::doResolution

(

)

The dependency resolution.

Definition at line 339 of file depresolver.cpp.

References activeFunctorGraphFile, boundCore, boundIniFile, Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::DRes::QueueEntry::first, function_order, generateTree(), Gambit::IniParser::IniFile::getObservables(), getObsLikeOrder(), Gambit::DRes::getSortedParentVertices(), initialisePrinter(), Gambit::logger(), loopManagerMap, makeFunctorsModelCompatible(), masterGraph, OBSLIKE_VERTEXID, Gambit::DRes::QueueEntry::printme, run_topological_sort(), Gambit::DRes::QueueEntry::second, Gambit::gambit_core::show_runorder, SortedParentVertices, and Gambit::DRes::sortVertices().

Referenced by main().

    {
      const IniParser::ObservablesType & observables = boundIniFile->getObservables();
      // (cap., typ) --> dep. vertex map
      std::queue<QueueEntry> parQueue;
      QueueEntry queueEntry;

      // Set up list of target ObsLikes
      logger() << LogTags::dependency_resolver << endl;
      logger() << "#######################################"   << endl;
      logger() << "#        List of Target ObsLikes      #"   << endl;
      logger() << "#                                     #"   << endl;
      logger() << "# format: Capability (Type) [Purpose] #"   << endl;
      logger() << "#######################################";
      for (auto it = observables.begin(); it != observables.end(); ++it)
      {
        // Format output
        logger() << LogTags::dependency_resolver << endl << it->capability << " (" << it->type << ") [" << it->purpose << "]";
        queueEntry.first.first = it->capability;
        queueEntry.first.second = it->type;
        queueEntry.second = OBSLIKE_VERTEXID;
        queueEntry.printme = it->printme;
        parQueue.push(queueEntry);
      }
      logger() << EOM;

      // Activate functors compatible with model we scan over (and deactivate the rest)
      makeFunctorsModelCompatible();

      // Generate dependency tree (the core of the dependency resolution)
      generateTree(parQueue);

      // Find one execution order for activated vertices that is compatible
      // with dependency structure
      function_order = run_topological_sort();

      // Loop manager initialization: Notify them about their nested functions
      for (std::map<VertexID, std::set<VertexID>>::iterator it =
          loopManagerMap.begin(); it != loopManagerMap.end(); ++it)
      {
        // Generate topologically sorted list of vertex IDs that are nested
        // within loop manager (*it) ...
        std::vector<VertexID> vertexList = sortVertices(it->second, function_order);
        // ... map this on functor pointers...
        std::vector<functor*> functorList;
        for (std::vector<VertexID>::iterator jt = vertexList.begin(); jt != vertexList.end(); ++jt)
        {
          functorList.push_back(masterGraph[*jt]);
        }
        // ...and store it into loop manager functor
        masterGraph[it->first]->setNestedList(functorList);
      }

      // Initialise the printer object with a list of functors that are set to print
      initialisePrinter();

#ifdef HAVE_GRAPHVIZ
      // Generate graphviz plot if running in dry-run mode.
      if (boundCore->show_runorder)
      {
        std::ofstream outf(activeFunctorGraphFile);
        write_graphviz(outf, masterGraph, labelWriter(&masterGraph), edgeWriter(&masterGraph));
      }
#endif

      // Pre-compute the individually ordered vertex lists for each of the ObsLike entries.
      std::vector<VertexID> order = getObsLikeOrder();
      for(auto it = order.begin(); it != order.end(); ++it)
      {
        SortedParentVertices[*it] = getSortedParentVertices(*it, masterGraph, function_order);
      }

      // Done
    }

Here is the call graph for this function:

Here is the caller graph for this function:

fillParQueue()

void Gambit::DRes::DependencyResolver::fillParQueue ( std::queue< QueueEntry > *  parQueue, DRes::VertexID  vertex  )

private

Helper functions/arrays.

Push module function dependencies onto the parameter queue.

Definition at line 1706 of file depresolver.cpp.

References Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::logger(), LOOP_MANAGER_DEPENDENCY, masterGraph, and NORMAL_DEPENDENCY.

Referenced by generateTree().

    {
      // Set the default printing flag for functors to pass to the parQueue constructor.
      bool printme_default = false;

      // Tell the logger what the following messages are about.
      logger() << LogTags::dependency_resolver;

      // Digest capability of loop manager (if defined)
      str lmcap = (*masterGraph[vertex]).loopManagerCapability();
      str lmtype = (*masterGraph[vertex]).loopManagerType();
      if (lmcap != "none")
      {
        logger() << "Adding module function loop manager to resolution queue:" << endl;
        logger() << lmcap << " ()" << endl;
        parQueue->push(QueueEntry(sspair(lmcap, lmtype), vertex, LOOP_MANAGER_DEPENDENCY, printme_default));
      }

      // Digest regular dependencies
      std::set<sspair> s = (*masterGraph[vertex]).dependencies();
      if (s.size() > 0) logger() << "Add dependencies of new module function to queue" << endl;
      for (std::set<sspair>::iterator it = s.begin(); it != s.end(); ++it)
      {
        // If the loop manager requirement exists and is type-specific, it is a true depencency,
        // and thus appears in the output of functor.dependencies(). So, we need to take care
        // not to double-count it for entry into the parQueue.
        if (lmcap == "none" or lmtype == "any" or lmcap != it->first or lmtype != it->second)
        {
          logger() << it->first << " (" << it->second << ")" << endl;
          parQueue->push(QueueEntry(*it, vertex, NORMAL_DEPENDENCY, printme_default));
        }
      }

      // Tell the logger we're done here.
      logger() << EOM;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

findIniEntry() [1/2]

const IniParser::ObservableType * Gambit::DRes::DependencyResolver::findIniEntry ( sspair  quantity, const IniParser::ObservablesType &  entries, const str &  errtag  )

private

Find entries (comparison of inifile entry with quantity or functor)

Find observable entry that matches capability/type.

Definition at line 1779 of file depresolver.cpp.

References Gambit::DRes::capabilityMatchesIniEntry(), Gambit::DRes::dependency_resolver_error(), and LOCAL_INFO.

Referenced by generateTree(), resolveDependency(), resolveVertexBackend(), and solveRequirement().

    {
      std::vector<const IniParser::ObservableType*> obsEntryCandidates;
      for (IniParser::ObservablesType::const_iterator it =
          entries.begin(); it != entries.end(); ++it)
      {
        if ( capabilityMatchesIniEntry(quantity, *it) ) // use same criteria than for normal dependencies
        {
          obsEntryCandidates.push_back(&(*it));
        }
      }
      if ( obsEntryCandidates.size() == 0 ) return NULL;
      else if ( obsEntryCandidates.size() != 1 )
      {
        str errmsg = "Found multiple " + errtag + " entries for ";
        errmsg += quantity.first + " (" + quantity.second + ")";
        dependency_resolver_error().raise(LOCAL_INFO,errmsg);
      }
      return obsEntryCandidates[0]; // obsEntryCandidates.size() == 1
    }

Here is the call graph for this function:

Here is the caller graph for this function:

findIniEntry() [2/2]

const IniParser::ObservableType * Gambit::DRes::DependencyResolver::findIniEntry ( DRes::VertexID  toVertex, const IniParser::ObservablesType &  entries, const str &  errtag  )

private

Find rules entry that matches vertex.

Definition at line 1753 of file depresolver.cpp.

References boundTEs, Gambit::DRes::dependency_resolver_error(), LOCAL_INFO, masterGraph, and Gambit::DRes::moduleFuncMatchesIniEntry().

    {
      std::vector<const IniParser::ObservableType*> auxEntryCandidates;
      for (IniParser::ObservablesType::const_iterator it =
          entries.begin(); it != entries.end(); ++it)
      {
        if ( moduleFuncMatchesIniEntry(masterGraph[toVertex], *it, *boundTEs) and it->capability != "" )
        {
          auxEntryCandidates.push_back(&(*it));
        }
      }
      if ( auxEntryCandidates.size() == 0 ) return NULL;
      else if ( auxEntryCandidates.size() != 1 )
      {
        str errmsg = "Found multiple " + errtag + " entries for ";
        errmsg += masterGraph[toVertex]->capability() +" (" +
            masterGraph[toVertex]->type() + ") [" +
            masterGraph[toVertex]->name() + ", " +
            masterGraph[toVertex]->origin() + "]";
        dependency_resolver_error().raise(LOCAL_INFO, errmsg);
      }
      return auxEntryCandidates[0]; // auxEntryCandidates.size() == 1
    }

Here is the call graph for this function:

generateTree()

void Gambit::DRes::DependencyResolver::generateTree ( std::queue< QueueEntry >  parQueue )

private

Generate full dependency tree.

Set up dependency tree.

Definition at line 1466 of file depresolver.cpp.

References boundCore, boundIniFile, collectIniOptions(), collectSubCaps(), Gambit::core_error(), Gambit::LogTags::dependency_resolver, Gambit::DRes::dependency_resolver_error(), edges_to_force_on_manager, Gambit::EOM, fillParQueue(), findIniEntry(), Gambit::IniParser::IniFile::getObservables(), Gambit::IniParser::IniFile::getRules(), Gambit::IniParser::Parser::getValueOrDef(), Gambit::DRes::OutputVertexInfo::iniEntry, LOCAL_INFO, Gambit::logger(), LOOP_MANAGER_DEPENDENCY, loopManagerMap, masterGraph, OBSLIKE_VERTEXID, Gambit::IniParser::Types::Observable::options, outputVertexInfos, print_timing, print_unitcube, printGenericFunctorList(), printQuantityToBeResolved(), resolveDependency(), resolveDependencyFromRules(), resolveVertexBackend(), Gambit::gambit_core::show_runorder, and Gambit::DRes::OutputVertexInfo::vertex.

Referenced by doResolution().

    {
      OutputVertexInfo outInfo;
      DRes::VertexID fromVertex, toVertex;
      DRes::EdgeID edge;
      // Inifile entry of ObsLike (if relevant)
      const IniParser::ObservableType * iniEntry;
      bool ok;
      sspair quantity;
      int dependency_type;
      bool printme;

      logger() << LogTags::dependency_resolver << endl;
      logger() << "################################################" << endl;
      logger() << "#         Starting dependency resolution       #" << endl;
      logger() << "#                                              #" << endl;
      logger() << "# format: Capability (Type) [Function, Module] #" << endl;
      logger() << "################################################" << EOM;

      // Print something to stdout as well
      #ifdef DEPRES_DEBUG
        std::cout << "Resolving dependency graph..." << std::endl;
      #endif

      // Read ini entries
      use_regex      = boundIniFile->getValueOrDef<bool>(true,  "dependency_resolution", "use_regex");
      print_timing   = boundIniFile->getValueOrDef<bool>(false, "print_timing_data");
      print_unitcube = boundIniFile->getValueOrDef<bool>(false, "print_unitcube");

      if ( use_regex      ) logger() << "Using regex for string comparison." << endl;
      if ( print_timing   ) logger() << "Will output timing information for all functors (via printer system)" << EOM;
      if ( print_unitcube ) logger() << "Printing of unitCubeParameters will be enabled." << EOM;

      //
      // Main loop: repeat until dependency queue is empty
      //

      while (not parQueue.empty())
      {

        // Retrieve capability, type and vertex ID of dependency of interest
        quantity = parQueue.front().first;  // (capability, type) pair
        toVertex = parQueue.front().second;  // dependent vertex
        dependency_type = parQueue.front().third;  // Normal or loop-manager
        printme = parQueue.front().printme;  // bool

        // Print information about required quantity and dependent vertex
        logger() << LogTags::dependency_resolver;
        logger() << "Resolving ";
        logger() << printQuantityToBeResolved(quantity, toVertex) << endl << endl;

        // Check that ObsLike vertices have non-empty capability
        if ( toVertex == OBSLIKE_VERTEXID and quantity.first == "" )
        {
          str errmsg = "ObsLike entry without without capability "
                       "information encountered.\n";
          dependency_resolver_error().raise(LOCAL_INFO,errmsg);
        }

        // Figure out how to resolve dependency
        if ( boundIniFile->getValueOrDef<bool>(false, "dependency_resolution", "use_old_routines") )
        {
          boost::tie(iniEntry, fromVertex) = resolveDependency(toVertex, quantity);
        }
        else
        {
          fromVertex = resolveDependencyFromRules(toVertex, quantity);
        }

        // Print user info.
        logger() << LogTags::dependency_resolver;
        logger() << "Resolved by: [";
        logger() << (*masterGraph[fromVertex]).name() << ", ";
        logger() << (*masterGraph[fromVertex]).origin() << "]" << endl;

        // Check if we wanted to output this observable to the printer system.
        if ( toVertex==OBSLIKE_VERTEXID ) masterGraph[fromVertex]->setPrintRequirement(printme);
        // Check if the flag to output timing data is set
        if(print_timing) masterGraph[fromVertex]->setTimingPrintRequirement(true);

        // Apply resolved dependency to masterGraph and functors
        if ( toVertex != OBSLIKE_VERTEXID )
        {
          // Resolve dependency on functor level...
          //
          // In case the fromVertex is a loop manager, store nested function
          // temporarily in loopManagerMap (they have to be sorted later)
          if (dependency_type == LOOP_MANAGER_DEPENDENCY)
          {
            // Check whether fromVertex is allowed to manage loops
            if (not masterGraph[fromVertex]->canBeLoopManager())
            {
              str errmsg = "Trying to resolve dependency on loop manager with\n"
               "module function that is not declared as loop manager.\n"
               + printGenericFunctorList(initVector<functor*>(masterGraph[fromVertex]));
              dependency_resolver_error().raise(LOCAL_INFO,errmsg);
            }
            std::set<DRes::VertexID> v;
            if (loopManagerMap.count(fromVertex) == 1)
            {
              v = loopManagerMap[fromVertex];
            }
            v.insert(toVertex);
            loopManagerMap[fromVertex] = v;
            (*masterGraph[toVertex]).resolveLoopManager(masterGraph[fromVertex]);

            // Take any dependencies of loop-managed vertices that have already been resolved,
            // and add them as "hidden" dependencies to this loop manager.
            if (edges_to_force_on_manager.find(toVertex) != edges_to_force_on_manager.end())
            {
              for (auto it = edges_to_force_on_manager.at(toVertex).begin();
                   it != edges_to_force_on_manager.at(toVertex).end(); ++it)
              {
                logger() << "Dynamically adding dependency of " << (*masterGraph[fromVertex]).origin()
                         << "::" << (*masterGraph[fromVertex]).name() << " on "
                         << (*masterGraph[*it]).origin() << "::" << (*masterGraph[*it]).name() << endl;
                boost::tie(edge, ok) = add_edge(*it, fromVertex, masterGraph);
              }
            }
          }
          // Default is to resolve dependency on functor level of toVertex
          else
          {
            (*masterGraph[toVertex]).resolveDependency(masterGraph[fromVertex]);
          }
          // ...and on masterGraph level.
          boost::tie(edge, ok) = add_edge(fromVertex, toVertex, masterGraph);

          // In the case that toVertex is a nested function, add fromVertex to
          // the edges of toVertex's loop manager.
          str to_lmcap = (*masterGraph[toVertex]).loopManagerCapability();
          str to_lmtype = (*masterGraph[toVertex]).loopManagerType();
          str from_lmcap = (*masterGraph[fromVertex]).loopManagerCapability();
          str from_lmtype = (*masterGraph[fromVertex]).loopManagerType();
          bool is_same_lmcap = to_lmcap == from_lmcap;
          bool is_same_lmtype = to_lmtype == "any" or from_lmtype == "any" or to_lmtype == from_lmtype;
          if (to_lmcap != "none")
          {
            // This function runs nested.  Check if its loop manager has been resolved yet.
            if ((*masterGraph[toVertex]).loopManagerName() == "none")
            {
              // toVertex's loop manager has not yet been determined.
              // Add the edge to the list to deal with when the loop manager dependency is resolved,
              // as long as toVertex and fromVertex cannot end up inside the same loop.
              if (!is_same_lmcap or !is_same_lmtype)
              {
                if (edges_to_force_on_manager.find(toVertex) == edges_to_force_on_manager.end())
                 edges_to_force_on_manager[toVertex] = std::set<DRes::VertexID>();
                edges_to_force_on_manager.at(toVertex).insert(fromVertex);
              }
            }
            else
            {
              // toVertex's loop manager has already been resolved.
              // If fromVertex is not the manager itself, and is not
              // itself a nested function that has the possibility to
              // end up in the same loop as toVertex, then add
              // fromVertex as an edge of the manager.
              str name = (*masterGraph[toVertex]).loopManagerName();
              str origin = (*masterGraph[toVertex]).loopManagerOrigin();
              bool is_itself = (name == (*masterGraph[fromVertex]).name() and origin == (*masterGraph[fromVertex]).origin());
              if (!is_itself and (!is_same_lmcap or !is_same_lmtype) )
              {
                // Hunt through the edges of toVertex and find the one that corresponds to its loop manager.
                graph_traits<DRes::MasterGraphType>::in_edge_iterator ibegin, iend;
                boost::tie(ibegin, iend) = in_edges(toVertex, masterGraph);
                if (ibegin != iend)
                {
                  DRes::VertexID managerVertex;
                  for (; ibegin != iend; ++ibegin)
                  {
                    managerVertex = source(*ibegin, masterGraph);
                    if ((*masterGraph[managerVertex]).name() == name and
                        (*masterGraph[managerVertex]).origin() == origin) break;
                  }
                  logger() << "Dynamically adding dependency of " << (*masterGraph[managerVertex]).origin()
                           << "::" << (*masterGraph[managerVertex]).name() << " on "
                           << (*masterGraph[fromVertex]).origin() << "::" << (*masterGraph[fromVertex]).name() << endl;
                  boost::tie(edge, ok) = add_edge(fromVertex, managerVertex, masterGraph);
                }
                else
                {
                  core_error().raise(LOCAL_INFO, "toVertex has no edges! So its loop manager hasn't been added as a dependency?!");
                }
              }
            }
          }
        }
        else // if output vertex
        {
          iniEntry = findIniEntry(quantity, boundIniFile->getObservables(), "ObsLike");
          outInfo.vertex = fromVertex;
          outInfo.iniEntry = iniEntry;
          outputVertexInfos.push_back(outInfo);
          // Don't need subcaps during dry-run
          if (not boundCore->show_runorder)
          {
            Options mySubCaps = collectSubCaps(fromVertex);
            masterGraph[fromVertex]->notifyOfSubCaps(mySubCaps);
          }
        }

        // If fromVertex is new, activate it
        if ( (*masterGraph[fromVertex]).status() != 2 )
        {
          logger() << LogTags::dependency_resolver << "Activate new module function" << endl;
          masterGraph[fromVertex]->setStatus(2); // activate node
          resolveVertexBackend(fromVertex);

          // Don't need options during dry-run, so skip this (just to simplify terminal output)
          if(not boundCore->show_runorder)
          {
            if ( boundIniFile->getValueOrDef<bool>( false, "dependency_resolution", "use_old_routines") )
            {
              // Generate options object from ini-file entry that corresponds to
              // fromVertex (overwrite iniEntry) and pass it to the fromVertex for later use
              iniEntry = findIniEntry(fromVertex, boundIniFile->getRules(), "Rules");
              if ( iniEntry != NULL )
              {
                Options myOptions(iniEntry->options);
                masterGraph[fromVertex]->notifyOfIniOptions(myOptions);
              }
            }
            else
            {
              Options myOptions = collectIniOptions(fromVertex);
              masterGraph[fromVertex]->notifyOfIniOptions(myOptions);
            }
          }
          // Fill parameter queue with dependencies of fromVertex
          fillParQueue(&parQueue, fromVertex);
        }

        // Done.
        logger() << EOM;
        parQueue.pop();
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_functor()

functor * Gambit::DRes::DependencyResolver::get_functor

(

VertexID

id

)

Get the functor corresponding to a single VertexID.

Definition at line 689 of file depresolver.cpp.

References masterGraph.

Referenced by Gambit::Likelihood_Container::main().

    {
      graph_traits<DRes::MasterGraphType>::vertex_iterator vi, vi_end;
      for (boost::tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        if (*vi == id) return masterGraph[id];
      }
      return NULL;
    }

Here is the caller graph for this function:

getIniEntry()

const IniParser::ObservableType * Gambit::DRes::DependencyResolver::getIniEntry

(

VertexID

v

)

Definition at line 731 of file depresolver.cpp.

References outputVertexInfos.

Referenced by Gambit::Likelihood_Container::Likelihood_Container().

    {
      for (std::vector<OutputVertexInfo>::iterator it = outputVertexInfos.begin();
          it != outputVertexInfos.end(); it++)
      {
        if (it->vertex == v)
          return it->iniEntry;
      }
      return NULL;
    }

Here is the caller graph for this function:

getObsLike()

template<typename TYPE >

TYPE Gambit::DRes::DependencyResolver::getObsLike ( VertexID  vertex )

inline

Return the result of a functor.

Definition at line 155 of file depresolver.hpp.

References Gambit::core_error(), combine_hdf5::group, LOCAL_INFO, and Gambit::functor::origin().

Referenced by Gambit::Likelihood_Container::main().

        {
          module_functor<TYPE>* module_ptr = dynamic_cast<module_functor<TYPE>*>(masterGraph[vertex]);
          if (module_ptr == NULL)
          {
            str msg = "Attempted to retrieve result of " + masterGraph[vertex]->origin() + "::" +
                      masterGraph[vertex]->name() + "\nwith incorrect type.  The type should be: " +
                      masterGraph[vertex]->type() + ".";
            core_error().raise(LOCAL_INFO, msg);
          }
          // This always accesses the 0-index result, which is the one-thread result
          // or the 'final result' when more than one thread has run the functor.
          return (*module_ptr)(0);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

getObsLikeOrder()

std::vector< VertexID > Gambit::DRes::DependencyResolver::getObsLikeOrder

(

)

Retrieve the order in which target vertices are to be evaluated.

Definition at line 580 of file depresolver.cpp.

References Gambit::LogTags::dependency_resolver, double, Gambit::EOM, Gambit::DRes::getParentVertices(), Gambit::DRes::getTimeEstimate(), Gambit::logger(), masterGraph, and outputVertexInfos.

Referenced by doResolution(), Gambit::Likelihood_Container::Likelihood_Container(), and printFunctorEvalOrder().

    {
      std::vector<VertexID> unsorted;
      std::vector<VertexID> sorted;
      std::set<VertexID> parents, colleages, colleages_min;
      // Copy unsorted vertexIDs --> unsorted
      for (std::vector<OutputVertexInfo>::iterator it = outputVertexInfos.begin();
          it != outputVertexInfos.end(); it++)
      {
        unsorted.push_back(it->vertex);
      }
      // Sort iteratively (unsorted --> sorted)
      while (unsorted.size() > 0)
      {
        double t2p_now;
        double t2p_min = -1;
        std::vector<VertexID>::iterator it_min;
        for (std::vector<VertexID>::iterator it = unsorted.begin(); it !=
            unsorted.end(); ++it)
        {
          parents.clear();
          getParentVertices(*it, masterGraph, parents);
          parents.insert(*it);
          // Remove vertices that were already calculated from the ist
          for ( auto cit = colleages.begin(); cit != colleages.end(); cit++)
          {
            parents.erase(*cit);
          }
          t2p_now = (double) getTimeEstimate(parents, masterGraph);
          t2p_now /= masterGraph[*it]->getInvalidationRate();
          if (t2p_min < 0 or t2p_now < t2p_min)
          {
            t2p_min = t2p_now;
            it_min = it;
            colleages_min = parents;
          }
        }
        // Extent list of calculated vertices
        colleages.insert(colleages_min.begin(), colleages_min.end());
        double prop = masterGraph[*it_min]->getInvalidationRate();
        logger() << LogTags::dependency_resolver << "Estimated T [s]: " << t2p_min*prop << EOM;
        logger() << LogTags::dependency_resolver << "Estimated p: " << prop << EOM;
        sorted.push_back(*it_min);
        unsorted.erase(it_min);
      }
      return sorted;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

initialisePrinter()

void Gambit::DRes::DependencyResolver::initialisePrinter ( )

private

Initialise the printer object with a list of functors for it to expect to be printed.

Set up printer object.

Definition at line 873 of file depresolver.cpp.

References boundPrinter, Gambit::Printers::get_param_id(), index, masterGraph, and print_unitcube.

Referenced by doResolution().

    {
      // Send the state of the "print_unitcube" flag to the printer
      boundPrinter->set_printUnitcube(print_unitcube);

      std::vector<int> functors_to_print;
      graph_traits<MasterGraphType>::vertex_iterator vi, vi_end;
      //IndexMap index = get(vertex_index, masterGraph); // Now done in the constructor
      //Err does that make sense? There is nothing in masterGraph at that point surely... maybe put this back.
      //Ok well it does seem to work in the constructor, not sure why though...

      for (boost::tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        // Inform the active functors of the vertex ID that the masterGraph has assigned to them
        // (so that later on they can pass this to the printer object to identify themselves)
        //masterGraph[*vi]->setVertexID(index[*vi]); // Ugh cannot do this, needs to be consistent with get_param_id
        std::string label = masterGraph[*vi]->label();
        masterGraph[*vi]->setVertexID(Printers::get_param_id(label));
        // Same for timing output ID, but get ID number from printer system
        std::string timing_label = masterGraph[*vi]->timingLabel();
        masterGraph[*vi]->setTimingVertexID(Printers::get_param_id(timing_label));

        // Check for non-void type and status==2 (after the dependency resolution) to print only active, printable functors.
        // TODO: this doesn't currently check for non-void type; that is done at the time of printing in calcObsLike.
        if( masterGraph[*vi]->requiresPrinting() and (masterGraph[*vi]->status()==2) )
        {
          functors_to_print.push_back(index[*vi]); // TODO: Probably obsolete
          boundPrinter->addToPrintList(label); // Needed mainly by postprocessor.
          // Trigger a dummy print call for all printable functors. This is used by some printers
          // to set up buffers for each of these output streams.
          //logger() << LogTags::dependency_resolver << "Triggering dummy print for functor '"<<masterGraph[*vi]->capability()<<"' ("<<masterGraph[*vi]->type()<<")..." << EOM;

          //masterGraph[*vi]->print(boundPrinter,-1);
        }
      }

      // Force-reset the printer to erase the dummy calls
      // (but don't do this if we are in resume mode!)
      //if(not boundCore->resume) boundPrinter->reset(true);
      //boundPrinter->reset(true); // Actually *do* do it in resume mode as well. Printers should only reset new data, not destroy old data.

      // sent vector of ID's of functors to be printed to printer.
      // (if we want to only print functor output sometimes, and dynamically
      // switch this on and off, we'll have to rethink the strategy here a
      // little... for now if the print function of a functor does not get
      // called, it is up to the printer how it deals with the missing result.
      // Similarly for extra results, i.e. from any functors not in this
      // initial list, whose "requiresPrinting" flag later gets set to 'true'
      // somehow.)
      boundPrinter->initialise(functors_to_print); // TODO: Probably obsolete
    }

Here is the call graph for this function:

Here is the caller graph for this function:

invalidatePointAt()

void Gambit::DRes::DependencyResolver::invalidatePointAt	(	VertexID	vertex,
		bool	isnan
	)

Definition at line 718 of file depresolver.cpp.

References masterGraph.

Referenced by Gambit::Likelihood_Container::main().

    {
      if (isnan)
      {
        masterGraph[vertex]->notifyOfInvalidation("NaN returned for likelihood value.");
      }
      else
      {
        masterGraph[vertex]->notifyOfInvalidation("Cumulative log-likelihood pushed below threshold.");
      }
    }

Here is the caller graph for this function:

makeFunctorsModelCompatible()

void Gambit::DRes::DependencyResolver::makeFunctorsModelCompatible ( )

private

Deactivate functors that are not allowed to be used with the model(s) being scanned.

Activate functors that are allowed to be used with one or more of the models being scanned.

Also activate the model-conditional dependencies and backend requirements of those functors.

Definition at line 833 of file depresolver.cpp.

References boundClaw, boundCore, Gambit::Models::ModelFunctorClaw::get_activemodels(), Gambit::gambit_core::getBackendFunctors(), and masterGraph.

Referenced by doResolution(), and printFunctorList().

    {
      // Run just once
      static bool already_run = false;
      if (already_run) return;

      graph_traits<DRes::MasterGraphType>::vertex_iterator vi, vi_end;
      std::vector<functor *>::const_iterator fi, fi_end = boundCore->getBackendFunctors().end();
      std::set<str> modelList = boundClaw->get_activemodels();

      // Activate those module functors that match the combination of models being scanned.
      for (boost::tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        if (masterGraph[*vi]->status() >= 0 and masterGraph[*vi]->modelComboAllowed(modelList))
        {
          for (std::set<str>::iterator it = modelList.begin(); it != modelList.end(); ++it)
          {
            masterGraph[*vi]->notifyOfModel(*it);
            masterGraph[*vi]->setStatus(1);
          }
        }
      }

      // Activate those backend functors that match one of the models being scanned.
      for (std::set<str>::iterator it = modelList.begin(); it != modelList.end(); ++it)
      {
        for (fi = boundCore->getBackendFunctors().begin(); fi != fi_end; ++fi)
        {
          // Activate if the backend vertex permits the model and has not been (severely) disabled by the backend system
          if ( (*fi)->status() >= 0 and (*fi)->modelAllowed(*it) )
          {
            (*fi)->setStatus(1);
          }
        }
      }
      already_run = true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printFunctorEvalOrder()

void Gambit::DRes::DependencyResolver::printFunctorEvalOrder

(

bool

toterminal = false

)

Pretty print function evaluation order.

Definition at line 445 of file depresolver.cpp.

References activeFunctorGraphFile, Gambit::LogTags::dependency_resolver, Gambit::EOM, getObsLikeOrder(), Gambit::DRes::getParentVertices(), Gambit::logger(), and masterGraph.

Referenced by main().

    {
      // Running this lets us check the order of execution. Also helps
      // to verify that we actually have pointers to all the required
      // functors.

      // Get order of evaluation
      std::set<VertexID> parents;
      std::set<VertexID> done; //set of vertices already accounted for
      std::vector<VertexID> order = getObsLikeOrder();

      str formatString  = "%-5s %-25s %-25s %-25s\n";
      // Might need to check if terminal supports unicode characters...
      str formatString0 = "%-7s %-23s %-25s %-25s %-25s %-6s\n";  // header
      str formatString1a= "%-9s %-21s %-25s %-25s %-25s %-6s\n";  // target functors
      str formatString1b= "%-4s \u2514\u2500\u2500> %-21s %-25s %-25s %-25s %-6s\n";  // target functors
      str formatString2a= "     \u250C\u2500 %-23s %-25s %-25s %-25s %-6s\n";  // parents
      str formatString2b= "     \u251C\u2500 %-23s %-25s %-25s %-25s %-6s\n";
      str formatString3a= "     \u250CX %-23s %-25s %-25s %-25s %-6s\n"; // "already done" parents
      str formatString3b= "     \u251CX %-23s %-25s %-25s %-25s %-6s\n";

      int i = 0;

      // Show the order in which the target functors will be attacked.
      std::ostringstream ss;
      ss << endl << "Initial target functor evaluation order" << endl;
      ss << "----------------------------------" << endl;
      ss << boost::format(formatString)% "#"% "FUNCTION"% "CAPABILITY"% "ORIGIN";

      for (std::vector<VertexID>::const_iterator
                  vi  = order.begin();
                  vi != order.end(); ++vi)
      {
        ss << boost::format(formatString)%
         i%
         (*masterGraph[*vi]).name()%
         (*masterGraph[*vi]).capability()%
         (*masterGraph[*vi]).origin();
        i++;
      }

      ss << endl;

      i = 0; // Reset counter
      // Do another loop to show the full initial sequence of functor evaluation
      // This doesn't figure out the sequence within each target functor group; I'm not 100% sure where that is determined. This does, however, show which groups get evaluated first, and which functors are already evaluated.
      ss << endl << "Full initial functor evaluation order" << endl;
      ss << "----------------------------------" << endl;
      ss << boost::format(formatString0)% "#"% "FUNCTION"% "CAPABILITY"% "TYPE"% "ORIGIN"% "PRINT?";

      for (std::vector<VertexID>::const_iterator
                  vi  = order.begin();
                  vi != order.end(); ++vi)
      {
        // loop through parents of each target functor
        parents.clear();
        getParentVertices(*vi, masterGraph, parents);
        parents.insert(*vi);
        bool first = true;
        for (std::set<VertexID>::const_iterator
                  vi2  = parents.begin();
                  vi2 != parents.end(); ++vi2)
        {
            str formatstr;
            bool dowrite = false;
            // Check if parent functor has been ticked off the list
            bool is_done = done.find(*vi2) != done.end();
            if( (not is_done) and (*vi != *vi2) )
            {
                formatstr = formatString2b;
                if (first) formatstr = formatString2a;
                dowrite = true;
            }
            else if( *vi != *vi2)
            {
                // Might be better to just do nothing here, i.e. set dowrite=false. For now just flagging functor as done with a special format string.
                formatstr = formatString3b;
                if (first) formatstr = formatString3a;
                dowrite = true;
            }

            if (dowrite)
            {
              ss << boost::format(formatstr)%
                (*masterGraph[*vi2]).name()%
                (*masterGraph[*vi2]).capability()%
                (*masterGraph[*vi2]).type()%
                (*masterGraph[*vi2]).origin()%
                (*masterGraph[*vi2]).requiresPrinting();
            }
            done.insert(*vi2); // tick parent functor off the list
            first = false;
        }

        // Now show target functor info
        str formatstr;
        if(parents.size()==1) { formatstr = formatString1a; }
        else { formatstr = formatString1b; }
        ss << boost::format(formatstr)%
         i%
         (*masterGraph[*vi]).name()%
         (*masterGraph[*vi]).capability()%
         (*masterGraph[*vi]).type()%
         (*masterGraph[*vi]).origin()%
         (*masterGraph[*vi]).requiresPrinting();
        i++;

        done.insert(*vi); // tick this target functor off the list

      }
      ss << "(\"X\" indicates that the functor is pre-evaluated before the marked position)" << endl << endl;

      if (toterminal)
      {
        // There is a command line flag to get this information, since it is very
        // handy to check before launching a full job. It can always be checked via
        // the logs, but this feature is more convenient.
        cout << ss.str();
        #ifdef HAVE_GRAPHVIZ
          cout << "To get postscript plot of active functors, please run: " << endl;
          cout << GAMBIT_DIR << "/Core/scripts/./graphviz.sh " << activeFunctorGraphFile << " no-loners" << endl;
        #else
          cout << "To get postscript plot of active functors, please install graphviz, rerun cmake and remake GAMBIT." << endl << endl;
        #endif
      }

      logger() << LogTags::dependency_resolver << ss.str() << EOM;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printFunctorList()

void Gambit::DRes::DependencyResolver::printFunctorList

(

)

Pretty print module functor information.

List of masterGraph content.

Definition at line 415 of file depresolver.cpp.

References boundCore, Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::gambit_core::getBackendFunctors(), Gambit::logger(), makeFunctorsModelCompatible(), masterGraph, and printGenericFunctorList().

Referenced by main().

    {
      // Activate functors compatible with model we scan over (and deactivate the rest)
      makeFunctorsModelCompatible();

      graph_traits<DRes::MasterGraphType>::vertex_iterator vi, vi_end;
      const str formatString = "%-20s %-32s %-32s %-32s %-15s %-7i %-5i %-5i\n";
      logger() << LogTags::dependency_resolver << endl << "Vertices registered in masterGraph" << endl;
      logger() << "----------------------------------" << endl;
      logger() << boost::format(formatString)%
       "MODULE (VERSION)"% "FUNCTION"% "CAPABILITY"% "TYPE"% "PURPOSE"% "STATUS"% "#DEPs"% "#BE_REQs";
      for (boost::tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        logger() << boost::format(formatString)%
         ((*masterGraph[*vi]).origin() + " (" + (*masterGraph[*vi]).version() + ")") %
         (*masterGraph[*vi]).name()%
         (*masterGraph[*vi]).capability()%
         (*masterGraph[*vi]).type()%
         (*masterGraph[*vi]).purpose()%
         (*masterGraph[*vi]).status()%
         (*masterGraph[*vi]).dependencies().size()%
         (*masterGraph[*vi]).backendreqs().size();
      }
      logger() <<  "Registered Backend vertices" << endl;
      logger() <<  "---------------------------" << endl;
      logger() << printGenericFunctorList(boundCore->getBackendFunctors());
      logger() << EOM;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printGenericFunctorList() [1/2]

str Gambit::DRes::DependencyResolver::printGenericFunctorList ( const std::vector< functor *> &  functorList )

private

Pretty print backend functor information.

Definition at line 784 of file depresolver.cpp.

Referenced by generateTree(), printFunctorList(), printGenericFunctorList(), resolveDependencyFromRules(), and solveRequirement().

    {
      const str formatString = "%-20s %-32s %-48s %-32s %-7i\n";
      std::ostringstream stream;
      stream << boost::format(formatString)%"ORIGIN (VERSION)"% "FUNCTION"% "CAPABILITY"% "TYPE"% "STATUS";
      for (std::vector<functor *>::const_iterator
          it  = functorList.begin();
          it != functorList.end();
          ++it)
      {
        stream << boost::format(formatString)%
         ((*it)->origin() + " (" + (*it)->version() + ")") %
         (*it)->name()%
         (*it)->capability()%
         (*it)->type()%
         (*it)->status();
      }
      return stream.str();
    }

Here is the caller graph for this function:

printGenericFunctorList() [2/2]

str Gambit::DRes::DependencyResolver::printGenericFunctorList ( const std::vector< VertexID > &  vertexIDs )

private

Definition at line 773 of file depresolver.cpp.

References masterGraph, and printGenericFunctorList().

    {
        std::vector<functor*> functorList;
        for ( auto it = vertexIDs.begin(); it != vertexIDs.end(); ++it )
        {
            functorList.push_back(masterGraph[*it]);
        }
        return printGenericFunctorList(functorList);
    }

Here is the call graph for this function:

printObsLike()

void Gambit::DRes::DependencyResolver::printObsLike	(	VertexID	vertex,
		const int	pointID
	)

Print a single target vertex.

Definition at line 656 of file depresolver.cpp.

References boundPrinter, boundTEs, Gambit::core_error(), Gambit::LogTags::debug, Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::LogTags::info, LOCAL_INFO, Gambit::logger(), masterGraph, SortedParentVertices, and Gambit::DRes::typeComp().

Referenced by Gambit::Likelihood_Container::main().

    {
      // pointID is supplied by the scanner, and is used to tell the printer which model
      // point the results should be associated with.

      if (SortedParentVertices.find(vertex) == SortedParentVertices.end())
        core_error().raise(LOCAL_INFO, "Tried to calculate a function not in or not at top of dependency graph.");
      std::vector<VertexID> order = SortedParentVertices.at(vertex);

      for (std::vector<VertexID>::iterator it = order.begin(); it != order.end(); ++it)
      {
        std::ostringstream ss;
        ss << "Printing " << masterGraph[*it]->name() << " from " << masterGraph[*it]->origin() << "...";
        logger() << LogTags::dependency_resolver << LogTags::info << LogTags::debug << ss.str() << EOM;

        if (not typeComp(masterGraph[*it]->type(),  "void", *boundTEs, false))
        {
          // Note that this prints from thread index 0 only, i.e. results created by
          // threads other than the main one need to be accessed with
          //   masterGraph[*it]->print(boundPrinter,pointID,index);
          // where index is some integer s.t. 0 <= index <= number of hardware threads.
          // At the moment GAMBIT only prints results of thread 0, under the expectation
          // that nested module functions are all designed to gather their results into
          // thread 0.
          masterGraph[*it]->print(boundPrinter,pointID);
        }
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printQuantityToBeResolved()

str Gambit::DRes::DependencyResolver::printQuantityToBeResolved ( const sspair &  quantity, const DRes::VertexID &  vertex  )

private

Print quantity to be resolved.

Definition at line 757 of file depresolver.cpp.

References masterGraph, and OBSLIKE_VERTEXID.

Referenced by generateTree(), and resolveDependencyFromRules().

    {
        str s = quantity.first + " (" + quantity.second + ")";
        s += ", required by ";
        if ( vertex != OBSLIKE_VERTEXID )
        {
            s += (*masterGraph[vertex]).capability() + " (";
            s += (*masterGraph[vertex]).type() + ") [";
            s += (*masterGraph[vertex]).name() + ", ";
            s += (*masterGraph[vertex]).origin() + "]";
        }
        else
            s += "Core";
        return s;
    }

Here is the caller graph for this function:

printTiming()

bool Gambit::DRes::DependencyResolver::printTiming

(

)

Getter for print_timing flag (used by LikelihoodContainer)

Definition at line 686 of file depresolver.cpp.

References print_timing.

Referenced by Gambit::Likelihood_Container::main().

{ return print_timing; }

Here is the caller graph for this function:

resetAll()

void Gambit::DRes::DependencyResolver::resetAll

(

)

Definition at line 743 of file depresolver.cpp.

References masterGraph.

Referenced by Gambit::Likelihood_Container::main().

    {
      graph_traits<DRes::MasterGraphType>::vertex_iterator vi, vi_end;
      for (boost::tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        if (masterGraph[*vi]->status() == 2) masterGraph[*vi]->reset();
      }
    }

Here is the caller graph for this function:

resolveDependency()

boost::tuple< const IniParser::ObservableType *, DRes::VertexID > Gambit::DRes::DependencyResolver::resolveDependency ( DRes::VertexID  toVertex, sspair  quantity  )

private

Resolution of individual module function dependencies.

Resolve dependency.

Definition at line 1332 of file depresolver.cpp.

References boundClaw, boundIniFile, boundTEs, Gambit::DRes::dependency_resolver_error(), findIniEntry(), Gambit::IniParser::Types::Observable::function, Gambit::Models::ModelFunctorClaw::get_activemodels(), Gambit::Models::ModelFunctorClaw::get_parent(), Gambit::IniParser::IniFile::getObservables(), Gambit::IniParser::IniFile::getRules(), Gambit::IniParser::Parser::getValueOrDef(), LOCAL_INFO, masterGraph, Gambit::IniParser::Types::Observable::module, Gambit::DRes::moduleFuncMatchesIniEntry(), OBSLIKE_VERTEXID, Gambit::DRes::stringComp(), and Gambit::DRes::typeComp().

Referenced by generateTree().

    {
      graph_traits<DRes::MasterGraphType>::vertex_iterator vi, vi_end;
      const IniParser::ObservableType *auxEntry = NULL;  // Ptr. on ini-file entry of the dependent vertex (if existent)
      const IniParser::ObservableType *depEntry = NULL;  // Ptr. on ini-file entry that specifies how to resolve 'quantity'
      std::vector<DRes::VertexID> vertexCandidates;
      bool entryExists = false;  // Ini-file entry to resolve 'quantity' found?

      // First, we check whether the dependent vertex has a unique
      // correspondence in the inifile. Final (output) vertices have to be
      // treated different from all other vertices, since they do not appear
      // as dependencies in the rules section of the inifile. For them,
      // we just use the entry from the observable/likelihood section for the
      // resolution of ambiguities.  A pointer to the relevant inifile entry
      // is stored in depEntry.
      if ( toVertex == OBSLIKE_VERTEXID )
      {
        depEntry = findIniEntry(quantity, boundIniFile->getObservables(), "ObsLike");
        entryExists = true;
      }
      // for all other vertices use the rules entries
      else
      {
        auxEntry = findIniEntry(toVertex, boundIniFile->getRules(), "Rules");
        if ( auxEntry != NULL )
          depEntry = findIniEntry(quantity, (*auxEntry).dependencies, "dependency");
        if ( auxEntry != NULL and depEntry != NULL )
        {
          entryExists = true;
        }
      }

      // Loop over all available vertices in masterGraph, and make a list of
      // functors that fulfill the dependency requirement.
      for (tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        // Don't allow resolution by deactivated functors
        if (masterGraph[*vi]->status() > 0)
        {
          // Without inifile entry, just match capabilities and types (no type
          // comparison when no types are given; this should only happen for
          // output nodes)
          if ( ( stringComp(masterGraph[*vi]->capability(), quantity.first) and
                 ( quantity.second == "" or quantity.second == "*" or
                   typeComp(masterGraph[*vi]->type(), quantity.second, *boundTEs, false) ) )
          // with inifile entry, we check capability, type, function name and
          // module name.
            and ( entryExists ? moduleFuncMatchesIniEntry(masterGraph[*vi], *depEntry, *boundTEs) : true ) )
          {
            // Add to vertex candidate list
            vertexCandidates.push_back(*vi);
          }
        }
      }

      // Die if there is no way to fulfill this dependency.
      if ( vertexCandidates.size() == 0 )
      {
        if ( not entryExists )
        {
            str errmsg = "I could not find any module function that provides ";
            errmsg += quantity.first + " (" + quantity.second + ")"
                +  "\nCheck your inifile for typos, your modules for consistency, etc.";
            dependency_resolver_error().raise(LOCAL_INFO,errmsg);
        }
        else
        {
            str errmsg = "I could not find any module function that provides ";
            errmsg += quantity.first + " (" + quantity.second + ") ["
                + depEntry->function + ", " + depEntry->module + "]"
                +  "\nCheck your inifile for typos, your modules for consistency, etc.";
            dependency_resolver_error().raise(LOCAL_INFO,errmsg);
        }
      }

      // In case of doubt (and if not explicitely disabled in the ini-file), prefer functors
      // that are more specifically tailored for the model being scanned. Do not consider functors
      // that are accessible via INTERPRET_AS_X links, as these are all considered to be equally 'far'
      // from the model being scanned, with the 'distance' being one step further than the most distant
      // ancestor.
      if ( vertexCandidates.size() > 1 and boundIniFile->getValueOrDef<bool>(true, "dependency_resolution", "prefer_model_specific_functions") )
      {
        // Work up the model ancestry one step at a time, and stop as soon as one or more valid model-specific functors is
        // found at a given level in the hierarchy.
        std::vector<DRes::VertexID> newVertexCandidates;
        std::set<str> s = boundClaw->get_activemodels();
        std::vector<str> parentModelList(s.begin(), s.end());
        while (newVertexCandidates.size() == 0 and not parentModelList.empty())
        {
          for (std::vector<str>::iterator mit = parentModelList.begin(); mit != parentModelList.end(); ++mit)
          {
            // Test each vertex candidate to see if it has been explicitly set up to work with the model *mit
            for (std::vector<DRes::VertexID>::iterator it = vertexCandidates.begin(); it != vertexCandidates.end(); ++it)
            {
              if ( masterGraph[*it]->modelExplicitlyAllowed(*mit) ) newVertexCandidates.push_back(*it);
            }
            // Step up a level in the model hierarchy for this model.
            *mit = boundClaw->get_parent(*mit);
          }
          parentModelList.erase(std::remove(parentModelList.begin(), parentModelList.end(), "none"), parentModelList.end());
        }
        if (newVertexCandidates.size() != 0) vertexCandidates = newVertexCandidates;
      }

      if ( vertexCandidates.size() > 1 )
      {
        str errmsg = "";
        if ( not entryExists )
        {
            errmsg += "I found too many module functions that provide ";
            errmsg += quantity.first + " (" + quantity.second + ")"
                +  "\nCheck your inifile for typos, your modules for consistency, etc.";
        }
        else
        {
            errmsg += "I found too many module functions that provide ";
            errmsg += quantity.first + " (" + quantity.second + ") \n"
                + "\nneeded by " + depEntry->module + "::" + depEntry->function
                +  "\nCheck your inifile for typos, your modules for consistency, etc.";
        }
        if (not boundIniFile->getValueOrDef<bool>(true, "dependency_resolution", "prefer_model_specific_functions"))
         errmsg += "\nAlso consider turning on prefer_model_specific_functions in your inifile.";
        errmsg += "\nCandidate module functions are:";
        for (std::vector<DRes::VertexID>::iterator it = vertexCandidates.begin(); it != vertexCandidates.end(); ++it)
        {
            errmsg += "\n   [" + masterGraph[*it]->name() + "," + masterGraph[*it]->origin() + "]";
        }
        dependency_resolver_error().raise(LOCAL_INFO,errmsg);
      }

      return boost::tie(depEntry, vertexCandidates[0]);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveDependencyFromRules()

DRes::VertexID Gambit::DRes::DependencyResolver::resolveDependencyFromRules ( const DRes::VertexID &  toVertex, const sspair &  quantity  )

private

Resolution of individual module function dependencies.

Resolve dependency.

Definition at line 1071 of file depresolver.cpp.

References boundIniFile, boundTEs, closestCandidateForModel(), Gambit::LogTags::dependency_resolver, Gambit::DRes::dependency_resolver_error(), Gambit::EOM, Gambit::IniParser::IniFile::getObservables(), Gambit::IniParser::IniFile::getRules(), Gambit::IniParser::Parser::getValueOrDef(), LOCAL_INFO, Gambit::logger(), masterGraph, Gambit::DRes::matchesRules(), Gambit::DRes::moduleFuncMatchesIniEntry(), OBSLIKE_VERTEXID, printGenericFunctorList(), printQuantityToBeResolved(), Gambit::DRes::quantityMatchesIniEntry(), Gambit::DRes::stringComp(), and Gambit::DRes::typeComp().

Referenced by generateTree().

    {
      graph_traits<DRes::MasterGraphType>::vertex_iterator vi, vi_end;

      // List of candidate vertices
      std::vector<DRes::VertexID> vertexCandidates;  // enabled
      std::vector<DRes::VertexID> disabledVertexCandidates;  // disabled
      // Rules
      std::vector<Rule> rules;
      std::vector<Rule> strong_rules;
      // Candidate vertices after applying rules
      std::vector<DRes::VertexID> filteredVertexCandidates;
      std::vector<DRes::VertexID> filteredVertexCandidates2;

      // Make list of candidate vertices.
      for (tie(vi, vi_end) = vertices(masterGraph); vi != vi_end; ++vi)
      {
        // Match capabilities and types (no type comparison when no types are
        // given; this can only apply to output nodes or loop managers).
        if ( stringComp(masterGraph[*vi]->capability(), quantity.first) and
             *vi != toVertex and // No self-resolution
             ( quantity.second == "" or quantity.second == "*" or quantity.second == "any" or
               typeComp(masterGraph[*vi]->type(), quantity.second, *boundTEs, false) ) )
        {
          // Add vertex to appropriate candidate list
          if (masterGraph[*vi]->status() > 0)
            vertexCandidates.push_back(*vi);
          else
            disabledVertexCandidates.push_back(*vi);
        }
      }
      if (vertexCandidates.size() == 0)
      {
        std::ostringstream errmsg;
        errmsg << "No candidates found while trying to resolve:" << endl;
        errmsg << printQuantityToBeResolved(quantity, toVertex) << endl;
        if (disabledVertexCandidates.size() != 0)
        {
          errmsg << "\nNote that viable candidates exist but have been disabled:\n"
                 << printGenericFunctorList(disabledVertexCandidates)
                 << endl
          << "Status flags:" << endl
          << " 0: This function is not compatible with any model you are scanning." << endl
          << "-3: This function requires a BOSSed class that is missing. The " << endl
          << "    backend that provides the class is missing (most likely), the " << endl
          << "    class is missing from the backend, or the factory functions" << endl
          << "    for this class have not been BOSSed and loaded correctly." << endl;
        }
        errmsg << "Please check your yaml file for typos, and make sure that the" << endl
        << "models you are scanning are compatible with at least one function" << endl
        << "that provides this capability (they may all have been deactivated" << endl
        << "due to having ALLOW_MODELS declarations which are" << endl
        << "incompatible with the models selected for scanning)." << endl;
        dependency_resolver_error().raise(LOCAL_INFO,errmsg.str());
      }

      logger() << LogTags::dependency_resolver;
      logger() << "List of candidate vertices:" << endl;
      logger() << printGenericFunctorList(vertexCandidates) << EOM;

      if (toVertex != OBSLIKE_VERTEXID)
      {
        // Make list of all relevant 1st and 2nd level dependency rules.
        const IniParser::ObservablesType & entries = boundIniFile->getRules();
        for (IniParser::ObservablesType::const_iterator
            it = entries.begin(); it != entries.end(); ++it)
        {
          {
            // Evaluate "dependencies" section
            if (moduleFuncMatchesIniEntry(masterGraph[toVertex], *it, *boundTEs) and
                (it->capability != "" or it->function != "" or
                 it->type != "" or it->module != ""))
            {
              for (IniParser::ObservablesType::const_iterator
                  it2 = (*it).dependencies.begin();
                  it2 != (*it).dependencies.end(); ++it2)
              {
                if (quantityMatchesIniEntry(quantity, *it2, *boundTEs) and
                    (it2->capability != "" or it2->type != "") and
                    (it2->function != "" or it2->module != ""))
                {
                  rules.push_back(Rule(*it2));
                  if (not it->weakrule and not it2->weakrule)
                    strong_rules.push_back(Rule(*it2));
                }
              }
            }
            // Evaluate "functionChain:" section
            if (moduleFuncMatchesIniEntry(masterGraph[toVertex], *it, *boundTEs) and
                it->capability != "" and
                it->function == "" and
                (*it).functionChain.size() > 1)
            {
              for (auto it2 = (*it).functionChain.begin();
                  it2 != (*it).functionChain.end() - 1; ++it2)
              {
                if ((*it2) == masterGraph[toVertex]->name())
                {
                  Rule rule(*(it2+1), masterGraph[toVertex]->origin());
                  rules.push_back(rule);
                  if (not it->weakrule)
                    strong_rules.push_back(rule);
                }
              }
            }
            // Evaluate second order rules
            if (quantityMatchesIniEntry(quantity, *it, *boundTEs) and
                it->dependencies.size()==0 and
                (it->capability != "" or it->type != "") and
                (it->function != "" or it->module != ""))
            {
              rules.push_back(Rule(*it));
              if (not it->weakrule)
                strong_rules.push_back(Rule(*it));
            }
          }
        }
      }
      else
      {
        // Add entries in ObsLike and Rules section as 2nd order
        const IniParser::ObservablesType & entries = boundIniFile->getObservables();
        for (IniParser::ObservablesType::const_iterator it =
            entries.begin(); it != entries.end(); ++it)
        {
          if (quantityMatchesIniEntry(quantity, *it, *boundTEs) and
              (it->capability != "" or it->type != "") and
              (it->function != "" or it->module != ""))
          {
            rules.push_back(Rule(*it));
            if (not it->weakrule)
              strong_rules.push_back(Rule(*it));
          }
          // FIXME: Throw error if dependency or options entry exists
        }
        const IniParser::ObservablesType & entries2 = boundIniFile->getRules();
        for (IniParser::ObservablesType::const_iterator it =
            entries2.begin(); it != entries2.end(); ++it)
        {
          if (quantityMatchesIniEntry(quantity, *it, *boundTEs) and
              it->dependencies.size()==0 and
              (it->capability != "" or it->type != "") and
              (it->function != "" or it->module != ""))
          {
            rules.push_back(Rule(*it));
            if (not it->weakrule)
              strong_rules.push_back(Rule(*it));
          }
        }
      }

      logger() << "Number of identified rules: " << rules.size() << endl
               << "Number of these rules that are marked as !weak: "
               << rules.size()-strong_rules.size() << EOM;

      // Make filtered lists
      for (std::vector<DRes::VertexID>::const_iterator
          it = vertexCandidates.begin();
          it != vertexCandidates.end(); it ++)
      {
        bool valid = true;
        for (std::vector<Rule>::const_iterator it2 = rules.begin();
            it2 != rules.end(); it2 ++)
        {
          if ( not matchesRules(masterGraph[*it], *it2) )
          {
            valid = false;
          }
        }
        if (valid)
            filteredVertexCandidates.push_back(*it);
        valid = true;
        for (std::vector<Rule>::const_iterator it2 = strong_rules.begin();
            it2 != strong_rules.end(); it2 ++)
        {
          if ( not matchesRules(masterGraph[*it], *it2) )
          {
            valid = false;
          }
        }
        if (valid)
            filteredVertexCandidates2.push_back(*it);
      }

      if (rules.size() > 0 and filteredVertexCandidates.size() > 0)
      {
        logger() << "Candidate vertices that fulfill all rules:" << endl;
        logger() << printGenericFunctorList(filteredVertexCandidates) << EOM;
      }

      if (filteredVertexCandidates.size() == 0)
      {
        filteredVertexCandidates = filteredVertexCandidates2;
        logger() << "Ignoring rules declared as '!weak'" << endl;
        logger() << "Candidate vertices that fulfill all non-weak rules:" << endl;
        logger() << printGenericFunctorList(filteredVertexCandidates) << EOM;
      }

      // Apply tailor-made filter
      if (boundIniFile->getValueOrDef<bool>(
            true, "dependency_resolution", "prefer_model_specific_functions")
          and filteredVertexCandidates.size() > 1)
      {
        filteredVertexCandidates = closestCandidateForModel(filteredVertexCandidates);
        logger() << "A subset of vertex candidates is tailor-made for the scanned model." << endl;
        logger() << "This is used as additional constraint since the YAML rules alone" << endl;
        logger() << "are not constraining enough. These vertices are:" << endl;
        logger() << printGenericFunctorList(filteredVertexCandidates) << EOM;
      }

      // Nothing left?
      if ( filteredVertexCandidates.size() == 0 )
      {
        str errmsg = "None of the vertex candidates for";
        errmsg += "\n" + printQuantityToBeResolved(quantity, toVertex);
        errmsg += "\nfulfills all rules in the YAML file.";
        errmsg += "\nPlease check your YAML file for contradictory rules, and";
        errmsg += "\nensure that you have built GAMBIT in the first place with";
        errmsg += "\nall of the components that you are trying to use.";
        dependency_resolver_error().raise(LOCAL_INFO,errmsg);
      }

      // Did vertices survive?
      if ( filteredVertexCandidates.size() == 1 )
        return filteredVertexCandidates[0];  // And done!

      str errmsg = "Unfortunately, the dependency resolution for";
      errmsg += "\n" + printQuantityToBeResolved(quantity, toVertex);
      errmsg += "\nis still ambiguous.\n";
      errmsg += "\nThe candidate vertices are:\n";
      errmsg += printGenericFunctorList(vertexCandidates) +"\n";
      errmsg += "See logger output for details on the attempted (but failed) dependency resolution.\n";
      errmsg += "\nAn entry in your YAML file that would e.g. select";
      errmsg += "\nthe first of the above candidates could read ";
      if ( toVertex != OBSLIKE_VERTEXID )
      {
        errmsg += "as a targeted rule (in the Rules section):\n";
        errmsg += "\n  - capability: "+masterGraph[toVertex]->capability();
        errmsg += "\n    function: "+masterGraph[toVertex]->name();
        errmsg += "\n    dependencies:";
        errmsg += "\n      - capability: " +masterGraph[vertexCandidates[0]]->capability();
        errmsg += "\n        function: " +masterGraph[vertexCandidates[0]]->name();
        errmsg += "\n        module: " +masterGraph[vertexCandidates[0]]->origin() +"\n\nor ";
      }
      errmsg += "as an untargeted rule (in the Rules or ObsLike section):\n";
      errmsg += "\n  - capability: "+masterGraph[vertexCandidates[0]]->capability();
      errmsg += "\n    function: "+masterGraph[vertexCandidates[0]]->name();
      errmsg += "\n    module: " +masterGraph[vertexCandidates[0]]->origin() +"\n";
      if ( toVertex == OBSLIKE_VERTEXID )
      {
        errmsg += "\n(Note that 1st class rules are not possible for vertices on which the core depends only.)\n";
      }

      dependency_resolver_error().raise(LOCAL_INFO,errmsg);

      return 0;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveRequirement()

void Gambit::DRes::DependencyResolver::resolveRequirement ( functor *  func, VertexID  vertex  )

private

Resolve a specific backend requirement.

Resolve a backend requirement of a specific module function using a specific backend function.

Definition at line 2207 of file depresolver.cpp.

References Gambit::LogTags::dependency_resolver, Gambit::EOM, Gambit::logger(), masterGraph, Gambit::functor::name(), Gambit::functor::origin(), and Gambit::functor::version().

Referenced by resolveVertexBackend().

    {
      (*masterGraph[vertex]).resolveBackendReq(func);
      logger() << LogTags::dependency_resolver;
      logger() << "Resolved by: [" << func->name() << ", ";
      logger() << func->origin() << " (" << func->version() << ")]";
      logger() << EOM;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveVertexBackend()

void Gambit::DRes::DependencyResolver::resolveVertexBackend ( VertexID  vertex )

private

Main function for resolution of backend requirements.

Node-by-node backend resolution.

Definition at line 1802 of file depresolver.cpp.

References boundIniFile, Gambit::LogTags::dependency_resolver, Gambit::EOM, findIniEntry(), Gambit::IniParser::IniFile::getRules(), Gambit::logger(), masterGraph, resolveRequirement(), and solveRequirement().

Referenced by generateTree().

    {
      functor* solution;
      std::vector<functor*> previous_successes;
      std::set<str> remaining_groups;
      std::set<sspair> remaining_reqs;
      bool allow_deferral = true;

      // If there are no backend requirements, and thus nothing to do, return.
      if ((*masterGraph[vertex]).backendreqs().size() == 0) return;

      // Get started.
      logger() << LogTags::dependency_resolver << "Doing backend function resolution..." << EOM;

      // Check whether this vertex is mentioned in the inifile.
      const IniParser::ObservableType * auxEntry = findIniEntry(vertex, boundIniFile->getRules(), "Rules");

      // Collect the list of groups that the backend requirements of this vertex exist in.
      std::set<str> groups = (*masterGraph[vertex]).backendgroups();

      // Collect the list of orphan (i.e. groupless) backend requirements.
      std::set<sspair> orphan_reqs = (*masterGraph[vertex]).backendreqs("none");

      // Loop until no further backend resolutions are possible, or no more are required.
      while ( not ( groups.empty() and orphan_reqs.empty() ) )
      {

        // Loop over all groups, including the null group (group="none").
        for (std::set<str>::iterator it = groups.begin(); it != groups.end(); ++it)
        {
          // Switch depending on whether this is a real group or not.
          if (*it == "none")
          {
            // Loop over all the orphan requirements.
            for (std::set<sspair>::iterator req = orphan_reqs.begin(); req != orphan_reqs.end(); ++req)
            {
              logger() << LogTags::dependency_resolver;
              logger() << "Resolving ungrouped requirement " << req->first;
              logger() << " (" << req->second << ")..." << EOM;

              // Find a backend function that fulfills the backend requirement.
              std::set<sspair> reqsubset;
              reqsubset.insert(*req);
              solution = solveRequirement(reqsubset,auxEntry,vertex,previous_successes,allow_deferral);

              // Check if a valid solution has been returned
              if (solution != NULL)
              {
                // It has, so resolve the backend requirement with that function and add it to the list of successful resolutions.
                resolveRequirement(solution,vertex);
                previous_successes.push_back(solution);

                // If *req is in remaining_reqs, remove it
                if (remaining_reqs.find(*req) != remaining_reqs.end())
                {
                  remaining_reqs.erase(*req);
                }
              }
              else // No valid solution found, but deferral has been suggested - so defer resolution of this group until later.
              {
                remaining_reqs.insert(*req);
                logger() << LogTags::dependency_resolver;
                logger() << "Resolution of ungrouped requirement " << req->first;
                logger() << " (" << req->second << ") deferred until later." << EOM;
              }
            }
            if (not remaining_reqs.empty()) remaining_groups.insert(*it);
          }
          else
          {
            logger() << LogTags::dependency_resolver;
            logger() << "Resolving from group " << *it << "..." << EOM;

            // Collect the list of backend requirements in this group.
            std::set<sspair> reqs = (*masterGraph[vertex]).backendreqs(*it);

            // Find a backend function that fulfills one of the backend requirements in the group.
            solution = solveRequirement(reqs,auxEntry,vertex,previous_successes,allow_deferral,*it);

            // Check if a valid solution has been returned
            if (solution != NULL)
            {
              // It has, so resolve the backend requirement with that function and add it to the list of successful resolutions.
              resolveRequirement(solution,vertex);
              previous_successes.push_back(solution);
            }
            else // No valid solution found, but deferral has been suggested - so defer resolution of this group until later.
            {
              remaining_groups.insert(*it);
              logger() << LogTags::dependency_resolver;
              logger() << "Resolution from group " << *it;
              logger() << "deferred until later." << EOM;
            }
          }
        }

        // If there has been no improvement this round, turn off deferral and make the next round the last attempt.
        if (orphan_reqs == remaining_reqs and groups == remaining_groups)
        {
          allow_deferral = false;
        }
        else // Otherwise try again to resolve the remaining groups and orphan requirements, now that some others are known.
        {
          orphan_reqs = remaining_reqs;
          groups = remaining_groups;
          remaining_reqs.clear();
          remaining_groups.clear();
        }

      }

    }

Here is the call graph for this function:

Here is the caller graph for this function:

run_topological_sort()

std::list< VertexID > Gambit::DRes::DependencyResolver::run_topological_sort ( )

private

Topological sort.

Boost lib topological sort.

Definition at line 1745 of file depresolver.cpp.

References masterGraph.

Referenced by doResolution().

    {
      std::list<VertexID> topo_order;
      topological_sort(masterGraph, front_inserter(topo_order));
      return topo_order;
    }

Here is the caller graph for this function:

solveRequirement()

functor * Gambit::DRes::DependencyResolver::solveRequirement ( std::set< sspair >  reqs, const IniParser::ObservableType *  auxEntry, VertexID  vertex, std::vector< functor *>  previous_successes, bool  allow_deferral, str  group = "none"  )

private

Find backend function matching any one of a number of capability-type pairs.

Find a backend function that matches any one of a vector of capability-type pairs.

Definition at line 1916 of file depresolver.cpp.

References Gambit::DRes::backendFuncMatchesIniEntry(), boundClaw, boundCore, boundIniFile, boundTEs, Gambit::DRes::dependency_resolver_error(), findIniEntry(), Gambit::Models::ModelFunctorClaw::get_activemodels(), Gambit::Models::ModelFunctorClaw::get_parent(), Gambit::gambit_core::getBackendFunctors(), Gambit::IniParser::Parser::getValueOrDef(), combine_hdf5::group, LOCAL_INFO, masterGraph, printGenericFunctorList(), and Gambit::DRes::typeComp().

Referenced by resolveVertexBackend().

    {
      std::vector<functor*> vertexCandidates;
      std::vector<functor*> vertexCandidatesWithIniEntry;
      std::vector<functor*> disabledVertexCandidates;

      // Loop over all existing backend vertices, and make a list of
      // functors that are available and fulfill the backend requirement
      for (std::vector<functor *>::const_iterator
          itf  = boundCore->getBackendFunctors().begin();
          itf != boundCore->getBackendFunctors().end();
          ++itf)
      {
        const IniParser::ObservableType * reqEntry = NULL;
        bool entryExists = false;

        // Find relevant iniFile entry from Rules section
        if ( auxEntry != NULL ) reqEntry = findIniEntry((*itf)->quantity(), (*auxEntry).backends, "backend");
        if ( reqEntry != NULL) entryExists = true;

        // Look for a match to at least one backend requirement, taking into account type equivalency classes.
        bool simple_match = false;
        for (std::set<sspair>::const_iterator
             itr  = reqs.begin();
             itr != reqs.end();
             ++itr)
        {
          if ((*itf)->capability() == itr->first and typeComp((*itf)->type(), itr->second, *boundTEs))
          {
            simple_match = true;
            break;
          }
        }

        // If there is a relevant inifile entry, we also check for a match to the capability, type, function name and backend name in that entry.
        if ( simple_match and ( entryExists ? backendFuncMatchesIniEntry(*itf, *reqEntry, *boundTEs) : true ) )
        {

          // Has the backend vertex already been disabled by the backend system?
          bool disabled = ( (*itf)->status() <= 0 );

          // Is it permitted to be used to fill this backend requirement?
          // First we create the backend-version pair for the backend vertex and its semi-generic form (where any version is OK).
          sspair itf_signature((*itf)->origin(), (*itf)->version());
          sspair itf_generic((*itf)->origin(), "any");
          // Then we find the set of backend-version pairs that are permitted.
          std::set<sspair> permitted_bes = (*masterGraph[vertex]).backendspermitted((*itf)->quantity());
          // Then we see if any match.  First we test for generic matches, where any version of any backend is allowed.
          bool permitted = ( permitted_bes.empty()
          // Next we test for semi-generic matches, where the backend matches and any version of that backend is allowed.
          or std::find(permitted_bes.begin(), permitted_bes.end(), itf_generic) != permitted_bes.end()
          // Finally we test for specific matches, where both the backend and version match what is allowed.
          or std::find(permitted_bes.begin(), permitted_bes.end(), itf_signature) != permitted_bes.end() );

          // If the backend vertex is able and allowed,
          if (permitted and not disabled)
          {
            // add it to the overall vertex candidate list
            vertexCandidates.push_back(*itf);
            // if it has an inifile entry, add it to the candidate list with inifile entries
            if (entryExists) vertexCandidatesWithIniEntry.push_back(*itf);
          }
          else
          {
            // otherwise, add it to disabled vertex candidate list
            if (not disabled) (*itf)->setStatus(1);
            disabledVertexCandidates.push_back(*itf);
          }
        }
      }

      // If too many candidates, prefer those with entries in the inifile.
      if (vertexCandidates.size() > 1 and vertexCandidatesWithIniEntry.size() >= 1)
      {
        // Loop over the remaining candidates, and disable those without entries in the inifile.
        for (std::vector<functor *>::iterator it = vertexCandidates.begin(); it != vertexCandidates.end(); ++it)
        {
          if (std::find(vertexCandidatesWithIniEntry.begin(), vertexCandidatesWithIniEntry.end(), *it) == vertexCandidatesWithIniEntry.end() )
            disabledVertexCandidates.push_back(*it);
        }
        // Set the new list of vertex candidates to be only those with inifile entries.
        vertexCandidates = vertexCandidatesWithIniEntry;
      }

      // Purge all candidates that conflict with a backend-matching rule.
      // Start by making a new vector to hold the candidates that survive the purge.
      std::vector<functor *> survivingVertexCandidates;
      // Loop over the current candidates.
      for (std::vector<functor *>::const_iterator it = vertexCandidates.begin(); it != vertexCandidates.end(); ++it)
      {
        // Set up a flag to keep track of whether anything has indicated that the candidate should be thrown out.
        bool keeper = true;
        // Retrieve the tags of the candidate.
        std::set<str> tags = (*masterGraph[vertex]).backendreq_tags((*it)->quantity());
        // Loop over the tags
        for (std::set<str>::iterator tagit = tags.begin(); tagit != tags.end(); ++tagit)
        {
          // Find out which other backend requirements exhibiting this tag must be filled from the same backend as the req this candidate would fill.
          std::set<sspair> must_match = (*masterGraph[vertex]).forcematchingbackend(*tagit);
          // Set up a flag to keep track of whether any of the other backend reqs have already been filled.
          bool others_filled = false;
          // Set up a string to keep track of which backend the other backend reqs have been filled from (if any).
          str common_backend_and_version;
          // Loop over the other backend reqs.
          for (std::set<sspair>::iterator mit = must_match.begin(); mit != must_match.end(); ++mit)
          {
            // Set up a flag to indicate if the other backend req in question has been filled yet.
            bool other_filled = false;
            // Set up a string to keep track of which backend the other backend req in question has been filled from (if any).
            str filled_from;
            // Loop over the backend functors that have successfully filled backend reqs already for this funcition
            for (std::vector<functor*>::const_iterator
                 itf  = previous_successes.begin();
                 itf != previous_successes.end();
                 ++itf)
            {
              // Check if the current previous successful resolution (itf) was of the same backend requirement as the
              // current one of the backend requirements (mit) that must be filled from the same backend as the current candidate (it).
              if ((*itf)->quantity() == *mit)
              {
                // Note that mit (the current backend req that must be filled from the same backend as the current candidate) has indeed been filled, by itf
                other_filled = true;
                // Note which backend mit has been filled from (i.e. where does itf come from?)
                filled_from = (*itf)->origin() + " v" + (*itf)->version();
                break;
              }
            }
            // If the other req has been filled, updated the tracker of whether any of the reqs linked to this flag have been filled,
            // and compare the filling backend to the one used to fill any other reqs associated with this tag.
            if (other_filled)
            {
              others_filled = true;
              if (common_backend_and_version.empty()) common_backend_and_version = filled_from; // Save the filling backend
              if (filled_from != common_backend_and_version) // Something buggy has happened and the rule is already broken(!)
              {
                str errmsg = "A backend-matching rule has been violated!";
                errmsg  += "\nFound whilst checking which backends have been used"
                           "\nto fill requirements with tag " + *tagit + " in function "
                           "\n" + (*masterGraph[vertex]).name() + " of " + (*masterGraph[vertex]).origin() + "."
                           "\nOne requirement was filled from " + common_backend_and_version + ", "
                           "\nwhereas another was filled from " + filled_from + "."
                           "\nThis should not happen and is probably a bug in GAMBIT.";
                dependency_resolver_error().raise(LOCAL_INFO,errmsg);
              }
            }
          }
          // Try to keep this candidate if it comes from the same backend as those already filled, or if none of the others are filled yet.
          keeper = (not others_filled or common_backend_and_version == (*it)->origin() + " v" + (*it)->version());
          if (not keeper) break;
        }
        if (keeper) survivingVertexCandidates.push_back(*it); else disabledVertexCandidates.push_back(*it);
      }
      // Replace the previous list of candidates with the survivors.
      vertexCandidates = survivingVertexCandidates;

      // Only print the status flags -5 or -6 if any of the disabled vertices has it
      bool printMathematicaStatus = false;
      for(unsigned int j=0; j < disabledVertexCandidates.size(); j++)
        if(disabledVertexCandidates[j]->status() == -5)
          printMathematicaStatus = true;
      bool printPythonStatus = false;
      for(unsigned int j=0; j < disabledVertexCandidates.size(); j++)
        if(disabledVertexCandidates[j]->status() == -6)
          printPythonStatus = true;

      // No candidates? Death.
      if (vertexCandidates.size() == 0)
      {
        std::ostringstream errmsg;
        errmsg
          << "Found no candidates for backend requirements of "
          << masterGraph[vertex]->origin() << "::" << masterGraph[vertex]->name() << ":\n"
          << reqs << "\nfrom group: " << group;
        if (disabledVertexCandidates.size() != 0)
        {
          errmsg << "\nNote that viable candidates exist but have been disabled:\n"
                 <<     printGenericFunctorList(disabledVertexCandidates)
                 << endl
                 << "Status flags:" << endl
                 << " 1: This function is available, but the backend version is not compatible with all your requests." << endl
                 << " 0: This function is not compatible with any model you are scanning." << endl
                 << "-1: The backend that provides this function is missing." << endl
                 << "-2: The backend is present, but function is absent or broken." << endl;
         if(printMathematicaStatus)
            errmsg << "-5: The backend requires Mathematica, but Mathematica is absent." << endl;
         if(printPythonStatus)
            errmsg << "-6: The backend requires Python, but pybind11 is absent." << endl;
          errmsg << endl
                 << "Make sure to check your YAML file, especially the rules" << endl
                 << "pertaining to backends."  << endl
                 << endl
                 << "Please also check that all shared objects exist for the"  << endl
                 << "necessary backends, and that they contain all the"  << endl
                 << "necessary functions required for this scan.  You may"  << endl
                 << "check the status of different backends by running"  << endl
                 << "  ./gambit backends"  << endl
                 << "You may also wish to check the specified search paths for each" << endl
                 << "backend shared library in "  << endl;
          if (Backends::backendInfo().custom_locations_exist())
          {
            errmsg << "  " << Backends::backendInfo().backend_locations()  << endl << "and"  << endl;
          }
          errmsg << "  " << Backends::backendInfo().default_backend_locations()  << endl;
        }
        dependency_resolver_error().raise(LOCAL_INFO,errmsg.str());
      }

      // Still more than one candidate...
      if (vertexCandidates.size() > 1)
      {
        // Check whether any of the remaining candidates is subject to a backend-matching rule,
        // and might therefore be uniquely chosen over the other(s) if resolution for this req is attempted again, after
        // another of the reqs subject to the same rule is resolved.
        bool rule_exists = false;
        // Loop over the remaining candidates.
        for (std::vector<functor *>::const_iterator it = vertexCandidates.begin(); it != vertexCandidates.end(); ++it)
        {
          // Retrieve the tags of the candidate.
          std::set<str> tags = (*masterGraph[vertex]).backendreq_tags((*it)->quantity());
          // Loop over the tags
          for (std::set<str>::iterator tagit = tags.begin(); tagit != tags.end(); ++tagit)
          {
            // Find if there is a backend-matching rule associated with this tag.
            rule_exists = not (*masterGraph[vertex]).forcematchingbackend(*tagit).empty();
            if (rule_exists) break;
          }
          if (rule_exists) break;
        }

        // If deferral is allowed and appears to be potentially useful, defer resolution until later.
        if (allow_deferral and rule_exists)
        {
          return NULL;
        }

        // If not, we have just one more trick up our sleeves... use the models scanned to narrow things down.
        if (boundIniFile->getValueOrDef<bool>(true, "dependency_resolution", "prefer_model_specific_functions"))
        {
          // Prefer backend functors that are more specifically tailored for the model being scanned. Do not
          // consider backend functors that are accessible via INTERPRET_AS_X links, as these are all considered
          // to be equally 'far' from the model being scanned, with the 'distance' being one step further than
          // the most distant ancestor.
          std::vector<functor*> newCandidates;
          std::set<str> s = boundClaw->get_activemodels();
          std::vector<str> parentModelList(s.begin(), s.end());
          while (newCandidates.size() == 0 and not parentModelList.empty())
          {
            for (std::vector<str>::iterator mit = parentModelList.begin(); mit != parentModelList.end(); ++mit)
            {
              // Test each vertex candidate to see if it has been explicitly set up to work with the model *mit
              for (std::vector<functor*>::iterator it = vertexCandidates.begin(); it != vertexCandidates.end(); ++it)
              {
                if ( (*it)->modelExplicitlyAllowed(*mit) ) newCandidates.push_back(*it);
              }
              // Step up a level in the model hierarchy for this model.
              *mit = boundClaw->get_parent(*mit);
            }
            parentModelList.erase(std::remove(parentModelList.begin(), parentModelList.end(), "none"), parentModelList.end());
          }
          if (newCandidates.size() != 0) vertexCandidates = newCandidates;
        }

        // Still more than one candidate, so the game is up.
        if (vertexCandidates.size() > 1)
        {
          str errmsg = "Found too many candidates for backend requirement ";
          if (reqs.size() == 1) errmsg += reqs.begin()->first + " (" + reqs.begin()->second + ")";
          else errmsg += "group " + group;
          errmsg += " of module function " + masterGraph[vertex]->origin() + "::" + masterGraph[vertex]->name()
           + "\nViable candidates are:\n" + printGenericFunctorList(vertexCandidates);
          errmsg += "\nIf you don't need all the above backends, you can resolve the ambiguity simply by";
          errmsg += "\nuninstalling the backends you don't use.";
          errmsg += "\n\nAlternatively, you can add an entry in your YAML file that selects which backend";
          errmsg += "\nthe module function " + masterGraph[vertex]->origin() + "::" + masterGraph[vertex]->name() + " should use. A YAML file entry";
          errmsg += "\nthat selects e.g. the first candidate above could read\n";
          errmsg += "\n  - capability: "+masterGraph[vertex]->capability();
          errmsg += "\n    function: "+masterGraph[vertex]->name();
          errmsg += "\n    backends:";
          errmsg += "\n      - {backend: "+vertexCandidates.at(0)->origin()+", version: "+vertexCandidates.at(0)->version()+"}\n";
          dependency_resolver_error().raise(LOCAL_INFO,errmsg);
        }
      }

      // Just one candidate.  Jackpot.
      return vertexCandidates[0];

    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

activeFunctorGraphFile

const str Gambit::DRes::DependencyResolver::activeFunctorGraphFile

private

Output filename for graph of active functors.

Definition at line 279 of file depresolver.hpp.

Referenced by doResolution(), and printFunctorEvalOrder().

boundClaw

const Models::ModelFunctorClaw* Gambit::DRes::DependencyResolver::boundClaw

private

Model claw to which this dependency resolver is bound.

Definition at line 245 of file depresolver.hpp.

Referenced by closestCandidateForModel(), makeFunctorsModelCompatible(), resolveDependency(), and solveRequirement().

boundCore

const gambit_core* Gambit::DRes::DependencyResolver::boundCore

private

Core to which this dependency resolver is bound.

Definition at line 242 of file depresolver.hpp.

Referenced by addFunctors(), calcObsLike(), doResolution(), generateTree(), makeFunctorsModelCompatible(), printFunctorList(), and solveRequirement().

boundIniFile

const IniParser::IniFile* Gambit::DRes::DependencyResolver::boundIniFile

private

ini file to which this dependency resolver is bound

Definition at line 248 of file depresolver.hpp.

Referenced by calcObsLike(), collectIniOptions(), collectSubCaps(), doResolution(), generateTree(), resolveDependency(), resolveDependencyFromRules(), resolveVertexBackend(), and solveRequirement().

boundPrinter

Printers::BasePrinter* Gambit::DRes::DependencyResolver::boundPrinter

private

Printer object to which this dependency resolver is bound.

Definition at line 254 of file depresolver.hpp.

Referenced by initialisePrinter(), and printObsLike().

boundTEs

const Utils::type_equivalency* Gambit::DRes::DependencyResolver::boundTEs

private

Type equivalency object to which this dependency resolver is bound.

Definition at line 251 of file depresolver.hpp.

Referenced by checkTypeMatch(), collectIniOptions(), collectSubCaps(), DependencyResolver(), findIniEntry(), printObsLike(), resolveDependency(), resolveDependencyFromRules(), and solveRequirement().

edges_to_force_on_manager

std::map<VertexID, std::set<VertexID> > Gambit::DRes::DependencyResolver::edges_to_force_on_manager

private

Map from nested function -> list of fulfilled dependencies that need to be passed on to its loop manager when it is selected.

Definition at line 273 of file depresolver.hpp.

Referenced by generateTree().

function_order

std::list<VertexID> Gambit::DRes::DependencyResolver::function_order

private

Saved calling order for functions.

Definition at line 263 of file depresolver.hpp.

Referenced by doResolution().

index

IndexMap Gambit::DRes::DependencyResolver::index

private

Indices associated with graph vertices (used by printers to identify functors)

Definition at line 276 of file depresolver.hpp.

Referenced by initialisePrinter().

loopManagerMap

std::map<VertexID, std::set<VertexID> > Gambit::DRes::DependencyResolver::loopManagerMap

private

Temporary map for loop manager -> list of nested functions.

Definition at line 269 of file depresolver.hpp.

Referenced by doResolution(), and generateTree().

masterGraph

MasterGraphType Gambit::DRes::DependencyResolver::masterGraph

private

The central boost graph object.

Definition at line 260 of file depresolver.hpp.

Referenced by addFunctors(), calcObsLike(), checkTypeMatch(), closestCandidateForModel(), collectIniOptions(), collectSubCaps(), doResolution(), fillParQueue(), findIniEntry(), generateTree(), get_functor(), getObsLikeOrder(), initialisePrinter(), invalidatePointAt(), makeFunctorsModelCompatible(), printFunctorEvalOrder(), printFunctorList(), printGenericFunctorList(), printObsLike(), printQuantityToBeResolved(), resetAll(), resolveDependency(), resolveDependencyFromRules(), resolveRequirement(), resolveVertexBackend(), run_topological_sort(), and solveRequirement().

outputVertexInfos

std::vector<OutputVertexInfo> Gambit::DRes::DependencyResolver::outputVertexInfos

private

Output Vertex Infos.

Definition at line 257 of file depresolver.hpp.

Referenced by generateTree(), getIniEntry(), and getObsLikeOrder().

print_timing

bool Gambit::DRes::DependencyResolver::print_timing = false

private

Global flag for triggering printing of timing data.

Definition at line 282 of file depresolver.hpp.

Referenced by generateTree(), and printTiming().

print_unitcube

bool Gambit::DRes::DependencyResolver::print_unitcube = false

private

Global flag for triggering printing of unitCubeParameters.

Definition at line 285 of file depresolver.hpp.

Referenced by generateTree(), and initialisePrinter().

SortedParentVertices

std::map<VertexID, std::vector<VertexID> > Gambit::DRes::DependencyResolver::SortedParentVertices

private

Saved calling order for functions required to compute single ObsLike entries.

Definition at line 266 of file depresolver.hpp.

Referenced by calcObsLike(), doResolution(), and printObsLike().

---

The documentation for this class was generated from the following files:

• Core/include/gambit/Core/depresolver.hpp
• Core/src/depresolver.cpp