SkelCL – A Skeleton Library for Heterogeneous Systems

SkelCL is a library providing high-level abstractions to alleviate programming of modern parallel heterogeneous systems comprising of multi-core CPUs and GPUs.

It is built on top of the OpenCL standard and offers pre-implemented recurring computation and communication patterns (called skeletons) which greatly simplify parallel programming.

SkelCL is a research project currently developed by Michel Steuwer and others at the research group parallel and distributed systems at the University of Münster, Germany.

Learn more » Get SkelCL »

#include <SkelCL/SkelCL.h>
#include <SkelCL/Zip.h>
#include <SkelCL/Reduce.h>
#include <SkelCL/Vector.h>
using namespace skelcl;
int main() {
  skelcl::init(); // initialize SkelCL

  // specify calculations using parallel patterns (skeletons):
  Zip<int(int,int)> mult("int func(int x, int y){ return x*y; }");
  Reduce<int(int)>   sum("int func(int x, int y){ return x+y; }", "0");

  Vector<int> A(1024);      Vector<int> B(1024); // create and fill vectors
  init(A.begin(), A.end()); init(B.begin(), B.end());

  Vector<int> C = sum( mult(A, B) ); // perform calculation in parallel

  std::cout << "Dot product: " << C.front() << std::endl; // access result
}

Computation of the dot product of two vectors using SkelCL

About SkelCL

SkelCL is a library providing high-level abstractions for alleviated programming of modern parallel heterogeneous systems.

Programming modern heterogeneous systems comprising of multi-core CPUs, GPUs, etc. is complex and error-prone. Existing programming approaches, like CUDA or OpenCL, are intrinsically low-level. Handling of multiple compute devices is complicated and requires manually data movement between them.

The SkelCL library is built on top of the OpenCL standard and offers pre-implemented recurring computation and communication patterns (called skeletons) which greatly simplify programming for modern heterogeneous systems.

The library also provides an abstract vector data type and a high-level data (re)distribution mechanism to shield the programmer from the low-level data transfers between the system's main memory and multiple compute devices.

SkelCL is a research project currently developed by Michel Steuwer and others at the research group parallel and distributed systems at University of Münster which is located in Germany.

Getting SkelCL

The source code of SkelCL is available at Gitub: https://github.com/skelcl/skelcl. Instructions for building SkelCL can be found at https://github.com/skelcl/skelcl/wiki. SkelCL has been build and tested successfully on recent Ubuntu systems, Mac OS X Mavericks as well as Windows 7 and 8. A set of examples can be found in the examples folder. If you have trouble building or using SkelCL feel free to contact the author Michel Steuwer.

Documentation

A documentation of SkelCL is available at http://skelcl.uni-muenster.de/doc.

Licensing

SkelCL is available under multiple licenses. The licenses are GPLv3 as well as a less restrictive license for non-commercial academic use. If you are interested in using SkelCL under different license terms please contact the author Michel Steuwer. For more details about the licensing please see the LICENSE.txt file.

Examples

#include <SkelCL/SkelCL.h>
#include <SkelCL/Zip.h>
#include <SkelCL/Reduce.h>
#include <SkelCL/vector.h>
using namespace skelcl;
int main() {
  skelcl::init(); // initialize skelcl

  // specify calculations using parallel patterns (skeletons):
  Zip<int(int,int)> mult("int func(int x, int y){ return x*y; }");
  Reduce<int(int)>   sum("int func(int x, int y){ return x+y; }", "0");

  Vector<int> a(1024);      Vector<int> b(1024); // create and fill vectors
  init(a.begin(), a.end()); init(b.begin(), b.end());

  Vector<int> c = sum( mult(a, b) ); // perform calculation in parallel

  std::cout << "dot product: " << c.front() << std::endl; // access result
}

Computation of the dot product of two vectors using SkelCL

#include <SkelCL/SkelCL.h>
#include <SkelCL/Zip.h>
#include <SkelCL/Vector.h>
using namespace skelcl;
int main() {
  skelcl::init(); // initialize skelcl

  // specify saxpy calculations using the zip skeleton:
  Zip<float(float,float)> saxpy("float func(float x, float y, float a){ return a*x + y; }");

  Vector<float> X(1024);      Vector<float> Y(1024); // create and fill vectors
  init(X.begin(), X.end()); init(Y.begin(), Y.end());
  float a = 2.5f;

 // pass a as an additional argument to the skeleton and store the result back in Y
  saxpy( out(Y), X, Y, a );

  print(Y.begin(), Y.end()); // access result
}

BLAS saxpy Computation using SkelCL

#include <SkelCL/SkelCL.h>
#include <SkelCL/AllPairs.h>
#include <SkelCL/Matrix.h>
using namespace skelcl;
int main() {
  skelcl::init(); // initialize skelcl

  // specify building blocks of the dot product (the zip and reduce skeletons):
  Zip<float(float,float)> mult("float func(float x, float y){ return x*y; }");
  Reduce<float(float)>     sum("float func(float x, float y){ return x+y; }", "0.0f");

  // create allpairs skeleton customized with the building blocks of the dot product:
  Allpairs<float(float,float)> mm(sum, mult);

  // create and fill matrices
  Matrix<float> A(N, D); init(A.begin(), A.end());
  Matrix<float> B(D, M); init(B.begin(), B.end());

  auto C = mm( A, B ); // perform matrix multiplication in parallel

  print(C.begin(), C.end()); // print result
}

Matrix multiplication computation using SkelCL

‹ ›

Publications

2014:

2013:

2012:

2011:

M. Steuwer, P. Kegel, and S. Gorlatch: SkelCL - A Portable Skeleton Library for High-Level GPU Programming. In 2011 IEEE International Symposium on Parallel and Distributed Processing Workshop and Phd Forum (IPDPSW), Anchorage, USA, 2011.

Contact

Michel Steuwer
michel.steuwer@uni-muenster.de