diff --git a/include/gsl/gsl_thread b/include/gsl/gsl_thread new file mode 100644 index 0000000..d63989f --- /dev/null +++ b/include/gsl/gsl_thread @@ -0,0 +1,103 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2017 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_THREAD_H +#define GSL_THREAD_H + +#include + +#ifdef _MSC_VER + #pragma warning(push) + + // turn off some warnings that are noisy about our Expects statements + #pragma warning(disable : 4127) // conditional expression is constant + + // blanket turn off warnings from CppCoreCheck for now + // so people aren't annoyed by them when running the tool. + // more targeted suppressions will be added in a future update to the GSL + #pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495) +#endif // _MSC_VER + +namespace gsl +{ + +class detached_thread +{ +public: + detached_thread(detached_thread const&) = delete; + + template + explicit detached_thread(Callable&& f, Args&&... args) + : t(std::forward(f), std::forward(args)...) { t.detach(); } + +private: + std::thread t; +}; + +class raii_thread +{ + friend void swap(raii_thread& t1, raii_thread& t2) noexcept; + +public: + raii_thread() noexcept = default; + + raii_thread(raii_thread const&) = delete; + raii_thread(raii_thread&& other): t(std::move(other.t)) {} + + raii_thread(std::thread const&) = delete; + raii_thread(std::thread&& other) noexcept: t(std::move(other)) {} + + raii_thread& operator=(raii_thread const&) = delete; + raii_thread& operator=(raii_thread&& other) noexcept { t = std::move(other.t); return *this; } + + raii_thread& operator=(std::thread const&) = delete; + raii_thread& operator=(std::thread&& other) noexcept { t = std::move(other); return *this; } + + template + explicit raii_thread(Callable&& f, Args&&... args) + : t(std::forward(f), std::forward(args)...) {} + + ~raii_thread() { if(t.joinable()) t.join(); } + + bool joinable() const { return t.joinable(); } + + std::thread::id get_id() const noexcept { return t.get_id(); } + + std::thread::native_handle_type native_handle() { return t.native_handle(); } + + void join() { t.join(); } + + void swap(raii_thread& other) noexcept { using std::swap; swap(t, other.t); } + +private: + std::thread t; +}; + +void swap(raii_thread& t1, raii_thread& t2) noexcept +{ + using std::swap; + swap(t1.t, t2.t); +} + +} // namespace gsl + +#ifdef _MSC_VER + #pragma warning(pop) +#endif // _MSC_VER + +#endif // GSL_THREAD_H diff --git a/tests/thread_tests.cpp b/tests/thread_tests.cpp new file mode 100644 index 0000000..7a552ed --- /dev/null +++ b/tests/thread_tests.cpp @@ -0,0 +1,112 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include + +#include +#include + +namespace +{ + +inline +int random_number(int from, int to) +{ + static std::mutex mtx; + static std::mt19937 mt{std::random_device{}()}; + std::lock_guard lock(mtx); + return std::uniform_int_distribution{from, to}(mt); +} + +SUITE(thread_tests) +{ + class scope_test_fixture + { + public: + scope_test_fixture(): v1(fill( 0, 49)), v2(fill(50, 99)), v3(fill( 0, 99)) {} + + std::mutex mtx; + const std::vector v1; + const std::vector v2; + const std::vector v3; + + private: + std::vector fill(int from, int to) + { + Ensures(from < to); + std::vector v(std::size_t(to - from)); + std::iota(std::begin(v), std::end(v), from); + return v; + } + }; + + TEST(same_scope) + { + scope_test_fixture fixture; + + std::vector v; + + gsl::raii_thread t1{[&]{ + for(auto i: fixture.v1) + { + std::this_thread::sleep_for(std::chrono::milliseconds(random_number(0, 1))); + std::lock_guard lock{fixture.mtx}; + v.push_back(i); + } + }}; + + for(auto i: fixture.v2) + { + std::this_thread::sleep_for(std::chrono::milliseconds(random_number(0, 1))); + std::lock_guard lock{fixture.mtx}; + v.push_back(i); + } + + CHECK(v != fixture.v3); + } + + TEST(different_scope) + { + scope_test_fixture fixture; + + std::vector v; + + { + gsl::raii_thread t1{[&]{ + for(auto i: fixture.v1) + { + std::this_thread::sleep_for(std::chrono::milliseconds(random_number(0, 1))); + std::lock_guard lock{fixture.mtx}; + v.push_back(i); + } + }}; + } + + for(auto i: fixture.v2) + { + std::this_thread::sleep_for(std::chrono::milliseconds(random_number(0, 1))); + std::lock_guard lock{fixture.mtx}; + v.push_back(i); + } + + CHECK(v == fixture.v3); + } +} + +int main(int, const char* []) { return UnitTest::RunAllTests(); }