data_tune.h

Go to the documentation of this file.

#ifndef DATA_TUNE_H
#define DATA_TUNE_H

#include <string>
#include <iostream>
#include <map>

#include <utility>
#include <fstream>
#include <algorithm> // uses for converting string to uppercase or lower case using transform algorithm
#include <iomanip>

#include <skepu/vector.h>
#include "exec_plan.h"

#include <iostream>




namespace skepu
{

template<typename T>
struct TuneParams
{
   TuneParams() {}
   TuneParams(T repPart, T fixPart, BackEnd be, int gs, int bs): repeatPart(repPart), fixedPart(fixPart)
   {
      backendParams.backend=be;
      backendParams.maxThreads=bs;
      backendParams.maxBlocks=gs;
   }

   TuneParams(T repPart, T fixPart, BackEnd be, int num_omp=1): repeatPart(repPart), fixedPart(fixPart)
   {
      backendParams.backend=be;
      backendParams.numOmpThreads=num_omp;
   }

   T getPrediction(int repetition=1)
   {
      return (repeatPart*repetition) + fixedPart;
   }

   T getPredictionPercentage(int percent=100, int repetition=1)
   {
      return (repeatPart*repetition) + (fixedPart* ((double)percent/100.0f));
   }

   BackEnd backend()
   {
      return backendParams.backend;
   }
   int maxBlocks()
   {
      return backendParams.maxBlocks;
   }
   int maxThreads()
   {
      return backendParams.maxThreads;
   }
   int numOmpThreads()
   {
      return backendParams.numOmpThreads;
   }

   void backend(BackEnd be)
   {
      backendParams.backend=be;
   }
   void maxBlocks(int mb)
   {
      backendParams.maxBlocks=mb;
   }
   void maxThreads(int mt)
   {
      backendParams.maxThreads=mt;
   }
   void numOmpThreads(int numTrd)
   {
      backendParams.numOmpThreads=numTrd;
   }

   BackEndParams backendParams;

   T fixedPart;
   T repeatPart;
   double time;
};

template <typename Tx, typename Ty>
class TuneData
{

public:
   TuneData(const std::string& _dataSetName, const std::string& _axisNameX, const std::string& _axisNameY);

   void addData(Tx x, TuneParams<Ty> params, int repetition=1);
   void clear();
   void writeDataToFile(const std::string& filename = "", int repeatition=1, DataExportFormat format = GNUPLOT);

   ExecPlan& getExecPlan(Vector<Tx>& v1, Vector<Tx>& v2, int percent=100);

   Ty getPrediction(Tx index, int repeatition=1);


   void loadPrediction(const std::string& filename, int repetition=1);

   friend std::ostream& operator <<(std::ostream &os, TuneData& tunedata)
   {
      os<<"MapDataSet Size:"<<tunedata.predictionData.size()<<"\n";
      int tabLength = 10;
      for(typename std::map< Tx, TuneParams<Ty> >::iterator it = tunedata.predictionData.begin(); it != tunedata.predictionData.end(); ++it)
      {
         TuneParams<Ty> params= it->second;
         BackEndParams bp=params.backendParams;
         if(bp.backend==CPU_BACKEND)
            os<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) << params.repeatPart << std::setw(tabLength) << params.fixedPart <<std::setw(20)<< tunedata.convertBackendToStr(bp.backend) <<"\n";
         else if(bp.backend==OMP_BACKEND)
            os<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) << params.repeatPart << std::setw(tabLength) << params.fixedPart <<std::setw(20)<< tunedata.convertBackendToStr(bp.backend) <<std::setw(20)<< bp.numOmpThreads<<"\n";
         else
            os<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) << params.repeatPart << std::setw(tabLength) << params.fixedPart <<std::setw(20)<< tunedata.convertBackendToStr(bp.backend) <<std::setw(20)<< bp.maxBlocks<< std::setw(10)<<bp.maxThreads <<"\n";
      }
      return os;
   }

   void writeGnuPlotFileOMP(const std::string& filename,int threads=1);

   ExecPlan& buildExecPlan();

   void changeRepeatPart(std::pair<int, Ty> newRep[], int size);
   void changeRepeatPart_NoAvg(std::pair<int, Ty> newRep[], int size);

   std::pair<Ty,Ty> getPredictionPair(Tx size);

