functors.hpp

Go to the documentation of this file.

//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************


#ifndef __functors_hpp__
#define __functors_hpp__

#include <map>
#include <set>
#include <vector>
#include <chrono>
#include <sstream>
#include <algorithm>
#include <omp.h>

#include "gambit/Utils/util_types.hpp"
#include "gambit/Utils/util_functions.hpp"
#include "gambit/Utils/yaml_options.hpp"
#include "gambit/Utils/model_parameters.hpp"
#include "gambit/Logs/logger.hpp"
#include "gambit/Logs/logmaster.hpp" // Need full declaration of LogMaster class

#define FUNCTORS_FADE_RATE 0.01
#define FUNCTORS_BASE_INVALIDATION_RATE 0.01
#define FUNCTORS_RUNTIME_INIT 0.000001

namespace Gambit
{

  namespace Printers { class BasePrinter; }

  namespace Models { class ModelFunctorClaw; }

  template <typename TYPE, typename... ARGS>
  struct variadic_ptr { typedef TYPE(*type)(ARGS..., ...); };

  class module_functor_common;
  namespace FunctorHelp {
    // void check_for_shutdown_signal(module_functor_common&);
    // bool emergency_shutdown_begun();
    void entering_multithreaded_region(module_functor_common&);
    void leaving_multithreaded_region(module_functor_common&);
  }

  // ======================== Base Functor =====================================

  class functor
  {

    public:

      functor(str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~functor() {}

      virtual void calculate();


      // It may be safer to have some of the following things accessible
      // only to the likelihood wrapper class and/or dependency resolver, i.e. so they cannot be used
      // from within module functions

      virtual double getRuntimeAverage();
      virtual double getInvalidationRate();
      virtual void setFadeRate(double);
      virtual void notifyOfInvalidation(const str&);
      virtual void reset();

      virtual void reset_and_calculate();

      void setStatus(int);
      virtual void setInUse(bool){};
      void setPurpose(str);
      void setVertexID(int);
      void setTimingVertexID(int);
      str name() const;
      str capability() const;
      str type() const;
      str origin() const;
      str version() const;
      virtual str safe_version() const;
      int status() const;
      sspair quantity() const;
      str purpose() const;
      int vertexID() const;
      int timingVertexID() const;
      str label() const;
      str timingLabel() const;
      virtual bool requiresPrinting() const;

      virtual bool requiresTimingPrinting() const;

      virtual void setPrintRequirement(bool);

      virtual void setTimingPrintRequirement(bool);

      virtual void setNestedList (std::vector<functor*>&);

      virtual void setIteration (long long);

      virtual bool canBeLoopManager();

      virtual str loopManagerCapability();
      virtual str loopManagerType();
      virtual str loopManagerName();
      virtual str loopManagerOrigin();

      virtual void breakLoop();

      virtual std::set<sspair> dependencies();
      virtual std::set<str> backendgroups();
      virtual std::set<sspair> backendreqs();
      virtual std::set<sspair> backendreqs(str);
      virtual std::set<sspair> backendspermitted(sspair);
      virtual std::set<str> backendreq_tags(sspair);
      virtual std::set<sspair> forcematchingbackend(str);

      virtual std::set<sspair> backend_conditional_dependencies (str, str, str, str);

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

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

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

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

      virtual void resolveDependency (functor*);

      virtual void resolveLoopManager (functor*);

      virtual void resolveBackendReq (functor*);

      virtual void notifyOfModel(str);

      virtual void notifyOfDependee(functor*);

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

      #ifndef NO_PRINTERS
        virtual void print(Printers::BasePrinter* printer, const int pointID, int thread_num);

        virtual void print(Printers::BasePrinter* printer, const int pointID);
      #endif

      virtual invalid_point_exception* retrieve_invalid_point_exception();

      void notifyOfIniOptions(const Options&);

      template<typename TYPE>
      void setOption(const str& key, const TYPE val)
      {
        myOptions.setValue<str,TYPE>(key, val);
      }

      safe_ptr<Options> getOptions();

      void notifyOfSubCaps(const Options&);

      template<typename TYPE>
      void setSubCap(const str& key, const TYPE val)
      {
        mySubCaps.setValue<str,TYPE>(key, val);
      }

      safe_ptr<Options> getSubCaps();

      safe_ptr<std::set<sspair>> getDependees();

      bool allModelsAllowed();

      bool modelAllowed(str model);

      bool modelExplicitlyAllowed(str model);

      void setAllowedModel(str model);

      bool modelComboAllowed(std::set<str> combo);

      bool modelComboExplicitlyAllowed(std::set<str> combo);

      void setModelGroup(str group, str contents);

      void setAllowedModelGroupCombo(str groups);

    protected:

      str myName;
      str myCapability;
      str myType;
      str myOrigin;
      str myVersion;
      str myPurpose;
      const Models::ModelFunctorClaw* myClaw;

      const str myLabel;
      const str myTimingLabel;
      int myStatus;
      int myVertexID;
      int myTimingVertexID;
      bool verbose;

      Options myOptions;

      Options mySubCaps;

      std::set<sspair> myDependees;

      std::set<str> allowedModels;

      std::set<std::set<str> > allowedGroupCombos;

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

      static void failBigTime(str method);

      inline bool allowed_parent_or_friend_exists(str model);

      inline bool in_allowed_combo(str model);

      inline bool contains_anything_interpretable_as_member_of(std::set<str> combo, str group);

      inline bool has_common_elements(std::set<str> combo, str group);

      str find_friend_or_parent_model_in_map(str model, std::map< str, std::set<sspair> > karta);

      virtual void reset(int);

  };


