mapoverlap.h

Go to the documentation of this file.

#ifndef MAPOVERLAP_H
#define MAPOVERLAP_H


#include <starpu.h>
#ifdef SKEPU_OPENCL 
    #include <starpu_opencl.h>
#endif  


#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/task.h"
#include "src/operator_macros.h"
#include "src/exec_plan.h"

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

namespace skepu
{


enum OverlapPolicy
{
  OVERLAP_ROW_WISE,
  OVERLAP_COL_WISE,
  OVERLAP_ROW_COL_WISE,
  OVERLAP_CONVOL_WISE
};
 
 
enum EdgePolicy
{
    CONSTANT,
    CYCLIC,
    DUPLICATE
};

template <typename MapOverlapFunc, typename T, skepu_container_type c_type=VECTOR>
class MapOverlap: public Task
{

typedef struct
{
    MapOverlap<MapOverlapFunc, T, c_type> *pMapOver;
    EdgePolicy poly;
    bool unaryOperand;
    T pad;
}ArgumentBuffer;

public:

    EdgePolicy poly;
    T pad;
    Vector<T> *input;
    Vector<T> *output;
    

    MapOverlap(MapOverlapFunc* mapOverlapFunc);
    
    MapOverlap(MapOverlapFunc* mapOverlapFunc, Vector<T> *in, Vector<T> *out, EdgePolicy poly, T pad=T());

    ~MapOverlap();
    
    
    Vector<T>& getOutput()
    {
        if(!temp_output.empty())
        {
            typename Vector<T>::iterator outputBegin = output->begin();
            for(typename Vector<T>::iterator it = temp_output.begin(); outputBegin != output->end(); ++outputBegin, ++it)
            {
                *outputBegin = *it;
            }
            temp_output.clear();
        }
        return *output;
    } 
    
    void *get_result()
    {
        if(!temp_output.empty())
        {
            typename Vector<T>::iterator outputBegin = output->begin();
            for(typename Vector<T>::iterator it = temp_output.begin(); outputBegin != output->end(); ++outputBegin, ++it)
            {
                *outputBegin = *it;
            }
            temp_output.clear();
        }
        return output;
    }    

    void setInput(Vector<T> *in)
    {
        input = in;
    }
    
    void setOutput(Vector<T> *out)
    {
        output = out;
    } 
    
    void setPad(T _pad)
    {
        pad = _pad;
    }
    
    void setEdgePolicy(EdgePolicy _poly)
    {
        poly = _poly;
    } 
    
    void run_async();

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

public:
    Environment<int>* m_environment;
    MapOverlapFunc* m_mapOverlapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *codelet;
    struct starpu_codelet *codelet_three;
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *mapoverlap_perf_model;
#endif
    
//     bool unaryOperand;

public:
    void operator()(Vector<T>& input, EdgePolicy poly = CONSTANT, T pad = T());

    void operator()(Vector<T>& input, Vector<T>& output, EdgePolicy poly = CONSTANT, T pad = T());

public:
    static void cpu_func(void *buffers[], void *arg);

#ifdef SKEPU_OPENMP
public:
    static void omp_func(void *buffers[], void *arg);
#endif

#ifdef SKEPU_CUDA
public:
    static void cuda_func(void *buffers[], void *arg);
#endif

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffers[], void *arg);

public:
    struct starpu_opencl_program opencl_codelet;
    char kernelNameArray[1024];

    void replaceText(std::string& text, std::string find, std::string replace);
    void createOpenCLProgram();
#endif

private:
    std::string perfmodel_str;
    
    Vector<T> temp_output;
    
};
















template <typename MapOverlapFunc, typename T>
class MapOverlap<MapOverlapFunc, T, MATRIX>: public Task
{
typedef struct
{
    MapOverlap<MapOverlapFunc, T, MATRIX> *pMapOverlap;
    EdgePolicy poly;
    bool parts;
    T pad;
}ArgumentBuffer;


typedef struct
{
    MapOverlap<MapOverlapFunc, T, MATRIX> *pMapOverlap;
    int filter_rows;
    int filter_cols;
}ArgumentBufferConvol;


private:
Matrix<T> temp_output;
Matrix<T> *input;
Matrix<T> *output;
Matrix<T> *filter;
OverlapPolicy overlapType;
EdgePolicy poly;
T pad;
int xblocks;
int yblocks;
int filter_rows;
int filter_cols;

public:


    MapOverlap(MapOverlapFunc* mapOverlapFunc);
    
    MapOverlap(MapOverlapFunc* mapOverlapFunc, Matrix<T> *input, Matrix<T> *output, OverlapPolicy overlapPolicy=OVERLAP_ROW_WISE, EdgePolicy poly=CONSTANT, T pad = T(),int xblocks=1, int yblocks=1);

    ~MapOverlap();
    
    
    Matrix<T>& getOutput()
    {
        if(!temp_output.empty())
        {
            typename Matrix<T>::iterator outputBegin = output->begin();
            for(typename Matrix<T>::iterator it = temp_output.begin(); outputBegin != output->end(); ++outputBegin, ++it)
            {
                *outputBegin = *it;
            }
            temp_output.clear();
        }
        return *output;
    } 
    