private:

   ExecPlan& buildExecPlanMultiEntries();

   skepu::ExecPlan plan;
   std::string dataSetName;
   std::pair<std::string, std::string> axisNames;

   //std::map< Tx, std::pair<Ty, Ty> > dataSet;

#ifdef SKEPU_COMPOSE_PREDICTION
   std::multimap< Tx, TuneParams<Ty> > predictionData;
#else
   std::map< Tx, TuneParams<Ty> > predictionData;
#endif


   std::string convertBackendToStr(BackEnd be);
   BackEnd convertStrToBackend(std::string str);
   void writeGnuPlotFile(const std::string& filename,int repeatition=1);

   void savePrediction(const std::string& filename);


};

template <typename Tx, typename Ty>
TuneData<Tx, Ty>::TuneData(const std::string& _dataSetName, const std::string& _axisNameX, const std::string& _axisNameY)
{
   dataSetName = _dataSetName;
   axisNames.first = _axisNameX;
   axisNames.second = _axisNameY;
}

// template <typename Tx, typename Ty>
// void TuneData<Tx, Ty>::addData(Tx size, Ty repeatPart, Ty fixedPart)
// {
//   typename std::map< Tx, TuneParams<Ty> >::iterator it=predictionData.find(size);
//   if(it!=predictionData.end())  // if already prediction exist for this case
//   {
//     if((it->second.repeatPart + it->second.fixedPart) > (repeatPart + fixedPart))  // if new one is optimal than previous
//     {
//       predictionData.erase(it);
//     }
//     else
//       return;
//   }
//   dataSet.insert(std::make_pair(size, std::make_pair(repeatPart, fixedPart)));
//   return;
// }


template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::addData(Tx size, TuneParams<Ty> params, int repetition)
{
#ifndef SKEPU_COMPOSE_PREDICTION
   typename std::map< Tx, TuneParams<Ty> >::iterator it=predictionData.find(size);
   if(it!=predictionData.end())  // if already prediction exist for this case
   {
      TuneParams<Ty> org_p= it->second;
      if( org_p.getPrediction(repetition) > params.getPrediction(repetition)) // if new one is optimal than previous
      {
         predictionData.erase(it);
      }
      else
         return;

   }
#endif
// comment above to add this as an alternative choice
   predictionData.insert(std::make_pair(size, params));
   return;

   //    std::cout<<params.backend<<"---"<<convertBackendToStr(params.backend)<<"\n";
}

template <typename Tx, typename Ty>
std::string TuneData<Tx, Ty>::convertBackendToStr(BackEnd be)
{
   std::string retval("CPU_BACKEND"); // default, if not match any other case

   switch(be)
   {
   case CL_BACKEND:
      retval= std::string("CL_BACKEND");
      break;
   case CLM_BACKEND:
      retval= std::string("CLM_BACKEND");
      break;
   case CU_BACKEND:
      retval= std::string("CU_BACKEND");
      break;
   case CUM_BACKEND:
      retval= std::string("CUM_BACKEND");
      break;
   case OMP_BACKEND:
      retval= std::string("OMP_BACKEND");
      break;
   case CPU_BACKEND:
      retval= std::string("CPU_BACKEND");
      break;
   }
   return retval;
}

