Gambit::module_functor_common Class Reference

Functor derived class for module functions. More...

#include <functors.hpp>

Inheritance diagram for Gambit::module_functor_common:

Collaboration diagram for Gambit::module_functor_common:

Public Member Functions
	module_functor_common (str, str, str, str, Models::ModelFunctorClaw &)
	Constructor. More...
virtual	~module_functor_common ()
	Destructor. More...
double	getRuntimeAverage ()
	Getter for averaged runtime. More...
void	reset ()
	Reset functor. More...
void	notifyOfInvalidation (const str &)
	Tell the functor that it invalidated the current point in model space, pass a message explaining why, and throw an exception. More...
double	getInvalidationRate ()
	Getter for invalidation rate. More...
void	setFadeRate (double)
	Setter for the fade rate. More...
void	setTimingPrintRequirement (bool)
	Setter for indicating if the timing data for this function's execution should be printed. More...
bool	requiresTimingPrinting () const
	Getter indicating if the timing data for this function's execution should be printed. More...
bool	getActiveModelFlag (str)
	Indicate whether or not a known model is activated or not. More...
safe_ptr< str >	getChosenReqFromGroup (str)
	Return a safe pointer to a string indicating which backend requirement has been activated for a given backend group. More...
virtual void	iterate (long long iteration)
	Execute a single iteration in the loop managed by this functor. More...
virtual void	init_myCurrentIteration_if_NULL ()
	Initialise the array holding the current iteration(s) of this functor. More...
virtual void	setIteration (long long iteration)
	Setter for setting the iteration number in the loop in which this functor runs. More...
virtual omp_safe_ptr< long long >	iterationPtr ()
	Return a safe pointer to the iteration number in the loop in which this functor runs. More...
virtual void	setCanBeLoopManager (bool canManage)
	Setter for specifying whether this is permitted to be a manager functor, which runs other functors nested in a loop. More...
virtual bool	canBeLoopManager ()
	Getter for revealing whether this is permitted to be a manager functor. More...
virtual void	setLoopManagerCapType (str cap, str t)
	Setter for specifying the capability required of a manager functor, if it is to run this functor nested in a loop. More...
virtual str	loopManagerCapability ()
	Getter for revealing the required capability of the wrapped function's loop manager. More...
virtual str	loopManagerType ()
	Getter for revealing the required type of the wrapped function's loop manager. More...
virtual str	loopManagerName ()
	Getter for revealing the name of the wrapped function's assigned loop manager. More...
virtual str	loopManagerOrigin ()
	Getter for revealing the module of the wrapped function's assigned loop manager. More...
virtual void	breakLoopFromManagedFunctor ()
	Tell the manager of the loop in which this functor runs that it is time to break the loop. More...
virtual safe_ptr< bool >	loopIsDone ()
	Return a safe pointer to the flag indicating that a loop managed by this functor should break now. More...
virtual void	resetLoop ()
	Provide a way to reset the flag indicating that a loop managed by this functor should break. More...
virtual void	breakLoop ()
	Tell the functor that the loop it manages should break now. More...
virtual std::set< sspair >	dependencies ()
	Getter for listing currently activated dependencies. More...
virtual std::set< str >	backendgroups ()
	Getter for listing backend requirement groups. More...
virtual std::set< sspair >	backendreqs ()
	Getter for listing all backend requirements. More...
virtual std::set< sspair >	backendreqs (str)
	Getter for listing backend requirements from a specific group. More...
virtual std::set< sspair >	backendspermitted (sspair quant)
	Getter for listing permitted backends. More...
virtual std::set< str >	backendreq_tags (sspair)
	Getter for listing tags associated with backend requirements. More...
virtual std::set< sspair >	forcematchingbackend (str)
	Getter for listing backend requirements that must be resolved from the same backend. More...
virtual std::set< sspair >	backend_conditional_dependencies (str req, str type, str be, str ver)
	Getter for listing backend-specific conditional dependencies (4-string version) More...
virtual std::set< sspair >	backend_conditional_dependencies (str req, str type, str be)
	Getter for backend-specific conditional dependencies (3-string version) More...
virtual std::set< sspair >	backend_conditional_dependencies (functor *be_functor)
	Getter for backend-specific conditional dependencies (backend functor pointer version) More...
virtual std::set< sspair >	model_conditional_dependencies (str model)
	Getter for listing model-specific conditional dependencies. More...
virtual std::set< sspair >	model_conditional_backend_reqs (str model)
	Getter for listing model-specific conditional backend requirements. More...
void	setDependency (str, str, void(*)(functor *, module_functor_common *), str purpose="")
	Add and activate unconditional dependencies. More...
void	setConditionalDependency (str, str)
	Add conditional dependency-type pairs in advance of later conditions. More...
void	setBackendConditionalDependency (str, str, str, str, void(*)(functor *, module_functor_common *))
	Add a backend conditional dependency for multiple backend versions. More...
void	setBackendConditionalDependencySingular (str, str, str, str, void(*)(functor *, module_functor_common *))
	Add a backend conditional dependency for a single backend version. More...
void	setModelConditionalDependency (str, str, void(*)(functor *, module_functor_common *))
	Add a model conditional dependency for multiple models. More...
void	setModelConditionalDependencySingular (str, str, void(*)(functor *, module_functor_common *))
	Add a model conditional dependency for a single model. More...
void	makeBackendRuleForModel (str, str)
	Add a rule for activating backend requirements according to the model being scanned. More...
void	setBackendReq (str, str, str, str, void(*)(functor *))
	Add an unconditional backend requirement The info gets updated later if this turns out to be contitional on a model. More...
void	setModelConditionalBackendReq (str model, str req, str type)
	Add a model conditional backend requirement for multiple models. More...
void	setModelConditionalBackendReqSingular (str model, str req, str type)
	Add a model conditional backend requirement for a single model. More...
void	makeBackendOptionRule (str, str)
	Add a rule for dictating which backends can be used to fulfill which backend requirements. More...
void	setPermittedBackend (str req, str be, str ver)
	Add a single permitted backend version. More...
void	makeBackendMatchingRule (str tag)
	Add one or more rules for forcing backends reqs with the same tags to always be resolved from the same backend. More...
void	setRequiredClassloader (str, str, str)
	Add a rule indicating that classes from a given backend must be available. More...
void	notifyOfBackends (std::map< str, std::set< str > >)
	Indicate to the functor which backends are actually loaded and working. More...
virtual void	setNestedList (std::vector< functor *> &newNestedList)
	Set the ordered list of pointers to other functors that should run nested in a loop managed by this one. More...
virtual void	resolveDependency (functor *dep_functor)
	Resolve a dependency using a pointer to another functor object. More...
virtual void	resolveLoopManager (functor *)
	Set this functor's loop manager (if it has one) More...
virtual void	resolveBackendReq (functor *be_functor)
	Resolve a backend requirement using a pointer to another functor object. More...
virtual void	notifyOfModel (str model)
	Notify the functor that a certain model is being scanned, so that it can activate its dependencies and backend reqs accordingly. More...
virtual void	notifyOfDependee (functor *)
	Notify the functor that another functor depends on it. More...
virtual invalid_point_exception *	retrieve_invalid_point_exception ()
	Retrieve the previously saved exception generated when this functor invalidated the current point in model space. More...
Public Member Functions inherited from Gambit::functor
	functor (str, str, str, str, Models::ModelFunctorClaw &)
	Constructor. More...
virtual	~functor ()
virtual void	calculate ()
	Virtual calculate(); needs to be redefined in daughters. More...
virtual void	reset_and_calculate ()
	Reset-then-recalculate method. More...
void	setStatus (int)
	Setter for status: -6 = required external tool absent (pybind11) -5 = required external tool absent (Mathematica) -4 = required backend absent (backend ini functions) -3 = required classes absent -2 = function absent -1 = origin absent 0 = model incompatibility (default) 1 = available 2 = active. More...
virtual void	setInUse (bool)
	Set the inUse flag (must be overridden in derived class to have any effect). More...
void	setPurpose (str)
	Setter for purpose (relevant only for next-to-output functors) More...
void	setVertexID (int)
	Setter for vertex ID (used in printer system) More...
void	setTimingVertexID (int)
	Set ID for timing 'vertex' (used in printer system) More...
str	name () const
	Getter for the wrapped function's name. More...
str	capability () const
	Getter for the wrapped function's reported capability. More...
str	type () const
	Getter for the wrapped function's reported return type. More...
str	origin () const
	Getter for the wrapped function's origin (module or backend name) More...
str	version () const
	Getter for the version of the wrapped function's origin (module or backend) More...
virtual str	safe_version () const
	Getter for the 'safe' incarnation of the version of the wrapped function's origin (module or backend) More...
int	status () const
	Getter for the wrapped function current status: -4 = required backend absent (backend ini functions) -3 = required classes absent -2 = function absent -1 = origin absent 0 = model incompatibility (default) 1 = available 2 = active. More...
sspair	quantity () const
	Getter for the overall quantity provided by the wrapped function (capability-type pair) More...
str	purpose () const
	Getter for purpose (relevant for output nodes, aka helper structures for the dep. resolution) More...
int	vertexID () const
	Getter for vertex ID. More...
int	timingVertexID () const
	Getter for timing vertex ID. More...
str	label () const
	Getter for string label. More...
str	timingLabel () const
	Getter for the printer timing label. More...
virtual bool	requiresPrinting () const
	Getter indicating if the wrapped function's result should to be printed. More...
virtual void	setPrintRequirement (bool)
	Setter for indicating if the wrapped function's result should to be printed. More...
virtual void	print (Printers::BasePrinter *printer, const int pointID, int thread_num)
	Printer function. More...
virtual void	print (Printers::BasePrinter *printer, const int pointID)
	Printer function (no-thread-index short-circuit) More...
void	notifyOfIniOptions (const Options &)
	Notify the functor about an instance of the options class that contains information from its corresponding ini-file entry in the auxiliaries or observables section. More...
template<typename TYPE >
void	setOption (const str &key, const TYPE val)
	Set an option for the functor directly (for use in standalone executables). More...
safe_ptr< Options >	getOptions ()
	Return a safe pointer to the options that this functor is supposed to run with (e.g. from the ini file). More...
void	notifyOfSubCaps (const Options &)
	Notify the functor about an instance of the options class that contains sub-capability information. More...
template<typename TYPE >
void	setSubCap (const str &key, const TYPE val)
	Set a sub-capability (subcap)for the functor directly (for use in standalone executables). More...
safe_ptr< Options >	getSubCaps ()
	Return a safe pointer to the subcaps that this functor realises it is supposed to facilitate downstream calculation of. More...
safe_ptr< std::set< sspair > >	getDependees ()
	Return a safe pointer to the vector of all capability,type pairs of functors arranged downstream of this one in the dependency tree. More...
bool	allModelsAllowed ()
	Test whether the functor is allowed to be used with all models. More...
bool	modelAllowed (str model)
	Test whether the functor is always allowed (either explicitly or implicitly) to be used with a given model. More...
bool	modelExplicitlyAllowed (str model)
	Test whether the functor is explictly always allowed to be used with a given model. More...
void	setAllowedModel (str model)
	Add a model to the internal list of models for which this functor is allowed to be used. More...
bool	modelComboAllowed (std::set< str > combo)
	Test whether the functor is allowed (either explicitly or implicitly) to be used with a given combination of models. More...
bool	modelComboExplicitlyAllowed (std::set< str > combo)
	Test whether the functor has been explictly allowed to be used with a given combination of models. More...
void	setModelGroup (str group, str contents)
	Add a model group definition to the internal list of model groups. More...
