class Gambit::module_functor_common #

Functor derived class for module functions.

#include <functors.hpp>

Inherits from Gambit::functor

Inherited by Gambit::module_functor< ModelParameters >, Gambit::module_functor< TYPE >, Gambit::module_functor< void >

Public Functions #

Protected Functions #

Protected Attributes #

Friends #

Additional inherited members #

Public Functions inherited from Gambit::functor

Protected Functions inherited from Gambit::functor

Protected Attributes inherited from Gambit::functor

Public Functions Documentation #

function module_functor_common #

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

Constructor.

function ~module_functor_common #

virtual ~module_functor_common()

Destructor.

function getRuntimeAverage #

virtual double getRuntimeAverage()

Getter for averaged runtime.

Reimplements: Gambit::functor::getRuntimeAverage

function reset #

virtual void reset()

Reset functor.

Reimplements: Gambit::functor::reset

Reset functor for all threads.

function notifyOfInvalidation #

virtual void notifyOfInvalidation(
    const str & msg
)

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

Reimplements: Gambit::functor::notifyOfInvalidation

function getInvalidationRate #

virtual double getInvalidationRate()

Getter for invalidation rate.

Reimplements: Gambit::functor::getInvalidationRate

function setFadeRate #

virtual void setFadeRate(
    double new_rate
)

Setter for the fade rate.

Reimplements: Gambit::functor::setFadeRate

function setTimingPrintRequirement #

virtual void setTimingPrintRequirement(
    bool flag
)

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

Reimplements: Gambit::functor::setTimingPrintRequirement

function requiresTimingPrinting #

virtual bool requiresTimingPrinting() const

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

Reimplements: Gambit::functor::requiresTimingPrinting

function getActiveModelFlag #

bool getActiveModelFlag(
    str model
)

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

function getChosenReqFromGroup #

safe_ptr< str > getChosenReqFromGroup(
    str group
)

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

function iterate #

virtual void iterate(
    long long iteration
)

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

function init_myCurrentIteration_if_NULL #

virtual void init_myCurrentIteration_if_NULL()

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

function setIteration #

virtual void setIteration(
    long long iteration
)

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

Reimplements: Gambit::functor::setIteration

function iterationPtr #

virtual omp_safe_ptr< long long > iterationPtr()

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

function setCanBeLoopManager #

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.

function canBeLoopManager #

virtual bool canBeLoopManager()

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

Reimplements: Gambit::functor::canBeLoopManager

function setLoopManagerCapType #

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.

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

function needsLoopManager #

virtual bool needsLoopManager()

Getter for revealing whether this functor needs a loop manager.

Reimplements: Gambit::functor::needsLoopManager

function loopManagerCapability #

virtual str loopManagerCapability()

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

Reimplements: Gambit::functor::loopManagerCapability

function loopManagerType #

virtual str loopManagerType()

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

Reimplements: Gambit::functor::loopManagerType

function loopManagerName #

virtual str loopManagerName()

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

Reimplements: Gambit::functor::loopManagerName

function loopManagerOrigin #

virtual str loopManagerOrigin()

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

Reimplements: Gambit::functor::loopManagerOrigin

function breakLoopFromManagedFunctor #

virtual void breakLoopFromManagedFunctor()

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

function loopIsDone #

virtual safe_ptr< bool > loopIsDone()

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

function resetLoop #

virtual void resetLoop()

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

function breakLoop #

virtual void breakLoop()

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

Reimplements: Gambit::functor::breakLoop

function dependencies #

virtual std::set< sspair > dependencies()

Getter for listing currently activated dependencies.

Reimplements: Gambit::functor::dependencies

function backendclassloading #

virtual std::set< sspair > backendclassloading()

Getter for listing backends that require class loading.

Reimplements: Gambit::functor::backendclassloading

function backendgroups #

virtual std::set< str > backendgroups()

Getter for listing backend requirement groups.

Reimplements: Gambit::functor::backendgroups

function backendreqs #

virtual std::set< sspair > backendreqs()

Getter for listing all backend requirements.

Reimplements: Gambit::functor::backendreqs

function backendreqs #

virtual std::set< sspair > backendreqs(
    str group
)

Getter for listing backend requirements from a specific group.

Reimplements: Gambit::functor::backendreqs

function backendspermitted #

virtual std::set< sspair > backendspermitted(
    sspair quant
)

Getter for listing permitted backends.

Reimplements: Gambit::functor::backendspermitted

function backendreq_tags #

virtual std::set< str > backendreq_tags(
    sspair quant
)

Getter for listing tags associated with backend requirements.