template <typename Tx, typename Ty>
BackEnd TuneData<Tx, Ty>::convertStrToBackend(std::string str)
{
   std::transform(str.begin(), str.end(), str.begin(), ::toupper);  // to convert in upper case to avoid any erroneous mismatch just because of case
//  std::cout<<">>>>"<<str<<"<<<<<";

   if(str=="CL_BACKEND")
      return CL_BACKEND;
   else if(str=="CLM_BACKEND")
      return CLM_BACKEND;
   else if(str=="CU_BACKEND")
      return CU_BACKEND;
   else if(str=="CUM_BACKEND")
      return CUM_BACKEND;
   else if(str=="OMP_BACKEND")
      return OMP_BACKEND;
   else if(str=="CPU_BACKEND")
      return CPU_BACKEND;

   return CPU_BACKEND; // default, if not match any other case
}


template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::changeRepeatPart(std::pair<int, Ty> newRep[], int size)
{
   double ratio;
   double *ratios = new double[size];
   for(int i=0; i<size; i++)
   {
      std::pair<Ty, Ty> p= getPredictionPair(newRep[i].first);
      ratios[i]= (double)p.first/newRep[i].second;
      std::cout<<"First for loop: "<<p.first<<"   "<<newRep[i].second<<"   ratio:"<<ratios[i]<<"\n";
   }
   double avgRatio=0.0;
   for(int i=0; i<size; i++)
   {
      avgRatio += ratios[i];
   }
   avgRatio /= size;  // calculate average
   std::cout<<"AvgRatio: "<<avgRatio<<"\n";

   // now modify all predictions.........
   typename std::map< Tx, TuneParams<Ty> >::iterator it;
   for(it=predictionData.begin(); it!=predictionData.end(); it++)
   {
      std::cout<<"Before: "<<it->second.repeatPart;
      it->second.repeatPart = ((double)(it->second.repeatPart)/avgRatio);
      std::cout<<"   After: "<<it->second.repeatPart<<"\n";
   }
}






template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::changeRepeatPart_NoAvg(std::pair<int, Ty> newRep[], int size)
{
   double ratio;

   std::map<std::pair<int, int>, double> rangesRatio;
   int lower=1, upper=1, prev_upper=-1;
   for(int i=0; i<size; i++)
   {
      if(i!=0) // not first one
         lower = ((prev_upper == -1) ? ((newRep[i].first + newRep[(i-1)].first)/2) : (prev_upper+1) );
      else
         lower = 1;

      if(i!=(size-1))
         upper = (newRep[i].first + newRep[(i+1)].first)/2;
      else
         upper  = newRep[i].first +1;


      std::pair<Ty, Ty> p= getPredictionPair(newRep[i].first);
      ratio= (double)p.first/newRep[i].second;

      rangesRatio.insert(std::make_pair(std::make_pair(lower, upper), ratio));

      std::cout<<"First for loop: "<<p.first<<"   "<<newRep[i].second<<"   ratio:"<<ratio<<" "<<newRep[i].first<<"   "<<lower<<"  ---  "<<upper<<"\n";

      prev_upper = upper;
   }

   typename std::map< Tx, TuneParams<Ty> >::iterator it, prev_it, nxt_it;

   for(it=predictionData.begin(); it!=predictionData.end(); it++)
   {
      std::map< std::pair<int, int>, double >::iterator ratio_it;
      for(ratio_it = rangesRatio.begin(); ratio_it != rangesRatio.end(); ++ratio_it)
      {
         if(it->first >= ratio_it->first.first && it->first <= ratio_it->first.second)
         {
            std::cout<<"Before: "<<it->second.repeatPart;
            it->second.repeatPart = ((double)(it->second.repeatPart)/ratio_it->second);
            std::cout<<"   After: "<<it->second.repeatPart<<"\n";
            break;
         }
      }
   }
}



