[Polly] Added OpenCL Runtime to GPURuntime Library for GPGPU CodeGen

[PhilippSchaad]

Summary

When compiling for GPU, one can now choose to compile for OpenCL or CUDA,
with the corresponding polly-gpu-runtime flag (libopencl / libcudart). The
GPURuntime library (GPUJIT) has been extended with the OpenCL Runtime library
for that purpose, correctly choosing the corresponding library calls to the
option chosen when compiling (via different initialization calls).

Additionally, a specific GPU Target architecture can now be chosen with -polly-gpu-arch (only nvptx64 implemented thus far).

[PhilippSchaad]

• Replaced magic numbers, added assertions and fixed if-braces.

[Meinersbur]

I wrote a runtime with similar scope here: https://github.com/Meinersbur/prl . We were one discussing to use it for Polly as well. What's the status of that?

lib/CodeGen/PPCGCodeGeneration.cpp

56–58

Did you consider an enum?

1695

Is there some vendor-neutral triple?

1804

Why a static flag?

2680–2698

Did you consider

Pass *polly::createPPCGCodeGenerationPass(int Runtime);

?

lib/Support/RegisterPasses.cpp

329–349

A switch instead?

[PhilippSchaad]

In D32431#736600, @Meinersbur wrote:

I wrote a runtime with similar scope here: https://github.com/Meinersbur/prl . We were one discussing to use it for Polly as well. What's the status of that?

I have looked into it a tiny little bit about a month ago, but had then decided to write a basic OpenCL Runtime from scratch in GPUJIT. So to my knowledge, nothing has changed on that status yet.

Currently looking into the rest of your comment-mentioned points.

lib/CodeGen/PPCGCodeGeneration.cpp

1695

Do you mean like nvptx64-nvcl / nvptx64-cuda?

[PhilippSchaad]

lib/CodeGen/PPCGCodeGeneration.cpp

2680–2698

That seems reasonable, but I get a template-conflict for the LLVM Pass-Creation template when trying to change the pass-creation-method structure. I thought it might be easier this way?

[PhilippSchaad]

lib/CodeGen/PPCGCodeGeneration.cpp

2680–2698

Correction: looking at wrong function of course, you mean a different one :-)

[PhilippSchaad]

• Stylistic changes and switch to -polly-gpu-runtime=cuda/opencl compiler flag

[PhilippSchaad]

• Removed left over commented out macros

[Meinersbur]

lib/CodeGen/PPCGCodeGeneration.cpp

58–60

See http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly for LLVM's coding policy for enum members.

Nitpick: A "T" suffix is rather unusual.

162

Nitpick: No need to use an enum qualifier.

1695

I hoped that there might be some kind of triple that works for OpenCL in general, not only for nvidia (nvptx, nvcl). If the generated program only works for devices that support cuda anyway, I don't see where the benefit of such a backend is.

If there is indeed no backend that also works on non-nvidia devices, should we call the the runtime accordingly, e.g. "nvcl" then?

lib/Support/RegisterPasses.cpp

329–349

Now that createPPCGCodeGenerationPass takes an argument, you don't need a switch anymore.

tools/GPURuntime/GPUJIT.c

308–316

Consistent variable name style? What style do you intend to use in this file?

352–353

Replace the magic number 256 by sizeof(DeviceRevision)?

[etherzhhb]

include/polly/LinkAllPasses.h

51

is this Runtime supposed to be with type GPURuntimeT ? it is a little bit tricky here.
Maybe we need to introduce a PPCG header and define the runtime enum there, than include that runtime enum.

or we can declare the function as

llvm::Pass *createPPCGCodeGenerationPass(int Runtime = 0);

to at least avoid the magic number 0 in line 86.

lib/CodeGen/PPCGCodeGeneration.cpp

1695

for opencl, it can be "spir-unknown-unknown" or "spir64-unknown-unknown", but that may not work :)

[PhilippSchaad]

Looking into the rest of your comments.

include/polly/LinkAllPasses.h

51

Yes, it would be. The reason it's not is exactly the one you mentioned. I was considering adding a PPCG header, but refrained from it because I was hesitant about creating a header 'just for one enum'. If you agree that this is a good solution, I will indeed introduce a new header for PPCG and define the enum there, to get rid of magic numbers. The second option seems reasonable too though.

lib/CodeGen/PPCGCodeGeneration.cpp

1695

