clfProgram.cpp

/* 
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003, 2004    (see file CONTACTS for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Base/Common/BIASpragma.hh>
#include <Base/Common/FileHandling.hh>
#include <OpenCLFramework/clfProgram.hh>
#include <OpenCLFramework/clfException.hh>
#include <fstream>
#include <iostream>
#include <Base/Debug/Error.hh>
#include <bias_config.h>

using namespace BIAS;
using namespace std;

clfKernelSources clfProgram::kernelsourcesdb_;
std::vector<std::string> clfProgram::additionalsourcedirs_;

clfProgram::clfProgram(cl::Context *context, std::vector<cl::Device> *devices) {
  context_ = context;
  devices_ = devices;
  sources_.clear();
  addWriteMultiplier_ = false;

  size_t testHeight;
  string name;
  (*devices_)[0].getInfo( (cl_device_info)CL_DEVICE_IMAGE2D_MAX_HEIGHT, &testHeight);
  (*devices_)[0].getInfo( (cl_device_info)CL_DEVICE_NAME, &name);
  if (testHeight == 16383) {
    if (name == "GeForce GTX 285") {
      BIASWARNONCE("you seem to have a gfx card with _image_write_coordinate_ bug (fkellner)");
      addWriteMultiplier_ = true;
    }
  }
}

clfProgram::~clfProgram() {
  for (unsigned i=0;i<sources_.size();i++) {
    delete[] sources_[i].first;
  }
}

std::string clfProgram::AddSource(string filename) {
  string sourcedb = kernelsourcesdb_.GetSource(filename);
  if (sourcedb.length()>0) {
    AddSourceFromString(sourcedb);
  } else {
    if (!BIAS::FileHandling::FileExists(filename)) {
      if (BIAS::FileHandling::FileExists(BIAS_SOURCE_DIR+filename)) {
        filename = BIAS_SOURCE_DIR+filename;
      } else {
        bool found = false;
        additionalsourcedirs_.push_back("D:\\DeCS\\decs-src\\KEMScan");
        for (unsigned int i=0;i<additionalsourcedirs_.size();i++) {
          if (BIAS::FileHandling::FileExists(additionalsourcedirs_[i]+filename)) {
            filename = additionalsourcedirs_[i]+filename;
            found = true;
            break;
          }
        }
        if (!found) {
          std::string err =  "source file could not be found: "+filename;
          THROW_CL_EXCEPTION(cl::Error(-100, err.c_str()));
        }
      }
    }
    ifstream sourceFile(filename.c_str());
    string sourceCode(istreambuf_iterator<char>(sourceFile), (istreambuf_iterator<char>()));
    if (sourceCode.length() == 0) {
      std::string err =  "source length = 0 for file "+filename;
      THROW_CL_EXCEPTION(cl::Error(-100, err.c_str()));
    }
    sourcedb = sourceCode;
    AddSourceFromString(sourceCode);
  }
  return sourcedb;
}

void clfProgram::AddSourceFromString(string sourceCode) {
  if (sourceCode.length() == 0){
    std::string err =  "source length = 0 for source "+sourceCode;
    THROW_CL_EXCEPTION(cl::Error(-100, err.c_str()));
  }
  if (addWriteMultiplier_) {
      sourceCode = "#define XM 2\n"+sourceCode;
  } else {
      sourceCode = "#define XM 1\n"+sourceCode;
  }
  char *code = new char[sourceCode.length()];
  memcpy(code, sourceCode.c_str(), sourceCode.length());
  sources_.push_back(make_pair(code, sourceCode.length()));
}

void clfProgram::Build(int deviceNr, std::string options) {
  program_ = cl::Program(*context_, sources_);
  cl_int error;
  try {
    if (options.length() == 0) {
      error = program_.build(*devices_);
    } else {
      error = program_.build(*devices_, options.c_str());
    }
  } catch (cl::Error &err) {
    string log="";
    cl_build_status bs = program_.getBuildInfo<CL_PROGRAM_BUILD_STATUS> (
        (*devices_)[deviceNr]);
    log+="Build status:\t";
    switch (bs) {
      case CL_BUILD_NONE:
        log+="None\n";
        break;
      case CL_BUILD_ERROR:
        log+="Build error\n";
        break;
      case CL_BUILD_SUCCESS:
        log+="Success\n";
        break;
      case CL_BUILD_IN_PROGRESS:
        log+="Build in progress\n";
        break;
      default:
        log+="ERROR\n";
        break;
    }

    log+="Build log:\t";
    log+= program_.getBuildInfo<CL_PROGRAM_BUILD_LOG>((*devices_)[deviceNr])+"\n";
    THROW_CL_EXCEPTION(cl::Error(-100, log.c_str()));
  }
}

std::string clfProgram::GetBuildLog(int deviceNr) {
  return program_.getBuildInfo<CL_PROGRAM_BUILD_LOG>((*devices_)[deviceNr]);
}


void clfProgram::AddKernel(string kernelname) {
  try {
    if (kernels_.find(kernelname) != kernels_.end()) {
      // already added
      return;
    }
    kernels_.insert(make_pair(kernelname, cl::Kernel(program_, kernelname.c_str() )));
  } catch (cl::Error &err) {
    cout<<"Kernelname:"<<kernelname<<endl;
    THROW_CL_EXCEPTION(err);
  }
}

void clfProgram::AddKernels(vector<string> kernelnames) {
  for (unsigned int i=0;i<kernelnames.size();i++) {
    AddKernel(kernelnames[i]);
  }
}

void clfProgram::KernelSetArgument(string kernelname, unsigned int argnumber, clfBuffer &buffer) {
  try {
    kernels_[ kernelname ].setArg( argnumber, buffer.buffer() );
  } catch (cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
}

void clfProgram::KernelSetArgument(string kernelname, unsigned int argnumber, clfImage2D &buffer) {
  try {
    kernels_[ kernelname ].setArg( argnumber, buffer.image() );
  } catch (cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
}

#define CLFIMPL_CL_TYPE(type) \
void clfProgram::KernelSetArgument(std::string kernelname, unsigned int argnumber, type arg) { \
  try { \
    kernels_[ kernelname ].setArg( argnumber, arg ); \
  } catch (cl::Error &err) { \
    THROW_CL_EXCEPTION(err); \
  } \
}

CLFIMPL_CL_TYPE(cl_float2)
CLFIMPL_CL_TYPE(cl_float4)
CLFIMPL_CL_TYPE(cl_float8)
CLFIMPL_CL_TYPE(cl_float16)

CLFIMPL_CL_TYPE(cl_int2)
CLFIMPL_CL_TYPE(cl_int4)
CLFIMPL_CL_TYPE(cl_int8)
CLFIMPL_CL_TYPE(cl_int16)

CLFIMPL_CL_TYPE(cl_uint2)
CLFIMPL_CL_TYPE(cl_uint4)
CLFIMPL_CL_TYPE(cl_uint8)
CLFIMPL_CL_TYPE(cl_uint16)

void clfProgram::KernelSetArgument(std::string kernelname, unsigned int argnumber, int arg) {
  try {
    kernels_[ kernelname ].setArg( argnumber, arg );
  } catch (cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
}

void clfProgram::KernelSetArgument(std::string kernelname, unsigned int argnumber, float arg) {
  try {
    kernels_[ kernelname ].setArg( argnumber, arg );
  } catch (cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
}

void clfProgram::
KernelSetArgument(std::string kernelname, unsigned int argnumber, float* arg)
{
  try {
    kernels_[ kernelname ].setArg( argnumber, arg );
  } catch (cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
}

void clfProgram::
KernelSetLocalArgument(std::string kernelname, unsigned int argnumber, int size) {
  try {
    kernels_[ kernelname ].setArg( argnumber, size, NULL );
  } catch (cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
}


cl::Kernel& clfProgram::operator()(string kernelname) {
  if (kernels_.find(kernelname) == kernels_.end()) {
    string err = "can not find kernel of name "+kernelname;
    THROW_CL_EXCEPTION(cl::Error(-100, err.c_str()));
  }
  return kernels_[ kernelname ];  
}