diff options
| -rw-r--r-- | include/winapi/shmem.hpp | 125 | ||||
| -rw-r--r-- | src/shmem.cpp | 88 | ||||
| -rw-r--r-- | test/unit_tests/shmem.cpp | 72 |
3 files changed, 285 insertions, 0 deletions
diff --git a/include/winapi/shmem.hpp b/include/winapi/shmem.hpp new file mode 100644 index 0000000..0fb2b76 --- /dev/null +++ b/include/winapi/shmem.hpp @@ -0,0 +1,125 @@ +// Copyright (c) 2020 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "winapi-common" project. +// For details, see https://github.com/egor-tensin/winapi-common. +// Distributed under the MIT License. + +#pragma once + +#include "handle.hpp" + +#include <boost/config.hpp> + +#include <cstddef> +#include <memory> +#include <string> +#include <type_traits> +#include <utility> + +namespace winapi { + +class SharedMemory { +public: + static SharedMemory create(const std::string& name, std::size_t nb); + static SharedMemory open(const std::string& name); + + // VS 2013 won't generate these automatically: + SharedMemory(SharedMemory&&) BOOST_NOEXCEPT_OR_NOTHROW; + SharedMemory& operator=(SharedMemory) BOOST_NOEXCEPT_OR_NOTHROW; + void swap(SharedMemory&) BOOST_NOEXCEPT_OR_NOTHROW; + SharedMemory(const SharedMemory&) = delete; + + void* get() const { return m_addr.get(); } + void* ptr() const { return get(); } + +private: + struct Unmap { + void operator()(void*) const; + }; + + SharedMemory() = default; + + SharedMemory(Handle&& handle, void* addr) : m_handle{std::move(handle)}, m_addr{addr} {} + + Handle m_handle; + std::unique_ptr<void, Unmap> m_addr; +}; + +inline void swap(SharedMemory& a, SharedMemory& b) BOOST_NOEXCEPT_OR_NOTHROW { + a.swap(b); +} + +template <typename T> +class SharedObject { +public: + typedef typename std::aligned_storage<sizeof(T), __alignof(T)>::type AlignedType; + + template <typename... Args> + static SharedObject create(const std::string& name, Args&&... args) { + SharedObject obj{SharedMemory::create(name, sizeof(AlignedType))}; + new (obj.ptr()) T(std::forward<Args>(args)...); + obj.m_destruct = true; + return obj; + } + + static SharedObject open(const std::string& name) { + SharedObject obj{SharedMemory::open(name)}; + return obj; + } + + SharedObject(SharedObject&& other) BOOST_NOEXCEPT_OR_NOTHROW + : m_shmem{std::move(other.m_shmem)}, + m_destruct{other.m_destruct} {} + + SharedObject& operator=(SharedObject other) BOOST_NOEXCEPT_OR_NOTHROW { + swap(other); + return *this; + } + + ~SharedObject() { + if (m_destruct && ptr()) { + ptr()->~T(); + } + } + + void swap(SharedObject& other) BOOST_NOEXCEPT_OR_NOTHROW { + using std::swap; + swap(m_shmem, other.m_shmem); + swap(m_destruct, other.m_destruct); + } + + T* ptr() const { return reinterpret_cast<T*>(m_shmem.ptr()); } + T& get() const { return *ptr(); } + + T* operator->() const { return ptr(); } + T& operator*() const { return get(); } + +private: + explicit SharedObject(SharedMemory&& shmem) : m_shmem{std::move(shmem)} {} + + SharedMemory m_shmem; + // Destruct only once, no matter the number of mappings. + bool m_destruct = false; + + SharedObject(const SharedObject&) = delete; +}; + +template <typename T> +inline void swap(SharedObject<T>& a, SharedObject<T>& b) BOOST_NOEXCEPT_OR_NOTHROW { + a.swap(b); +} + +} // namespace winapi + +namespace std { + +template <> +inline void swap(winapi::SharedMemory& a, winapi::SharedMemory& b) BOOST_NOEXCEPT_OR_NOTHROW { + a.swap(b); +} + +template <typename T> +inline void swap(winapi::SharedObject<T>& a, winapi::SharedObject<T>& b) BOOST_NOEXCEPT_OR_NOTHROW { + a.swap(b); +} + +} // namespace std diff --git a/src/shmem.cpp b/src/shmem.cpp new file mode 100644 index 0000000..552351d --- /dev/null +++ b/src/shmem.cpp @@ -0,0 +1,88 @@ +// Copyright (c) 2020 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "winapi-common" project. +// For details, see https://github.com/egor-tensin/winapi-common. +// Distributed under the MIT License. + +#include <winapi/error.hpp> +#include <winapi/handle.hpp> +#include <winapi/shmem.hpp> +#include <winapi/utf8.hpp> +#include <winapi/utils.hpp> + +#include <boost/config.hpp> + +#include <windows.h> + +#include <cstddef> +#include <cstdint> +#include <string> +#include <utility> + +namespace winapi { +namespace { + +void* do_map(const Handle& mapping, std::size_t nb = 0) { + const auto addr = ::MapViewOfFile(static_cast<HANDLE>(mapping), FILE_MAP_ALL_ACCESS, 0, 0, nb); + + if (addr == NULL) { + throw error::windows(GetLastError(), "MapViewOfFile"); + } + + return addr; +} + +} // namespace + +void SharedMemory::Unmap::operator()(void* ptr) const { + const auto ret = ::UnmapViewOfFile(ptr); + assert(ret); + WINAPI_UNUSED_PARAMETER(ret); +}; + +SharedMemory SharedMemory::create(const std::string& name, std::size_t nb) { + const auto nb64 = static_cast<std::uint64_t>(nb); + static_assert(sizeof(nb64) == 2 * sizeof(DWORD), "sizeof(DWORD) != 32"); + + const auto nb_low = static_cast<DWORD>(nb64); + const auto nb_high = static_cast<DWORD>(nb64 >> 32); + + const auto h_mapping = ::CreateFileMappingW( + INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, nb_high, nb_low, widen(name).c_str()); + + if (h_mapping == NULL) { + throw error::windows(GetLastError(), "CreateFileMappingW"); + } + + Handle mapping{h_mapping}; + const auto addr = do_map(mapping); + return {std::move(mapping), addr}; +} + +SharedMemory SharedMemory::open(const std::string& name) { + const auto h_mapping = ::OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, widen(name).c_str()); + + if (h_mapping == NULL) { + throw error::windows(GetLastError(), "OpenFileMappingW"); + } + + Handle mapping{h_mapping}; + const auto addr = do_map(mapping); + return {std::move(mapping), addr}; +} + +SharedMemory::SharedMemory(SharedMemory&& other) BOOST_NOEXCEPT_OR_NOTHROW { + swap(other); +} + +SharedMemory& SharedMemory::operator=(SharedMemory other) BOOST_NOEXCEPT_OR_NOTHROW { + swap(other); + return *this; +} + +void SharedMemory::swap(SharedMemory& other) BOOST_NOEXCEPT_OR_NOTHROW { + using std::swap; + swap(m_handle, other.m_handle); + swap(m_addr, other.m_addr); +} + +} // namespace winapi diff --git a/test/unit_tests/shmem.cpp b/test/unit_tests/shmem.cpp new file mode 100644 index 0000000..26f1389 --- /dev/null +++ b/test/unit_tests/shmem.cpp @@ -0,0 +1,72 @@ +// Copyright (c) 2020 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "winapi-common" project. +// For details, see https://github.com/egor-tensin/winapi-common. +// Distributed under the MIT License. + +#include <winapi/shmem.hpp> + +#include <boost/config.hpp> +#include <boost/test/unit_test.hpp> + +#include <condition_variable> +#include <mutex> +#include <thread> + +using namespace winapi; + +namespace { + +BOOST_CONSTEXPR_OR_CONST auto shmem_name = "test-data-struct"; + +BOOST_CONSTEXPR_OR_CONST int main_data = -1; +BOOST_CONSTEXPR_OR_CONST int setter1_data = 69; +BOOST_CONSTEXPR_OR_CONST int setter2_data = 420; + +struct DataStruct { + std::mutex mtx; + std::condition_variable cv; + int data; +}; + +void setter1_main() { + const auto data_struct = SharedObject<DataStruct>::open(shmem_name); + std::unique_lock<std::mutex> lck{data_struct->mtx}; + BOOST_TEST_MESSAGE(data_struct.ptr()); + + data_struct->cv.wait(lck, [&]() { return data_struct->data == main_data; }); + data_struct->data = setter1_data; + data_struct->cv.notify_all(); +} + +void setter2_main() { + auto data_struct = SharedObject<DataStruct>::open(shmem_name); + std::unique_lock<std::mutex> lck{data_struct->mtx}; + BOOST_TEST_MESSAGE(data_struct.ptr()); + + data_struct->cv.wait(lck, [&]() { return data_struct->data == setter1_data; }); + data_struct->data = setter2_data; + data_struct->cv.notify_all(); +} + +} // namespace + +BOOST_AUTO_TEST_SUITE(shmem_tests) + +BOOST_AUTO_TEST_CASE(basic) { + auto data_struct = SharedObject<DataStruct>::create(shmem_name); + + std::thread setter1{&setter1_main}; + std::thread setter2{&setter2_main}; + { + std::lock_guard<std::mutex> lck{data_struct->mtx}; + data_struct->data = main_data; + } + data_struct->cv.notify_all(); + + setter1.join(); + setter2.join(); + + BOOST_TEST(data_struct->data == setter2_data); +} + +BOOST_AUTO_TEST_SUITE_END() |