Kernel.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#ifndef AGX_KERNEL_H
#define AGX_KERNEL_H
 
 
#include <agx/Referenced.h>
#include <agx/Task.h>
#include <agxData/Value.h>
#include <agx/Vector.h>
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable : 4251 ) // class X needs to have dll-interface to be used by clients of class Y
#endif
 
 
namespace agx
{
  class TiXmlElement;
 
  AGX_DECLARE_POINTER_TYPES(Kernel);
  AGX_DECLARE_VECTOR_TYPES(Kernel);
  AGX_DECLARE_POINTER_TYPES(CpuKernel);
  AGX_DECLARE_VECTOR_TYPES(CpuKernel);
 
  class AGXCORE_EXPORT Kernel : public ParallelTask
  {
  public:
    static agx::Model *ClassModel();
 
    static Kernel *load(TiXmlElement *eKernel, Device *device);
    virtual void configure(TiXmlElement *eKernel) override;
 
  public:
    Kernel(const agx::Name& name, agx::Device* device, const agx::Job::Callback& dispatcher);
 
    agx::UInt getNumWorkItems() const;
 
    virtual float getComputeTime();
 
    agx::UInt getNumJobsPerThread() const;
 
    agx::UInt getMinJobSize() const;
 
    agx::UInt getMaxJobSize() const;
 
    agx::UInt getCostPerElement() const;
 
    void setNumJobsPerThread(agx::UInt numJobs);
 
    void setMinJobSize(agx::UInt min);
 
    void setMaxJobSize(agx::UInt max);
 
    void setCostPerElement(agx::UInt cost);
 
 
 
    // void setSplittingParameter(ArrayParameter *parameter);
 
    virtual void preDispatch() {}
 
    virtual void rebind() override;
 
  protected:
    virtual ~Kernel();
    virtual void parameterAddedCallback(Parameter* parameter) override;
    virtual void parameterRemovedCallback(Parameter* parameter) override;
    void locateNumWorkItemsValue();
    agxData::ValueRefT<UInt> m_numWorkItems;
 
  private:
    agxData::Val<UInt> m_numJobsPerThread;
    agxData::Val<UInt> m_minJobSize;
    agxData::Val<UInt> m_maxJobSize;
    agxData::Val<UInt> m_costPerElement;
    // ArrayParameterRef m_splittingParameter;
  };
 
 
  //---------------------------------------------------------------
 
  class AGXCORE_EXPORT CpuKernel : public Kernel
  {
  public:
    typedef RangeJob::RangeCallback RangeDispatch;
 
  public:
    static CpuKernel *load(TiXmlElement *eKernel, Device *device);
 
  public:
    CpuKernel(const agx::Name& name, RangeDispatch rangeDispatch);
    CpuKernel(const agx::Name& name, Job::Callback serialDispatch);
 
    UInt getNumJobs() const;
 
    const RangeDispatch& getRangeDispatch() const;
 
  protected:
    virtual ~CpuKernel();
    void generateJobs();
    virtual RangeJob *allocateRangeJobs(size_t numJobs) = 0;
 
  protected: // Should be private, is protected for custom job generators
    // Vector<RangeJob> m_rangeJobs;
    RangeDispatch m_rangeDispatch;
    UInt m_numJobs;
  };
 
 
  //---------------------------------------------------------------
 
  AGX_DECLARE_POINTER_TYPES(LambdaKernel);
  class AGXCORE_EXPORT LambdaKernel : public CpuKernel
  {
  public:
    typedef std::function<void (const RangeJob&)> LambdaCallback;
    typedef std::function<UInt ()> DataSetSizeCallback;
 
  public:
    LambdaKernel(const agx::Name& name, LambdaCallback lambdaCallback, DataSetSizeCallback sizeCallback);
 
  private:
    void generateJobs();
    virtual RangeJob *allocateRangeJobs(size_t numJobs) override;
    void callOnJobRange(const RangeJob& job);
 
  protected:
    Vector<RangeJob> m_rangeJobs;
 
  private:
    DataSetSizeCallback m_sizeCallback;
    LambdaCallback m_lambda;
  };
 
  //---------------------------------------------------------------
 
 
  /* Implementation */
  // inline const Kernel::ImplementationTable& Kernel::getImplementations() const { return m_implementations; }
  // inline const Kernel::Implementation& Kernel::getImplementation(const String& name) const { agxAssert(m_implementations.contains(name)); return m_implementations.find(name)->second; }
  // inline const Kernel::Implementation& Kernel::getActiveImplementation() const { return m_activeImplementation; }
  AGX_FORCE_INLINE UInt Kernel::getNumJobsPerThread() const { return m_numJobsPerThread; }
  AGX_FORCE_INLINE UInt Kernel::getMinJobSize() const { return m_minJobSize; }
  AGX_FORCE_INLINE UInt Kernel::getMaxJobSize() const { return m_maxJobSize; }
  AGX_FORCE_INLINE UInt Kernel::getCostPerElement() const { return m_costPerElement; }
 
  AGX_FORCE_INLINE UInt Kernel::getNumWorkItems() const
  {
    if (!m_numWorkItems)
      const_cast<Kernel *>(this)->locateNumWorkItemsValue();
 
    return m_numWorkItems->get();
  }
 
  AGX_FORCE_INLINE const CpuKernel::RangeDispatch& CpuKernel::getRangeDispatch() const { return m_rangeDispatch; }
 
  AGX_FORCE_INLINE UInt CpuKernel::getNumJobs() const { return m_numJobs; }
}
 
 
#ifdef _MSC_VER
# pragma warning(pop)
#endif
 
#endif /* _AGX_KERNEL_H_ */