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
{
    
  // this default constructor is the key here…. 
  BackEndParams() : backend(CPU_BACKEND) /* does not use it so it does not matter... */
  {
    #ifdef SKEPU_MAX_GPU_THREADS
      maxThreads = SKEPU_MAX_GPU_THREADS;
    #else   
      maxThreads = 64;
    #endif
    
    #ifdef SKEPU_MAX_GPU_BLOCKS
      maxBlocks = SKEPU_MAX_GPU_BLOCKS;
    #else   
      maxBlocks = 65535;
    #endif  
    
    #ifdef SKEPU_OMP_MAX_THREADS
      numOmpThreads = SKEPU_OMP_MAX_THREADS;
    #else   
      numOmpThreads = 2;
    #endif
  }
    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