Merge remote-tracking branch 'origin/development' into embb327_llx_scx

CMakeLists.txt

@@ -125,6 +125,8 @@ CheckPartestInstall(${BUILD_TESTS} partest_includepath partest_libpath)
 add_subdirectory(base_c)
 add_subdirectory(base_cpp)
 add_subdirectory(mtapi_c)
+add_subdirectory(mtapi_network_c)
+add_subdirectory(mtapi_opencl_c)
 add_subdirectory(tasks_cpp)
 add_subdirectory(mtapi_cpp)
 add_subdirectory(containers_cpp)

README.md

@@ -316,8 +316,6 @@ code using Cppcheck, a static analysis tool for C++.
 Known Bugs and Limitations
 --------------------------
 
-- The MTAPI implementation is currently limited to homogeneous systems.
-  Support for heterogeneous systems will be added in the near future.
 - For memory management reasons, the number of threads EMB² can deal with
   is bounded by a predefined but modifiable constant (see functions
   embb_thread_get_max_count() / embb_thread_set_max_count() and class

dataflow_cpp/include/embb/dataflow/internal/clock_listener.h

@@ -31,10 +31,19 @@ namespace embb {
 namespace dataflow {
 namespace internal {
 
+class Scheduler;
+class ClockListener;
+
+struct InitData {
+  Scheduler * sched;
+  ClockListener * sink_listener;
+};
+
 class ClockListener {
  public:
   virtual ~ClockListener() {}
   virtual void OnClock(int /*clock*/) = 0;
+  virtual void OnInit(InitData * /*sched*/) = 0;
 };
 
 } // namespace internal

dataflow_cpp/include/embb/dataflow/internal/constant_source.h

@@ -56,6 +56,11 @@ class ConstantSource
     GetOutput<0>().Send(Signal<Type>(clock, value_));
   }
 
+  virtual void Init(InitData * init_data) {
+    SetScheduler(init_data->sched);
+    GetOutput<0>().SendInit(init_data);
+  }
+
   virtual bool Start(int clock) {
     Run(clock);
     return true;

dataflow_cpp/include/embb/dataflow/internal/in.h

@@ -39,6 +39,8 @@ namespace embb {
 namespace dataflow {
 namespace internal {
 
+class Scheduler;
+
 template <typename, int>
 class Out;
 
@@ -95,6 +97,10 @@ class In {
     lock_.Unlock();
 #endif
   }
+
+  void ReceiveInit(InitData * init_data) {
+    listener_->OnInit(init_data);
+  }
 };
 
 } // namespace internal

dataflow_cpp/include/embb/dataflow/internal/inputs.h

@@ -57,6 +57,7 @@ class Inputs<Slices, embb::base::internal::Nil, embb::base::internal::Nil,
   bool AreNoneBlank(int /*clock*/) { return false; }
   bool AreAtClock(int /*clock*/) { return true; }
   virtual void OnClock(int /*clock*/) {}
+  virtual void OnInit(InitData * /*init_data*/) {}
 };
 
 template <int Slices, typename T1>
@@ -70,6 +71,7 @@ class Inputs<Slices, T1, embb::base::internal::Nil, embb::base::internal::Nil,
   Inputs() {
     for (int ii = 0; ii < Slices; ii++)
       count_[ii] = 1;
+    test_count_ = 1;
   }
   void SetListener(ClockListener * listener) {
     listener_ = listener;
@@ -97,8 +99,14 @@ class Inputs<Slices, T1, embb::base::internal::Nil, embb::base::internal::Nil,
       listener_->OnClock(clock);
     }
   }
+  virtual void OnInit(InitData * init_data) {
+    if (--test_count_ == 0) {
+      listener_->OnInit(init_data);
+    }
+  }
  private:
   embb::base::Atomic<int> count_[Slices];
+  int test_count_;
   ClockListener * listener_;
 };
 
@@ -112,6 +120,7 @@ class Inputs<Slices, T1, T2, embb::base::internal::Nil,
   Inputs() {
     for (int ii = 0; ii < Slices; ii++)
       count_[ii] = 2;
+    test_count_ = 2;
   }
   void SetListener(ClockListener * listener) {
     listener_ = listener;
@@ -143,8 +152,14 @@ class Inputs<Slices, T1, T2, embb::base::internal::Nil,
       listener_->OnClock(clock);
     }
   }
+  virtual void OnInit(InitData * init_data) {
+    if (--test_count_ == 0) {
+      listener_->OnInit(init_data);
+    }
+  }
  private:
   embb::base::Atomic<int> count_[Slices];
+  int test_count_;
   ClockListener * listener_;
 };
 
@@ -158,6 +173,7 @@ class Inputs<Slices, T1, T2, T3, embb::base::internal::Nil,
   Inputs() {
     for (int ii = 0; ii < Slices; ii++)
       count_[ii] = 3;
+    test_count_ = 3;
   }
   void SetListener(ClockListener * listener) {
     listener_ = listener;
@@ -193,8 +209,14 @@ class Inputs<Slices, T1, T2, T3, embb::base::internal::Nil,
       listener_->OnClock(clock);
     }
   }
+  virtual void OnInit(InitData * init_data) {
+    if (--test_count_ == 0) {
+      listener_->OnInit(init_data);
+    }
+  }
  private:
   embb::base::Atomic<int> count_[Slices];
+  int test_count_;
   ClockListener * listener_;
 };
 
@@ -207,6 +229,7 @@ class Inputs<Slices, T1, T2, T3, T4, embb::base::internal::Nil>
   Inputs() {
     for (int ii = 0; ii < Slices; ii++)
       count_[ii] = 4;
+    test_count_ = 4;
   }
   void SetListener(ClockListener * listener) {
     listener_ = listener;
@@ -246,8 +269,14 @@ class Inputs<Slices, T1, T2, T3, T4, embb::base::internal::Nil>
       listener_->OnClock(clock);
     }
   }
+  virtual void OnInit(InitData * init_data) {
+    if (--test_count_ == 0) {
+      listener_->OnInit(init_data);
+    }
+  }
  private:
   embb::base::Atomic<int> count_[Slices];
+  int test_count_;
   ClockListener * listener_;
 };
 
@@ -261,6 +290,7 @@ class Inputs
   Inputs() {
     for (int ii = 0; ii < Slices; ii++)
       count_[ii] = 5;
+    test_count_ = 5;
   }
   void SetListener(ClockListener * listener) {
     listener_ = listener;
@@ -304,8 +334,14 @@ class Inputs
       listener_->OnClock(clock);
     }
   }
+  virtual void OnInit(InitData * init_data) {
+    if (--test_count_ == 0) {
+      listener_->OnInit(init_data);
+    }
+  }
  private:
   embb::base::Atomic<int> count_[Slices];
+  int test_count_;
   ClockListener * listener_;
 };
 

dataflow_cpp/include/embb/dataflow/internal/node.h

@@ -30,6 +30,7 @@
 #include <cstddef>
 #include <embb/base/exceptions.h>
 #include <embb/dataflow/internal/scheduler.h>
+#include <embb/dataflow/internal/clock_listener.h>
 
 namespace embb {
 namespace dataflow {
@@ -46,12 +47,13 @@ class Node {
     EMBB_THROW(embb::base::ErrorException,
       "Nodes are started implicitly.");
   }
-  void SetScheduler(Scheduler * sched) { sched_ = sched; }
+  virtual void Init(InitData * init_data) = 0;
 
  protected:
   Scheduler * sched_;
   static int next_process_id_;
 
+  void SetScheduler(Scheduler * sched) { sched_ = sched; }
   static int GetNextProcessID() { return next_process_id_++; }
 };
 

dataflow_cpp/include/embb/dataflow/internal/out.h

@@ -35,6 +35,8 @@ namespace embb {
 namespace dataflow {
 namespace internal {
 
+class Scheduler;
+
 template <typename Type, int Slices>
 class Out {
  public:
@@ -50,6 +52,12 @@ class Out {
     }
   }
 
+  void SendInit(InitData * init_data) {
+    for (size_t ii = 0; ii < targets_.size(); ii++) {
+      targets_[ii]->ReceiveInit(init_data);
+    }
+  }
+
   void Connect(InType & input) {
     if (input.IsConnected()) {
       EMBB_THROW(embb::base::ErrorException,

dataflow_cpp/include/embb/dataflow/internal/process.h

@@ -78,6 +78,11 @@ class Process< Slices, Serial, Inputs<Slices, I1, I2, I3, I4, I5>,
     executor_.Execute(clock, inputs_, outputs_);
   }
 
+  virtual void Init(InitData * init_data) {
+    SetScheduler(init_data->sched);
+    executor_.Init(init_data, outputs_);
+  }
+
   InputsType & GetInputs() {
     return inputs_;
   }
@@ -142,6 +147,10 @@ class Process< Slices, Serial, Inputs<Slices, I1, I2, I3, I4, I5>,
     }
   }
 
+  virtual void OnInit(InitData * init_data) {
+    Init(init_data);
+  }
+
  private:
   InputsType inputs_;
   OutputsType outputs_;

dataflow_cpp/include/embb/dataflow/internal/process_executor.h

@@ -62,6 +62,10 @@ class ProcessExecutor< Inputs<Slices, I1>, Outputs<Slices, O1> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -91,6 +95,11 @@ class ProcessExecutor< Inputs<Slices, I1>, Outputs<Slices, O1, O2> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -124,6 +133,12 @@ class ProcessExecutor< Inputs<Slices, I1>, Outputs<Slices, O1, O2, O3> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2, O3> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+    outputs.template Get<2>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -161,6 +176,13 @@ class ProcessExecutor< Inputs<Slices, I1>, Outputs<Slices, O1, O2, O3, O4> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2, O3, O4> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+    outputs.template Get<2>().SendInit(init_data);
+    outputs.template Get<3>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -189,6 +211,10 @@ class ProcessExecutor< Inputs<Slices, I1, I2>, Outputs<Slices, O1> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -220,6 +246,11 @@ class ProcessExecutor< Inputs<Slices, I1, I2>, Outputs<Slices, O1, O2> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -255,6 +286,12 @@ class ProcessExecutor< Inputs<Slices, I1, I2>, Outputs<Slices, O1, O2, O3> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2, O3> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+    outputs.template Get<2>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -284,6 +321,10 @@ class ProcessExecutor< Inputs<Slices, I1, I2, I3>, Outputs<Slices, O1> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -317,6 +358,11 @@ class ProcessExecutor< Inputs<Slices, I1, I2, I3>, Outputs<Slices, O1, O2> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -348,6 +394,10 @@ class ProcessExecutor< Inputs<Slices, I1, I2, I3, I4>, Outputs<Slices, O1> > {
     }
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };

dataflow_cpp/include/embb/dataflow/internal/select.h

@@ -81,6 +81,11 @@ class Select
     }
   }
 
+  virtual void Init(InitData * init_data) {
+    SetScheduler(init_data->sched);
+    GetOutput<0>().SendInit(init_data);
+  }
+
   InputsType & GetInputs() {
     return inputs_;
   }
@@ -112,6 +117,10 @@ class Select
     Run(clock);
   }
 
+  virtual void OnInit(InitData * init_data) {
+    Init(init_data);
+  }
+
  private:
   InputsType inputs_;
   OutputsType outputs_;

dataflow_cpp/include/embb/dataflow/internal/sink.h

@@ -72,6 +72,12 @@ class Sink< Slices, Inputs<Slices, I1, I2, I3, I4, I5> >
     listener_->OnClock(clock);
   }
 
+  virtual void Init(InitData * init_data) {
+    SetListener(init_data->sink_listener);
+    SetScheduler(init_data->sched);
+    listener_->OnInit(init_data);
+  }
+
   InputsType & GetInputs() {
     return inputs_;
   }
@@ -115,6 +121,10 @@ class Sink< Slices, Inputs<Slices, I1, I2, I3, I4, I5> >
     }
   }
 
+  virtual void OnInit(InitData * init_data) {
+    Init(init_data);
+  }
+
  private:
   InputsType inputs_;
   ExecutorType executor_;

dataflow_cpp/include/embb/dataflow/internal/source.h

@@ -59,6 +59,11 @@ class Source< Slices, Outputs<Slices, O1, O2, O3, O4, O5> >
     not_done_ = executor_.Execute(clock, outputs_);
   }
 
