helper_methods.h

Go to the documentation of this file.

#ifndef _HELPER_METHODS_H
#define _HELPER_METHODS_H

#include <string>
#include <algorithm>
#include <fstream>
#include <sstream>

namespace skepu {

const std::string trimSpaces(const std::string& pString, const std::string& pWhitespace = " \t")
{
    const size_t beginStr = pString.find_first_not_of(pWhitespace);
    if (beginStr == std::string::npos)
    {
        // no content
        return "";
    }

    const size_t endStr = pString.find_last_not_of(pWhitespace);
    const size_t range = endStr - beginStr + 1;

    return pString.substr(beginStr, range);
}

template <class T> const T& max ( const T& a, const T& b ) {
  return (b<a)?a:b;     // or: return comp(b,a)?a:b; for the comp version
}


template <typename T>
inline T get_random_number(T min, T max)
{
    return (T)( rand() % (int)(max-min+1) + min); //(T)( rand() % (int)max + min );
}


std::string read_file_into_string(const std::string &filename)
{
    std::string content = "";
    std::ifstream ifs(filename.c_str());
    if(ifs.is_open())
    {
      content.assign( (std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()) );
    }
    return content;
}

void toLowerCase(std::string &str)
{
    std::transform(str.begin(), str.end(),str.begin(), ::tolower);
}

void toUpperCase(std::string &str)
{
    std::transform(str.begin(), str.end(),str.begin(), ::toupper);
}


bool startsWith(const std::string& main, const std::string& prefix)
{
    return (main.substr(0, prefix.size()) == prefix);
}


template <typename T>
T* allocateHostMemory(unsigned int n) 
{
    T* p=0;
    
    #if defined(SKEPU_CUDA) && defined(USE_PINNED_MEMORY)
        cudaError_t err;
        DEBUG_TEXT_LEVEL1("Pinned memory allocation ******\n")
//      err = cudaMallocHost((void **)&p, n * sizeof(T));   // Works before CUDA 4.0
        err = cudaHostAlloc((void **)&p, n * sizeof(T), cudaHostAllocPortable); // For CUDA 4.0
//      err = cudaHostAlloc((void **)&p, n * sizeof(T)); // For CUDA 4.0
    
    if(err)
    {
        std::cerr<<"*** Error Malloc: "<< cudaGetErrorString(err)<<"\n";    
        throw std::bad_alloc();
    }
   #else
        p = new T[n];
   #endif
   
   if (!p)
   {
        std::cerr<<"*** Error Malloc **************\n";
        throw std::bad_alloc();
   }
   return p;
}


template <typename T>
void deallocateHostMemory(T *p) 
{
    #if defined(SKEPU_CUDA) && defined(USE_PINNED_MEMORY)
    
    cudaError_t err;
    err = cudaFreeHost(p);
    if(err)
    {
        std::cerr<<"*** Error De-Alloc: "<< cudaGetErrorString(err) <<"\n"; 
        throw std::bad_alloc();
    }
    else
    {
        DEBUG_TEXT_LEVEL1("Pinned memory de-allocation Successful ******\n")
    }
    
    #else
        if(p) delete[] p;
    #endif
}


}


#endif