generate.h

Go to the documentation of this file.

#ifndef GENERATE_H
#define GENERATE_H

#ifdef SKEPU_OPENCL
#include <string>
#include <vector>
#ifdef USE_MAC_OPENCL
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif
#include "src/device_cl.h"
#endif

#include "src/environment.h"

#include "skepu/vector.h"
#include "skepu/matrix.h"

#include "src/operator_macros.h"
#include "src/exec_plan.h"

namespace skepu
{

template <typename GenerateFunc>
class Generate
{

public:

   Generate(GenerateFunc* generateFunc);

   ~Generate();

   template <typename T>
   void setConstant(T constant1)
   {
      m_generateFunc->setConstant(constant1);
   }

   void finishAll()
   {
      m_environment->finishAll();
   }
   void setExecPlan(ExecPlan& plan)
   {
      m_execPlan = &plan;
   }
   void setExecPlan(ExecPlan *plan)
   {
      m_execPlanMulti = plan;
   }

private:
   Environment<int>* m_environment;
   GenerateFunc* m_generateFunc;

   ExecPlan *m_execPlanMulti;

   ExecPlan *m_execPlan;

   ExecPlan m_defPlan;


public:
   template <typename T>
   void operator()(size_t numElements, Vector<T>& output);

   template <typename T>
   void operator()(size_t numRows, size_t numCols, Matrix<T>& output);

   template <typename OutputIterator>
   void operator()(size_t numElements, OutputIterator outputBegin);

public:
   template <typename T>
   void CPU(size_t numElements, Vector<T>& output);

   template <typename T>
   void CPU(size_t numRows, size_t numCols, Matrix<T>& output);

   template <typename OutputIterator>
   void CPU(size_t numElements, OutputIterator outputBegin);


#ifdef SKEPU_OPENMP
public:
   template <typename T>
   void OMP(size_t numElements, Vector<T>& output);

   template <typename T>
   void OMP(size_t numRows, size_t numCols, Matrix<T>& output);

   template <typename OutputIterator>
   void OMP(size_t numElements, OutputIterator outputBegin);

#endif

#ifdef SKEPU_CUDA
public:
   template <typename T>
   void CU(size_t numElements, Vector<T>& output, int useNumGPU = 1);

   template <typename T>
   void CU(size_t numRows, size_t numCols, Matrix<T>& output, int useNumGPU = 1);

   template <typename OutputIterator>
   void CU(size_t numElements, OutputIterator outputBegin, int useNumGPU = 1);

private:
   unsigned int cudaDeviceID;
   
   template <typename OutputIterator>
   void generateSingleThread_CU(size_t numElements, OutputIterator outputBegin, unsigned int deviceID);

#endif

#ifdef SKEPU_OPENCL
public:
   template <typename T>
   void CL(size_t numElements, Vector<T>& output, int useNumGPU = 1);

   template <typename T>
   void CL(size_t numRows, size_t numCols, Matrix<T>& output, int useNumGPU = 1);

   template <typename OutputIterator>
   void CL(size_t numElements, OutputIterator outputBegin, int useNumGPU = 1);

private:
   template <typename OutputIterator>
   void generateNumDevices_CL(size_t numElements, OutputIterator outputBegin, size_t numDevices);

private:
   std::vector<std::pair<cl_kernel, Device_CL*> > m_kernels_CL;

   void createOpenCLProgram();
#endif

};

}

#include "src/generate.inl"

#include "src/generate_cpu.inl"

#ifdef SKEPU_OPENMP
#include "src/generate_omp.inl"
#endif

#ifdef SKEPU_OPENCL
#include "src/generate_cl.inl"
#endif

#ifdef SKEPU_CUDA
#include "src/generate_cu.inl"
#endif

#endif