map.h

Go to the documentation of this file.

#ifndef MAP_H
#define MAP_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/vector.h"
#include "skepu/matrix.h"
#include "skepu/sparse_matrix.h"

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

#include "skepu/task.h"

namespace skepu
{

template <typename MapFunc, typename T, skepu::FuncType c_type=UNARY, skepu_container_type cont_type=VECTOR>
class Map: public Task
{
    
typedef struct
{
    Map<MapFunc, T, c_type, cont_type> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    bool unaryOperand;
}ArgumentBuffer;

public:

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, Vector<T> *input, Vector<T> *output, int parts=1);
    

    ~Map();
    
    
    Vector<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }
    

    void setInput(Vector<T> *in)
    {
        input = in;
    }
    
    void setOutput(Vector<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    } 

    
    void run_async();

    template <typename U> 
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;
#endif
    
    struct starpu_codelet *sameIOCodelet;
    struct starpu_codelet *diffIOCodelet;
    
    bool unaryOperand;

public:
    void operator()(Vector<T>& input);
    
    void operator()(Vector<T>& input, Vector<T>& output); // , unsigned int *tagId=0
    
    void operator()(Vector<T>& input, int parts);
    
    void operator()(Vector<T>& input, Vector<T>& output, int parts);
    
public:
    static void cpu_func(void *buffers[], void *arg);
                
#ifdef SKEPU_OPENMP
public:
    static void omp_func(void *buffer[], void *arg);
#endif    

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    
    Vector<T> *input; 
    
    Vector<T> *output;
    
    int parts;


};






template <typename MapFunc, typename T>
class Map<MapFunc, T, BINARY, VECTOR>: public Task
{

typedef struct
{
    Map<MapFunc, T, BINARY, VECTOR> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    int bufferIndex[3];
}ArgumentBuffer;


public:
    int bufferIndex[3];

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, Vector<T> *in1, Vector<T> *in2, Vector<T> *out, int parts=1);

    ~Map();
    
    Vector<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }

    void setInput1(Vector<T> *in)
    {
        input1 = in;
    }
    
    void setInput2(Vector<T> *in)
    {
        input2 = in;
    }
    
    void setOutput(Vector<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    }
    
    void run_async();

    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *singleBuffCodelet;   
    struct starpu_codelet *doubleBuffCodelet;
    struct starpu_codelet *tripleBuffCodelet;
    
#ifdef UNEVEN_PART
    struct starpu_codelet *singleBuffCodelet2;   
    struct starpu_codelet *doubleBuffCodelet2;
    struct starpu_codelet *tripleBuffCodelet2;
#endif
    
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;      
    starpu_perfmodel *map3_perf_model;      
#endif

public:
    void operator()(Vector<T>& input1, Vector<T>& input2, Vector<T>& output);
    
    void operator()(Vector<T>& input1, Vector<T>& input2, Vector<T>& output, int parts);

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

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    std::string perfmodel3_str;

    Vector<T> *input1; 
    Vector<T> *input2; 
    Vector<T> *output;
    
    int parts;
};







template <typename MapFunc, typename T>
class Map<MapFunc, T, TERNARY, VECTOR>: public Task
{

typedef struct
{
    Map<MapFunc, T, TERNARY, VECTOR> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    int bufferIndex[4];
}ArgumentBuffer;

public:
    int bufferIndex[4];

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, Vector<T> *in1, Vector<T> *in2, Vector<T> *in3, Vector<T> *out, int parts=1);

    ~Map();
    
    
    Vector<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }

    void setInput1(Vector<T> *in)
    {
        input1 = in;
    }
    
    void setInput2(Vector<T> *in)
    {
        input2 = in;
    }
    
    void setInput3(Vector<T> *in)
    {
        input3 = in;
    }
    
    void setOutput(Vector<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    }
    
    void run_async();


    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *singleBuffCodelet;   
    struct starpu_codelet *doubleBuffCodelet;
    struct starpu_codelet *tripleBuffCodelet;
    struct starpu_codelet *fourBuffCodelet;  
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;      
    starpu_perfmodel *map3_perf_model;
    starpu_perfmodel *map4_perf_model;    