template <typename Tx, typename Ty>
ExecPlan& TuneData<Tx, Ty>::buildExecPlanMultiEntries()
{
   if(predictionData.empty())
      return plan;  // no entry

   plan.clear();

   BackEndParams bp;//, prev_bp;
   int optionsCount=predictionData.count(predictionData.begin()->first);
   BackEndParams *prev_bp=new BackEndParams[optionsCount];
   int size;
   bool finish;
   int prev_upperLimit=-1;
   int lowerLimit=1, upperLimit;

   typedef typename std::map< Tx, TuneParams<Ty> >::iterator CIT;
   std::pair<CIT,CIT> range;

   typename std::map< Tx, TuneParams<Ty> >::iterator it;
   for(it = predictionData.begin(); it != predictionData.end();)
   {

      size=it->first;
      bp= (it->second.backendParams);

//     std::cout<<size<<" "<<convertBackendToStr(bp.backend)<<" "<<bp.numOmpThreads<<" "<<bp.maxThreads<<" "<<bp.maxBlocks<<"\n";

      upperLimit=size;
      if(prev_upperLimit!=-1)  // not first iteration
      {

         if(prev_bp[0].backend == bp.backend)
         {
            if(prev_bp[0].backend == OMP_BACKEND && (prev_bp[0].numOmpThreads == bp.numOmpThreads))
            {
               finish=false;
            }
            else if(prev_bp[0].backend == CPU_BACKEND)
               finish=false;
            else if((prev_bp[0].backend != OMP_BACKEND && prev_bp[0].backend != CPU_BACKEND) && prev_bp[0].maxThreads == bp.maxThreads && prev_bp[0].maxBlocks == bp.maxBlocks)
               finish=false;
            else
            {
//      std::cout<<"Hello inner else\n";
               finish=true;
            }
         }
         else
         {
//    std::cout<<"Hello outer else\n";
            finish=true;
         }
      }
      else
         finish=false;

      if(finish)
      {
         int newLimit;
//  if(prev_upperLimit != -1)

         newLimit= ((upperLimit+prev_upperLimit)/2);
//    std::cout<<upperLimit<<"   "<<prev_upperLimit<<" "<<newLimit<<"\n";
         /* else
              newLimit= upperLimit;*/


         range= predictionData.equal_range(size);
         TuneParams<Ty> params;
         int ind=0;
         for(CIT subit=range.first; subit!=range.second; subit++)
         {
            TuneParams<Ty> params= subit->second;
            plan.add(lowerLimit, newLimit, prev_bp[ind]);
            std::cout<<lowerLimit<<" --- "<<newLimit<<" "<<convertBackendToStr(prev_bp[ind].backend)<<" "<<prev_bp[ind].numOmpThreads<<" "<<prev_bp[ind].maxThreads<<" "<<prev_bp[ind].maxBlocks<<"\n";
            prev_bp[ind++]; //=params.backendParams;
         }
         finish=false;
         lowerLimit= (newLimit+1);
      }
//       if(it==predictionData.end())
//  break;
//      it++;
      range= predictionData.equal_range(size);
      TuneParams<Ty> params;
      int ind=0;
      for(CIT subit=range.first; subit!=range.second; subit++)
      {
         TuneParams<Ty> params= subit->second;
         prev_bp[ind++]=params.backendParams;
      }
      prev_upperLimit=upperLimit;

      it = predictionData.upper_bound(size); // go to next key
   }
   range= predictionData.equal_range(size);
   for(int ind=0; ind<optionsCount; ind++)
   {
      plan.add(lowerLimit, prev_upperLimit, prev_bp[ind]);
      std::cout<<lowerLimit<<" --- "<<prev_upperLimit<<" "<<convertBackendToStr(prev_bp[ind].backend)<<" "<<prev_bp[ind].numOmpThreads<<" "<<prev_bp[ind].maxThreads<<" "<<prev_bp[ind].maxBlocks<<"\n";
   }

//  std::cout<<lowerLimit<<" --- "<<prev_upperLimit<<" "<<convertBackendToStr(prev_bp.backend)<<" "<<prev_bp.numOmpThreads<<" "<<prev_bp.maxThreads<<" "<<prev_bp.maxBlocks<<"\n";
   return plan;

}



