reduce.h

Go to the documentation of this file.

#ifndef REDUCE_H
#define REDUCE_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/task.h"
#include "src/operator_macros.h"
#include "src/exec_plan.h"
#include "skepu/task.h"

namespace skepu
{
    
    #define MAX_REDUCE_PART 10

template <typename ReduceFunc, typename T>
class Reduce: public Task
{

public:
//    typename ReduceFunc::TYPE resultValue;
    starpu_data_handle_t  scalar_result_handle;
    bool isScalarStarPU;

    Reduce(ReduceFunc* reduceFunc);
    
    Reduce(ReduceFunc* reduceFunc, Vector<T> *in, T *out);

    ~Reduce();
    
    
    void *get_result()
    {
        if(isScalarStarPU)
        {
            starpu_data_unregister(scalar_result_handle); // unregister as this data can be modified
            isScalarStarPU = false;
        }

        return output;
    }
    

    void setInput(Vector<T> *in)
    {
        input = in;
    }
    
    void setOutput(T *out)
    {
        if(isScalarStarPU)
            starpu_data_acquire(scalar_result_handle, STARPU_W);
            
        output = out;
        
        if(isScalarStarPU)
            starpu_data_release(scalar_result_handle);
    } 
    
    T getOutput()
    {
        if(isScalarStarPU)
        {
            T _output;
            starpu_data_acquire(scalar_result_handle, STARPU_R); // acquire as we know that it is just a read access…
            _output = *output;
            starpu_data_release(scalar_result_handle); // release acquire before returning control…
            return _output;
        }
        return *output;
    } 
    
    void run_async();

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

private:
    Environment<int>* m_environment;
    ReduceFunc* m_reduceFunc;
    ExecPlan m_execPlan;
    
#ifdef USE_STARPU_HISTORY_MODEL    
    starpu_perfmodel *red_perf_model;
#endif
    
    struct starpu_codelet *codelet;
    
    #ifdef UNEVEN_PART
    struct starpu_codelet *codelet2;   
    #endif

public:
    T operator()(Vector<T>& input);
    
    T operator()(Vector<T>& input, int parts);

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[1028];

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

private:
    std::string perfmodel_str;
    
    Vector<T> *input;
    T *output;
    Vector<T> *temp_output;
//  T *inter_output[MAX_REDUCE_PART];
    
};

}

#include "src/reduce.inl"

#include "src/reduce_cpu.inl"

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

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

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

#endif