CompiledExpression.h

Go to the documentation of this file.

#ifndef AMPGEN_COMPILEDEXPRESSION_H
#define AMPGEN_COMPILEDEXPRESSION_H
 
#include "AmpGen/CacheTransfer.h"
#include "AmpGen/CompiledExpressionBase.h"
#include "AmpGen/DynamicFCN.h"
#include "AmpGen/Expression.h"
#include "AmpGen/MetaUtils.h"
#include "AmpGen/MsgService.h"
#include "AmpGen/Utilities.h"
#include "AmpGen/Types.h"
#include "AmpGen/simd/utils.h"
#include "AmpGen/Tensor.h"
#include "AmpGen/ArgumentPack.h"
#include <cxxabi.h>
#include <dlfcn.h>
#include <vector>
#include <map>
 
namespace AmpGen {
  /* @class CompiledExpression
     @tparam ret_type The type that is returned this compiled expression,
     usually this is a std::complex<double>,
     but in principal support also exists for computing coupled channel propagators
     (i.e. returning array types) */
  namespace detail {
    template <typename T> struct size_of {
      static constexpr unsigned value = sizeof(T);
    };
    template <> struct size_of<void> {
      static constexpr unsigned value = 0;
    };
  }
  DECLARE_ARGUMENT(disableBatch, bool);
  DECLARE_ARGUMENT(includeParameters, bool);
  DECLARE_ARGUMENT(includePythonBindings, bool);
 