template <typename Tx, typename Ty>
ExecPlan& TuneData<Tx, Ty>::buildExecPlan()
{
#ifdef SKEPU_COMPOSE_PREDICTION
   return buildExecPlanMultiEntries();
#endif
   if(predictionData.empty())
      return plan;  // no entry

   plan.clear();

   BackEndParams bp, prev_bp;
   int size;
   bool finish;
   int prev_upperLimit=-1;
   int lowerLimit=1, upperLimit;

   typename std::map< Tx, TuneParams<Ty> >::iterator it;
   for(it = predictionData.begin(); it != predictionData.end(); ++it)
   {
      size=it->first;
      bp= (it->second.backendParams);
      upperLimit=size;
      if(prev_upperLimit!=-1)  // not first iteration
      {

         if(prev_bp.backend == bp.backend)
         {
            if(prev_bp.backend == OMP_BACKEND && (prev_bp.numOmpThreads == bp.numOmpThreads))
            {
               finish=false;
            }
            else if(prev_bp.backend == CPU_BACKEND)
               finish=false;
            else if((prev_bp.backend != OMP_BACKEND && prev_bp.backend != CPU_BACKEND) && prev_bp.maxThreads == bp.maxThreads && prev_bp.maxBlocks == bp.maxBlocks)
               finish=false;
            else
            {
//      std::cout<<"Hello inner else\n";
               finish=true;
            }
         }
         else
         {
//    std::cout<<"Hello outer else\n";
            finish=true;
         }
      }
      else
         finish=false;

      if(finish)
      {
         int newLimit;
//  if(prev_upperLimit != -1)

         newLimit= ((upperLimit+prev_upperLimit)/2);
//    std::cout<<upperLimit<<"   "<<prev_upperLimit<<" "<<newLimit<<"\n";
         /* else
              newLimit= upperLimit;*/

         plan.add(lowerLimit, newLimit, prev_bp);
         std::cout<<lowerLimit<<" --- "<<newLimit<<" "<<convertBackendToStr(prev_bp.backend)<<" "<<prev_bp.numOmpThreads<<" "<<prev_bp.maxThreads<<" "<<prev_bp.maxBlocks<<"\n";
         finish=false;
         lowerLimit= (newLimit+1);
      }

      prev_bp=bp;
      prev_upperLimit=upperLimit;
   }
   plan.add(lowerLimit, prev_upperLimit, prev_bp);
   std::cout<<lowerLimit<<" --- "<<prev_upperLimit<<" "<<convertBackendToStr(prev_bp.backend)<<" "<<prev_bp.numOmpThreads<<" "<<prev_bp.maxThreads<<" "<<prev_bp.maxBlocks<<"\n";
   return plan;

}

template <typename Tx, typename Ty>
ExecPlan& TuneData<Tx, Ty>::getExecPlan(Vector<Tx>& v1, Vector<Tx>& v2, int percent)
{
   plan.clear();
   int size=v1.size();
   if(predictionData.find(size) == predictionData.end())
   {
      std::cerr<< "No Information for this size\n";    // Inter- or extra-polations
      return plan;
   }

   typedef typename std::map< Tx, TuneParams<Ty> >::iterator CIT;
   std::pair<CIT,CIT> range;
   range= predictionData.equal_range(size);
   TuneParams<Ty> params;
   TuneParams<Ty> opt_params;
   for(CIT it=range.first; it!=range.second; it++)
   {
      TuneParams<Ty> params= it->second;
      if(params.backend()==CL_BACKEND && percent==100)
      {
#ifdef SKEPU_OPENCL
         Environment<Tx> *envir=Environment<Tx>::getInstance();
         if(v1.isVectorOnDevice_CL(envir->m_devices_CL.at(0)))
            percent-=50;
         if(v2.isVectorOnDevice_CL(envir->m_devices_CL.at(0)))
            percent-=50;
#endif
      }
      else if (params.backend()==CU_BACKEND && percent==100)
      {
#ifdef SKEPU_CUDA
         if(v1.isVectorOnDevice_CU(0))
            percent-=50;
         if(v2.isVectorOnDevice_CU(0))
            percent-=50;
#endif
      }
      if(it==range.first)
      {
         opt_params=params;
      }
      else if(opt_params.getPredictionPercentage(percent) > params.getPredictionPercentage(percent))
      {
         opt_params=params;
      }
   }
   plan.add(size-100, size+100, opt_params.backendParams);

   return plan;
}

