From 76a87fc471a6283b82ddc1d3e91e43afc28629fa Mon Sep 17 00:00:00 2001 From: Winter Date: Sun, 31 Jan 2016 18:49:38 +0100 Subject: [PATCH] moved mtapi plugins to folder mtapi_plugins_c --- CMakeLists.txt | 4 ++-- doc/examples/CMakeLists.txt | 4 ++-- mtapi_network_c/CMakeLists.txt | 47 ----------------------------------------------- mtapi_network_c/include/embb/mtapi/c/mtapi_network.h | 208 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_network_c/src/embb_mtapi_network.c | 636 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ mtapi_network_c/src/embb_mtapi_network.h | 46 ---------------------------------------------- mtapi_network_c/src/embb_mtapi_network_buffer.c | 149 ----------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_network_c/src/embb_mtapi_network_buffer.h | 106 ---------------------------------------------------------------------------------------------------------- mtapi_network_c/src/embb_mtapi_network_socket.c | 253 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_network_c/src/embb_mtapi_network_socket.h | 104 -------------------------------------------------------------------------------------------------------- mtapi_network_c/test/embb_mtapi_network_test_buffer.cc | 68 -------------------------------------------------------------------- mtapi_network_c/test/embb_mtapi_network_test_buffer.h | 40 ---------------------------------------- mtapi_network_c/test/embb_mtapi_network_test_socket.cc | 102 ------------------------------------------------------------------------------------------------------ mtapi_network_c/test/embb_mtapi_network_test_socket.h | 40 ---------------------------------------- mtapi_network_c/test/embb_mtapi_network_test_task.cc | 145 ------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_network_c/test/embb_mtapi_network_test_task.h | 40 ---------------------------------------- mtapi_network_c/test/main.cc | 37 ------------------------------------- mtapi_opencl_c/CMakeLists.txt | 47 ----------------------------------------------- mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h | 198 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ mtapi_opencl_c/src/CL/cl.h | 997 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/src/CL/cl_ext.h | 213 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/src/CL/cl_gl.h | 155 ----------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/src/CL/cl_gl_ext.h | 70 ---------------------------------------------------------------------- mtapi_opencl_c/src/CL/cl_platform.h | 1198 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/src/CL/opencl.h | 54 ------------------------------------------------------ mtapi_opencl_c/src/embb_mtapi_opencl.c | 407 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c | 309 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h | 40 ---------------------------------------- mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc | 38 -------------------------------------- mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h | 40 ---------------------------------------- mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc | 125 ----------------------------------------------------------------------------------------------------------------------------- mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h | 40 ---------------------------------------- mtapi_opencl_c/test/main.cc | 36 ------------------------------------ mtapi_plugins_c/mtapi_network_c/CMakeLists.txt | 47 +++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.c | 636 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.h | 46 ++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.c | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.h | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.c | 253 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.h | 104 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.h | 40 ++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.cc | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.h | 40 ++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.cc | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.h | 40 ++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_network_c/test/main.cc | 37 +++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/CMakeLists.txt | 47 +++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h | 198 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/CL/cl.h | 997 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_ext.h | 213 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl.h | 155 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl_ext.h | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_platform.h | 1198 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/CL/opencl.h | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl.c | 407 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c | 309 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h | 40 ++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc | 38 ++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h | 40 ++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h | 40 ++++++++++++++++++++++++++++++++++++++++ mtapi_plugins_c/mtapi_opencl_c/test/main.cc | 36 ++++++++++++++++++++++++++++++++++++ 64 files changed, 5992 insertions(+), 5992 deletions(-) delete mode 100644 mtapi_network_c/CMakeLists.txt delete mode 100644 mtapi_network_c/include/embb/mtapi/c/mtapi_network.h delete mode 100644 mtapi_network_c/src/embb_mtapi_network.c delete mode 100644 mtapi_network_c/src/embb_mtapi_network.h delete mode 100644 mtapi_network_c/src/embb_mtapi_network_buffer.c delete mode 100644 mtapi_network_c/src/embb_mtapi_network_buffer.h delete mode 100644 mtapi_network_c/src/embb_mtapi_network_socket.c delete mode 100644 mtapi_network_c/src/embb_mtapi_network_socket.h delete mode 100644 mtapi_network_c/test/embb_mtapi_network_test_buffer.cc delete mode 100644 mtapi_network_c/test/embb_mtapi_network_test_buffer.h delete mode 100644 mtapi_network_c/test/embb_mtapi_network_test_socket.cc delete mode 100644 mtapi_network_c/test/embb_mtapi_network_test_socket.h delete mode 100644 mtapi_network_c/test/embb_mtapi_network_test_task.cc delete mode 100644 mtapi_network_c/test/embb_mtapi_network_test_task.h delete mode 100644 mtapi_network_c/test/main.cc delete mode 100644 mtapi_opencl_c/CMakeLists.txt delete mode 100644 mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h delete mode 100644 mtapi_opencl_c/src/CL/cl.h delete mode 100644 mtapi_opencl_c/src/CL/cl_ext.h delete mode 100644 mtapi_opencl_c/src/CL/cl_gl.h delete mode 100644 mtapi_opencl_c/src/CL/cl_gl_ext.h delete mode 100644 mtapi_opencl_c/src/CL/cl_platform.h delete mode 100644 mtapi_opencl_c/src/CL/opencl.h delete mode 100644 mtapi_opencl_c/src/embb_mtapi_opencl.c delete mode 100644 mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c delete mode 100644 mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h delete mode 100644 mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc delete mode 100644 mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h delete mode 100644 mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc delete mode 100644 mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h delete mode 100644 mtapi_opencl_c/test/main.cc create mode 100644 mtapi_plugins_c/mtapi_network_c/CMakeLists.txt create mode 100644 mtapi_plugins_c/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h create mode 100644 mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.c create mode 100644 mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.h create mode 100644 mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.c create mode 100644 mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.h create mode 100644 mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.c create mode 100644 mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.h create mode 100644 mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc create mode 100644 mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.h create mode 100644 mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.cc create mode 100644 mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.h create mode 100644 mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.cc create mode 100644 mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.h create mode 100644 mtapi_plugins_c/mtapi_network_c/test/main.cc create mode 100644 mtapi_plugins_c/mtapi_opencl_c/CMakeLists.txt create mode 100644 mtapi_plugins_c/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/CL/cl.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_ext.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl_ext.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_platform.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/CL/opencl.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl.c create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c create mode 100644 mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc create mode 100644 mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc create mode 100644 mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h create mode 100644 mtapi_plugins_c/mtapi_opencl_c/test/main.cc diff --git a/CMakeLists.txt b/CMakeLists.txt index c2c316b..98bef9c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -181,9 +181,9 @@ 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_plugins_c/mtapi_network_c) if(OpenCL_FOUND) - add_subdirectory(mtapi_opencl_c) + add_subdirectory(mtapi_plugins_c/mtapi_opencl_c) endif() add_subdirectory(tasks_cpp) add_subdirectory(mtapi_cpp) diff --git a/doc/examples/CMakeLists.txt b/doc/examples/CMakeLists.txt index d68a8a3..a6e0f72 100644 --- a/doc/examples/CMakeLists.txt +++ b/doc/examples/CMakeLists.txt @@ -12,7 +12,7 @@ include_directories( ${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_plugins_c/mtapi_network_c/include ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_cpp/include ${CMAKE_CURRENT_SOURCE_DIR}/../../tasks_cpp/include ${CMAKE_CURRENT_BINARY_DIR}/../../tasks_cpp/include @@ -26,7 +26,7 @@ if(OpenCL_FOUND) add_definitions(-DEMBB_WITH_OPENCL) # add opencl includes include_directories( - ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_opencl_c/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../mtapi_plugins_c/mtapi_opencl_c/include ) # later used, to link opencl to target... set (EMBB_MTAPI_OPENCL_C_CONDITIONAL "embb_mtapi_opencl_c") diff --git a/mtapi_network_c/CMakeLists.txt b/mtapi_network_c/CMakeLists.txt deleted file mode 100644 index c5b8fc2..0000000 --- a/mtapi_network_c/CMakeLists.txt +++ /dev/null @@ -1,47 +0,0 @@ -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 deleted file mode 100644 index 43385ee..0000000 --- a/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h +++ /dev/null @@ -1,208 +0,0 @@ -/* - * 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 deleted file mode 100644 index 598fe75..0000000 --- a/mtapi_network_c/src/embb_mtapi_network.c +++ /dev/null @@ -1,636 +0,0 @@ -/* - * 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 deleted file mode 100644 index cc524f8..0000000 --- a/mtapi_network_c/src/embb_mtapi_network.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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 deleted file mode 100644 index 399a530..0000000 --- a/mtapi_network_c/src/embb_mtapi_network_buffer.c +++ /dev/null @@ -1,149 +0,0 @@ -/* - * 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 deleted file mode 100644 index 64d6c13..0000000 --- a/mtapi_network_c/src/embb_mtapi_network_buffer.h +++ /dev/null @@ -1,106 +0,0 @@ -/* - * 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 deleted file mode 100644 index bd9960c..0000000 --- a/mtapi_network_c/src/embb_mtapi_network_socket.c +++ /dev/null @@ -1,253 +0,0 @@ -/* - * 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 deleted file mode 100644 index 7ce7282..0000000 --- a/mtapi_network_c/src/embb_mtapi_network_socket.h +++ /dev/null @@ -1,104 +0,0 @@ -/* - * 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 deleted file mode 100644 index bee2217..0000000 --- a/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc +++ /dev/null @@ -1,68 +0,0 @@ -/* - * 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 deleted file mode 100644 index abd34bd..0000000 --- a/mtapi_network_c/test/embb_mtapi_network_test_buffer.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 deleted file mode 100644 index 8d89104..0000000 --- a/mtapi_network_c/test/embb_mtapi_network_test_socket.cc +++ /dev/null @@ -1,102 +0,0 @@ -/* - * 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 deleted file mode 100644 index 6150a62..0000000 --- a/mtapi_network_c/test/embb_mtapi_network_test_socket.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 deleted file mode 100644 index cec09a2..0000000 --- a/mtapi_network_c/test/embb_mtapi_network_test_task.cc +++ /dev/null @@ -1,145 +0,0 @@ -/* - * 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 deleted file mode 100644 index 5cfbe8a..0000000 --- a/mtapi_network_c/test/embb_mtapi_network_test_task.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 deleted file mode 100644 index 081cd66..0000000 --- a/mtapi_network_c/test/main.cc +++ /dev/null @@ -1,37 +0,0 @@ -/* - * 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 deleted file mode 100644 index 6fe7561..0000000 --- a/mtapi_opencl_c/CMakeLists.txt +++ /dev/null @@ -1,47 +0,0 @@ -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 deleted file mode 100644 index b14583a..0000000 --- a/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h +++ /dev/null @@ -1,198 +0,0 @@ -/* - * 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 deleted file mode 100644 index 6d4a6f2..0000000 --- a/mtapi_opencl_c/src/CL/cl.h +++ /dev/null @@ -1,997 +0,0 @@ -/******************************************************************************* - * 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 deleted file mode 100644 index 2d6e64e..0000000 --- a/mtapi_opencl_c/src/CL/cl_ext.h +++ /dev/null @@ -1,213 +0,0 @@ -/******************************************************************************* - * 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 deleted file mode 100644 index 6eeae1e..0000000 --- a/mtapi_opencl_c/src/CL/cl_gl.h +++ /dev/null @@ -1,155 +0,0 @@ -/********************************************************************************** - * 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 deleted file mode 100644 index 5555dd1..0000000 --- a/mtapi_opencl_c/src/CL/cl_gl_ext.h +++ /dev/null @@ -1,70 +0,0 @@ -/********************************************************************************** - * 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 deleted file mode 100644 index 337d120..0000000 --- a/mtapi_opencl_c/src/CL/cl_platform.h +++ /dev/null @@ -1,1198 +0,0 @@ -/********************************************************************************** - * 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 deleted file mode 100644 index 8017299..0000000 --- a/mtapi_opencl_c/src/CL/opencl.h +++ /dev/null @@ -1,54 +0,0 @@ -/******************************************************************************* - * 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 deleted file mode 100644 index a4b7e19..0000000 --- a/mtapi_opencl_c/src/embb_mtapi_opencl.c +++ /dev/null @@ -1,407 +0,0 @@ -/* - * 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; - size_t work_group_size; - size_t 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(size_t), &plugin->work_group_size, NULL); - } - if (CL_SUCCESS == err) { - err = clGetDeviceInfo(plugin->device_id, CL_DEVICE_MAX_WORK_ITEM_SIZES, - 3 * sizeof(size_t), &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 deleted file mode 100644 index 9396a5b..0000000 --- a/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c +++ /dev/null @@ -1,309 +0,0 @@ -/* - * 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 deleted file mode 100644 index 7fc4256..0000000 --- a/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 deleted file mode 100644 index 83a81e7..0000000 --- a/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc +++ /dev/null @@ -1,38 +0,0 @@ -/* - * 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 deleted file mode 100644 index e8c4a84..0000000 --- a/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 deleted file mode 100644 index 61ddd31..0000000 --- a/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc +++ /dev/null @@ -1,125 +0,0 @@ -/* - * 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 deleted file mode 100644 index ca7545f..0000000 --- a/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 deleted file mode 100644 index 0888cac..0000000 --- a/mtapi_opencl_c/test/main.cc +++ /dev/null @@ -1,36 +0,0 @@ -/* - * 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/mtapi_plugins_c/mtapi_network_c/CMakeLists.txt b/mtapi_plugins_c/mtapi_network_c/CMakeLists.txt new file mode 100644 index 0000000..a23a903 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h b/mtapi_plugins_c/mtapi_network_c/include/embb/mtapi/c/mtapi_network.h new file mode 100644 index 0000000..43385ee --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/src/embb_mtapi_network.c b/mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.c new file mode 100644 index 0000000..598fe75 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/src/embb_mtapi_network.h b/mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network.h new file mode 100644 index 0000000..cc524f8 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.c b/mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.c new file mode 100644 index 0000000..399a530 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.h b/mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_buffer.h new file mode 100644 index 0000000..64d6c13 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.c b/mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.c new file mode 100644 index 0000000..bd9960c --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.h b/mtapi_plugins_c/mtapi_network_c/src/embb_mtapi_network_socket.h new file mode 100644 index 0000000..7ce7282 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc b/mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.cc new file mode 100644 index 0000000..bee2217 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.h b/mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_buffer.h new file mode 100644 index 0000000..abd34bd --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.cc b/mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.cc new file mode 100644 index 0000000..8d89104 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.h b/mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_socket.h new file mode 100644 index 0000000..6150a62 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.cc b/mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.cc new file mode 100644 index 0000000..cec09a2 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.h b/mtapi_plugins_c/mtapi_network_c/test/embb_mtapi_network_test_task.h new file mode 100644 index 0000000..5cfbe8a --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_network_c/test/main.cc b/mtapi_plugins_c/mtapi_network_c/test/main.cc new file mode 100644 index 0000000..081cd66 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/CMakeLists.txt b/mtapi_plugins_c/mtapi_opencl_c/CMakeLists.txt new file mode 100644 index 0000000..7dd94de --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h b/mtapi_plugins_c/mtapi_opencl_c/include/embb/mtapi/c/mtapi_opencl.h new file mode 100644 index 0000000..b14583a --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/CL/cl.h b/mtapi_plugins_c/mtapi_opencl_c/src/CL/cl.h new file mode 100644 index 0000000..6d4a6f2 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/CL/cl_ext.h b/mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_ext.h new file mode 100644 index 0000000..2d6e64e --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/CL/cl_gl.h b/mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl.h new file mode 100644 index 0000000..6eeae1e --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/CL/cl_gl_ext.h b/mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl_ext.h new file mode 100644 index 0000000..5555dd1 --- /dev/null +++ b/mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_gl_ext.h @@ -0,0 +1,70 @@ +/********************************************************************************** + * 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_plugins_c/mtapi_opencl_c/src/CL/cl_platform.h b/mtapi_plugins_c/mtapi_opencl_c/src/CL/cl_platform.h new file mode 100644 index 0000000..337d120 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/CL/opencl.h b/mtapi_plugins_c/mtapi_opencl_c/src/CL/opencl.h new file mode 100644 index 0000000..8017299 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl.c b/mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl.c new file mode 100644 index 0000000..a4b7e19 --- /dev/null +++ b/mtapi_plugins_c/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; + size_t work_group_size; + size_t 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(size_t), &plugin->work_group_size, NULL); + } + if (CL_SUCCESS == err) { + err = clGetDeviceInfo(plugin->device_id, CL_DEVICE_MAX_WORK_ITEM_SIZES, + 3 * sizeof(size_t), &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_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c b/mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.c new file mode 100644 index 0000000..9396a5b --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h b/mtapi_plugins_c/mtapi_opencl_c/src/embb_mtapi_opencl_runtimelinker.h new file mode 100644 index 0000000..7fc4256 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc b/mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.cc new file mode 100644 index 0000000..83a81e7 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h b/mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_linker.h new file mode 100644 index 0000000..e8c4a84 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc b/mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.cc new file mode 100644 index 0000000..61ddd31 --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h b/mtapi_plugins_c/mtapi_opencl_c/test/embb_mtapi_opencl_test_task.h new file mode 100644 index 0000000..ca7545f --- /dev/null +++ b/mtapi_plugins_c/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_plugins_c/mtapi_opencl_c/test/main.cc b/mtapi_plugins_c/mtapi_opencl_c/test/main.cc new file mode 100644 index 0000000..0888cac --- /dev/null +++ b/mtapi_plugins_c/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); +} -- libgit2 0.26.0