  // ======================== Module Functors =====================================

  class module_functor_common : public functor
  {

    public:

      module_functor_common(str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~module_functor_common();

      double getRuntimeAverage();

      void reset();

      void notifyOfInvalidation(const str&);

      double getInvalidationRate();

      void setFadeRate(double);

      void setTimingPrintRequirement(bool);

      bool requiresTimingPrinting() const;

      bool getActiveModelFlag(str);

      safe_ptr<str> getChosenReqFromGroup(str);

      virtual void iterate(long long iteration);

      virtual void init_myCurrentIteration_if_NULL();
      virtual void setIteration (long long iteration);
      virtual omp_safe_ptr<long long> iterationPtr();

      virtual void setCanBeLoopManager (bool canManage);
      virtual bool canBeLoopManager();

      virtual void setLoopManagerCapType (str cap, str t);
      virtual str loopManagerCapability();
      virtual str loopManagerType();
      virtual str loopManagerName();
      virtual str loopManagerOrigin();

      virtual void breakLoopFromManagedFunctor();
      virtual safe_ptr<bool> loopIsDone();
      virtual void resetLoop();
      virtual void breakLoop();

      virtual std::set<sspair> dependencies();
      virtual std::set<str> backendgroups();
      virtual std::set<sspair> backendreqs();
      virtual std::set<sspair> backendreqs(str);
      virtual std::set<sspair> backendspermitted(sspair quant);
      virtual std::set<str> backendreq_tags(sspair);
      virtual std::set<sspair> forcematchingbackend(str);

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

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

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

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

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

      void setDependency(str, str, void(*)(functor*, module_functor_common*), str purpose= "");

      void setConditionalDependency(str, str);

      void setBackendConditionalDependency(str, str, str, str, void(*)(functor*, module_functor_common*));

      void setBackendConditionalDependencySingular(str, str, str, str, void(*)(functor*, module_functor_common*));

      void setModelConditionalDependency(str, str, void(*)(functor*, module_functor_common*));

      void setModelConditionalDependencySingular(str, str, void(*)(functor*, module_functor_common*));

      void makeBackendRuleForModel(str, str);

      void setBackendReq(str, str, str, str, void(*)(functor*));

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

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

      void makeBackendOptionRule(str, str);

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

      void makeBackendMatchingRule(str tag);

      void setRequiredClassloader(str, str, str);

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

      virtual void setNestedList (std::vector<functor*> &newNestedList);

      virtual void resolveDependency (functor* dep_functor);

      virtual void resolveLoopManager (functor*);

      virtual void resolveBackendReq (functor* be_functor);

      virtual void notifyOfModel(str model);

      virtual void notifyOfDependee (functor*);

      virtual invalid_point_exception* retrieve_invalid_point_exception();


    protected:

      void reset(int);

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

      virtual void startTiming(int);

      virtual void finishTiming(int);

      bool myTimingPrintFlag;

      virtual void init_memory();

      void fill_activeModelFlags();

      sspair retrieve_conditional_dep_type_pair(str);

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

      bool point_exception_raised;

      invalid_point_exception raised_point_exception;

      double runtime_average;

      double fadeRate;

      double pInvalidation;

      bool* needs_recalculating;

      bool* already_printed;

      bool* already_printed_timing;

      bool iCanManageLoops;

      bool myLoopIsDone;

      bool iRunNested;

      str myLoopManagerCapability;
      str myLoopManagerType;
      functor* myLoopManager;

      std::vector<functor*> myNestedFunctorList;

      long long* myCurrentIteration;

      const int globlMaxThreads;

      std::set<str> myGroups;

      std::map<str,str> chosenReqsFromGroups;

      std::set<sspair> myBackendReqs;

      std::set<sspair> myResolvableBackendReqs;

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

      std::set<sspair> myDependencies;

      std::map<str,str> myConditionalDependencies;

      std::map< std::vector<str>, std::set<sspair> > myBackendConditionalDependencies;

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

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

      std::map<str, bool> activeModelFlags;

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

      std::map<sspair, functor*> dependency_functor_map;

      std::map<str, str> backendreq_types;

      std::map<sspair, str> backendreq_groups;

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

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

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

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

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

      std::vector<str> missing_backends;

      timespec tp;

      int myLogTag;

      void check_missing_LogTag();

      bool signal_mode_locked = true;

      // friend void FunctorHelp::check_for_shutdown_signal(module_functor_common&);
      // friend bool FunctorHelp::emergency_shutdown_begun();
      friend void FunctorHelp::entering_multithreaded_region(module_functor_common&);
      friend void FunctorHelp::leaving_multithreaded_region(module_functor_common&);
      // void check_for_shutdown_signal(){ FunctorHelp::check_for_shutdown_signal(*this); }
      // bool emergency_shutdown_begun(){ return FunctorHelp::emergency_shutdown_begun(); }
      void entering_multithreaded_region(){ FunctorHelp::entering_multithreaded_region(*this); }
      void leaving_multithreaded_region(){ FunctorHelp::leaving_multithreaded_region(*this); }

  };


