safety_bucket.hpp

Go to the documentation of this file.

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

#ifndef __safety_bucket_hpp__
#define __safety_bucket_hpp__

#include <iostream>
#include <omp.h>

#include "gambit/Elements/functors.hpp"
#include "gambit/Utils/util_types.hpp"
#include "gambit/Utils/standalone_error_handlers.hpp"


namespace Gambit
{

  class safety_bucket_base
  {

    public:

      safety_bucket_base(str myinfo) : whoami(myinfo) {}

      str name()
      {
        if (not _initialized) dieGracefully();
        return _functor_base_ptr->name();
      }

      str origin()
      {
        if (not _initialized) dieGracefully();
        return _functor_base_ptr->origin();
      }


    protected:

      functor * _functor_base_ptr;

      bool _initialized;

      const str whoami;

      void dieGracefully() const
      {
        str errmsg = "You just just tried to access the dependency or backend requirement\n"
                     + whoami + "\n"
                     "Unfortunately this does not yet point to anything, because the dependency\n"
                     "or backend requirement has not been satistified yet.  If using GAMBIT in \n"
                     "full, please check your rollcall declaration of this module function, and\n"
                     "its source code.  This error often occurs because you have written \n"
                     "  using namespace Pipes::x \n"
                     "where x is not actually the function being executed.  Don't steal pipes!!\n\n"
                     "Alternatively, if you are writing a standalone executable using some  \n"
                     "GAMBIT modules, please check that you have correctly filled this dep/req.";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
  };



  template <typename TYPE>
  class dep_bucket : public safety_bucket_base
  {

    public:

      dep_bucket(str mym, str myf, str me, module_functor<TYPE> * functor_ptr_in = NULL, module_functor_common* dependent_functor_ptr_in = NULL)
      : safety_bucket_base(mym+"::Pipes::"+myf+"::Dep::"+me)
      {
        initialize(functor_ptr_in, dependent_functor_ptr_in);
      }

      void initialize(module_functor<TYPE> * functor_ptr_in, module_functor_common* dependent_functor_ptr_in)
      {
        _functor_ptr = functor_ptr_in;
        _functor_base_ptr = functor_ptr_in;
        _dependent_functor_ptr = dependent_functor_ptr_in;

        // Extract pointer to dependency from functor and store as a safe_ptr.
        if (functor_ptr_in == NULL)
        {
          _sptr.set(NULL);
          _initialized = false;
        }
        else
        {
          _sptr = _functor_ptr->valuePtr();
          _initialized = true;
        }
      }

      str module()
      {
        return origin();
      }

      static bool use_thread_index(module_functor<TYPE>* f1, module_functor_common* f2)
      {
        return (f1->loopManagerCapability() != "none" and
          f1->loopManagerCapability() == f2->loopManagerCapability() and
          f1->loopManagerName()       == f2->loopManagerName()       and
          f1->loopManagerOrigin()     == f2->loopManagerOrigin() );
      }

      const TYPE& operator *() const
      {
        if (not _initialized) dieGracefully();
        //Choose the index of the thread if the dependency and the dependent functor are running inside the same loop.  If not, just access the first element.
        int index = use_thread_index(_functor_ptr, _dependent_functor_ptr) ? omp_get_thread_num() : 0;
        return _sptr[index];
      }


      const TYPE* operator->() const
      {
        if (not _initialized) this->dieGracefully();
        //Choose the index of the thread if the dependency and the dependent functor are running inside the same loop.  If not, just choose the first element.
        int index = use_thread_index(_functor_ptr, _dependent_functor_ptr) ? omp_get_thread_num() : 0;
        return _sptr.operator->() + index;   //Call a const member function of the indexth element of the array pointed to by the safe pointer.
      }

      safe_ptr<TYPE>& safe_pointer()
      {
        if (not _initialized) dieGracefully();
        return _sptr;
      }


    protected:

      module_functor<TYPE> * _functor_ptr;
      safe_ptr<TYPE> _sptr;
      module_functor_common * _dependent_functor_ptr;

  };



  class BE_bucket_base : public safety_bucket_base
  {

    public:

      BE_bucket_base(str mym, str myf, str me)
      : safety_bucket_base(mym+"::Pipes::"+myf+"::BEreq::"+me) {}

      str backend()
      {
        return origin();
      }

