include_starpu/skepu/src/exec_plan.h

Go to the documentation of this file.

#ifndef EXEC_PLAN_H
#define EXEC_PLAN_H

#include <map>



namespace skepu
{

enum BackEnd
{
    CPU_BACKEND,
    OMP_BACKEND,
    CU_BACKEND,
    CUM_BACKEND,
    CL_BACKEND,
    CLM_BACKEND
};


struct BackEndParams
{
  BackEndParams(): backend(CPU_BACKEND), maxThreads(32), maxBlocks(2048), numOmpThreads(1)  {}
    BackEnd backend;
    int maxThreads;
    int maxBlocks;
    int numOmpThreads;
};


class ExecPlan
{
public:
  
    void add(int lowBound, int highBound, BackEnd backend, unsigned gs, unsigned bs)
    {
        BackEndParams bp;
        bp.backend=backend;
        bp.maxThreads=bs;
        bp.maxBlocks = gs;
        sizePlan.insert(std::make_pair(std::make_pair(lowBound, highBound),bp));
    }  
  
    void add(int lowBound, int highBound, BackEnd backend, unsigned numOmpThreads)
    {
        BackEndParams bp;
        bp.backend=backend;
    bp.numOmpThreads = numOmpThreads;
        sizePlan.insert(std::make_pair(std::make_pair(lowBound, highBound),bp));
    }

    void add(int lowBound, int highBound, BackEndParams params)
    {
        sizePlan.insert(std::make_pair(std::make_pair(lowBound, highBound),params));
    }
    
    void add(int lowBound, int highBound, BackEnd backend)
    {
      BackEndParams bp;
      bp.backend=backend;
      sizePlan.insert(std::make_pair(std::make_pair(lowBound, highBound),bp));
    }
    
    void setMaxThreads(int size, int maxthreads)
    {
        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                it->second.maxThreads=maxthreads;
        return;
        }
        }

        (--it)->second.maxThreads= maxthreads;
    }
    
    void setMaxBlocks(int size, int maxBlocks)
    {
        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                it->second.maxBlocks=maxBlocks;
        return;
        }
        }

        (--it)->second.maxBlocks= maxBlocks;
    }
    
    void setNumOmpThreads(int size, int ompThreads)
    {
        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                it->second.numOmpThreads = ompThreads;
        return;
        }
        }

        (--it)->second.numOmpThreads = ompThreads;
    }
    
    int numOmpThreads(int size)
    {
        if(sizePlan.empty())
            return 1;

        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                return it->second.numOmpThreads;
        }
        }

        return (--it)->second.numOmpThreads;
    }
    
    int maxThreads(int size)
    {
        if(sizePlan.empty())
            return 32;

        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                return it->second.maxThreads;
        }
        }

        return (--it)->second.maxThreads;
    }

    BackEnd find(int size)
    {
        if(sizePlan.empty())
            return CPU_BACKEND;

        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                return it->second.backend;
        }
        }

        return (--it)->second.backend;
    }
    
    BackEndParams find_(int size)
    {
        if(sizePlan.empty())
      return BackEndParams();

        std::map< std::pair<int, int>, BackEndParams >::iterator it;
        for(it = sizePlan.begin(); it != sizePlan.end(); ++it)
        {
            if(size >= it->first.first && size <= it->first.second)
        {
                return it->second;
        }
        }

        return (--it)->second;
    }
    
    void clear()
    {
       sizePlan.clear();
    }

private:
    std::map< std::pair<int, int>, BackEndParams > sizePlan;
};

}

#endif