void	setAllowedModelGroupCombo (str groups)
	Add a combination of model groups to the internal list of combinations for which this functor is allowed to be used. More...

Protected Member Functions
void	reset (int)
	Reset functor for one thread only. More...
virtual void	acknowledgeInvalidation (invalid_point_exception &, functor *f=NULL)
	Acknowledge that this functor invalidated the current point in model space. More...
virtual void	startTiming (int)
	Do pre-calculate timing things. More...
virtual void	finishTiming (int)
	Do post-calculate timing things. More...
virtual void	init_memory ()
	Initialise the memory of this functor. More...
void	fill_activeModelFlags ()
	Construct the list of known models only if it doesn't yet exist. More...
sspair	retrieve_conditional_dep_type_pair (str)
	Retrieve full conditional dependency-type pair from conditional dependency only. More...
void	check_missing_LogTag ()
	Check if an appropriate LogTag for this functor is missing from the logging system. More...
void	entering_multithreaded_region ()
void	leaving_multithreaded_region ()
Protected Member Functions inherited from Gambit::functor
bool	allowed_parent_or_friend_exists (str model)
	Test if there is a model in the functor's allowedModels list as which this model can be interpreted. More...
bool	in_allowed_combo (str model)
	Check that a model is actually part of a combination that is allowed to be used with this functor. More...
bool	contains_anything_interpretable_as_member_of (std::set< str > combo, str group)
	Test whether any of the entries in a given model group is a valid interpretation of any members in a given combination. More...
bool	has_common_elements (std::set< str > combo, str group)
	Work out whether a given combination of models and a model group have any elements in common. More...
str	find_friend_or_parent_model_in_map (str model, std::map< str, std::set< sspair > > karta)
	Try to find a parent or friend model in some user-supplied map from models to sspair vectors. More...

Protected Attributes
bool	myTimingPrintFlag
	Flag to select whether or not the timing data for this function's execution should be printed;. More...
std::chrono::time_point< std::chrono::system_clock > *	start
	Beginning and end timing points. More...
std::chrono::time_point< std::chrono::system_clock > *	end
bool	point_exception_raised
	A flag indicating whether or not this functor has invalidated the current point. More...
invalid_point_exception	raised_point_exception
	An exception raised because this functor has invalidated the current point. More...
double	runtime_average
	Averaged runtime in ns. More...
double	fadeRate
	Fade rate for average runtime. More...
double	pInvalidation
	Probability that functors invalidates point in model parameter space. More...
bool *	needs_recalculating
	Needs recalculating or not? More...
bool *	already_printed
	Has result already been sent to the printer? More...
bool *	already_printed_timing
	Has timing data already been sent to the printer? More...
bool	iCanManageLoops
	Flag indicating whether this function can manage a loop over other functions. More...
bool	myLoopIsDone
	Flag indicating whether this function is ready to finish its loop (only relevant if iCanManageLoops = true) More...
bool	iRunNested
	Flag indicating whether this function can run nested in a loop over functions. More...
str	myLoopManagerCapability
	Capability of a function that mangages a loop that this function can run inside of. More...
str	myLoopManagerType
	Capability of a function that mangages a loop that this function can run inside of. More...
functor *	myLoopManager
	Pointer to the functor that mangages the loop that this function runs inside of. More...
std::vector< functor * >	myNestedFunctorList
	Vector of functors that have been set up to run nested within this one. More...
long long *	myCurrentIteration
	Pointer to counters for iterations of nested functor loop. More...
const int	globlMaxThreads
	Maximum number of OpenMP threads this MPI process is permitted to launch in total. More...
std::set< str >	myGroups
	Internal list of backend groups that this functor's requirements fall into. More...
std::map< str, str >	chosenReqsFromGroups
	Map from groups to backend reqs, indicating which backend req has been activated for which backend group. More...
std::set< sspair >	myBackendReqs
	Set of all backend requirement-type string pairs. More...
std::set< sspair >	myResolvableBackendReqs
	Set of all backend requirement-type string pairs currently available for resolution. More...
std::map< str, std::set< sspair > >	myGroupedBackendReqs
	Set of backend requirement-type string pairs for specific backend groups. More...
std::set< sspair >	myDependencies
	Vector of dependency-type string pairs. More...
std::map< str, str >	myConditionalDependencies
	Map of conditional dependencies to their types. More...
std::map< std::vector< str >, std::set< sspair > >	myBackendConditionalDependencies
	Map from (vector with 4 strings: backend req, type, backend, version) to (set of {conditional dependency-type} pairs) More...
std::map< str, std::set< sspair > >	myModelConditionalDependencies
	Map from models to (set of {conditional dependency-type} pairs) More...
std::map< str, std::set< sspair > >	myModelConditionalBackendReqs
	Map from models to (set of {conditional backend requirement-type} pairs) More...
std::map< str, bool >	activeModelFlags
	Map from known models to flags indicating if they are activated or not (known = allowed, in allowed groups or conditions for conditional dependencies) More...
std::map< sspair, void(*)(functor *, module_functor_common *)>	dependency_map
	Map from (dependency-type pairs) to (pointers to templated void functions that set dependency functor pointers) More...
std::map< sspair, functor * >	dependency_functor_map
	Map from (dependency-type pairs) to pointers to functors used to resolve them that set dependency functor pointers) More...
std::map< str, str >	backendreq_types
	Map from backend requirements to their required types. More...
std::map< sspair, str >	backendreq_groups
	Map from backend requirements to their designated groups. More...
std::map< sspair, std::set< str > >	backendreq_tagmap
	Map from backend requirements to their rule tags. More...
std::map< sspair, void(*)(functor *)>	backendreq_map
	Map from (backend requirement-type pairs) to (pointers to templated void functions that set backend requirement functor pointers) More...
std::map< sspair, std::set< sspair > >	permitted_map
	Map from (backend requirement-type pairs) to (set of permitted {backend-version} pairs) More...
std::map< str, std::set< sspair > >	myForcedMatches
	Map from tags to sets of matching (backend requirement-type pairs) that are forced to use the same backend. More...
std::map< str, std::set< str > >	required_classloading_backends
	Map from required classloading backends to their versions. More...
std::vector< str >	missing_backends
	Vector of required backends currently missing. More...
timespec	tp
	Internal timespec object. More...
int	myLogTag
	Integer LogTag, for tagging log messages. More...
bool	signal_mode_locked = true
	While locked, prevent this function switching off threadsafe* emergency signal handling. More...
Protected Attributes inherited from Gambit::functor
str	myName
	Internal storage of the function name. More...
str	myCapability
	Internal storage of exactly what the function calculates. More...
str	myType
	Internal storage of the type of what the function calculates. More...
str	myOrigin
	Internal storage of the name of the module or backend to which the function belongs. More...
str	myVersion
	Internal storage of the version of the module or backend to which the function belongs. More...
str	myPurpose
	Purpose of the function (relevant for output and next-to-output functors) More...
const Models::ModelFunctorClaw *	myClaw
	Bound model functor claw, for checking relationships between models. More...
const str	myLabel
	String label, used to label functor results for printer system. More...
const str	myTimingLabel
	String label, used to label functor timing data for printer system. More...
int	myStatus
	Status: -4 = required backend absent (backend ini functions) -3 = required classes absent -2 = function absent -1 = origin absent 0 = model incompatibility (default) 1 = available 2 = active. More...
int	myVertexID
	Internal storage of the vertex ID number used by the printer system to identify functors. More...
int	myTimingVertexID
	ID assigned by printers to the timing data output stream. More...
bool	verbose
	Debug flag. More...
Options	myOptions
	Internal storage of function options, as a YAML node. More...
Options	mySubCaps
	Internal storage of function sub-capabilities, as a YAML node. More...
std::set< sspair >	myDependees
	List of all capability,type pairs of functors downstream of this one in the dependency tree. More...
std::set< str >	allowedModels
	List of allowed models. More...
std::set< std::set< str > >	allowedGroupCombos
	List of allowed model group combinations. More...
std::map< str, std::set< str > >	modelGroups
	Map from model group names to group contents. More...

Friends
void	FunctorHelp::entering_multithreaded_region (module_functor_common &)
	Connectors to external helper functions (to decouple signal handling from this class) More...
void	FunctorHelp::leaving_multithreaded_region (module_functor_common &)

Additional Inherited Members
Static Protected Member Functions inherited from Gambit::functor
static void	failBigTime (str method)
	Attempt to retrieve a dependency or model parameter that has not been resolved. More...

Detailed Description

Functor derived class for module functions.

Definition at line 399 of file functors.hpp.

Constructor & Destructor Documentation

module_functor_common()

Gambit::module_functor_common::module_functor_common	(	str	func_name,
		str	func_capability,
		str	result_type,
		str	origin_name,
		Models::ModelFunctorClaw &	claw
	)

Constructor.

Definition at line 637 of file functors.cpp.

References check_missing_LogTag(), globlMaxThreads, LOCAL_INFO, Gambit::Models::ModelFunctorClaw::model_exists(), myLogTag, Gambit::functor::myOrigin, Gambit::Logging::str2tag(), and Gambit::utils_error().

    : functor                  (func_name, func_capability, result_type, origin_name, claw),
      myTimingPrintFlag        (false),
      start                    (NULL),
      end                      (NULL),
      point_exception_raised   (false),
      runtime_average          (FUNCTORS_RUNTIME_INIT),           // default 1 micro second
      fadeRate                 (FUNCTORS_FADE_RATE),              // can be set individually for each functor
      pInvalidation            (FUNCTORS_BASE_INVALIDATION_RATE),
      needs_recalculating      (NULL),
      already_printed          (NULL),
      already_printed_timing   (NULL),
      iCanManageLoops          (false),
      iRunNested               (false),
      myLoopManagerCapability  ("none"),
      myLoopManagerType        ("none"),
      myLoopManager            (NULL),
      myCurrentIteration       (NULL),
      globlMaxThreads          (omp_get_max_threads()),
      myLogTag                 (-1)
    {
      if (globlMaxThreads == 0) utils_error().raise(LOCAL_INFO,"Cannot determine number of hardware threads available on this system.");
      // Determine LogTag number
      myLogTag = Logging::str2tag(myOrigin);
      if (not claw.model_exists(origin_name)) check_missing_LogTag();
    }

Here is the call graph for this function:

~module_functor_common()

Gambit::module_functor_common::~module_functor_common ( )

virtual

Destructor.

Definition at line 669 of file functors.cpp.

References already_printed, already_printed_timing, end, myCurrentIteration, needs_recalculating, and start.

    {
      if (start != NULL)                  delete [] start;
      if (end != NULL)                    delete [] end;
      if (needs_recalculating != NULL)    delete [] needs_recalculating;
      if (already_printed != NULL)        delete [] already_printed;
      if (already_printed_timing != NULL) delete [] already_printed_timing;
      if (myCurrentIteration != NULL)     delete [] myCurrentIteration;
    }

Member Function Documentation

acknowledgeInvalidation()

void Gambit::module_functor_common::acknowledgeInvalidation ( invalid_point_exception &  e, functor *  f = NULL  )

protectedvirtual

Acknowledge that this functor invalidated the current point in model space.

Definition at line 741 of file functors.cpp.

References breakLoop(), fadeRate, FUNCTORS_BASE_INVALIDATION_RATE, pInvalidation, point_exception_raised, raised_point_exception, and Gambit::invalid_point_exception::set_thrower().