      str version()
      {
        if (not _initialized) dieGracefully();
        return _functor_base_ptr->version();
      }

  };


  template <typename TYPE>
  class BEvariable_bucket : public BE_bucket_base
  {

    protected:

      backend_functor<TYPE*(*)(),TYPE*> * _functor_ptr;
      safe_variable_ptr<TYPE> _svptr;

    public:

      BEvariable_bucket(str mym, str myf, str me, backend_functor<TYPE*(*)(),TYPE*> * functor_ptr_in = NULL)
      : BE_bucket_base(mym, myf, me)
      {
        initialize(functor_ptr_in);
      }


      void initialize(backend_functor<TYPE*(*)(),TYPE*> * functor_ptr_in)
      {
        _functor_ptr      = functor_ptr_in;
        _functor_base_ptr = functor_ptr_in;

        if (functor_ptr_in == NULL)
        {
          _svptr.set(NULL);
          _initialized = false;
        }
        else
        {
          // Extract variable pointer from functor and store as a safe_variable_ptr
          _svptr.set( (*_functor_ptr)() );
          _initialized = true;
        }
      }

      TYPE& operator *()
      {
        if (not _initialized) dieGracefully();
        return *_svptr;
      }

      TYPE* operator->()
      {
        return _svptr.operator->();
      }

      TYPE * pointer()
      {
        if (not _initialized) dieGracefully();
        return _svptr.get();
      }

      safe_variable_ptr<TYPE>& safe_pointer()
      {
        if (not _initialized) dieGracefully();
        return _svptr;
      }

  };


  template <typename PTR_TYPE, typename TYPE, typename... ARGS>
  class BEfunction_bucket_common : public BE_bucket_base
  {
   public:

      BEfunction_bucket_common(str mym, str myf, str me, backend_functor<PTR_TYPE, TYPE, ARGS...>* functor_ptr_in = NULL)
      : BE_bucket_base(mym, myf, me)
      {
        initialize(functor_ptr_in);
      }

      void initialize(backend_functor<PTR_TYPE, TYPE, ARGS...>* functor_ptr_in)
      {
        _functor_ptr      = functor_ptr_in;
        _functor_base_ptr = functor_ptr_in;

        if (functor_ptr_in == NULL)
        {
          _initialized = false;
        }
        else
        {
          _initialized = true;
        }
      }

      PTR_TYPE pointer()
      {
        if (not _initialized) dieGracefully();
        return _functor_ptr->handoutFunctionPointer();
      }


    protected:

      backend_functor<PTR_TYPE, TYPE, ARGS...>* _functor_ptr;

  };


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

  template <typename TYPE, typename... ARGS>
  class BEfunction_bucket<TYPE(*)(ARGS...),TYPE,ARGS...> : public BEfunction_bucket_common<TYPE(*)(ARGS...),TYPE,ARGS...>
  {

    public:

      BEfunction_bucket(str mym, str myf, str me, backend_functor<TYPE(*)(ARGS...), TYPE, ARGS...>* functor_ptr_in = NULL)
       : BEfunction_bucket_common<TYPE(*)(ARGS...),TYPE,ARGS...>(mym, myf, me, functor_ptr_in) {}

      TYPE operator ()(ARGS&& ...args)
      {
        if (not this->_initialized) this->dieGracefully();
        return (*(this->_functor_ptr))(std::forward<ARGS>(args)...);
      }

  };

  template <typename TYPE, typename... ARGS>
  class BEfunction_bucket<typename variadic_ptr<TYPE,ARGS...>::type,TYPE,ARGS...>
   : public BEfunction_bucket_common<typename variadic_ptr<TYPE,ARGS...>::type,TYPE,ARGS...>
  {

    public:

      BEfunction_bucket(str mym, str myf, str me, backend_functor<typename variadic_ptr<TYPE,ARGS...>::type, TYPE, ARGS...>* functor_ptr_in = NULL)
       : BEfunction_bucket_common<typename variadic_ptr<TYPE,ARGS...>::type,TYPE,ARGS...>(mym, myf, me, functor_ptr_in) {}

      template <typename... VARARGS>
      TYPE operator ()(VARARGS&& ...varargs)
      {
        if (not this->_initialized) this->dieGracefully();
        return (*(this->_functor_ptr))(std::forward<VARARGS>(varargs)...);
      }

  };

}

#endif // defined __safety_bucket_hpp__