+  virtual void Init(InitData * init_data) {
+    SetScheduler(init_data->sched);
+    executor_.Init(init_data, outputs_);
+  }
+
   virtual bool Start(int clock) {
     if (not_done_) {
       Run(clock);

dataflow_cpp/include/embb/dataflow/internal/source_executor.h

@@ -36,6 +36,8 @@ namespace embb {
 namespace dataflow {
 namespace internal {
 
+class Scheduler;
+
 template <class OUTPUTS>
 class SourceExecutor;
 
@@ -55,6 +57,10 @@ class SourceExecutor< Outputs<Slices, O1> > {
     return result;
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -77,6 +83,11 @@ class SourceExecutor< Outputs<Slices, O1, O2> > {
     return result;
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -101,6 +112,12 @@ class SourceExecutor< Outputs<Slices, O1, O2, O3> > {
     return result;
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2, O3> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+    outputs.template Get<2>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -127,6 +144,13 @@ class SourceExecutor< Outputs<Slices, O1, O2, O3, O4> > {
     return result;
   }
 
+  void Init(InitData * init_data, Outputs<Slices, O1, O2, O3, O4> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+    outputs.template Get<2>().SendInit(init_data);
+    outputs.template Get<3>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };
@@ -156,6 +180,15 @@ class SourceExecutor< Outputs<Slices, O1, O2, O3, O4, O5> > {
     return result;
   }
 
+  void Init(
+    InitData * init_data, Outputs<Slices, O1, O2, O3, O4, O5> & outputs) {
+    outputs.template Get<0>().SendInit(init_data);
+    outputs.template Get<1>().SendInit(init_data);
+    outputs.template Get<2>().SendInit(init_data);
+    outputs.template Get<3>().SendInit(init_data);
+    outputs.template Get<4>().SendInit(init_data);
+  }
+
  private:
   FunctionType function_;
 };

dataflow_cpp/include/embb/dataflow/internal/switch.h

@@ -78,6 +78,12 @@ class Switch
     }
   }
 
+  virtual void Init(InitData * init_data) {
+    SetScheduler(init_data->sched);
+    GetOutput<0>().SendInit(init_data);
+    GetOutput<1>().SendInit(init_data);
+  }
+
   InputsType & GetInputs() {
     return inputs_;
   }
@@ -109,6 +115,10 @@ class Switch
     Run(clock);
   }
 
+  virtual void OnInit(InitData * init_data) {
+    Init(init_data);
+  }
+
  private:
   InputsType inputs_;
   OutputsType outputs_;

dataflow_cpp/include/embb/dataflow/network.h

@@ -246,13 +246,6 @@ class Network {
   };
 
   /**
-   * Adds a new serial process to the network.
-   * \param proc The process to add.
-   */
-  template <class Inputs, class Outputs>
-  void Add(SerialProcess<Inputs, Outputs> & proc);
-
-  /**
   * Generic parallel process template.
   *
   * Implements a generic parallel process in the network that may have one to
@@ -334,13 +327,6 @@ class Network {
   };
 
   /**
-  * Adds a new parallel process to the network.
-  * \param proc The process to add.
-  */
-  template <class Inputs, class Outputs>
-  void Add(ParallelProcess<Inputs, Outputs> & proc);
-
-  /**
    * Switch process template.
    *
    * A switch has 2 inputs and 2 outputs. Input port 0 is of type boolean and
@@ -412,13 +398,6 @@ class Network {
   };
 
   /**
-   * Adds a new switch process to the network.
-   * \param sw The switch process to add.
-   */
-  template <typename Type>
-  void Add(Switch<Type> & sw);
-
-  /**
    * Select process template.
    *
    * A select has 3 inputs and 1 output. Input port 0 is of type boolean and
@@ -490,13 +469,6 @@ class Network {
   };
 
   /**
-   * Adds a new select process to the network.
-   * \param sel The select process to add.
-   */
-  template <typename Type>
-  void Add(Select<Type> & sel);
-
-  /**
    * Sink process template.
    *
    * A sink marks the end of a particular processing chain. It can have one to
@@ -557,13 +529,6 @@ class Network {
   };
 
   /**
-   * Adds a new sink process to the network.
-   * \param sink The sink process to add.
-   */
-  template<typename I1, typename I2, typename I3, typename I4, typename I5>
-  void Add(Sink<I1, I2, I3, I4, I5> & sink);
-
-  /**
    * Source process template.
    *
    * A source marks the start of a processing chain. It can have one to five
@@ -635,7 +600,7 @@ class Network {
    * \param source The source process to add.
    */
   template<typename O1, typename O2, typename O3, typename O4, typename O5>
-  void Add(Source<O1, O2, O3, O4, O5> & source);
+  void AddSource(Source<O1, O2, O3, O4, O5> & source);
 
   /**
    * Constant source process template.
@@ -694,7 +659,7 @@ class Network {
    * \param source The constant source process to add.
    */
   template<typename Type>
-  void Add(ConstantSource<Type> & source);
+  void AddSource(ConstantSource<Type> & source);
 
   /**
    * Executes the network until one of the the sources returns \c false.
@@ -748,11 +713,6 @@ class Network : public internal::ClockListener {
     }
   };
 
-  template <class Inputs, class Outputs>
-  void Add(SerialProcess<Inputs, Outputs> & proc) {
-    processes_.push_back(&proc);
-  }
-
   template <class Inputs, class Outputs> class ParallelProcess;
 
   template <
@@ -776,31 +736,16 @@ class Network : public internal::ClockListener {
     }
   };
 
-  template <class Inputs, class Outputs>
-  void Add(ParallelProcess<Inputs, Outputs> & proc) {
-    processes_.push_back(&proc);
-  }
-
   template<typename Type>
   class Switch : public internal::Switch<Slices, Type> {
    public:
   };
 
-  template <typename Type>
-  void Add(Switch<Type> & sw) {
-    processes_.push_back(&sw);
-  }
-
   template<typename Type>
   class Select : public internal::Select<Slices, Type> {
    public:
   };
 
-  template <typename Type>
-  void Add(Select<Type> & sel) {
-    processes_.push_back(&sel);
-  }
-
   template<typename I1, typename I2 = embb::base::internal::Nil,
     typename I3 = embb::base::internal::Nil,
     typename I4 = embb::base::internal::Nil,
@@ -818,12 +763,6 @@ class Network : public internal::ClockListener {
     }
   };
 
-  template<typename I1, typename I2, typename I3, typename I4, typename I5>
-  void Add(Sink<I1, I2, I3, I4, I5> & sink) {
-    sink.SetListener(this);
-    sinks_.push_back(&sink);
-  }
-
   template<typename O1, typename O2 = embb::base::internal::Nil,
     typename O3 = embb::base::internal::Nil,
     typename O4 = embb::base::internal::Nil,
@@ -843,7 +782,7 @@ class Network : public internal::ClockListener {
   };
 
   template<typename O1, typename O2, typename O3, typename O4, typename O5>
-  void Add(Source<O1, O2, O3, O4, O5> & source) {
+  void AddSource(Source<O1, O2, O3, O4, O5> & source) {
     sources_.push_back(&source);
   }
 
@@ -857,7 +796,7 @@ class Network : public internal::ClockListener {
   };
 
   template<typename Type>
-  void Add(ConstantSource<Type> & source) {
+  void AddSource(ConstantSource<Type> & source) {
     sources_.push_back(&source);
   }
 
@@ -866,19 +805,20 @@ class Network : public internal::ClockListener {
     internal::SchedulerMTAPI<Slices> sched_mtapi;
     internal::Scheduler * sched = &sched_mtapi;
 
+    internal::InitData init_data;
+    init_data.sched = sched;
+    init_data.sink_listener = this;
+
+    sink_count_ = 0;
     for (size_t it = 0; it < sources_.size(); it++)
-      sources_[it]->SetScheduler(sched);
-    for (size_t it = 0; it < processes_.size(); it++)
-      processes_[it]->SetScheduler(sched);
-    for (size_t it = 0; it < sinks_.size(); it++)
-      sinks_[it]->SetScheduler(sched);
+      sources_[it]->Init(&init_data);
 
-    for (int ii = 0; ii < Slices; ii++) sink_count_[ii] = 0;
+    for (int ii = 0; ii < Slices; ii++) sink_counter_[ii] = 0;
 
     int clock = 0;
     while (clock >= 0) {
       const int idx = clock % Slices;
-      while (sink_count_[idx] > 0) embb::base::Thread::CurrentYield();
+      while (sink_counter_[idx] > 0) embb::base::Thread::CurrentYield();
       sched->WaitForSlice(idx);
       if (!SpawnClock(clock))
         break;
@@ -889,7 +829,7 @@ class Network : public internal::ClockListener {
     if (ii < 0) ii = 0;
     for (; ii < clock; ii++) {
       const int idx = ii % Slices;
-      while (sink_count_[idx] > 0) embb::base::Thread::CurrentYield();
+      while (sink_counter_[idx] > 0) embb::base::Thread::CurrentYield();
       sched->WaitForSlice(idx);
     }
   }
@@ -902,17 +842,28 @@ class Network : public internal::ClockListener {
    */
   virtual void OnClock(int clock) {
     const int idx = clock % Slices;
-    const int cnt = --sink_count_[idx];
+    const int cnt = --sink_counter_[idx];
     if (cnt < 0)
       EMBB_THROW(embb::base::ErrorException,
         "More sinks than expected signaled reception of given clock.")
   }
 
+  /**
+   * Internal.
+   * \internal
+   * Gets called when an init token has reached all sinks.
+   */
+  virtual void OnInit(internal::InitData * /*sched*/) {
+    sink_count_++;
+  }
+
  private:
   std::vector<internal::Node*> processes_;
   std::vector<internal::Node*> sources_;
   std::vector<internal::Node*> sinks_;
-  embb::base::Atomic<int> sink_count_[Slices];
+  embb::base::Atomic<int> sink_counter_[Slices];
+  int sink_count_;
+
 #if EMBB_DATAFLOW_TRACE_SIGNAL_HISTORY
   std::vector<int> spawn_history_[Slices];
 #endif
@@ -923,7 +874,7 @@ class Network : public internal::ClockListener {
 #if EMBB_DATAFLOW_TRACE_SIGNAL_HISTORY
     spawn_history_[idx].push_back(clock);
 #endif
-    sink_count_[idx] = static_cast<int>(sinks_.size());
+    sink_counter_[idx] = sink_count_;
     for (size_t kk = 0; kk < sources_.size(); kk++) {
       result &= sources_[kk]->Start(clock);
     }

dataflow_cpp/test/dataflow_cpp_test_simple.cc

@@ -186,17 +186,8 @@ void SimpleTest::TestBasic() {
 
     sel.GetOutput<0>() >> sink.GetInput<0>();
 
-    network.Add(constant);
-    network.Add(source);
-
-    network.Add(filter);
-    network.Add(mult);
-
-    network.Add(pred);
-    network.Add(sw);
-    network.Add(sel);
-
-    network.Add(sink);
+    network.AddSource(constant);
+    network.AddSource(source);
 
     network();
 

doc/examples/CMakeLists.txt

@@ -10,6 +10,9 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/../../base_cpp/include
   ${CMAKE_CURRENT_BINARY_DIR}/../../base_cpp/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_c/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_c/src
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_network_c/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_opencl_c/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_cpp/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../../tasks_cpp/include
   ${CMAKE_CURRENT_BINARY_DIR}/../../tasks_cpp/include
@@ -20,9 +23,16 @@ include_directories(
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(CMAKE_CXX_FLAGS "-std=c++11")
+  set (EXTRA_LIBS dl)
 endif()
 
+IF(MSVC)
+  set (EXTRA_LIBS ws2_32)
+ENDIF()
+
 add_executable(examples ${EXAMPLES_SOURCES})
 target_link_libraries(examples embb_dataflow_cpp embb_algorithms_cpp embb_tasks_cpp embb_mtapi_cpp
-                      embb_mtapi_c embb_base_cpp embb_base_c embb_containers_cpp ${compiler_libs})
+                      embb_mtapi_network_c embb_mtapi_opencl_c embb_mtapi_c
+                      embb_base_cpp embb_base_c embb_containers_cpp
+                      ${EXTRA_LIBS} ${compiler_libs})
 CopyBin(BIN examples DEST ${local_install_dir})

doc/examples/dataflow/dataflow_add-snippet.h

-  nw.Add(read);
-  nw.Add(replace);
-  nw.Add(write);
+  nw.AddSource(read);

doc/examples/dataflow/dataflow_declare_add_sources-snippet.h

@@ -14,7 +14,7 @@
     source4(
       embb::base::MakeFunction(producer4, &Producer<int>::Run) );
 
-  nw.Add(source1);
-  nw.Add(source2);
-  nw.Add(source3);
-  nw.Add(source4);
+  nw.AddSource(source1);
+  nw.AddSource(source2);
+  nw.AddSource(source3);
+  nw.AddSource(source4);

doc/examples/dataflow/dataflow_nonlinear-fragmented.cc

@@ -60,19 +60,11 @@ void RunDataflowNonLinear() {
     process4( embb::base::MakeFunction(comparator, &Comparator<int>::Run) ),
     process5( embb::base::MakeFunction(comparator, &Comparator<int>::Run) );
 
-  nw.Add(process1);
-  nw.Add(process2);
-  nw.Add(process3);
-  nw.Add(process4);
-  nw.Add(process5);
-
   Consumer<int> consumer;
 
   Network::Sink<int, int, int, int>
     sink1(embb::base::MakeFunction(consumer, &Consumer<int>::Run));
 
-  nw.Add(sink1);
-
   source1.GetOutput<0>() >> process1.GetInput<0>();
   source2.GetOutput<0>() >> process2.GetInput<0>();
   source3.GetOutput<0>() >> process1.GetInput<1>();

doc/examples/main.cc

@@ -28,6 +28,9 @@
 #include <embb/base/c/thread.h>
 
 void RunMTAPI_C();
+void RunMTAPI_C_Plugin();
+void RunMTAPI_C_Network();
+void RunMTAPI_C_OpenCL();
 void RunMTAPI_CPP();
 void RunTasks();
 void RunDataflowLinear();
@@ -55,6 +58,18 @@ int main() {
   RunMTAPI_C();
   std::cout << "RunMTAPI_C() ... done" << std::endl;
 
+  std::cout << "RunMTAPI_C_Plugin() ..." << std::endl;
+  RunMTAPI_C_Plugin();
+  std::cout << "RunMTAPI_C_Plugin() ... done" << std::endl;
+
+  std::cout << "RunMTAPI_C_Network() ..." << std::endl;
+  RunMTAPI_C_Network();
+  std::cout << "RunMTAPI_C_Network() ... done" << std::endl;
+
+  std::cout << "RunMTAPI_C_OpenCL() ..." << std::endl;
+  RunMTAPI_C_OpenCL();
+  std::cout << "RunMTAPI_C_OpenCL() ... done" << std::endl;
+
   std::cout << "RunMTAPI_CPP() ..." << std::endl;
   RunMTAPI_CPP();
   std::cout << "RunMTAPI_CPP() ... done" << std::endl;

doc/examples/mtapi/mtapi_c_network-fragmented.cc

+/*
+ * Copyright (c) 2014-2015, 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/c/mtapi.h>
+#include "mtapi_network_c_header-snippet.h"
+#include <embb/base/c/internal/unused.h>
+
+#include "mtapi_check_status-snippet.h"
+
+#define NETWORK_DOMAIN 1
+#define NETWORK_LOCAL_NODE 3
+#define NETWORK_LOCAL_JOB 3
+#define NETWORK_REMOTE_NODE 3
+#define NETWORK_REMOTE_JOB 4
+
+#include "mtapi_network_c_action_function-snippet.h"
+
+void RunMTAPI_C_Network() {
+  mtapi_status_t status;
+  mtapi_job_hndl_t job;
+  mtapi_task_hndl_t task;
+  mtapi_action_hndl_t network_action, local_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_initialize(
+    NETWORK_DOMAIN,
+    NETWORK_LOCAL_NODE,
+    MTAPI_DEFAULT_NODE_ATTRIBUTES,
+    MTAPI_NULL,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_network_c_plugin_initialize-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_network_c_remote_action_create-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_network_c_local_action_create-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+  job = mtapi_job_get(NETWORK_LOCAL_JOB, NETWORK_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++) {
+    if (results[ii] != ii * 2 + 1) {
+      printf("result %d was expected to be %d but was %f.\n",
+        ii, ii * 2 + 1, results[ii]);
+      exit(MTAPI_ERR_UNKNOWN);
+    }
+  }
+
+#include "mtapi_network_c_plugin_finalize-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+}

doc/examples/mtapi/mtapi_c_opencl-fragmented.cc

+/*
+ * Copyright (c) 2014-2015, 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/c/mtapi.h>
+#include "mtapi_opencl_c_header-snippet.h"
+
+#include "mtapi_check_status-snippet.h"
+
+#define OPENCL_DOMAIN 1
+#define OPENCL_NODE 2
+#define OPENCL_JOB 2
+
+// OpenCL Kernel Function for element by element vector addition
+#include "mtapi_opencl_c_kernel-snippet.h"
+
+void RunMTAPI_C_OpenCL() {
+  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_initialize(
+    OPENCL_DOMAIN,
+    OPENCL_NODE,
+    MTAPI_DEFAULT_NODE_ATTRIBUTES,
+    MTAPI_NULL,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_opencl_c_plugin_initialize-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_opencl_c_action_create-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  job = mtapi_job_get(OPENCL_JOB, OPENCL_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++) {
+    if (results[ii] != ii * 2 + 1) {
+      printf("result %d was expected to be %d but was %f.\n",
+        ii, ii * 2 + 1, results[ii]);
+      exit(MTAPI_ERR_UNKNOWN);
+    }
+  }
+
+#include "mtapi_opencl_c_plugin_finalize-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+}

doc/examples/mtapi/mtapi_c_plugin-fragmented.cc

+/*
+ * Copyright (c) 2014-2015, 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/c/mtapi.h>
+#include <embb/mtapi/c/mtapi_ext.h>
+
+#include <embb_mtapi_task_t.h>
+#include <embb_mtapi_action_t.h>
+#include <embb_mtapi_node_t.h>
+
+#include <mtapi_status_t.h>
+
+#include <embb/base/c/memory_allocation.h>
+#include <embb/base/c/thread.h>
+#include <embb/base/c/atomic.h>
+#include <embb/base/c/internal/unused.h>
+
+#define PLUGIN_DOMAIN_ID 1
+#define PLUGIN_NODE_ID 1
+#define PLUGIN_JOB_ID 1
+
+#include "mtapi_check_status-snippet.h"
+
+#include "mtapi_c_plugin_task_schedule-snippet.h"
+
+#include "mtapi_c_plugin_task_start_cb-snippet.h"
+
+#include "mtapi_c_plugin_task_cancel_cb-snippet.h"
+
+#include "mtapi_c_plugin_action_finalize_cb-snippet.h"
+
+void RunMTAPI_C_Plugin() {
+  mtapi_status_t status;
+  mtapi_job_hndl_t job;
+  mtapi_action_hndl_t action;
+  mtapi_task_hndl_t task;
+
+  mtapi_initialize(
+    PLUGIN_DOMAIN_ID,
+    PLUGIN_NODE_ID,
+    MTAPI_DEFAULT_NODE_ATTRIBUTES,
+    MTAPI_NULL,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_c_plugin_action_create-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_c_plugin_get_job-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+#include "mtapi_c_plugin_task_start-snippet.h"
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_task_wait(task, MTAPI_INFINITE, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+}

doc/examples/mtapi/mtapi_c_plugin_action_create-snippet.h

+action = mtapi_ext_plugin_action_create(
+  PLUGIN_JOB_ID,
+  plugin_task_start,
+  plugin_task_cancel,
+  plugin_action_finalize,
+  MTAPI_NULL,
+  MTAPI_NULL,
+  0,
+  MTAPI_DEFAULT_ACTION_ATTRIBUTES,
+  &status);

doc/examples/mtapi/mtapi_c_plugin_action_finalize_cb-snippet.h

+void plugin_action_finalize(
+  MTAPI_IN mtapi_action_hndl_t action,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  EMBB_UNUSED(action);
+  // nothing to do for tearing down the plugin action
+  mtapi_status_set(status, MTAPI_SUCCESS);
+}

doc/examples/mtapi/mtapi_c_plugin_get_job-snippet.h

+  job = mtapi_job_get(
+    PLUGIN_JOB_ID,
+    PLUGIN_DOMAIN_ID,
+    &status);

doc/examples/mtapi/mtapi_c_plugin_task_cancel_cb-snippet.h

+void plugin_task_cancel(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  EMBB_UNUSED(task);
+  // nothing to cancel in this simple example
+  mtapi_status_set(status, MTAPI_SUCCESS);
+}

doc/examples/mtapi/mtapi_c_plugin_task_schedule-snippet.h

+void plugin_task_schedule(embb_mtapi_task_t* local_task) {
+  // here the task might be dispatched to some hardware or separate thread
+
+  // mark the task as running
+  embb_mtapi_task_set_state(local_task, MTAPI_TASK_RUNNING);
+
+  // nothing to do to execute the no-op task
+
+  // just mark the task as done
+  embb_mtapi_task_set_state(local_task, MTAPI_TASK_COMPLETED);
+}

doc/examples/mtapi/mtapi_c_plugin_task_start-snippet.h

+  task = mtapi_task_start(
+    MTAPI_TASK_ID_NONE,
+    job,
+    MTAPI_NULL, 0,
+    MTAPI_NULL, 0,
+    MTAPI_DEFAULT_TASK_ATTRIBUTES,
+    MTAPI_GROUP_NONE,
+    &status);

doc/examples/mtapi/mtapi_c_plugin_task_start_cb-snippet.h

+void plugin_task_start(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  // do we have a node?
+  if (embb_mtapi_node_is_initialized()) {
+    // get the node instance
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+    // is this a valid task?
+    if (embb_mtapi_task_pool_is_handle_valid(node->task_pool, task)) {
+      // get the tasks storage
+      embb_mtapi_task_t * local_task =
+        embb_mtapi_task_pool_get_storage_for_handle(node->task_pool, task);
+
+      // dispatch the task
+      plugin_task_schedule(local_task);
+
+      local_status = MTAPI_SUCCESS;
+    }
+    else {
+      local_status = MTAPI_ERR_TASK_INVALID;
+    }
+  }
+  else {
+    local_status = MTAPI_ERR_NODE_NOTINIT;
+  }
+
+  mtapi_status_set(status, local_status);
+}

doc/examples/mtapi/mtapi_network_c_action_function-snippet.h

+static void AddVectorAction(
+  void const * arguments,
+  mtapi_size_t arguments_size,
+  void * result_buffer,
+  mtapi_size_t result_buffer_size,
+  void const * node_local_data,
+  mtapi_size_t node_local_data_size,
+  mtapi_task_context_t * context) {
+  EMBB_UNUSED(context);
+  EMBB_UNUSED(result_buffer_size);
+  EMBB_UNUSED(node_local_data_size);
+  int elements = static_cast<int>(arguments_size / sizeof(float) / 2);
+  float const * a = reinterpret_cast<float const *>(arguments);
+  float const * b = reinterpret_cast<float const *>(arguments)+elements;
+  float * c = reinterpret_cast<float*>(result_buffer);
+  float const * d = reinterpret_cast<float const *>(node_local_data);
+  for (int ii = 0; ii < elements; ii++) {
+    c[ii] = a[ii] + b[ii] + d[0];
+  }
+}

doc/examples/mtapi/mtapi_network_c_header-snippet.h

+#include <embb/mtapi/c/mtapi_network.h>

doc/examples/mtapi/mtapi_network_c_local_action_create-snippet.h

+  network_action = mtapi_network_action_create(
+    NETWORK_DOMAIN,
+    NETWORK_LOCAL_JOB,
+    NETWORK_REMOTE_JOB,
+    "127.0.0.1", 12345,
+    &status);

doc/examples/mtapi/mtapi_network_c_plugin_finalize-snippet.h

+  mtapi_network_plugin_finalize(&status);

doc/examples/mtapi/mtapi_network_c_plugin_initialize-snippet.h

+  mtapi_network_plugin_initialize("127.0.0.1", 12345, 5,
+    kElements * 4 * 3 + 32, &status);

doc/examples/mtapi/mtapi_network_c_remote_action_create-snippet.h

+  float node_remote = 1.0f;
+  local_action = mtapi_action_create(
+    NETWORK_REMOTE_JOB,
+    AddVectorAction,
+    &node_remote, sizeof(float),
+    MTAPI_DEFAULT_ACTION_ATTRIBUTES,
+    &status);

doc/examples/mtapi/mtapi_opencl_c_action_create-snippet.h

+  float node_local = 1.0f;
+  action = mtapi_opencl_action_create(
+    OPENCL_JOB,
+    kernel, "AddVector", 32, 4,
+    &node_local, sizeof(float),
+    &status);

doc/examples/mtapi/mtapi_opencl_c_header-snippet.h

+#include <embb/mtapi/c/mtapi_opencl.h>

doc/examples/mtapi/mtapi_opencl_c_kernel-snippet.h

+const char * kernel =
+"__kernel void AddVector(\n"
+"  __global void* arguments,\n"
+"  int arguments_size,\n"
+"  __global void* result_buffer,\n"
+"  int result_buffer_size,\n"
+"  __global void* node_local_data,\n"
+"  int node_local_data_size) {\n"
+"  int ii = get_global_id(0);\n"
+"  int elements = arguments_size / sizeof(float) / 2;\n"
+"  if (ii >= elements)"
+"    return;"
+"  __global float* a = (__global float*)arguments;\n"
+"  __global float* b = ((__global float*)arguments) + elements;\n"
+"  __global float* c = (__global float*)result_buffer;\n"
+"  __global float* d = (__global float*)node_local_data;\n"
+"  c[ii] = a[ii] + b[ii] + d[0];\n"
+"}\n";

doc/examples/mtapi/mtapi_opencl_c_plugin_finalize-snippet.h

+  mtapi_opencl_plugin_finalize(&status);

doc/examples/mtapi/mtapi_opencl_c_plugin_initialize-snippet.h

+  mtapi_opencl_plugin_initialize(&status);

doc/reference/Doxyfile.in

@@ -152,7 +152,10 @@ INPUT                  = "@CMAKE_SOURCE_DIR@/doc/reference/embb.dox" \
                          "@CMAKE_SOURCE_DIR@/mtapi_cpp/include" \
                          "@CMAKE_SOURCE_DIR@/base_cpp/include" \
                          "@CMAKE_SOURCE_DIR@/mtapi_c/include" \
-                         "@CMAKE_SOURCE_DIR@/base_c/include"
+                         "@CMAKE_SOURCE_DIR@/base_c/include" \
+                         "@CMAKE_SOURCE_DIR@/mtapi_opencl_c/include" \
+                         "@CMAKE_SOURCE_DIR@/mtapi_network_c/include"
+
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
                          *.cc \

doc/tutorial/content/dataflow.tex

@@ -142,7 +142,7 @@ is used to construct the sink:
 
 \emph{\textbf{Note:} If you parallelize your own application using \embb and your compiler emits a lengthy error message containing lots of templates, it is very likely that for at least one process, the ports and their directions do not match the signature of the given function.}
 
-The network needs to know about the processes declared above, so we add them to our network:
+The network needs to know about the source declared above, so we add it to our network:
 %
 \\\inputlisting{../examples/dataflow/dataflow_add-snippet.h}
 %
@@ -303,11 +303,11 @@ The class-based approach has several advantages besides the use of templates: Fi
 
 Each instance of the class \lstinline|Network| maintains a list of source processes that belong to the network.
 % When you create a source process using \lstinline|MakeSource|, it is automatically added to this list. Otherwise, you must explicitly add it by a call to \lstinline|Add|. For example, if we want to feed our sorting network \lstinline|nw| with streams of integer values, we may write:
-You must explicitly add all processes to the network by a call to \lstinline|Add|. For example, if we want to feed our sorting network \lstinline|nw| with four streams of integer values, we may write:
+You must explicitly add all sources to the network by a call to \lstinline|AddSource|. For example, if we want to feed our sorting network \lstinline|nw| with four streams of integer values, we may write:
 %
 \\\inputlisting{../examples/dataflow/dataflow_declare_add_sources-snippet.h}
 %
-%This is only necessary for source processes. All other processes are automatically found via a depth-first search starting from the source processes.
+This is only necessary for source processes. All other processes are automatically found via a depth-first search starting from the source processes.
 
 The code for the comparators looks like this:
 %

doc/tutorial/content/mtapi.tex

@@ -202,3 +202,126 @@ Again, the started task has to be waited for (using \lstinline|embb::mtapi::Task
 The registered action will be unregistered when it goes out of scope.
 The runtime needs to be shut down by calling:
 \\\inputlisting{../examples/mtapi/mtapi_cpp_finalize-snippet.h}
+
+\section{Plugins}
+
+The \embb implementation of MTAPI provides an extension to allow for custom actions that are not executed by the scheduler for software actions as detailed in the previous sections.
+Two plugins are delivered with \embb, one for supporting distributed systems through TCP/IP networking and the other to allow for transparently using OpenCL accelerators.
+
+\subsection{Plugin API}
+
+The plugin API consists of a single function named \lstinline|mtapi_ext_plugin_action_create()| contained in the mtapi\_ext.h header file. It is used to associate the plugin action with a specific job ID:
+\begin{lstlisting}
+mtapi_action_hndl_t mtapi_ext_plugin_action_create(
+  MTAPI_IN mtapi_job_id_t job_id,
+  MTAPI_IN mtapi_ext_plugin_task_start_function_t task_start_function,
+  MTAPI_IN mtapi_ext_plugin_task_cancel_function_t task_cancel_function,
+  MTAPI_IN mtapi_ext_plugin_action_finalize_function_t action_finalize_function,
+  MTAPI_IN void* plugin_data,
+  MTAPI_IN void* node_local_data,
+  MTAPI_IN mtapi_size_t node_local_data_size,
+  MTAPI_IN mtapi_action_attributes_t* attributes,
+  MTAPI_OUT mtapi_status_t* status
+);
+\end{lstlisting}
+The plugin action is implemented through 3 callbacks, task start, task cancel and action finalize.
+
+\lstinline|task_start_function| is called when the user requests execution of the plugin action by calling \lstinline|mtapi_task_start()| or \lstinline|mtapi_task_enqueue()|. To those functions the fact that they operate on a plugin action is transparent, they only require the job handle of the job the action was registered with.
+
+\lstinline|task_cancel_function| is called when the user requests cancelation of a tasks by calling \lstinline|mtapi_task_cancel()| or by calling \lstinline|mtapi_queue_disable()| on a non-retaining queue.
+
+\lstinline|action_finalize_function| is called when the node is finalized and the action is deleted, or when the user explicitly deletes the action by calling \lstinline|mtapi_action_delete()|.
+
+For illustration our example plugin will provide a no-op action. The task start callback in that case looks like this:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_task_start_cb-snippet.h}
+%
+The scheduling operation is responsible for bringing the task to execution, this might involve instructing some hardware to execute the task or pushing the task into a queue for execution by a separate worker thread. Here however, the task is executed directly:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_task_schedule-snippet.h}
+%
+Since the task gets executed right away, it cannot be canceled and the task cancel callback implementation is empty:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_task_cancel_cb-snippet.h}
+%
+The plugin action did not acquire any resources so the action finalize callback is empty as well:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_action_finalize_cb-snippet.h}
+%
+
+Now that the callbacks are in place, the action can be registered with a job after the node was initialized using \lstinline|mtapi_initialize()|:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_action_create-snippet.h}
+%
+The job handle can now be obtained the normal MTAPI way. The fact that there is a plugin working behind the scenes is transparent by now:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_get_job-snippet.h}
+%
+Using the job handle tasks can be started like normal MTAPI tasks:
+%
+\\\inputlisting{../examples/mtapi/mtapi_c_plugin_task_start-snippet.h}
+%
+This call will lead to the invocation of then \lstinline|plugin_task_start| callback function, where the plugin implementor is responsible for bringing the task to execution.
+
+\subsection{Network}
+
+The MTAPI network plugin provides a means to distribute tasks over a TCP/IP network. As an example the following vector addition action is used:
+%
+\\\inputlisting{../examples/mtapi/mtapi_network_c_action_function-snippet.h}
+%
+It adds two float vectors and a float from node local data and writes the result into the result float vector. In the example code the vectors will hold \lstinline|kElements| floats each.
+
+To use the network plugin, its header file needs to be included first:
+%
+\\\inputlisting{../examples/mtapi/mtapi_network_c_header-snippet.h}
+%
+After initializing the node using \lstinline|mtapi_initialize()|, the plugin itself needs to be initialized:
+%
+\\\inputlisting{../examples/mtapi/mtapi_network_c_plugin_initialize-snippet.h}
+%
+This will set up a listening socket on the localhost interface (127.0.0.1) at port 12345. The socket will allow a maximum of 5 connections and have a maximum transfer buffer size of \lstinline|kElements * 4 * 3 + 32|. This buffer size needs to be big enough to fit at least the argument and result buffer sizes at once. The example uses 3 vectors of \lstinline|kElements| floats using \lstinline|kElements * sizeof(float) * 3| bytes.
+
+Since the example connects to itself on localhost, the "remote" action needs to be registered with the \lstinline|NETWORK_REMOTE_JOB|:
+%
+\\\inputlisting{../examples/mtapi/mtapi_network_c_remote_action_create-snippet.h}
+%
+After that, the local network action is created, that maps \lstinline|NETWORK_LOCAL_JOB| to \lstinline|NETWORK_REMOTE_JOB| through the network:
+%
+\\\inputlisting{../examples/mtapi/mtapi_network_c_local_action_create-snippet.h}
+%
+Now, \lstinline|NETWORK_LOCAL_JOB| can be used to execute tasks by simply calling \lstinline|mtapi_task_start()|. Their parameters will be transmitted through a socket connection and are consumed by the network plugin worker thread. The thread will start a task using the \lstinline|NETWORK_REMOTE_JOB|. When this task is finished, the results will be collected and sent back through the network. Again the network plugin thread will receive the results, provide them to the \lstinline|NETWORK_LOCAL_JOB| task and mark that task as finished.
+
+When all work is done, the plugin needs to be finalized. This will stop the plugin worker thread and close the sockets:
+%
+\\\inputlisting{../examples/mtapi/mtapi_network_c_plugin_finalize-snippet.h}
+%
+Then the node may be finalized by calling \lstinline|mtapi_finalize()|.
+
+\subsection{OpenCL}
+
+The MTAPI OpenCL plugin allows the user to incorporate the computational power of an OpenCL accelerator, if one is available in the system.
+
+The vector addition example from the network plugin is used again. However, the action function is an OpenCL kernel now:
+%
+\\\inputlisting{../examples/mtapi/mtapi_opencl_c_kernel-snippet.h}
+%
+The OpenCL plugin header file needs to be included first:
+%
+\\\inputlisting{../examples/mtapi/mtapi_opencl_c_header-snippet.h}
+%
+As with the network plugin, the OpenCL plugin needs to be initialized after the node has been initialized:
+%
+\\\inputlisting{../examples/mtapi/mtapi_opencl_c_plugin_initialize-snippet.h}
+%
+Then the plugin action can be registered with the \lstinline|OPENCL_JOB|:
+%
+\\\inputlisting{../examples/mtapi/mtapi_opencl_c_action_create-snippet.h}
+%
+The kernel source and the name of the kernel to use (AddVector) need to be specified while creating the action. The kernel will be compiled using the OpenCL runtime and the provided node local data transferred to accelerator memory. The local work size is the number of threads that will share OpenCL local memory, in this case 32. The element size instructs the OpenCL plugin how many bytes a single element in the result buffer consumes, in this case 4, as a single result is a single float. The OpenCL plugin will launch \lstinline|result_buffer_size/element_size| OpenCL threads to calculate the result.
+
+Now the \lstinline|OPENCL_JOB| can be used like a normal MTAPI job to start tasks.
+
+After all work is done, the plugin needs to be finalized. This will free all memory on the accelerator and delete the corresponding OpenCL context:
+%
+\\\inputlisting{../examples/mtapi/mtapi_opencl_c_plugin_finalize-snippet.h}
+%

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

@@ -557,6 +557,17 @@ enum mtapi_node_attributes_enum {
 #define MTAPI_NODE_TYPE_SMP 1
 #define MTAPI_NODE_TYPE_DSP 2
 
+/**
+ * Task handle type.
+ * \memberof mtapi_task_hndl_struct
+ */
+typedef struct mtapi_task_hndl_struct mtapi_task_hndl_t;
+
+/** task completion callback */
+typedef void(*mtapi_task_complete_function_t)(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status);
+
 /** task attributes */
 enum mtapi_task_attributes_enum {
   MTAPI_TASK_DETACHED,                 /**< task is detached, i.e., the runtime
@@ -574,7 +585,9 @@ enum mtapi_task_attributes_enum {
                                             executed n times, if possible in
                                             parallel */
   MTAPI_TASK_PRIORITY,
-  MTAPI_TASK_AFFINITY
+  MTAPI_TASK_AFFINITY,
+  MTAPI_TASK_USER_DATA,
+  MTAPI_TASK_COMPLETE_FUNCTION
 };
 /** size of the \a MTAPI_TASK_DETACHED attribute */
 #define MTAPI_TASK_DETACHED_SIZE sizeof(mtapi_boolean_t)
@@ -671,6 +684,10 @@ struct mtapi_task_attributes_struct {
   mtapi_uint_t num_instances;          /**< stores MTAPI_TASK_INSTANCES */
   mtapi_uint_t priority;               /**< stores MTAPI_TASK_PRIORITY */
   mtapi_affinity_t affinity;           /**< stores MTAPI_TASK_AFFINITY */
+  void * user_data;                    /**< stores MTAPI_TASK_USER_DATA */
+  mtapi_task_complete_function_t
+    complete_func;                     /**< stores
+                                            MTAPI_TASK_COMPLETE_FUNCTION */
 };
 
 /**
@@ -869,11 +886,8 @@ struct mtapi_task_hndl_struct {
   mtapi_task_id_t id;                  /**< pool index of this handle */
 };
 
-/**
- * Task handle type.
- * \memberof mtapi_task_hndl_struct
- */
-typedef struct mtapi_task_hndl_struct mtapi_task_hndl_t;
+// was forward declared
+//typedef struct mtapi_task_hndl_struct mtapi_task_hndl_t;
 
 
 /* ---- BASIC CONSTANTS ---------------------------------------------------- */

mtapi_c/include/embb/mtapi/c/mtapi_ext.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_EXT_H_
+#define EMBB_MTAPI_C_MTAPI_EXT_H_
+
+
+#include <embb/mtapi/c/mtapi.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \defgroup C_MTAPI_EXT MTAPI Extensions
+ *
+ * \ingroup C_MTAPI
+ *
+ * Provides extensions to the standard MTAPI API.
+ *
+ * There is a single extension function defined here to support user defined
+ * behavior of an action to allow for actions that are not implemented locally
+ * in software but e.g. on a remote node in a network or on an accelerator
+ * device like a GPU or FPGA.
+ */
+
+/**
+ * Represents a callback function that is called when a plugin action is about
+ * to start a plugin task.
+ * This function should return MTAPI_SUCCESS if the task could be started and
+ * the appropriate MTAPI_ERR_* if not.
+ *
+ * \ingroup C_MTAPI_EXT
+ */
+typedef void(*mtapi_ext_plugin_task_start_function_t)(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status
+);
+
+/**
+ * Represents a callback function that is called when a plugin task is about
+ * to be canceled.
+ * This function should return MTAPI_SUCCESS if the task could be canceled and
+ * the appropriate MTAPI_ERR_* if not.
+ *
+ * \ingroup C_MTAPI_EXT
+ */
+typedef void(*mtapi_ext_plugin_task_cancel_function_t)(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status
+);
+
+/**
+ * Represents a callback function that is called when a plugin action is about
+ * to be finalized.
+ * This function should return MTAPI_SUCCESS if the action could be deleted and
+ * the appropriate MTAPI_ERR_* if not.
+ *
+ * \ingroup C_MTAPI_EXT
+ */
+typedef void(*mtapi_ext_plugin_action_finalize_function_t)(
+  MTAPI_IN mtapi_action_hndl_t action,
+  MTAPI_OUT mtapi_status_t* status
+);
+
+/**
+ * This function creates a plugin action.
+ *
+ * It is called on the node where the plugin action is implemented. A plugin
+ * action is an abstract encapsulation of a user defined action that is needed
+ * to implement a job that does not represent a software action. A plugin
+ * action contains a reference to a job, callback functions to start and cancel
+ * tasks and a reference to an callback function to finalize the action.
+ * After a plugin 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 plugin action's
+ * life-cycle begins with mtapi_ext_plugin_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 action 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>
+ * </table>
+ *
+ * \see mtapi_action_delete(), mtapi_finalize()
+ *
+ * \returns Handle to newly created plugin action, invalid handle on error
+ * \threadsafe
+ * \ingroup C_MTAPI_EXT
+ */
+mtapi_action_hndl_t mtapi_ext_plugin_action_create(
+  MTAPI_IN mtapi_job_id_t job_id,
+  MTAPI_IN mtapi_ext_plugin_task_start_function_t task_start_function,
+  MTAPI_IN mtapi_ext_plugin_task_cancel_function_t task_cancel_function,
+  MTAPI_IN mtapi_ext_plugin_action_finalize_function_t action_finalize_function,
+  MTAPI_IN void* plugin_data,
+  MTAPI_IN void* node_local_data,
+  MTAPI_IN mtapi_size_t node_local_data_size,
+  MTAPI_IN mtapi_action_attributes_t* attributes,
+  MTAPI_OUT mtapi_status_t* status
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // EMBB_MTAPI_C_MTAPI_EXT_H_

mtapi_c/include/mtapi_ext.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_EXT_H_
+#define MTAPI_EXT_H_
+
+// Just includes the actual MTAPI extension header for standard conformity
+
+#include <embb/mtapi/c/mtapi_ext.h>
+
+#endif // MTAPI_EXT_H_

mtapi_c/src/embb_mtapi_action_plugin_t.c

+/*
+ * 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/c/mtapi_ext.h>
+#include <embb_mtapi_action_t.h>
+#include <embb_mtapi_node_t.h>
+#include <embb_mtapi_job_t.h>
+#include <embb_mtapi_log.h>
+#include <mtapi_status_t.h>
+
+mtapi_action_hndl_t mtapi_ext_plugin_action_create(
+  MTAPI_IN mtapi_job_id_t job_id,
+  MTAPI_IN mtapi_ext_plugin_task_start_function_t task_start_function,
+  MTAPI_IN mtapi_ext_plugin_task_cancel_function_t task_cancel_function,
+  MTAPI_IN mtapi_ext_plugin_action_finalize_function_t
+    action_finalize_function,
+  MTAPI_IN void* plugin_data,
+  MTAPI_IN void* node_local_data,
+  MTAPI_IN mtapi_size_t node_local_data_size,
+  MTAPI_IN mtapi_action_attributes_t* attributes,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  mtapi_action_hndl_t action_handle = { 0, EMBB_MTAPI_IDPOOL_INVALID_ID };
+
+  embb_mtapi_log_trace("mtapi_ext_plugin_action_create() called\n");
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t* node = embb_mtapi_node_get_instance();
+    /* check if job is valid */
+    if (embb_mtapi_job_is_id_valid(node, job_id)) {
+      embb_mtapi_job_t* job = embb_mtapi_job_get_storage_for_id(node, job_id);
+      embb_mtapi_action_t* new_action =
+        embb_mtapi_action_pool_allocate(node->action_pool);
+      if (MTAPI_NULL != new_action) {
+        new_action->domain_id = node->domain_id;
+        new_action->node_id = node->node_id;
+        new_action->job_id = job_id;
+        new_action->node_local_data = node_local_data;
+        new_action->node_local_data_size = node_local_data_size;
+        new_action->enabled = MTAPI_TRUE;
+        new_action->is_plugin_action = MTAPI_TRUE;
+        embb_atomic_store_int(&new_action->num_tasks, 0);
+
+        new_action->plugin_task_start_function = task_start_function;
+        new_action->plugin_task_cancel_function = task_cancel_function;
+        new_action->plugin_action_finalize_function = action_finalize_function;
+        new_action->plugin_data = (void*)plugin_data;
+
+        /* set defaults if no attributes were given */
+        if (MTAPI_NULL != attributes) {
+          new_action->attributes = *attributes;
+          local_status = MTAPI_SUCCESS;
+        } else {
+          /* use the default */
+          mtapi_actionattr_init(&new_action->attributes, &local_status);
+        }
+
+        /* check if affinity is sane */
+        if (0 == new_action->attributes.affinity) {
+          local_status = MTAPI_ERR_PARAMETER;
+        }
+
+        if (MTAPI_SUCCESS == local_status) {
+          action_handle = new_action->handle;
+          embb_mtapi_job_add_action(job, new_action);
+        } else {
+          embb_mtapi_action_pool_deallocate(node->action_pool, new_action);
+        }
+      } else {
+        /* no more space left in action pool */
+        local_status = MTAPI_ERR_ACTION_LIMIT;
+      }
+    } else {
+      local_status = MTAPI_ERR_JOB_INVALID;
+    }
+  } else {
+    embb_mtapi_log_error("mtapi not initialized\n");
+    local_status = MTAPI_ERR_NODE_NOTINIT;
+  }
+
+  mtapi_status_set(status, local_status);
+  return action_handle;
+}

mtapi_c/src/embb_mtapi_action_t.c

@@ -56,10 +56,15 @@ void embb_mtapi_action_initialize(embb_mtapi_action_t* that) {
   that->enabled = MTAPI_FALSE;
   that->node_local_data = NULL;
   that->node_local_data_size = 0;
+  that->plugin_data = MTAPI_NULL;
   embb_atomic_store_int(&that->num_tasks, 0);
 }
 
 void embb_mtapi_action_finalize(embb_mtapi_action_t* that) {
+  if (that->is_plugin_action) {
+    // TODO(mw): check status
+    that->plugin_action_finalize_function(that->handle, NULL);
+  }
   embb_mtapi_action_initialize(that);
 }
 
@@ -131,12 +136,14 @@ mtapi_action_hndl_t mtapi_action_create(
         new_action->domain_id = node->domain_id;
         new_action->node_id = node->node_id;
         new_action->job_id = job_id;
-        new_action->action_function = action_function;
         new_action->node_local_data = node_local_data;
         new_action->node_local_data_size = node_local_data_size;
         new_action->enabled = MTAPI_TRUE;
+        new_action->is_plugin_action = MTAPI_FALSE;
         embb_atomic_store_int(&new_action->num_tasks, 0);
 
+        new_action->action_function = action_function;
+
         /* set defaults if no attributes were given */
         if (MTAPI_NULL != attributes) {
           new_action->attributes = *attributes;
@@ -322,7 +329,8 @@ void mtapi_action_delete(
           node, local_action->job_id);
         embb_mtapi_job_remove_action(local_job, local_action);
       }
-      embb_mtapi_action_finalize(local_action);
+      /* this is done by pool deallocate:
+         embb_mtapi_action_finalize(local_action); */
       embb_mtapi_action_pool_deallocate(node->action_pool, local_action);
     } else {
       local_status = MTAPI_ERR_ACTION_INVALID;

mtapi_c/src/embb_mtapi_action_t.h

@@ -27,7 +27,7 @@
 #ifndef MTAPI_C_SRC_EMBB_MTAPI_ACTION_T_H_
 #define MTAPI_C_SRC_EMBB_MTAPI_ACTION_T_H_
 
-#include <embb/mtapi/c/mtapi.h>
+#include <embb/mtapi/c/mtapi_ext.h>
 #include <embb/base/c/atomic.h>
 
 #include <embb_mtapi_pool_template.h>
@@ -57,6 +57,12 @@ struct embb_mtapi_action_struct {
   mtapi_action_attributes_t attributes;
   mtapi_boolean_t enabled;
 
+  mtapi_boolean_t is_plugin_action;
+  void* plugin_data;
+  mtapi_ext_plugin_task_start_function_t plugin_task_start_function;
+  mtapi_ext_plugin_task_cancel_function_t plugin_task_cancel_function;
+  mtapi_ext_plugin_action_finalize_function_t plugin_action_finalize_function;
+
   embb_atomic_int num_tasks;
 };
 

mtapi_c/src/embb_mtapi_node_t.c

@@ -131,6 +131,11 @@ void mtapi_initialize(
 
           /* initialization succeeded, tell workers to start working */
           embb_atomic_store_int(&node->is_scheduler_running, MTAPI_TRUE);
+
+          if (MTAPI_SUCCESS != local_status) {
+            mtapi_finalize(MTAPI_NULL);
+            local_status = MTAPI_ERR_NODE_INITFAILED;
+          }
         } else {
           mtapi_finalize(MTAPI_NULL);
           local_status = MTAPI_ERR_NODE_INITFAILED;

mtapi_c/src/embb_mtapi_scheduler_t.c

@@ -350,6 +350,11 @@ int embb_mtapi_scheduler_worker(void * arg) {
         /* do nothing, although this is an error */
         break;
       }
+
+      /* issue task complete callback if set */
+      if (MTAPI_NULL != task->attributes.complete_func) {
+        task->attributes.complete_func(task->handle, MTAPI_NULL);
+      }
     } else if (counter < 1024) {
       /* spin and yield for a while before going to sleep */
       embb_thread_yield();

mtapi_c/src/embb_mtapi_task_t.c

@@ -227,9 +227,23 @@ static mtapi_task_hndl_t embb_mtapi_task_start(
           task->queue.id = EMBB_MTAPI_IDPOOL_INVALID_ID;
         }
 
-        /* load balancing is unsupported right now,
-           so always choose action 0 */
+        /* load balancing: choose action with minimum tasks */
         action_index = 0;
+        for (mtapi_uint_t ii = 0; ii < local_job->num_actions; ii++) {
+          if (embb_mtapi_action_pool_is_handle_valid(
+            node->action_pool, local_job->actions[ii])) {
+            embb_mtapi_action_t * act_m =
+              embb_mtapi_action_pool_get_storage_for_handle(
+              node->action_pool, local_job->actions[action_index]);
+            embb_mtapi_action_t * act_i =
+              embb_mtapi_action_pool_get_storage_for_handle(
+              node->action_pool, local_job->actions[ii]);
+            if (embb_atomic_load_int(&act_m->num_tasks) >
+              embb_atomic_load_int(&act_i->num_tasks)) {
+              action_index = ii;
+            }
+          }
+        }
         if (embb_mtapi_action_pool_is_handle_valid(
           node->action_pool, local_job->actions[action_index])) {
           task->action = local_job->actions[action_index];
@@ -248,15 +262,29 @@ static mtapi_task_hndl_t embb_mtapi_task_start(
         if (MTAPI_SUCCESS == local_status) {
           embb_mtapi_scheduler_t * scheduler = node->scheduler;
           mtapi_boolean_t was_scheduled;
+          embb_mtapi_action_t * local_action =
+            embb_mtapi_action_pool_get_storage_for_handle(
+              node->action_pool, task->action);
 
           embb_mtapi_task_set_state(task, MTAPI_TASK_SCHEDULED);
 
+          if (local_action->is_plugin_action) {
+            /* schedule plugin task */
+            mtapi_status_t plugin_status = MTAPI_ERR_UNKNOWN;
+            local_action->plugin_task_start_function(
+              task_hndl, &plugin_status);
+            was_scheduled = (MTAPI_SUCCESS == plugin_status) ?
+              MTAPI_TRUE : MTAPI_FALSE;
+          } else {
+            /* schedule local task */
             was_scheduled = MTAPI_TRUE;
 
-          for (mtapi_uint_t kk = 0; kk < task->attributes.num_instances; kk++) {
+            for (mtapi_uint_t kk = 0; kk < task->attributes.num_instances;
+              kk++) {
               was_scheduled = was_scheduled &
                 embb_mtapi_scheduler_schedule_task(scheduler, task, kk);
             }
+          }
 
           if (was_scheduled) {
             /* if task is detached, do not return a handle, it will be deleted
@@ -474,7 +502,19 @@ void mtapi_task_cancel(
       embb_mtapi_task_t* local_task =
         embb_mtapi_task_pool_get_storage_for_handle(node->task_pool, task);
       embb_mtapi_task_set_state(local_task, MTAPI_TASK_CANCELLED);
+
+      /* call plugin action cancel function */
+      if (embb_mtapi_action_pool_is_handle_valid(
+        node->action_pool, local_task->action)) {
+        embb_mtapi_action_t* local_action =
+          embb_mtapi_action_pool_get_storage_for_handle(
+          node->action_pool, local_task->action);
+        if (local_action->is_plugin_action) {
+          local_action->plugin_task_cancel_function(task, &local_status);
+        }
+      } else {
         local_status = MTAPI_SUCCESS;
+      }
     } else {
       local_status = MTAPI_ERR_TASK_INVALID;
     }

mtapi_c/src/mtapi_task_attributes_t.c

@@ -25,6 +25,7 @@
  */
 
 #include <assert.h>
+#include <string.h>
 
 #include <embb/mtapi/c/mtapi.h>
 
@@ -46,6 +47,7 @@ void mtapi_taskattr_init(
     attributes->num_instances = 1;
     attributes->is_detached = MTAPI_FALSE;
     attributes->priority = 0;
+    attributes->complete_func = MTAPI_NULL;
     mtapi_affinity_init(&attributes->affinity, MTAPI_TRUE, &local_status);
   } else {
     local_status = MTAPI_ERR_PARAMETER;
@@ -90,6 +92,16 @@ void mtapi_taskattr_set(
           &attributes->affinity, attribute, attribute_size);
         break;
 
+      case MTAPI_TASK_USER_DATA:
+        attributes->user_data = (void*)attribute;
+        local_status = MTAPI_SUCCESS;
+        break;
+
+      case MTAPI_TASK_COMPLETE_FUNCTION:
+        memcpy(&attributes->complete_func, &attribute, sizeof(void*));
+        local_status = MTAPI_SUCCESS;
+        break;
+
       default:
         /* attribute unknown */
         local_status = MTAPI_ERR_ATTR_NUM;

mtapi_c/test/embb_mtapi_test_config.h

@@ -29,6 +29,7 @@
 
 #include <partest/partest.h>
 #include <embb/mtapi/c/mtapi.h>
+#include <embb/mtapi/c/mtapi_ext.h>
 
 #include <embb_mtapi_log.h>
 

mtapi_c/test/embb_mtapi_test_plugin.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_test_config.h>
+#include <embb_mtapi_test_plugin.h>
+#include <embb_mtapi_task_t.h>
+#include <embb_mtapi_action_t.h>
+#include <embb_mtapi_node_t.h>
+
+#include <mtapi_status_t.h>
+
+#include <embb/base/c/memory_allocation.h>
+#include <embb/base/c/thread.h>
+#include <embb/base/c/atomic.h>
+#include <embb/base/c/internal/unused.h>
+
+#define PLUGIN_JOB_ID 2
+
+embb_thread_t plugin_thread;
+embb_atomic_int plugin_running;
+mtapi_task_hndl_t plugin_task;
+embb_atomic_int plugin_task_available;
+
+int plugin_thread_function(void * args) {
+  EMBB_UNUSED(args);
+  while (embb_atomic_load_int(&plugin_running)) {
+    /* wait for incoming task */
+    while (embb_atomic_load_int(&plugin_running) &&
+      !embb_atomic_load_int(&plugin_task_available))
+      embb_thread_yield();
+
+    if (embb_atomic_load_int(&plugin_running)) {
+      if (embb_mtapi_node_is_initialized()) {
+        embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+        if (embb_mtapi_task_pool_is_handle_valid(
+          node->task_pool, plugin_task)) {
+          embb_mtapi_task_t * local_task =
+            embb_mtapi_task_pool_get_storage_for_handle(
+            node->task_pool, plugin_task);
+          embb_mtapi_task_set_state(local_task, MTAPI_TASK_COMPLETED);
+        }
+      }
+      embb_atomic_store_int(&plugin_task_available, 0);
+    }
+  }
+
+  return 0;
+}
+
+void plugin_initialize(
+  MTAPI_IN mtapi_domain_t domain_id,
+  MTAPI_IN mtapi_node_t node_id,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  EMBB_UNUSED(domain_id);
+  EMBB_UNUSED(node_id);
+
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  int err;
+
+  plugin_task.id = 0;
+  plugin_task.tag = 0;
+  embb_atomic_store_int(&plugin_running, 1);
+  embb_atomic_store_int(&plugin_task_available, 0);
+
+  err = embb_thread_create(&plugin_thread, NULL, plugin_thread_function, NULL);
+  if (EMBB_SUCCESS == err) {
+    local_status = MTAPI_SUCCESS;
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+void plugin_finalize(
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  int result = 0;
+  int err;
+
+  embb_atomic_store_int(&plugin_running, 0);
+  err = embb_thread_join(&plugin_thread, &result);
+  if (EMBB_SUCCESS == err) {
+    local_status = MTAPI_SUCCESS;
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+void plugin_task_start(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+    if (embb_mtapi_task_pool_is_handle_valid(node->task_pool, task)) {
+      embb_mtapi_task_t * local_task =
+        embb_mtapi_task_pool_get_storage_for_handle(node->task_pool, task);
+      embb_mtapi_task_set_state(local_task, MTAPI_TASK_RUNNING);
+
+      plugin_task = task;
+      embb_atomic_store_int(&plugin_task_available, 1);
+    }
+  }
+
+  local_status = MTAPI_SUCCESS;
+
+  mtapi_status_set(status, local_status);
+}
+
+void plugin_task_cancel(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  EMBB_UNUSED(task);
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  mtapi_status_set(status, local_status);
+}
+
+void plugin_action_finalize(
+  MTAPI_IN mtapi_action_hndl_t action,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  EMBB_UNUSED(action);
+  mtapi_status_set(status, MTAPI_SUCCESS);
+}
+
+PluginTest::PluginTest() {
+  CreateUnit("mtapi plugin test").
+    Add(&PluginTest::TestBasic, this);
+}
+
+void PluginTest::TestBasic() {
+  embb_mtapi_log_info("running plugin test...\n");
+
+  mtapi_node_attributes_t node_attr;
+  mtapi_info_t info;
+  mtapi_status_t status;
+  mtapi_job_hndl_t job;
+  mtapi_action_hndl_t action;
+  mtapi_task_hndl_t task;
+
+  status = MTAPI_ERR_UNKNOWN;
+  mtapi_nodeattr_init(&node_attr, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  mtapi_nodeattr_set(&node_attr,
+    MTAPI_NODE_TYPE,
+    MTAPI_ATTRIBUTE_VALUE(MTAPI_NODE_TYPE_SMP),
+    MTAPI_ATTRIBUTE_POINTER_AS_VALUE,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  mtapi_initialize(
+    THIS_DOMAIN_ID,
+    THIS_NODE_ID,
+    &node_attr,
+    &info,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  plugin_initialize(THIS_DOMAIN_ID, THIS_NODE_ID, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  action = mtapi_ext_plugin_action_create(
+    PLUGIN_JOB_ID,
+    plugin_task_start,
+    plugin_task_cancel,
+    plugin_action_finalize,
+    MTAPI_NULL,
+    MTAPI_NULL,
+    0,
+    MTAPI_DEFAULT_ACTION_ATTRIBUTES,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  job = mtapi_job_get(
+    PLUGIN_JOB_ID,
+    THIS_DOMAIN_ID,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  task = mtapi_task_start(
+    MTAPI_TASK_ID_NONE,
+    job,
+    MTAPI_NULL, 0,
+    MTAPI_NULL, 0,
+    MTAPI_DEFAULT_TASK_ATTRIBUTES,
+    MTAPI_GROUP_NONE,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  mtapi_task_wait(task, MTAPI_INFINITE, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  plugin_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  mtapi_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+
+  PT_EXPECT_EQ(embb_get_bytes_allocated(), 0u);
+
+  embb_mtapi_log_info("...done\n\n");
+}

mtapi_c/test/embb_mtapi_test_plugin.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_C_TEST_EMBB_MTAPI_TEST_PLUGIN_H_
+#define MTAPI_C_TEST_EMBB_MTAPI_TEST_PLUGIN_H_
+
+#include <partest/partest.h>
+
+class PluginTest : public partest::TestCase {
+ public:
+  PluginTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_C_TEST_EMBB_MTAPI_TEST_PLUGIN_H_

mtapi_c/test/embb_mtapi_test_task.cc

@@ -218,11 +218,11 @@ void TaskTest::TestBasic() {
   mtapi_taskattr_init(&task_attr, &status);
   MTAPI_CHECK_STATUS(status);
 
-  const int kTaskInstances = 5;
+  const mtapi_uint_t kTaskInstances = 5;
 
   status = MTAPI_ERR_UNKNOWN;
   mtapi_taskattr_set(&task_attr, MTAPI_TASK_INSTANCES,
-    MTAPI_ATTRIBUTE_VALUE(kTaskInstances), MTAPI_ATTRIBUTE_POINTER_AS_VALUE,
+    &kTaskInstances, sizeof(mtapi_uint_t),
     &status);
   MTAPI_CHECK_STATUS(status);
 

mtapi_c/test/main.cc

@@ -31,6 +31,7 @@
 
 #include <embb_mtapi_log.h>
 
+#include <embb_mtapi_test_plugin.h>
 #include <embb_mtapi_test_init_finalize.h>
 #include <embb_mtapi_test_task.h>
 #include <embb_mtapi_test_group.h>
@@ -42,6 +43,7 @@ PT_MAIN("MTAPI C") {
   embb_thread_set_max_count(1024);
 
   PT_RUN(TaskTest);
+  PT_RUN(PluginTest);
   PT_RUN(ErrorTest);
   PT_RUN(InitFinalizeTest);
   PT_RUN(GroupTest);

mtapi_network_c/CMakeLists.txt

+project (project_embb_mtapi_network_c)
+
+file(GLOB_RECURSE EMBB_MTAPI_NETWORK_C_SOURCES "src/*.c" "src/*.h")
+file(GLOB_RECURSE EMBB_MTAPI_NETWORK_C_HEADERS "include/*.h")
+
+file(GLOB_RECURSE EMBB_MTAPI_NETWORK_TEST_SOURCES "test/*.cc" "test/*.h")
+  
+IF(MSVC8 OR MSVC9 OR MSVC10 OR MSVC11)
+FOREACH(src_tmp ${EMBB_MTAPI_NETWORK_TEST_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+FOREACH(src_tmp ${EMBB_MTAPI_NETWORK_C_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+ENDIF()
+
+IF(MSVC)
+set (EMBB_MTAPI_NETWORK_C_LIBS ws2_32)
+ENDIF()
+
+# Execute the GroupSources macro
+include(${CMAKE_SOURCE_DIR}/CMakeCommon/GroupSourcesMSVC.cmake)
+GroupSourcesMSVC(include)
+GroupSourcesMSVC(src)
+GroupSourcesMSVC(test)
+
+set (EMBB_MTAPI_NETWORK_INCLUDE_DIRS "include" "src" "test")
+include_directories(${EMBB_MTAPI_NETWORK_INCLUDE_DIRS}
+                    ${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_network_c ${EMBB_MTAPI_NETWORK_C_SOURCES} ${EMBB_MTAPI_NETWORK_C_HEADERS})
+target_link_libraries(embb_mtapi_network_c embb_mtapi_c embb_base_c)
+
+if (BUILD_TESTS STREQUAL ON)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/../partest/include)
+  add_executable (embb_mtapi_network_c_test ${EMBB_MTAPI_NETWORK_TEST_SOURCES})
+  target_link_libraries(embb_mtapi_network_c_test embb_mtapi_network_c embb_mtapi_c partest embb_base_c ${compiler_libs} ${EMBB_MTAPI_NETWORK_C_LIBS})
+  CopyBin(BIN embb_mtapi_network_c_test DEST ${local_install_dir})
+endif()
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
+        DESTINATION include FILES_MATCHING PATTERN "*.h")
+install(TARGETS embb_mtapi_network_c DESTINATION lib)

mtapi_network_c/include/embb/mtapi/c/mtapi_network.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_NETWORK_H_
+#define EMBB_MTAPI_C_MTAPI_NETWORK_H_
+
+
+#include <embb/mtapi/c/mtapi_ext.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * \defgroup C_MTAPI_NETWORK MTAPI Network Plugin
+ *
+ * \ingroup C_MTAPI_EXT
+ *
+ * Provides functionality to distribute tasks across nodes in a TCP/IP network.
+ */
+
+
+/**
+ * Initializes the MTAPI network environment on a previously initialized MTAPI
+ * node.
+ *
+ * It must be called on all nodes using the MTAPI network plugin.
+ *
+ * Application software using MTAPI network must call
+ * mtapi_network_plugin_initialize() once per node. It is an error to call
+ * mtapi_network_plugin_initialize() multiple times
+ * from a given node, unless mtapi_network_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 network couldn't be initialized.
+ *
+ * \see mtapi_network_plugin_finalize()
+ *
+ * \notthreadsafe
+ * \ingroup C_MTAPI_NETWORK
+ */
+void mtapi_network_plugin_initialize(
+  MTAPI_IN char * host,                /**< [in] The interface to listen on, if
+                                            MTAPI_NULL is given the plugin will
+                                            listen on all available
+                                            interfaces. */
+  MTAPI_IN mtapi_uint16_t port,        /**< [in] The port to listen on. */
+  MTAPI_IN mtapi_uint16_t max_connections,
+                                       /**< [in] Maximum concurrent connections
+                                            accepted by the plugin. */
+  MTAPI_IN mtapi_size_t buffer_size,   /**< [in] Capacity of the transfer
+                                            buffers, this should be chosen big
+                                            enough to hold argument and result
+                                            buffers.*/
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+/**
+ * Finalizes the MTAPI network environment on the local MTAPI node.
+ *
+ * It has to be called by each node using MTAPI network. It is an error to call
+ * mtapi_network_plugin_finalize() without first calling
+ * mtapi_network_plugin_initialize(). An MTAPI node can call
+ * mtapi_network_plugin_finalize() once for each call to
+ * mtapi_network_plugin_initialize(), but it is an error to call
+ * mtapi_network_plugin_finalize() multiple times from a given node
+ * unless mtapi_network_plugin_initialize() has been called prior to each
+ * mtapi_network_plugin_finalize() call.
+ *
+ * All network tasks that have not completed and that have been started on the
+ * node where mtapi_network_plugin_finalize() is called will be canceled
+ * (see mtapi_task_cancel()). mtapi_network_plugin_finalize() blocks until all
+ * tasks that have been started on the same node return. Tasks that execute
+ * actions on the node where mtapi_network_plugin_finalize() is called, also
+ * block finalization of the MTAPI network 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 network couldn't be finalized.
+ *
+ * \see mtapi_network_plugin_initialize(), mtapi_task_cancel()
+ *
+ * \notthreadsafe
+ * \ingroup C_MTAPI_NETWORK
+ */
+void mtapi_network_plugin_finalize(
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+/**
+ * This function creates a network action.
+ *
+ * It is called on the node where the user wants to execute an action on a
+ * remote node where the actual action is implemented. A network action
+ * contains a reference to a local job, a remote job and a remote domain as
+ * well as a host and port to connect to.
+ * After a network 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 network action's
+ * life-cycle begins with mtapi_network_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.
+ *
+ * A network action defines no node local data, instead the node local data of
+ * the remote action is used. The user has to make sure that the remote node
+ * local data matches what he expects the remote action to use if invoked
+ * through the network.
+ *
+ * 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 remote node could not be reached or there was no local 
+ *         interface available.</td>
+ *   </tr>
+ * </table>
+ *
+ * \see mtapi_action_delete(), mtapi_finalize()
+ *
+ * \returns Handle to newly created network action, invalid handle on error
+ * \threadsafe
+ * \ingroup C_MTAPI_NETWORK
+ */
+mtapi_action_hndl_t mtapi_network_action_create(
+  MTAPI_IN mtapi_domain_t domain_id,   /**< [in] The domain the action is
+                                            associated with */
+  MTAPI_IN mtapi_job_id_t local_job_id,
+                                       /**< [in] The ID of the local job */
+  MTAPI_IN mtapi_job_id_t remote_job_id,
+                                       /**< [in] The ID of the remote job */
+  MTAPI_IN char * host,                /**< [in] The host to connect to */
+  MTAPI_IN mtapi_uint16_t port,        /**< [in] The port the host is listening
+                                            on */
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // EMBB_MTAPI_C_MTAPI_NETWORK_H_

mtapi_network_c/src/embb_mtapi_network.c

+/*
+ * 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.
+ */
+
+#ifdef _WIN32
+#include <WinSock2.h>
+#endif
+
+#include <embb/mtapi/c/mtapi_network.h>
+#include <embb/base/c/memory_allocation.h>
+#include <embb/base/c/thread.h>
+#include <embb/base/c/atomic.h>
+#include <embb/base/c/mutex.h>
+#include <embb/base/c/internal/unused.h>
+#include <embb_mtapi_network_socket.h>
+#include <embb_mtapi_network.h>
+
+#include <embb_mtapi_task_t.h>
+#include <embb_mtapi_action_t.h>
+#include <embb_mtapi_node_t.h>
+#include <embb_mtapi_group_t.h>
+#include <mtapi_status_t.h>
+
+#include <assert.h>
+
+int embb_mtapi_network_initialize() {
+#ifdef _WIN32
+  WORD ver_request;
+  WSADATA wsa_data;
+  int err;
+
+  ver_request = MAKEWORD(2, 2);
+
+  err = WSAStartup(ver_request, &wsa_data);
+  if (err != 0) {
+    return 0;
+  } else {
+    return 1;
+  }
+#else
+  return 1;
+#endif
+}
+
+void embb_mtapi_network_finalize() {
+#ifdef _WIN32
+  WSACleanup();
+#endif
+}
+
+enum embb_mtapi_network_operation_enum {
+  EMBB_MTAPI_NETWORK_START_TASK,
+  EMBB_MTAPI_NETWORK_RETURN_RESULT
+};
+
+struct embb_mtapi_network_plugin_struct {
+  embb_thread_t thread;
+  embb_mtapi_network_socket_t *sockets; // sockets[0] is the listening socket
+  int socket_count;
+  embb_atomic_int run;
+  mtapi_size_t buffer_size;
+
+  embb_mutex_t send_mutex;
+  embb_mtapi_network_buffer_t send_buffer;
+};
+
+typedef struct embb_mtapi_network_plugin_struct embb_mtapi_network_plugin_t;
+
+static embb_mtapi_network_plugin_t embb_mtapi_network_plugin;
+
+struct embb_mtapi_network_action_struct {
+  mtapi_domain_t domain_id;
+  mtapi_job_id_t job_id;
+
+  char const * host;
+  mtapi_uint16_t port;
+  embb_mtapi_network_socket_t socket;
+
+  embb_mutex_t send_mutex;
+  embb_mtapi_network_buffer_t send_buffer;
+};
+
+typedef struct embb_mtapi_network_action_struct embb_mtapi_network_action_t;
+
+struct embb_mtapi_network_task_struct {
+  embb_mtapi_network_socket_t socket;
+  int32_t remote_task_id;
+  int32_t remote_task_tag;
+};
+
+typedef struct embb_mtapi_network_task_struct embb_mtapi_network_task_t;
+
+static void embb_mtapi_network_task_complete(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  int err;
+  EMBB_UNUSED_IN_RELEASE(err);
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+    if (embb_mtapi_task_pool_is_handle_valid(node->task_pool, task)) {
+      embb_mtapi_task_t * local_task =
+        embb_mtapi_task_pool_get_storage_for_handle(node->task_pool, task);
+
+      if (embb_mtapi_action_pool_is_handle_valid(
+        node->action_pool, local_task->action)) {
+        /* not needed right now
+        embb_mtapi_action_t * local_action =
+          embb_mtapi_action_pool_get_storage_for_handle(
+          node->action_pool, local_task->action);*/
+
+        embb_mtapi_network_plugin_t * plugin = &embb_mtapi_network_plugin;
+        embb_mtapi_network_task_t * network_task =
+          (embb_mtapi_network_task_t*)local_task->attributes.user_data;
+        embb_mtapi_network_buffer_t * send_buf = &plugin->send_buffer;
+
+        // serialize sending of results
+        embb_mutex_lock(&plugin->send_mutex);
+        embb_mtapi_network_buffer_clear(send_buf);
+
+        // operation is "return result"
+        err = embb_mtapi_network_buffer_push_back_int8(
+          send_buf, EMBB_MTAPI_NETWORK_RETURN_RESULT);
+        assert(err == 1);
+        // remote task id
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, network_task->remote_task_id);
+        assert(err == 4);
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, network_task->remote_task_tag);
+        assert(err == 4);
+        // status
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, local_task->error_code);
+        assert(err == 4);
+        // result size
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)local_task->result_size);
+        assert(err == 4);
+        err = embb_mtapi_network_buffer_push_back_rawdata(
+          send_buf, (int32_t)local_task->result_size, local_task->result_buffer);
+        assert(err == (int)local_task->result_size);
+
+        err = embb_mtapi_network_socket_sendbuffer(
+          &network_task->socket, send_buf);
+        assert(err == send_buf->size);
+
+        // sending done
+        embb_mutex_unlock(&plugin->send_mutex);
+
+        // we allocated arguments and results on receive, so free them here
+        embb_free((void*)local_task->arguments);
+        embb_free(local_task->result_buffer);
+
+        local_status = MTAPI_SUCCESS;
+      }
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+static int embb_mtapi_network_thread(void * args) {
+  embb_mtapi_network_plugin_t * plugin = &embb_mtapi_network_plugin;
+  embb_mtapi_network_buffer_t buffer;
+  int err;
+
+  EMBB_UNUSED(args);
+
+  embb_mtapi_network_buffer_initialize(&buffer, (int)plugin->buffer_size);
+
+  while (embb_atomic_load_int(&plugin->run)) {
+    err = embb_mtapi_network_socket_select(
+      plugin->sockets, plugin->socket_count, 100);
+    if (0 == err) {
+      // listening socket, accept connection
+      embb_mtapi_network_socket_t accept_socket;
+      err = embb_mtapi_network_socket_accept(
+        &plugin->sockets[0], &accept_socket);
+      if (0 < err) {
+        // add socket to socket list
+        plugin->sockets[plugin->socket_count] = accept_socket;
+        plugin->socket_count++;
+      }
+    } else if (0 < err) {
+      int32_t domain_id;
+      int32_t job_id;
+      int32_t results_size;
+      void * results;
+      int8_t operation;
+      embb_mtapi_network_socket_t * socket = &plugin->sockets[err];
+
+      embb_mtapi_network_buffer_clear(&buffer);
+
+      err = embb_mtapi_network_socket_recvbuffer_sized(
+        socket, &buffer, 1);
+      if (err == 0) {
+        // there was some socket error, ignore
+        continue;
+      }
+      assert(err == 1);
+      err = embb_mtapi_network_buffer_pop_front_int8(
+        &buffer, &operation);
+      assert(err == 1);
+
+      embb_mtapi_network_buffer_clear(&buffer);
+
+      if (operation == EMBB_MTAPI_NETWORK_START_TASK) {
+        int32_t arguments_size;
+        mtapi_uint_t priority = 0;
+        mtapi_job_hndl_t job_hndl;
+        mtapi_task_attributes_t task_attr;
+        void * arguments;
+        mtapi_task_complete_function_t func = embb_mtapi_network_task_complete;
+        void * func_void;
+        embb_mtapi_network_task_t * network_task =
+          (embb_mtapi_network_task_t*)embb_alloc(
+          sizeof(embb_mtapi_network_task_t));
+        mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+        err = embb_mtapi_network_socket_recvbuffer_sized(
+          socket, &buffer, 28);
+        assert(err == 28);
+        // domain id
+        err = embb_mtapi_network_buffer_pop_front_int32(&buffer, &domain_id);
+        assert(err == 4);
+        // job id
+        err = embb_mtapi_network_buffer_pop_front_int32(&buffer, &job_id);
+        assert(err == 4);
+        // priority
+        err = embb_mtapi_network_buffer_pop_front_int32(
+          &buffer, (int32_t*)&priority);
+        assert(err == 4);
+        // remote task handle
+        err = embb_mtapi_network_buffer_pop_front_int32(
+          &buffer, &network_task->remote_task_id);
+        assert(err == 4);
+        err = embb_mtapi_network_buffer_pop_front_int32(
+          &buffer, &network_task->remote_task_tag);
+        assert(err == 4);
+        // result size
+        err = embb_mtapi_network_buffer_pop_front_int32(&buffer,
+          &results_size);
+        assert(err == 4);
+        results = embb_alloc((size_t)results_size);
+        assert(results != NULL);
+        // arguments size
+        embb_mtapi_network_buffer_pop_front_int32(&buffer, &arguments_size);
+        assert(err == 4);
+        arguments = embb_alloc((size_t)arguments_size);
+        assert(arguments != NULL);
+
+        embb_mtapi_network_buffer_clear(&buffer);
+
+        // arguments
+        err = embb_mtapi_network_socket_recvbuffer_sized(
+          socket, &buffer, arguments_size);
+        assert(err == arguments_size);
+        err = embb_mtapi_network_buffer_pop_front_rawdata(
+          &buffer, arguments_size, arguments);
+        assert(err == arguments_size);
+
+        embb_mtapi_network_buffer_clear(&buffer);
+
+        network_task->socket = *socket;
+        mtapi_taskattr_init(&task_attr, &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+        mtapi_taskattr_set(&task_attr, MTAPI_TASK_USER_DATA,
+          (void*)network_task, 0, &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+        mtapi_boolean_t task_detached = MTAPI_TRUE;
+        mtapi_taskattr_set(&task_attr, MTAPI_TASK_DETACHED,
+          (void*)&task_detached, sizeof(mtapi_boolean_t), &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+        mtapi_taskattr_set(&task_attr, MTAPI_TASK_PRIORITY,
+          (void*)&priority, sizeof(mtapi_uint_t), &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+        memcpy(&func_void, &func, sizeof(void*));
+        mtapi_taskattr_set(&task_attr, MTAPI_TASK_COMPLETE_FUNCTION,
+          func_void, 0, &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+        job_hndl = mtapi_job_get((mtapi_job_id_t)job_id, (mtapi_domain_t)domain_id, &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+        mtapi_task_start(
+          MTAPI_TASK_ID_NONE, job_hndl,
+          arguments, (mtapi_size_t)arguments_size,
+          results, (mtapi_size_t)results_size,
+          &task_attr, MTAPI_GROUP_NONE,
+          &local_status);
+        assert(local_status == MTAPI_SUCCESS);
+
+        // send back result of task creation
+        //embb_mtapi_network_buffer_push_back_int32(
+        //  &buffer, local_status);
+        //embb_mtapi_network_socket_sendbuffer(
+        //  socket, &buffer);
+
+        embb_mtapi_network_buffer_clear(&buffer);
+      } else if (operation == EMBB_MTAPI_NETWORK_RETURN_RESULT) {
+        int task_status;
+        int task_id;
+        int task_tag;
+
+        embb_mtapi_network_buffer_clear(&buffer);
+
+        if (embb_mtapi_node_is_initialized()) {
+          embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+          mtapi_task_hndl_t task;
+
+          err = embb_mtapi_network_socket_recvbuffer_sized(
+            socket, &buffer, 16);
+          assert(err == 16);
+          // local task id
+          err = embb_mtapi_network_buffer_pop_front_int32(&buffer, &task_id);
+          assert(err == 4);
+          err = embb_mtapi_network_buffer_pop_front_int32(&buffer, &task_tag);
+          assert(err == 4);
+          // task status
+          err = embb_mtapi_network_buffer_pop_front_int32(
+            &buffer, &task_status);
+          assert(err == 4);
+          // result size
+          err = embb_mtapi_network_buffer_pop_front_int32(
+            &buffer, &results_size);
+          assert(err == 4);
+
+          embb_mtapi_network_buffer_clear(&buffer);
+
+          err = embb_mtapi_network_socket_recvbuffer_sized(
+            socket, &buffer, results_size);
+          assert(err == results_size);
+
+          task.id = (mtapi_task_id_t)task_id;
+          task.tag = (mtapi_uint_t)task_tag;
+
+          if (embb_mtapi_task_pool_is_handle_valid(node->task_pool, task)) {
+            embb_mtapi_task_t * local_task =
+              embb_mtapi_task_pool_get_storage_for_handle(
+              node->task_pool, task);
+
+            if (embb_mtapi_action_pool_is_handle_valid(
+              node->action_pool, local_task->action)) {
+              embb_mtapi_action_t * local_action =
+                embb_mtapi_action_pool_get_storage_for_handle(
+                node->action_pool, local_task->action);
+
+              /* not needed right now
+              embb_mtapi_network_action_t * network_action =
+                (embb_mtapi_network_action_t*)local_action->plugin_data;*/
+
+              err = embb_mtapi_network_buffer_pop_front_rawdata(
+                &buffer, results_size, local_task->result_buffer);
+              assert(err == results_size);
+
+              local_task->error_code = (mtapi_status_t)task_status;
+              local_task->state = MTAPI_TASK_COMPLETED;
+              embb_atomic_fetch_and_add_int(&local_action->num_tasks, -1);
+
+              /* is task associated with a group? */
+              if (embb_mtapi_group_pool_is_handle_valid(
+                node->group_pool, local_task->group)) {
+                embb_mtapi_group_t* local_group =
+                  embb_mtapi_group_pool_get_storage_for_handle(
+                  node->group_pool, local_task->group);
+                embb_mtapi_task_queue_push(&local_group->queue, local_task);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  embb_mtapi_network_buffer_finalize(&buffer);
+
+  return EMBB_SUCCESS;
+}
+
+void mtapi_network_plugin_initialize(
+  MTAPI_IN char * host,
+  MTAPI_IN mtapi_uint16_t port,
+  MTAPI_IN mtapi_uint16_t max_connections,
+  MTAPI_IN mtapi_size_t buffer_size,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  embb_mtapi_network_plugin_t * plugin = &embb_mtapi_network_plugin;
+  int err;
+
+  err = embb_mtapi_network_initialize();
+  if (err) {
+    embb_atomic_store_int(&plugin->run, 1);
+    plugin->buffer_size = buffer_size;
+
+    plugin->socket_count = 1;
+    // 1 listening socket and max_connections connections
+    // (2 sockets each if local)
+    plugin->sockets = (embb_mtapi_network_socket_t*)embb_alloc(
+      sizeof(embb_mtapi_network_socket_t) * (1 + max_connections * 2));
+
+    embb_mtapi_network_buffer_initialize(
+      &plugin->send_buffer, (int)plugin->buffer_size);
+    embb_mutex_init(&plugin->send_mutex, 0);
+
+    if (NULL != plugin->sockets) {
+      err = embb_mtapi_network_socket_initialize(&plugin->sockets[0]);
+      if (err) {
+        err = embb_mtapi_network_socket_bind_and_listen(
+          &plugin->sockets[0], host, port, max_connections);
+        if (err) {
+          err = embb_thread_create(
+            &plugin->thread, NULL, embb_mtapi_network_thread, NULL);
+          if (EMBB_SUCCESS == err) {
+            local_status = MTAPI_SUCCESS;
+          }
+        }
+      }
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+void mtapi_network_plugin_finalize(
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_SUCCESS;
+  embb_mtapi_network_plugin_t * plugin = &embb_mtapi_network_plugin;
+  int err;
+
+  embb_atomic_store_int(&plugin->run, 0);
+  embb_thread_join(&plugin->thread, &err);
+
+  embb_mutex_destroy(&plugin->send_mutex);
+  embb_mtapi_network_buffer_finalize(&plugin->send_buffer);
+
+  embb_mtapi_network_socket_finalize(&plugin->sockets[0]);
+  embb_free(plugin->sockets);
+  embb_mtapi_network_finalize();
+
+  mtapi_status_set(status, local_status);
+}
+
+static void network_task_start(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  int err;
+  EMBB_UNUSED_IN_RELEASE(err);
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+    if (embb_mtapi_task_pool_is_handle_valid(node->task_pool, task)) {
+      embb_mtapi_task_t * local_task =
+        embb_mtapi_task_pool_get_storage_for_handle(node->task_pool, task);
+
+      if (embb_mtapi_action_pool_is_handle_valid(
+        node->action_pool, local_task->action)) {
+        embb_mtapi_action_t * local_action =
+          embb_mtapi_action_pool_get_storage_for_handle(
+          node->action_pool, local_task->action);
+
+        embb_mtapi_network_action_t * network_action =
+          (embb_mtapi_network_action_t*)local_action->plugin_data;
+        embb_mtapi_network_buffer_t * send_buf = &network_action->send_buffer;
+
+        // serialize sending
+        embb_mutex_lock(&network_action->send_mutex);
+
+        // operation is "start task"
+        err = embb_mtapi_network_buffer_push_back_int8(
+          send_buf, EMBB_MTAPI_NETWORK_START_TASK);
+        assert(err == 1);
+
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)network_action->domain_id);
+        assert(err == 4);
+
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)network_action->job_id);
+        assert(err == 4);
+
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)local_task->attributes.priority);
+        assert(err == 4);
+
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)local_task->handle.id);
+        assert(err == 4);
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)local_task->handle.tag);
+        assert(err == 4);
+
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)local_task->result_size);
+        assert(err == 4);
+
+        err = embb_mtapi_network_buffer_push_back_int32(
+          send_buf, (int32_t)local_task->arguments_size);
+        assert(err == 4);
+        err = embb_mtapi_network_buffer_push_back_rawdata(
+          send_buf, (int32_t)local_task->arguments_size, local_task->arguments);
+        assert(err == (int)local_task->arguments_size);
+
+        err = embb_mtapi_network_socket_sendbuffer(
+          &network_action->socket, send_buf);
+        assert(err == send_buf->size);
+
+        embb_atomic_fetch_and_add_int(&local_action->num_tasks, 1);
+        local_task->state = MTAPI_TASK_RUNNING;
+
+        embb_mtapi_network_buffer_clear(send_buf);
+
+        embb_mutex_unlock(&network_action->send_mutex);
+
+        local_status = MTAPI_SUCCESS;
+      }
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+static void network_task_cancel(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  EMBB_UNUSED(task);
+
+  mtapi_status_set(status, local_status);
+}
+
+static void network_action_finalize(
+  MTAPI_IN mtapi_action_hndl_t action,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+    if (embb_mtapi_action_pool_is_handle_valid(node->action_pool, action)) {
+      embb_mtapi_action_t * local_action =
+        embb_mtapi_action_pool_get_storage_for_handle(
+          node->action_pool, action);
+      embb_mtapi_network_action_t * network_action =
+        (embb_mtapi_network_action_t *)local_action->plugin_data;
+
+      embb_mutex_destroy(&network_action->send_mutex);
+      embb_mtapi_network_buffer_finalize(&network_action->send_buffer);
+      embb_mtapi_network_socket_finalize(&network_action->socket);
+
+      embb_free(network_action);
+      local_status = MTAPI_SUCCESS;
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+mtapi_action_hndl_t mtapi_network_action_create(
+  MTAPI_IN mtapi_domain_t domain_id,
+  MTAPI_IN mtapi_job_id_t local_job_id,
+  MTAPI_IN mtapi_job_id_t remote_job_id,
+  MTAPI_IN char * host,
+  MTAPI_IN mtapi_uint16_t port,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  embb_mtapi_network_plugin_t * plugin = &embb_mtapi_network_plugin;
+  embb_mtapi_network_action_t * action =
+    (embb_mtapi_network_action_t*)embb_alloc(
+      sizeof(embb_mtapi_network_action_t));
+  mtapi_action_hndl_t action_hndl = { 0, 0 };
+  int err;
+
+  if (NULL != action) {
+    action->domain_id = domain_id;
+    action->job_id = remote_job_id;
+
+    embb_mtapi_network_buffer_initialize(
+      &action->send_buffer, (int)plugin->buffer_size);
+    embb_mutex_init(&action->send_mutex, 0);
+
+    action->host = host;
+    action->port = port;
+    embb_mtapi_network_socket_initialize(&action->socket);
+    err = embb_mtapi_network_socket_connect(&action->socket, host, port);
+
+    if (0 != err) {
+      // store socket for select
+      plugin->sockets[plugin->socket_count] = action->socket;
+      plugin->socket_count++;
+
+      action_hndl = mtapi_ext_plugin_action_create(
+        local_job_id,
+        network_task_start,
+        network_task_cancel,
+        network_action_finalize,
+        action,
+        NULL, 0, // no node local data obviously
+        MTAPI_NULL,
+        &local_status);
+    } else {
+      embb_mutex_destroy(&action->send_mutex);
+      embb_mtapi_network_buffer_finalize(&action->send_buffer);
+      embb_mtapi_network_socket_finalize(&action->socket);
+      embb_free(action);
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+  return action_hndl;
+}

mtapi_network_c/src/embb_mtapi_network.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_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_H_
+#define MTAPI_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+int embb_mtapi_network_initialize();
+
+void embb_mtapi_network_finalize();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MTAPI_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_H_

mtapi_network_c/src/embb_mtapi_network_buffer.c

+/*
+ * 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_network_buffer.h>
+#include <embb/base/c/memory_allocation.h>
+#include <string.h>
+
+void embb_mtapi_network_buffer_initialize(
+  embb_mtapi_network_buffer_t * that,
+  int capacity) {
+  that->position = 0;
+  that->size = 0;
+  that->data = (char*)embb_alloc((size_t)capacity);
+  if (NULL != that->data) {
+    that->capacity = capacity;
+  } else {
+    that->capacity = 0;
+  }
+}
+
+void embb_mtapi_network_buffer_finalize(
+  embb_mtapi_network_buffer_t * that) {
+  that->position = 0;
+  that->size = 0;
+  that->capacity = 0;
+  if (NULL != that->data) {
+    embb_free(that->data);
+    that->data = NULL;
+  }
+}
+
+void embb_mtapi_network_buffer_clear(
+  embb_mtapi_network_buffer_t * that) {
+  that->position = 0;
+  that->size = 0;
+}
+
+int embb_mtapi_network_buffer_push_back_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t value) {
+  if (that->size + 1 > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, &value, 1);
+  that->size += 1;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_push_back_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t value) {
+  if (that->size + 2 > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, &value, 2);
+  that->size += 2;
+  return 2;
+}
+
+int embb_mtapi_network_buffer_push_back_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t value) {
+  if (that->size + 4 > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, &value, 4);
+  that->size += 4;
+  return 4;
+}
+
+int embb_mtapi_network_buffer_push_back_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void const * rawdata) {
+  if (that->size + size > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, rawdata, (size_t)size);
+  that->size += size;
+  return size;
+}
+
+int embb_mtapi_network_buffer_pop_front_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t * value) {
+  if (that->position + 1 > that->size) {
+    return 0;
+  }
+  memcpy(value, that->data + that->position, 1);
+  that->position += 1;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_pop_front_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t * value) {
+  if (that->position + 2 > that->size) {
+    return 0;
+  }
+  memcpy(value, that->data + that->position, 2);
+  that->position += 2;
+  return 2;
+}
+
+int embb_mtapi_network_buffer_pop_front_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t * value) {
+  if (that->position + 4 > that->size) {
+    return 0;
+  }
+  memcpy(value, that->data + that->position, 4);
+  that->position += 4;
+  return 4;
+}
+
+int embb_mtapi_network_buffer_pop_front_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void * rawdata) {
+  if (that->position + size > that->size) {
+    return 0;
+  }
+  memcpy(rawdata, that->data + that->position, (size_t)size);
+  that->position += size;
+  return size;
+}

mtapi_network_c/src/embb_mtapi_network_buffer.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_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_BUFFER_H_
+#define MTAPI_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_BUFFER_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct embb_mtapi_network_buffer_struct {
+  int position;
+  int size;
+  int capacity;
+  char * data;
+};
+
+typedef struct embb_mtapi_network_buffer_struct embb_mtapi_network_buffer_t;
+
+void embb_mtapi_network_buffer_initialize(
+  embb_mtapi_network_buffer_t * that,
+  int capacity
+);
+
+void embb_mtapi_network_buffer_finalize(
+  embb_mtapi_network_buffer_t * that
+);
+
+void embb_mtapi_network_buffer_clear(
+  embb_mtapi_network_buffer_t * that
+);
+
+int embb_mtapi_network_buffer_push_back_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t value
+);
+
+int embb_mtapi_network_buffer_push_back_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t value
+);
+
+int embb_mtapi_network_buffer_push_back_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t value
+);
+
+int embb_mtapi_network_buffer_push_back_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void const * rawdata
+);
+
+int embb_mtapi_network_buffer_pop_front_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t * value
+);
+
+int embb_mtapi_network_buffer_pop_front_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t * value
+);
+
+int embb_mtapi_network_buffer_pop_front_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t * value
+);
+
+int embb_mtapi_network_buffer_pop_front_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void * rawdata
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MTAPI_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_BUFFER_H_

mtapi_network_c/src/embb_mtapi_network_socket.c

+/*
+ * 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.
+ */
+
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+
+#include <embb_mtapi_network_socket.h>
+#include <embb/base/c/internal/config.h>
+#include <string.h>
+#ifdef _WIN32
+#include <WinSock2.h>
+#else
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <errno.h>
+#endif
+
+int embb_mtapi_network_socket_initialize(
+  embb_mtapi_network_socket_t * that) {
+  that->handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (INVALID_SOCKET == that->handle) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+void embb_mtapi_network_socket_finalize(
+  embb_mtapi_network_socket_t * that) {
+  if (INVALID_SOCKET != that->handle) {
+#ifdef _WIN32
+    closesocket(that->handle);
+#else
+    close(that->handle);
+#endif
+    that->handle = INVALID_SOCKET;
+  }
+}
+
+int embb_mtapi_network_socket_bind_and_listen(
+  embb_mtapi_network_socket_t * that,
+  char const * host,
+  uint16_t port,
+  uint16_t max_connections) {
+  struct sockaddr_in in_addr;
+  int reuseaddr_on = 1;
+
+  // addr reuse
+  if (SOCKET_ERROR == setsockopt(that->handle, SOL_SOCKET, SO_REUSEADDR,
+    (const char *)&reuseaddr_on, sizeof(reuseaddr_on))) {
+    return 0;
+  }
+
+  // bind & listen
+  memset(&in_addr, 0, sizeof(in_addr));
+  in_addr.sin_family = AF_INET;
+  in_addr.sin_addr.s_addr = (NULL == host) ?
+    htonl(INADDR_ANY) : inet_addr(host);
+  in_addr.sin_port = htons(port);
+
+  if (SOCKET_ERROR == bind(that->handle, (struct sockaddr *) &in_addr,
+    sizeof(in_addr))) {
+    return 0;
+  }
+
+  if (SOCKET_ERROR == listen(that->handle, max_connections)) {
+    return 0;
+  }
+
+  return 1;
+}
+
+int embb_mtapi_network_socket_accept(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_socket_t * sock) {
+  sock->handle = accept(that->handle, NULL, NULL);
+  if (INVALID_SOCKET == sock->handle) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+int embb_mtapi_network_socket_connect(
+  embb_mtapi_network_socket_t * that,
+  const char * host,
+  uint16_t port) {
+  struct sockaddr_in addr;
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = inet_addr(host);
+  addr.sin_port = htons(port);
+
+  if (SOCKET_ERROR == connect(that->handle, (struct sockaddr *)&addr,
+    sizeof(addr))) {
+#ifdef _WIN32
+    if (WSAEWOULDBLOCK != WSAGetLastError())
+#else
+    if (EAGAIN != errno)
+#endif
+      return 0;
+  }
+
+  return 1;
+}
+
+int embb_mtapi_network_socket_select(
+  embb_mtapi_network_socket_t * sockets,
+  int count,
+  int timeout
+  ) {
+  fd_set read_set;
+  embb_mtapi_network_socket_t max_fd = { 0 };
+  int err;
+  int ii;
+  struct timeval tv;
+  tv.tv_sec = timeout / 1000;
+  tv.tv_usec = timeout % 1000;
+
+  FD_ZERO(&read_set);
+  for (ii = 0; ii < count; ii++) {
+#ifdef EMBB_PLATFORM_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4548)
+#endif
+    FD_SET(sockets[ii].handle, &read_set);
+#ifdef EMBB_PLATFORM_COMPILER_MSVC
+#pragma warning(pop)
+#endif
+    if (sockets[ii].handle > max_fd.handle)
+      max_fd.handle = sockets[ii].handle;
+  }
+
+  if (timeout >= 0) {
+    err = select((int)max_fd.handle + 1, &read_set, NULL, NULL, &tv);
+  } else {
+    err = select((int)max_fd.handle + 1, &read_set, NULL, NULL, NULL);
+  }
+  if (0 == err) {
+    // timeout
+    return -1;
+  }
+  if (SOCKET_ERROR == err) {
+    return -1;
+  }
+
+  for (ii = 0; ii < count; ii++) {
+    if (FD_ISSET(sockets[ii].handle, &read_set)) {
+      return ii;
+    }
+  }
+
+  return -1;
+}
+
+int embb_mtapi_network_socket_sendbuffer(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_buffer_t * buffer) {
+  char * buf = (char*)(buffer->data);
+  int cnt = 0;
+  int result = send(that->handle, buf, buffer->size, 0);
+  while (result > 0) {
+    buf += result;
+    cnt += result;
+    if (cnt == buffer->size)
+      break;
+    result = send(that->handle, buf, buffer->size - cnt, 0);
+  }
+  if (cnt == buffer->size) {
+    return buffer->size;
+  } else {
+    return 0;
+  }
+}
+
+int embb_mtapi_network_socket_recvbuffer_sized(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_buffer_t * buffer,
+  int size) {
+  int err;
+  /*
+#ifdef _WIN32
+  u_long bytes_available = 0;
+  if (0 != ioctlsocket(that->handle, FIONREAD, &bytes_available))
+#else
+  int bytes_available = 0;
+  if (0 != ioctl(that->handle, FIONREAD, &bytes_available))
+#endif
+    return 0;
+  */
+  if (buffer->capacity < size)
+    return 0;
+  /*
+  if (size > (int)bytes_available)
+    return 0;
+  */
+  if (0 < size) {
+    char * buf = (char*)(buffer->data);
+    int cnt = 0;
+    err = recv(that->handle, buf, size, 0);
+    while (err > 0) {
+      cnt += err;
+      if (cnt == size)
+        break;
+      buf += err;
+      err = recv(that->handle, buf, size - cnt, 0);
+    }
+    if (err > 0)
+      err = cnt;
+  } else {
+    err = 0;
+  }
+  if (err != size)
+    return 0;
+  buffer->size = size;
+  return buffer->size;
+}
+
+int embb_mtapi_network_socket_recvbuffer(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_buffer_t * buffer) {
+  return
+    embb_mtapi_network_socket_recvbuffer_sized(that, buffer, buffer->capacity);
+}

mtapi_network_c/src/embb_mtapi_network_socket.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_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_SOCKET_H_
+#define MTAPI_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_SOCKET_H_
+
+#include <stdint.h>
+#include <embb_mtapi_network_buffer.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct embb_mtapi_network_socket_struct {
+#ifdef _WIN32
+#  ifdef _WIN64
+  uint64_t handle;
+#  else
+  uint32_t handle;
+#  endif
+#else
+  int handle;
+#endif
+};
+
+typedef struct embb_mtapi_network_socket_struct embb_mtapi_network_socket_t;
+
+int embb_mtapi_network_socket_initialize(
+  embb_mtapi_network_socket_t * that
+);
+
+void embb_mtapi_network_socket_finalize(
+  embb_mtapi_network_socket_t * that
+);
+
+int embb_mtapi_network_socket_bind_and_listen(
+  embb_mtapi_network_socket_t * that,
+  char const * host,
+  uint16_t port,
+  uint16_t max_connections
+);
+
+int embb_mtapi_network_socket_accept(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_socket_t * sock
+);
+
+int embb_mtapi_network_socket_connect(
+  embb_mtapi_network_socket_t * that,
+  const char * host,
+  uint16_t port
+);
+
+int embb_mtapi_network_socket_select(
+  embb_mtapi_network_socket_t * sockets,
+  int count,
+  int timeout
+);
+
+int embb_mtapi_network_socket_sendbuffer(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_buffer_t * buffer
+);
+
+int embb_mtapi_network_socket_recvbuffer(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_buffer_t * buffer
+);
+
+int embb_mtapi_network_socket_recvbuffer_sized(
+  embb_mtapi_network_socket_t * that,
+  embb_mtapi_network_buffer_t * buffer,
+  int size
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MTAPI_NETWORK_C_SRC_EMBB_MTAPI_NETWORK_SOCKET_H_

mtapi_network_c/test/embb_mtapi_network_test_buffer.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_network_test_buffer.h>
+
+#include <embb_mtapi_network_buffer.h>
+
+#include <embb/base/c/memory_allocation.h>
+
+
+NetworkBufferTest::NetworkBufferTest() {
+  CreateUnit("mtapi network buffer test").Add(
+    &NetworkBufferTest::TestBasic, this);
+}
+
+void NetworkBufferTest::TestBasic() {
+  embb_mtapi_network_buffer_t buffer;
+  int err;
+
+  embb_mtapi_network_buffer_initialize(&buffer, 1024);
+
+  err = embb_mtapi_network_buffer_push_back_int8(&buffer, -1);
+  PT_EXPECT(err == 1);
+  err = embb_mtapi_network_buffer_push_back_int16(&buffer, -2);
+  PT_EXPECT(err == 2);
+
+  int8_t val8 = 0;
+  err = embb_mtapi_network_buffer_pop_front_int8(&buffer, &val8);
+  PT_EXPECT(err == 1);
+  PT_EXPECT(val8 == -1);
+
+  int32_t val32 = 0;
+  err = embb_mtapi_network_buffer_pop_front_int32(&buffer, &val32);
+  PT_EXPECT(err == 0);
+  PT_EXPECT(val32 == 0);
+
+  int16_t val16 = 0;
+  err = embb_mtapi_network_buffer_pop_front_int16(&buffer, &val16);
+  PT_EXPECT(err == 2);
+  PT_EXPECT(val16 == -2);
+
+  embb_mtapi_network_buffer_finalize(&buffer);
+
+  PT_EXPECT(embb_get_bytes_allocated() == 0);
+}

mtapi_network_c/test/embb_mtapi_network_test_buffer.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_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_BUFFER_H_
+#define MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_BUFFER_H_
+
+#include <partest/partest.h>
+
+class NetworkBufferTest : public partest::TestCase {
+ public:
+  NetworkBufferTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_BUFFER_H_

mtapi_network_c/test/embb_mtapi_network_test_socket.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_network_test_socket.h>
+
+#include <embb_mtapi_network.h>
+#include <embb_mtapi_network_socket.h>
+
+#include <embb/base/c/memory_allocation.h>
+
+
+NetworkSocketTest::NetworkSocketTest() {
+  CreateUnit("mtapi network socket test").Add(
+    &NetworkSocketTest::TestBasic, this);
+}
+
+void NetworkSocketTest::TestBasic() {
+  int err;
+  embb_mtapi_network_socket_t server_sock;
+  embb_mtapi_network_socket_t accept_sock;
+  embb_mtapi_network_socket_t client_sock;
+  embb_mtapi_network_buffer_t send_buffer;
+  embb_mtapi_network_buffer_t recv_buffer;
+
+  embb_mtapi_network_buffer_initialize(&send_buffer, 4);
+  embb_mtapi_network_buffer_initialize(&recv_buffer, 4);
+
+  err = embb_mtapi_network_initialize();
+  PT_EXPECT(err != 0);
+
+  err = embb_mtapi_network_socket_initialize(&server_sock);
+  PT_EXPECT(err != 0);
+  err = embb_mtapi_network_socket_bind_and_listen(
+    &server_sock, "127.0.0.1", 4711, 5);
+  PT_EXPECT(err != 0);
+
+  err = embb_mtapi_network_socket_select(&server_sock, 1, 1);
+  PT_EXPECT(err == -1);
+
+  err = embb_mtapi_network_socket_initialize(&client_sock);
+  PT_EXPECT(err != 0);
+  err = embb_mtapi_network_socket_connect(&client_sock, "127.0.0.1", 4711);
+  PT_EXPECT(err != 0);
+
+  err = embb_mtapi_network_socket_select(&server_sock, 1, -1);
+  PT_EXPECT(err == 0);
+
+  err = embb_mtapi_network_socket_accept(&server_sock, &accept_sock);
+  PT_EXPECT(err != 0);
+
+  err = embb_mtapi_network_socket_select(&accept_sock, 1, 1);
+  PT_EXPECT(err == -1);
+
+  err = embb_mtapi_network_buffer_push_back_int32(&send_buffer, 0x12345678);
+  PT_EXPECT(err == 4);
+  err = embb_mtapi_network_socket_sendbuffer(&client_sock, &send_buffer);
+  PT_EXPECT(err == 4);
+
+  err = embb_mtapi_network_socket_select(&accept_sock, 1, -1);
+  PT_EXPECT(err == 0);
+  err = embb_mtapi_network_socket_recvbuffer(&accept_sock, &recv_buffer);
+  PT_EXPECT(err == 4);
+
+  int32_t result = 0;
+  err = embb_mtapi_network_buffer_pop_front_int32(&recv_buffer, &result);
+  PT_EXPECT(err == 4);
+  PT_EXPECT(result == 0x12345678);
+
+  embb_mtapi_network_socket_finalize(&accept_sock);
+  embb_mtapi_network_socket_finalize(&client_sock);
+  embb_mtapi_network_socket_finalize(&server_sock);
+
+  embb_mtapi_network_buffer_finalize(&recv_buffer);
+  embb_mtapi_network_buffer_finalize(&send_buffer);
+
+  embb_mtapi_network_finalize();
+
+  PT_EXPECT(embb_get_bytes_allocated() == 0);
+}

mtapi_network_c/test/embb_mtapi_network_test_socket.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_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_SOCKET_H_
+#define MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_SOCKET_H_
+
+#include <partest/partest.h>
+
+class NetworkSocketTest : public partest::TestCase {
+ public:
+  NetworkSocketTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_SOCKET_H_

mtapi_network_c/test/embb_mtapi_network_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_network_test_task.h>
+
+#include <embb/mtapi/c/mtapi_ext.h>
+#include <embb/mtapi/c/mtapi_network.h>
+#include <embb/base/c/internal/unused.h>
+
+
+#define MTAPI_CHECK_STATUS(status) PT_ASSERT(MTAPI_SUCCESS == status)
+
+#define NETWORK_DOMAIN 1
+#define NETWORK_LOCAL_NODE 3
+#define NETWORK_LOCAL_JOB 3
+#define NETWORK_REMOTE_NODE 3
+#define NETWORK_REMOTE_JOB 4
+
+
+static void test(
+  void const * arguments,
+  mtapi_size_t arguments_size,
+  void * result_buffer,
+  mtapi_size_t result_buffer_size,
+  void const * node_local_data,
+  mtapi_size_t node_local_data_size,
+  mtapi_task_context_t * context) {
+  EMBB_UNUSED(context);
+  EMBB_UNUSED(result_buffer_size);
+  EMBB_UNUSED(node_local_data_size);
+  int elements = static_cast<int>(arguments_size / sizeof(float) / 2);
+  float const * a = reinterpret_cast<float const *>(arguments);
+  float const * b = reinterpret_cast<float const *>(arguments)+elements;
+  float * c = reinterpret_cast<float*>(result_buffer);
+  float const * d = reinterpret_cast<float const *>(node_local_data);
+  for (int ii = 0; ii < elements; ii++) {
+    c[ii] = a[ii] + b[ii] + d[0];
+  }
+}
+
+
+NetworkTaskTest::NetworkTaskTest() {
+  CreateUnit("mtapi network task test").Add(&NetworkTaskTest::TestBasic, this);
+}
+
+void NetworkTaskTest::TestBasic() {
+  mtapi_status_t status;
+  mtapi_job_hndl_t job;
+  mtapi_task_hndl_t task;
+  mtapi_action_hndl_t network_action, local_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_initialize(
+    NETWORK_DOMAIN,
+    NETWORK_LOCAL_NODE,
+    MTAPI_NULL,
+    MTAPI_NULL,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_network_plugin_initialize("127.0.0.1", 12345, 5,
+    kElements * 4 * 3 + 32, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  float node_remote = 1.0f;
+  local_action = mtapi_action_create(
+    NETWORK_REMOTE_JOB,
+    test,
+    &node_remote, sizeof(float),
+    MTAPI_DEFAULT_ACTION_ATTRIBUTES,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  network_action = mtapi_network_action_create(
+    NETWORK_DOMAIN,
+    NETWORK_LOCAL_JOB,
+    NETWORK_REMOTE_JOB,
+    "127.0.0.1", 12345,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  job = mtapi_job_get(NETWORK_LOCAL_JOB, NETWORK_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(network_action, MTAPI_INFINITE, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_action_delete(local_action, MTAPI_INFINITE, &status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_network_plugin_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+}

mtapi_network_c/test/embb_mtapi_network_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_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_TASK_H_
+#define MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_TASK_H_
+
+#include <partest/partest.h>
+
+class NetworkTaskTest : public partest::TestCase {
+ public:
+  NetworkTaskTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_TASK_H_

mtapi_network_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_network_test_buffer.h>
+#include <embb_mtapi_network_test_socket.h>
+#include <embb_mtapi_network_test_task.h>
+
+PT_MAIN("MTAPI NETWORK") {
+  PT_RUN(NetworkBufferTest);
+  PT_RUN(NetworkSocketTest);
+  PT_RUN(NetworkTaskTest);
+}

mtapi_opencl_c/CMakeLists.txt

+project (project_embb_mtapi_opencl_c)
+
+file(GLOB_RECURSE EMBB_MTAPI_OPENCL_C_SOURCES "src/*.c" "src/*.h")
+file(GLOB_RECURSE EMBB_MTAPI_OPENCL_C_HEADERS "include/*.h")
+
+file(GLOB_RECURSE EMBB_MTAPI_OPENCL_TEST_SOURCES "test/*.cc" "test/*.h")
+  
+IF(MSVC8 OR MSVC9 OR MSVC10 OR MSVC11)
+FOREACH(src_tmp ${EMBB_MTAPI_OPENCL_TEST_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+FOREACH(src_tmp ${EMBB_MTAPI_OPENCL_C_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+ENDIF()
+
+IF(CMAKE_COMPILER_IS_GNUCC)
+  set (EMBB_MTAPI_OPENCL_C_LIBS dl)
+ENDIF()
+
+# Execute the GroupSources macro
+include(${CMAKE_SOURCE_DIR}/CMakeCommon/GroupSourcesMSVC.cmake)
+GroupSourcesMSVC(include)
+GroupSourcesMSVC(src)
+GroupSourcesMSVC(test)
+
+set (EMBB_MTAPI_OPENCL_INCLUDE_DIRS "include" "src" "test")
+include_directories(${EMBB_MTAPI_OPENCL_INCLUDE_DIRS}
+                    ${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_opencl_c ${EMBB_MTAPI_OPENCL_C_SOURCES} ${EMBB_MTAPI_OPENCL_C_HEADERS})
+target_link_libraries(embb_mtapi_opencl_c embb_mtapi_c embb_base_c)
+
+if (BUILD_TESTS STREQUAL ON)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/../partest/include)
+  add_executable (embb_mtapi_opencl_c_test ${EMBB_MTAPI_OPENCL_TEST_SOURCES})
+  target_link_libraries(embb_mtapi_opencl_c_test embb_mtapi_opencl_c embb_mtapi_c partest embb_base_c ${compiler_libs} ${EMBB_MTAPI_OPENCL_C_LIBS})
+  CopyBin(BIN embb_mtapi_opencl_c_test DEST ${local_install_dir})
+endif()
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
+        DESTINATION include FILES_MATCHING PATTERN "*.h")
+install(TARGETS embb_mtapi_opencl_c DESTINATION lib)

mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.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_OPENCL_H_
+#define EMBB_MTAPI_C_MTAPI_OPENCL_H_
+
+
+#include <embb/mtapi/c/mtapi_ext.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * \defgroup C_MTAPI_OPENCL MTAPI OpenCL Plugin
+ *
+ * \ingroup C_MTAPI_EXT
+ *
+ * Provides functionality to execute tasks on OpenCL devices.
+ */
+
+
+/**
+ * Initializes the MTAPI OpenCL environment on a previously initialized MTAPI
+ * node.
+ *
+ * It must be called on all nodes using the MTAPI OpenCL plugin.
+ *
+ * Application software using MTAPI network 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
+ * 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 OpenCL couldn't be initialized.
+ *
+ * \see mtapi_opencl_plugin_finalize()
+ *
+ * \notthreadsafe
+ * \ingroup C_MTAPI_OPENCL
+ */
+void mtapi_opencl_plugin_initialize(
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+/**
+ * Finalizes the MTAPI OpenCL environment on the local MTAPI node.
+ *
+ * It has to be called by each node using MTAPI OpenCL. It is an error to call
+ * mtapi_opencl_plugin_finalize() without first calling
+ * mtapi_opencl_plugin_initialize(). An MTAPI node can call
+ * mtapi_opencl_plugin_finalize() once for each call to
+ * mtapi_opencl_plugin_initialize(), but it is an error to call
+ * mtapi_opencl_plugin_finalize() multiple times from a given node
+ * 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
+ * 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
+ * actions on the node where mtapi_opencl_plugin_finalize() is called, also
+ * block finalization of the MTAPI OpenCL 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 OpenCL couldn't be finalized.
+ *
+ * \see mtapi_opencl_plugin_initialize(), mtapi_task_cancel()
+ *
+ * \notthreadsafe
+ * \ingroup C_MTAPI_OPENCL
+ */
+void mtapi_opencl_plugin_finalize(
+  MTAPI_OUT mtapi_status_t* status     /**< [out] Pointer to error code,
+                                            may be \c MTAPI_NULL */
+);
+
+/**
+ * This function creates an OpenCL action.
+ *
+ * It is called on the node where the user wants to execute an action on an
+ * OpenCL device. An OpenCL action contains a reference to a local job, the
+ * kernel source to compile and execute on the OpenCL device, the name of the
+ * kernel function, a local work size (see OpenCL specification for details)
+ * and the size of one element in the result buffer.
+ * After an OpenCL 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. An OpenCL action's
+ * life-cycle begins with mtapi_opencl_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 OpenCL device was
+ *         available.</td>
+ *   </tr>
+ * </table>
+ *
+ * \see mtapi_action_delete(), mtapi_finalize()
+ *
+ * \returns Handle to newly created OpenCL action, invalid handle on error
+ * \threadsafe
+ * \ingroup C_MTAPI_OPENCL
+ */
+mtapi_action_hndl_t mtapi_opencl_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_OPENCL_H_

mtapi_opencl_c/src/CL/cl.h

+/*******************************************************************************
+ * Copyright (c) 2008-2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
+
+/* $Revision: 11708 $ on $Date: 2010-06-14 12:06:24 +0530 (Mon, 14 Jun 2010) $ */
+
+#ifndef __OPENCL_CL_H
+#define __OPENCL_CL_H
+
+#ifdef __APPLE__
+#include <OpenCL/cl_platform.h>
+#else
+#include <CL/cl_platform.h>
+#endif	
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/******************************************************************************/
+
+typedef struct _cl_platform_id *    cl_platform_id;
+typedef struct _cl_device_id *      cl_device_id;
+typedef struct _cl_context *        cl_context;
+typedef struct _cl_command_queue *  cl_command_queue;
+typedef struct _cl_mem *            cl_mem;
+typedef struct _cl_program *        cl_program;
+typedef struct _cl_kernel *         cl_kernel;
+typedef struct _cl_event *          cl_event;
+typedef struct _cl_sampler *        cl_sampler;
+
+typedef cl_uint             cl_bool;                     /* WARNING!  Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */ 
+typedef cl_ulong            cl_bitfield;
+typedef cl_bitfield         cl_device_type;
+typedef cl_uint             cl_platform_info;
+typedef cl_uint             cl_device_info;
+typedef cl_bitfield         cl_device_fp_config;
+typedef cl_uint             cl_device_mem_cache_type;
+typedef cl_uint             cl_device_local_mem_type;
+typedef cl_bitfield         cl_device_exec_capabilities;
+typedef cl_bitfield         cl_command_queue_properties;
+
+typedef intptr_t			cl_context_properties;
+typedef cl_uint             cl_context_info;
+typedef cl_uint             cl_command_queue_info;
+typedef cl_uint             cl_channel_order;
+typedef cl_uint             cl_channel_type;
+typedef cl_bitfield         cl_mem_flags;
+typedef cl_uint             cl_mem_object_type;
+typedef cl_uint             cl_mem_info;
+typedef cl_uint             cl_image_info;
+typedef cl_uint             cl_buffer_create_type;
+typedef cl_uint             cl_addressing_mode;
+typedef cl_uint             cl_filter_mode;
+typedef cl_uint             cl_sampler_info;
+typedef cl_bitfield         cl_map_flags;
+typedef cl_uint             cl_program_info;
+typedef cl_uint             cl_program_build_info;
+typedef cl_int              cl_build_status;
+typedef cl_uint             cl_kernel_info;
+typedef cl_uint             cl_kernel_work_group_info;
+typedef cl_uint             cl_event_info;
+typedef cl_uint             cl_command_type;
+typedef cl_uint             cl_profiling_info;
+
+typedef struct _cl_image_format {
+    cl_channel_order        image_channel_order;
+    cl_channel_type         image_channel_data_type;
+} cl_image_format;
+
+
+typedef struct _cl_buffer_region {
+    size_t                  origin;
+    size_t                  size;
+} cl_buffer_region;
+
+/******************************************************************************/
+
+/* Error Codes */
+#define CL_SUCCESS                                  0
+#define CL_DEVICE_NOT_FOUND                         -1
+#define CL_DEVICE_NOT_AVAILABLE                     -2
+#define CL_COMPILER_NOT_AVAILABLE                   -3
+#define CL_MEM_OBJECT_ALLOCATION_FAILURE            -4
+#define CL_OUT_OF_RESOURCES                         -5
+#define CL_OUT_OF_HOST_MEMORY                       -6
+#define CL_PROFILING_INFO_NOT_AVAILABLE             -7
+#define CL_MEM_COPY_OVERLAP                         -8
+#define CL_IMAGE_FORMAT_MISMATCH                    -9
+#define CL_IMAGE_FORMAT_NOT_SUPPORTED               -10
+#define CL_BUILD_PROGRAM_FAILURE                    -11
+#define CL_MAP_FAILURE                              -12
+#define CL_MISALIGNED_SUB_BUFFER_OFFSET             -13
+#define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14
+
+#define CL_INVALID_VALUE                            -30
+#define CL_INVALID_DEVICE_TYPE                      -31
+#define CL_INVALID_PLATFORM                         -32
+#define CL_INVALID_DEVICE                           -33
+#define CL_INVALID_CONTEXT                          -34
+#define CL_INVALID_QUEUE_PROPERTIES                 -35
+#define CL_INVALID_COMMAND_QUEUE                    -36
+#define CL_INVALID_HOST_PTR                         -37
+#define CL_INVALID_MEM_OBJECT                       -38
+#define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR          -39
+#define CL_INVALID_IMAGE_SIZE                       -40
+#define CL_INVALID_SAMPLER                          -41
+#define CL_INVALID_BINARY                           -42
+#define CL_INVALID_BUILD_OPTIONS                    -43
+#define CL_INVALID_PROGRAM                          -44
+#define CL_INVALID_PROGRAM_EXECUTABLE               -45
+#define CL_INVALID_KERNEL_NAME                      -46
+#define CL_INVALID_KERNEL_DEFINITION                -47
+#define CL_INVALID_KERNEL                           -48
+#define CL_INVALID_ARG_INDEX                        -49
+#define CL_INVALID_ARG_VALUE                        -50
+#define CL_INVALID_ARG_SIZE                         -51
+#define CL_INVALID_KERNEL_ARGS                      -52
+#define CL_INVALID_WORK_DIMENSION                   -53
+#define CL_INVALID_WORK_GROUP_SIZE                  -54
+#define CL_INVALID_WORK_ITEM_SIZE                   -55
+#define CL_INVALID_GLOBAL_OFFSET                    -56
+#define CL_INVALID_EVENT_WAIT_LIST                  -57
+#define CL_INVALID_EVENT                            -58
+#define CL_INVALID_OPERATION                        -59
+#define CL_INVALID_GL_OBJECT                        -60
+#define CL_INVALID_BUFFER_SIZE                      -61
+#define CL_INVALID_MIP_LEVEL                        -62
+#define CL_INVALID_GLOBAL_WORK_SIZE                 -63
+
+/* OpenCL Version */
+#define CL_VERSION_1_0                              1
+#define CL_VERSION_1_1                              1
+
+/* cl_bool */
+#define CL_FALSE                                    0
+#define CL_TRUE                                     1
+
+/* cl_platform_info */
+#define CL_PLATFORM_PROFILE                         0x0900
+#define CL_PLATFORM_VERSION                         0x0901
+#define CL_PLATFORM_NAME                            0x0902
+#define CL_PLATFORM_VENDOR                          0x0903
+#define CL_PLATFORM_EXTENSIONS                      0x0904
+
+/* cl_device_type - bitfield */
+#define CL_DEVICE_TYPE_DEFAULT                      (1 << 0)
+#define CL_DEVICE_TYPE_CPU                          (1 << 1)
+#define CL_DEVICE_TYPE_GPU                          (1 << 2)
+#define CL_DEVICE_TYPE_ACCELERATOR                  (1 << 3)
+#define CL_DEVICE_TYPE_ALL                          0xFFFFFFFF
+
+/* cl_device_info */
+#define CL_DEVICE_TYPE                              0x1000
+#define CL_DEVICE_VENDOR_ID                         0x1001
+#define CL_DEVICE_MAX_COMPUTE_UNITS                 0x1002
+#define CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS          0x1003
+#define CL_DEVICE_MAX_WORK_GROUP_SIZE               0x1004
+#define CL_DEVICE_MAX_WORK_ITEM_SIZES               0x1005
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR       0x1006
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT      0x1007
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT        0x1008
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG       0x1009
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT      0x100A
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE     0x100B
+#define CL_DEVICE_MAX_CLOCK_FREQUENCY               0x100C
+#define CL_DEVICE_ADDRESS_BITS                      0x100D
+#define CL_DEVICE_MAX_READ_IMAGE_ARGS               0x100E
+#define CL_DEVICE_MAX_WRITE_IMAGE_ARGS              0x100F
+#define CL_DEVICE_MAX_MEM_ALLOC_SIZE                0x1010
+#define CL_DEVICE_IMAGE2D_MAX_WIDTH                 0x1011
+#define CL_DEVICE_IMAGE2D_MAX_HEIGHT                0x1012
+#define CL_DEVICE_IMAGE3D_MAX_WIDTH                 0x1013
+#define CL_DEVICE_IMAGE3D_MAX_HEIGHT                0x1014
+#define CL_DEVICE_IMAGE3D_MAX_DEPTH                 0x1015
+#define CL_DEVICE_IMAGE_SUPPORT                     0x1016
+#define CL_DEVICE_MAX_PARAMETER_SIZE                0x1017
+#define CL_DEVICE_MAX_SAMPLERS                      0x1018
+#define CL_DEVICE_MEM_BASE_ADDR_ALIGN               0x1019
+#define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE          0x101A
+#define CL_DEVICE_SINGLE_FP_CONFIG                  0x101B
+#define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE             0x101C
+#define CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE         0x101D
+#define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE             0x101E
+#define CL_DEVICE_GLOBAL_MEM_SIZE                   0x101F
+#define CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE          0x1020
+#define CL_DEVICE_MAX_CONSTANT_ARGS                 0x1021
+#define CL_DEVICE_LOCAL_MEM_TYPE                    0x1022
+#define CL_DEVICE_LOCAL_MEM_SIZE                    0x1023
+#define CL_DEVICE_ERROR_CORRECTION_SUPPORT          0x1024
+#define CL_DEVICE_PROFILING_TIMER_RESOLUTION        0x1025
+#define CL_DEVICE_ENDIAN_LITTLE                     0x1026
+#define CL_DEVICE_AVAILABLE                         0x1027
+#define CL_DEVICE_COMPILER_AVAILABLE                0x1028
+#define CL_DEVICE_EXECUTION_CAPABILITIES            0x1029
+#define CL_DEVICE_QUEUE_PROPERTIES                  0x102A
+#define CL_DEVICE_NAME                              0x102B
+#define CL_DEVICE_VENDOR                            0x102C
+#define CL_DRIVER_VERSION                           0x102D
+#define CL_DEVICE_PROFILE                           0x102E
+#define CL_DEVICE_VERSION                           0x102F
+#define CL_DEVICE_EXTENSIONS                        0x1030
+#define CL_DEVICE_PLATFORM                          0x1031
+/* 0x1032 reserved for CL_DEVICE_DOUBLE_FP_CONFIG */
+/* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG */
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF       0x1034
+#define CL_DEVICE_HOST_UNIFIED_MEMORY               0x1035
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR          0x1036
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT         0x1037
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_INT           0x1038
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG          0x1039
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT         0x103A
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE        0x103B
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF          0x103C
+#define CL_DEVICE_OPENCL_C_VERSION                  0x103D
+
+/* cl_device_fp_config - bitfield */
+#define CL_FP_DENORM                                (1 << 0)
+#define CL_FP_INF_NAN                               (1 << 1)
+#define CL_FP_ROUND_TO_NEAREST                      (1 << 2)
+#define CL_FP_ROUND_TO_ZERO                         (1 << 3)
+#define CL_FP_ROUND_TO_INF                          (1 << 4)
+#define CL_FP_FMA                                   (1 << 5)
+#define CL_FP_SOFT_FLOAT                            (1 << 6)
+
+/* cl_device_mem_cache_type */
+#define CL_NONE                                     0x0
+#define CL_READ_ONLY_CACHE                          0x1
+#define CL_READ_WRITE_CACHE                         0x2
+
+/* cl_device_local_mem_type */
+#define CL_LOCAL                                    0x1
+#define CL_GLOBAL                                   0x2
+
+/* cl_device_exec_capabilities - bitfield */
+#define CL_EXEC_KERNEL                              (1 << 0)
+#define CL_EXEC_NATIVE_KERNEL                       (1 << 1)
+
+/* cl_command_queue_properties - bitfield */
+#define CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE      (1 << 0)
+#define CL_QUEUE_PROFILING_ENABLE                   (1 << 1)
+
+/* cl_context_info  */
+#define CL_CONTEXT_REFERENCE_COUNT                  0x1080
+#define CL_CONTEXT_DEVICES                          0x1081
+#define CL_CONTEXT_PROPERTIES                       0x1082
+#define CL_CONTEXT_NUM_DEVICES                      0x1083
+
+/* cl_context_info + cl_context_properties */
+#define CL_CONTEXT_PLATFORM                         0x1084
+
+/* cl_command_queue_info */
+#define CL_QUEUE_CONTEXT                            0x1090
+#define CL_QUEUE_DEVICE                             0x1091
+#define CL_QUEUE_REFERENCE_COUNT                    0x1092
+#define CL_QUEUE_PROPERTIES                         0x1093
+
+/* cl_mem_flags - bitfield */
+#define CL_MEM_READ_WRITE                           (1 << 0)
+#define CL_MEM_WRITE_ONLY                           (1 << 1)
+#define CL_MEM_READ_ONLY                            (1 << 2)
+#define CL_MEM_USE_HOST_PTR                         (1 << 3)
+#define CL_MEM_ALLOC_HOST_PTR                       (1 << 4)
+#define CL_MEM_COPY_HOST_PTR                        (1 << 5)
+
+/* cl_channel_order */
+#define CL_R                                        0x10B0
+#define CL_A                                        0x10B1
+#define CL_RG                                       0x10B2
+#define CL_RA                                       0x10B3
+#define CL_RGB                                      0x10B4
+#define CL_RGBA                                     0x10B5
+#define CL_BGRA                                     0x10B6
+#define CL_ARGB                                     0x10B7
+#define CL_INTENSITY                                0x10B8
+#define CL_LUMINANCE                                0x10B9
+#define CL_Rx                                       0x10BA
+#define CL_RGx                                      0x10BB
+#define CL_RGBx                                     0x10BC
+
+/* cl_channel_type */
+#define CL_SNORM_INT8                               0x10D0
+#define CL_SNORM_INT16                              0x10D1
+#define CL_UNORM_INT8                               0x10D2
+#define CL_UNORM_INT16                              0x10D3
+#define CL_UNORM_SHORT_565                          0x10D4
+#define CL_UNORM_SHORT_555                          0x10D5
+#define CL_UNORM_INT_101010                         0x10D6
+#define CL_SIGNED_INT8                              0x10D7
+#define CL_SIGNED_INT16                             0x10D8
+#define CL_SIGNED_INT32                             0x10D9
+#define CL_UNSIGNED_INT8                            0x10DA
+#define CL_UNSIGNED_INT16                           0x10DB
+#define CL_UNSIGNED_INT32                           0x10DC
+#define CL_HALF_FLOAT                               0x10DD
+#define CL_FLOAT                                    0x10DE
+
+/* cl_mem_object_type */
+#define CL_MEM_OBJECT_BUFFER                        0x10F0
+#define CL_MEM_OBJECT_IMAGE2D                       0x10F1
+#define CL_MEM_OBJECT_IMAGE3D                       0x10F2
+
+/* cl_mem_info */
+#define CL_MEM_TYPE                                 0x1100
+#define CL_MEM_FLAGS                                0x1101
+#define CL_MEM_SIZE                                 0x1102
+#define CL_MEM_HOST_PTR                             0x1103
+#define CL_MEM_MAP_COUNT                            0x1104
+#define CL_MEM_REFERENCE_COUNT                      0x1105
+#define CL_MEM_CONTEXT                              0x1106
+#define CL_MEM_ASSOCIATED_MEMOBJECT                 0x1107
+#define CL_MEM_OFFSET                               0x1108
+
+/* cl_image_info */
+#define CL_IMAGE_FORMAT                             0x1110
+#define CL_IMAGE_ELEMENT_SIZE                       0x1111
+#define CL_IMAGE_ROW_PITCH                          0x1112
+#define CL_IMAGE_SLICE_PITCH                        0x1113
+#define CL_IMAGE_WIDTH                              0x1114
+#define CL_IMAGE_HEIGHT                             0x1115
+#define CL_IMAGE_DEPTH                              0x1116
+
+/* cl_addressing_mode */
+#define CL_ADDRESS_NONE                             0x1130
+#define CL_ADDRESS_CLAMP_TO_EDGE                    0x1131
+#define CL_ADDRESS_CLAMP                            0x1132
+#define CL_ADDRESS_REPEAT                           0x1133
+#define CL_ADDRESS_MIRRORED_REPEAT                  0x1134
+
+/* cl_filter_mode */
+#define CL_FILTER_NEAREST                           0x1140
+#define CL_FILTER_LINEAR                            0x1141
+
+/* cl_sampler_info */
+#define CL_SAMPLER_REFERENCE_COUNT                  0x1150
+#define CL_SAMPLER_CONTEXT                          0x1151
+#define CL_SAMPLER_NORMALIZED_COORDS                0x1152
+#define CL_SAMPLER_ADDRESSING_MODE                  0x1153
+#define CL_SAMPLER_FILTER_MODE                      0x1154
+
+/* cl_map_flags - bitfield */
+#define CL_MAP_READ                                 (1 << 0)
+#define CL_MAP_WRITE                                (1 << 1)
+
+/* cl_program_info */
+#define CL_PROGRAM_REFERENCE_COUNT                  0x1160
+#define CL_PROGRAM_CONTEXT                          0x1161
+#define CL_PROGRAM_NUM_DEVICES                      0x1162
+#define CL_PROGRAM_DEVICES                          0x1163
+#define CL_PROGRAM_SOURCE                           0x1164
+#define CL_PROGRAM_BINARY_SIZES                     0x1165
+#define CL_PROGRAM_BINARIES                         0x1166
+
+/* cl_program_build_info */
+#define CL_PROGRAM_BUILD_STATUS                     0x1181
+#define CL_PROGRAM_BUILD_OPTIONS                    0x1182
+#define CL_PROGRAM_BUILD_LOG                        0x1183
+
+/* cl_build_status */
+#define CL_BUILD_SUCCESS                            0
+#define CL_BUILD_NONE                               -1
+#define CL_BUILD_ERROR                              -2
+#define CL_BUILD_IN_PROGRESS                        -3
+
+/* cl_kernel_info */
+#define CL_KERNEL_FUNCTION_NAME                     0x1190
+#define CL_KERNEL_NUM_ARGS                          0x1191
+#define CL_KERNEL_REFERENCE_COUNT                   0x1192
+#define CL_KERNEL_CONTEXT                           0x1193
+#define CL_KERNEL_PROGRAM                           0x1194
+
+/* cl_kernel_work_group_info */
+#define CL_KERNEL_WORK_GROUP_SIZE                   0x11B0
+#define CL_KERNEL_COMPILE_WORK_GROUP_SIZE           0x11B1
+#define CL_KERNEL_LOCAL_MEM_SIZE                    0x11B2
+#define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3
+#define CL_KERNEL_PRIVATE_MEM_SIZE                  0x11B4
+
+/* cl_event_info  */
+#define CL_EVENT_COMMAND_QUEUE                      0x11D0
+#define CL_EVENT_COMMAND_TYPE                       0x11D1
+#define CL_EVENT_REFERENCE_COUNT                    0x11D2
+#define CL_EVENT_COMMAND_EXECUTION_STATUS           0x11D3
+#define CL_EVENT_CONTEXT                            0x11D4
+
+/* cl_command_type */
+#define CL_COMMAND_NDRANGE_KERNEL                   0x11F0
+#define CL_COMMAND_TASK                             0x11F1
+#define CL_COMMAND_NATIVE_KERNEL                    0x11F2
+#define CL_COMMAND_READ_BUFFER                      0x11F3
+#define CL_COMMAND_WRITE_BUFFER                     0x11F4
+#define CL_COMMAND_COPY_BUFFER                      0x11F5
+#define CL_COMMAND_READ_IMAGE                       0x11F6
+#define CL_COMMAND_WRITE_IMAGE                      0x11F7
+#define CL_COMMAND_COPY_IMAGE                       0x11F8
+#define CL_COMMAND_COPY_IMAGE_TO_BUFFER             0x11F9
+#define CL_COMMAND_COPY_BUFFER_TO_IMAGE             0x11FA
+#define CL_COMMAND_MAP_BUFFER                       0x11FB
+#define CL_COMMAND_MAP_IMAGE                        0x11FC
+#define CL_COMMAND_UNMAP_MEM_OBJECT                 0x11FD
+#define CL_COMMAND_MARKER                           0x11FE
+#define CL_COMMAND_ACQUIRE_GL_OBJECTS               0x11FF
+#define CL_COMMAND_RELEASE_GL_OBJECTS               0x1200
+#define CL_COMMAND_READ_BUFFER_RECT                 0x1201
+#define CL_COMMAND_WRITE_BUFFER_RECT                0x1202
+#define CL_COMMAND_COPY_BUFFER_RECT                 0x1203
+#define CL_COMMAND_USER                             0x1204
+
+/* command execution status */
+#define CL_COMPLETE                                 0x0
+#define CL_RUNNING                                  0x1
+#define CL_SUBMITTED                                0x2
+#define CL_QUEUED                                   0x3
+  
+/* cl_buffer_create_type  */
+#define CL_BUFFER_CREATE_TYPE_REGION                0x1220
+
+/* cl_profiling_info  */
+#define CL_PROFILING_COMMAND_QUEUED                 0x1280
+#define CL_PROFILING_COMMAND_SUBMIT                 0x1281
+#define CL_PROFILING_COMMAND_START                  0x1282
+#define CL_PROFILING_COMMAND_END                    0x1283
+
+/********************************************************************************************************/
+
+/* Platform API */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetPlatformIDs(cl_uint          /* num_entries */,
+                 cl_platform_id * /* platforms */,
+                 cl_uint *        /* num_platforms */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL 
+clGetPlatformInfo(cl_platform_id   /* platform */, 
+                  cl_platform_info /* param_name */,
+                  size_t           /* param_value_size */, 
+                  void *           /* param_value */,
+                  size_t *         /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+/* Device APIs */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetDeviceIDs(cl_platform_id   /* platform */,
+               cl_device_type   /* device_type */, 
+               cl_uint          /* num_entries */, 
+               cl_device_id *   /* devices */, 
+               cl_uint *        /* num_devices */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetDeviceInfo(cl_device_id    /* device */,
+                cl_device_info  /* param_name */, 
+                size_t          /* param_value_size */, 
+                void *          /* param_value */,
+                size_t *        /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+/* Context APIs  */
+extern CL_API_ENTRY cl_context CL_API_CALL
+clCreateContext(const cl_context_properties * /* properties */,
+                cl_uint                       /* num_devices */,
+                const cl_device_id *          /* devices */,
+                void (CL_CALLBACK * /* pfn_notify */)(const char *, const void *, size_t, void *),
+                void *                        /* user_data */,
+                cl_int *                      /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_context CL_API_CALL
+clCreateContextFromType(const cl_context_properties * /* properties */,
+                        cl_device_type                /* device_type */,
+                        void (CL_CALLBACK *     /* pfn_notify*/ )(const char *, const void *, size_t, void *),
+                        void *                        /* user_data */,
+                        cl_int *                      /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetContextInfo(cl_context         /* context */, 
+                 cl_context_info    /* param_name */, 
+                 size_t             /* param_value_size */, 
+                 void *             /* param_value */, 
+                 size_t *           /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+/* Command Queue APIs */
+extern CL_API_ENTRY cl_command_queue CL_API_CALL
+clCreateCommandQueue(cl_context                     /* context */, 
+                     cl_device_id                   /* device */, 
+                     cl_command_queue_properties    /* properties */,
+                     cl_int *                       /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetCommandQueueInfo(cl_command_queue      /* command_queue */,
+                      cl_command_queue_info /* param_name */,
+                      size_t                /* param_value_size */,
+                      void *                /* param_value */,
+                      size_t *              /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+#ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS
+#warning CL_USE_DEPRECATED_OPENCL_1_0_APIS is defined. These APIs are unsupported and untested in OpenCL 1.1!
+/* 
+ *  WARNING:
+ *     This API introduces mutable state into the OpenCL implementation. It has been REMOVED
+ *  to better facilitate thread safety.  The 1.0 API is not thread safe. It is not tested by the
+ *  OpenCL 1.1 conformance test, and consequently may not work or may not work dependably.
+ *  It is likely to be non-performant. Use of this API is not advised. Use at your own risk.
+ *
+ *  Software developers previously relying on this API are instructed to set the command queue 
+ *  properties when creating the queue, instead. 
+ */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clSetCommandQueueProperty(cl_command_queue              /* command_queue */,
+                          cl_command_queue_properties   /* properties */, 
+                          cl_bool                        /* enable */,
+                          cl_command_queue_properties * /* old_properties */) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED;
+#endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */
+
+/* Memory Object APIs */
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateBuffer(cl_context   /* context */,
+               cl_mem_flags /* flags */,
+               size_t       /* size */,
+               void *       /* host_ptr */,
+               cl_int *     /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateSubBuffer(cl_mem                   /* buffer */,
+                  cl_mem_flags             /* flags */,
+                  cl_buffer_create_type    /* buffer_create_type */,
+                  const void *             /* buffer_create_info */,
+                  cl_int *                 /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
+
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateImage2D(cl_context              /* context */,
+                cl_mem_flags            /* flags */,
+                const cl_image_format * /* image_format */,
+                size_t                  /* image_width */,
+                size_t                  /* image_height */,
+                size_t                  /* image_row_pitch */, 
+                void *                  /* host_ptr */,
+                cl_int *                /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+                        
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateImage3D(cl_context              /* context */,
+                cl_mem_flags            /* flags */,
+                const cl_image_format * /* image_format */,
+                size_t                  /* image_width */, 
+                size_t                  /* image_height */,
+                size_t                  /* image_depth */, 
+                size_t                  /* image_row_pitch */, 
+                size_t                  /* image_slice_pitch */, 
+                void *                  /* host_ptr */,
+                cl_int *                /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+                        
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetSupportedImageFormats(cl_context           /* context */,
+                           cl_mem_flags         /* flags */,
+                           cl_mem_object_type   /* image_type */,
+                           cl_uint              /* num_entries */,
+                           cl_image_format *    /* image_formats */,
+                           cl_uint *            /* num_image_formats */) CL_API_SUFFIX__VERSION_1_0;
+                                    
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetMemObjectInfo(cl_mem           /* memobj */,
+                   cl_mem_info      /* param_name */, 
+                   size_t           /* param_value_size */,
+                   void *           /* param_value */,
+                   size_t *         /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetImageInfo(cl_mem           /* image */,
+               cl_image_info    /* param_name */, 
+               size_t           /* param_value_size */,
+               void *           /* param_value */,
+               size_t *         /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clSetMemObjectDestructorCallback(  cl_mem /* memobj */, 
+                                    void (CL_CALLBACK * /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/), 
+                                    void * /*user_data */ )             CL_API_SUFFIX__VERSION_1_1;  
+
+/* Sampler APIs  */
+extern CL_API_ENTRY cl_sampler CL_API_CALL
+clCreateSampler(cl_context          /* context */,
+                cl_bool             /* normalized_coords */, 
+                cl_addressing_mode  /* addressing_mode */, 
+                cl_filter_mode      /* filter_mode */,
+                cl_int *            /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetSamplerInfo(cl_sampler         /* sampler */,
+                 cl_sampler_info    /* param_name */,
+                 size_t             /* param_value_size */,
+                 void *             /* param_value */,
+                 size_t *           /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+                            
+/* Program Object APIs  */
+extern CL_API_ENTRY cl_program CL_API_CALL
+clCreateProgramWithSource(cl_context        /* context */,
+                          cl_uint           /* count */,
+                          const char **     /* strings */,
+                          const size_t *    /* lengths */,
+                          cl_int *          /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_program CL_API_CALL
+clCreateProgramWithBinary(cl_context                     /* context */,
+                          cl_uint                        /* num_devices */,
+                          const cl_device_id *           /* device_list */,
+                          const size_t *                 /* lengths */,
+                          const unsigned char **         /* binaries */,
+                          cl_int *                       /* binary_status */,
+                          cl_int *                       /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clBuildProgram(cl_program           /* program */,
+               cl_uint              /* num_devices */,
+               const cl_device_id * /* device_list */,
+               const char *         /* options */, 
+               void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void * /* user_data */),
+               void *               /* user_data */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetProgramInfo(cl_program         /* program */,
+                 cl_program_info    /* param_name */,
+                 size_t             /* param_value_size */,
+                 void *             /* param_value */,
+                 size_t *           /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetProgramBuildInfo(cl_program            /* program */,
+                      cl_device_id          /* device */,
+                      cl_program_build_info /* param_name */,
+                      size_t                /* param_value_size */,
+                      void *                /* param_value */,
+                      size_t *              /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+                            
+/* Kernel Object APIs */
+extern CL_API_ENTRY cl_kernel CL_API_CALL
+clCreateKernel(cl_program      /* program */,
+               const char *    /* kernel_name */,
+               cl_int *        /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clCreateKernelsInProgram(cl_program     /* program */,
+                         cl_uint        /* num_kernels */,
+                         cl_kernel *    /* kernels */,
+                         cl_uint *      /* num_kernels_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainKernel(cl_kernel    /* kernel */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseKernel(cl_kernel   /* kernel */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clSetKernelArg(cl_kernel    /* kernel */,
+               cl_uint      /* arg_index */,
+               size_t       /* arg_size */,
+               const void * /* arg_value */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetKernelInfo(cl_kernel       /* kernel */,
+                cl_kernel_info  /* param_name */,
+                size_t          /* param_value_size */,
+                void *          /* param_value */,
+                size_t *        /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetKernelWorkGroupInfo(cl_kernel                  /* kernel */,
+                         cl_device_id               /* device */,
+                         cl_kernel_work_group_info  /* param_name */,
+                         size_t                     /* param_value_size */,
+                         void *                     /* param_value */,
+                         size_t *                   /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+/* Event Object APIs  */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clWaitForEvents(cl_uint             /* num_events */,
+                const cl_event *    /* event_list */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetEventInfo(cl_event         /* event */,
+               cl_event_info    /* param_name */,
+               size_t           /* param_value_size */,
+               void *           /* param_value */,
+               size_t *         /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+                            
+extern CL_API_ENTRY cl_event CL_API_CALL
+clCreateUserEvent(cl_context    /* context */,
+                  cl_int *      /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;               
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clRetainEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clReleaseEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clSetUserEventStatus(cl_event   /* event */,
+                     cl_int     /* execution_status */) CL_API_SUFFIX__VERSION_1_1;
+                     
+extern CL_API_ENTRY cl_int CL_API_CALL
+clSetEventCallback( cl_event    /* event */,
+                    cl_int      /* command_exec_callback_type */,
+                    void (CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *),
+                    void *      /* user_data */) CL_API_SUFFIX__VERSION_1_1;
+
+/* Profiling APIs  */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetEventProfilingInfo(cl_event            /* event */,
+                        cl_profiling_info   /* param_name */,
+                        size_t              /* param_value_size */,
+                        void *              /* param_value */,
+                        size_t *            /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+                                
+/* Flush and Finish APIs */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clFlush(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clFinish(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
+
+/* Enqueued Commands APIs */
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueReadBuffer(cl_command_queue    /* command_queue */,
+                    cl_mem              /* buffer */,
+                    cl_bool             /* blocking_read */,
+                    size_t              /* offset */,
+                    size_t              /* cb */, 
+                    void *              /* ptr */,
+                    cl_uint             /* num_events_in_wait_list */,
+                    const cl_event *    /* event_wait_list */,
+                    cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_0;
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueReadBufferRect(cl_command_queue    /* command_queue */,
+                        cl_mem              /* buffer */,
+                        cl_bool             /* blocking_read */,
+                        const size_t *      /* buffer_offset */,
+                        const size_t *      /* host_offset */, 
+                        const size_t *      /* region */,
+                        size_t              /* buffer_row_pitch */,
+                        size_t              /* buffer_slice_pitch */,
+                        size_t              /* host_row_pitch */,
+                        size_t              /* host_slice_pitch */,                        
+                        void *              /* ptr */,
+                        cl_uint             /* num_events_in_wait_list */,
+                        const cl_event *    /* event_wait_list */,
+                        cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_1;
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueWriteBuffer(cl_command_queue   /* command_queue */, 
+                     cl_mem             /* buffer */, 
+                     cl_bool            /* blocking_write */, 
+                     size_t             /* offset */, 
+                     size_t             /* cb */, 
+                     const void *       /* ptr */, 
+                     cl_uint            /* num_events_in_wait_list */, 
+                     const cl_event *   /* event_wait_list */, 
+                     cl_event *         /* event */) CL_API_SUFFIX__VERSION_1_0;
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueWriteBufferRect(cl_command_queue    /* command_queue */,
+                         cl_mem              /* buffer */,
+                         cl_bool             /* blocking_read */,
+                         const size_t *      /* buffer_offset */,
+                         const size_t *      /* host_offset */, 
+                         const size_t *      /* region */,
+                         size_t              /* buffer_row_pitch */,
+                         size_t              /* buffer_slice_pitch */,
+                         size_t              /* host_row_pitch */,
+                         size_t              /* host_slice_pitch */,                        
+                         const void *        /* ptr */,
+                         cl_uint             /* num_events_in_wait_list */,
+                         const cl_event *    /* event_wait_list */,
+                         cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_1;
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueCopyBuffer(cl_command_queue    /* command_queue */, 
+                    cl_mem              /* src_buffer */,
+                    cl_mem              /* dst_buffer */, 
+                    size_t              /* src_offset */,
+                    size_t              /* dst_offset */,
+                    size_t              /* cb */, 
+                    cl_uint             /* num_events_in_wait_list */,
+                    const cl_event *    /* event_wait_list */,
+                    cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_0;
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueCopyBufferRect(cl_command_queue    /* command_queue */, 
+                        cl_mem              /* src_buffer */,
+                        cl_mem              /* dst_buffer */, 
+                        const size_t *      /* src_origin */,
+                        const size_t *      /* dst_origin */,
+                        const size_t *      /* region */, 
+                        size_t              /* src_row_pitch */,
+                        size_t              /* src_slice_pitch */,
+                        size_t              /* dst_row_pitch */,
+                        size_t              /* dst_slice_pitch */,
+                        cl_uint             /* num_events_in_wait_list */,
+                        const cl_event *    /* event_wait_list */,
+                        cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_1;
+                            
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueReadImage(cl_command_queue     /* command_queue */,
+                   cl_mem               /* image */,
+                   cl_bool              /* blocking_read */, 
+                   const size_t *       /* origin[3] */,
+                   const size_t *       /* region[3] */,
+                   size_t               /* row_pitch */,
+                   size_t               /* slice_pitch */, 
+                   void *               /* ptr */,
+                   cl_uint              /* num_events_in_wait_list */,
+                   const cl_event *     /* event_wait_list */,
+                   cl_event *           /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueWriteImage(cl_command_queue    /* command_queue */,
+                    cl_mem              /* image */,
+                    cl_bool             /* blocking_write */, 
+                    const size_t *      /* origin[3] */,
+                    const size_t *      /* region[3] */,
+                    size_t              /* input_row_pitch */,
+                    size_t              /* input_slice_pitch */, 
+                    const void *        /* ptr */,
+                    cl_uint             /* num_events_in_wait_list */,
+                    const cl_event *    /* event_wait_list */,
+                    cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueCopyImage(cl_command_queue     /* command_queue */,
+                   cl_mem               /* src_image */,
+                   cl_mem               /* dst_image */, 
+                   const size_t *       /* src_origin[3] */,
+                   const size_t *       /* dst_origin[3] */,
+                   const size_t *       /* region[3] */, 
+                   cl_uint              /* num_events_in_wait_list */,
+                   const cl_event *     /* event_wait_list */,
+                   cl_event *           /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueCopyImageToBuffer(cl_command_queue /* command_queue */,
+                           cl_mem           /* src_image */,
+                           cl_mem           /* dst_buffer */, 
+                           const size_t *   /* src_origin[3] */,
+                           const size_t *   /* region[3] */, 
+                           size_t           /* dst_offset */,
+                           cl_uint          /* num_events_in_wait_list */,
+                           const cl_event * /* event_wait_list */,
+                           cl_event *       /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueCopyBufferToImage(cl_command_queue /* command_queue */,
+                           cl_mem           /* src_buffer */,
+                           cl_mem           /* dst_image */, 
+                           size_t           /* src_offset */,
+                           const size_t *   /* dst_origin[3] */,
+                           const size_t *   /* region[3] */, 
+                           cl_uint          /* num_events_in_wait_list */,
+                           const cl_event * /* event_wait_list */,
+                           cl_event *       /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY void * CL_API_CALL
+clEnqueueMapBuffer(cl_command_queue /* command_queue */,
+                   cl_mem           /* buffer */,
+                   cl_bool          /* blocking_map */, 
+                   cl_map_flags     /* map_flags */,
+                   size_t           /* offset */,
+                   size_t           /* cb */,
+                   cl_uint          /* num_events_in_wait_list */,
+                   const cl_event * /* event_wait_list */,
+                   cl_event *       /* event */,
+                   cl_int *         /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY void * CL_API_CALL
+clEnqueueMapImage(cl_command_queue  /* command_queue */,
+                  cl_mem            /* image */, 
+                  cl_bool           /* blocking_map */, 
+                  cl_map_flags      /* map_flags */, 
+                  const size_t *    /* origin[3] */,
+                  const size_t *    /* region[3] */,
+                  size_t *          /* image_row_pitch */,
+                  size_t *          /* image_slice_pitch */,
+                  cl_uint           /* num_events_in_wait_list */,
+                  const cl_event *  /* event_wait_list */,
+                  cl_event *        /* event */,
+                  cl_int *          /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueUnmapMemObject(cl_command_queue /* command_queue */,
+                        cl_mem           /* memobj */,
+                        void *           /* mapped_ptr */,
+                        cl_uint          /* num_events_in_wait_list */,
+                        const cl_event *  /* event_wait_list */,
+                        cl_event *        /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueNDRangeKernel(cl_command_queue /* command_queue */,
+                       cl_kernel        /* kernel */,
+                       cl_uint          /* work_dim */,
+                       const size_t *   /* global_work_offset */,
+                       const size_t *   /* global_work_size */,
+                       const size_t *   /* local_work_size */,
+                       cl_uint          /* num_events_in_wait_list */,
+                       const cl_event * /* event_wait_list */,
+                       cl_event *       /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueTask(cl_command_queue  /* command_queue */,
+              cl_kernel         /* kernel */,
+              cl_uint           /* num_events_in_wait_list */,
+              const cl_event *  /* event_wait_list */,
+              cl_event *        /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueNativeKernel(cl_command_queue  /* command_queue */,
+					  void (*user_func)(void *), 
+                      void *            /* args */,
+                      size_t            /* cb_args */, 
+                      cl_uint           /* num_mem_objects */,
+                      const cl_mem *    /* mem_list */,
+                      const void **     /* args_mem_loc */,
+                      cl_uint           /* num_events_in_wait_list */,
+                      const cl_event *  /* event_wait_list */,
+                      cl_event *        /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueMarker(cl_command_queue    /* command_queue */,
+                cl_event *          /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueWaitForEvents(cl_command_queue /* command_queue */,
+                       cl_uint          /* num_events */,
+                       const cl_event * /* event_list */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueBarrier(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
+
+/* Extension function access
+ *
+ * Returns the extension function address for the given function name,
+ * or NULL if a valid function can not be found.  The client must
+ * check to make sure the address is not NULL, before using or 
+ * calling the returned function address.
+ */
+extern CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(const char * /* func_name */) CL_API_SUFFIX__VERSION_1_0;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __OPENCL_CL_H */
+

mtapi_opencl_c/src/CL/cl_ext.h

+/*******************************************************************************
+ * Copyright (c) 2008-2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
+
+/* $Revision: 11687 $ on $Date: 2010-06-12 03:47:22 +0530 (Sat, 12 Jun 2010) $ */
+
+/* cl_ext.h contains OpenCL extensions which don't have external */
+/* (OpenGL, D3D) dependencies.                                   */
+
+#ifndef __CL_EXT_H
+#define __CL_EXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __APPLE__
+	#include <OpenCL/cl.h>
+    #include <AvailabilityMacros.h>
+#else
+	#include <CL/cl.h>
+#endif
+
+/* cl_khr_fp64 extension - no extension #define since it has no functions  */
+#define CL_DEVICE_DOUBLE_FP_CONFIG                  0x1032
+
+/* cl_khr_fp16 extension - no extension #define since it has no functions  */
+#define CL_DEVICE_HALF_FP_CONFIG                    0x1033
+
+/* Memory object destruction
+ *
+ * Apple extension for use to manage externally allocated buffers used with cl_mem objects with CL_MEM_USE_HOST_PTR
+ *
+ * Registers a user callback function that will be called when the memory object is deleted and its resources 
+ * freed. Each call to clSetMemObjectCallbackFn registers the specified user callback function on a callback 
+ * stack associated with memobj. The registered user callback functions are called in the reverse order in 
+ * which they were registered. The user callback functions are called and then the memory object is deleted 
+ * and its resources freed. This provides a mechanism for the application (and libraries) using memobj to be 
+ * notified when the memory referenced by host_ptr, specified when the memory object is created and used as 
+ * the storage bits for the memory object, can be reused or freed.
+ *
+ * The application may not call CL api's with the cl_mem object passed to the pfn_notify.
+ *
+ * Please check for the "cl_APPLE_SetMemObjectDestructor" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS)
+ * before using.
+ */
+#define cl_APPLE_SetMemObjectDestructor 1
+cl_int	CL_API_ENTRY clSetMemObjectDestructorAPPLE(  cl_mem /* memobj */, 
+                                        void (* /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/), 
+                                        void * /*user_data */ )             CL_EXT_SUFFIX__VERSION_1_0;  
+
+
+/* Context Logging Functions
+ *
+ * The next three convenience functions are intended to be used as the pfn_notify parameter to clCreateContext().
+ * Please check for the "cl_APPLE_ContextLoggingFunctions" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS)
+ * before using.
+ *
+ * clLogMessagesToSystemLog fowards on all log messages to the Apple System Logger 
+ */
+#define cl_APPLE_ContextLoggingFunctions 1
+extern void CL_API_ENTRY clLogMessagesToSystemLogAPPLE(  const char * /* errstr */, 
+                                            const void * /* private_info */, 
+                                            size_t       /* cb */, 
+                                            void *       /* user_data */ )  CL_EXT_SUFFIX__VERSION_1_0;
+
+/* clLogMessagesToStdout sends all log messages to the file descriptor stdout */
+extern void CL_API_ENTRY clLogMessagesToStdoutAPPLE(   const char * /* errstr */, 
+                                          const void * /* private_info */, 
+                                          size_t       /* cb */, 
+                                          void *       /* user_data */ )    CL_EXT_SUFFIX__VERSION_1_0;
+
+/* clLogMessagesToStderr sends all log messages to the file descriptor stderr */
+extern void CL_API_ENTRY clLogMessagesToStderrAPPLE(   const char * /* errstr */, 
+                                          const void * /* private_info */, 
+                                          size_t       /* cb */, 
+                                          void *       /* user_data */ )    CL_EXT_SUFFIX__VERSION_1_0;
+
+
+/************************ 
+* cl_khr_icd extension *                                                  
+************************/
+#define cl_khr_icd 1
+
+/* cl_platform_info                                                        */
+#define CL_PLATFORM_ICD_SUFFIX_KHR                  0x0920
+
+/* Additional Error Codes                                                  */
+#define CL_PLATFORM_NOT_FOUND_KHR                   -1001
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clIcdGetPlatformIDsKHR(cl_uint          /* num_entries */,
+                       cl_platform_id * /* platforms */,
+                       cl_uint *        /* num_platforms */);
+
+typedef CL_API_ENTRY cl_int (CL_API_CALL *clIcdGetPlatformIDsKHR_fn)(
+    cl_uint          /* num_entries */,
+    cl_platform_id * /* platforms */,
+    cl_uint *        /* num_platforms */);
+
+
+/******************************************
+* cl_nv_device_attribute_query extension *
+******************************************/
+/* cl_nv_device_attribute_query extension - no extension #define since it has no functions */
+#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV       0x4000
+#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV       0x4001
+#define CL_DEVICE_REGISTERS_PER_BLOCK_NV            0x4002
+#define CL_DEVICE_WARP_SIZE_NV                      0x4003
+#define CL_DEVICE_GPU_OVERLAP_NV                    0x4004
+#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV            0x4005
+#define CL_DEVICE_INTEGRATED_MEMORY_NV              0x4006
+
+
+/*********************************
+* cl_amd_device_attribute_query *
+*********************************/
+#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD        0x4036
+
+
+#ifdef CL_VERSION_1_1
+   /***********************************
+    * cl_ext_device_fission extension *
+    ***********************************/
+    #define cl_ext_device_fission   1
+    
+    extern CL_API_ENTRY cl_int CL_API_CALL
+    clReleaseDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; 
+    
+    typedef CL_API_ENTRY cl_int 
+    (CL_API_CALL *clReleaseDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
+
+    extern CL_API_ENTRY cl_int CL_API_CALL
+    clRetainDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; 
+    
+    typedef CL_API_ENTRY cl_int 
+    (CL_API_CALL *clRetainDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
+
+    typedef cl_ulong  cl_device_partition_property_ext;
+    extern CL_API_ENTRY cl_int CL_API_CALL
+    clCreateSubDevicesEXT(  cl_device_id /*in_device*/,
+                            const cl_device_partition_property_ext * /* properties */,
+                            cl_uint /*num_entries*/,
+                            cl_device_id * /*out_devices*/,
+                            cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
+
+    extern CL_API_ENTRY cl_int 
+    ( CL_API_CALL * clCreateSubDevicesEXT_fn)(  cl_device_id /*in_device*/,
+                                                const cl_device_partition_property_ext * /* properties */,
+                                                cl_uint /*num_entries*/,
+                                                cl_device_id * /*out_devices*/,
+                                                cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
+
+    /* cl_device_partition_property_ext */
+    #define CL_DEVICE_PARTITION_EQUALLY_EXT             0x4050
+    #define CL_DEVICE_PARTITION_BY_COUNTS_EXT           0x4051
+    #define CL_DEVICE_PARTITION_BY_NAMES_EXT            0x4052
+    #define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT  0x4053
+    
+    /* clDeviceGetInfo selectors */
+    #define CL_DEVICE_PARENT_DEVICE_EXT                 0x4054
+    #define CL_DEVICE_PARTITION_TYPES_EXT               0x4055
+    #define CL_DEVICE_AFFINITY_DOMAINS_EXT              0x4056
+    #define CL_DEVICE_REFERENCE_COUNT_EXT               0x4057
+    #define CL_DEVICE_PARTITION_STYLE_EXT               0x4058
+    
+    /* error codes */
+    #define CL_DEVICE_PARTITION_FAILED_EXT              -1057
+    #define CL_INVALID_PARTITION_COUNT_EXT              -1058
+    #define CL_INVALID_PARTITION_NAME_EXT               -1059
+    
+    /* CL_AFFINITY_DOMAINs */
+    #define CL_AFFINITY_DOMAIN_L1_CACHE_EXT             0x1
+    #define CL_AFFINITY_DOMAIN_L2_CACHE_EXT             0x2
+    #define CL_AFFINITY_DOMAIN_L3_CACHE_EXT             0x3
+    #define CL_AFFINITY_DOMAIN_L4_CACHE_EXT             0x4
+    #define CL_AFFINITY_DOMAIN_NUMA_EXT                 0x10
+    #define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT     0x100
+    
+    /* cl_device_partition_property_ext list terminators */
+    #define CL_PROPERTIES_LIST_END_EXT                  ((cl_device_partition_property_ext) 0)
+    #define CL_PARTITION_BY_COUNTS_LIST_END_EXT         ((cl_device_partition_property_ext) 0)
+    #define CL_PARTITION_BY_NAMES_LIST_END_EXT          ((cl_device_partition_property_ext) 0 - 1)
+
+
+
+#endif /* CL_VERSION_1_1 */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __CL_EXT_H */

mtapi_opencl_c/src/CL/cl_gl.h

+/**********************************************************************************
+ * Copyright (c) 2008-2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ **********************************************************************************/
+
+/* $Revision: 11708 $ on $Date: 2010-06-14 12:06:24 +0530 (Mon, 14 Jun 2010) $ */
+
+/*
+ * cl_gl.h contains Khronos-approved (KHR) OpenCL extensions which have
+ * OpenGL dependencies. The application is responsible for #including
+ * OpenGL or OpenGL ES headers before #including cl_gl.h.
+ */
+
+#ifndef __OPENCL_CL_GL_H
+#define __OPENCL_CL_GL_H
+
+#ifdef __APPLE__
+#include <OpenCL/cl.h>
+#include <OpenGL/CGLDevice.h>
+#else
+#include <CL/cl.h>
+#endif	
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef cl_uint     cl_gl_object_type;
+typedef cl_uint     cl_gl_texture_info;
+typedef cl_uint     cl_gl_platform_info;
+typedef struct __GLsync *cl_GLsync;
+
+/* cl_gl_object_type */
+#define CL_GL_OBJECT_BUFFER             0x2000
+#define CL_GL_OBJECT_TEXTURE2D          0x2001
+#define CL_GL_OBJECT_TEXTURE3D          0x2002
+#define CL_GL_OBJECT_RENDERBUFFER       0x2003
+
+/* cl_gl_texture_info */
+#define CL_GL_TEXTURE_TARGET            0x2004
+#define CL_GL_MIPMAP_LEVEL              0x2005
+
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateFromGLBuffer(cl_context     /* context */,
+                     cl_mem_flags   /* flags */,
+                     cl_GLuint      /* bufobj */,
+                     int *          /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateFromGLTexture2D(cl_context      /* context */,
+                        cl_mem_flags    /* flags */,
+                        cl_GLenum       /* target */,
+                        cl_GLint        /* miplevel */,
+                        cl_GLuint       /* texture */,
+                        cl_int *        /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateFromGLTexture3D(cl_context      /* context */,
+                        cl_mem_flags    /* flags */,
+                        cl_GLenum       /* target */,
+                        cl_GLint        /* miplevel */,
+                        cl_GLuint       /* texture */,
+                        cl_int *        /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_mem CL_API_CALL
+clCreateFromGLRenderbuffer(cl_context   /* context */,
+                           cl_mem_flags /* flags */,
+                           cl_GLuint    /* renderbuffer */,
+                           cl_int *     /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetGLObjectInfo(cl_mem                /* memobj */,
+                  cl_gl_object_type *   /* gl_object_type */,
+                  cl_GLuint *              /* gl_object_name */) CL_API_SUFFIX__VERSION_1_0;
+                  
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetGLTextureInfo(cl_mem               /* memobj */,
+                   cl_gl_texture_info   /* param_name */,
+                   size_t               /* param_value_size */,
+                   void *               /* param_value */,
+                   size_t *             /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueAcquireGLObjects(cl_command_queue      /* command_queue */,
+                          cl_uint               /* num_objects */,
+                          const cl_mem *        /* mem_objects */,
+                          cl_uint               /* num_events_in_wait_list */,
+                          const cl_event *      /* event_wait_list */,
+                          cl_event *            /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueReleaseGLObjects(cl_command_queue      /* command_queue */,
+                          cl_uint               /* num_objects */,
+                          const cl_mem *        /* mem_objects */,
+                          cl_uint               /* num_events_in_wait_list */,
+                          const cl_event *      /* event_wait_list */,
+                          cl_event *            /* event */) CL_API_SUFFIX__VERSION_1_0;
+
+/* cl_khr_gl_sharing extension  */
+
+#define cl_khr_gl_sharing 1
+
+typedef cl_uint     cl_gl_context_info;
+
+/* Additional Error Codes  */
+#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR  -1000
+
+/* cl_gl_context_info  */
+#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR    0x2006
+#define CL_DEVICES_FOR_GL_CONTEXT_KHR           0x2007
+
+/* Additional cl_context_properties  */
+#define CL_GL_CONTEXT_KHR                       0x2008
+#define CL_EGL_DISPLAY_KHR                      0x2009
+#define CL_GLX_DISPLAY_KHR                      0x200A
+#define CL_WGL_HDC_KHR                          0x200B
+#define CL_CGL_SHAREGROUP_KHR                   0x200C
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetGLContextInfoKHR(const cl_context_properties * /* properties */,
+                      cl_gl_context_info            /* param_name */,
+                      size_t                        /* param_value_size */,
+                      void *                        /* param_value */,
+                      size_t *                      /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
+
+typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetGLContextInfoKHR_fn)(
+    const cl_context_properties * properties,
+    cl_gl_context_info            param_name,
+    size_t                        param_value_size,
+    void *                        param_value,
+    size_t *                      param_value_size_ret);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __OPENCL_CL_GL_H  */

mtapi_opencl_c/src/CL/cl_gl_ext.h

+/**********************************************************************************
+ * Copyright (c) 2008-2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ **********************************************************************************/
+
+/* $Revision: 11708 $ on $Date: 2010-06-14 12:06:24 +0530 (Mon, 14 Jun 2010) $ */
+
+/* cl_gl_ext.h contains vendor (non-KHR) OpenCL extensions which have           */
+/* OpenGL dependencies.                                                         */
+
+#ifndef __OPENCL_CL_GL_EXT_H
+#define __OPENCL_CL_GL_EXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __APPLE__
+    #include <OpenCL/cl_gl.h>
+#else
+    #include <CL/cl_gl.h>
+#endif
+
+/*
+ * For each extension, follow this template
+ * /* cl_VEN_extname extension  */
+/* #define cl_VEN_extname 1
+ * ... define new types, if any
+ * ... define new tokens, if any
+ * ... define new APIs, if any
+ *
+ *  If you need GLtypes here, mirror them with a cl_GLtype, rather than including a GL header
+ *  This allows us to avoid having to decide whether to include GL headers or GLES here.
+ */
+
+/* 
+ *  cl_khr_gl_event  extension
+ *  See section 9.9 in the OpenCL 1.1 spec for more information
+ */
+#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR     0x200D
+
+extern CL_API_ENTRY cl_event CL_API_CALL
+clCreateEventFromGLsyncKHR(cl_context           /* context */,
+                           cl_GLsync            /* cl_GLsync */,
+                           cl_int *             /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __OPENCL_CL_GL_EXT_H  */

mtapi_opencl_c/src/CL/cl_platform.h

+/**********************************************************************************
+ * Copyright (c) 2008-2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ **********************************************************************************/
+
+/* $Revision: 11803 $ on $Date: 2010-06-25 22:32:12 +0530 (Fri, 25 Jun 2010) $ */
+
+#ifndef __CL_PLATFORM_H
+#define __CL_PLATFORM_H
+
+#ifdef __APPLE__
+    /* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */
+    #include <AvailabilityMacros.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32)
+#define CL_API_ENTRY
+#define CL_API_CALL         __stdcall
+#define CL_CALLBACK         __stdcall
+#else
+#define CL_API_ENTRY
+#define CL_API_CALL
+#define CL_CALLBACK  
+#endif
+
+#ifdef __APPLE__
+    #define CL_EXTENSION_WEAK_LINK                  __attribute__((weak_import))       
+    #define CL_API_SUFFIX__VERSION_1_0              AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER
+    #define CL_EXT_SUFFIX__VERSION_1_0              CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER
+    #define CL_API_SUFFIX__VERSION_1_1              CL_EXTENSION_WEAK_LINK
+    #define CL_EXT_SUFFIX__VERSION_1_1              CL_EXTENSION_WEAK_LINK
+    #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED   CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER
+#else
+    #define CL_EXTENSION_WEAK_LINK                         
+    #define CL_API_SUFFIX__VERSION_1_0
+    #define CL_EXT_SUFFIX__VERSION_1_0
+    #define CL_API_SUFFIX__VERSION_1_1
+    #define CL_EXT_SUFFIX__VERSION_1_1
+    #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
+#endif
+
+#if (defined (_WIN32) && defined(_MSC_VER))
+
+/* scalar types  */
+typedef signed   __int8         cl_char;
+typedef unsigned __int8         cl_uchar;
+typedef signed   __int16        cl_short;
+typedef unsigned __int16        cl_ushort;
+typedef signed   __int32        cl_int;
+typedef unsigned __int32        cl_uint;
+typedef signed   __int64        cl_long;
+typedef unsigned __int64        cl_ulong;
+
+typedef unsigned __int16        cl_half;
+typedef float                   cl_float;
+typedef double                  cl_double;
+
+/* Macro names and corresponding values defined by OpenCL */
+#define CL_CHAR_BIT         8
+#define CL_SCHAR_MAX        127
+#define CL_SCHAR_MIN        (-127-1)
+#define CL_CHAR_MAX         CL_SCHAR_MAX
+#define CL_CHAR_MIN         CL_SCHAR_MIN
+#define CL_UCHAR_MAX        255
+#define CL_SHRT_MAX         32767
+#define CL_SHRT_MIN         (-32767-1)
+#define CL_USHRT_MAX        65535
+#define CL_INT_MAX          2147483647
+#define CL_INT_MIN          (-2147483647-1)
+#define CL_UINT_MAX         0xffffffffU
+#define CL_LONG_MAX         ((cl_long) 0x7FFFFFFFFFFFFFFFLL)
+#define CL_LONG_MIN         ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL)
+#define CL_ULONG_MAX        ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL)
+
+#define CL_FLT_DIG          6
+#define CL_FLT_MANT_DIG     24
+#define CL_FLT_MAX_10_EXP   +38
+#define CL_FLT_MAX_EXP      +128
+#define CL_FLT_MIN_10_EXP   -37
+#define CL_FLT_MIN_EXP      -125
+#define CL_FLT_RADIX        2
+#define CL_FLT_MAX          340282346638528859811704183484516925440.0f
+#define CL_FLT_MIN          1.175494350822287507969e-38f
+#define CL_FLT_EPSILON      0x1.0p-23f
+
+#define CL_DBL_DIG          15
+#define CL_DBL_MANT_DIG     53
+#define CL_DBL_MAX_10_EXP   +308
+#define CL_DBL_MAX_EXP      +1024
+#define CL_DBL_MIN_10_EXP   -307
+#define CL_DBL_MIN_EXP      -1021
+#define CL_DBL_RADIX        2
+#define CL_DBL_MAX          179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0
+#define CL_DBL_MIN          2.225073858507201383090e-308
+#define CL_DBL_EPSILON      2.220446049250313080847e-16
+
+#define  CL_M_E             2.718281828459045090796
+#define  CL_M_LOG2E         1.442695040888963387005
+#define  CL_M_LOG10E        0.434294481903251816668
+#define  CL_M_LN2           0.693147180559945286227
+#define  CL_M_LN10          2.302585092994045901094
+#define  CL_M_PI            3.141592653589793115998
+#define  CL_M_PI_2          1.570796326794896557999
+#define  CL_M_PI_4          0.785398163397448278999
+#define  CL_M_1_PI          0.318309886183790691216
+#define  CL_M_2_PI          0.636619772367581382433
+#define  CL_M_2_SQRTPI      1.128379167095512558561
+#define  CL_M_SQRT2         1.414213562373095145475
+#define  CL_M_SQRT1_2       0.707106781186547572737
+
+#define  CL_M_E_F           2.71828174591064f
+#define  CL_M_LOG2E_F       1.44269502162933f
+#define  CL_M_LOG10E_F      0.43429449200630f
+#define  CL_M_LN2_F         0.69314718246460f
+#define  CL_M_LN10_F        2.30258512496948f
+#define  CL_M_PI_F          3.14159274101257f
+#define  CL_M_PI_2_F        1.57079637050629f
+#define  CL_M_PI_4_F        0.78539818525314f
+#define  CL_M_1_PI_F        0.31830987334251f
+#define  CL_M_2_PI_F        0.63661974668503f
+#define  CL_M_2_SQRTPI_F    1.12837922573090f
+#define  CL_M_SQRT2_F       1.41421353816986f
+#define  CL_M_SQRT1_2_F     0.70710676908493f
+
+#define CL_NAN              (CL_INFINITY - CL_INFINITY)
+#define CL_HUGE_VALF        ((cl_float) 1e50)
+#define CL_HUGE_VAL         ((cl_double) 1e500)
+#define CL_MAXFLOAT         CL_FLT_MAX
+#define CL_INFINITY         CL_HUGE_VALF
+
+#else
+
+#include <stdint.h>
+
+/* scalar types  */
+typedef int8_t          cl_char;
+typedef uint8_t         cl_uchar;
+typedef int16_t         cl_short    __attribute__((aligned(2)));
+typedef uint16_t        cl_ushort   __attribute__((aligned(2)));
+typedef int32_t         cl_int      __attribute__((aligned(4)));
+typedef uint32_t        cl_uint     __attribute__((aligned(4)));
+typedef int64_t         cl_long     __attribute__((aligned(8)));
+typedef uint64_t        cl_ulong    __attribute__((aligned(8)));
+
+typedef uint16_t        cl_half     __attribute__((aligned(2)));
+typedef float           cl_float    __attribute__((aligned(4)));
+typedef double          cl_double   __attribute__((aligned(8)));
+
+/* Macro names and corresponding values defined by OpenCL */
+#define CL_CHAR_BIT         8
+#define CL_SCHAR_MAX        127
+#define CL_SCHAR_MIN        (-127-1)
+#define CL_CHAR_MAX         CL_SCHAR_MAX
+#define CL_CHAR_MIN         CL_SCHAR_MIN
+#define CL_UCHAR_MAX        255
+#define CL_SHRT_MAX         32767
+#define CL_SHRT_MIN         (-32767-1)
+#define CL_USHRT_MAX        65535
+#define CL_INT_MAX          2147483647
+#define CL_INT_MIN          (-2147483647-1)
+#define CL_UINT_MAX         0xffffffffU
+#define CL_LONG_MAX         ((cl_long) 0x7FFFFFFFFFFFFFFFLL)
+#define CL_LONG_MIN         ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL)
+#define CL_ULONG_MAX        ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL)
+
+#define CL_FLT_DIG          6
+#define CL_FLT_MANT_DIG     24
+#define CL_FLT_MAX_10_EXP   +38
+#define CL_FLT_MAX_EXP      +128
+#define CL_FLT_MIN_10_EXP   -37
+#define CL_FLT_MIN_EXP      -125
+#define CL_FLT_RADIX        2
+#define CL_FLT_MAX          0x1.fffffep127f
+#define CL_FLT_MIN          0x1.0p-126f
+#define CL_FLT_EPSILON      0x1.0p-23f
+
+#define CL_DBL_DIG          15
+#define CL_DBL_MANT_DIG     53
+#define CL_DBL_MAX_10_EXP   +308
+#define CL_DBL_MAX_EXP      +1024
+#define CL_DBL_MIN_10_EXP   -307
+#define CL_DBL_MIN_EXP      -1021
+#define CL_DBL_RADIX        2
+#define CL_DBL_MAX          0x1.fffffffffffffp1023
+#define CL_DBL_MIN          0x1.0p-1022
+#define CL_DBL_EPSILON      0x1.0p-52
+
+#define  CL_M_E             2.718281828459045090796
+#define  CL_M_LOG2E         1.442695040888963387005
+#define  CL_M_LOG10E        0.434294481903251816668
+#define  CL_M_LN2           0.693147180559945286227
+#define  CL_M_LN10          2.302585092994045901094
+#define  CL_M_PI            3.141592653589793115998
+#define  CL_M_PI_2          1.570796326794896557999
+#define  CL_M_PI_4          0.785398163397448278999
+#define  CL_M_1_PI          0.318309886183790691216
+#define  CL_M_2_PI          0.636619772367581382433
+#define  CL_M_2_SQRTPI      1.128379167095512558561
+#define  CL_M_SQRT2         1.414213562373095145475
+#define  CL_M_SQRT1_2       0.707106781186547572737
+
+#define  CL_M_E_F           2.71828174591064f
+#define  CL_M_LOG2E_F       1.44269502162933f
+#define  CL_M_LOG10E_F      0.43429449200630f
+#define  CL_M_LN2_F         0.69314718246460f
+#define  CL_M_LN10_F        2.30258512496948f
+#define  CL_M_PI_F          3.14159274101257f
+#define  CL_M_PI_2_F        1.57079637050629f
+#define  CL_M_PI_4_F        0.78539818525314f
+#define  CL_M_1_PI_F        0.31830987334251f
+#define  CL_M_2_PI_F        0.63661974668503f
+#define  CL_M_2_SQRTPI_F    1.12837922573090f
+#define  CL_M_SQRT2_F       1.41421353816986f
+#define  CL_M_SQRT1_2_F     0.70710676908493f
+
+#if defined( __GNUC__ )
+   #define CL_HUGE_VALF     __builtin_huge_valf()
+   #define CL_HUGE_VAL      __builtin_huge_val()
+   #define CL_NAN           __builtin_nanf( "" )
+#else
+   #define CL_HUGE_VALF     ((cl_float) 1e50)
+   #define CL_HUGE_VAL      ((cl_double) 1e500)
+   float nanf( const char * );
+   #define CL_NAN           nanf( "" )  
+#endif
+#define CL_MAXFLOAT         CL_FLT_MAX
+#define CL_INFINITY         CL_HUGE_VALF
+       
+#endif
+
+#include <stddef.h>
+
+/* Mirror types to GL types. Mirror types allow us to avoid deciding which headers to load based on whether we are using GL or GLES here. */
+typedef unsigned int cl_GLuint;
+typedef int          cl_GLint;
+typedef unsigned int cl_GLenum;
+
+/*
+ * Vector types 
+ *
+ *  Note:   OpenCL requires that all types be naturally aligned. 
+ *          This means that vector types must be naturally aligned.
+ *          For example, a vector of four floats must be aligned to
+ *          a 16 byte boundary (calculated as 4 * the natural 4-byte 
+ *          alignment of the float).  The alignment qualifiers here
+ *          will only function properly if your compiler supports them
+ *          and if you don't actively work to defeat them.  For example,
+ *          in order for a cl_float4 to be 16 byte aligned in a struct,
+ *          the start of the struct must itself be 16-byte aligned. 
+ *
+ *          Maintaining proper alignment is the user's responsibility.
+ */
+
+/* Define basic vector types */
+#if defined( __VEC__ )
+   #include <altivec.h>   /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */
+   typedef vector unsigned char     __cl_uchar16;
+   typedef vector signed char       __cl_char16;
+   typedef vector unsigned short    __cl_ushort8;
+   typedef vector signed short      __cl_short8;
+   typedef vector unsigned int      __cl_uint4;
+   typedef vector signed int        __cl_int4;
+   typedef vector float             __cl_float4;
+   #define  __CL_UCHAR16__  1
+   #define  __CL_CHAR16__   1
+   #define  __CL_USHORT8__  1
+   #define  __CL_SHORT8__   1
+   #define  __CL_UINT4__    1
+   #define  __CL_INT4__     1
+   #define  __CL_FLOAT4__   1
+#endif
+
+#if defined( __SSE__ )
+    #if defined( __MINGW64__ )
+        #include <intrin.h>
+    #else
+        #include <xmmintrin.h>
+    #endif
+    #if defined( __GNUC__ )
+        typedef float __cl_float4   __attribute__((vector_size(16)));
+    #else
+        typedef __m128 __cl_float4;
+    #endif
+    #define __CL_FLOAT4__   1
+#endif
+
+#if defined( __SSE2__ )
+    #if defined( __MINGW64__ )
+        #include <intrin.h>
+    #else
+        #include <emmintrin.h>
+    #endif
+    #if defined( __GNUC__ )
+        typedef cl_uchar    __cl_uchar16    __attribute__((vector_size(16)));
+        typedef cl_char     __cl_char16     __attribute__((vector_size(16)));
+        typedef cl_ushort   __cl_ushort8    __attribute__((vector_size(16)));
+        typedef cl_short    __cl_short8     __attribute__((vector_size(16)));
+        typedef cl_uint     __cl_uint4      __attribute__((vector_size(16)));
+        typedef cl_int      __cl_int4       __attribute__((vector_size(16)));
+        typedef cl_ulong    __cl_ulong2     __attribute__((vector_size(16)));
+        typedef cl_long     __cl_long2      __attribute__((vector_size(16)));
+        typedef cl_double   __cl_double2    __attribute__((vector_size(16)));
+    #else
+        typedef __m128i __cl_uchar16;
+        typedef __m128i __cl_char16;
+        typedef __m128i __cl_ushort8;
+        typedef __m128i __cl_short8;
+        typedef __m128i __cl_uint4;
+        typedef __m128i __cl_int4;
+        typedef __m128i __cl_ulong2;
+        typedef __m128i __cl_long2;
+        typedef __m128d __cl_double2;
+    #endif
+    #define __CL_UCHAR16__  1
+    #define __CL_CHAR16__   1
+    #define __CL_USHORT8__  1
+    #define __CL_SHORT8__   1
+    #define __CL_INT4__     1
+    #define __CL_UINT4__    1
+    #define __CL_ULONG2__   1
+    #define __CL_LONG2__    1
+    #define __CL_DOUBLE2__  1
+#endif
+
+#if defined( __MMX__ )
+    #include <mmintrin.h>
+    #if defined( __GNUC__ )
+        typedef cl_uchar    __cl_uchar8     __attribute__((vector_size(8)));
+        typedef cl_char     __cl_char8      __attribute__((vector_size(8)));
+        typedef cl_ushort   __cl_ushort4    __attribute__((vector_size(8)));
+        typedef cl_short    __cl_short4     __attribute__((vector_size(8)));
+        typedef cl_uint     __cl_uint2      __attribute__((vector_size(8)));
+        typedef cl_int      __cl_int2       __attribute__((vector_size(8)));
+        typedef cl_ulong    __cl_ulong1     __attribute__((vector_size(8)));
+        typedef cl_long     __cl_long1      __attribute__((vector_size(8)));
+        typedef cl_float    __cl_float2     __attribute__((vector_size(8)));
+    #else
+        typedef __m64       __cl_uchar8;
+        typedef __m64       __cl_char8;
+        typedef __m64       __cl_ushort4;
+        typedef __m64       __cl_short4;
+        typedef __m64       __cl_uint2;
+        typedef __m64       __cl_int2;
+        typedef __m64       __cl_ulong1;
+        typedef __m64       __cl_long1;
+        typedef __m64       __cl_float2;
+    #endif
+    #define __CL_UCHAR8__   1
+    #define __CL_CHAR8__    1
+    #define __CL_USHORT4__  1
+    #define __CL_SHORT4__   1
+    #define __CL_INT2__     1
+    #define __CL_UINT2__    1
+    #define __CL_ULONG1__   1
+    #define __CL_LONG1__    1
+    #define __CL_FLOAT2__   1
+#endif
+
+#if defined( __AVX__ )
+    #if defined( __MINGW64__ )
+        #include <intrin.h>
+    #else
+        #include <immintrin.h> 
+    #endif
+    #if defined( __GNUC__ )
+        typedef cl_float    __cl_float8     __attribute__((vector_size(32)));
+        typedef cl_double   __cl_double4    __attribute__((vector_size(32)));
+    #else
+        typedef __m256      __cl_float8;
+        typedef __m256d     __cl_double4;
+    #endif
+    #define __CL_FLOAT8__   1
+    #define __CL_DOUBLE4__  1
+#endif
+
+/* Define alignment keys */
+#if defined( __GNUC__ )
+    #define CL_ALIGNED(_x)          __attribute__ ((aligned(_x)))
+#elif defined( _WIN32) && (_MSC_VER)
+    /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements     */
+    /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx                                                 */
+    /* #include <crtdefs.h>                                                                                             */
+    /* #define CL_ALIGNED(_x)          _CRT_ALIGN(_x)                                                                   */
+    #define CL_ALIGNED(_x)
+#else
+   #warning  Need to implement some method to align data here
+   #define  CL_ALIGNED(_x)
+#endif
+
+/* Indicate whether .xyzw, .s0123 and .hi.lo are supported */
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+    /* .xyzw and .s0123...{f|F} are supported */
+    #define CL_HAS_NAMED_VECTOR_FIELDS 1
+    /* .hi and .lo are supported */
+    #define CL_HAS_HI_LO_VECTOR_FIELDS 1
+#endif
+
+/* Define cl_vector types */
+
+/* ---- cl_charn ---- */
+typedef union
+{
+    cl_char  CL_ALIGNED(2) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_char  x, y; };
+   __extension__ struct{ cl_char  s0, s1; };
+   __extension__ struct{ cl_char  lo, hi; };
+#endif
+#if defined( __CL_CHAR2__) 
+    __cl_char2     v2;
+#endif
+}cl_char2;
+
+typedef union
+{
+    cl_char  CL_ALIGNED(4) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_char  x, y, z, w; };
+   __extension__ struct{ cl_char  s0, s1, s2, s3; };
+   __extension__ struct{ cl_char2 lo, hi; };
+#endif
+#if defined( __CL_CHAR2__) 
+    __cl_char2     v2[2];
+#endif
+#if defined( __CL_CHAR4__) 
+    __cl_char4     v4;
+#endif
+}cl_char4;
+
+/* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */
+typedef  cl_char4  cl_char3;
+
+typedef union
+{
+    cl_char   CL_ALIGNED(8) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_char  x, y, z, w; };
+   __extension__ struct{ cl_char  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_char4 lo, hi; };
+#endif
+#if defined( __CL_CHAR2__) 
+    __cl_char2     v2[4];
+#endif
+#if defined( __CL_CHAR4__) 
+    __cl_char4     v4[2];
+#endif
+#if defined( __CL_CHAR8__ )
+    __cl_char8     v8;
+#endif
+}cl_char8;
+
+typedef union
+{
+    cl_char  CL_ALIGNED(16) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_char  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_char  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_char8 lo, hi; };
+#endif
+#if defined( __CL_CHAR2__) 
+    __cl_char2     v2[8];
+#endif
+#if defined( __CL_CHAR4__) 
+    __cl_char4     v4[4];
+#endif
+#if defined( __CL_CHAR8__ )
+    __cl_char8     v8[2];
+#endif
+#if defined( __CL_CHAR16__ )
+    __cl_char16    v16;
+#endif
+}cl_char16;
+
+
+/* ---- cl_ucharn ---- */
+typedef union
+{
+    cl_uchar  CL_ALIGNED(2) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uchar  x, y; };
+   __extension__ struct{ cl_uchar  s0, s1; };
+   __extension__ struct{ cl_uchar  lo, hi; };
+#endif
+#if defined( __cl_uchar2__) 
+    __cl_uchar2     v2;
+#endif
+}cl_uchar2;
+
+typedef union
+{
+    cl_uchar  CL_ALIGNED(4) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uchar  x, y, z, w; };
+   __extension__ struct{ cl_uchar  s0, s1, s2, s3; };
+   __extension__ struct{ cl_uchar2 lo, hi; };
+#endif
+#if defined( __CL_UCHAR2__) 
+    __cl_uchar2     v2[2];
+#endif
+#if defined( __CL_UCHAR4__) 
+    __cl_uchar4     v4;
+#endif
+}cl_uchar4;
+
+/* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */
+typedef  cl_uchar4  cl_uchar3;
+
+typedef union
+{
+    cl_uchar   CL_ALIGNED(8) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uchar  x, y, z, w; };
+   __extension__ struct{ cl_uchar  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_uchar4 lo, hi; };
+#endif
+#if defined( __CL_UCHAR2__) 
+    __cl_uchar2     v2[4];
+#endif
+#if defined( __CL_UCHAR4__) 
+    __cl_uchar4     v4[2];
+#endif
+#if defined( __CL_UCHAR8__ )
+    __cl_uchar8     v8;
+#endif
+}cl_uchar8;
+
+typedef union
+{
+    cl_uchar  CL_ALIGNED(16) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uchar  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_uchar  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_uchar8 lo, hi; };
+#endif
+#if defined( __CL_UCHAR2__) 
+    __cl_uchar2     v2[8];
+#endif
+#if defined( __CL_UCHAR4__) 
+    __cl_uchar4     v4[4];
+#endif
+#if defined( __CL_UCHAR8__ )
+    __cl_uchar8     v8[2];
+#endif
+#if defined( __CL_UCHAR16__ )
+    __cl_uchar16    v16;
+#endif
+}cl_uchar16;
+
+
+/* ---- cl_shortn ---- */
+typedef union
+{
+    cl_short  CL_ALIGNED(4) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_short  x, y; };
+   __extension__ struct{ cl_short  s0, s1; };
+   __extension__ struct{ cl_short  lo, hi; };
+#endif
+#if defined( __CL_SHORT2__) 
+    __cl_short2     v2;
+#endif
+}cl_short2;
+
+typedef union
+{
+    cl_short  CL_ALIGNED(8) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_short  x, y, z, w; };
+   __extension__ struct{ cl_short  s0, s1, s2, s3; };
+   __extension__ struct{ cl_short2 lo, hi; };
+#endif
+#if defined( __CL_SHORT2__) 
+    __cl_short2     v2[2];
+#endif
+#if defined( __CL_SHORT4__) 
+    __cl_short4     v4;
+#endif
+}cl_short4;
+
+/* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */
+typedef  cl_short4  cl_short3;
+
+typedef union
+{
+    cl_short   CL_ALIGNED(16) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_short  x, y, z, w; };
+   __extension__ struct{ cl_short  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_short4 lo, hi; };
+#endif
+#if defined( __CL_SHORT2__) 
+    __cl_short2     v2[4];
+#endif
+#if defined( __CL_SHORT4__) 
+    __cl_short4     v4[2];
+#endif
+#if defined( __CL_SHORT8__ )
+    __cl_short8     v8;
+#endif
+}cl_short8;
+
+typedef union
+{
+    cl_short  CL_ALIGNED(32) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_short  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_short  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_short8 lo, hi; };
+#endif
+#if defined( __CL_SHORT2__) 
+    __cl_short2     v2[8];
+#endif
+#if defined( __CL_SHORT4__) 
+    __cl_short4     v4[4];
+#endif
+#if defined( __CL_SHORT8__ )
+    __cl_short8     v8[2];
+#endif
+#if defined( __CL_SHORT16__ )
+    __cl_short16    v16;
+#endif
+}cl_short16;
+
+
+/* ---- cl_ushortn ---- */
+typedef union
+{
+    cl_ushort  CL_ALIGNED(4) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ushort  x, y; };
+   __extension__ struct{ cl_ushort  s0, s1; };
+   __extension__ struct{ cl_ushort  lo, hi; };
+#endif
+#if defined( __CL_USHORT2__) 
+    __cl_ushort2     v2;
+#endif
+}cl_ushort2;
+
+typedef union
+{
+    cl_ushort  CL_ALIGNED(8) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ushort  x, y, z, w; };
+   __extension__ struct{ cl_ushort  s0, s1, s2, s3; };
+   __extension__ struct{ cl_ushort2 lo, hi; };
+#endif
+#if defined( __CL_USHORT2__) 
+    __cl_ushort2     v2[2];
+#endif
+#if defined( __CL_USHORT4__) 
+    __cl_ushort4     v4;
+#endif
+}cl_ushort4;
+
+/* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */
+typedef  cl_ushort4  cl_ushort3;
+
+typedef union
+{
+    cl_ushort   CL_ALIGNED(16) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ushort  x, y, z, w; };
+   __extension__ struct{ cl_ushort  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_ushort4 lo, hi; };
+#endif
+#if defined( __CL_USHORT2__) 
+    __cl_ushort2     v2[4];
+#endif
+#if defined( __CL_USHORT4__) 
+    __cl_ushort4     v4[2];
+#endif
+#if defined( __CL_USHORT8__ )
+    __cl_ushort8     v8;
+#endif
+}cl_ushort8;
+
+typedef union
+{
+    cl_ushort  CL_ALIGNED(32) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ushort  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_ushort  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_ushort8 lo, hi; };
+#endif
+#if defined( __CL_USHORT2__) 
+    __cl_ushort2     v2[8];
+#endif
+#if defined( __CL_USHORT4__) 
+    __cl_ushort4     v4[4];
+#endif
+#if defined( __CL_USHORT8__ )
+    __cl_ushort8     v8[2];
+#endif
+#if defined( __CL_USHORT16__ )
+    __cl_ushort16    v16;
+#endif
+}cl_ushort16;
+
+/* ---- cl_intn ---- */
+typedef union
+{
+    cl_int  CL_ALIGNED(8) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_int  x, y; };
+   __extension__ struct{ cl_int  s0, s1; };
+   __extension__ struct{ cl_int  lo, hi; };
+#endif
+#if defined( __CL_INT2__) 
+    __cl_int2     v2;
+#endif
+}cl_int2;
+
+typedef union
+{
+    cl_int  CL_ALIGNED(16) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_int  x, y, z, w; };
+   __extension__ struct{ cl_int  s0, s1, s2, s3; };
+   __extension__ struct{ cl_int2 lo, hi; };
+#endif
+#if defined( __CL_INT2__) 
+    __cl_int2     v2[2];
+#endif
+#if defined( __CL_INT4__) 
+    __cl_int4     v4;
+#endif
+}cl_int4;
+
+/* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */
+typedef  cl_int4  cl_int3;
+
+typedef union
+{
+    cl_int   CL_ALIGNED(32) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_int  x, y, z, w; };
+   __extension__ struct{ cl_int  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_int4 lo, hi; };
+#endif
+#if defined( __CL_INT2__) 
+    __cl_int2     v2[4];
+#endif
+#if defined( __CL_INT4__) 
+    __cl_int4     v4[2];
+#endif
+#if defined( __CL_INT8__ )
+    __cl_int8     v8;
+#endif
+}cl_int8;
+
+typedef union
+{
+    cl_int  CL_ALIGNED(64) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_int  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_int  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_int8 lo, hi; };
+#endif
+#if defined( __CL_INT2__) 
+    __cl_int2     v2[8];
+#endif
+#if defined( __CL_INT4__) 
+    __cl_int4     v4[4];
+#endif
+#if defined( __CL_INT8__ )
+    __cl_int8     v8[2];
+#endif
+#if defined( __CL_INT16__ )
+    __cl_int16    v16;
+#endif
+}cl_int16;
+
+
+/* ---- cl_uintn ---- */
+typedef union
+{
+    cl_uint  CL_ALIGNED(8) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uint  x, y; };
+   __extension__ struct{ cl_uint  s0, s1; };
+   __extension__ struct{ cl_uint  lo, hi; };
+#endif
+#if defined( __CL_UINT2__) 
+    __cl_uint2     v2;
+#endif
+}cl_uint2;
+
+typedef union
+{
+    cl_uint  CL_ALIGNED(16) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uint  x, y, z, w; };
+   __extension__ struct{ cl_uint  s0, s1, s2, s3; };
+   __extension__ struct{ cl_uint2 lo, hi; };
+#endif
+#if defined( __CL_UINT2__) 
+    __cl_uint2     v2[2];
+#endif
+#if defined( __CL_UINT4__) 
+    __cl_uint4     v4;
+#endif
+}cl_uint4;
+
+/* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */
+typedef  cl_uint4  cl_uint3;
+
+typedef union
+{
+    cl_uint   CL_ALIGNED(32) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uint  x, y, z, w; };
+   __extension__ struct{ cl_uint  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_uint4 lo, hi; };
+#endif
+#if defined( __CL_UINT2__) 
+    __cl_uint2     v2[4];
+#endif
+#if defined( __CL_UINT4__) 
+    __cl_uint4     v4[2];
+#endif
+#if defined( __CL_UINT8__ )
+    __cl_uint8     v8;
+#endif
+}cl_uint8;
+
+typedef union
+{
+    cl_uint  CL_ALIGNED(64) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_uint  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_uint  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_uint8 lo, hi; };
+#endif
+#if defined( __CL_UINT2__) 
+    __cl_uint2     v2[8];
+#endif
+#if defined( __CL_UINT4__) 
+    __cl_uint4     v4[4];
+#endif
+#if defined( __CL_UINT8__ )
+    __cl_uint8     v8[2];
+#endif
+#if defined( __CL_UINT16__ )
+    __cl_uint16    v16;
+#endif
+}cl_uint16;
+
+/* ---- cl_longn ---- */
+typedef union
+{
+    cl_long  CL_ALIGNED(16) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_long  x, y; };
+   __extension__ struct{ cl_long  s0, s1; };
+   __extension__ struct{ cl_long  lo, hi; };
+#endif
+#if defined( __CL_LONG2__) 
+    __cl_long2     v2;
+#endif
+}cl_long2;
+
+typedef union
+{
+    cl_long  CL_ALIGNED(32) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_long  x, y, z, w; };
+   __extension__ struct{ cl_long  s0, s1, s2, s3; };
+   __extension__ struct{ cl_long2 lo, hi; };
+#endif
+#if defined( __CL_LONG2__) 
+    __cl_long2     v2[2];
+#endif
+#if defined( __CL_LONG4__) 
+    __cl_long4     v4;
+#endif
+}cl_long4;
+
+/* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */
+typedef  cl_long4  cl_long3;
+
+typedef union
+{
+    cl_long   CL_ALIGNED(64) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_long  x, y, z, w; };
+   __extension__ struct{ cl_long  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_long4 lo, hi; };
+#endif
+#if defined( __CL_LONG2__) 
+    __cl_long2     v2[4];
+#endif
+#if defined( __CL_LONG4__) 
+    __cl_long4     v4[2];
+#endif
+#if defined( __CL_LONG8__ )
+    __cl_long8     v8;
+#endif
+}cl_long8;
+
+typedef union
+{
+    cl_long  CL_ALIGNED(128) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_long  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_long  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_long8 lo, hi; };
+#endif
+#if defined( __CL_LONG2__) 
+    __cl_long2     v2[8];
+#endif
+#if defined( __CL_LONG4__) 
+    __cl_long4     v4[4];
+#endif
+#if defined( __CL_LONG8__ )
+    __cl_long8     v8[2];
+#endif
+#if defined( __CL_LONG16__ )
+    __cl_long16    v16;
+#endif
+}cl_long16;
+
+
+/* ---- cl_ulongn ---- */
+typedef union
+{
+    cl_ulong  CL_ALIGNED(16) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ulong  x, y; };
+   __extension__ struct{ cl_ulong  s0, s1; };
+   __extension__ struct{ cl_ulong  lo, hi; };
+#endif
+#if defined( __CL_ULONG2__) 
+    __cl_ulong2     v2;
+#endif
+}cl_ulong2;
+
+typedef union
+{
+    cl_ulong  CL_ALIGNED(32) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ulong  x, y, z, w; };
+   __extension__ struct{ cl_ulong  s0, s1, s2, s3; };
+   __extension__ struct{ cl_ulong2 lo, hi; };
+#endif
+#if defined( __CL_ULONG2__) 
+    __cl_ulong2     v2[2];
+#endif
+#if defined( __CL_ULONG4__) 
+    __cl_ulong4     v4;
+#endif
+}cl_ulong4;
+
+/* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */
+typedef  cl_ulong4  cl_ulong3;
+
+typedef union
+{
+    cl_ulong   CL_ALIGNED(64) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ulong  x, y, z, w; };
+   __extension__ struct{ cl_ulong  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_ulong4 lo, hi; };
+#endif
+#if defined( __CL_ULONG2__) 
+    __cl_ulong2     v2[4];
+#endif
+#if defined( __CL_ULONG4__) 
+    __cl_ulong4     v4[2];
+#endif
+#if defined( __CL_ULONG8__ )
+    __cl_ulong8     v8;
+#endif
+}cl_ulong8;
+
+typedef union
+{
+    cl_ulong  CL_ALIGNED(128) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_ulong  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_ulong  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_ulong8 lo, hi; };
+#endif
+#if defined( __CL_ULONG2__) 
+    __cl_ulong2     v2[8];
+#endif
+#if defined( __CL_ULONG4__) 
+    __cl_ulong4     v4[4];
+#endif
+#if defined( __CL_ULONG8__ )
+    __cl_ulong8     v8[2];
+#endif
+#if defined( __CL_ULONG16__ )
+    __cl_ulong16    v16;
+#endif
+}cl_ulong16;
+
+
+/* --- cl_floatn ---- */
+
+typedef union
+{
+    cl_float  CL_ALIGNED(8) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_float  x, y; };
+   __extension__ struct{ cl_float  s0, s1; };
+   __extension__ struct{ cl_float  lo, hi; };
+#endif
+#if defined( __CL_FLOAT2__) 
+    __cl_float2     v2;
+#endif
+}cl_float2;
+
+typedef union
+{
+    cl_float  CL_ALIGNED(16) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_float   x, y, z, w; };
+   __extension__ struct{ cl_float   s0, s1, s2, s3; };
+   __extension__ struct{ cl_float2  lo, hi; };
+#endif
+#if defined( __CL_FLOAT2__) 
+    __cl_float2     v2[2];
+#endif
+#if defined( __CL_FLOAT4__) 
+    __cl_float4     v4;
+#endif
+}cl_float4;
+
+/* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */
+typedef  cl_float4  cl_float3;
+
+typedef union
+{
+    cl_float   CL_ALIGNED(32) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_float   x, y, z, w; };
+   __extension__ struct{ cl_float   s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_float4  lo, hi; };
+#endif
+#if defined( __CL_FLOAT2__) 
+    __cl_float2     v2[4];
+#endif
+#if defined( __CL_FLOAT4__) 
+    __cl_float4     v4[2];
+#endif
+#if defined( __CL_FLOAT8__ )
+    __cl_float8     v8;
+#endif
+}cl_float8;
+
+typedef union
+{
+    cl_float  CL_ALIGNED(64) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_float  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_float  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_float8 lo, hi; };
+#endif
+#if defined( __CL_FLOAT2__) 
+    __cl_float2     v2[8];
+#endif
+#if defined( __CL_FLOAT4__) 
+    __cl_float4     v4[4];
+#endif
+#if defined( __CL_FLOAT8__ )
+    __cl_float8     v8[2];
+#endif
+#if defined( __CL_FLOAT16__ )
+    __cl_float16    v16;
+#endif
+}cl_float16;
+
+/* --- cl_doublen ---- */
+
+typedef union
+{
+    cl_double  CL_ALIGNED(16) s[2];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_double  x, y; };
+   __extension__ struct{ cl_double s0, s1; };
+   __extension__ struct{ cl_double lo, hi; };
+#endif
+#if defined( __CL_DOUBLE2__) 
+    __cl_double2     v2;
+#endif
+}cl_double2;
+
+typedef union
+{
+    cl_double  CL_ALIGNED(32) s[4];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_double  x, y, z, w; };
+   __extension__ struct{ cl_double  s0, s1, s2, s3; };
+   __extension__ struct{ cl_double2 lo, hi; };
+#endif
+#if defined( __CL_DOUBLE2__) 
+    __cl_double2     v2[2];
+#endif
+#if defined( __CL_DOUBLE4__) 
+    __cl_double4     v4;
+#endif
+}cl_double4;
+
+/* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */
+typedef  cl_double4  cl_double3;
+
+typedef union
+{
+    cl_double   CL_ALIGNED(64) s[8];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_double  x, y, z, w; };
+   __extension__ struct{ cl_double  s0, s1, s2, s3, s4, s5, s6, s7; };
+   __extension__ struct{ cl_double4 lo, hi; };
+#endif
+#if defined( __CL_DOUBLE2__) 
+    __cl_double2     v2[4];
+#endif
+#if defined( __CL_DOUBLE4__) 
+    __cl_double4     v4[2];
+#endif
+#if defined( __CL_DOUBLE8__ )
+    __cl_double8     v8;
+#endif
+}cl_double8;
+
+typedef union
+{
+    cl_double  CL_ALIGNED(128) s[16];
+#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ )
+   __extension__ struct{ cl_double  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
+   __extension__ struct{ cl_double  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
+   __extension__ struct{ cl_double8 lo, hi; };
+#endif
+#if defined( __CL_DOUBLE2__) 
+    __cl_double2     v2[8];
+#endif
+#if defined( __CL_DOUBLE4__) 
+    __cl_double4     v4[4];
+#endif
+#if defined( __CL_DOUBLE8__ )
+    __cl_double8     v8[2];
+#endif
+#if defined( __CL_DOUBLE16__ )
+    __cl_double16    v16;
+#endif
+}cl_double16;
+
+/* Macro to facilitate debugging 
+ * Usage:
+ *   Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. 
+ *   The first line ends with:   CL_PROGRAM_STRING_BEGIN \"
+ *   Each line thereafter of OpenCL C source must end with: \n\
+ *   The last line ends in ";
+ *
+ *   Example:
+ *
+ *   const char *my_program = CL_PROGRAM_STRING_BEGIN "\
+ *   kernel void foo( int a, float * b )             \n\
+ *   {                                               \n\
+ *      // my comment                                \n\
+ *      *b[ get_global_id(0)] = a;                   \n\
+ *   }                                               \n\
+ *   ";
+ *
+ * This should correctly set up the line, (column) and file information for your source 
+ * string so you can do source level debugging.
+ */
+#define  __CL_STRINGIFY( _x )               # _x
+#define  _CL_STRINGIFY( _x )                __CL_STRINGIFY( _x )
+#define  CL_PROGRAM_STRING_DEBUG_INFO       "#line "  _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" 
+  
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __CL_PLATFORM_H  */

mtapi_opencl_c/src/CL/opencl.h

+/*******************************************************************************
+ * Copyright (c) 2008-2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
+
+/* $Revision: 11708 $ on $Date: 2010-06-14 12:06:24 +0530 (Mon, 14 Jun 2010) $ */
+
+#ifndef __OPENCL_H
+#define __OPENCL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __APPLE__
+
+#include <OpenCL/cl.h>
+#include <OpenCL/cl_gl.h>
+#include <OpenCL/cl_gl_ext.h>
+#include <OpenCL/cl_ext.h>
+
+#else
+
+#include <CL/cl.h>
+#include <CL/cl_gl.h>
+#include <CL/cl_gl_ext.h>
+#include <CL/cl_ext.h>
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __OPENCL_H   */
+

mtapi_opencl_c/src/embb_mtapi_opencl.c

+/*
+ * 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 <CL/cl.h>
+#include <string.h>
+#include <assert.h>
+
+#include <embb/base/c/memory_allocation.h>
+#include <embb/mtapi/c/mtapi_ext.h>
+#include <embb/base/c/internal/unused.h>
+
+#include <embb/mtapi/c/mtapi_opencl.h>
+
+#include <embb_mtapi_opencl_runtimelinker.h>
+
+#include <embb_mtapi_task_t.h>
+#include <embb_mtapi_action_t.h>
+#include <embb_mtapi_node_t.h>
+#include <mtapi_status_t.h>
+
+struct embb_mtapi_opencl_plugin_struct {
+  cl_platform_id platform_id;
+  cl_device_id device_id;
+  cl_context context;
+  cl_command_queue command_queue;
+  cl_uint work_group_size;
+  cl_uint work_item_sizes[3];
+};
+
+typedef struct embb_mtapi_opencl_plugin_struct embb_mtapi_opencl_plugin_t;
+
+static embb_mtapi_opencl_plugin_t embb_mtapi_opencl_plugin;
+
+struct embb_mtapi_opencl_action_struct {
+  cl_program program;
+  cl_kernel kernel;
+  cl_mem node_local_data;
+  int node_local_data_size;
+  size_t local_work_size;
+  size_t element_size;
+};
+
+typedef struct embb_mtapi_opencl_action_struct embb_mtapi_opencl_action_t;
+
+struct embb_mtapi_opencl_task_struct {
+  cl_mem arguments;
+  int arguments_size;
+  cl_mem result_buffer;
+  int result_buffer_size;
+  cl_event kernel_finish_event;
+  mtapi_task_hndl_t task;
+};
+
+typedef struct embb_mtapi_opencl_task_struct embb_mtapi_opencl_task_t;
+
+static size_t round_up(size_t group_size, size_t global_size) {
+  size_t r = global_size % group_size;
+  if (r == 0) {
+    return global_size;
+  } else {
+    return global_size + group_size - r;
+  }
+}
+
+static void CL_API_CALL opencl_task_complete(
+  cl_event ev, cl_int status, void * data) {
+  EMBB_UNUSED(ev);
+  EMBB_UNUSED(status);
+
+  cl_int err;
+  EMBB_UNUSED_IN_RELEASE(err);
+  embb_mtapi_opencl_task_t * opencl_task = (embb_mtapi_opencl_task_t*)data;
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+    if (embb_mtapi_task_pool_is_handle_valid(
+      node->task_pool, opencl_task->task)) {
+      embb_mtapi_task_t * local_task =
+        embb_mtapi_task_pool_get_storage_for_handle(
+          node->task_pool, opencl_task->task);
+
+      err = clWaitForEvents(1, &opencl_task->kernel_finish_event);
+      assert(CL_SUCCESS == err);
+
+      if (NULL != opencl_task->result_buffer) {
+        err = clReleaseMemObject(opencl_task->result_buffer);
+        assert(CL_SUCCESS == err);
+      }
+      if (NULL != opencl_task->arguments) {
+        err = clReleaseMemObject(opencl_task->arguments);
+        assert(CL_SUCCESS == err);
+      }
+
+      embb_mtapi_task_set_state(local_task, MTAPI_TASK_COMPLETED);
+    }
+  }
+}
+
+static void opencl_task_start(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  cl_int err;
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+
+    if (embb_mtapi_task_pool_is_handle_valid(node->task_pool, task)) {
+      embb_mtapi_task_t * local_task =
+        embb_mtapi_task_pool_get_storage_for_handle(node->task_pool, task);
+
+      if (embb_mtapi_action_pool_is_handle_valid(
+        node->action_pool, local_task->action)) {
+        embb_mtapi_action_t * local_action =
+          embb_mtapi_action_pool_get_storage_for_handle(
+          node->action_pool, local_task->action);
+
+        embb_mtapi_opencl_plugin_t * plugin = &embb_mtapi_opencl_plugin;
+        embb_mtapi_opencl_action_t * opencl_action =
+          (embb_mtapi_opencl_action_t*)local_action->plugin_data;
+        embb_mtapi_opencl_task_t * opencl_task =
+          (embb_mtapi_opencl_task_t*)embb_alloc(
+            sizeof(embb_mtapi_opencl_task_t));
+
+        size_t elements = local_task->result_size /
+          opencl_action->element_size;
+        size_t global_work_size;
+
+        if (0 == elements)
+          elements = 1;
+        global_work_size =
+          round_up(opencl_action->local_work_size, elements);
+
+        opencl_task->task = task;
+
+        opencl_task->arguments_size = (int)local_task->arguments_size;
+        if (0 < local_task->arguments_size) {
+          opencl_task->arguments = clCreateBuffer(plugin->context,
+            CL_MEM_READ_ONLY, local_task->arguments_size, NULL, &err);
+        } else {
+          opencl_task->arguments = NULL;
+        }
+        opencl_task->result_buffer_size = (int)local_task->result_size;
+        if (0 < local_task->result_size) {
+          opencl_task->result_buffer = clCreateBuffer(plugin->context,
+            CL_MEM_WRITE_ONLY, local_task->result_size, NULL, &err);
+        } else {
+          opencl_task->result_buffer = NULL;
+        }
+
+        err = clSetKernelArg(opencl_action->kernel, 0, sizeof(cl_mem),
+          (const void*)&opencl_task->arguments);
+        err = clSetKernelArg(opencl_action->kernel, 1, sizeof(cl_int),
+          (const void*)&opencl_task->arguments_size);
+
+        err = clSetKernelArg(opencl_action->kernel, 2, sizeof(cl_mem),
+          (const void*)&opencl_task->result_buffer);
+        err = clSetKernelArg(opencl_action->kernel, 3, sizeof(cl_int),
+          (const void*)&opencl_task->result_buffer_size);
+
+        err = clEnqueueWriteBuffer(plugin->command_queue,
+          opencl_task->arguments, CL_FALSE, 0,
+          (size_t)opencl_task->arguments_size, local_task->arguments, 0, NULL, NULL);
+        err = clEnqueueNDRangeKernel(plugin->command_queue,
+          opencl_action->kernel, 1, NULL,
+          &global_work_size, &opencl_action->local_work_size, 0, NULL, NULL);
+        err = clEnqueueReadBuffer(plugin->command_queue,
+          opencl_task->result_buffer, CL_FALSE, 0,
+          (size_t)opencl_task->result_buffer_size, local_task->result_buffer,
+          0, NULL, &opencl_task->kernel_finish_event);
+        err = clSetEventCallback(opencl_task->kernel_finish_event,
+          CL_COMPLETE, opencl_task_complete, opencl_task);
+        err = clFlush(plugin->command_queue);
+
+        embb_mtapi_task_set_state(local_task, MTAPI_TASK_RUNNING);
+        local_status = MTAPI_SUCCESS;
+      }
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+static void opencl_task_cancel(
+  MTAPI_IN mtapi_task_hndl_t task,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  EMBB_UNUSED(task);
+
+  mtapi_status_set(status, local_status);
+}
+
+static void opencl_action_finalize(
+  MTAPI_IN mtapi_action_hndl_t action,
+  MTAPI_OUT mtapi_status_t* status
+  ) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  cl_int err;
+  EMBB_UNUSED_IN_RELEASE(err);
+
+  if (embb_mtapi_node_is_initialized()) {
+    embb_mtapi_node_t * node = embb_mtapi_node_get_instance();
+    if (embb_mtapi_action_pool_is_handle_valid(node->action_pool, action)) {
+      embb_mtapi_action_t * local_action =
+        embb_mtapi_action_pool_get_storage_for_handle(
+        node->action_pool, action);
+      embb_mtapi_opencl_action_t * opencl_action =
+        (embb_mtapi_opencl_action_t *)local_action->plugin_data;
+      if (NULL != opencl_action->node_local_data) {
+        err = clReleaseMemObject(opencl_action->node_local_data);
+        assert(CL_SUCCESS == err);
+      }
+
+      err = clReleaseKernel(opencl_action->kernel);
+      assert(CL_SUCCESS == err);
+      err = clReleaseProgram(opencl_action->program);
+      assert(CL_SUCCESS == err);
+
+      embb_free(opencl_action);
+      local_status = MTAPI_SUCCESS;
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+char buffer[1024];
+
+void mtapi_opencl_plugin_initialize(
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+  cl_int err;
+  embb_mtapi_opencl_plugin_t * plugin = &embb_mtapi_opencl_plugin;
+
+  err = embb_mtapi_opencl_link_at_runtime();
+  if (err != 0) {
+    err = clGetPlatformIDs(1, &plugin->platform_id, NULL);
+    if (CL_SUCCESS == err) {
+      err = clGetDeviceIDs(plugin->platform_id, CL_DEVICE_TYPE_DEFAULT,
+        1, &plugin->device_id, NULL);
+    }
+    if (CL_SUCCESS == err) {
+      plugin->context = clCreateContext(NULL, 1, &plugin->device_id,
+        NULL, NULL, &err);
+    }
+    if (CL_SUCCESS == err) {
+      err = clGetDeviceInfo(plugin->device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE,
+        sizeof(cl_uint), &plugin->work_group_size, NULL);
+    }
+    if (CL_SUCCESS == err) {
+      err = clGetDeviceInfo(plugin->device_id, CL_DEVICE_MAX_WORK_ITEM_SIZES,
+        3 * sizeof(cl_uint), &plugin->work_item_sizes[0], NULL);
+    }
+    if (CL_SUCCESS == err) {
+      plugin->command_queue = clCreateCommandQueue(plugin->context,
+        plugin->device_id, 0, &err);
+    }
+    if (CL_SUCCESS == err) {
+      local_status = MTAPI_SUCCESS;
+    }
+  }
+
+  mtapi_status_set(status, local_status);
+}
+
+void mtapi_opencl_plugin_finalize(
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  cl_int err;
+  EMBB_UNUSED_IN_RELEASE(err);
+  embb_mtapi_opencl_plugin_t * plugin = &embb_mtapi_opencl_plugin;
+
+  /* finalization */
+  err = clReleaseCommandQueue(plugin->command_queue);
+  assert(CL_SUCCESS == err);
+  err = clReleaseContext(plugin->context);
+  assert(CL_SUCCESS == err);
+
+  local_status = MTAPI_SUCCESS;
+  mtapi_status_set(status, local_status);
+}
+
+mtapi_action_hndl_t mtapi_opencl_action_create(
+  MTAPI_IN mtapi_job_id_t job_id,
+  MTAPI_IN char* kernel_source,
+  MTAPI_IN char* kernel_name,
+  MTAPI_IN mtapi_size_t local_work_size,
+  MTAPI_IN mtapi_size_t element_size,
+  MTAPI_IN void* node_local_data,
+  MTAPI_IN mtapi_size_t node_local_data_size,
+  MTAPI_OUT mtapi_status_t* status) {
+  mtapi_status_t local_status = MTAPI_ERR_UNKNOWN;
+
+  cl_int err;
+  embb_mtapi_opencl_plugin_t * plugin = &embb_mtapi_opencl_plugin;
+  embb_mtapi_opencl_action_t * action =
+    (embb_mtapi_opencl_action_t*)embb_alloc(
+      sizeof(embb_mtapi_opencl_action_t));
+  mtapi_action_hndl_t action_hndl = { 0, 0 }; // invalid handle
+  size_t kernel_length = strlen(kernel_source);
+  mtapi_boolean_t free_program_on_error = MTAPI_FALSE;
+  mtapi_boolean_t free_kernel_on_error = MTAPI_FALSE;
+  mtapi_boolean_t free_node_local_data_on_error = MTAPI_FALSE;
+
+  action->local_work_size = local_work_size;
+  action->element_size = element_size;
+
+  /* initialization */
+  action->program = clCreateProgramWithSource(plugin->context,
+    1, &kernel_source, &kernel_length, &err);
+  if (CL_SUCCESS == err) {
+    free_program_on_error = MTAPI_TRUE;
+    err = clBuildProgram(action->program, 1, &plugin->device_id,
+      NULL, NULL, NULL);
+  } else {
+    err = clGetProgramBuildInfo(action->program, plugin->device_id,
+      CL_PROGRAM_BUILD_LOG, 1024, buffer, NULL);
+  }
+
+  if (CL_SUCCESS == err) {
+    action->kernel = clCreateKernel(action->program, kernel_name, &err);
+    if (CL_SUCCESS == err) {
+      free_kernel_on_error = MTAPI_TRUE;
+    }
+  }
+
+  if (0 < node_local_data_size) {
+    action->node_local_data = clCreateBuffer(plugin->context, CL_MEM_READ_ONLY,
+      node_local_data_size, NULL, &err);
+    if (CL_SUCCESS == err) {
+      free_node_local_data_on_error = MTAPI_TRUE;
+    }
+    action->node_local_data_size = (int)node_local_data_size;
+    if (CL_SUCCESS == err) {
+      err = clEnqueueWriteBuffer(plugin->command_queue,
+        action->node_local_data, CL_TRUE, 0,
+        (size_t)action->node_local_data_size, node_local_data, 0, NULL, NULL);
+    }
+  } else {
+    action->node_local_data = NULL;
+    action->node_local_data_size = 0;
+  }
+
+  if (CL_SUCCESS == err) {
+    err = clSetKernelArg(action->kernel, 4, sizeof(cl_mem),
+      (const void*)&action->node_local_data);
+  }
+  if (CL_SUCCESS == err) {
+    err = clSetKernelArg(action->kernel, 5, sizeof(cl_int),
+      (const void*)&action->node_local_data_size);
+  }
+
+  if (CL_SUCCESS == err) {
+    action_hndl = mtapi_ext_plugin_action_create(
+      job_id,
+      opencl_task_start,
+      opencl_task_cancel,
+      opencl_action_finalize,
+      action,
+      node_local_data,
+      node_local_data_size,
+      MTAPI_NULL,
+      &local_status);
+  } else {
+    if (free_node_local_data_on_error) {
+      clReleaseMemObject(action->node_local_data);
+    }
+    if (free_kernel_on_error) {
+      clReleaseKernel(action->kernel);
+    }
+    if (free_program_on_error) {
+      clReleaseProgram(action->program);
+    }
+    embb_free(action);
+  }
+
+  mtapi_status_set(status, local_status);
+
+  return action_hndl;
+}

mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c

+/*
+ * 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 <CL/opencl.h>
+#include <embb/base/c/internal/config.h>
+
+//////////////////////////////////////////////////////////////////////////
+// function pointer wrappers to hide runtime linking
+
+#define DECLARECLFUNC(rettype, name, params) typedef CL_API_ENTRY rettype\
+    (CL_API_CALL *name##Proc)params;\
+    name##Proc name##_Dynamic = 0;\
+    \
+    CL_API_ENTRY rettype CL_API_CALL name params
+
+DECLARECLFUNC(cl_int, clGetPlatformIDs, (cl_uint num_entries,
+  cl_platform_id * platforms, cl_uint * num_platforms)) {
+  return clGetPlatformIDs_Dynamic(num_entries, platforms, num_platforms);
+}
+
+DECLARECLFUNC(cl_int, clGetPlatformInfo, (cl_platform_id platform,
+  cl_platform_info param_name, size_t param_value_size, void * param_value,
+  size_t * param_value_size_ret)) {
+  return clGetPlatformInfo_Dynamic(platform, param_name, param_value_size,
+    param_value, param_value_size_ret);
+}
+
+DECLARECLFUNC(cl_int, clGetDeviceIDs, (cl_platform_id platform,
+  cl_device_type device_type, cl_uint num_entries, cl_device_id * devices,
+  cl_uint * num_devices)) {
+  return clGetDeviceIDs_Dynamic(platform, device_type, num_entries, devices,
+    num_devices);
+}
+
+DECLARECLFUNC(cl_int, clGetDeviceInfo, (cl_device_id device,
+  cl_device_info param_name, size_t param_value_size, void * param_value,
+  size_t * param_value_size_ret)) {
+  return clGetDeviceInfo_Dynamic(device, param_name, param_value_size,
+    param_value, param_value_size_ret);
+}
+
+DECLARECLFUNC(cl_context, clCreateContext,
+  (const cl_context_properties * properties, cl_uint num_devices,
+  const cl_device_id * devices,
+  void (CL_CALLBACK * pfn_notify)(const char *, const void *, size_t, void *),
+  void * user_data, cl_int * errcode_ret)) {
+  return clCreateContext_Dynamic(properties, num_devices, devices, pfn_notify,
+    user_data, errcode_ret);
+}
+
+DECLARECLFUNC(cl_command_queue, clCreateCommandQueue, (cl_context context,
+  cl_device_id device, cl_command_queue_properties properties,
+  cl_int * errcode_ret)) {
+  return clCreateCommandQueue_Dynamic(context, device, properties,
+    errcode_ret);
+}
+
+DECLARECLFUNC(cl_mem, clCreateBuffer, (cl_context context, cl_mem_flags flags,
+  size_t size, void * host_ptr, cl_int * errcode_ret)) {
+  return clCreateBuffer_Dynamic(context, flags, size, host_ptr, errcode_ret);
+}
+
+DECLARECLFUNC(cl_program, clCreateProgramWithSource, (cl_context context,
+  cl_uint count, const char ** strings, const size_t * lengths,
+  cl_int * errcode_ret)) {
+  return clCreateProgramWithSource_Dynamic(context, count, strings, lengths,
+    errcode_ret);
+}
+
+DECLARECLFUNC(cl_int, clBuildProgram, (cl_program program, cl_uint num_devices,
+  const cl_device_id * device_list, const char * options,
+  void (CL_CALLBACK * pfn_notify)(cl_program, void *), void * user_data)) {
+  return clBuildProgram_Dynamic(program, num_devices, device_list, options,
+    pfn_notify, user_data);
+}
+
+DECLARECLFUNC(cl_int, clGetProgramBuildInfo, (cl_program program,
+  cl_device_id device, cl_program_build_info param_name,
+  size_t param_value_size, void * param_value,
+  size_t * param_value_size_ret)) {
+  return clGetProgramBuildInfo_Dynamic(program, device, param_name,
+    param_value_size, param_value, param_value_size_ret);
+}
+
+DECLARECLFUNC(cl_kernel, clCreateKernel, (cl_program program,
+  const char * kernel_name, cl_int * errcode_ret)) {
+  return clCreateKernel_Dynamic(program, kernel_name, errcode_ret);
+}
+
+DECLARECLFUNC(cl_int, clSetKernelArg, (cl_kernel kernel, cl_uint arg_index,
+  size_t arg_size, const void * arg_value)) {
+  return clSetKernelArg_Dynamic(kernel, arg_index, arg_size, arg_value);
+}
+
+DECLARECLFUNC(cl_int, clEnqueueWriteBuffer, (cl_command_queue command_queue,
+  cl_mem buffer, cl_bool blocking_write, size_t offset, size_t cb,
+  const void * ptr, cl_uint num_events_in_wait_list,
+  const cl_event * event_wait_list, cl_event * event)) {
+  return clEnqueueWriteBuffer_Dynamic(command_queue, buffer, blocking_write,
+    offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+DECLARECLFUNC(cl_int, clEnqueueNDRangeKernel, (cl_command_queue command_queue,
+  cl_kernel kernel, cl_uint work_dim, const size_t * global_work_offset,
+  const size_t * global_work_size, const size_t * local_work_size,
+  cl_uint num_events_in_wait_list, const cl_event * event_wait_list,
+  cl_event * event)) {
+  return clEnqueueNDRangeKernel_Dynamic(command_queue, kernel, work_dim,
+    global_work_offset, global_work_size, local_work_size,
+    num_events_in_wait_list, event_wait_list, event);
+}
+
+DECLARECLFUNC(cl_int, clEnqueueReadBuffer, (cl_command_queue command_queue,
+  cl_mem buffer, cl_bool blocking_read, size_t offset, size_t cb, void * ptr,
+  cl_uint num_events_in_wait_list, const cl_event * event_wait_list,
+  cl_event * event)) {
+  return clEnqueueReadBuffer_Dynamic(command_queue, buffer, blocking_read,
+    offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+DECLARECLFUNC(cl_int, clSetEventCallback, (cl_event event,
+  cl_int command_exec_callback_type,
+  void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *),
+  void * user_data)) {
+  return clSetEventCallback_Dynamic(event, command_exec_callback_type,
+    pfn_notify, user_data);
+}
+
+DECLARECLFUNC(cl_int, clWaitForEvents, (cl_uint num_events,
+  const cl_event * event_list)) {
+  return clWaitForEvents_Dynamic(num_events, event_list);
+}
+
+DECLARECLFUNC(cl_int, clReleaseKernel, (cl_kernel kernel)) {
+  return clReleaseKernel_Dynamic(kernel);
+}
+
+DECLARECLFUNC(cl_int, clReleaseProgram, (cl_program program)) {
+  return clReleaseProgram_Dynamic(program);
+}
+
+DECLARECLFUNC(cl_int, clReleaseCommandQueue,
+  (cl_command_queue command_queue)) {
+  return clReleaseCommandQueue_Dynamic(command_queue);
+}
+
+DECLARECLFUNC(cl_int, clReleaseContext, (cl_context context)) {
+  return clReleaseContext_Dynamic(context);
+}
+
+DECLARECLFUNC(cl_int, clReleaseMemObject, (cl_mem memobj)) {
+  return clReleaseMemObject_Dynamic(memobj);
+}
+
+DECLARECLFUNC(cl_int, clFlush, (cl_command_queue command_queue)) {
+  return clFlush_Dynamic(command_queue);
+}
+
+DECLARECLFUNC(cl_int, clFinish, (cl_command_queue command_queue)) {
+  return clFinish_Dynamic(command_queue);
+}
+
+DECLARECLFUNC(cl_sampler, clCreateSampler, (cl_context context,
+  cl_bool normalized_coords, cl_addressing_mode addressing_mode,
+  cl_filter_mode filter_mode, cl_int * errcode_ret)) {
+  return clCreateSampler_Dynamic(context, normalized_coords, addressing_mode,
+    filter_mode, errcode_ret);
+}
+
+DECLARECLFUNC(cl_int, clReleaseSampler, (cl_sampler sampler)) {
+  return clReleaseSampler_Dynamic(sampler);
+}
+
+DECLARECLFUNC(cl_mem, clCreateImage2D, (cl_context context,
+  cl_mem_flags flags, const cl_image_format * image_format, size_t image_width,
+  size_t image_height, size_t image_row_pitch, void * host_ptr,
+  cl_int * errcode_ret)) {
+  return clCreateImage2D_Dynamic(context, flags, image_format, image_width,
+    image_height, image_row_pitch, host_ptr, errcode_ret);
+}
+
+DECLARECLFUNC(cl_mem, clCreateImage3D, (cl_context context, cl_mem_flags flags,
+  const cl_image_format * image_format, size_t image_width,
+  size_t image_height, size_t image_depth, size_t image_row_pitch,
+  size_t image_slice_pitch, void * host_ptr, cl_int * errcode_ret)) {
+  return clCreateImage3D_Dynamic(context, flags, image_format, image_width,
+    image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr,
+    errcode_ret);
+}
+
+DECLARECLFUNC(cl_int, clEnqueueAcquireGLObjects,
+  (cl_command_queue command_queue, cl_uint num_objects,
+  const cl_mem * mem_objects, cl_uint num_events_in_wait_list,
+  const cl_event * event_wait_list, cl_event * event)) {
+  return clEnqueueAcquireGLObjects_Dynamic(command_queue, num_objects,
+    mem_objects, num_events_in_wait_list, event_wait_list, event);
+}
+
+DECLARECLFUNC(cl_int, clEnqueueReleaseGLObjects,
+  (cl_command_queue command_queue, cl_uint num_objects,
+  const cl_mem * mem_objects, cl_uint num_events_in_wait_list,
+  const cl_event * event_wait_list, cl_event * event)) {
+  return clEnqueueReleaseGLObjects_Dynamic(command_queue, num_objects,
+    mem_objects, num_events_in_wait_list, event_wait_list, event);
+}
+
+DECLARECLFUNC(cl_mem, clCreateFromGLBuffer, (cl_context context,
+  cl_mem_flags flags, cl_GLuint bufobj, int * errcode_ret)) {
+  return clCreateFromGLBuffer_Dynamic(context, flags, bufobj, errcode_ret);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// system specific functions
+
+#ifdef _WIN32
+
+#include <Windows.h>
+
+#define CHECKEDIMPORT(name) name##_Dynamic = \
+  (name##Proc)GetProcAddress(opencl_dll_handle, #name); \
+  if (name##_Dynamic == 0) return 0;
+
+#else
+
+#include <dlfcn.h>
+
+#define CHECKEDIMPORT(name) name##_Dynamic = \
+  (name##Proc)dlsym(opencl_dll_handle, #name); \
+  if (name##_Dynamic == 0) return 0;
+
+#endif
+
+#ifdef __cplusplus
+extern "C"
+#endif
+int embb_mtapi_opencl_link_at_runtime() {
+#ifdef _WIN32
+  HMODULE opencl_dll_handle = LoadLibraryA("opencl.dll");
+#else
+  void * opencl_dll_handle = dlopen("libOpenCL.so", RTLD_LAZY);
+#endif
+  if (opencl_dll_handle == 0)
+    return 0;
+
+#ifdef EMBB_PLATFORM_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4191)
+#endif
+  CHECKEDIMPORT(clGetPlatformIDs);
+  CHECKEDIMPORT(clGetPlatformInfo);
+  CHECKEDIMPORT(clGetDeviceIDs);
+  CHECKEDIMPORT(clGetDeviceInfo);
+  CHECKEDIMPORT(clCreateContext);
+  CHECKEDIMPORT(clCreateCommandQueue);
+  CHECKEDIMPORT(clCreateBuffer);
+  CHECKEDIMPORT(clCreateProgramWithSource);
+  CHECKEDIMPORT(clBuildProgram);
+  CHECKEDIMPORT(clGetProgramBuildInfo);
+  CHECKEDIMPORT(clCreateKernel);
+  CHECKEDIMPORT(clSetKernelArg);
+  CHECKEDIMPORT(clEnqueueWriteBuffer);
+  CHECKEDIMPORT(clEnqueueNDRangeKernel);
+  CHECKEDIMPORT(clEnqueueReadBuffer);
+  CHECKEDIMPORT(clSetEventCallback);
+  CHECKEDIMPORT(clWaitForEvents);
+  CHECKEDIMPORT(clReleaseKernel);
+  CHECKEDIMPORT(clReleaseProgram);
+  CHECKEDIMPORT(clReleaseCommandQueue);
+  CHECKEDIMPORT(clReleaseContext);
+  CHECKEDIMPORT(clReleaseMemObject);
+  CHECKEDIMPORT(clFlush);
+  CHECKEDIMPORT(clFinish);
+  CHECKEDIMPORT(clCreateSampler);
+  CHECKEDIMPORT(clReleaseSampler);
+  CHECKEDIMPORT(clCreateImage2D);
+  CHECKEDIMPORT(clCreateImage3D);
+
+  CHECKEDIMPORT(clEnqueueAcquireGLObjects);
+  CHECKEDIMPORT(clEnqueueReleaseGLObjects);
+  CHECKEDIMPORT(clCreateFromGLBuffer);
+#ifdef EMBB_PLATFORM_COMPILER_MSVC
+#pragma warning(pop)
+#endif
+
+  return 1;
+}

mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.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_OPENCL_C_SRC_EMBB_MTAPI_OPENCL_RUNTIMELINKER_H_
+#define MTAPI_OPENCL_C_SRC_EMBB_MTAPI_OPENCL_RUNTIMELINKER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int embb_mtapi_opencl_link_at_runtime();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MTAPI_OPENCL_C_SRC_EMBB_MTAPI_OPENCL_RUNTIMELINKER_H_

mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.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_opencl_test_linker.h>
+
+#include <embb_mtapi_opencl_runtimelinker.h>
+
+
+LinkerTest::LinkerTest() {
+  CreateUnit("mtapi opencl linker test").Add(&LinkerTest::TestBasic, this);
+}
+
+void LinkerTest::TestBasic() {
+  PT_EXPECT(embb_mtapi_opencl_link_at_runtime() != 0);
+}

mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.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_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_LINKER_H_
+#define MTAPI_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_LINKER_H_
+
+#include <partest/partest.h>
+
+class LinkerTest : public partest::TestCase {
+ public:
+  LinkerTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_LINKER_H_

mtapi_opencl_c/test/embb_mtapi_opencl_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_opencl_test_task.h>
+
+#include <embb/mtapi/c/mtapi_opencl.h>
+
+#define MTAPI_CHECK_STATUS(status) \
+PT_ASSERT(MTAPI_SUCCESS == status)
+
+#define OPENCL_DOMAIN 1
+#define OPENCL_NODE 2
+#define OPENCL_JOB 2
+
+// OpenCL Kernel Function for element by element vector addition
+const char * kernel =
+"__kernel void test(\n"
+"  __global void* arguments,\n"
+"  int arguments_size,\n"
+"  __global void* result_buffer,\n"
+"  int result_buffer_size,\n"
+"  __global void* node_local_data,\n"
+"  int node_local_data_size) {\n"
+"  int ii = get_global_id(0);\n"
+"  int elements = arguments_size / sizeof(float) / 2;\n"
+"  if (ii >= elements)"
+"    return;"
+"  __global float* a = (__global float*)arguments;\n"
+"  __global float* b = ((__global float*)arguments) + elements;\n"
+"  __global float* c = (__global float*)result_buffer;\n"
+"  __global float* d = (__global float*)node_local_data;\n"
+"  c[ii] = a[ii] + b[ii] + d[0];\n"
+"}\n";
+
+TaskTest::TaskTest() {
+  CreateUnit("mtapi opencl 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_opencl_plugin_initialize(&status);
+  MTAPI_CHECK_STATUS(status);
+
+  mtapi_initialize(
+    OPENCL_DOMAIN,
+    OPENCL_NODE,
+    MTAPI_NULL,
+    MTAPI_NULL,
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  float node_local = 1.0f;
+  action = mtapi_opencl_action_create(
+    OPENCL_JOB,
+    kernel, "test", 32, 4,
+    &node_local, sizeof(float),
+    &status);
+  MTAPI_CHECK_STATUS(status);
+
+  status = MTAPI_ERR_UNKNOWN;
+  job = mtapi_job_get(OPENCL_JOB, OPENCL_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_opencl_plugin_finalize(&status);
+  MTAPI_CHECK_STATUS(status);
+}

mtapi_opencl_c/test/embb_mtapi_opencl_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_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_TASK_H_
+#define MTAPI_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_TASK_H_
+
+#include <partest/partest.h>
+
+class TaskTest : public partest::TestCase {
+ public:
+  TaskTest();
+
+ private:
+  void TestBasic();
+};
+
+#endif // MTAPI_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_TASK_H_

mtapi_opencl_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_opencl_test_linker.h>
+#include <embb_mtapi_opencl_test_task.h>
+
+
+PT_MAIN("MTAPI OPENCL") {
+  PT_RUN(LinkerTest);
+  PT_RUN(TaskTest);
+}

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 base_cpp mtapi_cpp tasks_cpp algorithms_cpp containers_cpp dataflow_cpp
+for project in base_c mtapi_c mtapi_network_c mtapi_opencl_c base_cpp mtapi_cpp tasks_cpp algorithms_cpp containers_cpp dataflow_cpp
 do
   echo "-> Doing project: $project"
   dir=$d/$project
@@ -88,7 +88,7 @@ do
     echo
     usage
   fi
-  for file in `find $dir -name "*.cc" -o -name "*.h" -o -name "*inl.h" -o -name "*.c"`
+  for file in `find $dir \( -name "*.cc" -o -name "*.h" -o -name "*inl.h" -o -name "*.c" \) -and -not -path "*/src/CL/*"`
   do
     echo "--> Run cpplint on file $file"
     current_rules=$EXCLUDED_RULES