template <typename Tx, typename Ty>
Ty TuneData<Tx, Ty>::getPrediction(Tx size, int repetition)
{

   typename std::map< Tx, TuneParams<Ty> >::iterator it=predictionData.find(size);

   if(it==predictionData.end())  // if prediction does not exist for this case
   {
      if( predictionData.size() <= 1)  // if only one item, cannot predict
         return -1;

      int prev_size=-1;
      double value;
      for(it=predictionData.begin(); it!= predictionData.end(); it++)
      {
         if(size < it->first)
         {
            if(prev_size==-1)  // less than first item
            {
               double prev_pred= predictionData.at(it->first)->second.getPrediction(repetition);
               double curr_pred= predictionData.at((it+1)->first)->second.getPrediction(repetition);
               value= (((double)(curr_pred-prev_pred))/((double)((it+1)->first - it->first)));
               return ( prev_pred - ((it->first-size) * value));
            }
            else
            {
               double prev_pred= predictionData.at(prev_size)->second.getPrediction(repetition);
               double curr_pred= predictionData.at(it->first)->second.getPrediction(repetition);

               value= (((double)(curr_pred-prev_pred))/((double)(it->first-prev_size)));
               return (( (size-prev_size) * value) + prev_pred);
            }

         }
         prev_size=it->first;
      }
      // if greater than even the last item
      it--;
      double prev_pred= predictionData.at((it-1)->first)->second.getPrediction(repetition);
      double curr_pred= predictionData.at(it->first)->second.getPrediction(repetition);

      value= (((double)(curr_pred-prev_pred))/((double)(it->first - (it-1)->first)));
      return (( (size - it->first) * value) + curr_pred);
   }

   return predictionData.at(size)->second.getPrediction(repetition);
}