    void *get_result()
    {
        if(!temp_output.empty())
        {
            typename Matrix<T>::iterator outputBegin = output->begin();
            for(typename Matrix<T>::iterator it = temp_output.begin(); outputBegin != output->end(); ++outputBegin, ++it)
            {
                *outputBegin = *it;
            }
            temp_output.clear();
        }
        return output;
    }     

    void setInput(Matrix<T> *in)
    {
        input = in;
    }
    
    void setOutput(Matrix<T> *out)
    {
        output = out;
    } 
    
    void setFilter(Matrix<T> *fil)
    {
        filter = fil;
    }
    
    void setFilterSize(int rows, int cols)
    {
        filter_rows= rows;
        filter_cols= cols;
    } 
    
    void setPad(T _pad)
    {
        pad = _pad;
    }
    
    void setOverlapType(OverlapPolicy _overlapType)
    {
        overlapType = _overlapType;
    } 
    
    void run_async();

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

private:
    Environment<int>* m_environment;
    MapOverlapFunc* m_mapOverlapFunc;
    ExecPlan m_execPlan;

    struct starpu_codelet *codelet_row;
    struct starpu_codelet *codelet_col;
    struct starpu_codelet *codelet_convol;
    struct starpu_codelet *codelet_convol_filter;
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *mapoverlap_perf_model_row;
    starpu_perfmodel *mapoverlap_perf_model_col;
    starpu_perfmodel *mapoverlap_perf_model_convol;
    starpu_perfmodel *mapoverlap_perf_model_convol_filter;
#endif
     
private:
    void mapoverlap_matrix(Matrix<T>& input, EdgePolicy poly = CONSTANT, T pad = T(), OverlapPolicy overlapPolicy=OVERLAP_ROW_WISE,int xblocks=1, int yblocks=1);

    void mapoverlap_matrix(Matrix<T>& input, Matrix<T>& output, EdgePolicy poly = CONSTANT, T pad = T(), OverlapPolicy overlapPolicy=OVERLAP_ROW_WISE,int xblocks=1, int yblocks=1);

public:    
    void operator()(Matrix<T>& input, EdgePolicy poly = CONSTANT, T pad = T(), OverlapPolicy overlapPolicy=OVERLAP_ROW_WISE, int xblocks=1, int yblocks=1);
    
    void operator()(Matrix<T>& input, Matrix<T>& output, EdgePolicy poly = CONSTANT, T pad = T(), OverlapPolicy overlapPolicy=OVERLAP_ROW_WISE, int xblocks=1, int yblocks=1);
    
    void operator()(Matrix<T>& input, Matrix<T>& output, Matrix<T>& filter);
    
    void operator()(Matrix<T>& input, Matrix<T>& output, unsigned int filter_rows, unsigned int filter_cols);
    
public:
    static void cpu_func_row(void *buffers[], void *arg);
    
    static void cpu_func_col(void *buffers[], void *arg);
    
    static void cpu_func_convol_filter(void *buffers[], void *arg);
    
    static void cpu_func_convol(void *buffers[], void *arg); 

#ifdef SKEPU_OPENMP
public:
    static void omp_func_row(void *buffers[], void *arg);
    
    static void omp_func_col(void *buffers[], void *arg);
    
    static void omp_func_convol_filter(void *buffers[], void *arg);
    
    static void omp_func_convol(void *buffers[], void *arg); 
    
#endif

#ifdef SKEPU_CUDA
public:
    static void cuda_func_row(void *buffers[], void *arg);
    
    static void cuda_func_col(void *buffers[], void *arg);
    
    static void cuda_func_convol_filter(void *buffers[], void *arg);
    
    static void cuda_func_convol(void *buffers[], void *arg); 
#endif

#ifdef SKEPU_OPENCL
public:
    static void opencl_func_row(void *buffers[], void *arg);
    
    static void opencl_func_col(void *buffers[], void *arg);
    
    static void opencl_func_convol_filter(void *buffers[], void *arg);
    
    static void opencl_func_convol(void *buffers[], void *arg); 

public:
    struct starpu_opencl_program opencl_codelet;
//    struct starpu_opencl_program opencl_codelet_col;
//    struct starpu_opencl_program opencl_codelet_convol;
//    struct starpu_opencl_program opencl_codelet_convol_filter;
    
    char kernelNameArray_Row[1024];
    char kernelNameArray_Col[1024];
    char kernelNameArray_Convol[1024];
    char kernelNameArray_ConvolFilter[1024];
//    char kernelNameArray_Trans[1024];

    void replaceText(std::string& text, std::string find, std::string replace);
    void createOpenCLProgram();
#endif

private:
    std::string perfmodel_str_row;
    std::string perfmodel_str_col;
    std::string perfmodel_str_convol_filter;
    std::string perfmodel_str_convol;
    
};








}

#include "src/mapoverlap.inl"

#include "src/mapoverlap_cpu.inl"

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

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

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

#endif