  template <typename TYPE>
  class module_functor : public module_functor_common
  {

    public:

      module_functor(void(*)(TYPE &), str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~module_functor();

      virtual void setPrintRequirement(bool flag);

      virtual bool requiresPrinting() const;

      void calculate();

      const TYPE& operator()(int index);

      safe_ptr<TYPE> valuePtr();

      #ifndef NO_PRINTERS
        virtual void print(Printers::BasePrinter* printer, const int pointID, int index);

        virtual void print(Printers::BasePrinter* printer, const int pointID);
      #endif


    protected:

      void (*myFunction)(TYPE &);

      TYPE* myValue;

      bool myPrintFlag;

      virtual void init_memory();

  };


  template <>
  class module_functor<void> : public module_functor_common
  {

    public:

      module_functor(void (*)(), str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~module_functor() {}

      void calculate();

      #ifndef NO_PRINTERS
        virtual void print(Printers::BasePrinter*, const int, int);

        virtual void print(Printers::BasePrinter*, const int);
      #endif

    protected:

      void (*myFunction)();

  };


  // ======================== Backend Functors =====================================

  template <typename PTR_TYPE, typename TYPE, typename... ARGS>
  class backend_functor_common : public functor
  {

    protected:

      virtual void setInUse(bool);

      typedef PTR_TYPE funcPtrType;

      funcPtrType myFunction;

      int myLogTag;

      str mySafeVersion;

      bool inUse;

    public:

      backend_functor_common (funcPtrType, str, str, str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~backend_functor_common() {}

      void updatePointer(funcPtrType);

      funcPtrType handoutFunctionPointer();

      safe_ptr<bool> inUsePtr();

      virtual str safe_version() const;

  };


  template <typename PTR_TYPE, typename TYPE, typename... ARGS> class backend_functor;

  template <typename TYPE, typename... ARGS>
  class backend_functor<TYPE(*)(ARGS...), TYPE, ARGS...> : public backend_functor_common<TYPE(*)(ARGS...), TYPE, ARGS...>
  {

    public:

      backend_functor (TYPE(*)(ARGS...), str, str, str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~backend_functor() {}

      TYPE operator()(ARGS&&... args);

  };


  template <typename... ARGS>
  class backend_functor<void(*)(ARGS...), void, ARGS...> : public backend_functor_common<void(*)(ARGS...), void, ARGS...>
  {

    public:

      backend_functor (void (*)(ARGS...), str, str, str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~backend_functor() {}

      void operator()(ARGS&&... args);

  };

  template <typename TYPE, typename... ARGS>
  class backend_functor<typename variadic_ptr<TYPE,ARGS...>::type, TYPE, ARGS...>
   : public backend_functor_common<typename variadic_ptr<TYPE,ARGS...>::type, TYPE, ARGS...>
  {

    public:

      backend_functor(typename variadic_ptr<TYPE,ARGS...>::type, str, str, str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~backend_functor() {}

      template <typename... VARARGS>
      TYPE operator()(VARARGS&&... varargs)
      {
        logger().entering_backend(this->myLogTag);
        TYPE tmp = this->myFunction(std::forward<VARARGS>(varargs)...);
        logger().leaving_backend();
        return tmp;
      }

  };

  template <typename... ARGS>
  class backend_functor<typename variadic_ptr<void,ARGS...>::type, void, ARGS...>
   : public backend_functor_common<typename variadic_ptr<void,ARGS...>::type, void, ARGS...>
  {

    public:

      backend_functor(typename variadic_ptr<void,ARGS...>::type, str, str, str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~backend_functor() {}

      template <typename... VARARGS>
      void operator()(VARARGS&&... varargs)
      {
        logger().entering_backend(this->myLogTag);
        this->myFunction(std::forward<VARARGS>(varargs)...);
        logger().leaving_backend();
      }

  };


  // ======================== Model Functors =====================================

  class model_functor : public module_functor<ModelParameters>
  {

    public:

      model_functor(void (*)(ModelParameters &), str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~model_functor() {}

      void setModelName(str model_name);

      void addParameter(str parname);

      void donateParameters(model_functor &receiver);

  };


  class primary_model_functor : public model_functor
  {

    public:

      primary_model_functor(void (*)(ModelParameters &), str, str, str, str, Models::ModelFunctorClaw&);

      virtual ~primary_model_functor() {}

      ModelParameters* getcontentsPtr();

  };

}

#endif /* defined(__functors_hpp__) */