Referenced by Gambit::module_functor< void >::calculate(), iterate(), and notifyOfInvalidation().

    {
      #pragma omp atomic
      pInvalidation += fadeRate*(1-FUNCTORS_BASE_INVALIDATION_RATE);
      if (f==NULL) f = this;
      #pragma omp critical (raised_point_exception)
      {
        e.set_thrower(f);
        raised_point_exception = e;
        point_exception_raised = true;
      }
      if (omp_get_level()!=0) breakLoop();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

backend_conditional_dependencies() [1/3]

std::set< sspair > Gambit::module_functor_common::backend_conditional_dependencies ( str  req, str  type, str  be, str  ver  )

virtual

Getter for listing backend-specific conditional dependencies (4-string version)

Reimplemented from Gambit::functor.

Definition at line 989 of file functors.cpp.

References myBackendConditionalDependencies.

Referenced by backend_conditional_dependencies(), and resolveBackendReq().

    {
      std::set<sspair> generic_deps, specific_deps, total_deps;
      std::vector<str> quad;
      quad.push_back(req);
      quad.push_back(type);
      quad.push_back(be);
      quad.push_back(ver);
      //Check first what conditional dependencies exist for all versions of this backend
      if (ver != "any")
      {
        generic_deps = backend_conditional_dependencies(req, type, be, "any");
      }
      //Now see if there are any for this specific version
      if (myBackendConditionalDependencies.find(quad) != myBackendConditionalDependencies.end())
      {
        specific_deps = myBackendConditionalDependencies[quad];
      }
      //Now put them together
      total_deps.insert(generic_deps.begin(), generic_deps.end());
      total_deps.insert(specific_deps.begin(), specific_deps.end());
      return total_deps;
    }

Here is the caller graph for this function:

backend_conditional_dependencies() [2/3]

std::set< sspair > Gambit::module_functor_common::backend_conditional_dependencies ( str  req, str  type, str  be  )

virtual

Getter for backend-specific conditional dependencies (3-string version)

Reimplemented from Gambit::functor.

Definition at line 1014 of file functors.cpp.

References backend_conditional_dependencies().

    {
      return backend_conditional_dependencies(req, type, be, "any");
    }

Here is the call graph for this function:

backend_conditional_dependencies() [3/3]

std::set< sspair > Gambit::module_functor_common::backend_conditional_dependencies ( functor *  be_functor )

virtual

Getter for backend-specific conditional dependencies (backend functor pointer version)

Reimplemented from Gambit::functor.

Definition at line 1020 of file functors.cpp.

References backend_conditional_dependencies(), Gambit::functor::capability(), Gambit::functor::origin(), Gambit::functor::type(), and Gambit::functor::version().

    {
      return backend_conditional_dependencies (be_functor->capability(), be_functor->type(),
       be_functor->origin(), be_functor->version());
    }

Here is the call graph for this function:

backendgroups()

std::set< str > Gambit::module_functor_common::backendgroups ( )

virtual

Getter for listing backend requirement groups.

Reimplemented from Gambit::functor.

Definition at line 932 of file functors.cpp.

References myGroups.

{ return myGroups; }

backendreq_tags()

std::set< str > Gambit::module_functor_common::backendreq_tags ( sspair  quant )

virtual

Getter for listing tags associated with backend requirements.

Reimplemented from Gambit::functor.

Definition at line 962 of file functors.cpp.

References backendreq_tagmap.

    {
      if (backendreq_tagmap.find(quant) != backendreq_tagmap.end())
      {
        return backendreq_tagmap[quant];
      }
      else
      {
        std::set<str> empty;
        return empty;
      }
    }

backendreqs() [1/2]

std::set< sspair > Gambit::module_functor_common::backendreqs ( )

virtual

Getter for listing all backend requirements.

Reimplemented from Gambit::functor.

Definition at line 934 of file functors.cpp.

References myResolvableBackendReqs.

{ return myResolvableBackendReqs; }

backendreqs() [2/2]

std::set< sspair > Gambit::module_functor_common::backendreqs ( str  group )

virtual

Getter for listing backend requirements from a specific group.

Reimplemented from Gambit::functor.

Definition at line 936 of file functors.cpp.

References combine_hdf5::group, and myGroupedBackendReqs.

    {
      if (myGroupedBackendReqs.find(group) != myGroupedBackendReqs.end())
      {
        return myGroupedBackendReqs[group];
      }
      else
      {
        std::set<sspair> empty;
        return empty;
      }
    }

backendspermitted()

std::set< sspair > Gambit::module_functor_common::backendspermitted ( sspair  quant )

virtual

Getter for listing permitted backends.

Reimplemented from Gambit::functor.

Definition at line 949 of file functors.cpp.

References permitted_map.

    {
      if (permitted_map.find(quant) != permitted_map.end())
      {
        return permitted_map[quant];
      }
      else
      {
        std::set<sspair> empty;
        return empty;
      }
    }

breakLoop()

void Gambit::module_functor_common::breakLoop ( )

virtual

Tell the functor that the loop it manages should break now.

Reimplemented from Gambit::functor.

Definition at line 871 of file functors.cpp.

References myLoopIsDone.

Referenced by acknowledgeInvalidation(), and iterate().

    {
      #pragma omp critical (myLoopIsDone)
      {
        myLoopIsDone = true;
      }
    }

Here is the caller graph for this function:

breakLoopFromManagedFunctor()

void Gambit::module_functor_common::breakLoopFromManagedFunctor ( )

virtual

Tell the manager of the loop in which this functor runs that it is time to break the loop.

Definition at line 855 of file functors.cpp.

References Gambit::functor::breakLoop(), LOCAL_INFO, myLoopManager, Gambit::functor::name(), Gambit::functor::origin(), and Gambit::utils_error().

    {
      if (myLoopManager == NULL)
      {
        str errmsg = "Problem whilst attempting to break out of loop:";
        errmsg +=  "\n Loop Manager not properly defined."
                   "\n This is " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      else
      {
        myLoopManager->breakLoop();
      }
    }

Here is the call graph for this function:

canBeLoopManager()

bool Gambit::module_functor_common::canBeLoopManager ( )

virtual

Getter for revealing whether this is permitted to be a manager functor.

Reimplemented from Gambit::functor.

Definition at line 911 of file functors.cpp.

References iCanManageLoops.

{ return iCanManageLoops; }

check_missing_LogTag()

void Gambit::module_functor_common::check_missing_LogTag ( )

protected

Check if an appropriate LogTag for this functor is missing from the logging system.

Definition at line 680 of file functors.cpp.

References LOCAL_INFO, myLogTag, Gambit::functor::myName, Gambit::functor::myOrigin, and Gambit::utils_warning().

Referenced by module_functor_common().

    {
      if(myLogTag==-1)
      {
        std::ostringstream ss;
        ss << "Cannot retrieve LogTag number; no match for module name in tag2str map." << endl
           << "Module: " << myOrigin << endl
           << "Function:   " << myName << endl
           << "This is probably because there is no log specified for " << myOrigin << " in your yaml file.";
        utils_warning().raise(LOCAL_INFO,ss.str());
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

dependencies()

std::set< sspair > Gambit::module_functor_common::dependencies ( )

virtual

Getter for listing currently activated dependencies.

Reimplemented from Gambit::functor.

Definition at line 930 of file functors.cpp.

References myDependencies.

{ return myDependencies; }

entering_multithreaded_region()

void Gambit::module_functor_common::entering_multithreaded_region ( )

inlineprotected

Definition at line 737 of file functors.hpp.

References Gambit::FunctorHelp::entering_multithreaded_region().

Referenced by Gambit::module_functor< void >::calculate().

{ FunctorHelp::entering_multithreaded_region(*this); }

Here is the call graph for this function:

Here is the caller graph for this function:

fill_activeModelFlags()

void Gambit::module_functor_common::fill_activeModelFlags ( )

protected

Construct the list of known models only if it doesn't yet exist.

Definition at line 1544 of file functors.cpp.

References activeModelFlags, Gambit::functor::allowedModels, Gambit::functor::modelGroups, myModelConditionalBackendReqs, and myModelConditionalDependencies.

Referenced by Gambit::module_functor< void >::calculate(), and notifyOfModel().

    {
      // Construct the list of known models only if it doesn't yet exist
      if (activeModelFlags.empty())
      {
        // First get all the explicitly allowed models.
        for (auto it = allowedModels.begin(); it != allowedModels.end(); ++it) { activeModelFlags[*it] = false; }
        // Next get all the models in groups
        for (auto it = modelGroups.begin(); it != modelGroups.end(); ++it)
        { for (auto jt = it->second.begin(); jt != it->second.end(); ++jt) { activeModelFlags[*jt] = false; } }
        // Next get all the models mentioned in conditional dependencies and backend reqs
        for (auto it = myModelConditionalDependencies.begin(); it != myModelConditionalDependencies.end(); ++it) { activeModelFlags[it->first] = false; }
        for (auto it = myModelConditionalBackendReqs.begin();  it != myModelConditionalBackendReqs.end();  ++it) { activeModelFlags[it->first] = false; }
      }
    }

Here is the caller graph for this function:

finishTiming()

void Gambit::module_functor_common::finishTiming ( int  thread_num )

protectedvirtual

Do post-calculate timing things.

Definition at line 1677 of file functors.cpp.

References end, fadeRate, FUNCTORS_BASE_INVALIDATION_RATE, needs_recalculating, pInvalidation, runtime_average, and start.

Referenced by Gambit::module_functor< void >::calculate().

    {
      end[thread_num] = std::chrono::system_clock::now();
      std::chrono::duration<double> runtime = end[thread_num] - start[thread_num];
      #pragma omp critical(module_functor_common_finishTiming)
      {
        runtime_average = runtime_average*(1-fadeRate) + fadeRate*runtime.count();
        pInvalidation = pInvalidation*(1-fadeRate) + fadeRate*FUNCTORS_BASE_INVALIDATION_RATE;
      }
      needs_recalculating[thread_num] = false;
    }

Here is the caller graph for this function:

forcematchingbackend()

std::set< sspair > Gambit::module_functor_common::forcematchingbackend ( str  tag )

virtual

Getter for listing backend requirements that must be resolved from the same backend.

Reimplemented from Gambit::functor.

Definition at line 975 of file functors.cpp.

References myForcedMatches.

    {
      if (myForcedMatches.find(tag) != myForcedMatches.end())
      {
        return myForcedMatches[tag];
      }
      else
      {
        std::set<sspair> empty;
        return empty;
      }
    }

getActiveModelFlag()

bool Gambit::module_functor_common::getActiveModelFlag

(

str

model

)

Indicate whether or not a known model is activated or not.

Definition at line 780 of file functors.cpp.

References activeModelFlags, LOCAL_INFO, Gambit::model_error(), Gambit::functor::myName, and Gambit::functor::myOrigin.

    {
      if (activeModelFlags.find(model) == activeModelFlags.end())
      {
        std::ostringstream ss;
        ss << "Problem with ModelInUse(\"" << model << "\")." << endl
           << "This model is not known by " << myOrigin << "::" << myName << "." << endl
           << "Please make sure that it has been mentioned in some context in the" << endl
           << "rollcall header declaration of this function.";
        model_error().raise(LOCAL_INFO,ss.str());
      }
      return activeModelFlags.at(model);
    }

Here is the call graph for this function:

getChosenReqFromGroup()

safe_ptr< str > Gambit::module_functor_common::getChosenReqFromGroup

(

str

group

)

Return a safe pointer to a string indicating which backend requirement has been activated for a given backend group.

Definition at line 795 of file functors.cpp.

References chosenReqsFromGroups, and combine_hdf5::group.

    {
      chosenReqsFromGroups[group] = "none";
      return safe_ptr<str>(&chosenReqsFromGroups[group]);
    }

getInvalidationRate()

double Gambit::module_functor_common::getInvalidationRate ( )

virtual

Getter for invalidation rate.

Reimplemented from Gambit::functor.

Definition at line 768 of file functors.cpp.

References pInvalidation.

    {
      return pInvalidation;
    }

getRuntimeAverage()

double Gambit::module_functor_common::getRuntimeAverage ( )

virtual

Getter for averaged runtime.

Reimplemented from Gambit::functor.

Definition at line 694 of file functors.cpp.

References runtime_average.

    {
      return runtime_average;
    }

init_memory()

void Gambit::module_functor_common::init_memory ( )

protectedvirtual

Initialise the memory of this functor.

Reimplemented in Gambit::module_functor< TYPE >, and Gambit::module_functor< ModelParameters >.

Definition at line 1617 of file functors.cpp.

References already_printed, already_printed_timing, end, globlMaxThreads, iRunNested, generate_raster_scan_settings::n, needs_recalculating, and start.

Referenced by reset().

    {
      int n = (iRunNested ? globlMaxThreads : 1);
      // Reserve enough space to hold as many timing points and recalculation flags as there are slots (threads) allowed
      if(start==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_start)
        {
          if(start==NULL) start = new std::chrono::time_point<std::chrono::system_clock>[n];
        }
      }
      if(end==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_end)
        {
          if(end==NULL) end = new std::chrono::time_point<std::chrono::system_clock>[n];
        }
      }
      if(needs_recalculating==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_needs_recalculating)
        {
          if(needs_recalculating==NULL)
          {
            needs_recalculating = new bool[n];
            std::fill(needs_recalculating, needs_recalculating+n, true);
          }
        }
      }
      if(already_printed==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_already_printed)
        {
          if(already_printed==NULL)
          {
            already_printed = new bool[n];
            std::fill(already_printed, already_printed+n, false);
          }
        }
      }
      if(already_printed_timing==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_already_printed_timing)
        {
          if(already_printed_timing==NULL)
          {
            already_printed_timing = new bool[n];
            std::fill(already_printed_timing, already_printed_timing+n, false);
          }
        }
      }
    }

