diff --git a/CMakeLists.txt b/CMakeLists.txt index 5408e81..f59cdbc 100644 --- a/CMakeLists.txt +++ b/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) diff --git a/README.md b/README.md index 1698458..5498983 100644 --- a/README.md +++ b/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 diff --git a/dataflow_cpp/include/embb/dataflow/internal/clock_listener.h b/dataflow_cpp/include/embb/dataflow/internal/clock_listener.h index c8e7fd5..5234740 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/clock_listener.h +++ b/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 diff --git a/dataflow_cpp/include/embb/dataflow/internal/constant_source.h b/dataflow_cpp/include/embb/dataflow/internal/constant_source.h index 58da428..4ec14af 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/constant_source.h +++ b/dataflow_cpp/include/embb/dataflow/internal/constant_source.h @@ -56,6 +56,11 @@ class ConstantSource GetOutput<0>().Send(Signal(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; diff --git a/dataflow_cpp/include/embb/dataflow/internal/in.h b/dataflow_cpp/include/embb/dataflow/internal/in.h index 84ad9a3..71034cb 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/in.h +++ b/dataflow_cpp/include/embb/dataflow/internal/in.h @@ -39,6 +39,8 @@ namespace embb { namespace dataflow { namespace internal { +class Scheduler; + template class Out; @@ -95,6 +97,10 @@ class In { lock_.Unlock(); #endif } + + void ReceiveInit(InitData * init_data) { + listener_->OnInit(init_data); + } }; } // namespace internal diff --git a/dataflow_cpp/include/embb/dataflow/internal/inputs.h b/dataflow_cpp/include/embb/dataflow/internal/inputs.h index 4f4430a..7fc87b6 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/inputs.h +++ b/dataflow_cpp/include/embb/dataflow/internal/inputs.h @@ -57,6 +57,7 @@ class Inputs @@ -70,6 +71,7 @@ class InputsOnClock(clock); } } + virtual void OnInit(InitData * init_data) { + if (--test_count_ == 0) { + listener_->OnInit(init_data); + } + } private: embb::base::Atomic count_[Slices]; + int test_count_; ClockListener * listener_; }; @@ -112,6 +120,7 @@ class InputsOnClock(clock); } } + virtual void OnInit(InitData * init_data) { + if (--test_count_ == 0) { + listener_->OnInit(init_data); + } + } private: embb::base::Atomic count_[Slices]; + int test_count_; ClockListener * listener_; }; @@ -158,6 +173,7 @@ class InputsOnClock(clock); } } + virtual void OnInit(InitData * init_data) { + if (--test_count_ == 0) { + listener_->OnInit(init_data); + } + } private: embb::base::Atomic count_[Slices]; + int test_count_; ClockListener * listener_; }; @@ -207,6 +229,7 @@ class Inputs 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 listener_->OnClock(clock); } } + virtual void OnInit(InitData * init_data) { + if (--test_count_ == 0) { + listener_->OnInit(init_data); + } + } private: embb::base::Atomic 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 count_[Slices]; + int test_count_; ClockListener * listener_; }; diff --git a/dataflow_cpp/include/embb/dataflow/internal/node.h b/dataflow_cpp/include/embb/dataflow/internal/node.h index 122750e..ab47fee 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/node.h +++ b/dataflow_cpp/include/embb/dataflow/internal/node.h @@ -30,6 +30,7 @@ #include #include #include +#include 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_++; } }; diff --git a/dataflow_cpp/include/embb/dataflow/internal/out.h b/dataflow_cpp/include/embb/dataflow/internal/out.h index 382f6ad..9c2f1a1 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/out.h +++ b/dataflow_cpp/include/embb/dataflow/internal/out.h @@ -35,6 +35,8 @@ namespace embb { namespace dataflow { namespace internal { +class Scheduler; + template 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, diff --git a/dataflow_cpp/include/embb/dataflow/internal/process.h b/dataflow_cpp/include/embb/dataflow/internal/process.h index 581f162..4f5bc3f 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/process.h +++ b/dataflow_cpp/include/embb/dataflow/internal/process.h @@ -78,6 +78,11 @@ class Process< Slices, Serial, Inputs, 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, } } + virtual void OnInit(InitData * init_data) { + Init(init_data); + } + private: InputsType inputs_; OutputsType outputs_; diff --git a/dataflow_cpp/include/embb/dataflow/internal/process_executor.h b/dataflow_cpp/include/embb/dataflow/internal/process_executor.h index 7756722..4219cea 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/process_executor.h +++ b/dataflow_cpp/include/embb/dataflow/internal/process_executor.h @@ -62,6 +62,10 @@ class ProcessExecutor< Inputs, Outputs > { } } + void Init(InitData * init_data, Outputs & outputs) { + outputs.template Get<0>().SendInit(init_data); + } + private: FunctionType function_; }; @@ -91,6 +95,11 @@ class ProcessExecutor< Inputs, Outputs > { } } + void Init(InitData * init_data, Outputs & 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, Outputs > { } } + void Init(InitData * init_data, Outputs & 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, Outputs > { } } + void Init(InitData * init_data, Outputs & 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, Outputs > { } } + void Init(InitData * init_data, Outputs & outputs) { + outputs.template Get<0>().SendInit(init_data); + } + private: FunctionType function_; }; @@ -220,6 +246,11 @@ class ProcessExecutor< Inputs, Outputs > { } } + void Init(InitData * init_data, Outputs & 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, Outputs > { } } + void Init(InitData * init_data, Outputs & 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, Outputs > { } } + void Init(InitData * init_data, Outputs & outputs) { + outputs.template Get<0>().SendInit(init_data); + } + private: FunctionType function_; }; @@ -317,6 +358,11 @@ class ProcessExecutor< Inputs, Outputs > { } } + void Init(InitData * init_data, Outputs & 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, Outputs > { } } + void Init(InitData * init_data, Outputs & outputs) { + outputs.template Get<0>().SendInit(init_data); + } + private: FunctionType function_; }; diff --git a/dataflow_cpp/include/embb/dataflow/internal/select.h b/dataflow_cpp/include/embb/dataflow/internal/select.h index 423e2a5..f3a499f 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/select.h +++ b/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_; diff --git a/dataflow_cpp/include/embb/dataflow/internal/sink.h b/dataflow_cpp/include/embb/dataflow/internal/sink.h index b0b4063..2c835ed 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/sink.h +++ b/dataflow_cpp/include/embb/dataflow/internal/sink.h @@ -72,6 +72,12 @@ class Sink< Slices, Inputs > 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 > } } + virtual void OnInit(InitData * init_data) { + Init(init_data); + } + private: InputsType inputs_; ExecutorType executor_; diff --git a/dataflow_cpp/include/embb/dataflow/internal/source.h b/dataflow_cpp/include/embb/dataflow/internal/source.h index 232a50e..72f198b 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/source.h +++ b/dataflow_cpp/include/embb/dataflow/internal/source.h @@ -59,6 +59,11 @@ class Source< Slices, Outputs > 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); diff --git a/dataflow_cpp/include/embb/dataflow/internal/source_executor.h b/dataflow_cpp/include/embb/dataflow/internal/source_executor.h index 2e37faf..1461285 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/source_executor.h +++ b/dataflow_cpp/include/embb/dataflow/internal/source_executor.h @@ -36,6 +36,8 @@ namespace embb { namespace dataflow { namespace internal { +class Scheduler; + template class SourceExecutor; @@ -55,6 +57,10 @@ class SourceExecutor< Outputs > { return result; } + void Init(InitData * init_data, Outputs & outputs) { + outputs.template Get<0>().SendInit(init_data); + } + private: FunctionType function_; }; @@ -77,6 +83,11 @@ class SourceExecutor< Outputs > { return result; } + void Init(InitData * init_data, Outputs & 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 > { return result; } + void Init(InitData * init_data, Outputs & 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 > { return result; } + void Init(InitData * init_data, Outputs & 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 > { return result; } + void Init( + InitData * init_data, Outputs & 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_; }; diff --git a/dataflow_cpp/include/embb/dataflow/internal/switch.h b/dataflow_cpp/include/embb/dataflow/internal/switch.h index 7a1eb13..3bf36ee 100644 --- a/dataflow_cpp/include/embb/dataflow/internal/switch.h +++ b/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_; diff --git a/dataflow_cpp/include/embb/dataflow/network.h b/dataflow_cpp/include/embb/dataflow/network.h index ffe5633..33dbaff 100644 --- a/dataflow_cpp/include/embb/dataflow/network.h +++ b/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 - void Add(SerialProcess & 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 - void Add(ParallelProcess & 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 - void Add(Switch & 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 - void Add(Select & 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 - void Add(Sink & 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 - void Add(Source & source); + void AddSource(Source & source); /** * Constant source process template. @@ -694,7 +659,7 @@ class Network { * \param source The constant source process to add. */ template - void Add(ConstantSource & source); + void AddSource(ConstantSource & source); /** * Executes the network until one of the the sources returns \c false. @@ -748,11 +713,6 @@ class Network : public internal::ClockListener { } }; - template - void Add(SerialProcess & proc) { - processes_.push_back(&proc); - } - template class ParallelProcess; template < @@ -776,31 +736,16 @@ class Network : public internal::ClockListener { } }; - template - void Add(ParallelProcess & proc) { - processes_.push_back(&proc); - } - template class Switch : public internal::Switch { public: }; - template - void Add(Switch & sw) { - processes_.push_back(&sw); - } - template class Select : public internal::Select { public: }; - template - void Add(Select & sel) { - processes_.push_back(&sel); - } - template - void Add(Sink & sink) { - sink.SetListener(this); - sinks_.push_back(&sink); - } - template - void Add(Source & source) { + void AddSource(Source & source) { sources_.push_back(&source); } @@ -857,7 +796,7 @@ class Network : public internal::ClockListener { }; template - void Add(ConstantSource & source) { + void AddSource(ConstantSource & source) { sources_.push_back(&source); } @@ -866,19 +805,20 @@ class Network : public internal::ClockListener { internal::SchedulerMTAPI 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 processes_; std::vector sources_; std::vector sinks_; - embb::base::Atomic sink_count_[Slices]; + embb::base::Atomic sink_counter_[Slices]; + int sink_count_; + #if EMBB_DATAFLOW_TRACE_SIGNAL_HISTORY std::vector 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(sinks_.size()); + sink_counter_[idx] = sink_count_; for (size_t kk = 0; kk < sources_.size(); kk++) { result &= sources_[kk]->Start(clock); } diff --git a/dataflow_cpp/test/dataflow_cpp_test_simple.cc b/dataflow_cpp/test/dataflow_cpp_test_simple.cc index c63a57e..bf5b386 100644 --- a/dataflow_cpp/test/dataflow_cpp_test_simple.cc +++ b/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(); diff --git a/doc/examples/CMakeLists.txt b/doc/examples/CMakeLists.txt index 7d4e4c9..8f49812 100644 --- a/doc/examples/CMakeLists.txt +++ b/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}) diff --git a/doc/examples/dataflow/dataflow_add-snippet.h b/doc/examples/dataflow/dataflow_add-snippet.h index 70a1157..ce51ef8 100644 --- a/doc/examples/dataflow/dataflow_add-snippet.h +++ b/doc/examples/dataflow/dataflow_add-snippet.h @@ -1,3 +1 @@ - nw.Add(read); - nw.Add(replace); - nw.Add(write); + nw.AddSource(read); diff --git a/doc/examples/dataflow/dataflow_declare_add_sources-snippet.h b/doc/examples/dataflow/dataflow_declare_add_sources-snippet.h index 630dedd..f1cfcaa 100644 --- a/doc/examples/dataflow/dataflow_declare_add_sources-snippet.h +++ b/doc/examples/dataflow/dataflow_declare_add_sources-snippet.h @@ -14,7 +14,7 @@ source4( embb::base::MakeFunction(producer4, &Producer::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); diff --git a/doc/examples/dataflow/dataflow_nonlinear-fragmented.cc b/doc/examples/dataflow/dataflow_nonlinear-fragmented.cc index 5708773..e7f419d 100644 --- a/doc/examples/dataflow/dataflow_nonlinear-fragmented.cc +++ b/doc/examples/dataflow/dataflow_nonlinear-fragmented.cc @@ -60,19 +60,11 @@ void RunDataflowNonLinear() { process4( embb::base::MakeFunction(comparator, &Comparator::Run) ), process5( embb::base::MakeFunction(comparator, &Comparator::Run) ); - nw.Add(process1); - nw.Add(process2); - nw.Add(process3); - nw.Add(process4); - nw.Add(process5); - Consumer consumer; Network::Sink sink1(embb::base::MakeFunction(consumer, &Consumer::Run)); - nw.Add(sink1); - source1.GetOutput<0>() >> process1.GetInput<0>(); source2.GetOutput<0>() >> process2.GetInput<0>(); source3.GetOutput<0>() >> process1.GetInput<1>(); diff --git a/doc/examples/main.cc b/doc/examples/main.cc index f231db0..54414bf 100644 --- a/doc/examples/main.cc +++ b/doc/examples/main.cc @@ -28,6 +28,9 @@ #include 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; diff --git a/doc/examples/mtapi/mtapi_c_network-fragmented.cc b/doc/examples/mtapi/mtapi_c_network-fragmented.cc new file mode 100644 index 0000000..eafc07a --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_network-fragmented.cc @@ -0,0 +1,102 @@ +/* + * 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 +#include "mtapi_network_c_header-snippet.h" +#include + +#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(ii); + arguments[ii + kElements] = static_cast(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); +} diff --git a/doc/examples/mtapi/mtapi_c_opencl-fragmented.cc b/doc/examples/mtapi/mtapi_c_opencl-fragmented.cc new file mode 100644 index 0000000..741c461 --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_opencl-fragmented.cc @@ -0,0 +1,98 @@ +/* + * 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 +#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(ii); + arguments[ii + kElements] = static_cast(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); +} diff --git a/doc/examples/mtapi/mtapi_c_plugin-fragmented.cc b/doc/examples/mtapi/mtapi_c_plugin-fragmented.cc new file mode 100644 index 0000000..b1918ee --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin-fragmented.cc @@ -0,0 +1,83 @@ +/* + * 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 +#include + +#include +#include +#include + +#include + +#include +#include +#include +#include + +#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); +} diff --git a/doc/examples/mtapi/mtapi_c_plugin_action_create-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_action_create-snippet.h new file mode 100644 index 0000000..2ec43dd --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_action_create-snippet.h @@ -0,0 +1,10 @@ +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); diff --git a/doc/examples/mtapi/mtapi_c_plugin_action_finalize_cb-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_action_finalize_cb-snippet.h new file mode 100644 index 0000000..7c44e30 --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_action_finalize_cb-snippet.h @@ -0,0 +1,8 @@ +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); +} diff --git a/doc/examples/mtapi/mtapi_c_plugin_get_job-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_get_job-snippet.h new file mode 100644 index 0000000..9e97299 --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_get_job-snippet.h @@ -0,0 +1,4 @@ + job = mtapi_job_get( + PLUGIN_JOB_ID, + PLUGIN_DOMAIN_ID, + &status); diff --git a/doc/examples/mtapi/mtapi_c_plugin_task_cancel_cb-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_task_cancel_cb-snippet.h new file mode 100644 index 0000000..2a62c5d --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_task_cancel_cb-snippet.h @@ -0,0 +1,8 @@ +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); +} diff --git a/doc/examples/mtapi/mtapi_c_plugin_task_schedule-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_task_schedule-snippet.h new file mode 100644 index 0000000..a180edc --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_task_schedule-snippet.h @@ -0,0 +1,11 @@ +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); +} diff --git a/doc/examples/mtapi/mtapi_c_plugin_task_start-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_task_start-snippet.h new file mode 100644 index 0000000..344330a --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_task_start-snippet.h @@ -0,0 +1,8 @@ + task = mtapi_task_start( + MTAPI_TASK_ID_NONE, + job, + MTAPI_NULL, 0, + MTAPI_NULL, 0, + MTAPI_DEFAULT_TASK_ATTRIBUTES, + MTAPI_GROUP_NONE, + &status); diff --git a/doc/examples/mtapi/mtapi_c_plugin_task_start_cb-snippet.h b/doc/examples/mtapi/mtapi_c_plugin_task_start_cb-snippet.h new file mode 100644 index 0000000..8e4d063 --- /dev/null +++ b/doc/examples/mtapi/mtapi_c_plugin_task_start_cb-snippet.h @@ -0,0 +1,31 @@ +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); +} diff --git a/doc/examples/mtapi/mtapi_network_c_action_function-snippet.h b/doc/examples/mtapi/mtapi_network_c_action_function-snippet.h new file mode 100644 index 0000000..9f56102 --- /dev/null +++ b/doc/examples/mtapi/mtapi_network_c_action_function-snippet.h @@ -0,0 +1,20 @@ +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(arguments_size / sizeof(float) / 2); + float const * a = reinterpret_cast(arguments); + float const * b = reinterpret_cast(arguments)+elements; + float * c = reinterpret_cast(result_buffer); + float const * d = reinterpret_cast(node_local_data); + for (int ii = 0; ii < elements; ii++) { + c[ii] = a[ii] + b[ii] + d[0]; + } +} diff --git a/doc/examples/mtapi/mtapi_network_c_header-snippet.h b/doc/examples/mtapi/mtapi_network_c_header-snippet.h new file mode 100644 index 0000000..c052390 --- /dev/null +++ b/doc/examples/mtapi/mtapi_network_c_header-snippet.h @@ -0,0 +1 @@ +#include diff --git a/doc/examples/mtapi/mtapi_network_c_local_action_create-snippet.h b/doc/examples/mtapi/mtapi_network_c_local_action_create-snippet.h new file mode 100644 index 0000000..c057151 --- /dev/null +++ b/doc/examples/mtapi/mtapi_network_c_local_action_create-snippet.h @@ -0,0 +1,6 @@ + network_action = mtapi_network_action_create( + NETWORK_DOMAIN, + NETWORK_LOCAL_JOB, + NETWORK_REMOTE_JOB, + "127.0.0.1", 12345, + &status); diff --git a/doc/examples/mtapi/mtapi_network_c_plugin_finalize-snippet.h b/doc/examples/mtapi/mtapi_network_c_plugin_finalize-snippet.h new file mode 100644 index 0000000..74d49f3 --- /dev/null +++ b/doc/examples/mtapi/mtapi_network_c_plugin_finalize-snippet.h @@ -0,0 +1 @@ + mtapi_network_plugin_finalize(&status); diff --git a/doc/examples/mtapi/mtapi_network_c_plugin_initialize-snippet.h b/doc/examples/mtapi/mtapi_network_c_plugin_initialize-snippet.h new file mode 100644 index 0000000..b7cc83b --- /dev/null +++ b/doc/examples/mtapi/mtapi_network_c_plugin_initialize-snippet.h @@ -0,0 +1,2 @@ + mtapi_network_plugin_initialize("127.0.0.1", 12345, 5, + kElements * 4 * 3 + 32, &status); diff --git a/doc/examples/mtapi/mtapi_network_c_remote_action_create-snippet.h b/doc/examples/mtapi/mtapi_network_c_remote_action_create-snippet.h new file mode 100644 index 0000000..31fa6ac --- /dev/null +++ b/doc/examples/mtapi/mtapi_network_c_remote_action_create-snippet.h @@ -0,0 +1,7 @@ + float node_remote = 1.0f; + local_action = mtapi_action_create( + NETWORK_REMOTE_JOB, + AddVectorAction, + &node_remote, sizeof(float), + MTAPI_DEFAULT_ACTION_ATTRIBUTES, + &status); diff --git a/doc/examples/mtapi/mtapi_opencl_c_action_create-snippet.h b/doc/examples/mtapi/mtapi_opencl_c_action_create-snippet.h new file mode 100644 index 0000000..c3927a4 --- /dev/null +++ b/doc/examples/mtapi/mtapi_opencl_c_action_create-snippet.h @@ -0,0 +1,6 @@ + float node_local = 1.0f; + action = mtapi_opencl_action_create( + OPENCL_JOB, + kernel, "AddVector", 32, 4, + &node_local, sizeof(float), + &status); diff --git a/doc/examples/mtapi/mtapi_opencl_c_header-snippet.h b/doc/examples/mtapi/mtapi_opencl_c_header-snippet.h new file mode 100644 index 0000000..1d3a916 --- /dev/null +++ b/doc/examples/mtapi/mtapi_opencl_c_header-snippet.h @@ -0,0 +1 @@ +#include diff --git a/doc/examples/mtapi/mtapi_opencl_c_kernel-snippet.h b/doc/examples/mtapi/mtapi_opencl_c_kernel-snippet.h new file mode 100644 index 0000000..cfd3e99 --- /dev/null +++ b/doc/examples/mtapi/mtapi_opencl_c_kernel-snippet.h @@ -0,0 +1,18 @@ +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"; diff --git a/doc/examples/mtapi/mtapi_opencl_c_plugin_finalize-snippet.h b/doc/examples/mtapi/mtapi_opencl_c_plugin_finalize-snippet.h new file mode 100644 index 0000000..8689937 --- /dev/null +++ b/doc/examples/mtapi/mtapi_opencl_c_plugin_finalize-snippet.h @@ -0,0 +1 @@ + mtapi_opencl_plugin_finalize(&status); diff --git a/doc/examples/mtapi/mtapi_opencl_c_plugin_initialize-snippet.h b/doc/examples/mtapi/mtapi_opencl_c_plugin_initialize-snippet.h new file mode 100644 index 0000000..c8106fc --- /dev/null +++ b/doc/examples/mtapi/mtapi_opencl_c_plugin_initialize-snippet.h @@ -0,0 +1 @@ + mtapi_opencl_plugin_initialize(&status); diff --git a/doc/reference/Doxyfile.in b/doc/reference/Doxyfile.in index 45b37c5..76fc226 100644 --- a/doc/reference/Doxyfile.in +++ b/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 \ diff --git a/doc/tutorial/content/dataflow.tex b/doc/tutorial/content/dataflow.tex index 7d09e6b..e7a07a1 100644 --- a/doc/tutorial/content/dataflow.tex +++ b/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: % diff --git a/doc/tutorial/content/mtapi.tex b/doc/tutorial/content/mtapi.tex index 956e93a..4b940ce 100644 --- a/doc/tutorial/content/mtapi.tex +++ b/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} +% diff --git a/mtapi_c/include/embb/mtapi/c/mtapi.h b/mtapi_c/include/embb/mtapi/c/mtapi.h index 5347046..65379b8 100644 --- a/mtapi_c/include/embb/mtapi/c/mtapi.h +++ b/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 ---------------------------------------------------- */ diff --git a/mtapi_c/include/embb/mtapi/c/mtapi_ext.h b/mtapi_c/include/embb/mtapi/c/mtapi_ext.h new file mode 100644 index 0000000..b2b4c26 --- /dev/null +++ b/mtapi_c/include/embb/mtapi/c/mtapi_ext.h @@ -0,0 +1,169 @@ +/* + * 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 + + +#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. + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
Error codeDescription
\c MTAPI_ERR_JOB_INVALIDThe \c job_id is not a valid job ID, i.e., no action was created for + * that ID or the action has been deleted.
\c MTAPI_ERR_ACTION_EXISTSThis action is already created.
\c MTAPI_ERR_ACTION_LIMITExceeded maximum number of actions allowed.
\c MTAPI_ERR_NODE_NOTINITThe calling node is not initialized.
+ * + * \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_ diff --git a/mtapi_c/include/mtapi_ext.h b/mtapi_c/include/mtapi_ext.h new file mode 100644 index 0000000..1058ce4 --- /dev/null +++ b/mtapi_c/include/mtapi_ext.h @@ -0,0 +1,34 @@ +/* + * 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 + +#endif // MTAPI_EXT_H_ diff --git a/mtapi_c/src/embb_mtapi_action_plugin_t.c b/mtapi_c/src/embb_mtapi_action_plugin_t.c new file mode 100644 index 0000000..18e0841 --- /dev/null +++ b/mtapi_c/src/embb_mtapi_action_plugin_t.c @@ -0,0 +1,106 @@ +/* + * 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 +#include +#include +#include +#include +#include + +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; +} diff --git a/mtapi_c/src/embb_mtapi_action_t.c b/mtapi_c/src/embb_mtapi_action_t.c index eeeaf83..c062bdd 100644 --- a/mtapi_c/src/embb_mtapi_action_t.c +++ b/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; diff --git a/mtapi_c/src/embb_mtapi_action_t.h b/mtapi_c/src/embb_mtapi_action_t.h index bbe621c..0d6848f 100644 --- a/mtapi_c/src/embb_mtapi_action_t.h +++ b/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 +#include #include #include @@ -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; }; diff --git a/mtapi_c/src/embb_mtapi_node_t.c b/mtapi_c/src/embb_mtapi_node_t.c index 82c70cf..327cd21 100644 --- a/mtapi_c/src/embb_mtapi_node_t.c +++ b/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; diff --git a/mtapi_c/src/embb_mtapi_scheduler_t.c b/mtapi_c/src/embb_mtapi_scheduler_t.c index 28cc5ce..acae760 100644 --- a/mtapi_c/src/embb_mtapi_scheduler_t.c +++ b/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(); diff --git a/mtapi_c/src/embb_mtapi_task_t.c b/mtapi_c/src/embb_mtapi_task_t.c index 7f0c27f..e2f47dd 100644 --- a/mtapi_c/src/embb_mtapi_task_t.c +++ b/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,14 +262,28 @@ 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); - was_scheduled = MTAPI_TRUE; + 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++) { - was_scheduled = was_scheduled & - embb_mtapi_scheduler_schedule_task(scheduler, task, 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) { @@ -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); - local_status = MTAPI_SUCCESS; + + /* 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; } diff --git a/mtapi_c/src/mtapi_task_attributes_t.c b/mtapi_c/src/mtapi_task_attributes_t.c index 4962bd8..43d9004 100644 --- a/mtapi_c/src/mtapi_task_attributes_t.c +++ b/mtapi_c/src/mtapi_task_attributes_t.c @@ -25,6 +25,7 @@ */ #include +#include #include @@ -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; diff --git a/mtapi_c/test/embb_mtapi_test_config.h b/mtapi_c/test/embb_mtapi_test_config.h index b9606fa..fb08d64 100644 --- a/mtapi_c/test/embb_mtapi_test_config.h +++ b/mtapi_c/test/embb_mtapi_test_config.h @@ -29,6 +29,7 @@ #include #include +#include #include diff --git a/mtapi_c/test/embb_mtapi_test_plugin.cc b/mtapi_c/test/embb_mtapi_test_plugin.cc new file mode 100644 index 0000000..2a13fee --- /dev/null +++ b/mtapi_c/test/embb_mtapi_test_plugin.cc @@ -0,0 +1,241 @@ +/* + * 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 +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#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"); +} diff --git a/mtapi_c/test/embb_mtapi_test_plugin.h b/mtapi_c/test/embb_mtapi_test_plugin.h new file mode 100644 index 0000000..57c119a --- /dev/null +++ b/mtapi_c/test/embb_mtapi_test_plugin.h @@ -0,0 +1,40 @@ +/* + * 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 + +class PluginTest : public partest::TestCase { + public: + PluginTest(); + + private: + void TestBasic(); +}; + +#endif // MTAPI_C_TEST_EMBB_MTAPI_TEST_PLUGIN_H_ diff --git a/mtapi_c/test/embb_mtapi_test_task.cc b/mtapi_c/test/embb_mtapi_test_task.cc index bde956f..8d04992 100644 --- a/mtapi_c/test/embb_mtapi_test_task.cc +++ b/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); diff --git a/mtapi_c/test/main.cc b/mtapi_c/test/main.cc index 2c91b7e..a92b25d 100644 --- a/mtapi_c/test/main.cc +++ b/mtapi_c/test/main.cc @@ -31,6 +31,7 @@ #include +#include #include #include #include @@ -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); diff --git a/mtapi_network_c/CMakeLists.txt b/mtapi_network_c/CMakeLists.txt new file mode 100644 index 0000000..c5b8fc2 --- /dev/null +++ b/mtapi_network_c/CMakeLists.txt @@ -0,0 +1,47 @@ +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) diff --git a/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h b/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h new file mode 100644 index 0000000..43385ee --- /dev/null +++ b/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h @@ -0,0 +1,208 @@ +/* + * 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 + + +#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. + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
Error codeDescription
\c MTAPI_ERR_JOB_INVALIDThe \c job_id is not a valid job ID, i.e., no action was created for + * that ID or the action has been deleted.
\c MTAPI_ERR_ACTION_EXISTSThis action is already created.
\c MTAPI_ERR_ACTION_LIMITExceeded maximum number of actions allowed.
\c MTAPI_ERR_NODE_NOTINITThe calling node is not initialized.
\c MTAPI_ERR_UNKNOWNThe remote node could not be reached or there was no local + * interface available.
+ * + * \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_ diff --git a/mtapi_network_c/src/embb_mtapi_network.c b/mtapi_network_c/src/embb_mtapi_network.c new file mode 100644 index 0000000..598fe75 --- /dev/null +++ b/mtapi_network_c/src/embb_mtapi_network.c @@ -0,0 +1,636 @@ +/* + * 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 +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +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; +} diff --git a/mtapi_network_c/src/embb_mtapi_network.h b/mtapi_network_c/src/embb_mtapi_network.h new file mode 100644 index 0000000..cc524f8 --- /dev/null +++ b/mtapi_network_c/src/embb_mtapi_network.h @@ -0,0 +1,46 @@ +/* + * 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 + +#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_ diff --git a/mtapi_network_c/src/embb_mtapi_network_buffer.c b/mtapi_network_c/src/embb_mtapi_network_buffer.c new file mode 100644 index 0000000..399a530 --- /dev/null +++ b/mtapi_network_c/src/embb_mtapi_network_buffer.c @@ -0,0 +1,149 @@ +/* + * 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 +#include +#include + +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; +} diff --git a/mtapi_network_c/src/embb_mtapi_network_buffer.h b/mtapi_network_c/src/embb_mtapi_network_buffer.h new file mode 100644 index 0000000..64d6c13 --- /dev/null +++ b/mtapi_network_c/src/embb_mtapi_network_buffer.h @@ -0,0 +1,106 @@ +/* + * 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 + +#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_ diff --git a/mtapi_network_c/src/embb_mtapi_network_socket.c b/mtapi_network_c/src/embb_mtapi_network_socket.c new file mode 100644 index 0000000..bd9960c --- /dev/null +++ b/mtapi_network_c/src/embb_mtapi_network_socket.c @@ -0,0 +1,253 @@ +/* + * 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 +#include +#include +#ifdef _WIN32 +#include +#else +#define INVALID_SOCKET -1 +#define SOCKET_ERROR -1 +#include +#include +#include +#include +#include +#include +#include +#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); +} diff --git a/mtapi_network_c/src/embb_mtapi_network_socket.h b/mtapi_network_c/src/embb_mtapi_network_socket.h new file mode 100644 index 0000000..7ce7282 --- /dev/null +++ b/mtapi_network_c/src/embb_mtapi_network_socket.h @@ -0,0 +1,104 @@ +/* + * 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 +#include + +#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_ diff --git a/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc b/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc new file mode 100644 index 0000000..bee2217 --- /dev/null +++ b/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc @@ -0,0 +1,68 @@ +/* + * 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 + +#include + +#include + + +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); +} diff --git a/mtapi_network_c/test/embb_mtapi_network_test_buffer.h b/mtapi_network_c/test/embb_mtapi_network_test_buffer.h new file mode 100644 index 0000000..abd34bd --- /dev/null +++ b/mtapi_network_c/test/embb_mtapi_network_test_buffer.h @@ -0,0 +1,40 @@ +/* + * 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 + +class NetworkBufferTest : public partest::TestCase { + public: + NetworkBufferTest(); + + private: + void TestBasic(); +}; + +#endif // MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_BUFFER_H_ diff --git a/mtapi_network_c/test/embb_mtapi_network_test_socket.cc b/mtapi_network_c/test/embb_mtapi_network_test_socket.cc new file mode 100644 index 0000000..8d89104 --- /dev/null +++ b/mtapi_network_c/test/embb_mtapi_network_test_socket.cc @@ -0,0 +1,102 @@ +/* + * 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 + +#include +#include + +#include + + +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); +} diff --git a/mtapi_network_c/test/embb_mtapi_network_test_socket.h b/mtapi_network_c/test/embb_mtapi_network_test_socket.h new file mode 100644 index 0000000..6150a62 --- /dev/null +++ b/mtapi_network_c/test/embb_mtapi_network_test_socket.h @@ -0,0 +1,40 @@ +/* + * 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 + +class NetworkSocketTest : public partest::TestCase { + public: + NetworkSocketTest(); + + private: + void TestBasic(); +}; + +#endif // MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_SOCKET_H_ diff --git a/mtapi_network_c/test/embb_mtapi_network_test_task.cc b/mtapi_network_c/test/embb_mtapi_network_test_task.cc new file mode 100644 index 0000000..cec09a2 --- /dev/null +++ b/mtapi_network_c/test/embb_mtapi_network_test_task.cc @@ -0,0 +1,145 @@ +/* + * 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 + +#include +#include +#include + + +#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(arguments_size / sizeof(float) / 2); + float const * a = reinterpret_cast(arguments); + float const * b = reinterpret_cast(arguments)+elements; + float * c = reinterpret_cast(result_buffer); + float const * d = reinterpret_cast(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(ii); + arguments[ii + kElements] = static_cast(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); +} diff --git a/mtapi_network_c/test/embb_mtapi_network_test_task.h b/mtapi_network_c/test/embb_mtapi_network_test_task.h new file mode 100644 index 0000000..5cfbe8a --- /dev/null +++ b/mtapi_network_c/test/embb_mtapi_network_test_task.h @@ -0,0 +1,40 @@ +/* + * 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 + +class NetworkTaskTest : public partest::TestCase { + public: + NetworkTaskTest(); + + private: + void TestBasic(); +}; + +#endif // MTAPI_NETWORK_C_TEST_EMBB_MTAPI_NETWORK_TEST_TASK_H_ diff --git a/mtapi_network_c/test/main.cc b/mtapi_network_c/test/main.cc new file mode 100644 index 0000000..081cd66 --- /dev/null +++ b/mtapi_network_c/test/main.cc @@ -0,0 +1,37 @@ +/* + * 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 + +#include +#include +#include + +PT_MAIN("MTAPI NETWORK") { + PT_RUN(NetworkBufferTest); + PT_RUN(NetworkSocketTest); + PT_RUN(NetworkTaskTest); +} diff --git a/mtapi_opencl_c/CMakeLists.txt b/mtapi_opencl_c/CMakeLists.txt new file mode 100644 index 0000000..6fe7561 --- /dev/null +++ b/mtapi_opencl_c/CMakeLists.txt @@ -0,0 +1,47 @@ +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) diff --git a/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h b/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h new file mode 100644 index 0000000..b14583a --- /dev/null +++ b/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h @@ -0,0 +1,198 @@ +/* + * 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 + + +#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. + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
Error codeDescription
\c MTAPI_ERR_JOB_INVALIDThe \c job_id is not a valid job ID, i.e., no action was created for + * that ID or the action has been deleted.
\c MTAPI_ERR_ACTION_EXISTSThis action is already created.
\c MTAPI_ERR_ACTION_LIMITExceeded maximum number of actions allowed.
\c MTAPI_ERR_NODE_NOTINITThe calling node is not initialized.
\c MTAPI_ERR_UNKNOWNThe kernel could not be compiled or no OpenCL device was + * available.
+ * + * \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_ diff --git a/mtapi_opencl_c/src/CL/cl.h b/mtapi_opencl_c/src/CL/cl.h new file mode 100644 index 0000000..6d4a6f2 --- /dev/null +++ b/mtapi_opencl_c/src/CL/cl.h @@ -0,0 +1,997 @@ +/******************************************************************************* + * 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 +#else +#include +#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 */ + diff --git a/mtapi_opencl_c/src/CL/cl_ext.h b/mtapi_opencl_c/src/CL/cl_ext.h new file mode 100644 index 0000000..2d6e64e --- /dev/null +++ b/mtapi_opencl_c/src/CL/cl_ext.h @@ -0,0 +1,213 @@ +/******************************************************************************* + * 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 + #include +#else + #include +#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 */ diff --git a/mtapi_opencl_c/src/CL/cl_gl.h b/mtapi_opencl_c/src/CL/cl_gl.h new file mode 100644 index 0000000..6eeae1e --- /dev/null +++ b/mtapi_opencl_c/src/CL/cl_gl.h @@ -0,0 +1,155 @@ +/********************************************************************************** + * 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 +#include +#else +#include +#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 */ diff --git a/mtapi_opencl_c/src/CL/cl_gl_ext.h b/mtapi_opencl_c/src/CL/cl_gl_ext.h new file mode 100644 index 0000000..90996f2 --- /dev/null +++ b/mtapi_opencl_c/src/CL/cl_gl_ext.h @@ -0,0 +1,69 @@ +/********************************************************************************** + * 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 +#else + #include +#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 */ diff --git a/mtapi_opencl_c/src/CL/cl_platform.h b/mtapi_opencl_c/src/CL/cl_platform.h new file mode 100644 index 0000000..337d120 --- /dev/null +++ b/mtapi_opencl_c/src/CL/cl_platform.h @@ -0,0 +1,1198 @@ +/********************************************************************************** + * 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 +#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 + +/* 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 + +/* 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 /* 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 + #else + #include + #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 + #else + #include + #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 + #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 + #else + #include + #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 */ + /* #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 */ diff --git a/mtapi_opencl_c/src/CL/opencl.h b/mtapi_opencl_c/src/CL/opencl.h new file mode 100644 index 0000000..8017299 --- /dev/null +++ b/mtapi_opencl_c/src/CL/opencl.h @@ -0,0 +1,54 @@ +/******************************************************************************* + * 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 +#include +#include +#include + +#else + +#include +#include +#include +#include + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_H */ + diff --git a/mtapi_opencl_c/src/embb_mtapi_opencl.c b/mtapi_opencl_c/src/embb_mtapi_opencl.c new file mode 100644 index 0000000..b503b76 --- /dev/null +++ b/mtapi_opencl_c/src/embb_mtapi_opencl.c @@ -0,0 +1,407 @@ +/* + * 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 +#include +#include + +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +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; +} diff --git a/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c b/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c new file mode 100644 index 0000000..9396a5b --- /dev/null +++ b/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c @@ -0,0 +1,309 @@ +/* + * 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 +#include + +////////////////////////////////////////////////////////////////////////// +// 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 + +#define CHECKEDIMPORT(name) name##_Dynamic = \ + (name##Proc)GetProcAddress(opencl_dll_handle, #name); \ + if (name##_Dynamic == 0) return 0; + +#else + +#include + +#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; +} diff --git a/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h b/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h new file mode 100644 index 0000000..7fc4256 --- /dev/null +++ b/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h @@ -0,0 +1,40 @@ +/* + * 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_ diff --git a/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc b/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc new file mode 100644 index 0000000..83a81e7 --- /dev/null +++ b/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc @@ -0,0 +1,38 @@ +/* + * 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 + +#include + + +LinkerTest::LinkerTest() { + CreateUnit("mtapi opencl linker test").Add(&LinkerTest::TestBasic, this); +} + +void LinkerTest::TestBasic() { + PT_EXPECT(embb_mtapi_opencl_link_at_runtime() != 0); +} diff --git a/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h b/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h new file mode 100644 index 0000000..e8c4a84 --- /dev/null +++ b/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h @@ -0,0 +1,40 @@ +/* + * 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 + +class LinkerTest : public partest::TestCase { + public: + LinkerTest(); + + private: + void TestBasic(); +}; + +#endif // MTAPI_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_LINKER_H_ diff --git a/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc b/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc new file mode 100644 index 0000000..61ddd31 --- /dev/null +++ b/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc @@ -0,0 +1,125 @@ +/* + * 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 + +#include + +#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(ii); + arguments[ii + kElements] = static_cast(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); +} diff --git a/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h b/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h new file mode 100644 index 0000000..ca7545f --- /dev/null +++ b/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h @@ -0,0 +1,40 @@ +/* + * 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 + +class TaskTest : public partest::TestCase { + public: + TaskTest(); + + private: + void TestBasic(); +}; + +#endif // MTAPI_OPENCL_C_TEST_EMBB_MTAPI_OPENCL_TEST_TASK_H_ diff --git a/mtapi_opencl_c/test/main.cc b/mtapi_opencl_c/test/main.cc new file mode 100644 index 0000000..0888cac --- /dev/null +++ b/mtapi_opencl_c/test/main.cc @@ -0,0 +1,36 @@ +/* + * 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 + +#include +#include + + +PT_MAIN("MTAPI OPENCL") { + PT_RUN(LinkerTest); + PT_RUN(TaskTest); +} diff --git a/scripts/run_cpplint.sh b/scripts/run_cpplint.sh index 68a618e..174414f 100755 --- a/scripts/run_cpplint.sh +++ b/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