#endif    
    

public:
    void operator()(Vector<T>& input1, Vector<T>& input2, Vector<T>& input3, Vector<T>& output);
    
    void operator()(Vector<T>& input1, Vector<T>& input2, Vector<T>& input3, Vector<T>& output, int parts);


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

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    std::string perfmodel3_str;
    std::string perfmodel4_str;
    
    Vector<T> *input1; 
    Vector<T> *input2; 
    Vector<T> *input3; 
    
    Vector<T> *output;
    
    int parts;

};





//#########
//#########
//#########
//#########
//#########
//#########
//#########
//#########


template <typename MapFunc, typename T>
class Map<MapFunc, T, UNARY, MATRIX>: public Task 
{
    
typedef struct
{
    Map<MapFunc, T, UNARY, MATRIX> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    bool unaryOperand;
}ArgumentBuffer;

public:

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, Matrix<T> *input, Matrix<T> *output, int parts=1);
    

    ~Map();
    
    
    Matrix<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }
    

    void setInput(Matrix<T> *in)
    {
        input = in;
    }
    
    void setOutput(Matrix<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    } 

    
    void run_async();

    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;
#endif
    
    struct starpu_codelet *sameIOCodelet;
    struct starpu_codelet *diffIOCodelet;
    
    bool unaryOperand;

public:
    void operator()(Matrix<T>& input);
    
    void operator()(Matrix<T>& input, Matrix<T>& output); // , unsigned int *tagId=0
    
    void operator()(Matrix<T>& input, int parts);
    
    void operator()(Matrix<T>& input, Matrix<T>& output, int parts);
    
public:
    static void cpu_func(void *buffers[], void *arg);
                
#ifdef SKEPU_OPENMP
public:
    static void omp_func(void *buffer[], void *arg);
#endif    

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], void *arg);
    
    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 perfmodel1_str;
    std::string perfmodel2_str;
    
    Matrix<T> *input; 
    
    Matrix<T> *output;
    
    int parts;


};


template <typename MapFunc, typename T>
class Map<MapFunc, T, BINARY, MATRIX>: public Task
{

typedef struct
{
    Map<MapFunc, T, BINARY, MATRIX> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    int bufferIndex[3];
}ArgumentBuffer;


public:
    int bufferIndex[3];

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, Matrix<T> *in1, Matrix<T> *in2,  Matrix<T> *out, int _parts=1);
    
    
    Matrix<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }

    void setInput1(Matrix<T> *in)
    {
        input1 = in;
    }
    
    void setInput2(Matrix<T> *in)
    {
        input2 = in;
    }
    
    void setOutput(Matrix<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    }
    
    void run_async();


    ~Map();

    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *singleBuffCodelet;   
    struct starpu_codelet *doubleBuffCodelet;
    struct starpu_codelet *tripleBuffCodelet;

#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;      
    starpu_perfmodel *map3_perf_model;      
#endif

public:
    void operator()(Matrix<T>& input1, Matrix<T>& input2, Matrix<T>& output);
    
    void operator()(Matrix<T>& input1, Matrix<T>& input2, Matrix<T>& output, int xparts);
    
    void operator()(Matrix<T>& input1, Matrix<T>& input2, Matrix<T>& output, int xparts, int yparts);


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

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    std::string perfmodel3_str;
    
    Matrix<T> *input1; 
    Matrix<T> *input2; 
    
    Matrix<T> *output;
    
    int parts;
};