Here is the caller graph for this function:

init_myCurrentIteration_if_NULL()

void Gambit::module_functor_common::init_myCurrentIteration_if_NULL ( )

virtual

Initialise the array holding the current iteration(s) of this functor.

Definition at line 835 of file functors.cpp.

References globlMaxThreads, iRunNested, and myCurrentIteration.

Referenced by iterationPtr(), and setIteration().

    {
      if(myCurrentIteration==NULL)
      {
        #pragma omp critical(module_functor_init_myCurrentIteration_if_NULL)
        {
          if(myCurrentIteration==NULL)  // Check again in case two threads managed to get this far in sequence.
          {
            // Set the number of slots to the max number of threads allowed iff this functor can run in parallel
            int nslots = (iRunNested ? globlMaxThreads : 1);
            // Reserve enough space to hold as many iteration numbers as there are slots (threads) allowed
            myCurrentIteration = new long long[nslots];
            // Zero them to start off
            std::fill(myCurrentIteration, myCurrentIteration+nslots, 0);
          }
        }
      }
    }

Here is the caller graph for this function:

iterate()

void Gambit::module_functor_common::iterate ( long long  iteration )

virtual

Execute a single iteration in the loop managed by this functor.

Definition at line 802 of file functors.cpp.

References acknowledgeInvalidation(), breakLoop(), and myNestedFunctorList.

    {
      if (not myNestedFunctorList.empty())
      {
        for (std::vector<functor*>::iterator it = myNestedFunctorList.begin();
         it != myNestedFunctorList.end(); ++it)
        {
          (*it)->setIteration(iteration);     // Tell the nested functor what iteration this is.
          try
          {
            (*it)->reset_and_calculate();     // Reset the nested functor so that it recalculates, then set it off
          }
          catch (invalid_point_exception& e)
          {
            acknowledgeInvalidation(e,*it);
            if (omp_get_level()==0) throw(e); // If not in an OpenMP parallel block, inform of invalidation and throw onwards
          }
          catch (halt_loop_exception& e)
          {
            // Skip the rest of the iteration, without trying to evaluate the rest of the loop, and wrap it up.
            breakLoop();
            break;
          }
          catch (invalid_loop_iteration_exception& e)
          {
            // Just skip on to the next iteration, without trying to evaluate the rest of the loop.
            break;
          }
        }
      }
    }

Here is the call graph for this function:

iterationPtr()

omp_safe_ptr< long long > Gambit::module_functor_common::iterationPtr ( )

virtual

Return a safe pointer to the iteration number in the loop in which this functor runs.

Definition at line 902 of file functors.cpp.

References init_myCurrentIteration_if_NULL(), and myCurrentIteration.