  template <typename ret_type, typename... arg_types> class CompiledExpression;
  template <typename ret_type, typename... arg_types> class CompiledExpression<ret_type(arg_types...)> : public CompiledExpressionBase {
  private:
    DynamicFCN<ret_type(arg_types...)> m_fcn;
    DynamicFCN<void(const size_t &, const size_t &, const size_t &, ret_type *, arg_types...)> m_batchFcn;
    DynamicFCN<std::vector<std::pair<std::string, complex_v>>(arg_types...)> m_fdb;
    std::vector<real_t> m_externals = {};
    bool m_hasExternalsChanged = {false};
 
  public:
    typedef ret_type return_type;
    unsigned m_outputSize = {0};
 
    template <typename... namedArgs>
    CompiledExpression(const Expression &expression, const std::string &name, const namedArgs &...args) : CompiledExpressionBase(expression, name) {
      set(expression, name, args...);
    }
 
    template <typename... namedArgs> void set(const Expression &expression, const std::string &name, const namedArgs &...args) {
      m_obj = expression;
      m_name = name;
      const MinuitParameterSet *mps = nullptr;
      auto process_argument = [this, &mps](const auto &arg) mutable {
        DEBUG(type_string(arg));
        if constexpr(std::is_convertible<decltype(arg), DebugSymbols>::value) {
          this->m_db = arg;
        } else if constexpr(std::is_convertible<decltype(arg), std::map<std::string, unsigned>>::value)
          this->m_evtMap = arg;
        else if constexpr(std::is_convertible<decltype(arg), const MinuitParameterSet *>::value
                          or std::is_convertible<decltype(arg), const AmpGen::MinuitParameterSet *>::value
                          or std::is_convertible<decltype(arg), MinuitParameterSet *>::value) {
          mps = arg;
        } else if constexpr(std::is_convertible<decltype(arg), MinuitParameterSet>::value)
          mps = &arg;
 
        else if constexpr(std::is_convertible<decltype(arg), disableBatch>::value) {
          DEBUG("Disabling bulk evaluation: did you do this on purpose?");
          m_disableBatch = true;
        } else if constexpr(std::is_convertible<decltype(arg), includePythonBindings>::value) {
          m_includePythonBindings = true;
        } else if constexpr(std::is_convertible<decltype(arg), includeParameters>::value) {
          m_includeParameters = true;
        } else
          ERROR("Unrecognised argument: " << type_string(arg));
      };
      for_each(std::tuple<const namedArgs &...>(args...), process_argument);
      if(mps == nullptr) { DEBUG("No minuit parameterset linked."); }
      resolve(mps);
      if constexpr(std::is_same<ret_type, void>::value) {
        typedef typename std::remove_pointer<zeroType<arg_types...>>::type zt;
        m_outputSize = detail::size_of<zt>::value;
        DEBUG("one element: " << m_outputSize << type_string<zt>());
      } else if constexpr(isVector<ret_type>::value) {
        m_outputSize = detail::size_of<typename ret_type::value_type>::value;
      } else {
        m_outputSize = detail::size_of<ret_type>::value;
      }
      if(is<TensorExpression>(expression)) { m_outputSize *= cast<TensorExpression>(expression).tensor().size(); }
    }
 
    CompiledExpression(const std::string &name = "") : CompiledExpressionBase(name) { m_outputSize = detail::size_of<ret_type>::value; };
 
    void setDebug(const DebugSymbols &db) { m_db = db; }
 
    std::vector<real_t> externBuffer() const override { return m_externals; }
    std::string returnTypename() const override { return type_string<ret_type>(); }
    bool use_rto() const override { return std::is_same<ret_type, void>::value; }
    std::vector<std::string> types() const override { return typelist<arg_types...>(); }
    void resolve(const MinuitParameterSet *mps = nullptr) { CompiledExpressionBase::resolve(mps); }
    void setExternals(const std::vector<double> &external) { m_externals = external; }
 
    unsigned int getNParams() const { return m_externals.size(); }
 
    void print() const override {
      INFO("Name     = " << name());
      INFO("Hash     = " << hash());
      INFO("IsReady? = " << isReady() << " IsLinked? " << (m_fcn.isLinked()));
      INFO("args     = [" << vectorToString(m_externals, ", ") << "]");
      auto func = orderedCacheFunctors();
      for(auto &c : func) c->print();
    }
 
    void setExternal(const double &value, const unsigned int &address) override {
      if(m_externals[address] == value) return;
      DEBUG("Setting external " << address << " / " << m_externals.size() << " to value = " << value << " ; current = " << m_externals[address]);
      m_externals[address] = value;
      m_hasExternalsChanged = true;
    }
    void resizeExternalCache(const size_t &N) override {
      if(m_externals.size() < N) m_externals.resize(N);
    }
    bool hasExternalsChanged() { return m_hasExternalsChanged; }
    void resetExternals() { m_hasExternalsChanged = false; }
 
    const Expression &expression() const { return m_obj; }
    bool isReady() const override { return m_fcn.isLinked(); }
    bool isLinked() const { return m_fcn.isLinked(); }
 
    unsigned returnTypeSize() const override { return m_outputSize; }
 
    template <typename T> ret_type operator()(const T *event) const { return m_fcn(m_externals.data(), event); }
    ret_type operator()(const arg_types &...args) const { return m_fcn(args...); }
    template <typename... batch_arg_types> void batch(batch_arg_types... args) const { m_batchFcn(args...); }
 
    template <typename T> void debug(const T *event) const {
      if(!m_fcn.isLinked()) { FATAL("Function " << name() << " not linked"); }
      if(!m_fdb.isLinked()) { FATAL("Function" << name() << " debugging symbols not linked"); }
      std::vector<std::pair<std::string, complex_v>> debug_results;
      if constexpr(std::is_same<void, ret_type>::value)
        debug_results = m_fdb(nullptr, 0, &(m_externals[0]), event);
      else
        debug_results = m_fdb(&(m_externals[0]), event);
      for(auto &debug_result : debug_results) {
        auto val = debug_result.second;
        auto label = debug_result.first;
        if(utils::all_of(val.real(), -999.))
          std::cout << bold_on << std::setw(50) << std::left << label << bold_off << std::endl;
        else if(utils::all_of(val.imag(), 0.))
          std::cout << "  " << std::setw(50) << std::left << label << " = " << val.real() << std::endl;
        else
          std::cout << "  " << std::setw(50) << std::left << label << " = " << val << std::endl;
      }
    }
 
    bool link(void *handle) override {
      const std::string symbol = progName();
      bool status = true;
      status &= m_fcn.set(handle, symbol, true);
      status &= m_db.size() == 0 || m_fdb.set(handle, symbol + "_DB");
      if(!m_disableBatch) status &= m_batchFcn.set(handle, symbol + "_batch");
      return status;
    }
    bool link(const std::string &handle) override { return link(dlopen(handle.c_str(), RTLD_NOW)); };
    std::string arg_type(const unsigned &i) const override { return typelist<arg_types...>()[i]; }
  };
 
  template <typename return_type>
  CompiledExpression<void(return_type *, const double *, const double *)> make_rto_expression(const Expression &expression, const std::string &name) {
    CompiledExpression<void(return_type *, const double *, const double *)> rt(expression, name);
    rt.compile();
    rt.prepare();
    return rt;
  }
 
  template <typename return_type>
  CompiledExpression<return_type(const double *, const double *)> make_expression(const Expression &expression, const std::string &name) {
    CompiledExpression<return_type(const double *, const double *)> rt(expression, name);
    rt.compile();
    rt.prepare();
    return rt;
  }
  template <typename return_type, typename arg1 = double, typename arg2 = double, typename... arg_types>
  CompiledExpression<return_type(const arg1 *, const arg2 *)> make_expression(const Expression &expression, const std::string &name, const arg_types &...args) {
    CompiledExpression<return_type(const arg1 *, const arg2 *)> rt(expression, name, args...);
    rt.compile();
    rt.prepare();
    return rt;
  }
 
} // namespace AmpGen
 
#endif