template <typename Tx, typename Ty>
std::pair<Ty,Ty> TuneData<Tx, Ty>::getPredictionPair(Tx size)
{
   std::cout<<"In predictionPair\n";
   std::pair<Ty, Ty>  p(-1,-1);
   typename std::map< Tx, TuneParams<Ty> >::iterator it=predictionData.find(size);

   if(it==predictionData.end())  // if prediction does not exist for this case
   {
      if( predictionData.size() <= 1)  // if only one item, cannot predict
         return p;

      int prev_size=-1;
      std::pair<Ty, Ty> value;
      for(it=predictionData.begin(); it!= predictionData.end(); it++)
      {
         if(size < it->first)
         {
            if(prev_size==-1)  // less than first item
            {

               typename std::map< Tx, TuneParams<Ty> >::iterator temp_it= it;  // no operator + overload in iterator so need to do this agly stuff
               it++;
               std::pair<Ty, Ty> prev_pred(predictionData.find(temp_it->first)->second.repeatPart, predictionData.find(temp_it->first)->second.fixedPart);
               std::pair<Ty, Ty> curr_pred(predictionData.find((it)->first)->second.repeatPart, predictionData.find((it)->first)->second.fixedPart);

               value.first = (((double)(curr_pred.first-prev_pred.first))/((double)((it)->first - temp_it->first)));
               value.second = (((double)(curr_pred.second-prev_pred.second))/((double)((it)->first - temp_it->first)));
               return std::pair<Ty,Ty>( prev_pred.first - ((temp_it->first-size) * value.first), prev_pred.second - ((temp_it->first-size) * value.second));
            }
            else
            {
               std::pair<Ty, Ty> prev_pred(predictionData.find(prev_size)->second.repeatPart, predictionData.find(prev_size)->second.fixedPart);
               std::pair<Ty, Ty> curr_pred(predictionData.find(it->first)->second.repeatPart, predictionData.find(it->first)->second.fixedPart);
               value.first = (((double)(curr_pred.first-prev_pred.first))/((double)(it->first - prev_size)));
               value.second = (((double)(curr_pred.second-prev_pred.second))/((double)(it->first - prev_size)));
               return std::pair<Ty,Ty>( prev_pred.first + ((size-prev_size) * value.first), prev_pred.second + ((size-prev_size) * value.second));

//      double prev_pred= predictionData.at(prev_size)->second.getPrediction(repetition);
//      double curr_pred= predictionData.at(it->first)->second.getPrediction(repetition);
//
//      value= (((double)(curr_pred-prev_pred))/((double)(it->first-prev_size)));
//      return (( (size-prev_size) * value) + prev_pred);
            }

         }
         prev_size=it->first;
      }
      // if greater than even the last item
      it--;
      typename std::map< Tx, TuneParams<Ty> >::iterator temp_it= it;  // no operator + overload in iterator so need to do this agly stuff
      it--;

      std::pair<Ty, Ty> prev_pred(predictionData.find((it)->first)->second.repeatPart, predictionData.find((it)->first)->second.fixedPart);
      std::pair<Ty, Ty> curr_pred(predictionData.find(temp_it->first)->second.repeatPart, predictionData.find(temp_it->first)->second.fixedPart);
      value.first = (((double)(curr_pred.first-prev_pred.first))/((double)(temp_it->first - (it)->first)));
      value.second = (((double)(curr_pred.second-prev_pred.second))/((double)(temp_it->first - (it)->first)));
      return std::pair<Ty,Ty>( curr_pred.first + ((size-it->first) * value.first), curr_pred.second + ((size-prev_size) * value.second));

//       double prev_pred= predictionData.at((it-1)->first)->second.getPrediction(repetition);
//       double curr_pred= predictionData.at(it->first)->second.getPrediction(repetition);
//
//       value= (((double)(curr_pred-prev_pred))/((double)(it->first - (it-1)->first)));
//       return (( (size - it->first) * value) + curr_pred);
   }

   return std::pair<Ty,Ty>( (predictionData.find(size)->second.repeatPart), (predictionData.find(size)->second.fixedPart) );
}


template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::clear()
{
   predictionData.clear();
}



template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::writeDataToFile(const std::string& filename, int repeatition, DataExportFormat format)
{
   std::string _filename;

   if(filename.empty())
   {
      _filename = dataSetName + ".dat";
   }
   else
   {
      _filename = filename;
   }

   //Call right exporter
   if(format == GNUPLOT)
   {
      writeGnuPlotFile(_filename, repeatition);
   }
   else if(format == PREDICTION_FILE)
   {
      savePrediction(_filename);
   }
}

template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::writeGnuPlotFile(const std::string& filename,int repeatition)
{
   std::ofstream file(filename.c_str());
   int tabLength = axisNames.first.length()+20;
   file<<std::left;
   file<<std::fixed <<std::setprecision(5);
   if(file.is_open())
   {
      //First add name and axis names as comments
      file<<"# " <<dataSetName <<"\n";
      file<<"# " <<std::setw(tabLength) <<axisNames.first <<std::setw(tabLength) <<axisNames.second <<"_"<<repeatition<<"\n";

      //Add data in two columns
      for(typename std::map< Tx, TuneParams<Ty> >::iterator it = predictionData.begin(); it != predictionData.end(); ++it)
      {
         TuneParams<Ty> params= it->second;

         if(params.backendParams.backend==CPU_BACKEND)
            file<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) <<params.getPrediction(repeatition)<<std::setw(20)<< convertBackendToStr(params.backendParams.backend) <<"\n";

         else if(params.backendParams.backend==OMP_BACKEND)
            file<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) <<params.getPrediction(repeatition)<<std::setw(20)<< convertBackendToStr(params.backendParams.backend) <<std::setw(10)<< params.backendParams.numOmpThreads<<"\n";
         else
            file<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) <<params.getPrediction(repeatition)<<std::setw(20)<< convertBackendToStr(params.backendParams.backend) <<std::setw(10)<< params.backendParams.maxBlocks<< std::setw(10)<<params.backendParams.maxThreads <<"\n";
      }

      file.close();
   }
}