template <typename MapFunc, typename T>
class Map<MapFunc, T, TERNARY, MATRIX>: public Task
{

typedef struct
{
    Map<MapFunc, T, TERNARY, MATRIX> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    int bufferIndex[4];
}ArgumentBuffer;

public:
    int bufferIndex[4];

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, Matrix<T> *in1, Matrix<T> *in2, Matrix<T> *in3, Matrix<T> *out, int parts=1);

    ~Map();
    
    
    Matrix<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }

    void setInput1(Matrix<T> *in)
    {
        input1 = in;
    }
    
    void setInput2(Matrix<T> *in)
    {
        input2 = in;
    }
    
    void setInput3(Matrix<T> *in)
    {
        input3 = in;
    }
    
    void setOutput(Matrix<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    }
    
    void run_async();


    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *singleBuffCodelet;   
    struct starpu_codelet *doubleBuffCodelet;
    struct starpu_codelet *tripleBuffCodelet;
    struct starpu_codelet *fourBuffCodelet;  
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;      
    starpu_perfmodel *map3_perf_model;
    starpu_perfmodel *map4_perf_model;    
#endif    
    

public:
    void operator()(Matrix<T>& input1, Matrix<T>& input2, Matrix<T>& input3, Matrix<T>& output);
    
    void operator()(Matrix<T>& input1, Matrix<T>& input2, Matrix<T>& input3, Matrix<T>& output, int parts);


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

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    std::string perfmodel3_str;
    std::string perfmodel4_str;
    
    Matrix<T> *input1; 
    Matrix<T> *input2; 
    Matrix<T> *input3; 
    
    Matrix<T> *output;
    
    int parts;

};













//#########
//#########
//#########
//#########
//#########
//#########
//#########
//#########


template <typename MapFunc, typename T>
class Map<MapFunc, T, UNARY, SPARSE_MATRIX>: public Task 
{
    
typedef struct
{
    Map<MapFunc, T, UNARY, SPARSE_MATRIX> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    bool unaryOperand;
}ArgumentBuffer;

public:

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, SparseMatrix<T> *input, SparseMatrix<T> *output, int parts=1);
    

    ~Map();
    
    
    SparseMatrix<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }
    

    void setInput(SparseMatrix<T> *in)
    {
        input = in;
    }
    
    void setOutput(SparseMatrix<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    } 

    
    void run_async();

    template <typename U>  
    void setConstant(U constant1) { m_mapFunc->setConstant(constant1); }

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;
#endif
    
    struct starpu_codelet *sameIOCodelet;
    struct starpu_codelet *diffIOCodelet;
    
    bool unaryOperand;

public:
    void operator()(SparseMatrix<T>& input);
    
    void operator()(SparseMatrix<T>& input, SparseMatrix<T>& output); // , unsigned int *tagId=0
    
    void operator()(SparseMatrix<T>& input, int parts);
    
    void operator()(SparseMatrix<T>& input, SparseMatrix<T>& output, int parts);
    
public:
    static void cpu_func(void *buffers[], void *arg);
                
#ifdef SKEPU_OPENMP
public:
    static void omp_func(void *buffer[], void *arg);
#endif    

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    
    SparseMatrix<T> *input; 
    
    SparseMatrix<T> *output;
    
    int parts;


};


template <typename MapFunc, typename T>
class Map<MapFunc, T, BINARY, SPARSE_MATRIX>: public Task
{

typedef struct
{
    Map<MapFunc, T, BINARY, SPARSE_MATRIX> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    int bufferIndex[3];
}ArgumentBuffer;


public:
    int bufferIndex[3];

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, SparseMatrix<T> *in1, SparseMatrix<T> *in2,  SparseMatrix<T> *out, int _parts=1);
    
    
    SparseMatrix<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }

    void setInput1(SparseMatrix<T> *in)
    {
        input1 = in;
    }
    
    void setInput2(SparseMatrix<T> *in)
    {
        input2 = in;
    }
    
    void setOutput(SparseMatrix<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    }
    
    void run_async();


    ~Map();

    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *singleBuffCodelet;   
    struct starpu_codelet *doubleBuffCodelet;
    struct starpu_codelet *tripleBuffCodelet;

#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;      
    starpu_perfmodel *map3_perf_model;      
#endif

public:
    void operator()(SparseMatrix<T>& input1, SparseMatrix<T>& input2, SparseMatrix<T>& output);
    
    void operator()(SparseMatrix<T>& input1, SparseMatrix<T>& input2, SparseMatrix<T>& output, int xparts);
    