Referenced by Gambit::register_function_nesting().

    {
      init_myCurrentIteration_if_NULL();  // Init memory if this is the first run through.
      return omp_safe_ptr<long long>(myCurrentIteration);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

leaving_multithreaded_region()

void Gambit::module_functor_common::leaving_multithreaded_region ( )

inlineprotected

Definition at line 738 of file functors.hpp.

References Gambit::FunctorHelp::leaving_multithreaded_region().

Referenced by Gambit::module_functor< void >::calculate().

{ FunctorHelp::leaving_multithreaded_region(*this); }

Here is the call graph for this function:

Here is the caller graph for this function:

loopIsDone()

safe_ptr< bool > Gambit::module_functor_common::loopIsDone ( )

virtual

Return a safe pointer to the flag indicating that a loop managed by this functor should break now.

Definition at line 880 of file functors.cpp.

References myLoopIsDone.

Referenced by Gambit::register_function().

    {
      return safe_ptr<bool>(&myLoopIsDone);
    }

Here is the caller graph for this function:

loopManagerCapability()

str Gambit::module_functor_common::loopManagerCapability ( )

virtual

Getter for revealing the required capability of the wrapped function's loop manager.

Reimplemented from Gambit::functor.

Definition at line 921 of file functors.cpp.

References myLoopManagerCapability.

Referenced by Gambit::dep_bucket< TYPE >::use_thread_index().

{ return myLoopManagerCapability; }

Here is the caller graph for this function:

loopManagerName()

str Gambit::module_functor_common::loopManagerName ( )

virtual

Getter for revealing the name of the wrapped function's assigned loop manager.

Reimplemented from Gambit::functor.

Definition at line 925 of file functors.cpp.

References myLoopManager, and Gambit::functor::name().

Referenced by Gambit::dep_bucket< TYPE >::use_thread_index().

{ return (myLoopManager == NULL ? "none" : myLoopManager->name()); }

Here is the call graph for this function:

Here is the caller graph for this function:

loopManagerOrigin()

str Gambit::module_functor_common::loopManagerOrigin ( )

virtual

Getter for revealing the module of the wrapped function's assigned loop manager.

Reimplemented from Gambit::functor.

Definition at line 927 of file functors.cpp.

References myLoopManager, and Gambit::functor::origin().

Referenced by Gambit::dep_bucket< TYPE >::use_thread_index().

{ return (myLoopManager == NULL ? "none" : myLoopManager->origin()); }

Here is the call graph for this function:

Here is the caller graph for this function:

loopManagerType()

str Gambit::module_functor_common::loopManagerType ( )

virtual

Getter for revealing the required type of the wrapped function's loop manager.

Reimplemented from Gambit::functor.

Definition at line 923 of file functors.cpp.

References myLoopManagerType.

{ return myLoopManagerType; }

makeBackendMatchingRule()

void Gambit::module_functor_common::makeBackendMatchingRule

(

str

tag

)

Add one or more rules for forcing backends reqs with the same tags to always be resolved from the same backend.

Add one or more rules that force backends reqs with the same tag to always be resolved from the same backend.

Definition at line 1287 of file functors.cpp.

References backendreq_tagmap, Gambit::Utils::delimiterSplit(), LOCAL_INFO, myBackendReqs, myForcedMatches, Gambit::functor::name(), Gambit::functor::origin(), Gambit::Utils::strip_parentheses(), and Gambit::utils_error().

Referenced by Gambit::apply_backend_matching_rule().

    {
      //Strip the tag string of any parentheses, then split it
      Utils::strip_parentheses(tag);
      std::vector<str> tags = Utils::delimiterSplit(tag, ",");

      //Die if no tags were given.
      if (tags.empty())
      {
        str errmsg = "Problem whilst attempting to set backend-matching rule:";
        errmsg +=  "\nA call to FORCE_SAME_BACKEND must include at least one tag!"
                   "\nThis is " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }

      //Work with one tag at a time
      for (std::vector<str>::iterator tagit = tags.begin(); tagit != tags.end(); ++tagit)
      {
        std::set<sspair> matches;
        //Find all declared backend requirements that fit the current tag
        for (std::set<sspair>::iterator it = myBackendReqs.begin(); it != myBackendReqs.end(); ++it)
        {
          //Test if the current tag is amongst the tags listed for the current backend requirement
          std::set<str> its_tags = backendreq_tagmap[*it];
          if ( std::find(its_tags.begin(), its_tags.end(), *tagit) != its_tags.end() )
          {
            //It is; now place the current backend requirement into the set of matches
            matches.insert(*it);
          }
        }
        //Save the matched set of backend requirements as needing to be filled using the same backend.
        myForcedMatches[*tagit] = matches;
      }

      //Note that overlapping sets are explicitly left unmerged, as the common elements
      //may or may not be activated in a given scan, making the disjointedness of the
      //different sets determinable only at resolution time, not initialisation time.

    }

Here is the call graph for this function:

Here is the caller graph for this function:

makeBackendOptionRule()

void Gambit::module_functor_common::makeBackendOptionRule	(	str	be_and_ver,
		str	tag
	)

Add a rule for dictating which backends can be used to fulfill which backend requirements.

Definition at line 1222 of file functors.cpp.

References backendreq_tagmap, Gambit::Utils::delimiterSplit(), Gambit::Utils::is_disjoint(), LOCAL_INFO, myBackendReqs, Gambit::functor::name(), Gambit::functor::origin(), setPermittedBackend(), Gambit::Utils::strip_parentheses(), and Gambit::utils_error().

Referenced by Gambit::apply_backend_option_rule().

    {
      //Strip the tag and be-ver strings of their parentheses, then split them
      Utils::strip_parentheses(tag);
      Utils::strip_parentheses(be_and_ver);
      std::vector<str> v = Utils::delimiterSplit(tag, ",");
      std::set<str> tags(v.begin(), v.end());
      std::vector<str> be_plus_versions = Utils::delimiterSplit(be_and_ver, ",");

      //Die if no backend and/or no tags were given.
      if (tags.empty() or be_plus_versions.empty())
      {
        str errmsg = "Error whilst attempting to set permitted backends:";
        errmsg +=  "\nA BACKEND_OPTION must include a backend name and at least one tag."
                   "\nThis is " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }

      //Seperate the backend from the versions
      str be = be_plus_versions.at(0);
      std::vector<str> versions(be_plus_versions.begin()+1,be_plus_versions.end());
      if (versions.empty()) versions.push_back("any");

      //Find all declared backend requirements that fit one of the tags within the passed tag set.
      for (std::set<sspair>::iterator it = myBackendReqs.begin(); it != myBackendReqs.end(); ++it)
      {
        std::set<str> tagset = backendreq_tagmap[*it];
        if (not Utils::is_disjoint(tags, tagset))
        {
          // For each of the matching backend requirements, set the chosen backend-version pairs as permitted
          for (std::vector<str>::iterator vit = versions.begin() ; vit != versions.end(); ++vit)
          {
            setPermittedBackend(it->first, be, *vit);
          }
        }
      }

    }

Here is the call graph for this function:

Here is the caller graph for this function:

makeBackendRuleForModel()

void Gambit::module_functor_common::makeBackendRuleForModel	(	str	model,
		str	tag
	)

Add a rule for activating backend requirements according to the model being scanned.

Definition at line 1165 of file functors.cpp.

References backendreq_tagmap, Gambit::Utils::delimiterSplit(), Gambit::Utils::is_disjoint(), myBackendReqs, setModelConditionalBackendReq(), and Gambit::Utils::strip_parentheses().

    {
      //Strip the tag and model strings of their parentheses
      Utils::strip_parentheses(tag);
      Utils::strip_parentheses(model);

      //Split the tag string and sort it.
      std::vector<str> v = Utils::delimiterSplit(tag, ",");
      std::set<str> tags(v.begin(), v.end());

      //Find all declared backend requirements that fit one of the tags within the passed tag set.
      for (std::set<sspair>::iterator it = myBackendReqs.begin(); it != myBackendReqs.end(); ++it)
      {
        std::set<str> tagset = backendreq_tagmap[*it];
        if (not Utils::is_disjoint(tags, tagset))
        {
          // Make each of the matching backend requirements conditional on the models passed in.
          setModelConditionalBackendReq(model,it->first,it->second);
        }
      }

    }

Here is the call graph for this function:

model_conditional_backend_reqs()

std::set< sspair > Gambit::module_functor_common::model_conditional_backend_reqs ( str  model )

virtual

Getter for listing model-specific conditional backend requirements.

Reimplemented from Gambit::functor.

Definition at line 1036 of file functors.cpp.

References Gambit::functor::find_friend_or_parent_model_in_map(), and myModelConditionalBackendReqs.

Referenced by notifyOfModel().

    {
      str parent = find_friend_or_parent_model_in_map(model,myModelConditionalBackendReqs);
      if (parent != "") return myModelConditionalBackendReqs[parent];
      std::set<sspair> empty;
      return empty;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

model_conditional_dependencies()

std::set< sspair > Gambit::module_functor_common::model_conditional_dependencies ( str  model )

virtual

Getter for listing model-specific conditional dependencies.

Reimplemented from Gambit::functor.

Definition at line 1027 of file functors.cpp.

References Gambit::functor::find_friend_or_parent_model_in_map(), and myModelConditionalDependencies.

Referenced by notifyOfModel().

    {
      str parent = find_friend_or_parent_model_in_map(model,myModelConditionalDependencies);
      if (parent != "") return myModelConditionalDependencies[parent];
      std::set<sspair> empty;
      return empty;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

notifyOfBackends()

void Gambit::module_functor_common::notifyOfBackends ( std::map< str, std::set< str > >  be_ver_map )

virtual

Indicate to the functor which backends are actually loaded and working.

Reimplemented from Gambit::functor.

Definition at line 1341 of file functors.cpp.

References missing_backends, Gambit::functor::myStatus, and required_classloading_backends.

    {
      missing_backends.clear();
      // Loop over all the backends that are needed for this functor to work.
      for (auto it = required_classloading_backends.begin(); it != required_classloading_backends.end(); ++it)
      {
        // Check to make sure some version of the backend in question is connected.
        if (be_ver_map.find(it->first) == be_ver_map.end())
        {
          this->myStatus = -3;
          missing_backends.push_back(it->first);
        }
        else
        {  // Loop over all the versions of the backend that are needed for this functor to work.
          for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
          {
            std::set<str> versions = be_ver_map.at(it->first);
            // Check that the specific version needed is connected.
            if (versions.find(*jt) == versions.end())
            {
              this->myStatus = -3;
              missing_backends.push_back(it->first + ", v" + *jt);
            }
          }
        }
      }
    }

notifyOfDependee()

void Gambit::module_functor_common::notifyOfDependee ( functor *  dependent_functor )

virtual

Notify the functor that another functor depends on it.

Reimplemented from Gambit::functor.

Definition at line 1410 of file functors.cpp.

References dependency_functor_map, Gambit::functor::getDependees(), Gambit::functor::getSubCaps(), Gambit::functor::myDependees, Gambit::functor::notifyOfSubCaps(), and Gambit::functor::quantity().

    {
      // Add the dependent functor's capability-type pair to the list of dependees
      myDependees.insert(dependent_functor->quantity());
      // Inherit the dependent functor's own dependees
      for (const sspair& q : *(dependent_functor->getDependees())) { myDependees.insert(q); }
      // Inherit the dependent functor's subcaps
      notifyOfSubCaps(*(dependent_functor->getSubCaps()));
      // Notify all functors on which this one depends that they also now have a new dependent
      for (auto entry : dependency_functor_map) entry.second->notifyOfDependee(dependent_functor);
    }

Here is the call graph for this function:

notifyOfInvalidation()

void Gambit::module_functor_common::notifyOfInvalidation ( const str &  msg )

virtual

Tell the functor that it invalidated the current point in model space, pass a message explaining why, and throw an exception.

Reimplemented from Gambit::functor.

Definition at line 734 of file functors.cpp.

References acknowledgeInvalidation(), Gambit::invalid_point(), Gambit::invalid_point_exception::raise(), and retrieve_invalid_point_exception().

    {
      acknowledgeInvalidation(invalid_point());
      retrieve_invalid_point_exception()->raise(msg);
    }

Here is the call graph for this function:

notifyOfModel()

void Gambit::module_functor_common::notifyOfModel ( str  model )

virtual

Notify the functor that a certain model is being scanned, so that it can activate its dependencies and backend reqs accordingly.

Reimplemented from Gambit::functor.

Definition at line 1561 of file functors.cpp.

References activeModelFlags, backendreq_groups, Gambit::Models::ModelFunctorClaw::downstream_of(), fill_activeModelFlags(), model_conditional_backend_reqs(), model_conditional_dependencies(), Gambit::Models::ModelFunctorClaw::model_exists(), Gambit::functor::myClaw, myDependencies, myGroupedBackendReqs, myResolvableBackendReqs, and Gambit::functor::verbose.

    {
      // If activeModels hasn't been populated yet, make sure it is.
      fill_activeModelFlags();

      // Now activate the flags for the models that are being used.
      for (auto it = activeModelFlags.begin(); it != activeModelFlags.end(); ++it)
      {
        str activation_candidate = it->first;
        if (myClaw->model_exists(activation_candidate))
        {
          if (myClaw->downstream_of(model, activation_candidate))
          {
            // Found an activation candidate that the model being scanned can be cast to.
            // Assume for now that the candidate will indeed be activated.
            it->second = true;
            // Compare with models that have already been activated, to avoid activating multiple models of the same lineage.
            for (auto jt = activeModelFlags.begin(); jt != activeModelFlags.end(); ++jt)
            {
              str active_model = jt->first;
              if (activation_candidate != active_model and myClaw->model_exists(active_model) and jt->second)
              {
                // If the already active model can be upcast to the activation candidate, abort the activiation of the candidate.
                if (myClaw->downstream_of(active_model, activation_candidate)) it->second = false;
                // If the candidate can be upcast to the already active model, activate the candidate instead of the already active model.
                if (myClaw->downstream_of(activation_candidate, active_model)) jt->second = false;
                if (verbose)
                {
                  cout << "model: " << model << " " << "model to be activated: " << activation_candidate << "(" << it->second << ") active model: " << active_model << "(" << jt->second << ")" << endl;
                  cout << "active model lives below:" << myClaw->downstream_of(active_model, activation_candidate) << endl;
                  cout << "activation candidate lives below:" << myClaw->downstream_of(activation_candidate, active_model) << endl;
                }
              }
            }
            if (verbose) cout << "Activate candidate " << activation_candidate << "?" << it->second << endl;
          }
        }
      }

      // If this model fits any conditional dependencies (or descended from one that can be interpreted as one that fits any), then activate them.
      std::set<sspair> deps_to_activate = model_conditional_dependencies(model);
      for (std::set<sspair>::iterator it = deps_to_activate.begin() ; it != deps_to_activate.end(); ++it)
      {
        myDependencies.insert(*it);
      }
      // If this model fits any conditional backend requirements (or descended from one that can be interpreted as one that fits any), then activate them.
      std::set<sspair> backend_reqs_to_activate = model_conditional_backend_reqs(model);
      for (std::set<sspair>::iterator it = backend_reqs_to_activate.begin() ; it != backend_reqs_to_activate.end(); ++it)
      {
        if (verbose) cout << "req: " << it->first << " " << it->second << endl;
        myResolvableBackendReqs.insert(*it);
        myGroupedBackendReqs.at(backendreq_groups.at(*it)).insert(*it);
      }
    }

Here is the call graph for this function:

requiresTimingPrinting()

bool Gambit::module_functor_common::requiresTimingPrinting ( ) const

virtual

Getter indicating if the timing data for this function's execution should be printed.

Reimplemented from Gambit::functor.

Definition at line 706 of file functors.cpp.

References myTimingPrintFlag.

    {
      return myTimingPrintFlag;
    }

reset() [1/2]

void Gambit::module_functor_common::reset ( )

virtual

Reset functor.

Reset functor for all threads.

Reimplemented from Gambit::functor.

Definition at line 712 of file functors.cpp.

References already_printed, already_printed_timing, globlMaxThreads, iCanManageLoops, init_memory(), iRunNested, generate_raster_scan_settings::n, needs_recalculating, point_exception_raised, and resetLoop().

    {
      init_memory();
      int n = (iRunNested ? globlMaxThreads : 1);
      std::fill(needs_recalculating, needs_recalculating+n, true);
      std::fill(already_printed, already_printed+n, false);
      std::fill(already_printed_timing, already_printed_timing+n, false);
      if (iCanManageLoops) resetLoop();
      point_exception_raised = false;
    }

Here is the call graph for this function:

reset() [2/2]

void Gambit::module_functor_common::reset ( int  thread_num )

protectedvirtual

Reset functor for one thread only.

Reimplemented from Gambit::functor.

Definition at line 724 of file functors.cpp.

References already_printed, already_printed_timing, iCanManageLoops, init_memory(), needs_recalculating, and resetLoop().

    {
      init_memory();
      needs_recalculating[thread_num] = true;
      already_printed[thread_num] = false;
      already_printed_timing[thread_num] = false;
      if (iCanManageLoops) resetLoop();
    }

Here is the call graph for this function:

resetLoop()

void Gambit::module_functor_common::resetLoop ( )

virtual

Provide a way to reset the flag indicating that a loop managed by this functor should break.

Definition at line 886 of file functors.cpp.

References myLoopIsDone.

Referenced by reset().

    {
      #pragma omp critical (myLoopIsDone)
      {
        myLoopIsDone = false;
      }
    }

Here is the caller graph for this function:

resolveBackendReq()

void Gambit::module_functor_common::resolveBackendReq ( functor *  be_functor )

virtual

Resolve a backend requirement using a pointer to another functor object.

Reimplemented from Gambit::functor.

Definition at line 1446 of file functors.cpp.

References backend_conditional_dependencies(), backendreq_groups, backendreq_map, chosenReqsFromGroups, end, combine_hdf5::group, LOCAL_INFO, myDependencies, Gambit::functor::myName, Gambit::functor::myOrigin, Gambit::functor::origin(), permitted_map, Gambit::functor::quantity(), Gambit::functor::safe_version(), Gambit::functor::setStatus(), Gambit::utils_error(), and Gambit::functor::version().

    {

      sspair key (be_functor->quantity());

      //First make sure that the proposed backend function fulfills a known requirement of the module function.
      if (backendreq_map.find(key) != backendreq_map.end())
      {

        sspair proposal (be_functor->origin(), be_functor->version());  //Proposed backend-version pair
        sspair generic_proposal (be_functor->origin(), "any");          //Proposed backend, any version

        if ( //Check for a condition under which the proposed backend function is an acceptable fit for this requirement.
         //Check whether there are have been any permitted backends stated for this requirement (if not, anything goes).
         (permitted_map.find(key) == permitted_map.end()) ||
         //Iterate over the vector of backend-version pairs for this requirement to see if all versions of the
         //proposed backend have been explicitly permitted.
         (std::find(permitted_map[key].begin(), permitted_map[key].end(), generic_proposal) != permitted_map[key].end()) ||
         //Iterate over the vector of backend-version pairs again to see if the specific backend version
         //proposed had been explicitly permitted.
         (std::find(permitted_map[key].begin(), permitted_map[key].end(), proposal) != permitted_map[key].end()) )
        {

          //One of the conditions was met, so do the resolution.
          (*backendreq_map[key])(be_functor);

          //Set this backend functor's status to active.
          be_functor->setStatus(2);

          //If this is also the condition under which any backend-conditional dependencies should be activated, do it.
          std::set<sspair> deps_to_activate = backend_conditional_dependencies(be_functor);
          for (std::set<sspair>::iterator it = deps_to_activate.begin() ; it != deps_to_activate.end(); ++it)
          {
            myDependencies.insert(*it);
          }

          // Add a dependency on the initialisation function of the backend that this backend function hails from (if not done already).
          sspair be_ini_quantity(be_functor->origin() + "_" + be_functor->safe_version() + "_init", "void");
          if (std::find(myDependencies.begin(), myDependencies.end(), be_ini_quantity) == myDependencies.end())
          {
            myDependencies.insert(be_ini_quantity);
          }

          //Check if this backend requirement is part of a group.
          str group = backendreq_groups[key];
          if (group != "none")
          {
            //If it is part of a group, make sure that group has actually been declared.
            if (chosenReqsFromGroups.find(group) != chosenReqsFromGroups.end() )
            {
              //If it is part of a group, make sure another backend requirement from the same group has not already been activated.
              if (chosenReqsFromGroups[group] == "none")
              {
                //If not, then this this specific backend requirement is now the active one within its group.
                chosenReqsFromGroups[group] = key.first;
              }
              else //This backend requirement is not the first from its group to be resolved.
              {
                str errmsg = "Cannot resolve backend requirement in group " + group + ":";
                errmsg +=  "\nFunction " + myName + " in " + myOrigin + " has already had backend "
                           "\nrequirement " + chosenReqsFromGroups[group] + " from the same group filled.";
                utils_error().raise(LOCAL_INFO,errmsg);
              }
            }
            else //This backend requirement is part of group that was not declared.
            {
              str errmsg = "Cannot resolve backend requirement in group " + group + ":";
              errmsg +=  "\nThis group has not been declared.  Please add"
                         "\n BACKEND_GROUP("+group+")"
                         "\nTo the rollcall declaration of " + myName + " in " + myOrigin + ".";
              utils_error().raise(LOCAL_INFO,errmsg);
            }
          }

        }

        else //The proposed backend function is not an acceptable fit for this requirement.
        {
          str errmsg = "Cannot resolve backend requirement:";
          errmsg +=  "\nBackend capability " + key.first + " with type " + key.second +
                     "\nrequired by function " + myName + " in " + myOrigin + " is not permitted"
                     "\nto use " + proposal.first + ", version " + proposal.second + ".";
          utils_error().raise(LOCAL_INFO,errmsg);
        }

      }

      else //The proposed backend function does not fulfill any known requirement of the module function.
      {
        str errmsg = "Cannot resolve backend requirement:";
        errmsg +=  "\nFunction " + myName + " in " + myOrigin + " does not require"
                   "\nbackend capability " + key.first + " with type " + key.second + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }

    }

Here is the call graph for this function:

resolveDependency()

void Gambit::module_functor_common::resolveDependency ( functor *  dep_functor )

virtual

Resolve a dependency using a pointer to another functor object.

Reimplemented from Gambit::functor.

Definition at line 1386 of file functors.cpp.

References dependency_functor_map, dependency_map, LOCAL_INFO, myDependencies, Gambit::functor::myName, Gambit::functor::myOrigin, Gambit::functor::myPurpose, Gambit::functor::notifyOfDependee(), Gambit::functor::quantity(), Gambit::functor::setPurpose(), and Gambit::utils_error().

Referenced by resolveLoopManager().

    {
      sspair key (dep_functor->quantity());
      if (std::find(myDependencies.begin(), myDependencies.end(), key) == myDependencies.end())
      {
        str errmsg = "Cannot resolve dependency:";
        errmsg +=  "\nFunction " + myName + " in " + myOrigin + " does not depend on"
                   "\ncapability " + key.first + " with type = " + key.second + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      else
      {
        // resolve the dependency
        if (dependency_map.find(key) != dependency_map.end()) (*dependency_map[key])(dep_functor,this);
        // propagate purpose from next to next-to-output nodes
        dep_functor->setPurpose(this->myPurpose);
        // propagate this functor's dependees and subcaps on to the resolving functor
        dep_functor->notifyOfDependee(this);
        // save the pointer to the resolving functor to allow this functor to notify it of future dependees
        dependency_functor_map[key] = dep_functor;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveLoopManager()

void Gambit::module_functor_common::resolveLoopManager ( functor *  dep_functor )

virtual

Set this functor's loop manager (if it has one)

Reimplemented from Gambit::functor.

Definition at line 1423 of file functors.cpp.

References Gambit::functor::canBeLoopManager(), Gambit::functor::capability(), LOCAL_INFO, myLoopManager, myLoopManagerCapability, myLoopManagerType, Gambit::functor::myName, Gambit::functor::myOrigin, resolveDependency(), Gambit::functor::type(), and Gambit::utils_error().

    {
      if (dep_functor->capability() != myLoopManagerCapability or not dep_functor->canBeLoopManager())
      {
        utils_error().raise(LOCAL_INFO, "Cannot set loop manager for nested functor:\n"
         "Function " + myName + " in " + myOrigin + " does not need a loop manager with\n"
         "capability " + dep_functor->capability() + ".");
      }
      // Do type checking only if the need for a manger was declared with a specific type
      if (myLoopManagerType != "any")
      {
        if (dep_functor->type() != myLoopManagerType)
        {
          utils_error().raise(LOCAL_INFO, "Cannot set loop manager for nested functor:\n"
           "Function " + myName + " in " + myOrigin + " requires a manager with\n"
           "type " + dep_functor->type() + ".");
        }
        resolveDependency(dep_functor);
      }
      myLoopManager = dep_functor;
    }

Here is the call graph for this function:

retrieve_conditional_dep_type_pair()

sspair Gambit::module_functor_common::retrieve_conditional_dep_type_pair ( str  dep )

protected

Retrieve full conditional dependency-type pair from conditional dependency only.

Definition at line 1060 of file functors.cpp.

References LOCAL_INFO, myConditionalDependencies, Gambit::functor::name(), Gambit::functor::origin(), setBackendConditionalDependency(), and Gambit::utils_error().

Referenced by setBackendConditionalDependencySingular(), and setModelConditionalDependencySingular().

    {
      if (myConditionalDependencies.find(dep) == myConditionalDependencies.end())
      {
        str errmsg = "Problem whilst attempting to set conditional dependency:";
        errmsg +=  "\nThe conditional dependency " + dep + " appears not to have"
                   "\nbeen fully declared; START_CONDITIONAL_DEPENDENCY() is missing."
                   "\nThis is " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      return sspair(dep, myConditionalDependencies.at(dep));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

retrieve_invalid_point_exception()

invalid_point_exception * Gambit::module_functor_common::retrieve_invalid_point_exception ( )

virtual

Retrieve the previously saved exception generated when this functor invalidated the current point in model space.

Reimplemented from Gambit::functor.

Definition at line 756 of file functors.cpp.

References f, myNestedFunctorList, point_exception_raised, and raised_point_exception.

Referenced by notifyOfInvalidation().

    {
      if (point_exception_raised) return &raised_point_exception;
      for (auto f = myNestedFunctorList.begin(); f != myNestedFunctorList.end(); ++f)
      {
        invalid_point_exception* e = (*f)->retrieve_invalid_point_exception();
        if (e != NULL) return e;
      }
      return NULL;
    }

Here is the caller graph for this function:

setBackendConditionalDependency()

void Gambit::module_functor_common::setBackendConditionalDependency	(	str	req,
		str	be,
		str	ver,
		str	dep,
		void(*)(functor *, module_functor_common *)	resolver
	)

Add a backend conditional dependency for multiple backend versions.

Definition at line 1075 of file functors.cpp.

References Gambit::Utils::delimiterSplit(), and setBackendConditionalDependencySingular().

Referenced by Gambit::register_backend_conditional_dependency(), and retrieve_conditional_dep_type_pair().

    {
      // Split the version string and send each version to be registered
      std::vector<str> versions = Utils::delimiterSplit(ver, ",");
      for (std::vector<str>::iterator it = versions.begin() ; it != versions.end(); ++it)
      {
        setBackendConditionalDependencySingular(req, be, *it, dep, resolver);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setBackendConditionalDependencySingular()

void Gambit::module_functor_common::setBackendConditionalDependencySingular	(	str	req,
		str	be,
		str	ver,
		str	dep,
		void(*)(functor *, module_functor_common *)	resolver
	)

Add a backend conditional dependency for a single backend version.

Definition at line 1087 of file functors.cpp.

References backendreq_types, dependency_map, LOCAL_INFO, myBackendConditionalDependencies, Gambit::functor::name(), Gambit::functor::origin(), retrieve_conditional_dep_type_pair(), setModelConditionalDependency(), and Gambit::utils_error().

Referenced by setBackendConditionalDependency().

    {
      sspair key = retrieve_conditional_dep_type_pair(dep);
      std::vector<str> quad;
      if (backendreq_types.find(req) != backendreq_types.end())
      {
        quad.push_back(req);
        quad.push_back(backendreq_types[req]);
        quad.push_back(be);
        quad.push_back(ver);
      }
      else
      {
        str errmsg = "Problem whilst attempting to set backend-conditional dependency:";
        errmsg +=  "\nThe type of the backend requirement " + req + "on which the"
                   "\ndependency " + dep + " is conditional has not been set.  This"
                   "\nis " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      if (myBackendConditionalDependencies.find(quad) == myBackendConditionalDependencies.end())
      {
        std::set<sspair> newvec;
        myBackendConditionalDependencies[quad] = newvec;
      }
      myBackendConditionalDependencies[quad].insert(key);
      dependency_map[key] = resolver;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setBackendReq()

void Gambit::module_functor_common::setBackendReq	(	str	group,
		str	req,
		str	tags,
		str	type,
		void(*)(functor *)	resolver
	)

Add an unconditional backend requirement The info gets updated later if this turns out to be contitional on a model.

Add an unconditional backend requirement The info gets updated later if this turns out to be conditional on a model.

Definition at line 1143 of file functors.cpp.

References backendreq_groups, backendreq_map, backendreq_tagmap, backendreq_types, Gambit::Utils::delimiterSplit(), Gambit::Utils::fix_type(), combine_hdf5::group, myBackendReqs, myGroupedBackendReqs, myGroups, myResolvableBackendReqs, Gambit::Utils::strip_parentheses(), and Gambit::functor::type().

Referenced by Gambit::register_backend_requirement().

    {
      type = Utils::fix_type(type);
      sspair key (req, type);
      backendreq_types[req] = type;
      myBackendReqs.insert(key);
      myResolvableBackendReqs.insert(key);
      if ( std::find(myGroups.begin(), myGroups.end(), group) == myGroups.end() )
      {
        myGroups.insert(group);
        std::set<sspair> empty;
        myGroupedBackendReqs[group] = empty;
      }
      myGroupedBackendReqs[group].insert(key);
      backendreq_map[key] = resolver;
      Utils::strip_parentheses(tags);
      std::vector<str> v = Utils::delimiterSplit(tags, ",");
      backendreq_tagmap[key] = std::set<str>(v.begin(), v.end());
      backendreq_groups[key] = group;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setCanBeLoopManager()

void Gambit::module_functor_common::setCanBeLoopManager ( bool  canManage )

virtual

Setter for specifying whether this is permitted to be a manager functor, which runs other functors nested in a loop.

Definition at line 909 of file functors.cpp.

References iCanManageLoops.

Referenced by Gambit::register_function().

{ iCanManageLoops = canManage; }

Here is the caller graph for this function:

setConditionalDependency()

void Gambit::module_functor_common::setConditionalDependency	(	str	dep,
		str	dep_type
	)

Add conditional dependency-type pairs in advance of later conditions.

Definition at line 1054 of file functors.cpp.

References myConditionalDependencies.

Referenced by Gambit::register_conditional_dependency().

    {
      myConditionalDependencies[dep] = dep_type;
    }

Here is the caller graph for this function:

setDependency()

void Gambit::module_functor_common::setDependency	(	str	dep,
		str	dep_type,
		void(*)(functor *, module_functor_common *)	resolver,
		str	purpose = ""
	)

Add and activate unconditional dependencies.

Definition at line 1045 of file functors.cpp.

References dependency_map, Gambit::Utils::fix_type(), myDependencies, Gambit::functor::myPurpose, and Gambit::functor::purpose().

Referenced by Gambit::register_dependency().

    {
      sspair key (dep, Utils::fix_type(dep_type));
      myDependencies.insert(key);
      dependency_map[key] = resolver;
      this->myPurpose = purpose; // only relevant for output nodes
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setFadeRate()

void Gambit::module_functor_common::setFadeRate ( double  new_rate )

virtual

Setter for the fade rate.

Reimplemented from Gambit::functor.

Definition at line 774 of file functors.cpp.

References fadeRate.

    {
      fadeRate = new_rate;
    }

setIteration()

void Gambit::module_functor_common::setIteration ( long long  iteration )

virtual

Setter for setting the iteration number in the loop in which this functor runs.

Reimplemented from Gambit::functor.

Definition at line 895 of file functors.cpp.

References init_myCurrentIteration_if_NULL(), and myCurrentIteration.

    {
      init_myCurrentIteration_if_NULL(); // Init memory if this is the first run through.
      myCurrentIteration[omp_get_thread_num()] = iteration;
    }

Here is the call graph for this function:

setLoopManagerCapType()

void Gambit::module_functor_common::setLoopManagerCapType ( str  cap, str  t  )

virtual

Setter for specifying the capability required of a manager functor, if it is to run this functor nested in a loop.

Setter for specifying the capability and type required of a manager functor, if it is to run this functor nested in a loop.

Definition at line 914 of file functors.cpp.

References iRunNested, myLoopManagerCapability, and myLoopManagerType.

Referenced by Gambit::register_function_nesting().

    {
      iRunNested = true;
      myLoopManagerCapability = cap;
      myLoopManagerType = t;
    }

Here is the caller graph for this function:

setModelConditionalBackendReq()

void Gambit::module_functor_common::setModelConditionalBackendReq	(	str	model,
		str	req,
		str	type
	)

Add a model conditional backend requirement for multiple models.

Definition at line 1190 of file functors.cpp.

References Gambit::Utils::delimiterSplit(), Gambit::LogTags::models, and setModelConditionalBackendReqSingular().

Referenced by makeBackendRuleForModel().

    {
      // Split the model string and send each model to be registered
      std::vector<str> models = Utils::delimiterSplit(model, ",");
      for (std::vector<str>::iterator it = models.begin() ; it != models.end(); ++it)
      {
        setModelConditionalBackendReqSingular(*it, req, type);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setModelConditionalBackendReqSingular()

void Gambit::module_functor_common::setModelConditionalBackendReqSingular	(	str	model,
		str	req,
		str	type
	)

Add a model conditional backend requirement for a single model.

Definition at line 1202 of file functors.cpp.

References backendreq_groups, Gambit::Utils::fix_type(), myGroupedBackendReqs, myModelConditionalBackendReqs, and myResolvableBackendReqs.

Referenced by setModelConditionalBackendReq().

    {
      sspair key (req, Utils::fix_type(type));

      // Remove the entry from the resolvable backend reqs list...
      myResolvableBackendReqs.erase(key);

      // Remove the entry from the grouped backend reqs list...
      myGroupedBackendReqs.at(backendreq_groups.at(key)).erase(key);

      // Check that the model is not already in the conditional backend reqs list, then add it
      if (myModelConditionalBackendReqs.find(model) == myModelConditionalBackendReqs.end())
      {
        std::set<sspair> newvec;
        myModelConditionalBackendReqs[model] = newvec;
      }
      myModelConditionalBackendReqs[model].insert(key);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setModelConditionalDependency()

void Gambit::module_functor_common::setModelConditionalDependency	(	str	model,
		str	dep,
		void(*)(functor *, module_functor_common *)	resolver
	)

Add a model conditional dependency for multiple models.

Definition at line 1117 of file functors.cpp.

References Gambit::Utils::delimiterSplit(), Gambit::LogTags::models, and setModelConditionalDependencySingular().

Referenced by Gambit::register_model_conditional_dependency(), and setBackendConditionalDependencySingular().

    {
      // Split the model string and send each model to be registered
      std::vector<str> models = Utils::delimiterSplit(model, ",");
      for (std::vector<str>::iterator it = models.begin() ; it != models.end(); ++it)
      {
        setModelConditionalDependencySingular(*it, dep, resolver);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setModelConditionalDependencySingular()

void Gambit::module_functor_common::setModelConditionalDependencySingular	(	str	model,
		str	dep,
		void(*)(functor *, module_functor_common *)	resolver
	)

Add a model conditional dependency for a single model.

Definition at line 1129 of file functors.cpp.

References dependency_map, myModelConditionalDependencies, and retrieve_conditional_dep_type_pair().

Referenced by setModelConditionalDependency().

    {
      sspair key = retrieve_conditional_dep_type_pair(dep);
      if (myModelConditionalDependencies.find(model) == myModelConditionalDependencies.end())
      {
        std::set<sspair> newvec;
        myModelConditionalDependencies[model] = newvec;
      }
      myModelConditionalDependencies[model].insert(key);
      dependency_map[key] = resolver;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setNestedList()

void Gambit::module_functor_common::setNestedList ( std::vector< functor *> &  newNestedList )

virtual

Set the ordered list of pointers to other functors that should run nested in a loop managed by this one.

Reimplemented from Gambit::functor.

Definition at line 1370 of file functors.cpp.

References iCanManageLoops, LOCAL_INFO, myNestedFunctorList, Gambit::functor::name(), Gambit::functor::origin(), and Gambit::utils_error().

    {
      if (iCanManageLoops)
      {
        myNestedFunctorList = newNestedList;
      }
      else
      {
        str errmsg = "This module functor is not permitted to manage";
        errmsg +=  "\nloops, so you cannot set its nested functor list."
                   "\nThis is " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
    }

Here is the call graph for this function:

setPermittedBackend()

void Gambit::module_functor_common::setPermittedBackend	(	str	req,
		str	be,
		str	ver
	)

Add a single permitted backend version.

Definition at line 1262 of file functors.cpp.

References backendreq_types, LOCAL_INFO, Gambit::functor::name(), Gambit::functor::origin(), permitted_map, and Gambit::utils_error().

Referenced by makeBackendOptionRule().

    {
      sspair key;
      if (backendreq_types.find(req) != backendreq_types.end())
      {
        key = std::make_pair(req, backendreq_types[req]);
      }
      else
      {
        str errmsg = "Error whilst attempting to set permitted backend:";
        errmsg += "\nThe return type of the backend requirement " + req + "is not set."
                  "\nThis probably means the backend requirement has not been declared."
                  "\nThis is " + this->name() + " in " + this->origin() + ".";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      sspair vector_entry (be,  ver);
      if (permitted_map.find(key) == permitted_map.end())
      {
        std::set<sspair> newvec;
        permitted_map[key] = newvec;
      }
      permitted_map[key].insert(vector_entry);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setRequiredClassloader()

void Gambit::module_functor_common::setRequiredClassloader	(	str	be,
		str	ver,
		str	safe_ver
	)

Add a rule indicating that classes from a given backend must be available.

Definition at line 1328 of file functors.cpp.

References myDependencies, and required_classloading_backends.

    {
      // Add the rule.
      required_classloading_backends[be].insert(ver);
      // Add a dependency on the backend's initialisation function.
      sspair be_ini_quantity(be + "_" + safe_ver + "_init", "void");
      if (std::find(myDependencies.begin(), myDependencies.end(), be_ini_quantity) == myDependencies.end())
      {
        myDependencies.insert(be_ini_quantity);
      }
    }

setTimingPrintRequirement()

void Gambit::module_functor_common::setTimingPrintRequirement ( bool  flag )

virtual

Setter for indicating if the timing data for this function's execution should be printed.

Reimplemented from Gambit::functor.

Definition at line 700 of file functors.cpp.

References myTimingPrintFlag.

    {
      myTimingPrintFlag = flag;
    }

startTiming()

void Gambit::module_functor_common::startTiming ( int  thread_num )

protectedvirtual

Do pre-calculate timing things.

Definition at line 1671 of file functors.cpp.

References start.

Referenced by Gambit::module_functor< void >::calculate().

    {
      start[thread_num] = std::chrono::system_clock::now();
    }

Here is the caller graph for this function:

Friends And Related Function Documentation

FunctorHelp::entering_multithreaded_region

void FunctorHelp::entering_multithreaded_region ( module_functor_common &  )

friend

Connectors to external helper functions (to decouple signal handling from this class)

FunctorHelp::leaving_multithreaded_region

void FunctorHelp::leaving_multithreaded_region ( module_functor_common &  )

friend

Member Data Documentation

activeModelFlags

std::map<str, bool> Gambit::module_functor_common::activeModelFlags

protected

Map from known models to flags indicating if they are activated or not (known = allowed, in allowed groups or conditions for conditional dependencies)

Definition at line 679 of file functors.hpp.

Referenced by fill_activeModelFlags(), getActiveModelFlag(), and notifyOfModel().

already_printed

bool* Gambit::module_functor_common::already_printed

protected

Has result already been sent to the printer?

Definition at line 618 of file functors.hpp.

Referenced by init_memory(), reset(), and ~module_functor_common().

already_printed_timing

bool* Gambit::module_functor_common::already_printed_timing

protected

Has timing data already been sent to the printer?

Definition at line 621 of file functors.hpp.

Referenced by init_memory(), reset(), and ~module_functor_common().

backendreq_groups

std::map<sspair, str> Gambit::module_functor_common::backendreq_groups

protected

Map from backend requirements to their designated groups.

Definition at line 693 of file functors.hpp.

Referenced by notifyOfModel(), resolveBackendReq(), setBackendReq(), and setModelConditionalBackendReqSingular().

backendreq_map

std::map<sspair, void(*)(functor*)> Gambit::module_functor_common::backendreq_map

protected

Map from (backend requirement-type pairs) to (pointers to templated void functions that set backend requirement functor pointers)

Definition at line 700 of file functors.hpp.

Referenced by resolveBackendReq(), and setBackendReq().

backendreq_tagmap

std::map<sspair, std::set<str> > Gambit::module_functor_common::backendreq_tagmap

protected

Map from backend requirements to their rule tags.

Definition at line 696 of file functors.hpp.

Referenced by backendreq_tags(), makeBackendMatchingRule(), makeBackendOptionRule(), makeBackendRuleForModel(), and setBackendReq().

backendreq_types

std::map<str, str> Gambit::module_functor_common::backendreq_types

protected

Map from backend requirements to their required types.

Definition at line 690 of file functors.hpp.

Referenced by setBackendConditionalDependencySingular(), setBackendReq(), and setPermittedBackend().

chosenReqsFromGroups

std::map<str,str> Gambit::module_functor_common::chosenReqsFromGroups

protected

Map from groups to backend reqs, indicating which backend req has been activated for which backend group.

Definition at line 652 of file functors.hpp.

Referenced by getChosenReqFromGroup(), and resolveBackendReq().

dependency_functor_map

std::map<sspair, functor*> Gambit::module_functor_common::dependency_functor_map

protected

Map from (dependency-type pairs) to pointers to functors used to resolve them that set dependency functor pointers)

Definition at line 687 of file functors.hpp.

Referenced by notifyOfDependee(), and resolveDependency().

dependency_map

std::map<sspair, void(*)(functor*, module_functor_common*)> Gambit::module_functor_common::dependency_map

protected

Map from (dependency-type pairs) to (pointers to templated void functions that set dependency functor pointers)

Definition at line 683 of file functors.hpp.

Referenced by resolveDependency(), setBackendConditionalDependencySingular(), setDependency(), and setModelConditionalDependencySingular().

end

std::chrono::time_point<std::chrono::system_clock> * Gambit::module_functor_common::end

protected

Definition at line 597 of file functors.hpp.

Referenced by finishTiming(), init_memory(), resolveBackendReq(), and ~module_functor_common().

fadeRate

double Gambit::module_functor_common::fadeRate

protected

Fade rate for average runtime.

Definition at line 609 of file functors.hpp.

Referenced by acknowledgeInvalidation(), finishTiming(), and setFadeRate().

globlMaxThreads

const int Gambit::module_functor_common::globlMaxThreads

protected

Maximum number of OpenMP threads this MPI process is permitted to launch in total.

Definition at line 646 of file functors.hpp.

Referenced by init_memory(), init_myCurrentIteration_if_NULL(), module_functor_common(), and reset().

iCanManageLoops

bool Gambit::module_functor_common::iCanManageLoops

protected

Flag indicating whether this function can manage a loop over other functions.

Definition at line 624 of file functors.hpp.

Referenced by canBeLoopManager(), Gambit::FunctorHelp::entering_multithreaded_region(), Gambit::FunctorHelp::leaving_multithreaded_region(), reset(), setCanBeLoopManager(), and setNestedList().

iRunNested

bool Gambit::module_functor_common::iRunNested

protected

Flag indicating whether this function can run nested in a loop over functions.

Definition at line 630 of file functors.hpp.

Referenced by init_memory(), init_myCurrentIteration_if_NULL(), reset(), and setLoopManagerCapType().

missing_backends

std::vector<str> Gambit::module_functor_common::missing_backends

protected

Vector of required backends currently missing.

Definition at line 712 of file functors.hpp.

Referenced by Gambit::module_functor< void >::calculate(), and notifyOfBackends().

myBackendConditionalDependencies

std::map< std::vector<str>, std::set<sspair> > Gambit::module_functor_common::myBackendConditionalDependencies

protected

Map from (vector with 4 strings: backend req, type, backend, version) to (set of {conditional dependency-type} pairs)

Definition at line 670 of file functors.hpp.

Referenced by backend_conditional_dependencies(), and setBackendConditionalDependencySingular().

myBackendReqs

std::set<sspair> Gambit::module_functor_common::myBackendReqs

protected

Set of all backend requirement-type string pairs.

Definition at line 655 of file functors.hpp.

Referenced by makeBackendMatchingRule(), makeBackendOptionRule(), makeBackendRuleForModel(), and setBackendReq().

myConditionalDependencies

std::map<str,str> Gambit::module_functor_common::myConditionalDependencies

protected

Map of conditional dependencies to their types.

Definition at line 667 of file functors.hpp.

Referenced by retrieve_conditional_dep_type_pair(), and setConditionalDependency().

myCurrentIteration

long long* Gambit::module_functor_common::myCurrentIteration

protected

Pointer to counters for iterations of nested functor loop.

Definition at line 643 of file functors.hpp.

Referenced by init_myCurrentIteration_if_NULL(), iterationPtr(), setIteration(), and ~module_functor_common().

myDependencies

std::set<sspair> Gambit::module_functor_common::myDependencies

protected

Vector of dependency-type string pairs.

Definition at line 664 of file functors.hpp.

Referenced by dependencies(), notifyOfModel(), resolveBackendReq(), resolveDependency(), setDependency(), and setRequiredClassloader().

myForcedMatches

std::map< str, std::set<sspair> > Gambit::module_functor_common::myForcedMatches

protected

Map from tags to sets of matching (backend requirement-type pairs) that are forced to use the same backend.

Definition at line 706 of file functors.hpp.

Referenced by forcematchingbackend(), and makeBackendMatchingRule().

myGroupedBackendReqs

std::map<str,std::set<sspair> > Gambit::module_functor_common::myGroupedBackendReqs

protected

Set of backend requirement-type string pairs for specific backend groups.

Definition at line 661 of file functors.hpp.

Referenced by backendreqs(), notifyOfModel(), setBackendReq(), and setModelConditionalBackendReqSingular().

myGroups

std::set<str> Gambit::module_functor_common::myGroups

protected

Internal list of backend groups that this functor's requirements fall into.

Definition at line 649 of file functors.hpp.

Referenced by backendgroups(), and setBackendReq().

myLogTag

int Gambit::module_functor_common::myLogTag

protected

Integer LogTag, for tagging log messages.

Definition at line 718 of file functors.hpp.

Referenced by Gambit::module_functor< void >::calculate(), check_missing_LogTag(), and module_functor_common().

myLoopIsDone

bool Gambit::module_functor_common::myLoopIsDone

protected

Flag indicating whether this function is ready to finish its loop (only relevant if iCanManageLoops = true)

Definition at line 627 of file functors.hpp.

Referenced by breakLoop(), loopIsDone(), and resetLoop().

myLoopManager

functor* Gambit::module_functor_common::myLoopManager

protected

Pointer to the functor that mangages the loop that this function runs inside of.

Definition at line 637 of file functors.hpp.

Referenced by breakLoopFromManagedFunctor(), loopManagerName(), loopManagerOrigin(), and resolveLoopManager().

myLoopManagerCapability

str Gambit::module_functor_common::myLoopManagerCapability

protected

Capability of a function that mangages a loop that this function can run inside of.

Definition at line 633 of file functors.hpp.

Referenced by loopManagerCapability(), resolveLoopManager(), and setLoopManagerCapType().

myLoopManagerType

str Gambit::module_functor_common::myLoopManagerType

protected

Capability of a function that mangages a loop that this function can run inside of.

Definition at line 635 of file functors.hpp.

Referenced by loopManagerType(), resolveLoopManager(), and setLoopManagerCapType().

myModelConditionalBackendReqs

std::map< str, std::set<sspair> > Gambit::module_functor_common::myModelConditionalBackendReqs

protected

Map from models to (set of {conditional backend requirement-type} pairs)

Definition at line 676 of file functors.hpp.

Referenced by fill_activeModelFlags(), model_conditional_backend_reqs(), and setModelConditionalBackendReqSingular().

myModelConditionalDependencies

std::map< str, std::set<sspair> > Gambit::module_functor_common::myModelConditionalDependencies

protected

Map from models to (set of {conditional dependency-type} pairs)

Definition at line 673 of file functors.hpp.

Referenced by fill_activeModelFlags(), model_conditional_dependencies(), and setModelConditionalDependencySingular().

myNestedFunctorList

std::vector<functor*> Gambit::module_functor_common::myNestedFunctorList

protected

Vector of functors that have been set up to run nested within this one.

Definition at line 640 of file functors.hpp.

Referenced by iterate(), retrieve_invalid_point_exception(), and setNestedList().

myResolvableBackendReqs

std::set<sspair> Gambit::module_functor_common::myResolvableBackendReqs

protected

Set of all backend requirement-type string pairs currently available for resolution.

Definition at line 658 of file functors.hpp.

Referenced by backendreqs(), notifyOfModel(), setBackendReq(), and setModelConditionalBackendReqSingular().

myTimingPrintFlag

bool Gambit::module_functor_common::myTimingPrintFlag

protected

Flag to select whether or not the timing data for this function's execution should be printed;.

Definition at line 585 of file functors.hpp.

Referenced by requiresTimingPrinting(), and setTimingPrintRequirement().

needs_recalculating

bool* Gambit::module_functor_common::needs_recalculating

protected

Needs recalculating or not?

Definition at line 615 of file functors.hpp.

Referenced by Gambit::module_functor< void >::calculate(), finishTiming(), init_memory(), reset(), and ~module_functor_common().

permitted_map

std::map< sspair, std::set<sspair> > Gambit::module_functor_common::permitted_map

protected

Map from (backend requirement-type pairs) to (set of permitted {backend-version} pairs)

Definition at line 703 of file functors.hpp.

Referenced by backendspermitted(), resolveBackendReq(), and setPermittedBackend().

pInvalidation

double Gambit::module_functor_common::pInvalidation

protected

Probability that functors invalidates point in model parameter space.

Definition at line 612 of file functors.hpp.

Referenced by acknowledgeInvalidation(), finishTiming(), and getInvalidationRate().

point_exception_raised

bool Gambit::module_functor_common::point_exception_raised

protected

A flag indicating whether or not this functor has invalidated the current point.

Definition at line 600 of file functors.hpp.

Referenced by acknowledgeInvalidation(), Gambit::module_functor< void >::calculate(), reset(), and retrieve_invalid_point_exception().

raised_point_exception

invalid_point_exception Gambit::module_functor_common::raised_point_exception

protected

An exception raised because this functor has invalidated the current point.

Definition at line 603 of file functors.hpp.

Referenced by acknowledgeInvalidation(), and retrieve_invalid_point_exception().

required_classloading_backends

std::map< str, std::set<str> > Gambit::module_functor_common::required_classloading_backends

protected

Map from required classloading backends to their versions.

Definition at line 709 of file functors.hpp.

Referenced by notifyOfBackends(), and setRequiredClassloader().

runtime_average

double Gambit::module_functor_common::runtime_average

protected

Averaged runtime in ns.

Definition at line 606 of file functors.hpp.

Referenced by finishTiming(), and getRuntimeAverage().

signal_mode_locked

bool Gambit::module_functor_common::signal_mode_locked = true

protected

While locked, prevent this function switching off threadsafe* emergency signal handling.

*The emergency signal handling cannot be made completely threadsafe; it can still cause lockups and memory corruption if it occurs at an inopportune time. "soft" shutdown is always preferable.

Definition at line 727 of file functors.hpp.

Referenced by Gambit::FunctorHelp::entering_multithreaded_region(), and Gambit::FunctorHelp::leaving_multithreaded_region().

start

std::chrono::time_point<std::chrono::system_clock>* Gambit::module_functor_common::start

protected

Beginning and end timing points.

Definition at line 597 of file functors.hpp.

Referenced by finishTiming(), init_memory(), startTiming(), and ~module_functor_common().

tp

timespec Gambit::module_functor_common::tp

protected

Internal timespec object.

Definition at line 715 of file functors.hpp.

---

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

• Elements/include/gambit/Elements/functors.hpp
• Elements/src/functors.cpp