From 173916a83655b3a08eedf3918bc11f709f8f351d Mon Sep 17 00:00:00 2001 From: lucapegolotti Date: Fri, 15 Apr 2016 14:21:11 +0200 Subject: [PATCH] containers_cpp: added abstract test for containers --- containers_cpp/test/blocking_container_test-inl.h | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ containers_cpp/test/blocking_container_test.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 190 insertions(+) create mode 100755 containers_cpp/test/blocking_container_test-inl.h create mode 100755 containers_cpp/test/blocking_container_test.h diff --git a/containers_cpp/test/blocking_container_test-inl.h b/containers_cpp/test/blocking_container_test-inl.h new file mode 100755 index 0000000..b647988 --- /dev/null +++ b/containers_cpp/test/blocking_container_test-inl.h @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2014-2016, Siemens AG. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 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 CONTAINERS_CPP_TEST_BLOCKING_CONTAINER_TEST_INL_H_ +#define CONTAINERS_CPP_TEST_BLOCKING_CONTAINER_TEST_INL_H_ + +#include +#include + +namespace embb { +namespace containers { +namespace test { +template +BlockingContainerTest::BlockingContainerTest() : +n_threads(static_cast + (partest::TestSuite::GetDefaultNumThreads())), + n_iterations(200), + n_container_elements_per_thread(100), + n_container_elements(n_container_elements_per_thread*n_threads), + container(){ + std::cout << "num thread = " << n_threads << std::endl; + CreateUnit("BlockingContainerTestThreadsPushAndPopToGlobalBlockingContainer"). + Pre(&BlockingContainerTest::BlockingContainerTest1_Pre, this). + Add(&BlockingContainerTest::BlockingContainerTest1_ThreadMethod, this, + static_cast(n_threads), + static_cast(n_iterations)). + Post(&BlockingContainerTest::BlockingContainerTest1_Post, this); +} + +template +void BlockingContainerTest::BlockingContainerTest1_Pre() { + embb_internal_thread_index_reset(); + thread_local_vectors = + new std::vector[static_cast(n_threads)]; + + for (int i = 0; i != n_threads; ++i) { + int offset = n_container_elements_per_thread * 2; + + for (int i2 = 0; i2 != n_container_elements_per_thread; ++i2) { + int push_element = i2 + (offset*i); + thread_local_vectors[i].push_back(push_element); + expected_container_elements.push_back(push_element); + } + } +} + +template +void BlockingContainerTest::BlockingContainerTest1_Post() { + std::vector produced; + for (int i = 0; i != n_threads; ++i) { + std::vector& loc_elements = thread_local_vectors[i]; + for (std::vector::iterator it = loc_elements.begin(); + it != loc_elements.end(); + ++it) { + produced.push_back(*it); + } + } + + PT_ASSERT(produced.size() == expected_container_elements.size()); + + std::sort(expected_container_elements.begin(), expected_container_elements.end()); + std::sort(produced.begin(), produced.end()); + + for (unsigned int i = 0; + i != static_cast(produced.size()); ++i) { + PT_ASSERT(expected_container_elements[i] == produced[i]); + } + + delete[] thread_local_vectors; +} + +template +void BlockingContainerTest::BlockingContainerTest1_ThreadMethod() { + unsigned int thread_index; + int return_val = embb_internal_thread_index(&thread_index); + + PT_ASSERT(EMBB_SUCCESS == return_val); + + std::vector& my_elements = thread_local_vectors[thread_index]; + + for (std::vector::iterator it = my_elements.begin(); + it != my_elements.end(); + ++it) { + SpecializezdPush(*it); + } + + my_elements.clear(); + + for (int i = 0; i != n_container_elements_per_thread; ++i) { + int return_elem; + SpecializedPop(return_elem); + my_elements.push_back(return_elem); + } +} +} // namespace test +} // namespace containers +} // namespace embb + +#endif // CONTAINERS_CPP_TEST_BLOCKING_CONTAINER_TEST_INL_H_ diff --git a/containers_cpp/test/blocking_container_test.h b/containers_cpp/test/blocking_container_test.h new file mode 100755 index 0000000..2750e54 --- /dev/null +++ b/containers_cpp/test/blocking_container_test.h @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2014-2016, Siemens AG. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 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 CONTAINERS_CPP_TEST_BLOCKING_CONTAINER_TEST_H_ +#define CONTAINERS_CPP_TEST_BLOCKING_CONTAINER_TEST_H_ + +#include +#include +#include + +namespace embb { +namespace containers { +namespace test { +template +class BlockingContainerTest : public partest::TestCase { + private: + int n_threads; + int n_iterations; + int n_container_elements_per_thread; + int n_container_elements; + Container_t container; + std::vector expected_container_elements; + std::vector* thread_local_vectors; + + public: + BlockingContainerTest(); + + void BlockingContainerTest1_Pre(); + + void BlockingContainerTest1_Post(); + + void BlockingContainerTest1_ThreadMethod(); + + protected: + + virtual void SpecializedPush(const int& element) = 0; + + virtual void SpecializedPop(int& element) = 0; +}; +} // namespace test +} // namespace containers +} // namespace embb + +#include "./blocking_container_test-inl.h" + +#endif // CONTAINERS_CPP_TEST_BLOCKING_CONTAINER_TEST_H_ -- libgit2 0.26.0