public:
    static void cpu_func(void *buffers[], void *arg);
                
#ifdef SKEPU_OPENMP
public:
    static void omp_func(void *buffer[], void *arg);
#endif    

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    std::string perfmodel3_str;
    
    SparseMatrix<T> *input1; 
    SparseMatrix<T> *input2; 
    
    SparseMatrix<T> *output;
    
    int parts;
};








template <typename MapFunc, typename T>
class Map<MapFunc, T, TERNARY, SPARSE_MATRIX>: public Task
{

typedef struct
{
    Map<MapFunc, T, TERNARY, SPARSE_MATRIX> *pMap;
    typename MapFunc::CONST_TYPE constant;
    bool parts;
    int bufferIndex[4];
}ArgumentBuffer;

public:
    int bufferIndex[4];

    Map(MapFunc* mapFunc);
    
    Map(MapFunc* mapFunc, SparseMatrix<T> *in1, SparseMatrix<T> *in2, SparseMatrix<T> *in3, SparseMatrix<T> *out, int parts=1);

    ~Map();
    
    
    SparseMatrix<T>& getOutput()
    {
        return *output;
    } 
    
    void *get_result()
    {
        return output;
    }

    void setInput1(SparseMatrix<T> *in)
    {
        input1 = in;
    }
    
    void setInput2(SparseMatrix<T> *in)
    {
        input2 = in;
    }
    
    void setInput3(SparseMatrix<T> *in)
    {
        input3 = in;
    }
    
    void setOutput(SparseMatrix<T> *out)
    {
        output = out;
    } 
    
    void setPartitions(int _parts)
    {
        parts = _parts;
    }
    
    void run_async();


    template <typename U>  
    void setConstant(U constant1) {m_mapFunc->setConstant(constant1);}

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

public:
    Environment<int>* m_environment;
    MapFunc* m_mapFunc;
    ExecPlan m_execPlan;
    
    struct starpu_codelet *singleBuffCodelet;   
    struct starpu_codelet *doubleBuffCodelet;
    struct starpu_codelet *tripleBuffCodelet;
    struct starpu_codelet *fourBuffCodelet;  
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *map1_perf_model;
    starpu_perfmodel *map2_perf_model;      
    starpu_perfmodel *map3_perf_model;
    starpu_perfmodel *map4_perf_model;    
#endif    
    

public:
    void operator()(SparseMatrix<T>& input1, SparseMatrix<T>& input2, SparseMatrix<T>& input3, SparseMatrix<T>& output);
    
    void operator()(SparseMatrix<T>& input1, SparseMatrix<T>& input2, SparseMatrix<T>& input3, SparseMatrix<T>& output, int parts);


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

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

#ifdef SKEPU_OPENCL
public:
    static void opencl_func(void *buffer[], 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 perfmodel1_str;
    std::string perfmodel2_str;
    std::string perfmodel3_str;
    std::string perfmodel4_str;
    
    SparseMatrix<T> *input1; 
    SparseMatrix<T> *input2; 
    SparseMatrix<T> *input3; 
    
    SparseMatrix<T> *output;
    
    int parts;

};



}

#include "src/map.inl"
#include "src/map_matrix.inl"
#include "src/map_sparse_matrix.inl"

#include "src/map_cpu.inl"
#include "src/map_cpu_matrix.inl"
#include "src/map_cpu_sparse_matrix.inl"

#ifdef SKEPU_OPENMP
#include "src/map_omp.inl"
#include "src/map_omp_matrix.inl"
#include "src/map_omp_sparse_matrix.inl"
#endif

#ifdef SKEPU_OPENCL
#include "src/map_cl.inl"
#include "src/map_cl_matrix.inl"
#include "src/map_cl_sparse_matrix.inl"
#endif

#ifdef SKEPU_CUDA
#include "src/map_cu.inl"
#include "src/map_cu_matrix.inl"
#include "src/map_cu_sparse_matrix.inl"
#endif

#endif