Merge branch 'development' into embb609_doxygen_warnings

CMakeLists.txt

@@ -30,6 +30,8 @@ set (EMBB_BASE_VERSION_MAJOR 0)
 set (EMBB_BASE_VERSION_MINOR 4)
 set (EMBB_BASE_VERSION_PATCH 0)
 
+include(FindCUDA)
+
 # Fix compilation for CMake versions >= 3.1
 #
 # New Policy 0054:
@@ -143,6 +145,9 @@ set(EXPECTED_EMBB_TEST_EXECUTABLES "embb_algorithms_cpp_test"
 if(BUILD_OPENCL_PLUGIN STREQUAL ON)
   list(APPEND EXPECTED_EMBB_TEST_EXECUTABLES "embb_mtapi_opencl_c_test")
 endif()
+if(CUDA_FOUND)
+  list(APPEND EXPECTED_EMBB_TEST_EXECUTABLES "embb_mtapi_cuda_c_test")
+endif()
 
 
 ## Copy test execution script to local binaries folder
@@ -179,6 +184,9 @@ add_subdirectory(mtapi_plugins_c/mtapi_network_c)
 if(BUILD_OPENCL_PLUGIN STREQUAL ON)
   add_subdirectory(mtapi_plugins_c/mtapi_opencl_c)
 endif()
+if(CUDA_FOUND)
+  add_subdirectory(mtapi_plugins_c/mtapi_cuda_c)
+endif()
 add_subdirectory(mtapi_cpp)
 add_subdirectory(containers_cpp)
 add_subdirectory(algorithms_cpp)

algorithms_cpp/include/embb/algorithms/internal/quick_sort-inl.h

@@ -29,8 +29,9 @@
 
 #include <cassert>
 #include <iterator>
-#include <algorithm>
 #include <functional>
+#include <utility>   // swap C++ 11
+#include <algorithm> // swap C++ 98
 
 #include <embb/base/exceptions.h>
 #include <embb/mtapi/mtapi.h>

base_c/include/embb/base/c/thread.h

@@ -57,6 +57,19 @@ typedef opaque_type embb_thread_t;
 #endif /* DOXYGEN */
 
 /**
+ * Thread priority type.
+ */
+typedef enum {
+  EMBB_THREAD_PRIORITY_IDLE,
+  EMBB_THREAD_PRIORITY_LOWEST,
+  EMBB_THREAD_PRIORITY_BELOW_NORMAL,
+  EMBB_THREAD_PRIORITY_NORMAL,
+  EMBB_THREAD_PRIORITY_ABOVE_NORMAL,
+  EMBB_THREAD_PRIORITY_HIGHEST,
+  EMBB_THREAD_PRIORITY_TIME_CRITICAL
+} embb_thread_priority_t;
+
+/**
  * Thread start function pointer type.
  *
  * The return value can be used to return a user-defined exit code when the
@@ -123,7 +136,7 @@ void embb_thread_yield();
  * Creates and runs a thread.
  *
  * \pre The given thread is not running and has not yet been successfully
-        joined.
+ *      joined.
  * \post On success, the given thread has started to run.
  * \return EMBB_SUCCESS if the thread could be created. \n
  *         EMBB_NOMEM if there was insufficient amount of memory \n
@@ -148,6 +161,36 @@ int embb_thread_create(
   );
 
 /**
+ * Creates and runs a thread.
+ *
+ * \pre The given thread is not running and has not yet been successfully
+ *      joined.
+ * \post On success, the given thread has started to run.
+ * \return EMBB_SUCCESS if the thread could be created. \n
+ *         EMBB_NOMEM if there was insufficient amount of memory \n
+ *         EMBB_ERROR otherwise.
+ * \memory Dynamically allocates a small constant amount of memory to store the
+ *         function and argument pointers. This memory is freed when the thread
+ *         is joined.
+ * \notthreadsafe
+ * \see embb_thread_join()
+ */
+int embb_thread_create_with_priority(
+  embb_thread_t* thread,
+  /**< [OUT] Thread to be run */
+  const embb_core_set_t* core_set,
+  /**< [IN] Set of cores on which the thread shall be executed. Can be NULL to
+            indicate automatic thread scheduling by the OS. */
+  embb_thread_priority_t priority,
+  /**< [IN] Priority to run the thread at. */
+  embb_thread_start_t function,
+  /**< [IN] Function which is executed by the thread when started. Has to be of
+            type embb_thread_start_t. */
+  void* arg
+  /**< [IN/OUT] Argument to thread start function. Can be NULL. */
+  );
+
+/**
  * Waits until the given thread has finished execution.
  *
  * \pre The given thread has been successfully created using

base_c/src/thread.c

@@ -40,6 +40,15 @@ void embb_thread_set_max_count(unsigned int max) {
   embb_internal_thread_index_set_max(max);
 }
 
+int embb_thread_create(
+  embb_thread_t* thread,
+  const embb_core_set_t* core_set,
+  embb_thread_start_t func,
+  void *arg) {
+  return embb_thread_create_with_priority(thread, core_set,
+    EMBB_THREAD_PRIORITY_NORMAL, func, arg);
+}
+
 #ifdef EMBB_PLATFORM_THREADING_WINTHREADS
 
 /**
@@ -78,8 +87,12 @@ void embb_thread_yield() {
   SwitchToThread();
 }
 
-int embb_thread_create(embb_thread_t* thread, const embb_core_set_t* core_set,
-                       embb_thread_start_t func, void *arg) {
+int embb_thread_create_with_priority(
+  embb_thread_t* thread,
+  const embb_core_set_t* core_set,
+  embb_thread_priority_t priority,
+  embb_thread_start_t func,
+  void *arg) {
   if (thread == NULL) {
     return EMBB_ERROR;
   }
@@ -121,6 +134,37 @@ int embb_thread_create(embb_thread_t* thread, const embb_core_set_t* core_set,
     }
   }
 
+  int internal_priority;
+  switch (priority) {
+  case EMBB_THREAD_PRIORITY_IDLE:
+    internal_priority = THREAD_PRIORITY_IDLE;
+    break;
+  case EMBB_THREAD_PRIORITY_LOWEST:
+    internal_priority = THREAD_PRIORITY_LOWEST;
+    break;
+  case EMBB_THREAD_PRIORITY_BELOW_NORMAL:
+    internal_priority = THREAD_PRIORITY_BELOW_NORMAL;
+    break;
+  case EMBB_THREAD_PRIORITY_ABOVE_NORMAL:
+    internal_priority = THREAD_PRIORITY_ABOVE_NORMAL;
+    break;
+  case EMBB_THREAD_PRIORITY_HIGHEST:
+    internal_priority = THREAD_PRIORITY_HIGHEST;
+    break;
+  case EMBB_THREAD_PRIORITY_TIME_CRITICAL:
+    internal_priority = THREAD_PRIORITY_TIME_CRITICAL;
+    break;
+  case EMBB_THREAD_PRIORITY_NORMAL:
+  default:
+    internal_priority = THREAD_PRIORITY_NORMAL;
+    break;
+  }
+  BOOL result = SetThreadPriority(
+    thread->embb_internal_handle, internal_priority);
+  if (result == 0) {
+    return EMBB_ERROR;
+  }
+
   return EMBB_SUCCESS;
 }
 
@@ -180,12 +224,18 @@ int embb_thread_equal(const embb_thread_t* lhs, const embb_thread_t* rhs) {
 #include <sys/sysinfo.h> /* Used to get number of processors */
 #endif /* EMBB_PLATFORM_HAS_HEADER_SYSINFO */
 
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
 /**
  * Used to wrap client thread start function and argument when calling internal
  * thread start function embb_internal_thread_start.
  */
 typedef struct embb_internal_thread_arg_t {
   embb_thread_start_t func;
+  int priority;
   void* arg;
   int result;
 } embb_internal_thread_arg_t;
@@ -197,6 +247,12 @@ typedef struct embb_internal_thread_arg_t {
  * argument.
  */
 void* embb_internal_thread_start(void* internalArg) {
+#ifdef EMBB_PLATFORM_HAS_GLIB_CPU
+  pid_t tid;
+  tid = syscall(SYS_gettid);
+  setpriority(PRIO_PROCESS, tid,
+    ((embb_internal_thread_arg_t*)internalArg)->priority);
+#endif
   ((embb_internal_thread_arg_t*)internalArg)->result =
       ((embb_internal_thread_arg_t*)internalArg)->func(
       ((struct embb_internal_thread_arg_t*)internalArg)->arg);
@@ -214,8 +270,12 @@ void embb_thread_yield() {
   pthread_yield();
 }
 
-int embb_thread_create(embb_thread_t* thread, const embb_core_set_t* core_set,
-                       embb_thread_start_t func, void* arg) {
+int embb_thread_create_with_priority(
+  embb_thread_t* thread,
+  const embb_core_set_t* core_set,
+  embb_thread_priority_t priority,
+  embb_thread_start_t func,
+  void* arg) {
   if (thread == NULL) {
     return EMBB_ERROR;
   }
@@ -261,6 +321,31 @@ int embb_thread_create(embb_thread_t* thread, const embb_core_set_t* core_set,
   thread->embb_internal_arg->func = func;
   thread->embb_internal_arg->arg = arg;
 
+  switch (priority) {
+  case EMBB_THREAD_PRIORITY_IDLE:
+    thread->embb_internal_arg->priority = 19;
+    break;
+  case EMBB_THREAD_PRIORITY_LOWEST:
+    thread->embb_internal_arg->priority = 2;
+    break;
+  case EMBB_THREAD_PRIORITY_BELOW_NORMAL:
+    thread->embb_internal_arg->priority = 1;
+    break;
+  case EMBB_THREAD_PRIORITY_ABOVE_NORMAL:
+    thread->embb_internal_arg->priority = -1;
+    break;
+  case EMBB_THREAD_PRIORITY_HIGHEST:
+    thread->embb_internal_arg->priority = -2;
+    break;
+  case EMBB_THREAD_PRIORITY_TIME_CRITICAL:
+    thread->embb_internal_arg->priority = -19;
+    break;
+  case EMBB_THREAD_PRIORITY_NORMAL:
+  default:
+    thread->embb_internal_arg->priority = 0;
+    break;
+  }
+
   status = pthread_create(
       &(thread->embb_internal_handle),     /* pthread handle */
       &attr,                               /* additional attributes,

base_cpp/include/embb/base/internal/mutex-inl.h

@@ -28,7 +28,8 @@
 #define EMBB_BASE_INTERNAL_MUTEX_INL_H_
 
 #include <cassert>
-#include <algorithm>
+#include <utility>   // swap C++ 11
+#include <algorithm> // swap C++ 98
 
 namespace embb {
 namespace base {

base_cpp/include/embb/base/internal/thread-inl.h

@@ -28,7 +28,6 @@
 #define EMBB_BASE_INTERNAL_THREAD_INL_H_
 
 #include <embb/base/exceptions.h>
-#include <embb/base/c/thread.h>
 #include <embb/base/internal/thread_closures.h>
 #include <embb/base/memory_allocation.h>
 #include <iostream>
@@ -60,6 +59,22 @@ Thread::Thread(CoreSet& core_set, Function function) : rep_() {
   CheckThreadCreationErrors(result, closure);
 }
 
+template<typename Function>
+Thread::Thread(
+  CoreSet& core_set,
+  embb_thread_priority_t priority,
+  Function function) : rep_() {
+  typedef internal::ThreadClosure<Function> Closure;
+  Closure* closure = Allocation::New<Closure>(function);
+  int result = embb_thread_create_with_priority(
+    &rep_,
+    &core_set.rep_,
+    priority,
+    internal::ThreadClosure<Function>::ThreadStart,
+    static_cast<void*>(closure));
+  CheckThreadCreationErrors(result, closure);
+}
+
 template<typename Function, typename Arg1>
 Thread::Thread(Function function, Arg1 arg1) : rep_() {
   typedef internal::ThreadClosureArg1<Function, Arg1> Closure;

base_cpp/include/embb/base/thread.h

@@ -31,6 +31,7 @@
 #include <embb/base/internal/thread_closures.h>
 #include <embb/base/mutex.h>
 #include <embb/base/core_set.h>
+#include <embb/base/c/thread.h>
 #include <ostream>
 
 namespace embb {
@@ -177,9 +178,33 @@ class Thread {
    * \tparam Function Function object type
    */
   template<typename Function>
-  explicit Thread(
+  Thread(
+    CoreSet& core_set,
+    /**< [IN] Set of cores on which the thread shall be executed. */
+    Function function
+    /**< [IN] Copyable function object, callable without arguments */
+    );
+
+  /**
+   * Creates and runs a thread with zero-argument start function.
+   *
+   * \note If the function is passed as a temporary object when creating a
+   * thread, this might be interpreted as a function declaration ("most vexing
+   * parse"). C++11 resolves this by using curly braces for initialization.
+   *
+   * \throws NoMemoryException if not enough memory is available
+   * \throws ErrorException in case of another error
+   * \memory A small constant amount of memory to store the function. This
+   *         memory is freed the thread is joined.
+   * \notthreadsafe
+   * \tparam Function Function object type
+   */
+  template<typename Function>
+  Thread(
     CoreSet& core_set,
     /**< [IN] Set of cores on which the thread shall be executed. */
+    embb_thread_priority_t priority,
+    /**< [IN] Priority of the new thread. */
     Function function
     /**< [IN] Copyable function object, callable without arguments */
     );

base_cpp/test/log_test.cc

@@ -38,18 +38,17 @@ LogTest::LogTest() {
   CreateUnit("Test all").Add(&LogTest::Test, this);
 }
 
-static std::string logged_message;
-
 static void test_log_function(void * context, char const * msg) {
-  EMBB_UNUSED(context);
-  logged_message = msg;
+  std::string * logged_message = reinterpret_cast<std::string*>(context);
+  *logged_message = msg;
 }
 
 void LogTest::Test() {
   using embb::base::Log;
   char const * test_msg = "hello";
+  std::string logged_message;
 
-  Log::SetLogFunction(0, test_log_function);
+  Log::SetLogFunction(&logged_message, test_log_function);
 
   Log::SetLogLevel(EMBB_LOG_LEVEL_TRACE);
   logged_message = "none";

doc/reference/Doxyfile.in

@@ -153,7 +153,8 @@ INPUT                  = "@CMAKE_SOURCE_DIR@/doc/reference/embb.dox" \
                          "@CMAKE_SOURCE_DIR@/mtapi_c/include" \
                          "@CMAKE_SOURCE_DIR@/base_c/include" \
                          "@CMAKE_SOURCE_DIR@/mtapi_plugins_c/mtapi_opencl_c/include" \
-                         "@CMAKE_SOURCE_DIR@/mtapi_plugins_c/mtapi_network_c/include"
+                         "@CMAKE_SOURCE_DIR@/mtapi_plugins_c/mtapi_network_c/include" \
+                         "@CMAKE_SOURCE_DIR@/mtapi_plugins_c/mtapi_cuda_c/include"
 
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \

mtapi_c/include/embb/mtapi/c/mtapi.h

@@ -244,6 +244,7 @@
 
 #include <stdint.h>
 #include <embb/base/c/core_set.h>
+#include <embb/base/c/thread.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -529,6 +530,96 @@ enum mtapi_notification_enum {
 typedef enum mtapi_notification_enum mtapi_notification_t;
                                        /**< runtime notification */
 
+/**
+ * Enum to select default or specific worker for priority setter
+ */
+enum mtapi_worker_priority_type_enum {
+  MTAPI_WORKER_PRIORITY_END = 0,
+  MTAPI_WORKER_PRIORITY_DEFAULT = 1,
+  MTAPI_WORKER_PRIORITY_WORKER = 100,
+  MTAPI_WORKER_PRIORITY_WORKER_0 = MTAPI_WORKER_PRIORITY_WORKER + 0,
+  MTAPI_WORKER_PRIORITY_WORKER_1 = MTAPI_WORKER_PRIORITY_WORKER + 1,
+  MTAPI_WORKER_PRIORITY_WORKER_2 = MTAPI_WORKER_PRIORITY_WORKER + 2,
+  MTAPI_WORKER_PRIORITY_WORKER_3 = MTAPI_WORKER_PRIORITY_WORKER + 3,
+  MTAPI_WORKER_PRIORITY_WORKER_4 = MTAPI_WORKER_PRIORITY_WORKER + 4,
+  MTAPI_WORKER_PRIORITY_WORKER_5 = MTAPI_WORKER_PRIORITY_WORKER + 5,
+  MTAPI_WORKER_PRIORITY_WORKER_6 = MTAPI_WORKER_PRIORITY_WORKER + 6,
+  MTAPI_WORKER_PRIORITY_WORKER_7 = MTAPI_WORKER_PRIORITY_WORKER + 7,
+  MTAPI_WORKER_PRIORITY_WORKER_8 = MTAPI_WORKER_PRIORITY_WORKER + 8,
+  MTAPI_WORKER_PRIORITY_WORKER_9 = MTAPI_WORKER_PRIORITY_WORKER + 9,
+  MTAPI_WORKER_PRIORITY_WORKER_10 = MTAPI_WORKER_PRIORITY_WORKER + 10,
+  MTAPI_WORKER_PRIORITY_WORKER_11 = MTAPI_WORKER_PRIORITY_WORKER + 11,
+  MTAPI_WORKER_PRIORITY_WORKER_12 = MTAPI_WORKER_PRIORITY_WORKER + 12,
+  MTAPI_WORKER_PRIORITY_WORKER_13 = MTAPI_WORKER_PRIORITY_WORKER + 13,
+  MTAPI_WORKER_PRIORITY_WORKER_14 = MTAPI_WORKER_PRIORITY_WORKER + 14,
+  MTAPI_WORKER_PRIORITY_WORKER_15 = MTAPI_WORKER_PRIORITY_WORKER + 15,
+  MTAPI_WORKER_PRIORITY_WORKER_16 = MTAPI_WORKER_PRIORITY_WORKER + 16,
+  MTAPI_WORKER_PRIORITY_WORKER_17 = MTAPI_WORKER_PRIORITY_WORKER + 17,
+  MTAPI_WORKER_PRIORITY_WORKER_18 = MTAPI_WORKER_PRIORITY_WORKER + 18,
+  MTAPI_WORKER_PRIORITY_WORKER_19 = MTAPI_WORKER_PRIORITY_WORKER + 19,
+  MTAPI_WORKER_PRIORITY_WORKER_20 = MTAPI_WORKER_PRIORITY_WORKER + 20,
+  MTAPI_WORKER_PRIORITY_WORKER_21 = MTAPI_WORKER_PRIORITY_WORKER + 21,
+  MTAPI_WORKER_PRIORITY_WORKER_22 = MTAPI_WORKER_PRIORITY_WORKER + 22,
+  MTAPI_WORKER_PRIORITY_WORKER_23 = MTAPI_WORKER_PRIORITY_WORKER + 23,
+  MTAPI_WORKER_PRIORITY_WORKER_24 = MTAPI_WORKER_PRIORITY_WORKER + 24,
+  MTAPI_WORKER_PRIORITY_WORKER_25 = MTAPI_WORKER_PRIORITY_WORKER + 25,
+  MTAPI_WORKER_PRIORITY_WORKER_26 = MTAPI_WORKER_PRIORITY_WORKER + 26,
+  MTAPI_WORKER_PRIORITY_WORKER_27 = MTAPI_WORKER_PRIORITY_WORKER + 27,
+  MTAPI_WORKER_PRIORITY_WORKER_28 = MTAPI_WORKER_PRIORITY_WORKER + 28,
+  MTAPI_WORKER_PRIORITY_WORKER_29 = MTAPI_WORKER_PRIORITY_WORKER + 29,
+  MTAPI_WORKER_PRIORITY_WORKER_30 = MTAPI_WORKER_PRIORITY_WORKER + 30,
+  MTAPI_WORKER_PRIORITY_WORKER_31 = MTAPI_WORKER_PRIORITY_WORKER + 31,
+  MTAPI_WORKER_PRIORITY_WORKER_32 = MTAPI_WORKER_PRIORITY_WORKER + 32,
+  MTAPI_WORKER_PRIORITY_WORKER_33 = MTAPI_WORKER_PRIORITY_WORKER + 33,
+  MTAPI_WORKER_PRIORITY_WORKER_34 = MTAPI_WORKER_PRIORITY_WORKER + 34,
+  MTAPI_WORKER_PRIORITY_WORKER_35 = MTAPI_WORKER_PRIORITY_WORKER + 35,
+  MTAPI_WORKER_PRIORITY_WORKER_36 = MTAPI_WORKER_PRIORITY_WORKER + 36,
+  MTAPI_WORKER_PRIORITY_WORKER_37 = MTAPI_WORKER_PRIORITY_WORKER + 37,
+  MTAPI_WORKER_PRIORITY_WORKER_38 = MTAPI_WORKER_PRIORITY_WORKER + 38,
+  MTAPI_WORKER_PRIORITY_WORKER_39 = MTAPI_WORKER_PRIORITY_WORKER + 39,
+  MTAPI_WORKER_PRIORITY_WORKER_40 = MTAPI_WORKER_PRIORITY_WORKER + 40,
+  MTAPI_WORKER_PRIORITY_WORKER_41 = MTAPI_WORKER_PRIORITY_WORKER + 41,
+  MTAPI_WORKER_PRIORITY_WORKER_42 = MTAPI_WORKER_PRIORITY_WORKER + 42,
+  MTAPI_WORKER_PRIORITY_WORKER_43 = MTAPI_WORKER_PRIORITY_WORKER + 43,
+  MTAPI_WORKER_PRIORITY_WORKER_44 = MTAPI_WORKER_PRIORITY_WORKER + 44,
+  MTAPI_WORKER_PRIORITY_WORKER_45 = MTAPI_WORKER_PRIORITY_WORKER + 45,
+  MTAPI_WORKER_PRIORITY_WORKER_46 = MTAPI_WORKER_PRIORITY_WORKER + 46,
+  MTAPI_WORKER_PRIORITY_WORKER_47 = MTAPI_WORKER_PRIORITY_WORKER + 47,
+  MTAPI_WORKER_PRIORITY_WORKER_48 = MTAPI_WORKER_PRIORITY_WORKER + 48,
+  MTAPI_WORKER_PRIORITY_WORKER_49 = MTAPI_WORKER_PRIORITY_WORKER + 49,
+  MTAPI_WORKER_PRIORITY_WORKER_50 = MTAPI_WORKER_PRIORITY_WORKER + 50,
+  MTAPI_WORKER_PRIORITY_WORKER_51 = MTAPI_WORKER_PRIORITY_WORKER + 51,
+  MTAPI_WORKER_PRIORITY_WORKER_52 = MTAPI_WORKER_PRIORITY_WORKER + 52,
+  MTAPI_WORKER_PRIORITY_WORKER_53 = MTAPI_WORKER_PRIORITY_WORKER + 53,
+  MTAPI_WORKER_PRIORITY_WORKER_54 = MTAPI_WORKER_PRIORITY_WORKER + 54,
+  MTAPI_WORKER_PRIORITY_WORKER_55 = MTAPI_WORKER_PRIORITY_WORKER + 55,
+  MTAPI_WORKER_PRIORITY_WORKER_56 = MTAPI_WORKER_PRIORITY_WORKER + 56,
+  MTAPI_WORKER_PRIORITY_WORKER_57 = MTAPI_WORKER_PRIORITY_WORKER + 57,
+  MTAPI_WORKER_PRIORITY_WORKER_58 = MTAPI_WORKER_PRIORITY_WORKER + 58,
+  MTAPI_WORKER_PRIORITY_WORKER_59 = MTAPI_WORKER_PRIORITY_WORKER + 59,
+  MTAPI_WORKER_PRIORITY_WORKER_60 = MTAPI_WORKER_PRIORITY_WORKER + 60,
+  MTAPI_WORKER_PRIORITY_WORKER_61 = MTAPI_WORKER_PRIORITY_WORKER + 61,
+  MTAPI_WORKER_PRIORITY_WORKER_62 = MTAPI_WORKER_PRIORITY_WORKER + 62,
+  MTAPI_WORKER_PRIORITY_WORKER_63 = MTAPI_WORKER_PRIORITY_WORKER + 63
+};
+/**
+ * Enum to select default or specific worker for priority setter
+ */
+typedef enum mtapi_worker_priority_type_enum mtapi_worker_priority_type_t;
+
+/**
+ * Describes the default priority of all workers or the priority of a
+ * specific worker.
+ */
+struct mtapi_worker_priority_entry_struct {
+  mtapi_worker_priority_type_t type;   /**< default or specific worker */
+  embb_thread_priority_t priority;     /**< priority to set */
+};
+/**
+* Describes the default priority of all workers or the priority of a
+* specific worker.
+*/
+typedef struct mtapi_worker_priority_entry_struct mtapi_worker_priority_entry_t;
 
 /**
  * Node attributes, to be extended for implementation specific attributes
@@ -554,7 +645,8 @@ enum mtapi_node_attributes_enum {
                                             allowed by the node */
   MTAPI_NODE_MAX_PRIORITIES,           /**< maximum number of priorities
                                             allowed by the node */
-  MTAPI_NODE_REUSE_MAIN_THREAD         /**< reuse main thread as worker */
+  MTAPI_NODE_REUSE_MAIN_THREAD,        /**< reuse main thread as worker */
+  MTAPI_NODE_WORKER_PRIORITIES         /**< set worker priorites */
 };
 /** size of the \a MTAPI_NODE_CORE_AFFINITY attribute */
 #define MTAPI_NODE_CORE_AFFINITY_SIZE sizeof(embb_core_set_t)
@@ -580,6 +672,8 @@ enum mtapi_node_attributes_enum {
 #define MTAPI_NODE_MAX_PRIORITIES_SIZE sizeof(mtapi_uint_t)
 /** size of the \a MTAPI_NODE_REUSE_MAIN_THREAD attribute */
 #define MTAPI_NODE_REUSE_MAIN_THREAD_SIZE sizeof(mtapi_boolean_t)
+/** size of the \a MTAPI_NODE_WORKER_PRIORITIES attribute */
+#define MTAPI_NODE_WORKER_PRIORITIES_SIZE 0
 
 /* example attribute value */
 #define MTAPI_NODE_TYPE_SMP 1
@@ -693,6 +787,9 @@ struct mtapi_node_attributes_struct {
   mtapi_uint_t max_priorities;         /**< stores MTAPI_NODE_MAX_PRIORITIES */
   mtapi_boolean_t reuse_main_thread;   /**< stores
                                             MTAPI_NODE_REUSE_MAIN_THREAD */
+  mtapi_worker_priority_entry_t * worker_priorities;
+                                       /**< stores
+                                            MTAPI_NODE_WORKER_PRIORITIES */
 };
 
 /**

mtapi_c/include/embb/mtapi/c/mtapi_ext.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_c/include/mtapi_ext.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_c/src/embb_mtapi_action_plugin_t.c

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_c/src/embb_mtapi_scheduler_t.c

@@ -503,8 +503,25 @@ mtapi_boolean_t embb_mtapi_scheduler_initialize_with_mode(
       }
       core_num++;
     }
-    isinit &= embb_mtapi_thread_context_initialize_with_node_worker_and_core(
-      &that->worker_contexts[ii], node, ii, core_num);
+    embb_thread_priority_t priority = EMBB_THREAD_PRIORITY_NORMAL;
+    if (NULL != node->attributes.worker_priorities) {
+      mtapi_worker_priority_entry_t * entry =
+        node->attributes.worker_priorities;
+      mtapi_worker_priority_type_t type = entry->type;
+      while (type != MTAPI_WORKER_PRIORITY_END) {
+        if (type == MTAPI_WORKER_PRIORITY_DEFAULT) {
+          priority = entry->priority;
+        } else if (type ==
+          (mtapi_worker_priority_type_t)(MTAPI_WORKER_PRIORITY_WORKER + ii)) {
+          priority = entry->priority;
+          break;
+        }
+        entry++;
+        type = entry->type;
+      }
+    }
+    isinit &= embb_mtapi_thread_context_initialize(
+      &that->worker_contexts[ii], node, ii, core_num, priority);
   }
   if (!isinit) {
     return MTAPI_FALSE;

mtapi_c/src/embb_mtapi_thread_context_t.c

@@ -38,11 +38,12 @@
 
 /* ---- CLASS MEMBERS ------------------------------------------------------ */
 
-mtapi_boolean_t embb_mtapi_thread_context_initialize_with_node_worker_and_core(
+mtapi_boolean_t embb_mtapi_thread_context_initialize(
   embb_mtapi_thread_context_t* that,
   embb_mtapi_node_t* node,
   mtapi_uint_t worker_index,
-  mtapi_uint_t core_num) {
+  mtapi_uint_t core_num,
+  embb_thread_priority_t priority) {
   mtapi_uint_t ii;
   mtapi_boolean_t result = MTAPI_TRUE;
 
@@ -54,6 +55,7 @@ mtapi_boolean_t embb_mtapi_thread_context_initialize_with_node_worker_and_core(
   that->core_num = core_num;
   that->priorities = node->attributes.max_priorities;
   that->is_initialized = MTAPI_FALSE;
+  that->thread_priority = priority;
   that->is_main_thread = (worker_index == 0) ?
     node->attributes.reuse_main_thread : MTAPI_FALSE;
   embb_atomic_store_int(&that->run, 0);
@@ -135,7 +137,8 @@ mtapi_boolean_t embb_mtapi_thread_context_start(
     embb_tss_set(&(that->tss_id), that);
     embb_atomic_store_int(&that->run, 1);
   } else {
-    err = embb_thread_create(&that->thread, &core_set, worker_func, that);
+    err = embb_thread_create_with_priority(
+      &that->thread, &core_set, that->thread_priority, worker_func, that);
     if (EMBB_SUCCESS != err) {
       embb_mtapi_log_error(
         "embb_mtapi_ThreadContext_initializeWithNodeAndCoreNumber() could not "

mtapi_c/src/embb_mtapi_thread_context_t.h

@@ -69,6 +69,8 @@ struct embb_mtapi_thread_context_struct {
   mtapi_status_t status;
   mtapi_boolean_t is_initialized;
   mtapi_boolean_t is_main_thread;
+
+  embb_thread_priority_t thread_priority;
 };
 
 #include <embb_mtapi_thread_context_t_fwd.h>
@@ -78,11 +80,12 @@ struct embb_mtapi_thread_context_struct {
  * \memberof embb_mtapi_thread_context_struct
  * \returns MTAPI_TRUE if successful, MTAPI_FALSE on error
  */
-mtapi_boolean_t embb_mtapi_thread_context_initialize_with_node_worker_and_core(
+mtapi_boolean_t embb_mtapi_thread_context_initialize(
   embb_mtapi_thread_context_t* that,
   embb_mtapi_node_t* node,
   mtapi_uint_t worker_index,
-  mtapi_uint_t core_num);
+  mtapi_uint_t core_num,
+  embb_thread_priority_t priority);
 
 /**
  * Destructor.

mtapi_c/src/mtapi_node_attributes_t.c

@@ -53,6 +53,7 @@ void mtapi_nodeattr_init(
     attributes->max_actions_per_job = MTAPI_NODE_MAX_ACTIONS_PER_JOB_DEFAULT;
     attributes->max_priorities = MTAPI_NODE_MAX_PRIORITIES_DEFAULT;
     attributes->reuse_main_thread = MTAPI_FALSE;
+    attributes->worker_priorities = NULL;
 
     embb_core_set_init(&attributes->core_affinity, 1);
     attributes->num_cores = embb_core_set_count(&attributes->core_affinity);
@@ -149,6 +150,12 @@ void mtapi_nodeattr_set(
           &attributes->reuse_main_thread, attribute, attribute_size);
         break;
 
+      case MTAPI_NODE_WORKER_PRIORITIES:
+        local_status = MTAPI_SUCCESS;
+        attributes->worker_priorities =
+          (mtapi_worker_priority_entry_t*)attribute;
+        break;
+
       default:
         /* attribute unknown */
         local_status = MTAPI_ERR_ATTR_NUM;

mtapi_c/test/embb_mtapi_test_plugin.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_c/test/embb_mtapi_test_plugin.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_cpp/include/embb/mtapi/node_attributes.h

@@ -87,6 +87,23 @@ class NodeAttributes {
   }
 
   /**
+   * Sets the priority of the specified worker threads.
+   *
+   * \returns Reference to this object.
+   * \notthreadsafe
+   */
+  NodeAttributes & SetWorkerPriority(
+    mtapi_worker_priority_entry_t * worker_priorities
+                                       /**< Array of priorities */
+    ) {
+    mtapi_status_t status;
+    mtapi_nodeattr_set(&attributes_, MTAPI_NODE_WORKER_PRIORITIES,
+      worker_priorities, MTAPI_NODE_WORKER_PRIORITIES_SIZE, &status);
+    internal::CheckStatus(status);
+    return *this;
+  }
+
+  /**
    * Sets the maximum number of concurrently active tasks.
    *
    * \returns Reference to this object.

mtapi_plugins_c/mtapi_cuda_c/CMakeLists.txt

+project (project_embb_mtapi_cuda_c)
+
+file(GLOB_RECURSE EMBB_MTAPI_CUDA_C_SOURCES "src/*.c" "src/*.h")
+file(GLOB_RECURSE EMBB_MTAPI_CUDA_C_HEADERS "include/*.h")
+
+file(GLOB_RECURSE EMBB_MTAPI_CUDA_TEST_SOURCES "test/*.cc" "test/*.cu" "test/*.h")
+
+IF(MSVC8 OR MSVC9 OR MSVC10 OR MSVC11)
+FOREACH(src_tmp ${EMBB_MTAPI_CUDA_TEST_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+FOREACH(src_tmp ${EMBB_MTAPI_CUDA_C_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+ENDIF()
+
+IF(CMAKE_COMPILER_IS_GNUCC)
+  set (EMBB_MTAPI_CUDA_C_LIBS dl)
+ENDIF()
+
+# Execute the GroupSources macro
+include(${CMAKE_SOURCE_DIR}/CMakeCommon/GroupSourcesMSVC.cmake)
+GroupSourcesMSVC(include)
+GroupSourcesMSVC(src)
+GroupSourcesMSVC(test)
+
+set (EMBB_MTAPI_CUDA_INCLUDE_DIRS "include" "src" "test")
+include_directories(${EMBB_MTAPI_CUDA_INCLUDE_DIRS}
+                    ${CUDA_TOOLKIT_INCLUDE}
+                    ${CMAKE_CURRENT_SOURCE_DIR}/../../base_c/include
+                    ${CMAKE_CURRENT_BINARY_DIR}/../../base_c/include
+                    ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_c/include
+                    ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_c/src
+                    )
+
+add_library(embb_mtapi_cuda_c ${EMBB_MTAPI_CUDA_C_SOURCES} ${EMBB_MTAPI_CUDA_C_HEADERS})
+target_link_libraries(embb_mtapi_cuda_c embb_mtapi_c embb_base_c)
+
+if (BUILD_TESTS STREQUAL ON)
+  add_custom_command(
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/test/embb_mtapi_cuda_test_kernel.cu"
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.ptx"
+    COMMAND ${CUDA_NVCC_EXECUTABLE} -ptx -m 32
+      "${CMAKE_CURRENT_SOURCE_DIR}/test/embb_mtapi_cuda_test_kernel.cu"
+      -o "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.ptx"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+  )
+  add_custom_command(
+    DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.ptx"
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.h"
+    COMMAND ${CUDA_TOOLKIT_ROOT_DIR}/bin/bin2c -p 0
+      "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.ptx" >
+      "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.h"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+  )
+  include_directories(
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_BINARY_DIR}/../../partest/include)
+  add_executable (embb_mtapi_cuda_c_test ${EMBB_MTAPI_CUDA_TEST_SOURCES} "${CMAKE_CURRENT_BINARY_DIR}/embb_mtapi_cuda_test_kernel.h")
+  target_link_libraries(embb_mtapi_cuda_c_test embb_mtapi_cuda_c embb_mtapi_c partest embb_base_c ${compiler_libs} ${EMBB_MTAPI_CUDA_C_LIBS} ${CUDA_CUDA_LIBRARY})
+  CopyBin(BIN embb_mtapi_cuda_c_test DEST ${local_install_dir})
+endif()
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
+        DESTINATION include FILES_MATCHING PATTERN "*.h")
+install(TARGETS embb_mtapi_cuda_c DESTINATION lib)
+if (MSVC)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Debug/embb_mtapi_cuda_c.pdb
+          DESTINATION lib
+          CONFIGURATIONS Debug)
+endif()

mtapi_plugins_c/mtapi_cuda_c/include/embb/mtapi/c/mtapi_cuda.h

+/*
+ * Copyright (c) 2014, Siemens AG. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef EMBB_MTAPI_C_MTAPI_CUDA_H_
+#define EMBB_MTAPI_C_MTAPI_CUDA_H_
+
+
+#include <embb/mtapi/c/mtapi_ext.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * \defgroup C_MTAPI_CUDA MTAPI CUDA Plugin
+ *
+ * \ingroup C_MTAPI_EXT
+ *
+ * Provides functionality to execute tasks on CUDA devices.
+ */
+
+
+/**
+ * Initializes the MTAPI CUDA environment on a previously initialized MTAPI
+ * node.
+ *
+ * It must be called on all nodes using the MTAPI CUDA plugin.
+ *
+ * Application software using MTAPI CUDA must call
+ * mtapi_cuda_plugin_initialize() once per node. It is an error to call
+ * mtapi_cuda_plugin_initialize() multiple times
+ * from a given node, unless mtapi_cuda_plugin_finalize() is called in
+ * between.
+ *
+ * On success, \c *status is set to \c MTAPI_SUCCESS. On error, \c *status is
+ * set to the appropriate error defined below.
+ * Error code                  | Description
+ * --------------------------- | ----------------------------------------------
+ * \c MTAPI_ERR_UNKNOWN        | MTAPI CUDA couldn't be initialized.
+ *
+ * \see mtapi_cuda_plugin_finalize()
+ *
+ * \notthreadsafe
+ * \ingroup C_MTAPI_CUDA
+ */
+void mtapi_cuda_plugin_initialize(
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+/**
+ * Finalizes the MTAPI CUDA environment on the local MTAPI node.
+ *
+ * It has to be called by each node using MTAPI CUDA. It is an error to call
+ * mtapi_cuda_plugin_finalize() without first calling
+ * mtapi_cuda_plugin_initialize(). An MTAPI node can call
+ * mtapi_cuda_plugin_finalize() once for each call to
+ * mtapi_cuda_plugin_initialize(), but it is an error to call
+ * mtapi_cuda_plugin_finalize() multiple times from a given node
+ * unless mtapi_cuda_plugin_initialize() has been called prior to each
+ * mtapi_cuda_plugin_finalize() call.
+ *
+ * All CUDA tasks that have not completed and that have been started on the
+ * node where mtapi_cuda_plugin_finalize() is called will be canceled
+ * (see mtapi_task_cancel()). mtapi_cuda_plugin_finalize() blocks until all
+ * tasks that have been started on the same node return. Tasks that execute
+ * actions on the node where mtapi_cuda_plugin_finalize() is called, also
+ * block finalization of the MTAPI CUDA system on that node.
+ *
+ * On success, \c *status is set to \c MTAPI_SUCCESS. On error, \c *status is
+ * set to the appropriate error defined below.
+ * Error code                    | Description
+ * ----------------------------- | --------------------------------------------
+ * \c MTAPI_ERR_UNKNOWN          | MTAPI CUDA couldn't be finalized.
+ *
+ * \see mtapi_cuda_plugin_initialize(), mtapi_task_cancel()
+ *
+ * \notthreadsafe
+ * \ingroup C_MTAPI_CUDA
+ */
+void mtapi_cuda_plugin_finalize(
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+/**
+ * This function creates a CUDA action.
+ *
+ * It is called on the node where the user wants to execute an action on an
+ * CUDA device. A CUDA action contains a reference to a local job, the
+ * kernel source to compile and execute on the CUDA device, the name of the
+ * kernel function, a local work size (see CUDA specification for details)
+ * and the size of one element in the result buffer.
+ * After a CUDA action is created, it is referenced by the application using
+ * a node-local handle of type \c mtapi_action_hndl_t, or indirectly through a
+ * node-local job handle of type \c mtapi_job_hndl_t. A CUDA action's
+ * life-cycle begins with mtapi_cuda_action_create(), and ends when
+ * mtapi_action_delete() or mtapi_finalize() is called.
+ *
+ * To create an action, the application must supply the domain-wide job ID of
+ * the job associated with the action. Job IDs must be predefined in the
+ * application and runtime, of type \c mtapi_job_id_t, which is an
+ * implementation-defined type. The job ID is unique in the sense that it is
+ * unique for the job implemented by the action. However several actions may
+ * implement the same job for load balancing purposes.
+ *
+ * If \c node_local_data_size is not zero, \c node_local_data specifies the
+ * start of node local data shared by kernel functions executed on the same
+ * node. \c node_local_data_size can be used by the runtime for cache coherency
+ * operations.
+ *
+ * On success, an action handle is returned and \c *status is set to
+ * \c MTAPI_SUCCESS. On error, \c *status is set to the appropriate error
+ * defined below. In the case where the action already exists, \c status will
+ * be set to \c MTAPI_ERR_ACTION_EXISTS and the handle returned will not be a
+ * valid handle.
+ * <table>
+ *   <tr>
+ *     <th>Error code</th>
+ *     <th>Description</th>
+ *   </tr>
+ *   <tr>
+ *     <td>\c MTAPI_ERR_JOB_INVALID</td>
+ *     <td>The \c job_id is not a valid job ID, i.e., no action was created for
+ *         that ID or the action has been deleted.</td>
+ *   </tr>
+ *   <tr>
+ *     <td>\c MTAPI_ERR_ACTION_EXISTS</td>
+ *     <td>This action is already created.</td>
+ *   </tr>
+ *   <tr>
+ *     <td>\c MTAPI_ERR_ACTION_LIMIT</td>
+ *     <td>Exceeded maximum number of actions allowed.</td>
+ *   </tr>
+ *   <tr>
+ *     <td>\c MTAPI_ERR_NODE_NOTINIT</td>
+ *     <td>The calling node is not initialized.</td>
+ *   </tr>
+ *   <tr>
+ *     <td>\c MTAPI_ERR_UNKNOWN</td>
+ *     <td>The kernel could not be compiled or no CUDA device was
+ *         available.</td>
+ *   </tr>
+ * </table>
+ *
+ * \see mtapi_action_delete(), mtapi_finalize()
+ *
+ * \returns Handle to newly created CUDA action, invalid handle on error
+ * \threadsafe
+ * \ingroup C_MTAPI_CUDA
+ */
+mtapi_action_hndl_t mtapi_cuda_action_create(
+  MTAPI_IN mtapi_job_id_t job_id,      /**< [in] Job id */
+  MTAPI_IN char* kernel_source,        /**< [in] Pointer to kernel source */
+  MTAPI_IN char* kernel_name,          /**< [in] Name of the kernel function */
+  MTAPI_IN mtapi_size_t local_work_size,
+                                       /**< [in] Size of local work group */
+  MTAPI_IN mtapi_size_t element_size,  /**< [in] Size of one element in the
+                                            result buffer */
+  MTAPI_IN void* node_local_data,      /**< [in] Data shared across tasks */
+  MTAPI_IN mtapi_size_t node_local_data_size,
+                                       /**< [in] Size of shared data */
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // EMBB_MTAPI_C_MTAPI_CUDA_H_

mtapi_plugins_c/mtapi_cuda_c/test/embb_mtapi_cuda_test_kernel.cu

+extern "C" __global__ void test(
+  void* arguments,
+  int arguments_size,
+  void* result_buffer,
+  int result_buffer_size,
+  void* node_local_data,
+  int node_local_data_size) {
+  int ii = blockDim.x * blockIdx.x + threadIdx.x;
+  int elements = arguments_size / sizeof(float) / 2;
+  if (ii >= elements)
+    return;
+  float* a = (float*)arguments;
+  float* b = ((float*)arguments) + elements;
+  float* c = (float*)result_buffer;
+  float* d = (float*)node_local_data;
+  c[ii] = a[ii] + b[ii] + d[0];
+}

mtapi_plugins_c/mtapi_cuda_c/test/embb_mtapi_cuda_test_task.cc

+/*
+ * Copyright (c) 2014, Siemens AG. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <embb_mtapi_cuda_test_task.h>
+
+#include <embb/mtapi/c/mtapi_cuda.h>
+
+#define MTAPI_CHECK_STATUS(status) \
+PT_ASSERT(MTAPI_SUCCESS == status)
+
+#define CUDA_DOMAIN 1
+#define CUDA_NODE 2
+#define CUDA_JOB 2
+
+// CUDA Kernel Function for element by element vector addition
+#include <embb_mtapi_cuda_test_kernel.h>
+
+TaskTest::TaskTest() {
+  CreateUnit("mtapi cuda task test").Add(&TaskTest::TestBasic, this);
+}
+
+void TaskTest::TestBasic() {
+  mtapi_status_t status;
+  mtapi_job_hndl_t job;
+  mtapi_task_hndl_t task;
+  mtapi_action_hndl_t action;
+
+  const int kElements = 64;
+  float arguments[kElements * 2];
+  float results[kElements];
+
+  for (int ii = 0; ii < kElements; ii++) {
+    arguments[ii] = static_cast<float>(ii);
+    arguments[ii + kElements] = static_cast<float>(ii);
+  }
+
+  mtapi_cuda_plugin_initialize(&status);
+  if (status == MTAPI_ERR_FUNC_NOT_IMPLEMENTED) {
+    // CUDA unavailable
+    return;
+  }
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_initialize(
+    CUDA_DOMAIN,
+    CUDA_NODE,
+    MTAPI_NULL,
+    MTAPI_NULL,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  float node_local = 1.0f;
+  action = mtapi_cuda_action_create(
+    CUDA_JOB,
+    reinterpret_cast<char const *>(imageBytes), "test", 32, 4,
+    &node_local, sizeof(float),
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  job = mtapi_job_get(CUDA_JOB, CUDA_DOMAIN, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  task = mtapi_task_start(
+    MTAPI_TASK_ID_NONE,
+    job,
+    arguments, kElements * 2 * sizeof(float),
+    results, kElements*sizeof(float),
+    MTAPI_DEFAULT_TASK_ATTRIBUTES,
+    MTAPI_GROUP_NONE,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_task_wait(task, MTAPI_INFINITE, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  for (int ii = 0; ii < kElements; ii++) {
+    PT_EXPECT_EQ(results[ii], ii * 2 + 1);
+  }
+
+  mtapi_action_delete(action, MTAPI_INFINITE, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_cuda_plugin_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+}

mtapi_plugins_c/mtapi_cuda_c/test/embb_mtapi_cuda_test_task.h

+/*
+ * Copyright (c) 2014, Siemens AG. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MTAPI_PLUGINS_C_MTAPI_CUDA_C_TEST_EMBB_MTAPI_CUDA_TEST_TASK_H_
+#define MTAPI_PLUGINS_C_MTAPI_CUDA_C_TEST_EMBB_MTAPI_CUDA_TEST_TASK_H_
+
+#include <partest/partest.h>
+
+class TaskTest : public partest::TestCase {
+ public:
+  TaskTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_PLUGINS_C_MTAPI_CUDA_C_TEST_EMBB_MTAPI_CUDA_TEST_TASK_H_

mtapi_plugins_c/mtapi_cuda_c/test/main.cc

+/*
+ * Copyright (c) 2014, Siemens AG. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <partest/partest.h>
+
+#include <embb_mtapi_cuda_test_task.h>
+
+
+PT_MAIN("MTAPI CUDA") {
+  PT_RUN(TaskTest);
+}

mtapi_plugins_c/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.c

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.c

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.c

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_network_c/test/main.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -51,7 +51,7 @@ extern "C" {
  *
  * It must be called on all nodes using the MTAPI OpenCL plugin.
  *
- * Application software using MTAPI network must call
+ * Application software using MTAPI OpenCL must call
  * mtapi_opencl_plugin_initialize() once per node. It is an error to call
  * mtapi_opencl_plugin_initialize() multiple times
  * from a given node, unless mtapi_opencl_plugin_finalize() is called in
@@ -85,7 +85,7 @@ void mtapi_opencl_plugin_initialize(
  * unless mtapi_opencl_plugin_initialize() has been called prior to each
  * mtapi_opencl_plugin_finalize() call.
  *
- * All network tasks that have not completed and that have been started on the
+ * All OpenCL tasks that have not completed and that have been started on the
  * node where mtapi_opencl_plugin_finalize() is called will be canceled
  * (see mtapi_task_cancel()). mtapi_opencl_plugin_finalize() blocks until all
  * tasks that have been started on the same node return. Tasks that execute

mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl.c

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,6 +26,7 @@
 
 #include <CL/opencl.h>
 #include <embb/base/c/internal/config.h>
+#include <embb_mtapi_opencl_runtimelinker.h>
 
 //////////////////////////////////////////////////////////////////////////
 // function pointer wrappers to hide runtime linking

mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

mtapi_plugins_c/mtapi_opencl_c/test/main.cc

 /*
- * Copyright (c) 2014, Siemens AG. All rights reserved.
+ * Copyright (c) 2014-2016, Siemens AG. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:

scripts/run_cpplint.sh

@@ -79,7 +79,7 @@ retval=0
 
 ##Excluded files
 RAND_FILES=( embb_mtapi_test_group.cc embb_mtapi_test_queue.cc embb_mtapi_test_task.cc queue_test-inl.h )
-for project in base_c mtapi_c mtapi_plugins_c/mtapi_network_c mtapi_plugins_c/mtapi_opencl_c base_cpp mtapi_cpp algorithms_cpp containers_cpp dataflow_cpp
+for project in base_c mtapi_c mtapi_plugins_c/mtapi_network_c mtapi_plugins_c/mtapi_opencl_c mtapi_plugins_c/mtapi_cuda_c base_cpp mtapi_cpp algorithms_cpp containers_cpp dataflow_cpp
 do
   echo "-> Doing project: $project"
   dir=$d/$project
@@ -120,7 +120,7 @@ do
         current_rules+=",-runtime/threadsafe_fn" # These tests are allowed to use the thread unsafe rand()
       fi
     done
-    python ${c} --filter=$current_rules --root="$project/include" --output=vs7 $file
+    python ${c} --extensions=c,cc,h --filter=$current_rules --root="$project/include" --output=vs7 $file
     if [[ ! $? -eq 0 ]]; then
       retval=$((retval+1))
     fi