Commit e2aeef31 by Marcus Winter

mtapi_cpp_ext: first revision of lower level mtapi_cpp library

parent a517b341
...@@ -126,6 +126,7 @@ add_subdirectory(base_c) ...@@ -126,6 +126,7 @@ add_subdirectory(base_c)
add_subdirectory(base_cpp) add_subdirectory(base_cpp)
add_subdirectory(mtapi_c) add_subdirectory(mtapi_c)
add_subdirectory(mtapi_cpp) add_subdirectory(mtapi_cpp)
add_subdirectory(mtapi_cpp_ext)
add_subdirectory(containers_cpp) add_subdirectory(containers_cpp)
add_subdirectory(algorithms_cpp) add_subdirectory(algorithms_cpp)
add_subdirectory(dataflow_cpp) add_subdirectory(dataflow_cpp)
......
...@@ -184,6 +184,11 @@ class CoreSet { ...@@ -184,6 +184,11 @@ class CoreSet {
/** [IN] Core set on right-hand side of union operation */ /** [IN] Core set on right-hand side of union operation */
); );
/**
* Provides access to internal representation to use it with C API.
*/
embb_core_set_t const & GetInternal() const { return rep_; }
private: private:
/** /**
* Internal representation of core set. * Internal representation of core set.
......
...@@ -148,7 +148,7 @@ INPUT = "@CMAKE_SOURCE_DIR@/doc/reference/embb.dox" \ ...@@ -148,7 +148,7 @@ INPUT = "@CMAKE_SOURCE_DIR@/doc/reference/embb.dox" \
"@CMAKE_SOURCE_DIR@/containers_cpp/include" \ "@CMAKE_SOURCE_DIR@/containers_cpp/include" \
"@CMAKE_SOURCE_DIR@/dataflow_cpp/include" \ "@CMAKE_SOURCE_DIR@/dataflow_cpp/include" \
"@CMAKE_SOURCE_DIR@/algorithms_cpp/include" \ "@CMAKE_SOURCE_DIR@/algorithms_cpp/include" \
"@CMAKE_SOURCE_DIR@/mtapi_cpp/include" \ "@CMAKE_SOURCE_DIR@/mtapi_cpp_ext/include" \
"@CMAKE_SOURCE_DIR@/base_cpp/include" \ "@CMAKE_SOURCE_DIR@/base_cpp/include" \
"@CMAKE_SOURCE_DIR@/mtapi_c/include" \ "@CMAKE_SOURCE_DIR@/mtapi_c/include" \
"@CMAKE_SOURCE_DIR@/base_c/include" "@CMAKE_SOURCE_DIR@/base_c/include"
......
project (project_mtapi_cpp_ext)
file(GLOB_RECURSE EMBB_MTAPI_CPP_EXT_SOURCES "src/*.cc" "src/*.h")
file(GLOB_RECURSE EMBB_MTAPI_CPP_EXT_HEADERS "include/*.h")
file(GLOB_RECURSE EMBB_MTAPI_CPP_EXT_TEST_SOURCES "test/*.cc" "test/*.h")
if (USE_AUTOMATIC_INITIALIZATION STREQUAL ON)
message("-- Automatic initialization enabled (default)")
set(MTAPI_CPP_AUTOMATIC_INITIALIZE 1)
else()
set(MTAPI_CPP_AUTOMATIC_INITIALIZE 0)
message("-- Automatic initialization disabled")
endif()
message(" (set with command line option -DUSE_AUTOMATIC_INITIALIZATION=ON/OFF)")
# Execute the GroupSources macro
include(${CMAKE_SOURCE_DIR}/CMakeCommon/GroupSourcesMSVC.cmake)
GroupSourcesMSVC(include)
GroupSourcesMSVC(src)
GroupSourcesMSVC(test)
set (EMBB_MTAPI_CPP_EXT_INCLUDE_DIRS "include" "src" "test")
include_directories(${EMBB_MTAPI_CPP_EXT_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/../base_c/include
${CMAKE_CURRENT_BINARY_DIR}/../base_c/include
${CMAKE_CURRENT_SOURCE_DIR}/../base_cpp/include
${CMAKE_CURRENT_BINARY_DIR}/../base_cpp/include
${CMAKE_CURRENT_SOURCE_DIR}/../mtapi_c/include)
add_library (embb_mtapi_cpp_ext ${EMBB_MTAPI_CPP_EXT_SOURCES} ${EMBB_MTAPI_CPP_EXT_HEADERS})
target_link_libraries(embb_mtapi_cpp_ext embb_mtapi_c)
if (BUILD_TESTS STREQUAL ON)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/../partest/include)
add_executable (embb_mtapi_cpp_ext_test ${EMBB_MTAPI_CPP_EXT_TEST_SOURCES})
target_link_libraries(embb_mtapi_cpp_ext_test embb_mtapi_cpp_ext embb_mtapi_c partest
embb_base_cpp embb_base_c ${compiler_libs})
CopyBin(BIN embb_mtapi_cpp_ext_test DEST ${local_install_dir})
endif()
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
DESTINATION include FILES_MATCHING PATTERN "*.h")
install(TARGETS embb_mtapi_cpp_ext DESTINATION lib)
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_ACTION_H_
#define EMBB_MTAPI_ACTION_H_
#include <embb/mtapi_ext/internal/check_status.h>
#include <embb/mtapi_ext/action_attributes.h>
#include <embb/mtapi_ext/job.h>
namespace embb {
namespace mtapi {
/**
* Holds the actual worker function used to execute a Task.
*
* \ingroup CPP_MTAPI_EXT
*/
class Action {
public:
/**
* Constructs an Action.
*/
Action(
mtapi_job_id_t job_id, /**< Job ID the Action belongs to */
mtapi_action_function_t func, /**< The action function */
const void * node_local_data, /**< Node local data available to all
Tasks using this Action */
mtapi_size_t node_local_data_size, /**< Size of node local data */
ActionAttributes const & attributes
/**< Attributes of the Action */
) {
Create(job_id, func, node_local_data, node_local_data_size,
&attributes.GetInternal());
}
/**
* Constructs an Action.
*/
Action(
mtapi_job_id_t job_id, /**< Job ID the Action belongs to */
mtapi_action_function_t func, /**< The action function */
const void * node_local_data, /**< Node local data available to all
Tasks using this Action */
mtapi_size_t node_local_data_size /**< Size of node local data */
) {
Create(job_id, func, node_local_data, node_local_data_size,
MTAPI_DEFAULT_ACTION_ATTRIBUTES);
}
/**
* Constructs an Action.
*/
Action(
mtapi_job_id_t job_id, /**< Job ID the Action belongs to */
mtapi_action_function_t func, /**< The action function */
ActionAttributes const & attributes
/**< Attributes of the Action */
) {
Create(job_id, func, MTAPI_NULL, 0, &attributes.GetInternal());
}
/**
* Constructs an Action.
*/
Action(
mtapi_job_id_t job_id, /**< Job ID the Action belongs to */
mtapi_action_function_t func /**< The action function */
) {
Create(job_id, func, MTAPI_NULL, 0, MTAPI_DEFAULT_ACTION_ATTRIBUTES);
}
/**
* Destroys an Action.
*/
~Action() {
mtapi_action_delete(handle_, MTAPI_INFINITE, MTAPI_NULL);
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns The internal mtapi_action_hndl_t.
*/
mtapi_action_hndl_t GetInternal() const {
return handle_;
}
private:
// no default constructor
Action();
// not copyable
Action(Action const & other);
void operator=(Action const & other);
void Create(
mtapi_job_id_t job_id,
mtapi_action_function_t func,
const void * node_local_data,
mtapi_size_t node_local_data_size,
mtapi_action_attributes_t const * attributes
) {
mtapi_status_t status;
handle_ = mtapi_action_create(job_id, func, node_local_data, node_local_data_size,
attributes, &status);
internal::CheckStatus(status);
}
mtapi_action_hndl_t handle_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_ACTION_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_ACTION_ATTRIBUTES_H_
#define EMBB_MTAPI_ACTION_ATTRIBUTES_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
#include <embb/mtapi_ext/affinity.h>
namespace embb {
namespace mtapi {
/**
* Contains attributes of an Action.
*
* \ingroup CPP_MTAPI_EXT
*/
class ActionAttributes {
public:
/**
* Constructs an ActionAttributes object.
*/
ActionAttributes() {
mtapi_status_t status;
mtapi_actionattr_init(&attributes_, &status);
internal::CheckStatus(status);
}
/**
* Sets the global property of an Action.
* This determines whether the object will be visible across nodes.
*
* \returns Reference to this object.
*/
ActionAttributes & SetGlobal(
bool state /**< The state to set */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_actionattr_set(&attributes_, MTAPI_ACTION_GLOBAL,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the affinity of an Action.
*
* \returns Reference to this object.
*/
ActionAttributes & SetAffinity(
Affinity const & affinity /**< The Affinity to set. */
) {
mtapi_status_t status;
mtapi_affinity_t af = affinity.GetInternal();
mtapi_actionattr_set(&attributes_, MTAPI_ACTION_AFFINITY,
&af, sizeof(af), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the domain shared property of an Action.
* This determines whether the object will be visible across domains.
*
* \returns Reference to this object.
*/
ActionAttributes & SetDomainShared(
bool state /**< The state to set */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_actionattr_set(&attributes_, MTAPI_ACTION_DOMAIN_SHARED,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns A reference to the internal mtapi_action_attributes_t structure.
*/
mtapi_action_attributes_t const & GetInternal() const {
return attributes_;
}
private:
mtapi_action_attributes_t attributes_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_ACTION_ATTRIBUTES_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_AFFINITY_H_
#define EMBB_MTAPI_AFFINITY_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Describes the affinity of an Action or Task to a worker thread of a Node.
*
* \ingroup CPP_MTAPI_EXT
*/
class Affinity {
public:
/**
* Constructs an Affinity object.
*/
Affinity() {
Init(true);
}
/**
* Copies an Affinity object.
*/
Affinity(
Affinity const & other /**< The Affinity to copy from */
)
: affinity_(other.affinity_) {
// empty
}
/**
* Copies an Affinity object.
*/
void operator=(
Affinity const & other /**< The Affinity to copy from */
) {
affinity_ = other.affinity_;
}
/**
* Constructs an Affinity object with the given initial affinity.
* If \c initial_affinity is \c true the Affinity will map to all worker
* threads, otherwise it will map to no worker threads.
*/
Affinity(
bool initial_affinity /**< The initial affinity to set. */
) {
Init(initial_affinity);
}
/**
* Initializes an Affinity object with the given initial affinity.
* If \c initial_affinity is \c true the Affinity will map to all worker
* threads, otherwise it will map to no worker threads.
*/
void Init(
bool initial_affinity /**< The initial affinity to set. */
) {
mtapi_status_t status;
mtapi_boolean_t ia = initial_affinity ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_affinity_init(&affinity_, ia, &status);
internal::CheckStatus(status);
}
/**
* Sets affinity to the given worker.
*/
void Set(
mtapi_uint_t worker, /**< The worker to set affinity to. */
bool state /**< The state of the affinity. */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_affinity_set(&affinity_, worker, st, &status);
internal::CheckStatus(status);
}
/**
* Gets affinity to the given worker.
*
* \returns \c true, if the Affinity maps to the worker, \c false otherwise.
*/
bool Get(
mtapi_uint_t worker /**< The worker to get affinity of. */
) {
mtapi_status_t status;
mtapi_boolean_t state =
mtapi_affinity_get(&affinity_, worker, &status);
internal::CheckStatus(status);
return (state != MTAPI_FALSE) ? true : false;
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns The internal mtapi_affinity_t.
*/
mtapi_affinity_t GetInternal() const {
return affinity_;
}
private:
mtapi_affinity_t affinity_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_AFFINITY_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_GROUP_H_
#define EMBB_MTAPI_GROUP_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/job.h>
#include <embb/mtapi_ext/task.h>
#include <embb/mtapi_ext/task_attributes.h>
#include <embb/mtapi_ext/group_attributes.h>
namespace embb {
namespace base {
class Allocation;
} // namespace base
namespace mtapi {
/**
* Represents a facility to wait for multiple related
* \link Task Tasks\endlink.
*
* \ingroup CPP_MTAPI_EXT
*/
class Group {
public:
/**
* Constructs a Group object with default attributes.
* Requires an initialized Node.
*/
Group() {
Create(MTAPI_GROUP_ID_NONE, MTAPI_DEFAULT_GROUP_ATTRIBUTES);
}
/**
* Constructs a Group object using the given Attributes.
* Requires an initialized Node.
*/
Group(
GroupAttributes const & attr /**< The GroupAttributes to use. */
) {
Create(MTAPI_GROUP_ID_NONE, &attr.GetInternal());
}
/**
* Constructs a Group object with default attributes and the given ID.
* Requires an initialized Node.
*/
Group(
mtapi_group_id_t id /**< A user defined ID of the Group. */
) {
Create(id, MTAPI_DEFAULT_GROUP_ATTRIBUTES);
}
/**
* Constructs a Group object with given attributes and ID.
* Requires an initialized Node.
*/
Group(
mtapi_group_id_t id, /**< A user defined ID of the Group. */
GroupAttributes const & attr /**< The GroupAttributes to use. */
) {
Create(id, &attr.GetInternal());
}
/**
* Destroys a Group object.
*/
~Group() {
// delete the group, ignore status
mtapi_group_delete(handle_, MTAPI_NULL);
}
/**
* Starts a new Task in this Group.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes /**< Attributes of the Task */
) {
return Start(task_id,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal());
}
/**
* Starts a new Task in this Group.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results /**< Pointer to the results. */
) {
return Start(task_id,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES);
}
/**
* Starts a new Task in this Group.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes /**< Attributes of the Task */
) {
return Start(MTAPI_TASK_ID_NONE,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal());
}
/**
* Starts a new Task in this Group.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results /**< Pointer to the results. */
) {
return Start(MTAPI_TASK_ID_NONE,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES);
}
/**
* Waits for any Task in the Group to finish for \c timeout milliseconds and
* retrieves the result buffer given in Start().
* \return The status of the Task that finished execution, \c MTAPI_TIMEOUT
* or \c MTAPI_ERR_*
* \threadsafe
*/
mtapi_status_t WaitAny(
mtapi_timeout_t timeout, /**< [in] Timeout duration in
milliseconds */
void ** result /**< [out] The result buffer given in
Node::Start, Group::Start or
Queue::Enqueue */
) {
mtapi_status_t status;
mtapi_group_wait_any(handle_, result, timeout, &status);
needs_delete_ = status != MTAPI_GROUP_COMPLETED;
return status;
}
/**
* Waits for any Task in the Group to finish and
* retrieves the result buffer given in Start().
* \return The status of the Task that finished execution or \c MTAPI_ERR_*
* \threadsafe
*/
mtapi_status_t WaitAny(
void ** result /**< [out] The result buffer given in
Node::Start, Group::Start or
Queue::Enqueue */
) {
return WaitAny(MTAPI_INFINITE, result);
}
/**
* Waits for any Task in the Group to finish for \c timeout milliseconds.
* \return The status of the Task that finished execution
* \threadsafe
*/
mtapi_status_t WaitAny(
mtapi_timeout_t timeout /**< [in] Timeout duration in
milliseconds */
) {
return WaitAny(timeout, MTAPI_NULL);
}
/**
* Waits for any Task in the Group to finish.
* \return The status of the Task that finished execution
* \threadsafe
*/
mtapi_status_t WaitAny() {
return WaitAny(MTAPI_INFINITE, MTAPI_NULL);
}
/**
* Waits for all Task in the Group to finish for \c timeout milliseconds.
* \return \c MTAPI_SUCCESS, \c MTAPI_TIMEOUT, \c MTAPI_ERR_* or the status
* of any failed Task
* \threadsafe
*/
mtapi_status_t WaitAll(
mtapi_timeout_t timeout /**< [in] Timeout duration in
milliseconds */
) {
mtapi_status_t status;
mtapi_group_wait_all(handle_, timeout, &status);
needs_delete_ = status != MTAPI_SUCCESS;
return status;
}
/**
* Waits for all Task in the Group to finish.
* \return \c MTAPI_SUCCESS, \c MTAPI_TIMEOUT, \c MTAPI_ERR_* or the status
* of any failed Task
* \threadsafe
*/
mtapi_status_t WaitAll() {
return WaitAll(MTAPI_INFINITE);
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns The internal mtapi_group_hndl_t.
*/
mtapi_group_hndl_t GetInternal() const {
return handle_;
}
friend class embb::base::Allocation;
private:
// not copyable
Group(Group const & other);
void operator=(Group const & other);
void Create(
mtapi_group_id_t group_id,
mtapi_group_attributes_t const * attributes
) {
needs_delete_ = false;
mtapi_status_t status;
handle_ = mtapi_group_create(group_id, attributes, &status);
internal::CheckStatus(status);
needs_delete_ = true;
}
Task Start(
mtapi_task_id_t task_id,
mtapi_job_hndl_t job,
const void * arguments,
mtapi_size_t arguments_size,
void * results,
mtapi_size_t results_size,
mtapi_task_attributes_t const * attributes
) {
mtapi_status_t status;
mtapi_task_hndl_t task_hndl =
mtapi_task_start(task_id, job, arguments, arguments_size,
results, results_size, attributes, handle_,
&status);
internal::CheckStatus(status);
return Task(task_hndl);
}
mtapi_group_hndl_t handle_;
bool needs_delete_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_GROUP_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_GROUP_ATTRIBUTES_H_
#define EMBB_MTAPI_GROUP_ATTRIBUTES_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Contains attributes of a Group.
*
* \ingroup CPP_MTAPI_EXT
*/
class GroupAttributes {
public:
/**
* Constructs a GroupAttributes object.
*/
GroupAttributes() {
mtapi_status_t status;
mtapi_groupattr_init(&attributes_, &status);
internal::CheckStatus(status);
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns A reference to the internal mtapi_group_attributes_t structure.
*/
mtapi_group_attributes_t const & GetInternal() const {
return attributes_;
}
private:
mtapi_group_attributes_t attributes_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_GROUP_ATTRIBUTES_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_INTERNAL_CHECK_STATUS_H_
#define EMBB_MTAPI_INTERNAL_CHECK_STATUS_H_
#include <embb/mtapi/c/mtapi.h>
namespace embb {
namespace mtapi {
namespace internal {
void CheckStatus(mtapi_status_t status);
template <typename T>
inline mtapi_size_t SizeOfType() {
return sizeof(T);
}
template <>
inline mtapi_size_t SizeOfType<void>() {
return 0u;
}
} // namespace internal
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_INTERNAL_CHECK_STATUS_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_JOB_H_
#define EMBB_MTAPI_JOB_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Represents a collection of Actions.
*
* \ingroup CPP_MTAPI_EXT
*/
class Job {
public:
/**
* Constructs a Job.
* The Job object will be invalid.
*/
Job() {
handle_.id = 0;
handle_.tag = 0;
}
/**
* Constructs a Job with the given \c job_id and \c domain_id.
* Requires an initialized Node.
*/
Job(
mtapi_job_id_t job_id, /**< Job ID to use. */
mtapi_domain_t domain_id /**< Domain ID to use. */
) {
mtapi_status_t status;
handle_ = mtapi_job_get(job_id, domain_id, &status);
internal::CheckStatus(status);
}
/**
* Copies a Job object.
*/
Job(
Job const & other /**< The Job to copy from */
) : handle_(other.handle_) {
// empty
}
/**
* Copies a Job object.
*/
void operator=(
Job const & other /**< The Job to copy from */
) {
handle_ = other.handle_;
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns The internal mtapi_job_hndl_t.
*/
mtapi_job_hndl_t GetInternal() const {
return handle_;
}
private:
mtapi_job_hndl_t handle_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_GROUP_ATTRIBUTES_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_MTAPI_H_
#define EMBB_MTAPI_MTAPI_H_
/**
* \defgroup CPP_MTAPI_EXT MTAPI EXT
* C++ wrapper around C implementation of MTAPI.
* For a description of the basic concepts, see the
* \ref C_MTAPI "C implementation of MTAPI".
* \ingroup CPP
*/
#include <embb/mtapi_ext/job.h>
#include <embb/mtapi_ext/action.h>
#include <embb/mtapi_ext/group.h>
#include <embb/mtapi_ext/queue.h>
#include <embb/mtapi_ext/task.h>
#include <embb/mtapi_ext/task_context.h>
#include <embb/mtapi_ext/node.h>
#endif // EMBB_MTAPI_MTAPI_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_NODE_H_
#define EMBB_MTAPI_NODE_H_
#include <embb/base/memory_allocation.h>
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/status_exception.h>
#include <embb/mtapi_ext/node_attributes.h>
#include <embb/mtapi_ext/task.h>
#include <embb/mtapi_ext/task_attributes.h>
#include <embb/mtapi_ext/job.h>
namespace embb {
namespace base {
class Allocation;
} // namespace base
namespace mtapi {
/**
* A singleton representing the MTAPI runtime.
*
* \ingroup CPP_MTAPI_EXT
*/
class Node {
public:
/**
* Initializes the runtime singleton using default values:
* - all available cores will be used
* - maximum number of tasks is 1024
* - maximum number of groups is 128
* - maximum number of queues is 16
* - maximum queue capacity is 1024
* - maximum number of priorities is 4.
*
* \notthreadsafe
* \throws ErrorException if the singleton was already initialized or the
* Node could not be initialized.
* \memory Allocates about 200kb of memory.
*/
static void Initialize(
mtapi_domain_t domain_id, /**< [in] The domain id to use */
mtapi_node_t node_id /**< [in] The node id to use */
) {
if (IsInitialized()) {
EMBB_THROW(StatusException,
"MTAPI: node was already initialized.");
}
else {
NodeAttributes attributes; // default attributes
node_instance_ = embb::base::Allocation::New<Node>(
domain_id, node_id, attributes);
}
}
/**
* Initializes the runtime singleton.
* \notthreadsafe
* \throws ErrorException if the singleton was already initialized or the
* Node could not be initialized.
* \memory Allocates some memory depending on the values given.
*/
static void Initialize(
mtapi_domain_t domain_id, /**< [in] The domain id to use */
mtapi_node_t node_id, /**< [in] The node id to use */
NodeAttributes const & attributes /**< [in] Attributes to use */
) {
if (IsInitialized()) {
EMBB_THROW(StatusException,
"MTAPI: node was already initialized.");
}
else {
node_instance_ = embb::base::Allocation::New<Node>(
domain_id, node_id, attributes);
}
}
/**
* Checks if runtime is initialized.
* \return \c true if the Node singleton is already initialized, false
* otherwise
* \waitfree
*/
static bool IsInitialized() {
return NULL != node_instance_;
}
/**
* Gets the instance of the runtime system.
* \return Reference to the Node singleton
* \threadsafe
*/
static Node & GetInstance() {
if (IsInitialized()) {
return *node_instance_;
}
else {
EMBB_THROW(StatusException,
"MTAPI: node is not initialized.");
}
}
/**
* Shuts the runtime system down.
* \throws ErrorException if the singleton is not initialized.
* \notthreadsafe
*/
static void Finalize() {
if (IsInitialized()) {
embb::base::Allocation::Delete(node_instance_);
node_instance_ = NULL;
}
else {
EMBB_THROW(StatusException,
"MTAPI: node is not initialized.");
}
}
/**
* Returns the number of available cores.
* \return The number of available cores
* \waitfree
*/
mtapi_uint_t GetCoreCount() const {
return core_count_;
}
/**
* Returns the number of worker threads.
* \return The number of worker threads.
* \waitfree
*/
mtapi_uint_t GetWorkerThreadCount() const {
return worker_thread_count_;
}
/**
* Starts a new Task.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes /**< Attributes of the Task */
) {
return Start(task_id,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal());
}
/**
* Starts a new Task.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results /**< Pointer to the results. */
) {
return Start(task_id,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES);
}
/**
* Starts a new Task.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes /**< Attributes of the Task */
) {
return Start(MTAPI_TASK_ID_NONE,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal());
}
/**
* Starts a new Task.
*
* \returns The handle to the started Task.
*/
template <typename ARGS, typename RES>
Task Start(
Job const & job, /**< The Job to execute. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results /**< Pointer to the results. */
) {
return Start(MTAPI_TASK_ID_NONE,
job.GetInternal(),
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES);
}
friend class embb::base::Allocation;
private:
// not copyable
Node(Node const & node);
Node const & operator=(Node const & other);
Node(
mtapi_domain_t domain_id,
mtapi_node_t node_id,
NodeAttributes const & attr) {
mtapi_status_t status;
mtapi_info_t info;
mtapi_initialize(domain_id, node_id, &attr.GetInternal(), &info, &status);
needs_finalize_ = status == MTAPI_SUCCESS;
internal::CheckStatus(status);
core_count_ = info.hardware_concurrency;
worker_thread_count_ = embb_core_set_count(
&attr.GetInternal().core_affinity);
}
~Node() {
if (needs_finalize_) {
mtapi_status_t status;
mtapi_finalize(&status);
internal::CheckStatus(status);
}
}
Task Start(
mtapi_task_id_t task_id,
mtapi_job_hndl_t job,
const void * arguments,
mtapi_size_t arguments_size,
void * results,
mtapi_size_t results_size,
mtapi_task_attributes_t const * attributes
) {
mtapi_status_t status;
mtapi_task_hndl_t task_hndl =
mtapi_task_start(task_id, job, arguments, arguments_size,
results, results_size, attributes, MTAPI_GROUP_NONE,
&status);
internal::CheckStatus(status);
return Task(task_hndl);
}
static embb::mtapi::Node * node_instance_;
mtapi_uint_t core_count_;
mtapi_uint_t worker_thread_count_;
bool needs_finalize_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_NODE_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_NODE_ATTRIBUTES_H_
#define EMBB_MTAPI_NODE_ATTRIBUTES_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/base/core_set.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Contains attributes of a Node.
*
* \ingroup CPP_MTAPI_EXT
*/
class NodeAttributes {
public:
/**
* Constructs a NodeAttributes object.
*/
NodeAttributes() {
mtapi_status_t status;
mtapi_nodeattr_init(&attributes_, &status);
internal::CheckStatus(status);
}
/**
* Copies a NodeAttributes object.
*/
NodeAttributes(
NodeAttributes const & other /**< The NodeAttributes to copy. */
)
: attributes_(other.attributes_) {
// empty
}
/**
* Copies a NodeAttributes object.
*/
void operator=(
NodeAttributes const & other /**< The NodeAttributes to copy. */
) {
attributes_ = other.attributes_;
}
NodeAttributes & SetCoreAffinity(embb::base::CoreSet const & cores) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_CORE_AFFINITY,
&cores.GetInternal(), sizeof(embb_core_set_t), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxTasks(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_TASKS,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxActions(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_ACTIONS,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxGroups(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_GROUPS,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxQueues(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_QUEUES,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetQueueLimit(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_QUEUE_LIMIT,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxJobs(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_JOBS,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxActionsPerJob(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_ACTIONS_PER_JOB,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
NodeAttributes & SetMaxPriorities(mtapi_uint_t value) {
mtapi_status_t status;
mtapi_nodeattr_set(&attributes_, MTAPI_NODE_MAX_PRIORITIES,
&value, sizeof(value), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns A reference to the internal mtapi_node_attributes_t structure.
*/
mtapi_node_attributes_t const & GetInternal() const {
return attributes_;
}
private:
mtapi_node_attributes_t attributes_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_NODE_ATTRIBUTES_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_QUEUE_H_
#define EMBB_MTAPI_QUEUE_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/job.h>
#include <embb/mtapi_ext/task.h>
#include <embb/mtapi_ext/group.h>
#include <embb/mtapi_ext/queue_attributes.h>
#include <embb/mtapi_ext/task_attributes.h>
namespace embb {
namespace base {
class Allocation;
} // namespace base
namespace mtapi {
/**
* Allows for stream processing, either ordered or unordered.
*
* \ingroup CPP_MTAPI_EXT
*/
class Queue {
public:
/**
* Constructs a Queue with the given Job and default attributes.
* Requires an initialized Node.
*/
Queue(
Job const & job /**< The Job to use for the Queue. */
) {
Create(MTAPI_QUEUE_ID_NONE, job, MTAPI_DEFAULT_QUEUE_ATTRIBUTES);
}
/**
* Constructs a Queue with the given Job and QueueAttributes.
* Requires an initialized Node.
*/
Queue(
Job const & job, /**< The Job to use for the Queue. */
QueueAttributes const & attr /**< The attributes to use. */
) {
Create(MTAPI_QUEUE_ID_NONE, job, &attr.GetInternal());
}
/**
* Destroys a Queue object.
*/
~Queue() {
mtapi_queue_delete(handle_, MTAPI_INFINITE, MTAPI_NULL);
}
/**
* Enables the Queue. \link Task Tasks \endlink enqueued while the Queue was
* disabled are executed.
* \waitfree
*/
void Enable() {
mtapi_status_t status;
mtapi_queue_enable(handle_, &status);
internal::CheckStatus(status);
}
/**
* Disables the Queue. Running \link Task Tasks \endlink are canceled. The
* Queue waits for the Tasks to finish for \c timout milliseconds.
* \waitfree
*/
void Disable(
mtapi_timeout_t timeout /**< The timeout in milliseconds. */
) {
mtapi_status_t status;
mtapi_queue_disable(handle_, timeout, &status);
internal::CheckStatus(status);
}
/**
* Disables the Queue. Running \link Task Tasks \endlink are canceled. The
* Queue waits for the Tasks to finish.
* \waitfree
*/
void Disable() {
Disable(MTAPI_INFINITE);
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes, /**< Attributes of the Task */
Group const & group /**< The Group to start the Task in */
) {
return Enqueue(task_id,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal(), group.GetInternal());
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
Group const & group /**< The Group to start the Task in */
) {
return Enqueue(task_id,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES, group.GetInternal());
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes /**< Attributes of the Task */
) {
return Enqueue(task_id,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal(), MTAPI_GROUP_NONE);
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
mtapi_task_id_t task_id, /**< A user defined ID of the Task. */
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results /**< Pointer to the results. */
) {
return Enqueue(task_id,
arguments, internal::SizeOfType<ARGS>(),
results, sizeofinternal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES, MTAPI_GROUP_NONE);
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes, /**< Attributes of the Task */
Group const & group /**< The Group to start the Task in */
) {
return Enqueue(MTAPI_TASK_ID_NONE,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal(), group.GetInternal());
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
Group const & group /**< The Group to start the Task in */
) {
return Enqueue(MTAPI_TASK_ID_NONE,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES, group.GetInternal());
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results, /**< Pointer to the results. */
TaskAttributes const & attributes /**< Attributes of the Task */
) {
return Enqueue(MTAPI_TASK_ID_NONE,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
&attributes.GetInternal(), MTAPI_GROUP_NONE);
}
/**
* Enqueues a new Task.
*
* \returns The handle to the enqueued Task.
*/
template <typename ARGS, typename RES>
Task Enqueue(
const ARGS * arguments, /**< Pointer to the arguments. */
RES * results /**< Pointer to the results. */
) {
return Enqueue(MTAPI_TASK_ID_NONE,
arguments, internal::SizeOfType<ARGS>(),
results, internal::SizeOfType<RES>(),
MTAPI_DEFAULT_TASK_ATTRIBUTES, MTAPI_GROUP_NONE);
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns The internal mtapi_queue_hndl_t.
*/
mtapi_queue_hndl_t GetInternal() const {
return handle_;
}
friend class embb::base::Allocation;
private:
// no default constructor
Queue();
// not copyable
Queue(Queue const & other);
void operator=(Queue const & other);
void Create(
mtapi_queue_id_t queue_id,
Job const & job,
mtapi_queue_attributes_t const * attributes
) {
mtapi_status_t status;
handle_ = mtapi_queue_create(queue_id, job.GetInternal(),
attributes, &status);
internal::CheckStatus(status);
}
Task Enqueue(
mtapi_task_id_t task_id,
const void * arguments,
mtapi_size_t arguments_size,
void * results,
mtapi_size_t results_size,
mtapi_task_attributes_t const * attributes,
mtapi_group_hndl_t group
) {
mtapi_status_t status;
mtapi_task_hndl_t task_hndl =
mtapi_task_enqueue(task_id, handle_, arguments, arguments_size,
results, results_size, attributes, group,
&status);
internal::CheckStatus(status);
return Task(task_hndl);
}
mtapi_queue_hndl_t handle_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_QUEUE_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_QUEUE_ATTRIBUTES_H_
#define EMBB_MTAPI_QUEUE_ATTRIBUTES_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Contains attributes of a Queue.
*
* \ingroup CPP_MTAPI_EXT
*/
class QueueAttributes {
public:
/**
* Constructs a QueueAttributes object.
*/
QueueAttributes() {
mtapi_status_t status;
mtapi_queueattr_init(&attributes_, &status);
internal::CheckStatus(status);
}
/**
* Sets the global property of a Queue.
* This determines whether the object will be visible across nodes.
*
* \returns Reference to this object.
*/
QueueAttributes & SetGlobal(
bool state /**< The state to set. */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_queueattr_set(&attributes_, MTAPI_QUEUE_GLOBAL,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the ordered property of a Queue.
* If set to \c true, tasks enqueued will be executed in order.
*
* \returns Reference to this object.
*/
QueueAttributes & SetOrdered(
bool state /**< The state to set. */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_queueattr_set(&attributes_, MTAPI_QUEUE_ORDERED,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the retain property of a Queue.
* If set to \c true, tasks will be retained while a queue is disabled.
* Otherwise the will be canceled.
*
* \returns Reference to this object.
*/
QueueAttributes & SetRetain(
bool state /**< The state to set. */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_queueattr_set(&attributes_, MTAPI_QUEUE_RETAIN,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the domain shared property of a Queue.
* This determines whether the object will be visible across domains.
*
* \returns Reference to this object.
*/
QueueAttributes & SetDomainShared(
bool state /**< The state to set. */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_queueattr_set(&attributes_, MTAPI_QUEUE_DOMAIN_SHARED,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the priority of a Queue.
* The priority influences the order in which tasks are chosen for execution.
*
* \returns Reference to this object.
*/
QueueAttributes & SetPriority(
mtapi_uint_t priority /**< The priority to set. */
) {
mtapi_status_t status;
mtapi_queueattr_set(&attributes_, MTAPI_QUEUE_PRIORITY,
&priority, sizeof(priority), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the limit (capacity) of a Queue.
*
* \returns Reference to this object.
*/
QueueAttributes & SetLimit(
mtapi_uint_t limit /**< The limit to set. */
) {
mtapi_status_t status;
mtapi_queueattr_set(&attributes_, MTAPI_QUEUE_LIMIT,
&limit, sizeof(limit), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns A reference to the internal mtapi_queue_attributes_t structure.
*/
mtapi_queue_attributes_t const & GetInternal() const {
return attributes_;
}
private:
mtapi_queue_attributes_t attributes_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_QUEUE_ATTRIBUTES_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_STATUS_EXCEPTION_H_
#define EMBB_MTAPI_STATUS_EXCEPTION_H_
#include <embb/base/exceptions.h>
namespace embb {
namespace mtapi {
/**
* Represents an MTAPI error state and is thrown by almost all mtapi_cpp
* methods.
*
* \ingroup CPP_MTAPI_EXT
*/
class StatusException : public embb::base::Exception {
public:
/**
* Constructs a StatusException.
*/
explicit StatusException(
const char* message /**< The message to use. */
)
: embb::base::Exception(message) {
// empty
}
/**
* Returns the code of the exception.
*/
virtual int Code() const { return EMBB_ERROR; }
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_STATUS_EXCEPTION_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_TASK_H_
#define EMBB_MTAPI_TASK_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* A Task represents a running Action of a specific Job.
*
* \ingroup CPP_MTAPI_EXT
*/
class Task {
public:
/**
* Constructs an invalid Task.
*/
Task() {
handle_.id = 0;
handle_.tag = 0;
}
/**
* Copies a Task.
*/
Task(
Task const & other /**< The task to copy. */
) : handle_(other.handle_) {
// emtpy
}
/**
* Copies a Task.
*/
void operator=(
Task const & other /**< The task to copy. */
) {
handle_ = other.handle_;
}
/**
* Destroys a Task.
*/
~Task() {
// empty
}
/**
* Waits for Task to finish for \c timeout milliseconds.
* \return The status of the finished Task, \c MTAPI_TIMEOUT or
* \c MTAPI_ERR_*
* \threadsafe
*/
mtapi_status_t Wait(
mtapi_timeout_t timeout /**< [in] Timeout duration in
milliseconds */
) {
mtapi_status_t status;
mtapi_task_wait(handle_, timeout, &status);
return status;
}
/**
* Waits for Task to finish.
* \return The status of the finished Task or \c MTAPI_ERR_*
* \threadsafe
*/
mtapi_status_t Wait() {
mtapi_status_t status;
mtapi_task_wait(handle_, MTAPI_INFINITE, &status);
return status;
}
/**
* Signals the Task to cancel computation.
* \waitfree
*/
void Cancel() {
mtapi_status_t status;
mtapi_task_cancel(handle_, &status);
internal::CheckStatus(status);
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns The internal mtapi_task_hndl_t.
*/
mtapi_task_hndl_t GetInternal() const {
return handle_;
}
private:
Task(mtapi_task_hndl_t handle)
: handle_(handle) {
// empty
}
mtapi_task_hndl_t handle_;
friend class Node;
friend class Group;
friend class Queue;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_TASK_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_TASK_ATTRIBUTES_H_
#define EMBB_MTAPI_TASK_ATTRIBUTES_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Contains attributes of a Task.
*
* \ingroup CPP_MTAPI_EXT
*/
class TaskAttributes {
public:
/**
* Constructs a TaskAttributes object.
*/
TaskAttributes() {
mtapi_status_t status;
mtapi_taskattr_init(&attributes_, &status);
internal::CheckStatus(status);
}
/**
* Sets the detached property of a Task.
* If set to \c true, the started Task will have no handle and cannot be
* waited for.
*
* \returns Reference to this object.
*/
TaskAttributes & SetDetached(
bool state /**< The state to set. */
) {
mtapi_status_t status;
mtapi_boolean_t st = state ? MTAPI_TRUE : MTAPI_FALSE;
mtapi_taskattr_set(&attributes_, MTAPI_TASK_DETACHED,
&st, sizeof(st), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the priority of a Task.
* The priority influences the order in which tasks are chosen for execution.
*
* \returns Reference to this object.
*/
TaskAttributes & SetPriority(
mtapi_uint_t priority /**< The priority to set. */
) {
mtapi_status_t status;
mtapi_taskattr_set(&attributes_, MTAPI_TASK_PRIORITY,
&priority, sizeof(priority), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Sets the number of instances in a Task.
* The Task will be launched \c instances times. In the action function,
* the number of instances and the current instance can be queried from
* the TaskContext.
*
* \returns Reference to this object.
*/
TaskAttributes & SetInstances(
mtapi_uint_t instances /**< Number of instances to set. */
) {
mtapi_status_t status;
mtapi_taskattr_set(&attributes_, MTAPI_TASK_INSTANCES,
&instances, sizeof(instances), &status);
internal::CheckStatus(status);
return *this;
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns A reference to the internal mtapi_task_attributes_t structure.
*/
mtapi_task_attributes_t const & GetInternal() const {
return attributes_;
}
private:
mtapi_task_attributes_t attributes_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_TASK_ATTRIBUTES_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_MTAPI_TASK_CONTEXT_H_
#define EMBB_MTAPI_TASK_CONTEXT_H_
#include <embb/mtapi/c/mtapi.h>
#include <embb/mtapi_ext/internal/check_status.h>
namespace embb {
namespace mtapi {
/**
* Provides information about the status of the currently running Task.
*
* \ingroup CPP_MTAPI_EXT
*/
class TaskContext {
public:
/**
* Constructs a TaskContext from the given C representation.
*/
explicit TaskContext(
mtapi_task_context_t * task_context
/**< The C task context to wrap. */
)
: context_(task_context) {
// empty
}
/**
* Queries whether the Task running in the TaskContext should finish.
* \return \c true if the Task should finish, otherwise \c false
* \notthreadsafe
*/
bool ShouldCancel() {
return MTAPI_TASK_CANCELLED == GetTaskState();
}
/**
* Queries the current Task state.
* \return The current Task state.
* \notthreadsafe
*/
mtapi_task_state_t GetTaskState() {
mtapi_status_t status;
mtapi_task_state_t result =
mtapi_context_taskstate_get(context_, &status);
internal::CheckStatus(status);
return result;
}
/**
* Queries the index of the worker thread the Task is running on.
* \return The worker thread index the Task is running on
* \notthreadsafe
*/
mtapi_uint_t GetCurrentWorkerNumber() {
mtapi_status_t status;
mtapi_uint_t result = mtapi_context_corenum_get(context_, &status);
internal::CheckStatus(status);
return result;
}
/**
* Queries the current instance of the currently executing Task.
* \return The current instance number
* \notthreadsafe
*/
mtapi_uint_t GetInstanceNumber() {
mtapi_status_t status;
mtapi_uint_t result = mtapi_context_instnum_get(context_, &status);
internal::CheckStatus(status);
return result;
}
/**
* Queries the number of instances of the currently executing Task.
* \return The number of instances
* \notthreadsafe
*/
mtapi_uint_t GetNumberOfInstances() {
mtapi_status_t status;
mtapi_uint_t result = mtapi_context_numinst_get(context_, &status);
internal::CheckStatus(status);
return result;
}
/**
* Sets the return status of the running Task. This will be returned by
* Task::Wait() and is set to \c MTAPI_SUCCESS by default.
* \notthreadsafe
*/
void SetStatus(
mtapi_status_t error_code /**< [in] The status to return by
Task::Wait(), Group::WaitAny(),
Group::WaitAll() */
) {
mtapi_status_t status;
mtapi_context_status_set(context_, error_code, &status);
internal::CheckStatus(status);
}
/**
* Returns the internal representation of this object.
* Allows for interoperability with the C interface.
*
* \returns A pointer to a mtapi_task_context_t.
*/
mtapi_task_context_t * GetInternal() const {
return context_;
}
private:
// no default constructor
TaskContext();
mtapi_task_context_t * context_;
};
} // namespace mtapi
} // namespace embb
#endif // EMBB_MTAPI_TASK_CONTEXT_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <embb/mtapi_ext/task_context.h>
#include <embb/mtapi_ext/internal/check_status.h>
#include <embb/mtapi_ext/status_exception.h>
#include <embb/base/internal/config.h>
namespace embb {
namespace mtapi {
namespace internal {
void CheckStatus(mtapi_status_t status) {
if (MTAPI_SUCCESS != status) {
switch (status) {
case MTAPI_SUCCESS:
case MTAPI_TIMEOUT:
case MTAPI_GROUP_COMPLETED:
// these are no errors
break;
case MTAPI_ERR_NODE_INITIALIZED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: node already initialized.");
break;
case MTAPI_ERR_NODE_NOTINIT:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: node not initialized.");
break;
case MTAPI_ERR_PARAMETER:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: invalid parameter.");
break;
case MTAPI_ERR_CORE_NUM:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: invalid worker number.");
break;
case MTAPI_ERR_RUNTIME_LOADBALANCING_NOTSUPPORTED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: load balancing not supported.");
break;
case MTAPI_ERR_RUNTIME_REMOTETASKS_NOTSUPPORTED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: remote tasks not supported.");
break;
case MTAPI_ERR_ARG_NOT_IMPLEMENTED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: argument not implemented.");
break;
case MTAPI_ERR_FUNC_NOT_IMPLEMENTED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: function not implemented.");
break;
case MTAPI_ERR_WAIT_PENDING:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: wait pending.");
break;
case MTAPI_ERR_ARG_SIZE:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: argument size mismatch.");
break;
case MTAPI_ERR_RESULT_SIZE:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: result buffer size mismatch.");
break;
case MTAPI_ERR_BUFFER_SIZE:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: buffer size mismatch.");
break;
case MTAPI_ERR_GROUP_LIMIT:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: group limit exceeded.");
break;
case MTAPI_ERR_GROUP_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: group invalid.");
break;
case MTAPI_ERR_QUEUE_LIMIT:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: queue limit exceeded.");
break;
case MTAPI_ERR_QUEUE_DISABLED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: queue disabled.");
break;
case MTAPI_ERR_QUEUE_DELETED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: queue deleted.");
break;
case MTAPI_ERR_QUEUE_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: queue invalid.");
break;
case MTAPI_ERR_JOB_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: job invalid.");
break;
case MTAPI_ERR_TASK_LIMIT:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: task limit exceeded.");
break;
case MTAPI_ERR_TASK_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: task invalid.");
break;
case MTAPI_ERR_CONTEXT_OUTOFCONTEXT:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: task context used outside of worker thread.");
break;
case MTAPI_ERR_CONTEXT_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: task context invalid.");
break;
case MTAPI_ERR_ACTION_DISABLED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action disabled.");
break;
case MTAPI_ERR_ACTION_DELETED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action deleted.");
break;
case MTAPI_ERR_ACTION_CANCELLED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action canceled.");
break;
case MTAPI_ERR_ACTION_FAILED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action failed.");
break;
case MTAPI_ERR_ACTION_LIMIT:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action limit exceeded.");
break;
case MTAPI_ERR_ACTION_EXISTS:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action already exists.");
break;
case MTAPI_ERR_ACTION_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: action invalid.");
break;
case MTAPI_ERR_DOMAIN_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: domain invalid.");
break;
case MTAPI_ERR_NODE_INVALID:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: node invalid.");
break;
case MTAPI_ERR_NODE_INITFAILED:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: node initialization failed.");
break;
case MTAPI_ERR_ATTR_SIZE:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: attribute size mismatch.");
break;
case MTAPI_ERR_ATTR_NUM:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: invalid attribute.");
break;
case MTAPI_ERR_ATTR_READONLY:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: attribute is read only.");
break;
case MTAPI_ERR_ACTION_NUM_INVALID:
case MTAPI_ERR_UNKNOWN:
default:
EMBB_THROW(embb::mtapi::StatusException,
"MTAPI: unknown error.");
break;
}
}
}
} // namespace internal
} // namespace mtapi
} // namespace embb
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <embb/mtapi_ext/node.h>
namespace embb {
namespace mtapi {
embb::mtapi::Node * embb::mtapi::Node::node_instance_ = NULL;
} // namespace mtapi
} // namespace embb
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <partest/partest.h>
#include <embb/base/c/thread.h>
#include <mtapi_cpp_test_task.h>
#include <mtapi_cpp_test_group.h>
#include <mtapi_cpp_test_queue.h>
PT_MAIN("MTAPI C++") {
embb_thread_set_max_count(1024);
PT_RUN(TaskTest);
PT_RUN(GroupTest);
PT_RUN(QueueTest);
}
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MTAPI_CPP_TEST_MTAPI_CPP_TEST_CONFIG_H_
#define MTAPI_CPP_TEST_MTAPI_CPP_TEST_CONFIG_H_
#include <partest/partest.h>
#include <embb/mtapi_ext/mtapi.h>
#define THIS_DOMAIN_ID 1
#define THIS_NODE_ID 1
#endif // MTAPI_CPP_TEST_MTAPI_CPP_TEST_CONFIG_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <mtapi_cpp_test_config.h>
#include <mtapi_cpp_test_group.h>
#include <embb/base/c/memory_allocation.h>
#define JOB_TEST_GROUP 5
#define TASK_COUNT 4
struct result_example_struct {
int value1;
int value2;
};
typedef struct result_example_struct result_example_t;
static void testGroupAction(
const void* args,
mtapi_size_t /*args_size*/,
void* results,
mtapi_size_t /*results_size*/,
const void* /*node_local_data*/,
mtapi_size_t /*node_local_data_size*/,
mtapi_task_context_t * /*context*/) {
result_example_t const * in = static_cast<result_example_t const *>(args);
result_example_t * out = static_cast<result_example_t *>(results);
out->value2 = in->value1;
}
static void testDoSomethingElse() {
}
GroupTest::GroupTest() {
CreateUnit("mtapi_cpp group test").Add(&GroupTest::TestBasic, this);
}
void GroupTest::TestBasic() {
embb::mtapi::Node::Initialize(THIS_DOMAIN_ID, THIS_NODE_ID);
embb::mtapi::Job job(JOB_TEST_GROUP, THIS_DOMAIN_ID);
embb::mtapi::Action action(JOB_TEST_GROUP, testGroupAction);
{
embb::mtapi::Group group;
result_example_t buffer[TASK_COUNT];
for (int ii = 0; ii < TASK_COUNT; ii++) {
buffer[ii].value1 = ii;
buffer[ii].value2 = -1;
group.Start(job, &buffer[ii], &buffer[ii]);
}
testDoSomethingElse();
group.WaitAll();
for (int ii = 0; ii < TASK_COUNT; ii++) {
PT_EXPECT_EQ(buffer[ii].value1, ii);
PT_EXPECT_EQ(buffer[ii].value2, ii);
}
}
{
embb::mtapi::Group group;
result_example_t buffer[TASK_COUNT];
for (int ii = 0; ii < 4; ii++) {
buffer[ii].value1 = ii;
buffer[ii].value2 = -1;
group.Start(job, &buffer[ii], &buffer[ii]);
}
testDoSomethingElse();
mtapi_status_t status;
result_example_t* result;
while (MTAPI_SUCCESS ==
(status = group.WaitAny(reinterpret_cast<void**>(&result)))) {
PT_EXPECT(result != MTAPI_NULL);
PT_EXPECT_EQ(result->value1, result->value2);
}
PT_EXPECT_EQ(status, MTAPI_GROUP_COMPLETED);
}
embb::mtapi::Node::Finalize();
PT_EXPECT_EQ(embb_get_bytes_allocated(), 0u);
}
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MTAPI_CPP_TEST_MTAPI_CPP_TEST_GROUP_H_
#define MTAPI_CPP_TEST_MTAPI_CPP_TEST_GROUP_H_
#include <partest/partest.h>
class GroupTest : public partest::TestCase {
public:
GroupTest();
private:
void TestBasic();
};
#endif // MTAPI_CPP_TEST_MTAPI_CPP_TEST_GROUP_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <mtapi_cpp_test_config.h>
#include <mtapi_cpp_test_queue.h>
#include <embb/base/c/memory_allocation.h>
#define JOB_TEST_QUEUE 42
static void testQueueAction(
const void* /*args*/,
mtapi_size_t /*args_size*/,
void* results,
mtapi_size_t /*results_size*/,
const void* /*node_local_data*/,
mtapi_size_t /*node_local_data_size*/,
mtapi_task_context_t * context) {
embb::mtapi::TaskContext ctx(context);
int * out = reinterpret_cast<int*>(results);
*out = 1;
ctx.SetStatus(MTAPI_ERR_ACTION_CANCELLED);
}
static void testDoSomethingElse() {
}
QueueTest::QueueTest() {
CreateUnit("mtapi_cpp queue test").Add(&QueueTest::TestBasic, this);
}
void QueueTest::TestBasic() {
embb::mtapi::Node::Initialize(THIS_DOMAIN_ID, THIS_NODE_ID);
embb::mtapi::Job job(JOB_TEST_QUEUE, THIS_DOMAIN_ID);
embb::mtapi::Action action(JOB_TEST_QUEUE, testQueueAction,
MTAPI_NULL, 0);
{
embb::mtapi::Queue queue(job);
int result = 0;
embb::mtapi::Task task = queue.Enqueue<void, int>(MTAPI_NULL, &result);
testDoSomethingElse();
mtapi_status_t status = task.Wait();
PT_EXPECT_EQ(status, MTAPI_ERR_ACTION_CANCELLED);
PT_EXPECT_EQ(result, 1);
}
embb::mtapi::Node::Finalize();
PT_EXPECT_EQ(embb_get_bytes_allocated(), 0u);
}
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MTAPI_CPP_TEST_MTAPI_CPP_TEST_QUEUE_H_
#define MTAPI_CPP_TEST_MTAPI_CPP_TEST_QUEUE_H_
#include <partest/partest.h>
class QueueTest : public partest::TestCase {
public:
QueueTest();
private:
void TestBasic();
};
#endif // MTAPI_CPP_TEST_MTAPI_CPP_TEST_QUEUE_H_
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include <string>
#include <cassert>
#include <mtapi_cpp_test_config.h>
#include <mtapi_cpp_test_task.h>
#include <embb/base/c/memory_allocation.h>
#define JOB_TEST_TASK 42
#define JOB_TEST_ERROR 17
static void testTaskAction(
const void* args,
mtapi_size_t /*args_size*/,
void* results,
mtapi_size_t /*results_size*/,
const void* /*node_local_data*/,
mtapi_size_t /*node_local_data_size*/,
mtapi_task_context_t * context) {
embb::mtapi::TaskContext ctx(context);
const char * msg = static_cast<const char *>(args);
std::string* out = static_cast<std::string*>(results);
*out = msg;
}
static void testErrorAction(
const void* /*args*/,
mtapi_size_t /*args_size*/,
void* /*results*/,
mtapi_size_t /*results_size*/,
const void* /*node_local_data*/,
mtapi_size_t /*node_local_data_size*/,
mtapi_task_context_t * context) {
embb::mtapi::TaskContext ctx(context);
ctx.SetStatus(MTAPI_ERR_ACTION_FAILED);
}
static void testDoSomethingElse() {
}
TaskTest::TaskTest() {
CreateUnit("mtapi_cpp task test").Add(&TaskTest::TestBasic, this);
}
void TaskTest::TestBasic() {
embb::mtapi::Node::Initialize(THIS_DOMAIN_ID, THIS_NODE_ID);
embb::mtapi::Node & node = embb::mtapi::Node::GetInstance();
{
embb::mtapi::NodeAttributes attr;
attr
.SetMaxActions(1024)
.SetMaxActionsPerJob(2)
.SetMaxPriorities(4);
}
{
embb::mtapi::Affinity affinity(false);
PT_EXPECT_EQ(affinity.GetInternal(), 0u);
affinity.Set(0u, true);
PT_EXPECT_EQ(affinity.GetInternal(), 1u);
affinity.Set(1u, true);
PT_EXPECT_EQ(affinity.GetInternal(), 3u);
affinity.Set(0u, false);
PT_EXPECT_EQ(affinity.GetInternal(), 2u);
PT_EXPECT_EQ(affinity.Get(0), false);
PT_EXPECT_EQ(affinity.Get(1), true);
}
{
embb::mtapi::Job job_task(JOB_TEST_TASK, THIS_DOMAIN_ID);
embb::mtapi::Action action_task(JOB_TEST_TASK, testTaskAction);
std::string test;
embb::mtapi::Task task = node.Start(job_task, "simple", &test);
testDoSomethingElse();
mtapi_status_t status = task.Wait();
PT_EXPECT_EQ(status, MTAPI_SUCCESS);
PT_EXPECT(test == "simple");
}
{
embb::mtapi::Job job_error(JOB_TEST_ERROR, THIS_DOMAIN_ID);
embb::mtapi::Action action_error(JOB_TEST_ERROR, testErrorAction, embb::mtapi::ActionAttributes());
std::string test;
embb::mtapi::Task task = node.Start(job_error, "simple", &test);
testDoSomethingElse();
mtapi_status_t status = task.Wait();
PT_EXPECT_EQ(status, MTAPI_ERR_ACTION_FAILED);
}
embb::mtapi::Node::Finalize();
PT_EXPECT_EQ(embb_get_bytes_allocated(), 0u);
}
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MTAPI_CPP_TEST_MTAPI_CPP_TEST_TASK_H_
#define MTAPI_CPP_TEST_MTAPI_CPP_TEST_TASK_H_
#include <partest/partest.h>
class TaskTest : public partest::TestCase {
public:
TaskTest();
private:
void TestBasic();
};
#endif // MTAPI_CPP_TEST_MTAPI_CPP_TEST_TASK_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment