include_starpu/skepu/src/environment.h

Go to the documentation of this file.

#ifndef DEVICE_H
#define DEVICE_H

#ifndef SKEPU_NUMGPU
#define SKEPU_NUMGPU 0
#endif

#include <vector>

#ifdef SKEPU_OPENCL
#include "device_cl.h"
#include "device_mem_pointer_cl.h"
#endif

#include <sstream>

#include "skepu/vector.h"

namespace skepu
{

template <typename T>
class EnvironmentDestroyer; 



template <typename T>
class Environment
{

public:


enum SkelObjectType {
    MAP_UNARY = 0,
    MAP_BINARY,
    MAP_TERNARY,
    MAP_UNARY_MATRIX,
    MAP_BINARY_MATRIX,
    MAP_TERNARY_MATRIX,
    MAPRED_UNARY,
    MAPRED_BINARY,
    MAPRED_TERNARY,
    REDUCE,
    MAP_ARRAY,
    MAP_ARRAY_MATRIX,
    MAP_OVERLAP,
    MAP_OVERLAP_MAT_ROW,
    MAP_OVERLAP_MAT_COL,
    MAP_OVERLAP_MAT_CONVOL,
    NUMBER_OF_SkelObjectType
  };

    static Environment* getInstance();
    
    int objCounters[NUMBER_OF_SkelObjectType];

    #ifdef SKEPU_OPENCL
        std::vector<Device_CL*> m_devices_CL;
    #endif

    #ifdef SKEPU_CUDA
//      std::vector<Device_CU*> m_devices_CU; // Not used in this translation
    #endif

    void finishAll();
    
 protected:
    Environment();
    
virtual ~Environment();
    
    friend class EnvironmentDestroyer<T>; // To safely clean resources
   

    
private:
    
    static EnvironmentDestroyer<T> _destroyer;
    

    void init();

private:
    static Environment* instance;    
    struct starpu_conf conf;


public:
    unsigned int getNextTagID()
    {
        int tagId = ++tagCounter;
        m_tagIds.push_back(tagId);
        return tagId;
    } 
    unsigned int getCurrentTagID()
    {
        return tagCounter;
    }    
private:    
    unsigned int tagCounter;
    
public:
    std::vector<unsigned int> m_tagIds;    
    bool m_useTagIds;
    bool m_isFarmCall;

};


template <typename T>
EnvironmentDestroyer<T> Environment<T>::_destroyer;


template <typename T>
class EnvironmentDestroyer 
{
    public:
        EnvironmentDestroyer(Environment<T>* = 0);
        ~EnvironmentDestroyer();

        void SetEnvironment(Environment<T>* s);
    private:
        Environment<T>* _singleton;
 };
 
 
 

 template <typename T>
 EnvironmentDestroyer<T>::EnvironmentDestroyer(Environment<T>* s) {
     _singleton = s;
 }

 template <typename T>
 EnvironmentDestroyer<T>::~EnvironmentDestroyer () {
     delete _singleton;
 }

 template <typename T>
 void EnvironmentDestroyer<T>::SetEnvironment (Environment<T>* s) {
     _singleton = s;
 }

}

#include "environment.inl"

#endif