Reimplements: Gambit::functor::backendreq_tags

function forcematchingbackend #

virtual std::set< sspair > forcematchingbackend(
    str tag
)

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

Reimplements: Gambit::functor::forcematchingbackend

function backend_conditional_dependencies #

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)

Reimplements: Gambit::functor::backend_conditional_dependencies

function backend_conditional_dependencies #

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

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

Reimplements: Gambit::functor::backend_conditional_dependencies

function backend_conditional_dependencies #

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

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

Reimplements: Gambit::functor::backend_conditional_dependencies

function model_conditional_dependencies #

virtual std::set< sspair > model_conditional_dependencies(
    str model
)

Getter for listing model-specific conditional dependencies (matches also on parents and friends)

Reimplements: Gambit::functor::model_conditional_dependencies

function model_conditional_dependencies_exact #

virtual std::set< sspair > model_conditional_dependencies_exact(
    str model
)

Getter for listing model-specific conditional dependencies (matches on the exact model)

Reimplements: Gambit::functor::model_conditional_dependencies_exact

function model_conditional_backend_reqs #

virtual std::set< sspair > model_conditional_backend_reqs(
    str model
)

Getter for listing model-specific conditional backend requirements (matches also on parents and friends)

Reimplements: Gambit::functor::model_conditional_backend_reqs

function model_conditional_backend_reqs_exact #

virtual std::set< sspair > model_conditional_backend_reqs_exact(
    str model
)

Getter for listing model-specific conditional backend requirements (matches on the exact model)

Reimplements: Gambit::functor::model_conditional_backend_reqs_exact

function setDependency #

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

Add and activate unconditional dependencies.

function setConditionalDependency #

void setConditionalDependency(
    str dep,
    str dep_type
)

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

function setBackendConditionalDependency #

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

Add a backend conditional dependency for multiple backend versions.

function setBackendConditionalDependencySingular #

void 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.

function setModelConditionalDependency #

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

Add a model conditional dependency for multiple models.

function setModelConditionalDependencySingular #

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

Add a model conditional dependency for a single model.

function makeBackendRuleForModel #

void makeBackendRuleForModel(
    str model,
    str tag
)

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

function setBackendReq #

void 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.

function setModelConditionalBackendReq #

void setModelConditionalBackendReq(
    str model,
    str req,
    str type
)

Add a model conditional backend requirement for multiple models.

function setModelConditionalBackendReqSingular #

void setModelConditionalBackendReqSingular(
    str model,
    str req,
    str type
)

Add a model conditional backend requirement for a single model.

function makeBackendOptionRule #

void makeBackendOptionRule(
    str be_and_ver,
    str tag
)

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

function setPermittedBackend #

void setPermittedBackend(
    str req,
    str be,
    str ver
)

Add a single permitted backend version.

function makeBackendMatchingRule #

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.

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

function setRequiredClassloader #

void setRequiredClassloader(
    str be,
    str ver,
    str safe_ver
)

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

function notifyOfBackends #

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

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

Reimplements: Gambit::functor::notifyOfBackends

function setNestedList #

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.

Reimplements: Gambit::functor::setNestedList

function resolveDependency #

virtual void resolveDependency(
    functor * dep_functor
)

Resolve a dependency using a pointer to another functor object.

Reimplements: Gambit::functor::resolveDependency

function resolveLoopManager #

virtual void resolveLoopManager(
    functor * dep_functor
)

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

Reimplements: Gambit::functor::resolveLoopManager

function resolveBackendReq #

virtual void resolveBackendReq(
    functor * be_functor
)

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

Reimplements: Gambit::functor::resolveBackendReq

function notifyOfModel #

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.

Reimplements: Gambit::functor::notifyOfModel

function notifyOfDependee #

virtual void notifyOfDependee(
    functor * dependent_functor
)

Notify the functor that another functor depends on it.

Reimplements: Gambit::functor::notifyOfDependee

function retrieve_invalid_point_exception #

virtual invalid_point_exception * retrieve_invalid_point_exception()

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

Reimplements: Gambit::functor::retrieve_invalid_point_exception

Protected Functions Documentation #

function reset #

virtual void reset(
    int thread_num
)

Reset functor for one thread only.

Reimplements: Gambit::functor::reset

function acknowledgeInvalidation #

virtual void acknowledgeInvalidation(
    invalid_point_exception & e,
    functor * f =NULL
)

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

function startTiming #

virtual void startTiming(
    int thread_num
)

Do pre-calculate timing things.

function finishTiming #

virtual void finishTiming(
    int thread_num
)