template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::savePrediction(const std::string& filename)
{
   std::ofstream file(filename.c_str());
   file<<std::left;
   file<<std::fixed <<std::setprecision(5);
   if(file.is_open())
   {
      //Add data in two columns
      for(typename std::map< Tx, TuneParams<Ty> >::iterator it = predictionData.begin(); it != predictionData.end(); ++it)
      {
         TuneParams<Ty> params= it->second;

         if(params.backendParams.backend==CPU_BACKEND)
            file<<it->first <<" " <<params.repeatPart << " " << params.fixedPart << " "<<" "<< convertBackendToStr(params.backendParams.backend) <<"\n";

         else if(params.backendParams.backend==OMP_BACKEND)
            file<<it->first <<" " <<params.repeatPart << " " << params.fixedPart << " "<<" "<< convertBackendToStr(params.backendParams.backend) <<" "<< params.backendParams.numOmpThreads<<"\n";

         else
            file<<it->first <<" " <<params.repeatPart << " " << params.fixedPart << " "<< convertBackendToStr(params.backendParams.backend) <<" "<< params.backendParams.maxBlocks<< " "<<params.backendParams.maxThreads <<"\n";
      }

      file.close();
   }
}



template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::writeGnuPlotFileOMP(const std::string& filename,int threads)
{
   std::ofstream file(filename.c_str());
   int tabLength = axisNames.first.length()+20;
   file<<std::left;
   file<<std::fixed <<std::setprecision(5);
   if(file.is_open())
   {
      //First add name and axis names as comments
      file<<"# " <<dataSetName <<"\n";
      file<<"# " <<std::setw(tabLength) <<axisNames.first <<std::setw(tabLength) <<axisNames.second <<"_"<<threads<<"\n";

      //Add data in two columns
      for(typename std::map< Tx, TuneParams<Ty> >::iterator it = predictionData.begin(); it != predictionData.end(); ++it)
      {
         TuneParams<Ty> params= it->second;
         if(params.backendParams.backend==OMP_BACKEND)
            file<<"  " <<std::setw(tabLength) <<it->first <<std::setw(tabLength) <<(params.repeatPart/threads + params.fixedPart.second*threads)<<std::setw(20)<< convertBackendToStr(params.backendParams.backend) <<std::setw(10)<< params.backendParams.numproc_omp<<"\n";
      }

      file.close();
   }
}


template <typename Tx, typename Ty>
void TuneData<Tx, Ty>::loadPrediction(const std::string& filename, int repetition)
{

   std::ifstream file(filename.c_str());
   file>>std::fixed >>std::setprecision(5);

   std::string s;
//    char ch;
   Tx vecSize, gs, bs, num_omp;
   Ty fixPart, repPart;

   if(file.is_open())
   {
//      predictionData.clear();

      while (std::getline( file, s ))
      {
         std::istringstream ss(s);

         std::string        backend;
         //bool               final = true;


         ss>>vecSize>>repPart>>fixPart>>backend;//>>gs>>bs;

         BackEnd be= convertStrToBackend(backend);
         TuneParams<Ty> tp(repPart, fixPart, be);

         if(be==skepu::OMP_BACKEND)
         {
            ss>>num_omp;
            tp.backendParams.numOmpThreads=num_omp;
         }
         else if(be!=skepu::CPU_BACKEND)  // if not CPU
         {
            ss>>gs>>bs;  // no char for int
            tp.backendParams.maxBlocks=gs;
            tp.backendParams.maxThreads=bs;
         }
         //ss>>vecSize>>ch>>fixPart>>ch>>gs>>bs;
         //predictionData.insert(std::make_pair(vecSize, tp));
         addData(vecSize, tp, repetition);

      }
      file.close();
   }
}


} // end namespace

#endif