Looking into it. The next goal would be to add the AMDGPU backend to generate AMD ISA, which would then again utilize the same OpenCL Runtime implemented here. (I realize there will have to be some naming changes to make that clear in the GPUJIT, but as you pointed out, I have a naming-mess to fix there anyway.

[etherzhhb]

include/polly/LinkAllPasses.h

51

we could start from the second option if you think it is reasonable

[PhilippSchaad]

• Addressed consistency and naming concerns

[PhilippSchaad]

• Made CUDA Runtime default, fixed formatting, adapted test case

[grosser]

Hi Philip and others,

this already looks very cool. I also added some minor comments.

Best,
Tobias

lib/CodeGen/PPCGCodeGeneration.cpp

56–58

You can use C++11 enums ala

enum class GPURuntime { CUDA, OpenCL };

1695

Making OpenCL work for CUDA is just the first step. I expect that when adding AMDGPU support, we will use here different triples depending on which vendor to target. AMD will have a specific one, CUDA will have a specific one, and for Intel we likely use the generic SPIR-V comment. I assume this could then also work for Xilinx.

[PhilippSchaad]

• Fixed enum style to C++11

[Meinersbur]

lib/CodeGen/PPCGCodeGeneration.cpp

1695

At compile time, we don't know on which hardware it will run on, so we cannot specify a triple here.

Unless you think of a runtime dispatch system, then you need to generate all kernels at once. In that case, I still would like to select a single target only for when I know I will run only on that hardware and to keep the executable small.

[PhilippSchaad]

lib/CodeGen/PPCGCodeGeneration.cpp

1695

I thought the goal was to let the user compile for a specific target, i.e. providing something like -polly-gpu-arch=amd/nvidia/intel, and then choosing the correct target triple according to said selection. Meaning for example -polly-gpu-arch=amd would utilize the AMDGPU backend triple and feed that into the OpenCL runtime.

Am I misunderstanding something?

[Meinersbur]

lib/CodeGen/PPCGCodeGeneration.cpp

1695

I think we were miscommunicating. The -polly-gpu-arch switch is new to me and doesn't appear in this patch. I assumed a fat executable when you mentioned an AMD backend.

OpenCL claims to be hardware-independent with platform's driver translating OpenCL-C or SPIR(-V) to its proprietary format. In NVidia's terminology, CUDA is a platform of which CUDA C++, their OpenCL implementation, cudart (CUDA runtime) etc. are part of. We are still vendor-locked to CUDA, since it only works with CUDA's OpenCL runtime library. -polly-gpu-runtime=opencl therefore is misleading (at least it was to me), it it no alternative to CUDA.

It might resolve if it is indeed just the runtime library GPUJIT is linked to. If so, could you make it more clear? I suggest the following switches:

-polly-target=cpu/gpu

if -polly-target=gpu then
-polly-gpu-arch=nvptx64/hsa/spir/spir-v/opencl-c
(with -polly-gpu-arch=nvptx64 the only one implemented so far)

if -polly-gpu-arch=nvptx64 then there is a choice between
-polly-cuda-runtime=libcudart/libopencl

[PhilippSchaad]

• GPURuntime works on systems with just one of CUDA/OpenCL now.

[PhilippSchaad]

lib/CodeGen/PPCGCodeGeneration.cpp

1695

This change should address exactly this. The framework is now set to introduce new architectures and utilize eg. the AMDGPU backend instead of NVPTX etc.

[singam-sanjay]

lib/CodeGen/PPCGCodeGeneration.cpp

1729

Does nvptx64-nvidia-nvcl mean OpenCL code meant to be run on NVIDIA GPUs ?

[PhilippSchaad]

lib/CodeGen/PPCGCodeGeneration.cpp

1729

Yes, exactly. It generates a slightly different flavor of PTX, which can be used by OpenCL to generate a kernel from the PTX binary (on NVIDIA GPUs). If you were to use the standard CUDA PTX, OpenCL would complain because of wrong argument accesses.

[singam-sanjay]

lib/CodeGen/PPCGCodeGeneration.cpp

1729

Okay. From what you're saying, nvptx64-nvidia-nvcl indicates that backend must generate NVPTX code for a 64bit architecture for an NVIDIA GPU controlled by a OpenCL driver. Please correct me if I'm wrong.

[PhilippSchaad]

lib/CodeGen/PPCGCodeGeneration.cpp

1729

That is correct.

[singam-sanjay]

lib/CodeGen/PPCGCodeGeneration.cpp

1729

Thank you ! That was helpful.

[PhilippSchaad]

• Integrated D32226 - Managed memory support

[PhilippSchaad]

@grosser @Meinersbur ping

[PhilippSchaad]

• Fixed formatting and managed-memory test case (including pre-existing bug)

[Meinersbur]

I only consider the clSetKernelArg as a remaining bigger issue. Having only "polly_"-prefixed function non-static would also be great.

Tobias is the sole author of Polly-ACC. I think he should give the final LGTM.

include/polly/LinkAllPasses.h

51

I assume you kept the arguments of type int to not include header files here.

lib/CodeGen/PPCGCodeGeneration.cpp

769–772

Can you make this a switch so you get warned by the compiler when adding more runtimes?

1726–1729

Could also be a switch.

2689

We should check whether the arguments are valid. Such as:

switch (Runtime) {
case 1:
case 2:
  ...
default:
  llvm_unreachable("Invalid argument for Runtime");
}

2691–2695

Similarly:

switch (Arch) {
case 1:
  ...
default:
  llvm_unreachable("Invalid argument for Arch");
}

lib/Support/RegisterPasses.cpp

331–349

int Arch;
switch (GPUArch) {
case GPU_ARCH_NVPTX64;
  Arch = 1;
  break;
}

int Runtime;
switch (GPURuntime) {
case GPU_RUNTIME_CUDA:
  Runtime = 1;
  break;
case GPU_RUNTIME_OPENCL:
  Runtime = 2;
  breal
}

PM.add(polly::createPPCGCodeGenerationPass(Arch, Runtime))

With "you don't need a switch anymore", I was thinking about the like of:

PM.add(polly::createPPCGCodeGenerationPass(1, GPURuntime + 1));

Your choice.

It could be helpful to have createPPCGCodeGenerationPass accept the GPURuntime enum as arguments instead.

In your solution, I don't see the use of static const int local variables. If you want identifiers that give names to the accepted arguments, declare them as #define or static const int in the header file that also declares createPPCGCodeGenerationPass, so these can be used in the implementation of createPPCGCodeGenerationPass as well.

tools/GPURuntime/GPUJIT.c

397–401

Did you consider introducing a new function this sequence of code? It appears quite often.

610–618

Trying each argument size after the other and hoping one matches is not good. The caller must know the argument sizes. You probably have to pass the sizes in another argument to launchKernelCL that contains those sizes for each argument, generated by Polly.

Without this, the code will fail if you pass a struct (or vector) of size other than 8, 4, 2, or 1.

676

Shouldn't these print to stderr?

750

The function name does not follow the naming of other functions in this file. In C it is common have the public API functions prefixed with the library name (here: "polly") and everything else static. Don't choose the prefix of another library (here: "cl_"). This avoids symbol conflicts because multiple libraries happen to give the same name for a function.

[PhilippSchaad]

include/polly/LinkAllPasses.h

51

That is correct, yes.

lib/Support/RegisterPasses.cpp

331–349

With "you don't need a switch anymore", I was thinking about the like of:

PM.add(polly::createPPCGCodeGenerationPass(1, GPURuntime + 1));

Your choice.

Personally, I think the current solution is tiny little bit more 'documenting'. Both is fine though, good call.

It could be helpful to have createPPCGCodeGenerationPass accept the GPURuntime enum as arguments instead.

That is true, would mean having to provide a header with that GPURuntime enum instead though, right?

In your solution, I don't see the use of static const int local variables. If you want identifiers that give names to the accepted arguments, declare them as #define or static const int in the header file that also declares createPPCGCodeGenerationPass, so these can be used in the implementation of createPPCGCodeGenerationPass as well.

Would it maybe make sense to introduce a PPCGCodeGeneration header at this point?

tools/GPURuntime/GPUJIT.c

610–618

Yes, this is a priority issue still. The issue will have to be resolved at some point. This is basically a temporary way around some (probably) major argument handling changes in PPCG etc.

[PhilippSchaad]

• Addressed multiple issues pointed out in comment

[PhilippSchaad]

• Fixed formatting

[Meinersbur]

You changed stdout to stderr everywhere, which is better in my point of view, but logically is a different change. Sorry that I didn't realize that the libcudart also printed to stdout before so you tried to be consistent. Could you commit that change separately beforehand? (Maybe also the change in argument name capitalization)

I am accepting the patch proved that you are going to improve the clSetKernelArg situation later and add a TODO into the code about it. The other stuff is of stylistic nature only.

Please also wait for Tobias' approval.

lib/Support/RegisterPasses.cpp

331–349

Please remove at least the static keyword. It makes sense for global constants, but not for function-local ones.

The style

static const int ArgumentName = 0;
func(ArgumentName);

rather unusual in LLVM-style code (but not bad if applied consistenly, which is unfortunately not the case in Polly). I've seen

func(/* ArgumentName = */ 0);

much more often.

In this case I think UseOpenCLRuntime, UseCUDARuntime and TargetNVPTX64 should really be global constants declated close to the declaration of createPPCGCodeGenerationPass so it can be used by ever caller of that function.

Would it maybe make sense to introduce a PPCGCodeGeneration header at this point?

Yes, that sounds good to me as well.

tools/GPURuntime/GPUJIT.c

606–607

Thanks for the introduction of checkOpenCLError. You could also introduce one for these two lines. for instance:

if (!GlobalContext)
  handleError("GPGPU-code generation not correctly initialized.\n");

handleError could also be called by checkOpenCLError. It helps centralising the error handling, such that if we change some detail about it (e.g. the return code on exit, or some cleanup code), there is a single function for that.

610–618

Also note that I am not sure that OpenCL ICD's are required to check for correct CL_INVALID_ARG_SIZE. It might just trust the caller, or be a badly written one.

1033–1039

These are unrelated changes Tobias usually complains about. I personally don't care.

1173

Unrelated whitespace change?

[PhilippSchaad]

Addressed most of your concerns. @grosser it should be ready now, what do you think?

[PhilippSchaad]

• Introduced PPCGCodeGeneration header file for simplicity

[PhilippSchaad]

@Meinersbur the unrelated changes you mentioned have been added/moved to D32852 and D32854.

[grosser]

test/GPGPU/cuda-managed-memory-simple.ll

49 ↗

(On Diff #97804)

This change is unrelated.

[PhilippSchaad]

test/GPGPU/cuda-managed-memory-simple.ll

49 ↗

(On Diff #97804)

It is, but it got fixed in the meantime anyway. Removing it.

[PhilippSchaad]

Reopened for rebase

[PhilippSchaad]

Rebase

CMakeLists.txt

 
 # Add path for custom modules
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${POLLY_SOURCE_DIR}/cmake")
 
 SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
 option(POLLY_ENABLE_GPGPU_CODEGEN "Enable GPGPU code generation feature" OFF)
 if (POLLY_ENABLE_GPGPU_CODEGEN)
-  # Do not require CUDA, as GPU code generation test cases can be run without
-  # a cuda library.
+  # Do not require CUDA/OpenCL, as GPU code generation test cases can be run
+  # without a CUDA/OpenCL library.
   FIND_PACKAGE(CUDA)
+  FIND_PACKAGE(OpenCL)
   set(GPU_CODEGEN TRUE)
 else(POLLY_ENABLE_GPGPU_CODEGEN)
   set(GPU_CODEGEN FALSE)
 endif(POLLY_ENABLE_GPGPU_CODEGEN)
 
 
 # Support GPGPU code generation if the library is available.
 if (CUDALIB_FOUND)
+  add_definitions(-DHAS_LIBCUDART)
   INCLUDE_DIRECTORIES( ${CUDALIB_INCLUDE_DIR} )
 endif(CUDALIB_FOUND)
+if (OpenCL_FOUND)
+  add_definitions(-DHAS_LIBOPENCL)
+  INCLUDE_DIRECTORIES( ${OpenCL_INCLUDE_DIR} )
+endif(OpenCL_FOUND)
 
 option(POLLY_BUNDLED_ISL "Use the bundled version of libisl included in Polly" ON)
 if (NOT POLLY_BUNDLED_ISL)
   find_package(ISL MODULE REQUIRED)
   message(STATUS "Using external libisl ${ISL_VERSION} in: ${ISL_PREFIX}")
   set(ISL_TARGET ISL)
 else()
   set(ISL_INCLUDE_DIRS

include/polly/LinkAllPasses.h

 llvm::Pass *createPollyCanonicalizePass();
 llvm::Pass *createPolyhedralInfoPass();
 llvm::Pass *createScopDetectionPass();
 llvm::Pass *createScopInfoRegionPassPass();
 llvm::Pass *createScopInfoWrapperPassPass();
 llvm::Pass *createIslAstInfoPass();
 llvm::Pass *createCodeGenerationPass();
 #ifdef GPU_CODEGEN
-llvm::Pass *createPPCGCodeGenerationPass();
+llvm::Pass *createPPCGCodeGenerationPass(int Arch = 0, int Runtime = 0);
 #endif
 llvm::Pass *createIslScheduleOptimizerPass();
 llvm::Pass *createFlattenSchedulePass();
 llvm::Pass *createDeLICMPass();
 
 extern char &CodePreparationID;
 } // namespace polly
 

lib/CodeGen/PPCGCodeGeneration.cpp

 
 #include "llvm/Support/Debug.h"
 
 using namespace polly;
 using namespace llvm;
 
 #define DEBUG_TYPE "polly-codegen-ppcg"
 
+/// The GPU Architecture to target.
+enum GPUArch { NVPTX64 };
+
+/// The GPU Runtime implementation to use.
+enum GPURuntime { CUDA, OpenCL };
+
 static cl::opt<bool> DumpSchedule("polly-acc-dump-schedule",
                                   cl::desc("Dump the computed GPU Schedule"),
                                   cl::Hidden, cl::init(false), cl::ZeroOrMore,
                                   cl::cat(PollyCategory));
 
 static cl::opt<bool>
     DumpCode("polly-acc-dump-code",
              cl::desc("Dump C code describing the GPU mapping"), cl::Hidden,

 /// for generating GPU specific user nodes.
 ///
 /// @see GPUNodeBuilder::createUser
 class GPUNodeBuilder : public IslNodeBuilder {
 public:
   GPUNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator,
                  const DataLayout &DL, LoopInfo &LI, ScalarEvolution &SE,
                  DominatorTree &DT, Scop &S, BasicBlock *StartBlock,
-                 gpu_prog *Prog)
+                 gpu_prog *Prog, GPURuntime Runtime, GPUArch Arch)
       : IslNodeBuilder(Builder, Annotator, DL, LI, SE, DT, S, StartBlock),
-        Prog(Prog) {
+        Prog(Prog), Runtime(Runtime), Arch(Arch) {
     getExprBuilder().setIDToSAI(&IDToSAI);
   }
 
   /// Create after-run-time-check initialization code.
   void initializeAfterRTH();
 
   /// Finalize the generated scop.
   virtual void finalize();
private:
   /// A module containing GPU code.
   ///
   /// This pointer is only set in case we are currently generating GPU code.
   std::unique_ptr<Module> GPUModule;
 
   /// The GPU program we generate code for.
   gpu_prog *Prog;
 
+  /// The GPU Runtime implementation to use (OpenCL or CUDA).
+  GPURuntime Runtime;
+
+  /// The GPU Architecture to target.
+  GPUArch Arch;
+
   /// Class to free isl_ids.
   class IslIdDeleter {
   public:
     void operator()(__isl_take isl_id *Id) { isl_id_free(Id); };
   };
 
   /// A set containing all isl_ids allocated in a GPU kernel.
   ///
if (!F) {
     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), false);
     F = Function::Create(Ty, Linkage, Name, M);
   }
 
   Builder.CreateCall(F);
 }
 
 Value *GPUNodeBuilder::createCallInitContext() {
-  const char *Name = "polly_initContext";
+  const char *Name;
+
+  if (Runtime == GPURuntime::CUDA)
+    Name = "polly_initContextCUDA";
+  else if (Runtime == GPURuntime::OpenCL)
+    Name = "polly_initContextCL";
+
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
 
   // If F is not available, declare it.
   if (!F) {
     GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
     std::vector<Type *> Args;
     FunctionType *Ty = FunctionType::get(Builder.getInt8PtrTy(), Args, false);
void GPUNodeBuilder::createScopStmt(isl_ast_expr *Expr,
   if (Stmt->isBlockStmt())
     BlockGen.copyStmt(*Stmt, LTS, Indexes);
   else
     RegionGen.copyStmt(*Stmt, LTS, Indexes);
 }
 
 void GPUNodeBuilder::createKernelSync() {
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
-  auto *Sync = Intrinsic::getDeclaration(M, Intrinsic::nvvm_barrier0);
+
+  Function *Sync;
+
+  switch (Arch) {
+  case GPUArch::NVPTX64:
+    Sync = Intrinsic::getDeclaration(M, Intrinsic::nvvm_barrier0);
+    break;
+  }
+
   Builder.CreateCall(Sync, {});
 }
 
 /// Collect llvm::Values referenced from @p Node
 ///
 /// This function only applies to isl_ast_nodes that are user_nodes referring
 /// to a ScopStmt. All other node types are ignore.
 ///
GPUNodeBuilder::createKernelFunctionDecl(ppcg_kernel *Kernel,
   }
 
   for (auto *V : SubtreeValues)
     Args.push_back(V->getType());
 
   auto *FT = FunctionType::get(Builder.getVoidTy(), Args, false);
   auto *FN = Function::Create(FT, Function::ExternalLinkage, Identifier,
                               GPUModule.get());
+
+  switch (Arch) {
+  case GPUArch::NVPTX64:
     FN->setCallingConv(CallingConv::PTX_Kernel);
+    break;
+  }
 
   auto Arg = FN->arg_begin();
   for (long i = 0; i < Kernel->n_array; i++) {
     if (!ppcg_kernel_requires_array_argument(Kernel, i))
       continue;
 
     Arg->setName(Kernel->array[i].array->name);
 
for (auto *V : SubtreeValues) {
     ValueMap[V] = &*Arg;
     Arg++;
   }
 
   return FN;
 }
 
 void GPUNodeBuilder::insertKernelIntrinsics(ppcg_kernel *Kernel) {
-  Intrinsic::ID IntrinsicsBID[] = {Intrinsic::nvvm_read_ptx_sreg_ctaid_x,
-                                   Intrinsic::nvvm_read_ptx_sreg_ctaid_y};
+  Intrinsic::ID IntrinsicsBID[2];
+  Intrinsic::ID IntrinsicsTID[3];
 
-  Intrinsic::ID IntrinsicsTID[] = {Intrinsic::nvvm_read_ptx_sreg_tid_x,
-                                   Intrinsic::nvvm_read_ptx_sreg_tid_y,
-                                   Intrinsic::nvvm_read_ptx_sreg_tid_z};
+  switch (Arch) {
+  case GPUArch::NVPTX64:
+    IntrinsicsBID[0] = Intrinsic::nvvm_read_ptx_sreg_ctaid_x;
+    IntrinsicsBID[1] = Intrinsic::nvvm_read_ptx_sreg_ctaid_y;
+
+    IntrinsicsTID[0] = Intrinsic::nvvm_read_ptx_sreg_tid_x;
+    IntrinsicsTID[1] = Intrinsic::nvvm_read_ptx_sreg_tid_y;
+    IntrinsicsTID[2] = Intrinsic::nvvm_read_ptx_sreg_tid_z;
+    break;
+  }
 
   auto addId = [this](__isl_take isl_id *Id, Intrinsic::ID Intr) mutable {
     std::string Name = isl_id_get_name(Id);
     Module *M = Builder.GetInsertBlock()->getParent()->getParent();
     Function *IntrinsicFn = Intrinsic::getDeclaration(M, Intr);
     Value *Val = Builder.CreateCall(IntrinsicFn, {});
     Val = Builder.CreateIntCast(Val, Builder.getInt64Ty(), false, Name);
     IDToValue[Id] = Val;
for (int i = 0; i < Kernel->n_var; ++i) {
     LocalArrays.push_back(Allocation);
     KernelIds.push_back(Id);
     IDToSAI[Id] = SAI;
   }
 }
 
 void GPUNodeBuilder::createKernelFunction(ppcg_kernel *Kernel,
                                           SetVector<Value *> &SubtreeValues) {
-
   std::string Identifier = "kernel_" + std::to_string(Kernel->id);
   GPUModule.reset(new Module(Identifier, Builder.getContext()));
+
+  switch (Arch) {
+  case GPUArch::NVPTX64:
+    if (Runtime == GPURuntime::CUDA)
       GPUModule->setTargetTriple(Triple::normalize("nvptx64-nvidia-cuda"));
+    else if (Runtime == GPURuntime::OpenCL)
+      GPUModule->setTargetTriple(Triple::normalize("nvptx64-nvidia-nvcl"));
     GPUModule->setDataLayout(computeNVPTXDataLayout(true /* is64Bit */));
+    break;
+  }
 
   Function *FN = createKernelFunctionDecl(Kernel, SubtreeValues);
 
   BasicBlock *PrevBlock = Builder.GetInsertBlock();
   auto EntryBlock = BasicBlock::Create(Builder.getContext(), "entry", FN);
 
   DT.addNewBlock(EntryBlock, PrevBlock);
 
   Builder.SetInsertPoint(EntryBlock);
   Builder.CreateRetVoid();
   Builder.SetInsertPoint(EntryBlock, EntryBlock->begin());
 
   ScopDetection::markFunctionAsInvalid(FN);
 
   prepareKernelArguments(Kernel, FN);
   createKernelVariables(Kernel, FN);
   insertKernelIntrinsics(Kernel);
 }
 
 std::string GPUNodeBuilder::createKernelASM() {
-  llvm::Triple GPUTriple(Triple::normalize("nvptx64-nvidia-cuda"));
+  llvm::Triple GPUTriple;
+
+  switch (Arch) {
+  case GPUArch::NVPTX64:
+    if (Runtime == GPURuntime::CUDA)
+      GPUTriple = llvm::Triple(Triple::normalize("nvptx64-nvidia-cuda"));
+    else if (Runtime == GPURuntime::OpenCL)
+      GPUTriple = llvm::Triple(Triple::normalize("nvptx64-nvidia-nvcl"));
+    break;
+  }
+
   std::string ErrMsg;
   auto GPUTarget = TargetRegistry::lookupTarget(GPUTriple.getTriple(), ErrMsg);
 
   if (!GPUTarget) {
     errs() << ErrMsg << "\n";
     return "";
   }
 
   TargetOptions Options;
   Options.UnsafeFPMath = FastMath;
-  std::unique_ptr<TargetMachine> TargetM(
-      GPUTarget->createTargetMachine(GPUTriple.getTriple(), CudaVersion, "",
-                                     Options, Optional<Reloc::Model>()));
+
+  std::string subtarget;
+
+  switch (Arch) {
+  case GPUArch::NVPTX64:
+    subtarget = CudaVersion;
+    break;
+  }
+
+  std::unique_ptr<TargetMachine> TargetM(GPUTarget->createTargetMachine(
+      GPUTriple.getTriple(), subtarget, "", Options, Optional<Reloc::Model>()));
 
   SmallString<0> ASMString;
   raw_svector_ostream ASMStream(ASMString);
   llvm::legacy::PassManager PM;
 
   PM.add(createTargetTransformInfoWrapperPass(TargetM->getTargetIRAnalysis()));
 
   if (TargetM->addPassesToEmitFile(
std::string GPUNodeBuilder::finalizeKernelFunction() {
 
   return Assembly;
 }
 
 namespace {
 class PPCGCodeGeneration : public ScopPass {
 public:
   static char ID;
 
+  GPURuntime Runtime = GPURuntime::CUDA;
+
+  GPUArch Architecture = GPUArch::NVPTX64;
+
   /// The scop that is currently processed.
   Scop *S;
 
   LoopInfo *LI;
   DominatorTree *DT;
   ScalarEvolution *SE;
   const DataLayout *DL;
   RegionInfo *RI;
void generateCode(__isl_take isl_ast_node *Root, gpu_prog *Prog) {
     // branch will guard the original scop from new induction variables that
     // the SCEVExpander may introduce while code generating the parameters and
     // which may introduce scalar dependences that prevent us from correctly
     // code generating this scop.
     BasicBlock *StartBlock =
         executeScopConditionally(*S, Builder.getTrue(), *DT, *RI, *LI);
 
     GPUNodeBuilder NodeBuilder(Builder, Annotator, *DL, *LI, *SE, *DT, *S,
-                               StartBlock, Prog);
+                               StartBlock, Prog, Runtime, Architecture);
 
     // TODO: Handle LICM
     auto SplitBlock = StartBlock->getSinglePredecessor();
     Builder.SetInsertPoint(SplitBlock->getTerminator());
     NodeBuilder.addParameters(S->getContext());
 
     isl_ast_build *Build = isl_ast_build_alloc(S->getIslCtx());
     isl_ast_expr *Condition = IslAst::buildRunCondition(S, Build);
void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addPreserved<RegionInfoPass>();
     AU.addPreserved<ScopInfoRegionPass>();
   }
 };
 } // namespace
 
 char PPCGCodeGeneration::ID = 1;
 
-Pass *polly::createPPCGCodeGenerationPass() { return new PPCGCodeGeneration(); }
+Pass *polly::createPPCGCodeGenerationPass(int Arch, int Runtime) {
+  PPCGCodeGeneration *generator = new PPCGCodeGeneration();
+  switch (Runtime) {
+  case 1:
+    generator->Runtime = GPURuntime::CUDA;
+    break;
+  case 2:
+    generator->Runtime = GPURuntime::OpenCL;
+    break;
+  }
+
+  switch (Arch) {
+  case 1:
+    generator->Architecture = GPUArch::NVPTX64;
+    break;
+  }
+  return generator;
+}
 
 INITIALIZE_PASS_BEGIN(PPCGCodeGeneration, "polly-codegen-ppcg",
                       "Polly - Apply PPCG translation to SCOP", false, false)
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScopDetection);
 INITIALIZE_PASS_END(PPCGCodeGeneration, "polly-codegen-ppcg",
                     "Polly - Apply PPCG translation to SCOP", false, false)

lib/Support/RegisterPasses.cpp

Target("polly-target", cl::desc("The hardware to target"),
            cl::values(clEnumValN(TARGET_CPU, "cpu", "generate CPU code")
 #ifdef GPU_CODEGEN
                           ,
                       clEnumValN(TARGET_GPU, "gpu", "generate GPU code")
 #endif
                           ),
            cl::init(TARGET_CPU), cl::ZeroOrMore, cl::cat(PollyCategory));
 
+#ifdef GPU_CODEGEN
+enum GPURuntimeChoice { GPU_RUNTIME_CUDA, GPU_RUNTIME_OPENCL };
+static cl::opt<GPURuntimeChoice>
+    GPURuntime("polly-gpu-runtime", cl::desc("The GPU Runtime API to target"),
+               cl::values(clEnumValN(GPU_RUNTIME_CUDA, "libcudart",
+                                     "use the CUDA Runtime API"),
+                          clEnumValN(GPU_RUNTIME_OPENCL, "libopencl",
+                                     "use the OpenCL Runtime API")),
+               cl::init(GPU_RUNTIME_CUDA), cl::ZeroOrMore,
+               cl::cat(PollyCategory));
+
+enum GPUArchChoice { GPU_ARCH_NVPTX64 };
+static cl::opt<GPUArchChoice>
+    GPUArch("polly-gpu-arch", cl::desc("The GPU Architecture to target"),
+            cl::values(clEnumValN(GPU_ARCH_NVPTX64, "nvptx64",
+                                  "target NVIDIA 64-bit architecture")),
+            cl::init(GPU_ARCH_NVPTX64), cl::ZeroOrMore, cl::cat(PollyCategory));
+#endif
+
 VectorizerChoice polly::PollyVectorizerChoice;
 static cl::opt<polly::VectorizerChoice, true> Vectorizer(
     "polly-vectorizer", cl::desc("Select the vectorization strategy"),
     cl::values(
         clEnumValN(polly::VECTORIZER_NONE, "none", "No Vectorization"),
         clEnumValN(polly::VECTORIZER_POLLY, "polly",
                    "Polly internal vectorizer"),
         clEnumValN(
case OPTIMIZER_ISL:
       PM.add(polly::createIslScheduleOptimizerPass());
       break;
     }
   }
 
   if (ExportJScop)
     PM.add(polly::createJSONExporterPass());
 
   if (Target == TARGET_GPU) {
 #ifdef GPU_CODEGEN
-    PM.add(polly::createPPCGCodeGenerationPass());
+    int Arch;
+    int Runtime;
+
+    static const int UseOpenCLRuntime = 2;
+    Runtime = UseOpenCLRuntime;
+
+    switch (GPUArch) {
+    case GPU_ARCH_NVPTX64:
+      static const int TargetNVPTX64 = 1;
+      Arch = TargetNVPTX64;
+      if (GPURuntime == GPU_RUNTIME_CUDA) {
+        static const int UseCUDARuntime = 1;
+        Runtime = UseCUDARuntime;
+      }
+      break;
+    }
+
+    PM.add(polly::createPPCGCodeGenerationPass(Arch, Runtime));
 #endif
   } else {
     switch (CodeGeneration) {
     case CODEGEN_AST:
       PM.add(polly::createIslAstInfoPass());
       break;
     case CODEGEN_FULL:
       PM.add(polly::createCodeGenerationPass());
       break;

test/GPGPU/size-cast.ll

 ; CODE:   cudaCheckReturn(cudaMemcpy(MemRef_arg2, dev_MemRef_arg2, (arg) * sizeof(double), cudaMemcpyDeviceToHost));
 ; CODE-NEXT: }
 
 ; CODE: # kernel0
 ; CODE-NEXT: for (int c0 = 0; c0 <= (arg - 32 * b0 - 1) / 1048576; c0 += 1)
 ; CODE-NEXT:   if (arg >= 32 * b0 + t0 + 1048576 * c0 + 1)
 ; CODE-NEXT:     Stmt_bb6(0, 32 * b0 + t0 + 1048576 * c0);
 
-; IR:        call i8* @polly_initContext()
+; IR:        call i8* @polly_initContextCUDA()
 ; IR-NEXT:   sext i32 %arg to i64
 ; IR-NEXT:   mul i64
 ; IR-NEXT:   @polly_allocateMemoryForDevice
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @hoge(i32 %arg, i32 %arg1, [1000 x double]* %arg2, double* %arg3) {

tools/CMakeLists.txt

-if (CUDALIB_FOUND)
+if (CUDALIB_FOUND OR OpenCL_FOUND)
   add_subdirectory(GPURuntime)
-endif (CUDALIB_FOUND)
+endif (CUDALIB_FOUND OR OpenCL_FOUND)
 
 set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} PARENT_SCOPE)

tools/GPURuntime/GPUJIT.h

  *   polly_copyFromDeviceToHost(HostData, DevData, MemSize);
  *   polly_freeKernel(Kernel);
  *   polly_freeDeviceMemory(DevArray);
  *   polly_freeContext(Context);
  * }
  *
  */
 
+typedef enum PollyGPURuntimeT {
+  RUNTIME_NONE,
+  RUNTIME_CUDA,
+  RUNTIME_CL
+} PollyGPURuntime;
+
 typedef struct PollyGPUContextT PollyGPUContext;
 typedef struct PollyGPUFunctionT PollyGPUFunction;
 typedef struct PollyGPUDevicePtrT PollyGPUDevicePtr;
 
-PollyGPUContext *polly_initContext();
-PollyGPUFunction *polly_getKernel(const char *PTXBuffer,
+typedef struct OpenCLContextT OpenCLContext;
+typedef struct OpenCLKernelT OpenCLKernel;
+typedef struct OpenCLDevicePtrT OpenCLDevicePtr;
+
+typedef struct CUDAContextT CUDAContext;
+typedef struct CUDAKernelT CUDAKernel;
+typedef struct CUDADevicePtrT CUDADevicePtr;
+
+PollyGPUContext *polly_initContextCUDA();
+PollyGPUContext *polly_initContextCL();
+PollyGPUFunction *polly_getKernel(const char *BinaryBuffer,
                                   const char *KernelName);
 void polly_freeKernel(PollyGPUFunction *Kernel);
 void polly_copyFromHostToDevice(void *HostData, PollyGPUDevicePtr *DevData,
                                 long MemSize);
 void polly_copyFromDeviceToHost(PollyGPUDevicePtr *DevData, void *HostData,
                                 long MemSize);
 void polly_synchronizeDevice();
 void polly_launchKernel(PollyGPUFunction *Kernel, unsigned int GridDimX,
                         unsigned int GridDimY, unsigned int BlockSizeX,
                         unsigned int BlockSizeY, unsigned int BlockSizeZ,
                         void **Parameters);
 void polly_freeDeviceMemory(PollyGPUDevicePtr *Allocation);
 void polly_freeContext(PollyGPUContext *Context);
 #endif /* GPUJIT_H_ */

tools/GPURuntime/GPUJIT.c

 /******************** GPUJIT.c - GPUJIT Execution Engine **********************/
 /*                                                                            */
 /*                     The LLVM Compiler Infrastructure                       */
 /*                                                                            */
 /* This file is dual licensed under the MIT and the University of Illinois    */
 /* Open Source License. See LICENSE.TXT for details.                          */
 /*                                                                            */
 /******************************************************************************/
 /*                                                                            */
 /*  This file implements GPUJIT, a ptx string execution engine for GPU.       */
 /*                                                                            */
 /******************************************************************************/
 
 #include "GPUJIT.h"
+
+#ifdef HAS_LIBCUDART
 #include <cuda.h>
 #include <cuda_runtime.h>
+#endif /* HAS_LIBCUDART */
+
+#ifdef HAS_LIBOPENCL
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+#endif /* HAS_LIBOPENCL */
+
 #include <dlfcn.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
 static int DebugMode;
 static int CacheMode;
 
+static PollyGPURuntime Runtime = RUNTIME_NONE;
+
 static void debug_print(const char *format, ...) {
   if (!DebugMode)
     return;
 
   va_list args;
   va_start(args, format);
   vfprintf(stderr, format, args);
   va_end(args);
 }
 #define dump_function() debug_print("-> %s\n", __func__)
 
-/* Define Polly's GPGPU data types. */
+#define KERNEL_CACHE_SIZE 10
+
+static void err_runtime() {
+  fprintf(stdout, "Runtime not correctly initialized.\n");
+  exit(-1);
+}
+
 struct PollyGPUContextT {
-  CUcontext Cuda;
+  void *Context;
 };
 
 struct PollyGPUFunctionT {
+  void *Kernel;
+};
+
+struct PollyGPUDevicePtrT {
+  void *DevicePtr;
+};
+
+/******************************************************************************/
+/*                                  OpenCL                                    */
+/******************************************************************************/
+#ifdef HAS_LIBOPENCL
+
+struct OpenCLContextT {
+  cl_context Context;
+  cl_command_queue CommandQueue;
+};
+
+struct OpenCLKernelT {
+  cl_kernel Kernel;
+  cl_program Program;
+  const char *BinaryString;
+};
+
+struct OpenCLDevicePtrT {
+  cl_mem MemObj;
+};
+
+/* Dynamic library handles for the OpenCL runtime library. */
+static void *HandleOpenCL;
+
+/* Type-defines of function pointer to OpenCL Runtime API. */
+typedef cl_int clGetPlatformIDsFcnTy(cl_uint NumEntries,
+                                     cl_platform_id *Platforms,
+                                     cl_uint *NumPlatforms);
+static clGetPlatformIDsFcnTy *clGetPlatformIDsFcnPtr;
+
+typedef cl_int clGetDeviceIDsFcnTy(cl_platform_id Platform,
+                                   cl_device_type DeviceType,
+                                   cl_uint NumEntries, cl_device_id *Devices,
+                                   cl_uint *NumDevices);
+static clGetDeviceIDsFcnTy *clGetDeviceIDsFcnPtr;
+
+typedef cl_int clGetDeviceInfoFcnTy(cl_device_id Device,
+                                    cl_device_info ParamName,
+                                    size_t ParamValueSize, void *ParamValue,
+                                    size_t *ParamValueSizeRet);
+static clGetDeviceInfoFcnTy *clGetDeviceInfoFcnPtr;
+
+typedef cl_int clGetKernelInfoFcnTy(cl_kernel Kernel, cl_kernel_info ParamName,
+                                    size_t ParamValueSize, void *ParamValue,
+                                    size_t *ParamValueSizeRet);
+static clGetKernelInfoFcnTy *clGetKernelInfoFcnPtr;
+
+typedef cl_context clCreateContextFcnTy(
+    const cl_context_properties *Properties, cl_uint NumDevices,
+    const cl_device_id *Devices,
+    void CL_CALLBACK *pfn_notify(const char *Errinfo, const void *PrivateInfo,
+                                 size_t CB, void *UserData),
+    void *UserData, cl_int *ErrcodeRet);
+static clCreateContextFcnTy *clCreateContextFcnPtr;
+
+typedef cl_command_queue
+clCreateCommandQueueFcnTy(cl_context Context, cl_device_id Device,
+                          cl_command_queue_properties Properties,
+                          cl_int *ErrcodeRet);
+static clCreateCommandQueueFcnTy *clCreateCommandQueueFcnPtr;
+
+typedef cl_mem clCreateBufferFcnTy(cl_context Context, cl_mem_flags Flags,
+                                   size_t Size, void *HostPtr,
+                                   cl_int *ErrcodeRet);
+static clCreateBufferFcnTy *clCreateBufferFcnPtr;
+
+typedef cl_int
+clEnqueueWriteBufferFcnTy(cl_command_queue CommandQueue, cl_mem Buffer,
+                          cl_bool BlockingWrite, size_t Offset, size_t Size,
+                          const void *Ptr, cl_uint NumEventsInWaitList,
+                          const cl_event *EventWaitList, cl_event *Event);
+static clEnqueueWriteBufferFcnTy *clEnqueueWriteBufferFcnPtr;
+
+typedef cl_program clCreateProgramWithBinaryFcnTy(
+    cl_context Context, cl_uint NumDevices, const cl_device_id *DeviceList,
+    const size_t *Lengths, const unsigned char **Binaries, cl_int *BinaryStatus,
+    cl_int *ErrcodeRet);
+static clCreateProgramWithBinaryFcnTy *clCreateProgramWithBinaryFcnPtr;
+
+typedef cl_int clBuildProgramFcnTy(
+    cl_program Program, cl_uint NumDevices, const cl_device_id *DeviceList,
+    const char *Options,
+    void(CL_CALLBACK *pfn_notify)(cl_program Program, void *UserData),
+    void *UserData);
+static clBuildProgramFcnTy *clBuildProgramFcnPtr;
+
+typedef cl_kernel clCreateKernelFcnTy(cl_program Program,
+                                      const char *KernelName,
+                                      cl_int *ErrcodeRet);
+static clCreateKernelFcnTy *clCreateKernelFcnPtr;
+
+typedef cl_int clSetKernelArgFcnTy(cl_kernel Kernel, cl_uint ArgIndex,
+                                   size_t ArgSize, const void *ArgValue);
+static clSetKernelArgFcnTy *clSetKernelArgFcnPtr;
+
+typedef cl_int clEnqueueNDRangeKernelFcnTy(
+    cl_command_queue CommandQueue, cl_kernel Kernel, cl_uint WorkDim,
+    const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize,
+    const size_t *LocalWorkSize, cl_uint NumEventsInWaitList,
+    const cl_event *EventWaitList, cl_event *Event);
+static clEnqueueNDRangeKernelFcnTy *clEnqueueNDRangeKernelFcnPtr;
+
+typedef cl_int clEnqueueReadBufferFcnTy(cl_command_queue CommandQueue,
+                                        cl_mem Buffer, cl_bool BlockingRead,
+                                        size_t Offset, size_t Size, void *Ptr,
+                                        cl_uint NumEventsInWaitList,
+                                        const cl_event *EventWaitList,
+                                        cl_event *Event);
+static clEnqueueReadBufferFcnTy *clEnqueueReadBufferFcnPtr;
+
+typedef cl_int clFlushFcnTy(cl_command_queue CommandQueue);
+static clFlushFcnTy *clFlushFcnPtr;
+
+typedef cl_int clFinishFcnTy(cl_command_queue CommandQueue);
+static clFinishFcnTy *clFinishFcnPtr;
+
+typedef cl_int clReleaseKernelFcnTy(cl_kernel Kernel);
+static clReleaseKernelFcnTy *clReleaseKernelFcnPtr;
+
+typedef cl_int clReleaseProgramFcnTy(cl_program Program);
+static clReleaseProgramFcnTy *clReleaseProgramFcnPtr;
+
+typedef cl_int clReleaseMemObjectFcnTy(cl_mem Memobject);
+static clReleaseMemObjectFcnTy *clReleaseMemObjectFcnPtr;
+
+typedef cl_int clReleaseCommandQueueFcnTy(cl_command_queue CommandQueue);
+static clReleaseCommandQueueFcnTy *clReleaseCommandQueueFcnPtr;
+
+typedef cl_int clReleaseContextFcnTy(cl_context Context);
+static clReleaseContextFcnTy *clReleaseContextFcnPtr;
+
+static void *getAPIHandleCL(void *Handle, const char *FuncName) {
+  char *Err;
+  void *FuncPtr;
+  dlerror();
+  FuncPtr = dlsym(Handle, FuncName);
+  if ((Err = dlerror()) != 0) {
+    fprintf(stdout, "Load OpenCL Runtime API failed: %s. \n", Err);
+    return 0;
+  }
+  return FuncPtr;
+}
+
+static int initialDeviceAPILibrariesCL() {
+  HandleOpenCL = dlopen("libOpenCL.so", RTLD_LAZY);
+  if (!HandleOpenCL) {
+    printf("Cannot open library: %s. \n", dlerror());
+    return 0;
+  }
+  return 1;
+}
+
+static int initialDeviceAPIsCL() {
+  if (initialDeviceAPILibrariesCL() == 0)
+    return 0;
+
+  /* Get function pointer to OpenCL Runtime API.
+   *
+   * Note that compilers conforming to the ISO C standard are required to
+   * generate a warning if a conversion from a void * pointer to a function
+   * pointer is attempted as in the following statements. The warning
+   * of this kind of cast may not be emitted by clang and new versions of gcc
+   * as it is valid on POSIX 2008.
+   */
+  clGetPlatformIDsFcnPtr =
+      (clGetPlatformIDsFcnTy *)getAPIHandleCL(HandleOpenCL, "clGetPlatformIDs");
+
+  clGetDeviceIDsFcnPtr =
+      (clGetDeviceIDsFcnTy *)getAPIHandleCL(HandleOpenCL, "clGetDeviceIDs");
+
+  clGetDeviceInfoFcnPtr =
+      (clGetDeviceInfoFcnTy *)getAPIHandleCL(HandleOpenCL, "clGetDeviceInfo");
+
+  clGetKernelInfoFcnPtr =
+      (clGetKernelInfoFcnTy *)getAPIHandleCL(HandleOpenCL, "clGetKernelInfo");
+
+  clCreateContextFcnPtr =
+      (clCreateContextFcnTy *)getAPIHandleCL(HandleOpenCL, "clCreateContext");
+
+  clCreateCommandQueueFcnPtr = (clCreateCommandQueueFcnTy *)getAPIHandleCL(
+      HandleOpenCL, "clCreateCommandQueue");
+
+  clCreateBufferFcnPtr =
+      (clCreateBufferFcnTy *)getAPIHandleCL(HandleOpenCL, "clCreateBuffer");
+
+  clEnqueueWriteBufferFcnPtr = (clEnqueueWriteBufferFcnTy *)getAPIHandleCL(
+      HandleOpenCL, "clEnqueueWriteBuffer");
+
+  clCreateProgramWithBinaryFcnPtr =
+      (clCreateProgramWithBinaryFcnTy *)getAPIHandleCL(
+          HandleOpenCL, "clCreateProgramWithBinary");
+
+  clBuildProgramFcnPtr =
+      (clBuildProgramFcnTy *)getAPIHandleCL(HandleOpenCL, "clBuildProgram");
+
+  clCreateKernelFcnPtr =
+      (clCreateKernelFcnTy *)getAPIHandleCL(HandleOpenCL, "clCreateKernel");
+
+  clSetKernelArgFcnPtr =
+      (clSetKernelArgFcnTy *)getAPIHandleCL(HandleOpenCL, "clSetKernelArg");
+
+  clEnqueueNDRangeKernelFcnPtr = (clEnqueueNDRangeKernelFcnTy *)getAPIHandleCL(
+      HandleOpenCL, "clEnqueueNDRangeKernel");
+
+  clEnqueueReadBufferFcnPtr = (clEnqueueReadBufferFcnTy *)getAPIHandleCL(
+      HandleOpenCL, "clEnqueueReadBuffer");
+
+  clFlushFcnPtr = (clFlushFcnTy *)getAPIHandleCL(HandleOpenCL, "clFlush");
+
+  clFinishFcnPtr = (clFinishFcnTy *)getAPIHandleCL(HandleOpenCL, "clFinish");
+
+  clReleaseKernelFcnPtr =
+      (clReleaseKernelFcnTy *)getAPIHandleCL(HandleOpenCL, "clReleaseKernel");
+
+  clReleaseProgramFcnPtr =
+      (clReleaseProgramFcnTy *)getAPIHandleCL(HandleOpenCL, "clReleaseProgram");
+
+  clReleaseMemObjectFcnPtr = (clReleaseMemObjectFcnTy *)getAPIHandleCL(
+      HandleOpenCL, "clReleaseMemObject");
+
+  clReleaseCommandQueueFcnPtr = (clReleaseCommandQueueFcnTy *)getAPIHandleCL(
+      HandleOpenCL, "clReleaseCommandQueue");
+
+  clReleaseContextFcnPtr =
+      (clReleaseContextFcnTy *)getAPIHandleCL(HandleOpenCL, "clReleaseContext");
+
+  return 1;
+}
+
+/* Context and Device. */
+static PollyGPUContext *GlobalContext = NULL;
+static cl_device_id GlobalDeviceID = NULL;
+
+/* Fd-Decl: Print out OpenCL Error codes to human readable strings. */
+void cl_printError(int Error);
+
+PollyGPUContext *initContextCL() {
+  dump_function();
+
+  PollyGPUContext *Context;
+
+  cl_platform_id PlatformID = NULL;
+  cl_device_id DeviceID = NULL;
+  cl_uint NumDevicesRet;
+  cl_int Ret;
+
+  char DeviceRevision[256];
+  char DeviceName[256];
+  size_t DeviceRevisionRetSize, DeviceNameRetSize;
+
+  static __thread PollyGPUContext *CurrentContext = NULL;
+
+  if (CurrentContext)
+    return CurrentContext;
+
+  /* Get API handles. */
+  if (initialDeviceAPIsCL() == 0) {
+    fprintf(stdout, "Getting the \"handle\" for the OpenCL Runtime failed.\n");
+    exit(-1);
+  }
+
+  /* Get number of devices that support OpenCL. */
+  static const int NumberOfPlatforms = 1;
+  Ret = clGetPlatformIDsFcnPtr(NumberOfPlatforms, &PlatformID, NULL);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to get platform IDs.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+  // TODO: Extend to CL_DEVICE_TYPE_ALL?
+  static const int NumberOfDevices = 1;
+  Ret = clGetDeviceIDsFcnPtr(PlatformID, CL_DEVICE_TYPE_GPU, NumberOfDevices,
+                             &DeviceID, &NumDevicesRet);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to get device IDs.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  GlobalDeviceID = DeviceID;
+  if (NumDevicesRet == 0) {
+    fprintf(stdout, "There is no device supporting OpenCL.\n");
+    exit(-1);
+  }
+
+  /* Get device revision. */
+  Ret =
+      clGetDeviceInfoFcnPtr(DeviceID, CL_DEVICE_VERSION, sizeof(DeviceRevision),
+                            DeviceRevision, &DeviceRevisionRetSize);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to fetch device revision.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  /* Get device name. */
+  Ret = clGetDeviceInfoFcnPtr(DeviceID, CL_DEVICE_NAME, sizeof(DeviceName),
+                              DeviceName, &DeviceNameRetSize);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to fetch device name.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  debug_print("> Running on GPU device %d : %s.\n", DeviceID, DeviceName);
+
+  /* Create context on the device. */
+  Context = (PollyGPUContext *)malloc(sizeof(PollyGPUContext));
+  if (Context == 0) {
+    fprintf(stdout, "Allocate memory for Polly GPU context failed.\n");
+    exit(-1);
+  }
+  Context->Context = (OpenCLContext *)malloc(sizeof(OpenCLContext));
+  if (Context->Context == 0) {
+    fprintf(stdout, "Allocate memory for Polly OpenCL context failed.\n");
+    exit(-1);
+  }
+  ((OpenCLContext *)Context->Context)->Context =
+      clCreateContextFcnPtr(NULL, NumDevicesRet, &DeviceID, NULL, NULL, &Ret);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to create context.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  static const int ExtraProperties = 0;
+  ((OpenCLContext *)Context->Context)->CommandQueue =
+      clCreateCommandQueueFcnPtr(((OpenCLContext *)Context->Context)->Context,
+                                 DeviceID, ExtraProperties, &Ret);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to create command queue.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  if (CacheMode)
+    CurrentContext = Context;
+
+  GlobalContext = Context;
+  return Context;
+}
+
+static void freeKernelCL(PollyGPUFunction *Kernel) {
+  dump_function();
+
+  if (CacheMode)
+    return;
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  cl_int Ret;
+  Ret = clFlushFcnPtr(((OpenCLContext *)GlobalContext->Context)->CommandQueue);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to flush command queue.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+  Ret = clFinishFcnPtr(((OpenCLContext *)GlobalContext->Context)->CommandQueue);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to flush command queue.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  if (((OpenCLKernel *)Kernel->Kernel)->Kernel) {
+    cl_int Ret =
+        clReleaseKernelFcnPtr(((OpenCLKernel *)Kernel->Kernel)->Kernel);
+    if (Ret != CL_SUCCESS) {
+      fprintf(stdout, "Failed to release kernel.\n");
+      cl_printError(Ret);
+      exit(-1);
+    }
+  }
+
+  if (((OpenCLKernel *)Kernel->Kernel)->Program) {
+    cl_int Ret =
+        clReleaseProgramFcnPtr(((OpenCLKernel *)Kernel->Kernel)->Program);
+    if (Ret != CL_SUCCESS) {
+      fprintf(stdout, "Failed to release program.\n");
+      cl_printError(Ret);
+      exit(-1);
+    }
+  }
+
+  if (Kernel->Kernel)
+    free((OpenCLKernel *)Kernel->Kernel);
+
+  if (Kernel)
+    free(Kernel);
+}
+
+PollyGPUFunction *getKernelCL(const char *BinaryBuffer,
+                              const char *KernelName) {
+  dump_function();
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  static __thread PollyGPUFunction *KernelCache[KERNEL_CACHE_SIZE];
+  static __thread int NextCacheItem = 0;
+
+  for (long i = 0; i < KERNEL_CACHE_SIZE; i++) {
+    // We exploit here the property that all Polly-ACC kernels are allocated
+    // as global constants, hence a pointer comparision is sufficient to
+    // determin equality.
+    if (KernelCache[i] &&
+        ((OpenCLKernel *)KernelCache[i]->Kernel)->BinaryString ==
+            BinaryBuffer) {
+      debug_print("  -> using cached kernel\n");
+      return KernelCache[i];
+    }
+  }
+
+  PollyGPUFunction *Function = malloc(sizeof(PollyGPUFunction));
+  if (Function == 0) {
+    fprintf(stdout, "Allocate memory for Polly GPU function failed.\n");
+    exit(-1);
+  }
+  Function->Kernel = (OpenCLKernel *)malloc(sizeof(OpenCLKernel));
+  if (Function->Kernel == 0) {
+    fprintf(stdout, "Allocate memory for Polly OpenCL kernel failed.\n");
+    exit(-1);
+  }
+
+  if (!GlobalDeviceID) {
+    fprintf(stdout, "GPGPU-code generation not initialized correctly.\n");
+    exit(-1);
+  }
+
+  cl_int Ret;
+  size_t BinarySize = strlen(BinaryBuffer);
+  ((OpenCLKernel *)Function->Kernel)->Program = clCreateProgramWithBinaryFcnPtr(
+      ((OpenCLContext *)GlobalContext->Context)->Context, 1, &GlobalDeviceID,
+      (const size_t *)&BinarySize, (const unsigned char **)&BinaryBuffer, NULL,
+      &Ret);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to create program from binary.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  Ret = clBuildProgramFcnPtr(((OpenCLKernel *)Function->Kernel)->Program, 1,
+                             &GlobalDeviceID, NULL, NULL, NULL);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to build program.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  ((OpenCLKernel *)Function->Kernel)->Kernel = clCreateKernelFcnPtr(
+      ((OpenCLKernel *)Function->Kernel)->Program, KernelName, &Ret);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to create kernel.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  ((OpenCLKernel *)Function->Kernel)->BinaryString = BinaryBuffer;
+
+  if (CacheMode) {
+    if (KernelCache[NextCacheItem])
+      freeKernelCL(KernelCache[NextCacheItem]);
+
+    KernelCache[NextCacheItem] = Function;
+
+    NextCacheItem = (NextCacheItem + 1) % KERNEL_CACHE_SIZE;
+  }
+
+  return Function;
+}
+
+void copyFromHostToDeviceCL(void *HostData, PollyGPUDevicePtr *DevData,
+                            long MemSize) {
+  dump_function();
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  cl_int Ret;
+  Ret = clEnqueueWriteBufferFcnPtr(
+      ((OpenCLContext *)GlobalContext->Context)->CommandQueue,
+      ((OpenCLDevicePtr *)DevData->DevicePtr)->MemObj, CL_TRUE, 0, MemSize,
+      HostData, 0, NULL, NULL);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Copying data from host memory to device failed.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+}
+
+void copyFromDeviceToHostCL(PollyGPUDevicePtr *DevData, void *HostData,
+                            long MemSize) {
+  dump_function();
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  cl_int Ret;
+  Ret = clEnqueueReadBufferFcnPtr(
+      ((OpenCLContext *)GlobalContext->Context)->CommandQueue,
+      ((OpenCLDevicePtr *)DevData->DevicePtr)->MemObj, CL_TRUE, 0, MemSize,
+      HostData, 0, NULL, NULL);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Copying results from device to host memory failed.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+}
+
+void launchKernelCL(PollyGPUFunction *Kernel, unsigned int GridDimX,
+                    unsigned int GridDimY, unsigned int BlockDimX,
+                    unsigned int BlockDimY, unsigned int BlockDimZ,
+                    void **Parameters) {
+  dump_function();
+
+  cl_int Ret;
+  cl_uint NumArgs;
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  OpenCLKernel *CLKernel = (OpenCLKernel *)Kernel->Kernel;
+  Ret = clGetKernelInfoFcnPtr(CLKernel->Kernel, CL_KERNEL_NUM_ARGS,
+                              sizeof(cl_uint), &NumArgs, NULL);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to get number of kernel arguments.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  for (cl_uint i = 0; i < NumArgs; i++) {
+    Ret = clSetKernelArgFcnPtr(CLKernel->Kernel, i, 8, (void *)Parameters[i]);
+    if (Ret == CL_INVALID_ARG_SIZE) {
+      Ret = clSetKernelArgFcnPtr(CLKernel->Kernel, i, 4, (void *)Parameters[i]);
+      if (Ret == CL_INVALID_ARG_SIZE) {
+        Ret =
+            clSetKernelArgFcnPtr(CLKernel->Kernel, i, 2, (void *)Parameters[i]);
+        if (Ret == CL_INVALID_ARG_SIZE) {
+          Ret = clSetKernelArgFcnPtr(CLKernel->Kernel, i, 1,
+                                     (void *)Parameters[i]);
+          if (Ret != CL_SUCCESS) {
+            fprintf(stdout, "Failed to set Kernel argument %d.\n", i);
+            cl_printError(Ret);
+            exit(-1);
+          }
+        }
+      }
+    }
+    if (Ret != CL_SUCCESS && Ret != CL_INVALID_ARG_SIZE) {
+      fprintf(stdout, "Failed to set Kernel argument.\n");
+      cl_printError(Ret);
+      exit(-1);
+    }
+  }
+
+  unsigned int GridDimZ = 1;
+  size_t GlobalWorkSize[3] = {BlockDimX * GridDimX, BlockDimY * GridDimY,
+                              BlockDimZ * GridDimZ};
+  size_t LocalWorkSize[3] = {BlockDimX, BlockDimY, BlockDimZ};
+
+  static const int WorkDim = 3;
+  OpenCLContext *CLContext = (OpenCLContext *)GlobalContext->Context;
+  Ret = clEnqueueNDRangeKernelFcnPtr(CLContext->CommandQueue, CLKernel->Kernel,
+                                     WorkDim, NULL, GlobalWorkSize,
+                                     LocalWorkSize, 0, NULL, NULL);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Launching OpenCL kernel failed.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+}
+
+void freeDeviceMemoryCL(PollyGPUDevicePtr *Allocation) {
+  dump_function();
+
+  OpenCLDevicePtr *DevPtr = (OpenCLDevicePtr *)Allocation->DevicePtr;
+  cl_int Ret = clReleaseMemObjectFcnPtr((cl_mem)DevPtr->MemObj);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Failed to free device memory.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  free(DevPtr);
+  free(Allocation);
+}
+
+PollyGPUDevicePtr *allocateMemoryForDeviceCL(long MemSize) {
+  dump_function();
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  PollyGPUDevicePtr *DevData = malloc(sizeof(PollyGPUDevicePtr));
+  if (DevData == 0) {
+    fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
+    exit(-1);
+  }
+  DevData->DevicePtr = (OpenCLDevicePtr *)malloc(sizeof(OpenCLDevicePtr));
+  if (DevData->DevicePtr == 0) {
+    fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
+    exit(-1);
+  }
+
+  cl_int Ret;
+  ((OpenCLDevicePtr *)DevData->DevicePtr)->MemObj =
+      clCreateBufferFcnPtr(((OpenCLContext *)GlobalContext->Context)->Context,
+                           CL_MEM_READ_WRITE, MemSize, NULL, &Ret);
+  if (Ret != CL_SUCCESS) {
+    fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
+    cl_printError(Ret);
+    exit(-1);
+  }
+
+  return DevData;
+}
+
+void *getDevicePtrCL(PollyGPUDevicePtr *Allocation) {
+  dump_function();
+
+  OpenCLDevicePtr *DevPtr = (OpenCLDevicePtr *)Allocation->DevicePtr;
+  return (void *)DevPtr->MemObj;
+}
+
+void synchronizeDeviceCL() {
+  dump_function();
+
+  if (!GlobalContext) {
+    fprintf(stdout, "GPGPU-code generation not correctly initialized.\n");
+    exit(-1);
+  }
+
+  if (clFinishFcnPtr(
+        ((OpenCLContext *)GlobalContext->Context)->CommandQueue) != CL_SUCCESS) {
+    fprintf(stdout, "Synchronizing device and host memory failed.\n");
+    exit(-1);
+  }
+}
+
+void freeContextCL(PollyGPUContext *Context) {
+  dump_function();
+
+  cl_int Ret;
+
+  GlobalContext = NULL;
+
+  OpenCLContext *Ctx = (OpenCLContext *)Context->Context;
+  if (Ctx->CommandQueue) {
+    Ret = clReleaseCommandQueueFcnPtr(Ctx->CommandQueue);
+    if (Ret != CL_SUCCESS) {
+      fprintf(stdout, "Could not release command queue.\n");
+      cl_printError(Ret);
+      exit(-1);
+    }
+  }
+
+  if (Ctx->Context) {
+    Ret = clReleaseContextFcnPtr(Ctx->Context);
+    if (Ret != CL_SUCCESS) {
+      fprintf(stdout, "Could not release context.\n");
+      cl_printError(Ret);
+      exit(-1);
+    }
+  }
+
+  free(Ctx);
+  free(Context);
+}
+
+void cl_printError(int Error) {
+
+  switch (Error) {
+  case CL_SUCCESS:
+    // Success, don't print an error.
+    break;
+
+  // JIT/Runtime errors.
+  case CL_DEVICE_NOT_FOUND:
+    fprintf(stdout, "Device not found.\n");
+    break;
+  case CL_DEVICE_NOT_AVAILABLE:
+    fprintf(stdout, "Device not available.\n");
+    break;
+  case CL_COMPILER_NOT_AVAILABLE:
+    fprintf(stdout, "Compiler not available.\n");
+    break;
+  case CL_MEM_OBJECT_ALLOCATION_FAILURE:
+    fprintf(stdout, "Mem object allocation failure.\n");
+    break;
+  case CL_OUT_OF_RESOURCES:
+    fprintf(stdout, "Out of resources.\n");
+    break;
+  case CL_OUT_OF_HOST_MEMORY:
+    fprintf(stdout, "Out of host memory.\n");
+    break;
+  case CL_PROFILING_INFO_NOT_AVAILABLE:
+    fprintf(stdout, "Profiling info not available.\n");
+    break;
+  case CL_MEM_COPY_OVERLAP:
+    fprintf(stdout, "Mem copy overlap.\n");
+    break;
+  case CL_IMAGE_FORMAT_MISMATCH:
+    fprintf(stdout, "Image format mismatch.\n");
+    break;
+  case CL_IMAGE_FORMAT_NOT_SUPPORTED:
+    fprintf(stdout, "Image format not supported.\n");
+    break;
+  case CL_BUILD_PROGRAM_FAILURE:
+    fprintf(stdout, "Build program failure.\n");
+    break;
+  case CL_MAP_FAILURE:
+    fprintf(stdout, "Map failure.\n");
+    break;
+  case CL_MISALIGNED_SUB_BUFFER_OFFSET:
+    fprintf(stdout, "Misaligned sub buffer offset.\n");
+    break;
+  case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:
+    fprintf(stdout, "Exec status error for events in wait list.\n");
+    break;
+  case CL_COMPILE_PROGRAM_FAILURE:
+    fprintf(stdout, "Compile program failure.\n");
+    break;
+  case CL_LINKER_NOT_AVAILABLE:
+    fprintf(stdout, "Linker not available.\n");
+    break;
+  case CL_LINK_PROGRAM_FAILURE:
+    fprintf(stdout, "Link program failure.\n");
+    break;
+  case CL_DEVICE_PARTITION_FAILED:
+    fprintf(stdout, "Device partition failed.\n");
+    break;
+  case CL_KERNEL_ARG_INFO_NOT_AVAILABLE:
+    fprintf(stdout, "Kernel arg info not available.\n");
+    break;
+
+  // Compiler errors.
+  case CL_INVALID_VALUE:
+    fprintf(stdout, "Invalid value.\n");
+    break;
+  case CL_INVALID_DEVICE_TYPE:
+    fprintf(stdout, "Invalid device type.\n");
+    break;
+  case CL_INVALID_PLATFORM:
+    fprintf(stdout, "Invalid platform.\n");
+    break;
+  case CL_INVALID_DEVICE:
+    fprintf(stdout, "Invalid device.\n");
+    break;
+  case CL_INVALID_CONTEXT:
+    fprintf(stdout, "Invalid context.\n");
+    break;
+  case CL_INVALID_QUEUE_PROPERTIES:
+    fprintf(stdout, "Invalid queue properties.\n");
+    break;
+  case CL_INVALID_COMMAND_QUEUE:
+    fprintf(stdout, "Invalid command queue.\n");
+    break;
+  case CL_INVALID_HOST_PTR:
+    fprintf(stdout, "Invalid host pointer.\n");
+    break;
+  case CL_INVALID_MEM_OBJECT:
+    fprintf(stdout, "Invalid memory object.\n");
+    break;
+  case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
+    fprintf(stdout, "Invalid image format descriptor.\n");
+    break;
+  case CL_INVALID_IMAGE_SIZE:
+    fprintf(stdout, "Invalid image size.\n");
+    break;
+  case CL_INVALID_SAMPLER:
+    fprintf(stdout, "Invalid sampler.\n");
+    break;
+  case CL_INVALID_BINARY:
+    fprintf(stdout, "Invalid binary.\n");
+    break;
+  case CL_INVALID_BUILD_OPTIONS:
+    fprintf(stdout, "Invalid build options.\n");
+    break;
+  case CL_INVALID_PROGRAM:
+    fprintf(stdout, "Invalid program.\n");
+    break;
+  case CL_INVALID_PROGRAM_EXECUTABLE:
+    fprintf(stdout, "Invalid program executable.\n");
+    break;
+  case CL_INVALID_KERNEL_NAME:
+    fprintf(stdout, "Invalid kernel name.\n");
+    break;
+  case CL_INVALID_KERNEL_DEFINITION:
+    fprintf(stdout, "Invalid kernel definition.\n");
+    break;
+  case CL_INVALID_KERNEL:
+    fprintf(stdout, "Invalid kernel.\n");
+    break;
+  case CL_INVALID_ARG_INDEX:
+    fprintf(stdout, "Invalid arg index.\n");
+    break;
+  case CL_INVALID_ARG_VALUE:
+    fprintf(stdout, "Invalid arg value.\n");
+    break;
+  case CL_INVALID_ARG_SIZE:
+    fprintf(stdout, "Invalid arg size.\n");
+    break;
+  case CL_INVALID_KERNEL_ARGS:
+    fprintf(stdout, "Invalid kernel args.\n");
+    break;
+  case CL_INVALID_WORK_DIMENSION:
+    fprintf(stdout, "Invalid work dimension.\n");
+    break;
+  case CL_INVALID_WORK_GROUP_SIZE:
+    fprintf(stdout, "Invalid work group size.\n");
+    break;
+  case CL_INVALID_WORK_ITEM_SIZE:
+    fprintf(stdout, "Invalid work item size.\n");
+    break;
+  case CL_INVALID_GLOBAL_OFFSET:
+    fprintf(stdout, "Invalid global offset.\n");
+    break;
+  case CL_INVALID_EVENT_WAIT_LIST:
+    fprintf(stdout, "Invalid event wait list.\n");
+    break;
+  case CL_INVALID_EVENT:
+    fprintf(stdout, "Invalid event.\n");
+    break;
+  case CL_INVALID_OPERATION:
+    fprintf(stdout, "Invalid operation.\n");
+    break;
+  case CL_INVALID_GL_OBJECT:
+    fprintf(stdout, "Invalid GL object.\n");
+    break;
+  case CL_INVALID_BUFFER_SIZE:
+    fprintf(stdout, "Invalid buffer size.\n");
+    break;
+  case CL_INVALID_MIP_LEVEL:
+    fprintf(stdout, "Invalid mip level.\n");
+    break;
+  case CL_INVALID_GLOBAL_WORK_SIZE:
+    fprintf(stdout, "Invalid global work size.\n");
+    break;
+  case CL_INVALID_PROPERTY:
+    fprintf(stdout, "Invalid property.\n");
+    break;
+  case CL_INVALID_IMAGE_DESCRIPTOR:
+    fprintf(stdout, "Invalid image descriptor.\n");
+    break;
+  case CL_INVALID_COMPILER_OPTIONS:
+    fprintf(stdout, "Invalid compiler options.\n");
+    break;
+  case CL_INVALID_LINKER_OPTIONS:
+    fprintf(stdout, "Invalid linker options.\n");
+    break;
+  case CL_INVALID_DEVICE_PARTITION_COUNT:
+    fprintf(stdout, "Invalid device partition count.\n");
+    break;
+  case CL_INVALID_PIPE_SIZE:
+    fprintf(stdout, "Invalid pipe size.\n");
+    break;
+  case CL_INVALID_DEVICE_QUEUE:
+    fprintf(stdout, "Invalid device queue.\n");
+    break;
+
+  // NVIDIA specific error.
+  case -9999:
+    fprintf(stdout, "NVIDIA invalid read or write buffer.\n");
+    break;
+
+  default:
+    fprintf(stdout, "Unknown error code!\n");
+    break;
+  }
+}
+
+#endif /* HAS_LIBOPENCL */
+/******************************************************************************/
+/*                                   CUDA                                     */
+/******************************************************************************/
+#ifdef HAS_LIBCUDART
+
+struct CUDAContextT {
+  CUcontext Cuda;
+};
+
+struct CUDAKernelT {
   CUfunction Cuda;
   CUmodule CudaModule;
-  const char *PTXString;
+  const char *BinaryString;
 };
 
-struct PollyGPUDevicePtrT {
+struct CUDADevicePtrT {
   CUdeviceptr Cuda;
 };
 
 /* Dynamic library handles for the CUDA and CUDA runtime library. */
 static void *HandleCuda;
 static void *HandleCudaRT;
 
 /* Type-defines of function pointer to CUDA driver APIs. */
 typedef CUresult CUDAAPI CuMemAllocFcnTy(CUdeviceptr *, size_t);
 static CuMemAllocFcnTy *CuMemAllocFcnPtr;
 
 typedef CUresult CUDAAPI CuLaunchKernelFcnTy(
-    CUfunction f, unsigned int gridDimX, unsigned int gridDimY,
-    unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY,
-    unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream,
-    void **kernelParams, void **extra);
+    CUfunction F, unsigned int GridDimX, unsigned int GridDimY,
+    unsigned int gridDimZ, unsigned int blockDimX, unsigned int BlockDimY,
+    unsigned int BlockDimZ, unsigned int SharedMemBytes, CUstream HStream,
+    void **KernelParams, void **Extra);
 static CuLaunchKernelFcnTy *CuLaunchKernelFcnPtr;
 
 typedef CUresult CUDAAPI CuMemcpyDtoHFcnTy(void *, CUdeviceptr, size_t);
 static CuMemcpyDtoHFcnTy *CuMemcpyDtoHFcnPtr;
 
 typedef CUresult CUDAAPI CuMemcpyHtoDFcnTy(CUdeviceptr, const void *, size_t);
 static CuMemcpyHtoDFcnTy *CuMemcpyHtoDFcnPtr;
 

 typedef CUresult CUDAAPI CuDeviceGetFcnTy(CUdevice *, int);
 static CuDeviceGetFcnTy *CuDeviceGetFcnPtr;
 
 typedef CUresult CUDAAPI CuModuleLoadDataExFcnTy(CUmodule *, const void *,
                                                  unsigned int, CUjit_option *,
                                                  void **);
 static CuModuleLoadDataExFcnTy *CuModuleLoadDataExFcnPtr;
 
-typedef CUresult CUDAAPI CuModuleLoadDataFcnTy(CUmodule *module,
-                                               const void *image);
+typedef CUresult CUDAAPI CuModuleLoadDataFcnTy(CUmodule *Module,
+                                               const void *Image);
 static CuModuleLoadDataFcnTy *CuModuleLoadDataFcnPtr;
 
 typedef CUresult CUDAAPI CuModuleGetFunctionFcnTy(CUfunction *, CUmodule,
                                                   const char *);
 static CuModuleGetFunctionFcnTy *CuModuleGetFunctionFcnPtr;
 
 typedef CUresult CUDAAPI CuDeviceComputeCapabilityFcnTy(int *, int *, CUdevice);
 static CuDeviceComputeCapabilityFcnTy *CuDeviceComputeCapabilityFcnPtr;
 
 typedef CUresult CUDAAPI CuDeviceGetNameFcnTy(char *, int, CUdevice);
 static CuDeviceGetNameFcnTy *CuDeviceGetNameFcnPtr;
 
-typedef CUresult CUDAAPI CuLinkAddDataFcnTy(CUlinkState state,
-                                            CUjitInputType type, void *data,
-                                            size_t size, const char *name,
-                                            unsigned int numOptions,
-                                            CUjit_option *options,
-                                            void **optionValues);
+typedef CUresult CUDAAPI CuLinkAddDataFcnTy(CUlinkState State,
+                                            CUjitInputType Type, void *Data,
+                                            size_t Size, const char *Name,
+                                            unsigned int NumOptions,
+                                            CUjit_option *Options,
+                                            void **OptionValues);
 static CuLinkAddDataFcnTy *CuLinkAddDataFcnPtr;
 
-typedef CUresult CUDAAPI CuLinkCreateFcnTy(unsigned int numOptions,
-                                           CUjit_option *options,
-                                           void **optionValues,
-                                           CUlinkState *stateOut);
+typedef CUresult CUDAAPI CuLinkCreateFcnTy(unsigned int NumOptions,
+                                           CUjit_option *Options,
+                                           void **OptionValues,
+                                           CUlinkState *StateOut);
 static CuLinkCreateFcnTy *CuLinkCreateFcnPtr;
 
-typedef CUresult CUDAAPI CuLinkCompleteFcnTy(CUlinkState state, void **cubinOut,
-                                             size_t *sizeOut);
+typedef CUresult CUDAAPI CuLinkCompleteFcnTy(CUlinkState State, void **CubinOut,
+                                             size_t *SizeOut);
 static CuLinkCompleteFcnTy *CuLinkCompleteFcnPtr;
 
-typedef CUresult CUDAAPI CuLinkDestroyFcnTy(CUlinkState state);
+typedef CUresult CUDAAPI CuLinkDestroyFcnTy(CUlinkState State);
 static CuLinkDestroyFcnTy *CuLinkDestroyFcnPtr;
 
 typedef CUresult CUDAAPI CuCtxSynchronizeFcnTy();
 static CuCtxSynchronizeFcnTy *CuCtxSynchronizeFcnPtr;
 
 /* Type-defines of function pointer ot CUDA runtime APIs. */
 typedef cudaError_t CUDARTAPI CudaThreadSynchronizeFcnTy(void);
 static CudaThreadSynchronizeFcnTy *CudaThreadSynchronizeFcnPtr;
 
-static void *getAPIHandle(void *Handle, const char *FuncName) {
+static void *getAPIHandleCUDA(void *Handle, const char *FuncName) {
   char *Err;
   void *FuncPtr;
   dlerror();
   FuncPtr = dlsym(Handle, FuncName);
   if ((Err = dlerror()) != 0) {
     fprintf(stdout, "Load CUDA driver API failed: %s. \n", Err);
     return 0;
   }
   return FuncPtr;
 }
 
-static int initialDeviceAPILibraries() {
+static int initialDeviceAPILibrariesCUDA() {
   HandleCuda = dlopen("libcuda.so", RTLD_LAZY);
   if (!HandleCuda) {
     printf("Cannot open library: %s. \n", dlerror());
     return 0;
   }
 
   HandleCudaRT = dlopen("libcudart.so", RTLD_LAZY);
   if (!HandleCudaRT) {
     printf("Cannot open library: %s. \n", dlerror());
     return 0;
   }
 
   return 1;
 }
 
-static int initialDeviceAPIs() {
-  if (initialDeviceAPILibraries() == 0)
+static int initialDeviceAPIsCUDA() {
+  if (initialDeviceAPILibrariesCUDA() == 0)
     return 0;
 
   /* Get function pointer to CUDA Driver APIs.
    *
    * Note that compilers conforming to the ISO C standard are required to
    * generate a warning if a conversion from a void * pointer to a function
    * pointer is attempted as in the following statements. The warning
    * of this kind of cast may not be emitted by clang and new versions of gcc
    * as it is valid on POSIX 2008.
    */
   CuLaunchKernelFcnPtr =
-      (CuLaunchKernelFcnTy *)getAPIHandle(HandleCuda, "cuLaunchKernel");
+      (CuLaunchKernelFcnTy *)getAPIHandleCUDA(HandleCuda, "cuLaunchKernel");
 
   CuMemAllocFcnPtr =
-      (CuMemAllocFcnTy *)getAPIHandle(HandleCuda, "cuMemAlloc_v2");
+      (CuMemAllocFcnTy *)getAPIHandleCUDA(HandleCuda, "cuMemAlloc_v2");
 
-  CuMemFreeFcnPtr = (CuMemFreeFcnTy *)getAPIHandle(HandleCuda, "cuMemFree_v2");
+  CuMemFreeFcnPtr =
+      (CuMemFreeFcnTy *)getAPIHandleCUDA(HandleCuda, "cuMemFree_v2");
 
   CuMemcpyDtoHFcnPtr =
-      (CuMemcpyDtoHFcnTy *)getAPIHandle(HandleCuda, "cuMemcpyDtoH_v2");
+      (CuMemcpyDtoHFcnTy *)getAPIHandleCUDA(HandleCuda, "cuMemcpyDtoH_v2");
 
   CuMemcpyHtoDFcnPtr =
-      (CuMemcpyHtoDFcnTy *)getAPIHandle(HandleCuda, "cuMemcpyHtoD_v2");
+      (CuMemcpyHtoDFcnTy *)getAPIHandleCUDA(HandleCuda, "cuMemcpyHtoD_v2");
 
   CuModuleUnloadFcnPtr =
-      (CuModuleUnloadFcnTy *)getAPIHandle(HandleCuda, "cuModuleUnload");
+      (CuModuleUnloadFcnTy *)getAPIHandleCUDA(HandleCuda, "cuModuleUnload");
 
   CuCtxDestroyFcnPtr =
-      (CuCtxDestroyFcnTy *)getAPIHandle(HandleCuda, "cuCtxDestroy");
+      (CuCtxDestroyFcnTy *)getAPIHandleCUDA(HandleCuda, "cuCtxDestroy");
 
-  CuInitFcnPtr = (CuInitFcnTy *)getAPIHandle(HandleCuda, "cuInit");
+  CuInitFcnPtr = (CuInitFcnTy *)getAPIHandleCUDA(HandleCuda, "cuInit");
 
   CuDeviceGetCountFcnPtr =
-      (CuDeviceGetCountFcnTy *)getAPIHandle(HandleCuda, "cuDeviceGetCount");
+      (CuDeviceGetCountFcnTy *)getAPIHandleCUDA(HandleCuda, "cuDeviceGetCount");
 
   CuDeviceGetFcnPtr =
-      (CuDeviceGetFcnTy *)getAPIHandle(HandleCuda, "cuDeviceGet");
+      (CuDeviceGetFcnTy *)getAPIHandleCUDA(HandleCuda, "cuDeviceGet");
 
   CuCtxCreateFcnPtr =
-      (CuCtxCreateFcnTy *)getAPIHandle(HandleCuda, "cuCtxCreate_v2");
+      (CuCtxCreateFcnTy *)getAPIHandleCUDA(HandleCuda, "cuCtxCreate_v2");
 
-  CuModuleLoadDataExFcnPtr =
-      (CuModuleLoadDataExFcnTy *)getAPIHandle(HandleCuda, "cuModuleLoadDataEx");
+  CuModuleLoadDataExFcnPtr = (CuModuleLoadDataExFcnTy *)getAPIHandleCUDA(
+      HandleCuda, "cuModuleLoadDataEx");
 
   CuModuleLoadDataFcnPtr =
-      (CuModuleLoadDataFcnTy *)getAPIHandle(HandleCuda, "cuModuleLoadData");
+      (CuModuleLoadDataFcnTy *)getAPIHandleCUDA(HandleCuda, "cuModuleLoadData");
 
-  CuModuleGetFunctionFcnPtr = (CuModuleGetFunctionFcnTy *)getAPIHandle(
+  CuModuleGetFunctionFcnPtr = (CuModuleGetFunctionFcnTy *)getAPIHandleCUDA(
       HandleCuda, "cuModuleGetFunction");
 
   CuDeviceComputeCapabilityFcnPtr =
-      (CuDeviceComputeCapabilityFcnTy *)getAPIHandle(
+      (CuDeviceComputeCapabilityFcnTy *)getAPIHandleCUDA(
           HandleCuda, "cuDeviceComputeCapability");
 
   CuDeviceGetNameFcnPtr =
-      (CuDeviceGetNameFcnTy *)getAPIHandle(HandleCuda, "cuDeviceGetName");
+      (CuDeviceGetNameFcnTy *)getAPIHandleCUDA(HandleCuda, "cuDeviceGetName");
 
   CuLinkAddDataFcnPtr =
-      (CuLinkAddDataFcnTy *)getAPIHandle(HandleCuda, "cuLinkAddData");
+      (CuLinkAddDataFcnTy *)getAPIHandleCUDA(HandleCuda, "cuLinkAddData");
 
   CuLinkCreateFcnPtr =
-      (CuLinkCreateFcnTy *)getAPIHandle(HandleCuda, "cuLinkCreate");
+      (CuLinkCreateFcnTy *)getAPIHandleCUDA(HandleCuda, "cuLinkCreate");
 
   CuLinkCompleteFcnPtr =
-      (CuLinkCompleteFcnTy *)getAPIHandle(HandleCuda, "cuLinkComplete");
+      (CuLinkCompleteFcnTy *)getAPIHandleCUDA(HandleCuda, "cuLinkComplete");
 
   CuLinkDestroyFcnPtr =
-      (CuLinkDestroyFcnTy *)getAPIHandle(HandleCuda, "cuLinkDestroy");
+      (CuLinkDestroyFcnTy *)getAPIHandleCUDA(HandleCuda, "cuLinkDestroy");
 
   CuCtxSynchronizeFcnPtr =
-      (CuCtxSynchronizeFcnTy *)getAPIHandle(HandleCuda, "cuCtxSynchronize");
+      (CuCtxSynchronizeFcnTy *)getAPIHandleCUDA(HandleCuda, "cuCtxSynchronize");
 
   /* Get function pointer to CUDA Runtime APIs. */
-  CudaThreadSynchronizeFcnPtr = (CudaThreadSynchronizeFcnTy *)getAPIHandle(
+  CudaThreadSynchronizeFcnPtr = (CudaThreadSynchronizeFcnTy *)getAPIHandleCUDA(
       HandleCudaRT, "cudaThreadSynchronize");
 
   return 1;
 }
 
-PollyGPUContext *polly_initContext() {
-  DebugMode = getenv("POLLY_DEBUG") != 0;
-
+PollyGPUContext *initContextCUDA() {
   dump_function();
+
   PollyGPUContext *Context;
   CUdevice Device;
 
   int Major = 0, Minor = 0, DeviceID = 0;
   char DeviceName[256];
   int DeviceCount = 0;
 
   static __thread PollyGPUContext *CurrentContext = NULL;
 
   if (CurrentContext)
     return CurrentContext;
 
   /* Get API handles. */
-  if (initialDeviceAPIs() == 0) {
+  if (initialDeviceAPIsCUDA() == 0) {
     fprintf(stdout, "Getting the \"handle\" for the CUDA driver API failed.\n");
     exit(-1);
   }
 
   if (CuInitFcnPtr(0) != CUDA_SUCCESS) {
     fprintf(stdout, "Initializing the CUDA driver API failed.\n");
     exit(-1);
   }
PollyGPUContext *initContextCUDA() {
   debug_print("> Running on GPU device %d : %s.\n", DeviceID, DeviceName);
 
   /* Create context on the device. */
   Context = (PollyGPUContext *)malloc(sizeof(PollyGPUContext));
   if (Context == 0) {
     fprintf(stdout, "Allocate memory for Polly GPU context failed.\n");
     exit(-1);
   }
-  CuCtxCreateFcnPtr(&(Context->Cuda), 0, Device);
-
-  CacheMode = getenv("POLLY_NOCACHE") == 0;
+  Context->Context = malloc(sizeof(CUDAContext));
+  if (Context->Context == 0) {
+    fprintf(stdout, "Allocate memory for Polly CUDA context failed.\n");
+    exit(-1);
+  }
+  CuCtxCreateFcnPtr(&(((CUDAContext *)Context->Context)->Cuda), 0, Device);
 
   if (CacheMode)
     CurrentContext = Context;
 
   return Context;
 }
 
-static void freeKernel(PollyGPUFunction *Kernel) {
-  if (Kernel->CudaModule)
-    CuModuleUnloadFcnPtr(Kernel->CudaModule);
+static void freeKernelCUDA(PollyGPUFunction *Kernel) {
+  dump_function();
+
+  if (CacheMode)
+    return;
+
+  if (((CUDAKernel *)Kernel->Kernel)->CudaModule)
+    CuModuleUnloadFcnPtr(((CUDAKernel *)Kernel->Kernel)->CudaModule);
+
+  if (Kernel->Kernel)
+    free((CUDAKernel *)Kernel->Kernel);
 
   if (Kernel)
     free(Kernel);
 }
 
-#define KERNEL_CACHE_SIZE 10
-
-PollyGPUFunction *polly_getKernel(const char *PTXBuffer,
-                                  const char *KernelName) {
+PollyGPUFunction *getKernelCUDA(const char *BinaryBuffer,
   dump_function();
 
   static __thread PollyGPUFunction *KernelCache[KERNEL_CACHE_SIZE];
   static __thread int NextCacheItem = 0;
 
   for (long i = 0; i < KERNEL_CACHE_SIZE; i++) {
     // We exploit here the property that all Polly-ACC kernels are allocated
     // as global constants, hence a pointer comparision is sufficient to
     // determin equality.
-    if (KernelCache[i] && KernelCache[i]->PTXString == PTXBuffer) {
+    if (KernelCache[i] &&
+        ((CUDAKernel *)KernelCache[i]->Kernel)->BinaryString == BinaryBuffer) {
       debug_print("  -> using cached kernel\n");
       return KernelCache[i];
     }
   }
 
   PollyGPUFunction *Function = malloc(sizeof(PollyGPUFunction));
-
   if (Function == 0) {
     fprintf(stdout, "Allocate memory for Polly GPU function failed.\n");
     exit(-1);
   }
+  Function->Kernel = (CUDAKernel *)malloc(sizeof(CUDAKernel));
+  if (Function->Kernel == 0) {
+    fprintf(stdout, "Allocate memory for Polly CUDA function failed.\n");
+    exit(-1);
+  }
 
   CUresult Res;
   CUlinkState LState;
   CUjit_option Options[6];
   void *OptionVals[6];
   float Walltime = 0;
   unsigned long LogSize = 8192;
   char ErrorLog[8192], InfoLog[8192];
PollyGPUFunction *getKernelCUDA(const char *BinaryBuffer,
   OptionVals[4] = (void *)LogSize;
   // Make the linker verbose
   Options[5] = CU_JIT_LOG_VERBOSE;
   OptionVals[5] = (void *)1;
 
   memset(ErrorLog, 0, sizeof(ErrorLog));
 
   CuLinkCreateFcnPtr(6, Options, OptionVals, &LState);
-  Res = CuLinkAddDataFcnPtr(LState, CU_JIT_INPUT_PTX, (void *)PTXBuffer,
-                            strlen(PTXBuffer) + 1, 0, 0, 0, 0);
+  Res = CuLinkAddDataFcnPtr(LState, CU_JIT_INPUT_PTX, (void *)BinaryBuffer,
+                            strlen(BinaryBuffer) + 1, 0, 0, 0, 0);
   if (Res != CUDA_SUCCESS) {
     fprintf(stdout, "PTX Linker Error:\n%s\n%s", ErrorLog, InfoLog);
     exit(-1);
   }
 
   Res = CuLinkCompleteFcnPtr(LState, &CuOut, &OutSize);
   if (Res != CUDA_SUCCESS) {
     fprintf(stdout, "Complete ptx linker step failed.\n");
     fprintf(stdout, "\n%s\n", ErrorLog);
     exit(-1);
   }
 
   debug_print("CUDA Link Completed in %fms. Linker Output:\n%s\n", Walltime,
               InfoLog);
 
-  Res = CuModuleLoadDataFcnPtr(&(Function->CudaModule), CuOut);
+  Res = CuModuleLoadDataFcnPtr(&(((CUDAKernel *)Function->Kernel)->CudaModule),
+                               CuOut);
   if (Res != CUDA_SUCCESS) {
     fprintf(stdout, "Loading ptx assembly text failed.\n");
     exit(-1);
   }
 
-  Res = CuModuleGetFunctionFcnPtr(&(Function->Cuda), Function->CudaModule,
+  Res = CuModuleGetFunctionFcnPtr(&(((CUDAKernel *)Function->Kernel)->Cuda),
+                                  ((CUDAKernel *)Function->Kernel)->CudaModule,
                                   KernelName);
   if (Res != CUDA_SUCCESS) {
     fprintf(stdout, "Loading kernel function failed.\n");
     exit(-1);
   }
 
   CuLinkDestroyFcnPtr(LState);
 
-  Function->PTXString = PTXBuffer;
+  ((CUDAKernel *)Function->Kernel)->BinaryString = BinaryBuffer;
 
   if (CacheMode) {
     if (KernelCache[NextCacheItem])
-      freeKernel(KernelCache[NextCacheItem]);
+      freeKernelCUDA(KernelCache[NextCacheItem]);
 
     KernelCache[NextCacheItem] = Function;
 
     NextCacheItem = (NextCacheItem + 1) % KERNEL_CACHE_SIZE;
   }
 
   return Function;
 }
 
-void polly_freeKernel(PollyGPUFunction *Kernel) {
+void synchronizeDeviceCUDA() {
   dump_function();
-
-  if (CacheMode)
-    return;
-
-  freeKernel(Kernel);
+  if (CuCtxSynchronizeFcnPtr() != CUDA_SUCCESS) {
+    fprintf(stdout, "Synchronizing device and host memory failed.\n");
+    exit(-1);
+  }
 }
 
-void polly_copyFromHostToDevice(void *HostData, PollyGPUDevicePtr *DevData,
-                                long MemSize) {
+void copyFromHostToDeviceCUDA(void *HostData, PollyGPUDevicePtr *DevData,
   dump_function();
 
-  CUdeviceptr CuDevData = DevData->Cuda;
+  CUdeviceptr CuDevData = ((CUDADevicePtr *)DevData->DevicePtr)->Cuda;
   CuMemcpyHtoDFcnPtr(CuDevData, HostData, MemSize);
 }
 
-void polly_copyFromDeviceToHost(PollyGPUDevicePtr *DevData, void *HostData,
-                                long MemSize) {
+void copyFromDeviceToHostCUDA(PollyGPUDevicePtr *DevData, void *HostData,
   dump_function();
 
-  if (CuMemcpyDtoHFcnPtr(HostData, DevData->Cuda, MemSize) != CUDA_SUCCESS) {
+  if (CuMemcpyDtoHFcnPtr(HostData, ((CUDADevicePtr *)DevData->DevicePtr)->Cuda,
+                         MemSize) != CUDA_SUCCESS) {
     fprintf(stdout, "Copying results from device to host memory failed.\n");
     exit(-1);
   }
 }
-void polly_synchronizeDevice() {
-  dump_function();
-  if (CuCtxSynchronizeFcnPtr() != CUDA_SUCCESS) {
-    fprintf(stdout, "Synchronizing device and host memory failed.\n");
-    exit(-1);
-  }
-}
 
-void polly_launchKernel(PollyGPUFunction *Kernel, unsigned int GridDimX,
-                        unsigned int GridDimY, unsigned int BlockDimX,
-                        unsigned int BlockDimY, unsigned int BlockDimZ,
-                        void **Parameters) {
+void launchKernelCUDA(PollyGPUFunction *Kernel, unsigned int GridDimX,
   dump_function();
 
   unsigned GridDimZ = 1;
   unsigned int SharedMemBytes = CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE;
   CUstream Stream = 0;
   void **Extra = 0;
 
   CUresult Res;
-  Res = CuLaunchKernelFcnPtr(Kernel->Cuda, GridDimX, GridDimY, GridDimZ,
-                             BlockDimX, BlockDimY, BlockDimZ, SharedMemBytes,
-                             Stream, Parameters, Extra);
+  Res =
+      CuLaunchKernelFcnPtr(((CUDAKernel *)Kernel->Kernel)->Cuda, GridDimX,
+                           GridDimY, GridDimZ, BlockDimX, BlockDimY, BlockDimZ,
+                           SharedMemBytes, Stream, Parameters, Extra);
   if (Res != CUDA_SUCCESS) {
     fprintf(stdout, "Launching CUDA kernel failed.\n");
     exit(-1);
   }
 }
 
-void polly_freeDeviceMemory(PollyGPUDevicePtr *Allocation) {
+void freeDeviceMemoryCUDA(PollyGPUDevicePtr *Allocation) {
   dump_function();
-  CuMemFreeFcnPtr((CUdeviceptr)Allocation->Cuda);
+  CUDADevicePtr *DevPtr = (CUDADevicePtr *)Allocation->DevicePtr;
+  CuMemFreeFcnPtr((CUdeviceptr)DevPtr->Cuda);
+  free(DevPtr);
   free(Allocation);
 }
 
-PollyGPUDevicePtr *polly_allocateMemoryForDevice(long MemSize) {
+PollyGPUDevicePtr *allocateMemoryForDeviceCUDA(long MemSize) {
   dump_function();
 
   PollyGPUDevicePtr *DevData = malloc(sizeof(PollyGPUDevicePtr));
-
   if (DevData == 0) {
     fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
     exit(-1);
   }
+  DevData->DevicePtr = (CUDADevicePtr *)malloc(sizeof(CUDADevicePtr));
+  if (DevData->DevicePtr == 0) {
+    fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
+    exit(-1);
+  }
 
-  CUresult Res = CuMemAllocFcnPtr(&(DevData->Cuda), MemSize);
+  CUresult Res =
+      CuMemAllocFcnPtr(&(((CUDADevicePtr *)DevData->DevicePtr)->Cuda), MemSize);
 
   if (Res != CUDA_SUCCESS) {
     fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
     exit(-1);
   }
 
   return DevData;
 }
 
+void *getDevicePtrCUDA(PollyGPUDevicePtr *Allocation) {
+  dump_function();
+
+  CUDADevicePtr *DevPtr = (CUDADevicePtr *)Allocation->DevicePtr;
+  return (void *)DevPtr->Cuda;
+}
+
+void freeContextCUDA(PollyGPUContext *Context) {
+  dump_function();
+
+  CUDAContext *Ctx = (CUDAContext *)Context->Context;
+  if (Ctx->Cuda) {
+    CuCtxDestroyFcnPtr(Ctx->Cuda);
+    free(Ctx);
+    free(Context);
+  }
+
+  dlclose(HandleCuda);
+  dlclose(HandleCudaRT);
+}
+
+#endif /* HAS_LIBCUDART */
+/******************************************************************************/
+/*                                    API                                     */
+/******************************************************************************/
+
+PollyGPUContext *polly_initContext() {
+  DebugMode = getenv("POLLY_DEBUG") != 0;
+  CacheMode = getenv("POLLY_NOCACHE") == 0;
+
+  dump_function();
+
+  PollyGPUContext *Context;
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    Context = initContextCUDA();
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    Context = initContextCL();
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+
+  return Context;
+}
+
+void polly_freeKernel(PollyGPUFunction *Kernel) {
+  dump_function();
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    freeKernelCUDA(Kernel);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    freeKernelCL(Kernel);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+}
+
+PollyGPUFunction *polly_getKernel(const char *BinaryBuffer,
+                                  const char *KernelName) {
+  dump_function();
+
+  PollyGPUFunction *Function;
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    Function = getKernelCUDA(BinaryBuffer, KernelName);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    Function = getKernelCL(BinaryBuffer, KernelName);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+
+  return Function;
+}
+
+void polly_copyFromHostToDevice(void *HostData, PollyGPUDevicePtr *DevData,
+                                long MemSize) {
+  dump_function();
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    copyFromHostToDeviceCUDA(HostData, DevData, MemSize);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    copyFromHostToDeviceCL(HostData, DevData, MemSize);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+}
+
+void polly_copyFromDeviceToHost(PollyGPUDevicePtr *DevData, void *HostData,
+                                long MemSize) {
+  dump_function();
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    copyFromDeviceToHostCUDA(DevData, HostData, MemSize);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    copyFromDeviceToHostCL(DevData, HostData, MemSize);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+}
+
+void polly_launchKernel(PollyGPUFunction *Kernel, unsigned int GridDimX,
+                        unsigned int GridDimY, unsigned int BlockDimX,
+                        unsigned int BlockDimY, unsigned int BlockDimZ,
+                        void **Parameters) {
+  dump_function();
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    launchKernelCUDA(Kernel, GridDimX, GridDimY, BlockDimX, BlockDimY,
+                     BlockDimZ, Parameters);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    launchKernelCL(Kernel, GridDimX, GridDimY, BlockDimX, BlockDimY, BlockDimZ,
+                   Parameters);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+}
+
+void polly_freeDeviceMemory(PollyGPUDevicePtr *Allocation) {
+  dump_function();
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    freeDeviceMemoryCUDA(Allocation);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    freeDeviceMemoryCL(Allocation);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+}
+
+PollyGPUDevicePtr *polly_allocateMemoryForDevice(long MemSize) {
+  dump_function();
+
+  PollyGPUDevicePtr *DevData;
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    DevData = allocateMemoryForDeviceCUDA(MemSize);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    DevData = allocateMemoryForDeviceCL(MemSize);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+
+  return DevData;
+}
+
 void *polly_getDevicePtr(PollyGPUDevicePtr *Allocation) {
   dump_function();
 
-  return (void *)Allocation->Cuda;
+  void *DevPtr;
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    DevPtr = getDevicePtrCUDA(Allocation);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    DevPtr = getDevicePtrCL(Allocation);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
+
+  return DevPtr;
+}
+
+void polly_synchronizeDevice() {
+  dump_function();
+
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    synchronizeDeviceCUDA();
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    synchronizeDeviceCL();
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
 }
 
 void polly_freeContext(PollyGPUContext *Context) {
   dump_function();
 
   if (CacheMode)
     return;
 
-  if (Context->Cuda) {
-    CuCtxDestroyFcnPtr(Context->Cuda);
-    free(Context);
-  }
+  switch (Runtime) {
+#ifdef HAS_LIBCUDART
+  case RUNTIME_CUDA:
+    freeContextCUDA(Context);
+    break;
+#endif /* HAS_LIBCUDART */
+#ifdef HAS_LIBOPENCL
+  case RUNTIME_CL:
+    freeContextCL(Context);
+    break;
+#endif /* HAS_LIBOPENCL */
+  default:
+    err_runtime();
+  }
 
-  dlclose(HandleCuda);
-  dlclose(HandleCudaRT);
+/* Initialize GPUJIT with CUDA as runtime library. */
+PollyGPUContext *polly_initContextCUDA() {
+#ifdef HAS_LIBCUDART
+  Runtime = RUNTIME_CUDA;
+  return polly_initContext();
+#else
+  fprintf(stdout, "GPU Runtime was built without CUDA support.\n");
+  exit(-1);
+#endif /* HAS_LIBCUDART */
+}
+
+/* Initialize GPUJIT with OpenCL as runtime library. */
+PollyGPUContext *polly_initContextCL() {
+#ifdef HAS_LIBOPENCL
+  Runtime = RUNTIME_CL;
+  return polly_initContext();
+#else
+  fprintf(stdout, "GPU Runtime was built without OpenCL support.\n");
+  exit(-1);
+#endif /* HAS_LIBOPENCL */
 }