Do post-calculate timing things.

function init_memory #

virtual void init_memory()

Initialise the memory of this functor.

Reimplemented by: Gambit::module_functor::init_memory, Gambit::module_functor::init_memory

function fill_activeModelFlags #

void fill_activeModelFlags()

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

function retrieve_conditional_dep_type_pair #

sspair retrieve_conditional_dep_type_pair(
    str dep
)

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

function check_missing_LogTag #

void check_missing_LogTag()

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

function entering_multithreaded_region #

inline void entering_multithreaded_region()

function leaving_multithreaded_region #

inline void leaving_multithreaded_region()

Protected Attributes Documentation #

variable myTimingPrintFlag #

bool myTimingPrintFlag;

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

variable start #

std::chrono::time_point< std::chrono::system_clock > * start;

Beginning and end timing points.

variable end #

std::chrono::time_point< std::chrono::system_clock > * end;

variable point_exception_raised #

bool point_exception_raised;

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

variable raised_point_exception #

invalid_point_exception raised_point_exception;

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

variable runtime_average #

double runtime_average;

Averaged runtime in ns.

variable fadeRate #

double fadeRate;

Fade rate for average runtime.

variable pInvalidation #

double pInvalidation;

Probability that functors invalidates point in model parameter space.

variable needs_recalculating #

bool * needs_recalculating;

Needs recalculating or not?

variable already_printed #

bool * already_printed;

Has result already been sent to the printer?

variable already_printed_timing #

bool * already_printed_timing;

Has timing data already been sent to the printer?

variable iCanManageLoops #

bool iCanManageLoops;

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

variable myLoopIsDone #

bool myLoopIsDone;

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

variable iRunNested #

bool iRunNested;

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

variable myLoopManagerCapability #

str myLoopManagerCapability;

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

variable myLoopManagerType #

str myLoopManagerType;

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

variable myLoopManager #

functor * myLoopManager;

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

variable myNestedFunctorList #

std::vector< functor * > myNestedFunctorList;

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

variable myCurrentIteration #

long long * myCurrentIteration;

Pointer to counters for iterations of nested functor loop.

variable globlMaxThreads #

const int globlMaxThreads;

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

variable myGroups #

std::set< str > myGroups;

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

variable chosenReqsFromGroups #

std::map< str, str > chosenReqsFromGroups;

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

variable myBackendReqs #

std::set< sspair > myBackendReqs;

Set of all backend requirement-type string pairs.

variable myResolvableBackendReqs #

std::set< sspair > myResolvableBackendReqs;

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

variable myGroupedBackendReqs #

std::map< str, std::set< sspair > > myGroupedBackendReqs;

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

variable myDependencies #

std::set< sspair > myDependencies;

Vector of dependency-type string pairs.

variable myConditionalDependencies #

std::map< str, str > myConditionalDependencies;

Map of conditional dependencies to their types.

variable myBackendConditionalDependencies #

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)

variable myModelConditionalDependencies #

std::map< str, std::set< sspair > > myModelConditionalDependencies;

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

variable myModelConditionalBackendReqs #

std::map< str, std::set< sspair > > myModelConditionalBackendReqs;

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

variable activeModelFlags #

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)

variable dependency_map #

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)

variable dependency_functor_map #

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)

variable backendreq_types #

std::map< str, str > backendreq_types;

Map from backend requirements to their required types.

variable backendreq_groups #

std::map< sspair, str > backendreq_groups;

Map from backend requirements to their designated groups.

variable backendreq_tagmap #

std::map< sspair, std::set< str > > backendreq_tagmap;

Map from backend requirements to their rule tags.

variable backendreq_map #

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)

variable permitted_map #

std::map< sspair, std::set< sspair > > permitted_map;

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

variable myForcedMatches #

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.

variable required_classloading_backends #

std::map< str, std::set< str > > required_classloading_backends;

Map from required classloading backends to their versions.

variable missing_backends #

std::vector< str > missing_backends;

Vector of required backends currently missing.

variable tp #

timespec tp;

Internal timespec object.

variable myLogTag #

int myLogTag;

Integer LogTag, for tagging log messages.

variable signal_mode_locked #

bool signal_mode_locked = true;

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.

Friends #

friend FunctorHelp::entering_multithreaded_region #

friend void FunctorHelp::entering_multithreaded_region(
    module_functor_common & 
);

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

friend FunctorHelp::leaving_multithreaded_region #

friend void FunctorHelp::leaving_multithreaded_region(
    module_functor_common & 
);

Updated on 2024-07-18 at 13:53:30 +0000