coffee/cpp-ipc
1
0
Fork 0
mirror of https://github.com/mutouyun/cpp-ipc.git synced 2025-12-07 01:06:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: coffee:master
Branches Tags
coffee:master
coffee:feature/memory
coffee:yonker-yk-master
coffee:refactoring
coffee:develop
coffee:v1.3.0
coffee:v1.2.0
coffee:v1.1.1
coffee:v1.1.0
coffee:v1.0.0
..
compare: coffee:v1.2.0
Branches Tags
coffee:master
coffee:feature/memory
coffee:yonker-yk-master
coffee:refactoring
coffee:develop
coffee:v1.3.0
coffee:v1.2.0
coffee:v1.1.1
coffee:v1.1.0
coffee:v1.0.0

No commits in common. "master" and "v1.2.0" have entirely different histories.
master ... v1.2.0

72 changed files with 885 additions and 5783 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -28,7 +28,6 @@ ui_*.h
*.jsc
Makefile*
*build-*
*build_*
# Qt unit tests
target_wrapper.*

4
3rdparty/gtest/src/gtest-death-test.cc vendored
View File

@ -1296,8 +1296,8 @@ static void StackLowerThanAddress(const void* ptr, bool* result) {
GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
static bool StackGrowsDown() {
int dummy {};
bool result {};
int dummy;
bool result;
StackLowerThanAddress(&dummy, &result);
return result;
}

7
CMakeLists.txt
View File

@ -59,13 +59,6 @@ if (LIBIPC_BUILD_DEMOS)
add_subdirectory(demo/chat)
add_subdirectory(demo/msg_que)
add_subdirectory(demo/send_recv)
if (MSVC)
add_subdirectory(demo/win_service/service)
add_subdirectory(demo/win_service/client)
else()
add_subdirectory(demo/linux_service/service)
add_subdirectory(demo/linux_service/client)
endif()
endif()
install(

70
README.md
View File

@ -1,21 +1,22 @@
# cpp-ipc (libipc) - C++ IPC Library
# cpp-ipc(libipc) - C++ IPC Library
[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/mutouyun/cpp-ipc/blob/master/LICENSE)
[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/mutouyun/cpp-ipc/blob/master/LICENSE)
[![Build Status](https://github.com/mutouyun/cpp-ipc/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/mutouyun/cpp-ipc/actions)
[![Build status](https://ci.appveyor.com/api/projects/status/github/mutouyun/cpp-ipc?branch=master&svg=true)](https://ci.appveyor.com/project/mutouyun/cpp-ipc)
[![Vcpkg package](https://img.shields.io/badge/Vcpkg-package-blueviolet)](https://github.com/microsoft/vcpkg/tree/master/ports/cpp-ipc)
## A high-performance inter-process communication library using shared memory on Linux/Windows/FreeBSD.
* Compilers with C++17 support are recommended (msvc-2017/gcc-7/clang-4)
* No other dependencies except STL.
* Only lock-free or lightweight spin-lock is used.
* Circular array is used as the underline data structure.
* `ipc::route` supports single write and multiple read. `ipc::channel` supports multiple read and write. (**Note: currently, a channel supports up to 32 receivers, but there is no such a limit for the sender.**)
* Broadcasting is used by default, but user can choose any read/ write combinations.
* No long time blind wait. (Semaphore will be used after a certain number of retries.)
* [Vcpkg](https://github.com/microsoft/vcpkg/blob/master/README.md) way of installation is supported. E.g. `vcpkg install cpp-ipc`
A high-performance inter-process communication using shared memory on Linux/Windows.
使用共享内存的跨平台（Linux/Windows，x86/x64/ARM）高性能IPC通讯库。
* 推荐支持C++17的编译器（msvc-2017/gcc-7/clang-4）
* 除STL外，无其他依赖
* 无锁（lock-free）或轻量级spin-lock
* 底层数据结构为循环数组（circular array）
* `ipc::route`支持单写多读，`ipc::channel`支持多写多读【**注意：目前同一条通道最多支持32个receiver，sender无限制**】
* 默认采用广播模式收发数据，支持用户任意选择读写方案
* 不会长时间忙等（重试一定次数后会使用信号量进行等待），支持超时
* 支持[Vcpkg](https://github.com/microsoft/vcpkg/blob/master/README_zh_CN.md)方式安装，如`vcpkg install cpp-ipc`
## Usage
See: [Wiki](https://github.com/mutouyun/cpp-ipc/wiki)
@ -30,7 +31,7 @@ See: [Wiki](https://github.com/mutouyun/cpp-ipc/wiki)
OS | Windows 7 Ultimate x64
Compiler | MSVC 2017 15.9.4
Unit & benchmark tests: [test](test)
UT & benchmark test function: [test](test)
Performance data: [performance.xlsx](performance.xlsx)
## Reference
@ -40,42 +41,3 @@ Performance data: [performance.xlsx](performance.xlsx)
* [Lock-Free 编程 | 匠心十年 - 博客园](http://www.cnblogs.com/gaochundong/p/lock_free_programming.html)
* [无锁队列的实现 | 酷 壳 - CoolShell](https://coolshell.cn/articles/8239.html)
* [Implementing Condition Variables with Semaphores](https://www.microsoft.com/en-us/research/wp-content/uploads/2004/12/ImplementingCVs.pdf)
------
## 使用共享内存的跨平台（Linux/Windows/FreeBSD，x86/x64/ARM）高性能IPC通讯库
* 推荐支持C++17的编译器（msvc-2017/gcc-7/clang-4）
* 除STL外，无其他依赖
* 无锁（lock-free）或轻量级spin-lock
* 底层数据结构为循环数组（circular array）
* `ipc::route`支持单写多读，`ipc::channel`支持多写多读【**注意：目前同一条通道最多支持32个receiver，sender无限制**】
* 默认采用广播模式收发数据，支持用户任意选择读写方案
* 不会长时间忙等（重试一定次数后会使用信号量进行等待），支持超时
* 支持[Vcpkg](https://github.com/microsoft/vcpkg/blob/master/README_zh_CN.md)方式安装，如`vcpkg install cpp-ipc`
## 使用方法
详见：[Wiki](https://github.com/mutouyun/cpp-ipc/wiki)
## 性能
| 环境 | 值 |
| -------- | -------------------------------- |
| 设备 | 联想 ThinkPad T450 |
| CPU | 英特尔® Core™ i5-4300U @ 2.5 GHz |
| 内存 | 16 GB |
| 操作系统 | Windows 7 Ultimate x64 |
| 编译器 | MSVC 2017 15.9.4 |
单元测试和Benchmark测试: [test](test)
性能数据: [performance.xlsx](performance.xlsx)
## 参考
* [Lock-Free Data Structures | Dr Dobb's](http://www.drdobbs.com/lock-free-data-structures/184401865)
* [Yet another implementation of a lock-free circular array queue | CodeProject](https://www.codeproject.com/Articles/153898/Yet-another-implementation-of-a-lock-free-circular)
* [Lock-Free 编程 | 匠心十年 - 博客园](http://www.cnblogs.com/gaochundong/p/lock_free_programming.html)
* [无锁队列的实现 | 酷 壳 - CoolShell](https://coolshell.cn/articles/8239.html)
* [Implementing Condition Variables with Semaphores](https://www.microsoft.com/en-us/research/wp-content/uploads/2004/12/ImplementingCVs.pdf)

8
demo/linux_service/client/CMakeLists.txt
View File

@ -1,8 +0,0 @@
project(linux_client)
file(GLOB SRC_FILES ./*.cpp)
file(GLOB HEAD_FILES ./*.h)
add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
target_link_libraries(${PROJECT_NAME} ipc)

28
demo/linux_service/client/main.cpp
View File

@ -1,28 +0,0 @@
/// \brief To create a basic command line program.
#include <stdio.h>
#include <thread>
#include <chrono>
#include "libipc/ipc.h"
int main(int argc, char *argv[]) {
printf("My Sample Client: Entry\n");
ipc::channel ipc_r{"service ipc r", ipc::receiver};
ipc::channel ipc_w{"service ipc w", ipc::sender};
while (1) {
auto msg = ipc_r.recv();
if (msg.empty()) {
printf("My Sample Client: message recv error\n");
return -1;
}
printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
while (!ipc_w.send("Copy.")) {
printf("My Sample Client: message send error\n");
std::this_thread::sleep_for(std::chrono::seconds(1));
}
printf("My Sample Client: message send [Copy]\n");
}
printf("My Sample Client: Exit\n");
return 0;
}

8
demo/linux_service/service/CMakeLists.txt
View File

@ -1,8 +0,0 @@
project(linux_service)
file(GLOB SRC_FILES ./*.cpp)
file(GLOB HEAD_FILES ./*.h)
add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
target_link_libraries(${PROJECT_NAME} ipc)

34
demo/linux_service/service/main.cpp
View File

@ -1,34 +0,0 @@
/// \brief To create a basic command line program.
#include <stdio.h>
#include <string>
#include <thread>
#include <chrono>
#include "libipc/ipc.h"
int main(int argc, char *argv[]) {
printf("My Sample Service: Main: Entry\n");
ipc::channel ipc_r{"service ipc r", ipc::sender};
ipc::channel ipc_w{"service ipc w", ipc::receiver};
while (1) {
if (!ipc_r.send("Hello, World!")) {
printf("My Sample Service: send failed.\n");
}
else {
printf("My Sample Service: send [Hello, World!]\n");
auto msg = ipc_w.recv(1000);
if (msg.empty()) {
printf("My Sample Service: recv error\n");
} else {
printf("%s\n", (std::string{"My Sample Service: recv ["} + msg.get<char const *>() + "]").c_str());
}
}
std::this_thread::sleep_for(std::chrono::seconds(3));
}
printf("My Sample Service: Main: Exit\n");
return 0;
}

8
demo/win_service/client/CMakeLists.txt
View File

@ -1,8 +0,0 @@
project(win_client)
file(GLOB SRC_FILES ./*.cpp)
file(GLOB HEAD_FILES ./*.h)
add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
target_link_libraries(${PROJECT_NAME} ipc)

45
demo/win_service/client/main.cpp
View File

@ -1,45 +0,0 @@
/// \brief To create a basic Windows command line program.
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include <tchar.h>
#include <stdio.h>
#include "libipc/ipc.h"
int _tmain (int argc, TCHAR *argv[]) {
_tprintf(_T("My Sample Client: Entry\n"));
ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::receiver};
ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::sender};
while (1) {
if (!ipc_r.reconnect(ipc::receiver)) {
Sleep(1000);
continue;
}
auto msg = ipc_r.recv();
if (msg.empty()) {
_tprintf(_T("My Sample Client: message recv error\n"));
ipc_r.disconnect();
continue;
}
printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
for (;;) {
if (!ipc_w.reconnect(ipc::sender)) {
Sleep(1000);
continue;
}
if (ipc_w.send("Copy.")) {
break;
}
_tprintf(_T("My Sample Client: message send error\n"));
ipc_w.disconnect();
Sleep(1000);
}
_tprintf(_T("My Sample Client: message send [Copy]\n"));
}
_tprintf(_T("My Sample Client: Exit\n"));
return 0;
}

8
demo/win_service/service/CMakeLists.txt
View File

@ -1,8 +0,0 @@
project(win_service)
file(GLOB SRC_FILES ./*.cpp)
file(GLOB HEAD_FILES ./*.h)
add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
target_link_libraries(${PROJECT_NAME} ipc)

193
demo/win_service/service/main.cpp
View File

@ -1,193 +0,0 @@
/// \brief To create a basic Windows Service in C++.
/// \see https://www.codeproject.com/Articles/499465/Simple-Windows-Service-in-Cplusplus
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include <tchar.h>
#include <string>
#include "libipc/ipc.h"
SERVICE_STATUS g_ServiceStatus = {0};
SERVICE_STATUS_HANDLE g_StatusHandle = NULL;
HANDLE g_ServiceStopEvent = INVALID_HANDLE_VALUE;
VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv);
VOID WINAPI ServiceCtrlHandler (DWORD);
DWORD WINAPI ServiceWorkerThread (LPVOID lpParam);
#define SERVICE_NAME _T("My Sample Service")
int _tmain (int argc, TCHAR *argv[]) {
OutputDebugString(_T("My Sample Service: Main: Entry"));
SERVICE_TABLE_ENTRY ServiceTable[] = {
{SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION) ServiceMain},
{NULL, NULL}
};
if (StartServiceCtrlDispatcher (ServiceTable) == FALSE) {
OutputDebugString(_T("My Sample Service: Main: StartServiceCtrlDispatcher returned error"));
return GetLastError ();
}
OutputDebugString(_T("My Sample Service: Main: Exit"));
return 0;
}
VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv) {
DWORD Status = E_FAIL;
OutputDebugString(_T("My Sample Service: ServiceMain: Entry"));
g_StatusHandle = RegisterServiceCtrlHandler (SERVICE_NAME, ServiceCtrlHandler);
if (g_StatusHandle == NULL) {
OutputDebugString(_T("My Sample Service: ServiceMain: RegisterServiceCtrlHandler returned error"));
goto EXIT;
}
// Tell the service controller we are starting
ZeroMemory (&g_ServiceStatus, sizeof (g_ServiceStatus));
g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
g_ServiceStatus.dwControlsAccepted = 0;
g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
g_ServiceStatus.dwWin32ExitCode = 0;
g_ServiceStatus.dwServiceSpecificExitCode = 0;
g_ServiceStatus.dwCheckPoint = 0;
if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
}
/*
* Perform tasks neccesary to start the service here
*/
OutputDebugString(_T("My Sample Service: ServiceMain: Performing Service Start Operations"));
// Create stop event to wait on later.
g_ServiceStopEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
if (g_ServiceStopEvent == NULL) {
OutputDebugString(_T("My Sample Service: ServiceMain: CreateEvent(g_ServiceStopEvent) returned error"));
g_ServiceStatus.dwControlsAccepted = 0;
g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
g_ServiceStatus.dwWin32ExitCode = GetLastError();
g_ServiceStatus.dwCheckPoint = 1;
if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
}
goto EXIT;
}
// Tell the service controller we are started
g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
g_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
g_ServiceStatus.dwWin32ExitCode = 0;
g_ServiceStatus.dwCheckPoint = 0;
if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
}
// Start the thread that will perform the main task of the service
HANDLE hThread = CreateThread (NULL, 0, ServiceWorkerThread, NULL, 0, NULL);
OutputDebugString(_T("My Sample Service: ServiceMain: Waiting for Worker Thread to complete"));
// Wait until our worker thread exits effectively signaling that the service needs to stop
WaitForSingleObject (hThread, INFINITE);
OutputDebugString(_T("My Sample Service: ServiceMain: Worker Thread Stop Event signaled"));
/*
* Perform any cleanup tasks
*/
OutputDebugString(_T("My Sample Service: ServiceMain: Performing Cleanup Operations"));
CloseHandle (g_ServiceStopEvent);
g_ServiceStatus.dwControlsAccepted = 0;
g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
g_ServiceStatus.dwWin32ExitCode = 0;
g_ServiceStatus.dwCheckPoint = 3;
if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
}
EXIT:
OutputDebugString(_T("My Sample Service: ServiceMain: Exit"));
return;
}
VOID WINAPI ServiceCtrlHandler (DWORD CtrlCode) {
OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: Entry"));
switch (CtrlCode) {
case SERVICE_CONTROL_STOP :
OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SERVICE_CONTROL_STOP Request"));
if (g_ServiceStatus.dwCurrentState != SERVICE_RUNNING)
break;
/*
* Perform tasks neccesary to stop the service here
*/
g_ServiceStatus.dwControlsAccepted = 0;
g_ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
g_ServiceStatus.dwWin32ExitCode = 0;
g_ServiceStatus.dwCheckPoint = 4;
if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SetServiceStatus returned error"));
}
// This will signal the worker thread to start shutting down
SetEvent (g_ServiceStopEvent);
break;
default:
break;
}
OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: Exit"));
}
DWORD WINAPI ServiceWorkerThread (LPVOID lpParam) {
OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Entry"));
ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::sender};
ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::receiver};
// Periodically check if the service has been requested to stop
while (WaitForSingleObject(g_ServiceStopEvent, 0) != WAIT_OBJECT_0) {
/*
* Perform main service function here
*/
if (!ipc_r.send("Hello, World!")) {
OutputDebugString(_T("My Sample Service: send failed."));
}
else {
OutputDebugString(_T("My Sample Service: send [Hello, World!]"));
auto msg = ipc_w.recv(1000);
if (msg.empty()) {
OutputDebugString(_T("My Sample Service: recv error"));
} else {
OutputDebugStringA((std::string{"My Sample Service: recv ["} + msg.get<char const *>() + "]").c_str());
}
}
Sleep(3000);
}
OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Exit"));
return ERROR_SUCCESS;
}

8
include/libipc/buffer.h
View File

@ -17,16 +17,14 @@ public:
buffer();
buffer(void* p, std::size_t s, destructor_t d);
// mem_to_free: pointer to be passed to destructor (if different from p)
// Use case: when p points into a larger allocated block that needs to be freed
buffer(void* p, std::size_t s, destructor_t d, void* mem_to_free);
buffer(void* p, std::size_t s, destructor_t d, void* additional);
buffer(void* p, std::size_t s);
template <std::size_t N>
explicit buffer(byte_t (& data)[N])
explicit buffer(byte_t const (& data)[N])
: buffer(data, sizeof(data)) {
}
explicit buffer(char & c);
explicit buffer(char const & c);
buffer(buffer&& rhs);
~buffer();

3
include/libipc/condition.h
View File

@ -26,9 +26,6 @@ public:
bool open(char const *name) noexcept;
void close() noexcept;
void clear() noexcept;
static void clear_storage(char const * name) noexcept;
bool wait(ipc::sync::mutex &mtx, std::uint64_t tm = ipc::invalid_value) noexcept;
bool notify(ipc::sync::mutex &mtx) noexcept;
bool broadcast(ipc::sync::mutex &mtx) noexcept;

5
include/libipc/def.h
View File

@ -65,9 +65,4 @@ struct relat_trait<wr<Rp, Rc, Ts>> {
template <template <typename> class Policy, typename Flag>
struct relat_trait<Policy<Flag>> : relat_trait<Flag> {};
// the prefix tag of a channel
struct prefix {
char const *str;
};
} // namespace ipc

70
include/libipc/ipc.h
View File

@ -19,26 +19,15 @@ enum : unsigned {
template <typename Flag>
struct IPC_EXPORT chan_impl {
static ipc::handle_t init_first();
static bool connect (ipc::handle_t * ph, char const * name, unsigned mode);
static bool connect (ipc::handle_t * ph, prefix, char const * name, unsigned mode);
static bool reconnect (ipc::handle_t * ph, unsigned mode);
static void disconnect(ipc::handle_t h);
static void destroy (ipc::handle_t h);
static char const * name(ipc::handle_t h);
// Release memory without waiting for the connection to disconnect.
static void release(ipc::handle_t h) noexcept;
// Force cleanup of all shared memory storage that handles depend on.
static void clear(ipc::handle_t h) noexcept;
static void clear_storage(char const * name) noexcept;
static void clear_storage(prefix, char const * name) noexcept;
static std::size_t recv_count (ipc::handle_t h);
static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm);
static std::size_t recv_count(ipc::handle_t h);
static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm);
static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm);
static buff_t recv(ipc::handle_t h, std::uint64_t tm);
@ -52,7 +41,7 @@ class chan_wrapper {
private:
using detail_t = chan_impl<Flag>;
ipc::handle_t h_ = detail_t::init_first();
ipc::handle_t h_ = nullptr;
unsigned mode_ = ipc::sender;
bool connected_ = false;
@ -63,10 +52,6 @@ public:
: connected_{this->connect(name, mode)} {
}
chan_wrapper(prefix pref, char const * name, unsigned mode = ipc::sender)
: connected_{this->connect(pref, name, mode)} {
}
chan_wrapper(chan_wrapper&& rhs) noexcept
: chan_wrapper{} {
swap(rhs);
@ -91,28 +76,6 @@ public:
return detail_t::name(h_);
}
// Release memory without waiting for the connection to disconnect.
void release() noexcept {
detail_t::release(h_);
h_ = nullptr;
}
// Clear shared memory files under opened handle.
void clear() noexcept {
detail_t::clear(h_);
h_ = nullptr;
}
// Clear shared memory files under a specific name.
static void clear_storage(char const * name) noexcept {
detail_t::clear_storage(name);
}
// Clear shared memory files under a specific name with a prefix.
static void clear_storage(prefix pref, char const * name) noexcept {
detail_t::clear_storage(pref, name);
}
ipc::handle_t handle() const noexcept {
return h_;
}
@ -137,11 +100,6 @@ public:
detail_t::disconnect(h_); // clear old connection
return connected_ = detail_t::connect(&h_, name, mode_ = mode);
}
bool connect(prefix pref, char const * name, unsigned mode = ipc::sender | ipc::receiver) {
if (name == nullptr || name[0] == '\0') return false;
detail_t::disconnect(h_); // clear old connection
return connected_ = detail_t::connect(&h_, pref, name, mode_ = mode);
}
/**
* Try connecting with new mode flags.
@ -209,22 +167,26 @@ template <relat Rp, relat Rc, trans Ts>
using chan = chan_wrapper<ipc::wr<Rp, Rc, Ts>>;
/**
* \class route
* class route
*
* \note You could use one producer/server/sender for sending messages to a route,
* then all the consumers/clients/receivers which are receiving with this route,
* would receive your sent messages.
* A route could only be used in 1 to N (one producer/writer to multi consumers/readers).
* You could use one producer/server/sender for sending messages to a route,
* then all the consumers/clients/receivers which are receiving with this route,
* would receive your sent messages.
*
* A route could only be used in 1 to N
* (one producer/writer to multi consumers/readers)
*/
using route = chan<relat::single, relat::multi, trans::broadcast>;
/**
* \class channel
* class channel
*
* \note You could use multi producers/writers for sending messages to a channel,
* then all the consumers/readers which are receiving with this channel,
* would receive your sent messages.
* You could use multi producers/writers for sending messages to a channel,
* then all the consumers/readers which are receiving with this channel,
* would receive your sent messages.
*/
using channel = chan<relat::multi, relat::multi, trans::broadcast>;
} // namespace ipc

3
include/libipc/mutex.h
View File

@ -26,9 +26,6 @@ public:
bool open(char const *name) noexcept;
void close() noexcept;
void clear() noexcept;
static void clear_storage(char const * name) noexcept;
bool lock(std::uint64_t tm = ipc::invalid_value) noexcept;
bool try_lock() noexcept(false); // std::system_error
bool unlock() noexcept;

4
include/libipc/pool_alloc.h
View File

@ -11,8 +11,8 @@ namespace mem {
class IPC_EXPORT pool_alloc {
public:
static void* alloc(std::size_t size) noexcept;
static void free (void* p, std::size_t size) noexcept;
static void* alloc(std::size_t size);
static void free (void* p, std::size_t size);
};
////////////////////////////////////////////////////////////////

9
include/libipc/rw_lock.h
View File

@ -6,7 +6,6 @@
#include <limits>
#include <type_traits>
#include <utility>
#include <cstdint>
////////////////////////////////////////////////////////////////
/// Gives hint to processor that improves performance of spin-wait loops.
@ -99,7 +98,7 @@ inline void sleep(K& k) {
namespace ipc {
class spin_lock {
std::atomic<std::uint32_t> lc_ { 0 };
std::atomic<unsigned> lc_ { 0 };
public:
void lock(void) noexcept {
@ -114,13 +113,13 @@ public:
};
class rw_lock {
using lc_ui_t = std::uint32_t;
using lc_ui_t = unsigned;
std::atomic<lc_ui_t> lc_ { 0 };
enum : lc_ui_t {
w_mask = (std::numeric_limits<std::make_signed_t<lc_ui_t>>::max)(), // b 0111 1111 ...
w_flag = w_mask + 1 // b 1000 0000 ...
w_mask = (std::numeric_limits<std::make_signed_t<lc_ui_t>>::max)(), // b 0111 1111
w_flag = w_mask + 1 // b 1000 0000
};
public:

3
include/libipc/semaphore.h
View File

@ -25,9 +25,6 @@ public:
bool open(char const *name, std::uint32_t count = 0) noexcept;
void close() noexcept;
void clear() noexcept;
static void clear_storage(char const * name) noexcept;
bool wait(std::uint64_t tm = ipc::invalid_value) noexcept;
bool post(std::uint32_t count = 1) noexcept;

32
include/libipc/shm.h
View File

@ -17,31 +17,9 @@ enum : unsigned {
IPC_EXPORT id_t acquire(char const * name, std::size_t size, unsigned mode = create | open);
IPC_EXPORT void * get_mem(id_t id, std::size_t * size);
// Release shared memory resource and clean up disk file if reference count reaches zero.
// This function decrements the reference counter. When the counter reaches zero, it:
// 1. Unmaps the shared memory region
// 2. Removes the backing file from disk (shm_unlink on POSIX)
// 3. Frees the id structure
// After calling this function, the id becomes invalid and must not be used again.
// Returns: The reference count before decrement, or -1 on error.
IPC_EXPORT std::int32_t release(id_t id) noexcept;
// Release shared memory resource and force cleanup of disk file.
// This function calls release(id) internally, then unconditionally attempts to
// remove the backing file. WARNING: Do NOT call this after release(id) on the
// same id, as the id is already freed by release(). Use this function alone,
// not in combination with release().
// Typical use case: Force cleanup when you want to ensure the disk file is removed
// regardless of reference count state.
IPC_EXPORT void remove (id_t id) noexcept;
// Remove shared memory backing file by name.
// This function only removes the disk file and does not affect any active memory
// mappings or id structures. Use this for cleanup of orphaned files or for explicit
// file removal without affecting runtime resources.
// Safe to call at any time, even if shared memory is still in use elsewhere.
IPC_EXPORT void remove (char const * name) noexcept;
IPC_EXPORT std::int32_t release(id_t id);
IPC_EXPORT void remove (id_t id);
IPC_EXPORT void remove (char const * name);
IPC_EXPORT std::int32_t get_ref(id_t id);
IPC_EXPORT void sub_ref(id_t id);
@ -67,10 +45,6 @@ public:
bool acquire(char const * name, std::size_t size, unsigned mode = create | open);
std::int32_t release();
// Clean the handle file.
void clear() noexcept;
static void clear_storage(char const * name) noexcept;
void* get() const;
void attach(id_t);

30
src/CMakeLists.txt
View File

@ -1,7 +1,5 @@
project(ipc)
set (PACKAGE_VERSION 1.3.0)
aux_source_directory(${LIBIPC_PROJECT_DIR}/src/libipc SRC_FILES)
aux_source_directory(${LIBIPC_PROJECT_DIR}/src/libipc/sync SRC_FILES)
aux_source_directory(${LIBIPC_PROJECT_DIR}/src/libipc/platform SRC_FILES)
@ -36,13 +34,11 @@ set_target_properties(${PROJECT_NAME}
# set version
set_target_properties(${PROJECT_NAME}
PROPERTIES
VERSION ${PACKAGE_VERSION}
VERSION 1.2.0
SOVERSION 3)
target_include_directories(${PROJECT_NAME}
PUBLIC
"$<BUILD_INTERFACE:${LIBIPC_PROJECT_DIR}/include>"
"$<INSTALL_INTERFACE:include>"
PUBLIC ${LIBIPC_PROJECT_DIR}/include
PRIVATE ${LIBIPC_PROJECT_DIR}/src
$<$<BOOL:UNIX>:${LIBIPC_PROJECT_DIR}/src/libipc/platform/linux>)
@ -54,28 +50,6 @@ endif()
install(
TARGETS ${PROJECT_NAME}
EXPORT cpp-ipc-targets
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib)
install(EXPORT cpp-ipc-targets
FILE cpp-ipc-targets.cmake
NAMESPACE cpp-ipc::
DESTINATION share/cpp-ipc
)
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/cpp-ipc-config.cmake.in"
[[include(CMakeFindDependencyMacro)
include("${CMAKE_CURRENT_LIST_DIR}/cpp-ipc-targets.cmake")
]])
configure_file("${CMAKE_CURRENT_BINARY_DIR}/cpp-ipc-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cpp-ipc-config.cmake" @ONLY)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cpp-ipc-config.cmake DESTINATION share/cpp-ipc)
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
cppIpcConfigVersion.cmake
VERSION ${PACKAGE_VERSION}
COMPATIBILITY AnyNewerVersion
)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cppIpcConfigVersion.cmake DESTINATION share/cpp-ipc)

8
src/libipc/buffer.cpp
View File

@ -38,16 +38,16 @@ buffer::buffer(void* p, std::size_t s, destructor_t d)
: p_(p_->make(p, s, d, nullptr)) {
}
buffer::buffer(void* p, std::size_t s, destructor_t d, void* mem_to_free)
: p_(p_->make(p, s, d, mem_to_free)) {
buffer::buffer(void* p, std::size_t s, destructor_t d, void* additional)
: p_(p_->make(p, s, d, additional)) {
}
buffer::buffer(void* p, std::size_t s)
: buffer(p, s, nullptr) {
}
buffer::buffer(char & c)
: buffer(&c, 1) {
buffer::buffer(char const & c)
: buffer(const_cast<char*>(&c), 1) {
}
buffer::buffer(buffer&& rhs)

4
src/libipc/circ/elem_array.h
View File

@ -37,8 +37,8 @@ private:
elem_t block_[elem_max] {};
/**
* \remarks 'warning C4348: redefinition of default parameter' with MSVC.
* \see
* @remarks 'warning C4348: redefinition of default parameter' with MSVC.
* @see
* - https://stackoverflow.com/questions/12656239/redefinition-of-default-template-parameter
* - https://developercommunity.visualstudio.com/content/problem/425978/incorrect-c4348-warning-in-nested-template-declara.html
*/

11
src/libipc/circ/elem_def.h
View File

@ -60,7 +60,7 @@ public:
for (unsigned k = 0;; ipc::yield(k)) {
cc_t curr = this->cc_.load(std::memory_order_acquire);
cc_t next = curr | (curr + 1); // find the first 0, and set it to 1.
if (next == curr) {
if (next == 0) {
// connection-slot is full.
return 0;
}
@ -74,10 +74,6 @@ public:
return this->cc_.fetch_and(~cc_id, std::memory_order_acq_rel) & ~cc_id;
}
bool connected(cc_t cc_id) const noexcept {
return (this->connections() & cc_id) != 0;
}
std::size_t conn_count(std::memory_order order = std::memory_order_acquire) const noexcept {
cc_t cur = this->cc_.load(order);
cc_t cnt; // accumulates the total bits set in cc
@ -104,11 +100,6 @@ public:
}
}
bool connected(cc_t cc_id) const noexcept {
// In non-broadcast mode, connection tags are only used for counting.
return (this->connections() != 0) && (cc_id != 0);
}
std::size_t conn_count(std::memory_order order = std::memory_order_acquire) const noexcept {
return this->connections(order);
}

324
src/libipc/ipc.cpp
View File

@ -9,7 +9,6 @@
#include <vector>
#include <array>
#include <cassert>
#include <mutex>
#include "libipc/ipc.h"
#include "libipc/def.h"
@ -70,23 +69,6 @@ ipc::buff_t make_cache(T& data, std::size_t size) {
return { ptr, size, ipc::mem::free };
}
acc_t *cc_acc(ipc::string const &pref) {
static ipc::unordered_map<ipc::string, ipc::shm::handle> handles;
static std::mutex lock;
std::lock_guard<std::mutex> guard {lock};
auto it = handles.find(pref);
if (it == handles.end()) {
ipc::string shm_name {ipc::make_prefix(pref, {"CA_CONN__"})};
ipc::shm::handle h;
if (!h.acquire(shm_name.c_str(), sizeof(acc_t))) {
ipc::error("[cc_acc] acquire failed: %s\n", shm_name.c_str());
return nullptr;
}
it = handles.emplace(pref, std::move(h)).first;
}
return static_cast<acc_t *>(it->second.get());
}
struct cache_t {
std::size_t fill_;
ipc::buff_t buff_;
@ -103,70 +85,10 @@ struct cache_t {
}
};
struct conn_info_head {
ipc::string prefix_;
ipc::string name_;
msg_id_t cc_id_; // connection-info id
ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
ipc::shm::handle acc_h_;
conn_info_head(char const * prefix, char const * name)
: prefix_{ipc::make_string(prefix)}
, name_ {ipc::make_string(name)}
, cc_id_ {} {}
void init() {
if (!cc_waiter_.valid()) cc_waiter_.open(ipc::make_prefix(prefix_, {"CC_CONN__", name_}).c_str());
if (!wt_waiter_.valid()) wt_waiter_.open(ipc::make_prefix(prefix_, {"WT_CONN__", name_}).c_str());
if (!rd_waiter_.valid()) rd_waiter_.open(ipc::make_prefix(prefix_, {"RD_CONN__", name_}).c_str());
if (!acc_h_.valid()) acc_h_.acquire(ipc::make_prefix(prefix_, {"AC_CONN__", name_}).c_str(), sizeof(acc_t));
if (cc_id_ != 0) {
return;
}
acc_t *pacc = cc_acc(prefix_);
if (pacc == nullptr) {
// Failed to obtain the global accumulator.
return;
}
cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed) + 1;
if (cc_id_ == 0) {
// The identity cannot be 0.
cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed) + 1;
}
}
void clear() noexcept {
cc_waiter_.clear();
wt_waiter_.clear();
rd_waiter_.clear();
acc_h_.clear();
}
static void clear_storage(char const * prefix, char const * name) noexcept {
auto p = ipc::make_string(prefix);
auto n = ipc::make_string(name);
ipc::detail::waiter::clear_storage(ipc::make_prefix(p, {"CC_CONN__", n}).c_str());
ipc::detail::waiter::clear_storage(ipc::make_prefix(p, {"WT_CONN__", n}).c_str());
ipc::detail::waiter::clear_storage(ipc::make_prefix(p, {"RD_CONN__", n}).c_str());
ipc::shm::handle::clear_storage(ipc::make_prefix(p, {"AC_CONN__", n}).c_str());
}
void quit_waiting() {
cc_waiter_.quit_waiting();
wt_waiter_.quit_waiting();
rd_waiter_.quit_waiting();
}
auto acc() {
return static_cast<acc_t*>(acc_h_.get());
}
auto& recv_cache() {
thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
return tls;
}
};
auto cc_acc() {
static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
return static_cast<acc_t*>(acc_h.get());
}
IPC_CONSTEXPR_ std::size_t align_chunk_size(std::size_t size) noexcept {
return (((size - 1) / ipc::large_msg_align) + 1) * ipc::large_msg_align;
@ -208,32 +130,17 @@ struct chunk_info_t {
auto& chunk_storages() {
class chunk_handle_t {
ipc::unordered_map<ipc::string, ipc::shm::handle> handles_;
std::mutex lock_;
static bool make_handle(ipc::shm::handle &h, ipc::string const &shm_name, std::size_t chunk_size) {
if (!h.valid() &&
!h.acquire( shm_name.c_str(),
sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
ipc::error("[chunk_storages] chunk_shm.id_info_.acquire failed: chunk_size = %zd\n", chunk_size);
return false;
}
return true;
}
ipc::shm::handle handle_;
public:
chunk_info_t *get_info(conn_info_head *inf, std::size_t chunk_size) {
ipc::string pref {(inf == nullptr) ? ipc::string{} : inf->prefix_};
ipc::string shm_name {ipc::make_prefix(pref, {"CHUNK_INFO__", ipc::to_string(chunk_size)})};
ipc::shm::handle *h;
{
std::lock_guard<std::mutex> guard {lock_};
h = &(handles_[pref]);
if (!make_handle(*h, shm_name, chunk_size)) {
return nullptr;
}
chunk_info_t *get_info(std::size_t chunk_size) {
if (!handle_.valid() &&
!handle_.acquire( ("__CHUNK_INFO__" + ipc::to_string(chunk_size)).c_str(),
sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
ipc::error("[chunk_storages] chunk_shm.id_info_.acquire failed: chunk_size = %zd\n", chunk_size);
return nullptr;
}
auto *info = static_cast<chunk_info_t*>(h->get());
auto info = static_cast<chunk_info_t*>(handle_.get());
if (info == nullptr) {
ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
return nullptr;
@ -241,35 +148,29 @@ auto& chunk_storages() {
return info;
}
};
using deleter_t = void (*)(chunk_handle_t*);
using chunk_handle_ptr_t = std::unique_ptr<chunk_handle_t, deleter_t>;
static ipc::map<std::size_t, chunk_handle_ptr_t> chunk_hs;
static ipc::map<std::size_t, chunk_handle_t> chunk_hs;
return chunk_hs;
}
chunk_info_t *chunk_storage_info(conn_info_head *inf, std::size_t chunk_size) {
chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
auto &storages = chunk_storages();
std::decay_t<decltype(storages)>::iterator it;
{
static ipc::rw_lock lock;
IPC_UNUSED_ std::shared_lock<ipc::rw_lock> guard {lock};
if ((it = storages.find(chunk_size)) == storages.end()) {
using chunk_handle_ptr_t = std::decay_t<decltype(storages)>::value_type::second_type;
using chunk_handle_t = chunk_handle_ptr_t::element_type;
using chunk_handle_t = std::decay_t<decltype(storages)>::value_type::second_type;
guard.unlock();
IPC_UNUSED_ std::lock_guard<ipc::rw_lock> guard {lock};
it = storages.emplace(chunk_size, chunk_handle_ptr_t{
ipc::mem::alloc<chunk_handle_t>(), [](chunk_handle_t *p) {
ipc::mem::destruct(p);
}}).first;
it = storages.emplace(chunk_size, chunk_handle_t{}).first;
}
}
return it->second->get_info(inf, chunk_size);
return it->second.get_info(chunk_size);
}
std::pair<ipc::storage_id_t, void*> acquire_storage(conn_info_head *inf, std::size_t size, ipc::circ::cc_t conns) {
std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ::cc_t conns) {
std::size_t chunk_size = calc_chunk_size(size);
auto info = chunk_storage_info(inf, chunk_size);
auto info = chunk_storage_info(chunk_size);
if (info == nullptr) return {};
info->lock_.lock();
@ -284,24 +185,24 @@ std::pair<ipc::storage_id_t, void*> acquire_storage(conn_info_head *inf, std::si
return { id, chunk->data() };
}
void *find_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size) {
void *find_storage(ipc::storage_id_t id, std::size_t size) {
if (id < 0) {
ipc::error("[find_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
return nullptr;
}
std::size_t chunk_size = calc_chunk_size(size);
auto info = chunk_storage_info(inf, chunk_size);
auto info = chunk_storage_info(chunk_size);
if (info == nullptr) return nullptr;
return info->at(chunk_size, id)->data();
}
void release_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size) {
void release_storage(ipc::storage_id_t id, std::size_t size) {
if (id < 0) {
ipc::error("[release_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
return;
}
std::size_t chunk_size = calc_chunk_size(size);
auto info = chunk_storage_info(inf, chunk_size);
auto info = chunk_storage_info(chunk_size);
if (info == nullptr) return;
info->lock_.lock();
info->pool_.release(id);
@ -328,13 +229,13 @@ bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::broadcast>,
}
template <typename Flag>
void recycle_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
if (id < 0) {
ipc::error("[recycle_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
return;
}
std::size_t chunk_size = calc_chunk_size(size);
auto info = chunk_storage_info(inf, chunk_size);
auto info = chunk_storage_info(chunk_size);
if (info == nullptr) return;
auto chunk = info->at(chunk_size, id);
@ -349,7 +250,7 @@ void recycle_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size
}
template <typename MsgT>
bool clear_message(conn_info_head *inf, void* p) {
bool clear_message(void* p) {
auto msg = static_cast<MsgT*>(p);
if (msg->storage_) {
std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg->remain_;
@ -357,12 +258,45 @@ bool clear_message(conn_info_head *inf, void* p) {
ipc::error("[clear_message] invalid msg size: %d\n", (int)r_size);
return true;
}
release_storage(*reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
inf, static_cast<std::size_t>(r_size));
release_storage(
*reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
static_cast<std::size_t>(r_size));
}
return true;
}
struct conn_info_head {
ipc::string name_;
msg_id_t cc_id_; // connection-info id
ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
ipc::shm::handle acc_h_;
conn_info_head(char const * name)
: name_ {name}
, cc_id_ {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
, cc_waiter_{("__CC_CONN__" + name_).c_str()}
, wt_waiter_{("__WT_CONN__" + name_).c_str()}
, rd_waiter_{("__RD_CONN__" + name_).c_str()}
, acc_h_ {("__AC_CONN__" + name_).c_str(), sizeof(acc_t)} {
}
void quit_waiting() {
cc_waiter_.quit_waiting();
wt_waiter_.quit_waiting();
rd_waiter_.quit_waiting();
}
auto acc() {
return static_cast<acc_t*>(acc_h_.get());
}
auto& recv_cache() {
thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
return tls;
}
};
template <typename W, typename F>
bool wait_for(W& waiter, F&& pred, std::uint64_t tm) {
if (tm == 0) return !pred();
@ -388,32 +322,11 @@ struct queue_generator {
struct conn_info_t : conn_info_head {
queue_t que_;
conn_info_t(char const * pref, char const * name)
: conn_info_head{pref, name} { init(); }
void init() {
conn_info_head::init();
if (!que_.valid()) {
que_.open(ipc::make_prefix(prefix_, {
"QU_CONN__",
this->name_,
"__", ipc::to_string(DataSize),
"__", ipc::to_string(AlignSize)}).c_str());
}
}
void clear() noexcept {
que_.clear();
conn_info_head::clear();
}
static void clear_storage(char const * prefix, char const * name) noexcept {
queue_t::clear_storage(ipc::make_prefix(ipc::make_string(prefix), {
"QU_CONN__",
ipc::make_string(name),
"__", ipc::to_string(DataSize),
"__", ipc::to_string(AlignSize)}).c_str());
conn_info_head::clear_storage(prefix, name);
conn_info_t(char const * name)
: conn_info_head{name}
, que_{("__QU_CONN__" +
ipc::to_string(DataSize) + "__" +
ipc::to_string(AlignSize) + "__" + name).c_str()} {
}
void disconnect_receiver() {
@ -444,18 +357,6 @@ constexpr static queue_t* queue_of(ipc::handle_t h) noexcept {
/* API implementations */
static bool connect(ipc::handle_t * ph, ipc::prefix pref, char const * name, bool start_to_recv) {
assert(ph != nullptr);
if (*ph == nullptr) {
*ph = ipc::mem::alloc<conn_info_t>(pref.str, name);
}
return reconnect(ph, start_to_recv);
}
static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
return connect(ph, {nullptr}, name, start_to_recv);
}
static void disconnect(ipc::handle_t h) {
auto que = queue_of(h);
if (que == nullptr) {
@ -473,7 +374,6 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
if (que == nullptr) {
return false;
}
info_of(*ph)->init();
if (start_to_recv) {
que->shut_sending();
if (que->connect()) { // wouldn't connect twice
@ -489,7 +389,16 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
return que->ready_sending();
}
static void destroy(ipc::handle_t h) noexcept {
static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
assert(ph != nullptr);
if (*ph == nullptr) {
*ph = ipc::mem::alloc<conn_info_t>(name);
}
return reconnect(ph, start_to_recv);
}
static void destroy(ipc::handle_t h) {
disconnect(h);
ipc::mem::free(info_of(h));
}
@ -536,16 +445,15 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
return false;
}
// calc a new message id
conn_info_t *inf = info_of(h);
auto acc = inf->acc();
auto acc = info_of(h)->acc();
if (acc == nullptr) {
ipc::error("fail: send, info_of(h)->acc() == nullptr\n");
return false;
}
auto msg_id = acc->fetch_add(1, std::memory_order_relaxed);
auto try_push = std::forward<F>(gen_push)(inf, que, msg_id);
auto try_push = std::forward<F>(gen_push)(info_of(h), que, msg_id);
if (size > ipc::large_msg_limit) {
auto dat = acquire_storage(inf, size, conns);
auto dat = acquire_storage(size, conns);
void * buf = dat.second;
if (buf != nullptr) {
std::memcpy(buf, data, size);
@ -576,7 +484,7 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
}
static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
return send([tm](auto *info, auto *que, auto msg_id) {
return send([tm](auto info, auto que, auto msg_id) {
return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
if (!wait_for(info->wt_waiter_, [&] {
return !que->push(
@ -585,7 +493,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint
}, tm)) {
ipc::log("force_push: msg_id = %zd, remain = %d, size = %zd\n", msg_id, remain, size);
if (!que->force_push(
[info](void* p) { return clear_message<typename queue_t::value_t>(info, p); },
clear_message<typename queue_t::value_t>,
info->cc_id_, msg_id, remain, data, size)) {
return false;
}
@ -597,7 +505,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint
}
static bool try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
return send([tm](auto *info, auto *que, auto msg_id) {
return send([tm](auto info, auto que, auto msg_id) {
return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
if (!wait_for(info->wt_waiter_, [&] {
return !que->push(
@ -622,22 +530,18 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
// hasn't connected yet, just return.
return {};
}
conn_info_t *inf = info_of(h);
auto& rc = inf->recv_cache();
auto& rc = info_of(h)->recv_cache();
for (;;) {
// pop a new message
typename queue_t::value_t msg {};
if (!wait_for(inf->rd_waiter_, [que, &msg, &h] {
if (!que->connected()) {
reconnect(&h, true);
}
typename queue_t::value_t msg;
if (!wait_for(info_of(h)->rd_waiter_, [que, &msg] {
return !que->pop(msg);
}, tm)) {
// pop failed, just return.
return {};
}
inf->wt_waiter_.broadcast();
if ((inf->acc() != nullptr) && (msg.cc_id_ == inf->cc_id_)) {
info_of(h)->wt_waiter_.broadcast();
if ((info_of(h)->acc() != nullptr) && (msg.cc_id_ == info_of(h)->cc_id_)) {
continue; // ignore message to self
}
// msg.remain_ may minus & abs(msg.remain_) < data_length
@ -650,18 +554,14 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
// large message
if (msg.storage_) {
ipc::storage_id_t buf_id = *reinterpret_cast<ipc::storage_id_t*>(&msg.data_);
void* buf = find_storage(buf_id, inf, msg_size);
void* buf = find_storage(buf_id, msg_size);
if (buf != nullptr) {
struct recycle_t {
ipc::storage_id_t storage_id;
conn_info_t * inf;
ipc::circ::cc_t curr_conns;
ipc::circ::cc_t conn_id;
} *r_info = ipc::mem::alloc<recycle_t>(recycle_t{
buf_id,
inf,
que->elems()->connections(std::memory_order_relaxed),
que->connected_id()
buf_id, que->elems()->connections(std::memory_order_relaxed), que->connected_id()
});
if (r_info == nullptr) {
ipc::log("fail: ipc::mem::alloc<recycle_t>.\n");
@ -672,11 +572,7 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
IPC_UNUSED_ auto finally = ipc::guard([r_info] {
ipc::mem::free(r_info);
});
recycle_storage<flag_t>(r_info->storage_id,
r_info->inf,
size,
r_info->curr_conns,
r_info->conn_id);
recycle_storage<flag_t>(r_info->storage_id, size, r_info->curr_conns, r_info->conn_id);
}, r_info};
}
} else {
@ -734,22 +630,11 @@ using policy_t = ipc::policy::choose<ipc::circ::elem_array, Flag>;
namespace ipc {
template <typename Flag>
ipc::handle_t chan_impl<Flag>::init_first() {
ipc::detail::waiter::init();
return nullptr;
}
template <typename Flag>
bool chan_impl<Flag>::connect(ipc::handle_t * ph, char const * name, unsigned mode) {
return detail_impl<policy_t<Flag>>::connect(ph, name, mode & receiver);
}
template <typename Flag>
bool chan_impl<Flag>::connect(ipc::handle_t * ph, prefix pref, char const * name, unsigned mode) {
return detail_impl<policy_t<Flag>>::connect(ph, pref, name, mode & receiver);
}
template <typename Flag>
bool chan_impl<Flag>::reconnect(ipc::handle_t * ph, unsigned mode) {
return detail_impl<policy_t<Flag>>::reconnect(ph, mode & receiver);
@ -762,42 +647,15 @@ void chan_impl<Flag>::disconnect(ipc::handle_t h) {
template <typename Flag>
void chan_impl<Flag>::destroy(ipc::handle_t h) {
disconnect(h);
detail_impl<policy_t<Flag>>::destroy(h);
}
template <typename Flag>
void chan_impl<Flag>::release(ipc::handle_t h) noexcept {
detail_impl<policy_t<Flag>>::destroy(h);
}
template <typename Flag>
char const * chan_impl<Flag>::name(ipc::handle_t h) {
auto *info = detail_impl<policy_t<Flag>>::info_of(h);
auto info = detail_impl<policy_t<Flag>>::info_of(h);
return (info == nullptr) ? nullptr : info->name_.c_str();
}
template <typename Flag>
void chan_impl<Flag>::clear(ipc::handle_t h) noexcept {
disconnect(h);
using conn_info_t = typename detail_impl<policy_t<Flag>>::conn_info_t;
auto conn_info_p = static_cast<conn_info_t *>(h);
if (conn_info_p == nullptr) return;
conn_info_p->clear();
destroy(h);
}
template <typename Flag>
void chan_impl<Flag>::clear_storage(char const * name) noexcept {
chan_impl<Flag>::clear_storage({nullptr}, name);
}
template <typename Flag>
void chan_impl<Flag>::clear_storage(prefix pref, char const * name) noexcept {
using conn_info_t = typename detail_impl<policy_t<Flag>>::conn_info_t;
conn_info_t::clear_storage(pref.str, name);
}
template <typename Flag>
std::size_t chan_impl<Flag>::recv_count(ipc::handle_t h) {
return detail_impl<policy_t<Flag>>::recv_count(h);

8
src/libipc/memory/alloc.h
View File

@ -19,17 +19,17 @@ namespace mem {
class static_alloc {
public:
static void swap(static_alloc&) noexcept {}
static void swap(static_alloc&) {}
static void* alloc(std::size_t size) noexcept {
static void* alloc(std::size_t size) {
return size ? std::malloc(size) : nullptr;
}
static void free(void* p) noexcept {
static void free(void* p) {
std::free(p);
}
static void free(void* p, std::size_t /*size*/) noexcept {
static void free(void* p, std::size_t /*size*/) {
free(p);
}
};

20
src/libipc/memory/resource.h
View File

@ -87,24 +87,4 @@ ipc::string to_string(T val) {
return {};
}
/// \brief Check string validity.
constexpr bool is_valid_string(char const *str) noexcept {
return (str != nullptr) && (str[0] != '\0');
}
/// \brief Make a valid string.
inline ipc::string make_string(char const *str) {
return is_valid_string(str) ? ipc::string{str} : ipc::string{};
}
/// \brief Combine prefix from a list of strings.
inline ipc::string make_prefix(ipc::string prefix, std::initializer_list<ipc::string> args) {
prefix += "__IPC_SHM__";
for (auto const &txt: args) {
if (txt.empty()) continue;
prefix += txt;
}
return prefix;
}
} // namespace ipc

14
src/libipc/platform/detail.h
View File

@ -9,8 +9,6 @@
# define IPC_OS_WINDOWS_
#elif defined(__linux__) || defined(__linux)
# define IPC_OS_LINUX_
#elif defined(__FreeBSD__)
# define IPC_OS_FREEBSD_
#elif defined(__QNX__)
# define IPC_OS_QNX_
#elif defined(__APPLE__)
@ -72,9 +70,15 @@
#if __cplusplus >= 201703L
namespace std {
// C++17 and later: std library already provides deduction guides
// No need to add custom ones, just use the standard ones directly
// deduction guides for std::unique_ptr
template <typename T>
unique_ptr(T* p) -> unique_ptr<T>;
template <typename T, typename D>
unique_ptr(T* p, D&& d) -> unique_ptr<T, std::decay_t<D>>;
} // namespace std
namespace ipc {
namespace detail {
@ -129,4 +133,4 @@ constexpr const T& (min)(const T& a, const T& b) {
} // namespace ipc
#endif // defined(__cplusplus)
#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_
#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_

2
src/libipc/platform/linux/condition.h
View File

@ -27,7 +27,7 @@ public:
return false;
}
} else {
auto ts = linux_::detail::make_timespec(tm);
auto ts = detail::make_timespec(tm);
int eno = A0_SYSERR(a0_cnd_timedwait(native(), static_cast<a0_mtx_t *>(mtx.native()), {ts}));
if (eno != 0) {
if (eno != ETIMEDOUT) {

2
src/libipc/platform/linux/get_wait_time.h
View File

@ -10,7 +10,6 @@
#include "a0/err_macro.h"
namespace ipc {
namespace linux_ {
namespace detail {
inline bool calc_wait_time(timespec &ts, std::uint64_t tm /*ms*/) noexcept {
@ -44,5 +43,4 @@ inline timespec make_timespec(std::uint64_t tm /*ms*/) noexcept(false) {
}
} // namespace detail
} // namespace linux_
} // namespace ipc

46
src/libipc/platform/linux/mutex.h
View File

@ -25,7 +25,7 @@ public:
bool lock(std::uint64_t tm) noexcept {
if (!valid()) return false;
for (;;) {
auto ts = linux_::detail::make_timespec(tm);
auto ts = detail::make_timespec(tm);
int eno = A0_SYSERR(
(tm == invalid_value) ? a0_mtx_lock(native())
: a0_mtx_timedlock(native(), {ts}));
@ -56,7 +56,7 @@ public:
bool try_lock() noexcept(false) {
if (!valid()) return false;
int eno = A0_SYSERR(a0_mtx_timedlock(native(), {linux_::detail::make_timespec(0)}));
int eno = A0_SYSERR(a0_mtx_timedlock(native(), {detail::make_timespec(0)}));
switch (eno) {
case 0:
return true;
@ -125,27 +125,23 @@ class mutex {
IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
auto it = info.mutex_handles.find(name);
if (it == info.mutex_handles.end()) {
it = info.mutex_handles
.emplace(std::piecewise_construct,
std::forward_as_tuple(name),
std::forward_as_tuple(curr_prog::shm_data::init{name}))
.first;
it = curr_prog::get().mutex_handles.emplace(name,
curr_prog::shm_data::init{name}).first;
}
mutex_ = &it->second.mtx;
ref_ = &it->second.ref;
}
template <typename F>
static void release_mutex(ipc::string const &name, F &&clear) {
void release_mutex(ipc::string const &name, F &&clear) {
if (name.empty()) return;
auto &info = curr_prog::get();
IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
auto it = info.mutex_handles.find(name);
if (it == info.mutex_handles.end()) {
IPC_UNUSED_ std::lock_guard<std::mutex> guard {curr_prog::get().lock};
auto it = curr_prog::get().mutex_handles.find(name);
if (it == curr_prog::get().mutex_handles.end()) {
return;
}
if (clear()) {
info.mutex_handles.erase(it);
curr_prog::get().mutex_handles.erase(it);
}
}
@ -153,11 +149,6 @@ public:
mutex() = default;
~mutex() = default;
static void init() {
// Avoid exception problems caused by static member initialization order.
curr_prog::get();
}
a0_mtx_t const *native() const noexcept {
return valid() ? mutex_->native() : nullptr;
}
@ -192,25 +183,6 @@ public:
ref_ = nullptr;
}
void clear() noexcept {
if (mutex_ != nullptr) {
if (mutex_->name() != nullptr) {
release_mutex(mutex_->name(), [this] {
mutex_->clear();
return true;
});
} else mutex_->clear();
}
mutex_ = nullptr;
ref_ = nullptr;
}
static void clear_storage(char const *name) noexcept {
if (name == nullptr) return;
release_mutex(name, [] { return true; });
robust_mutex::clear_storage(name);
}
bool lock(std::uint64_t tm) noexcept {
if (!valid()) return false;
return mutex_->lock(tm);

9
src/libipc/platform/linux/sync_obj_impl.h
View File

@ -62,15 +62,6 @@ public:
shm_.release();
h_ = nullptr;
}
void clear() noexcept {
shm_.clear(); // Make sure the storage is cleaned up.
h_ = nullptr;
}
static void clear_storage(char const *name) noexcept {
ipc::shm::handle::clear_storage(name);
}
};
} // namespace sync

2
src/libipc/platform/platform.c
View File

@ -7,7 +7,7 @@
#include "libipc/platform/linux/a0/strconv.c"
#include "libipc/platform/linux/a0/tid.c"
#include "libipc/platform/linux/a0/time.c"
#elif defined(IPC_OS_QNX_) || defined(IPC_OS_FREEBSD_)
#elif defined(IPC_OS_QNX_)
#else/*IPC_OS*/
# error "Unsupported platform."
#endif

2
src/libipc/platform/platform.cpp
View File

@ -2,7 +2,7 @@
#include "libipc/platform/detail.h"
#if defined(IPC_OS_WINDOWS_)
#include "libipc/platform/win/shm_win.cpp"
#elif defined(IPC_OS_LINUX_) || defined(IPC_OS_QNX_) || defined(IPC_OS_FREEBSD_)
#elif defined(IPC_OS_LINUX_) || defined(IPC_OS_QNX_)
#include "libipc/platform/posix/shm_posix.cpp"
#else/*IPC_OS*/
# error "Unsupported platform."

17
src/libipc/platform/posix/condition.h
View File

@ -88,21 +88,6 @@ public:
cond_ = nullptr;
}
void clear() noexcept {
if ((shm_.ref() <= 1) && cond_ != nullptr) {
int eno;
if ((eno = ::pthread_cond_destroy(cond_)) != 0) {
ipc::error("fail pthread_cond_destroy[%d]\n", eno);
}
}
shm_.clear(); // Make sure the storage is cleaned up.
cond_ = nullptr;
}
static void clear_storage(char const *name) noexcept {
ipc::shm::handle::clear_storage(name);
}
bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
if (!valid()) return false;
switch (tm) {
@ -115,7 +100,7 @@ public:
}
break;
default: {
auto ts = posix_::detail::make_timespec(tm);
auto ts = detail::make_timespec(tm);
int eno;
if ((eno = ::pthread_cond_timedwait(cond_, static_cast<pthread_mutex_t *>(mtx.native()), &ts)) != 0) {
if (eno != ETIMEDOUT) {

2
src/libipc/platform/posix/get_wait_time.h
View File

@ -10,7 +10,6 @@
#include "libipc/utility/log.h"
namespace ipc {
namespace posix_ {
namespace detail {
inline bool calc_wait_time(timespec &ts, std::uint64_t tm /*ms*/) noexcept {
@ -37,5 +36,4 @@ inline timespec make_timespec(std::uint64_t tm /*ms*/) noexcept(false) {
}
} // namespace detail
} // namespace posix_
} // namespace ipc

103
src/libipc/platform/posix/mutex.h
View File

@ -55,12 +55,8 @@ class mutex {
IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
auto it = info.mutex_handles.find(name);
if (it == info.mutex_handles.end()) {
it = info.mutex_handles
.emplace(std::piecewise_construct,
std::forward_as_tuple(name),
std::forward_as_tuple(curr_prog::shm_data::init{
name, sizeof(pthread_mutex_t)}))
.first;
it = curr_prog::get().mutex_handles.emplace(name,
curr_prog::shm_data::init{name, sizeof(pthread_mutex_t)}).first;
}
shm_ = &it->second.shm;
ref_ = &it->second.ref;
@ -71,34 +67,22 @@ class mutex {
}
template <typename F>
static void release_mutex(ipc::string const &name, F &&clear) {
void release_mutex(ipc::string const &name, F &&clear) {
if (name.empty()) return;
auto &info = curr_prog::get();
IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
auto it = info.mutex_handles.find(name);
if (it == info.mutex_handles.end()) {
IPC_UNUSED_ std::lock_guard<std::mutex> guard {curr_prog::get().lock};
auto it = curr_prog::get().mutex_handles.find(name);
if (it == curr_prog::get().mutex_handles.end()) {
return;
}
if (clear()) {
info.mutex_handles.erase(it);
curr_prog::get().mutex_handles.erase(it);
}
}
static pthread_mutex_t const &zero_mem() {
static const pthread_mutex_t tmp{};
return tmp;
}
public:
mutex() = default;
~mutex() = default;
static void init() {
// Avoid exception problems caused by static member initialization order.
zero_mem();
curr_prog::get();
}
pthread_mutex_t const *native() const noexcept {
return mutex_;
}
@ -108,8 +92,9 @@ public:
}
bool valid() const noexcept {
static const char tmp[sizeof(pthread_mutex_t)] {};
return (shm_ != nullptr) && (ref_ != nullptr) && (mutex_ != nullptr)
&& (std::memcmp(&zero_mem(), mutex_, sizeof(pthread_mutex_t)) != 0);
&& (std::memcmp(tmp, mutex_, sizeof(pthread_mutex_t)) != 0);
}
bool open(char const *name) noexcept {
@ -154,15 +139,6 @@ public:
release_mutex(shm_->name(), [this] {
auto self_ref = ref_->fetch_sub(1, std::memory_order_relaxed);
if ((shm_->ref() <= 1) && (self_ref <= 1)) {
// Before destroying the mutex, try to unlock it.
// This is important for robust mutexes on FreeBSD, which maintain
// a per-thread robust list. If we destroy a mutex while it's locked
// or still in the robust list, FreeBSD may encounter dangling pointers
// later, leading to segfaults.
// Only unlock here (when we're the last reference) to avoid
// interfering with other threads that might be using the mutex.
::pthread_mutex_unlock(mutex_);
int eno;
if ((eno = ::pthread_mutex_destroy(mutex_)) != 0) {
ipc::error("fail pthread_mutex_destroy[%d]\n", eno);
@ -178,37 +154,10 @@ public:
mutex_ = nullptr;
}
void clear() noexcept {
if ((shm_ != nullptr) && (mutex_ != nullptr)) {
if (shm_->name() != nullptr) {
release_mutex(shm_->name(), [this] {
// Unlock before destroying, same reasoning as in close()
::pthread_mutex_unlock(mutex_);
int eno;
if ((eno = ::pthread_mutex_destroy(mutex_)) != 0) {
ipc::error("fail pthread_mutex_destroy[%d]\n", eno);
}
shm_->clear();
return true;
});
} else shm_->clear();
}
shm_ = nullptr;
ref_ = nullptr;
mutex_ = nullptr;
}
static void clear_storage(char const *name) noexcept {
if (name == nullptr) return;
release_mutex(name, [] { return true; });
ipc::shm::handle::clear_storage(name);
}
bool lock(std::uint64_t tm) noexcept {
if (!valid()) return false;
for (;;) {
auto ts = posix_::detail::make_timespec(tm);
auto ts = detail::make_timespec(tm);
int eno = (tm == invalid_value)
? ::pthread_mutex_lock(mutex_)
: ::pthread_mutex_timedlock(mutex_, &ts);
@ -218,17 +167,21 @@ public:
case ETIMEDOUT:
return false;
case EOWNERDEAD: {
// EOWNERDEAD means we have successfully acquired the lock,
// but the previous owner died. We need to make it consistent.
if (shm_->ref() > 1) {
shm_->sub_ref();
}
int eno2 = ::pthread_mutex_consistent(mutex_);
if (eno2 != 0) {
ipc::error("fail pthread_mutex_lock[%d], pthread_mutex_consistent[%d]\n", eno, eno2);
return false;
}
// After calling pthread_mutex_consistent(), the mutex is now in a
// consistent state and we hold the lock. Return success.
return true;
int eno3 = ::pthread_mutex_unlock(mutex_);
if (eno3 != 0) {
ipc::error("fail pthread_mutex_lock[%d], pthread_mutex_unlock[%d]\n", eno, eno3);
return false;
}
}
break; // loop again
default:
ipc::error("fail pthread_mutex_lock[%d]\n", eno);
return false;
@ -238,7 +191,7 @@ public:
bool try_lock() noexcept(false) {
if (!valid()) return false;
auto ts = posix_::detail::make_timespec(0);
auto ts = detail::make_timespec(0);
int eno = ::pthread_mutex_timedlock(mutex_, &ts);
switch (eno) {
case 0:
@ -246,17 +199,21 @@ public:
case ETIMEDOUT:
return false;
case EOWNERDEAD: {
// EOWNERDEAD means we have successfully acquired the lock,
// but the previous owner died. We need to make it consistent.
if (shm_->ref() > 1) {
shm_->sub_ref();
}
int eno2 = ::pthread_mutex_consistent(mutex_);
if (eno2 != 0) {
ipc::error("fail pthread_mutex_timedlock[%d], pthread_mutex_consistent[%d]\n", eno, eno2);
throw std::system_error{eno2, std::system_category()};
break;
}
int eno3 = ::pthread_mutex_unlock(mutex_);
if (eno3 != 0) {
ipc::error("fail pthread_mutex_timedlock[%d], pthread_mutex_unlock[%d]\n", eno, eno3);
break;
}
// After calling pthread_mutex_consistent(), the mutex is now in a
// consistent state and we hold the lock. Return success.
return true;
}
break;
default:
ipc::error("fail pthread_mutex_timedlock[%d]\n", eno);
break;

48
src/libipc/platform/posix/semaphore_impl.h
View File

@ -19,7 +19,6 @@ namespace sync {
class semaphore {
ipc::shm::handle shm_;
sem_t *h_ = SEM_FAILED;
std::string sem_name_; // Store the actual semaphore name used
public:
semaphore() = default;
@ -39,16 +38,9 @@ public:
ipc::error("[open_semaphore] fail shm.acquire: %s\n", name);
return false;
}
// POSIX semaphore names must start with "/" on some platforms (e.g., FreeBSD)
// Use a separate namespace for semaphores to avoid conflicts with shm
if (name[0] == '/') {
sem_name_ = std::string(name) + "_sem";
} else {
sem_name_ = std::string("/") + name + "_sem";
}
h_ = ::sem_open(sem_name_.c_str(), O_CREAT, 0666, static_cast<unsigned>(count));
h_ = ::sem_open(name, O_CREAT, 0666, static_cast<unsigned>(count));
if (h_ == SEM_FAILED) {
ipc::error("fail sem_open[%d]: %s\n", errno, sem_name_.c_str());
ipc::error("fail sem_open[%d]: %s\n", errno, name);
return false;
}
return true;
@ -60,40 +52,14 @@ public:
ipc::error("fail sem_close[%d]: %s\n", errno);
}
h_ = SEM_FAILED;
if (!sem_name_.empty() && shm_.name() != nullptr) {
if (shm_.name() != nullptr) {
std::string name = shm_.name();
if (shm_.release() <= 1) {
if (::sem_unlink(sem_name_.c_str()) != 0) {
ipc::error("fail sem_unlink[%d]: %s, name: %s\n", errno, sem_name_.c_str());
if (::sem_unlink(name.c_str()) != 0) {
ipc::error("fail sem_unlink[%d]: %s, name: %s\n", errno, name.c_str());
}
}
}
sem_name_.clear();
}
void clear() noexcept {
if (valid()) {
if (::sem_close(h_) != 0) {
ipc::error("fail sem_close[%d]: %s\n", errno);
}
h_ = SEM_FAILED;
}
if (!sem_name_.empty()) {
::sem_unlink(sem_name_.c_str());
sem_name_.clear();
}
shm_.clear(); // Make sure the storage is cleaned up.
}
static void clear_storage(char const *name) noexcept {
// Construct the semaphore name same way as open() does
std::string sem_name;
if (name[0] == '/') {
sem_name = std::string(name) + "_sem";
} else {
sem_name = std::string("/") + name + "_sem";
}
::sem_unlink(sem_name.c_str());
ipc::shm::handle::clear_storage(name);
}
bool wait(std::uint64_t tm) noexcept {
@ -104,7 +70,7 @@ public:
return false;
}
} else {
auto ts = posix_::detail::make_timespec(tm);
auto ts = detail::make_timespec(tm);
if (::sem_timedwait(h_, &ts) != 0) {
if (errno != ETIMEDOUT) {
ipc::error("fail sem_timedwait[%d]: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",

56
src/libipc/platform/posix/shm_posix.cpp
View File

@ -45,18 +45,11 @@ namespace ipc {
namespace shm {
id_t acquire(char const * name, std::size_t size, unsigned mode) {
if (!is_valid_string(name)) {
if (name == nullptr || name[0] == '\0') {
ipc::error("fail acquire: name is empty\n");
return nullptr;
}
// For portable use, a shared memory object should be identified by name of the form /somename.
// see: https://man7.org/linux/man-pages/man3/shm_open.3.html
ipc::string op_name;
if (name[0] == '/') {
op_name = name;
} else {
op_name = ipc::string{"/"} + name;
}
ipc::string op_name = ipc::string{"__IPC_SHM__"} + name;
// Open the object for read-write access.
int flag = O_RDWR;
switch (mode) {
@ -73,19 +66,13 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
flag |= O_CREAT;
break;
}
int fd = ::shm_open(op_name.c_str(), flag, S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP |
int fd = ::shm_open(op_name.c_str(), flag, S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP |
S_IROTH | S_IWOTH);
if (fd == -1) {
// only open shm not log error when file not exist
if (open != mode || ENOENT != errno) {
ipc::error("fail shm_open[%d]: %s\n", errno, op_name.c_str());
}
ipc::error("fail shm_open[%d]: %s\n", errno, name);
return nullptr;
}
::fchmod(fd, S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP |
S_IROTH | S_IWOTH);
auto ii = mem::alloc<id_info_t>();
ii->fd_ = fd;
ii->size_ = size;
@ -164,7 +151,7 @@ void * get_mem(id_t id, std::size_t * size) {
return mem;
}
std::int32_t release(id_t id) noexcept {
std::int32_t release(id_t id) {
if (id == nullptr) {
ipc::error("fail release: invalid id (null)\n");
return -1;
@ -172,16 +159,12 @@ std::int32_t release(id_t id) noexcept {
std::int32_t ret = -1;
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ == nullptr || ii->size_ == 0) {
ipc::error("fail release: invalid id (mem = %p, size = %zd), name = %s\n",
ii->mem_, ii->size_, ii->name_.c_str());
ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
}
else if ((ret = acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel)) <= 1) {
::munmap(ii->mem_, ii->size_);
if (!ii->name_.empty()) {
int unlink_ret = ::shm_unlink(ii->name_.c_str());
if (unlink_ret == -1) {
ipc::error("fail shm_unlink[%d]: %s\n", errno, ii->name_.c_str());
}
::shm_unlink(ii->name_.c_str());
}
}
else ::munmap(ii->mem_, ii->size_);
@ -189,7 +172,7 @@ std::int32_t release(id_t id) noexcept {
return ret;
}
void remove(id_t id) noexcept {
void remove(id_t id) {
if (id == nullptr) {
ipc::error("fail remove: invalid id (null)\n");
return;
@ -198,29 +181,16 @@ void remove(id_t id) noexcept {
auto name = std::move(ii->name_);
release(id);
if (!name.empty()) {
int unlink_ret = ::shm_unlink(name.c_str());
if (unlink_ret == -1) {
ipc::error("fail shm_unlink[%d]: %s\n", errno, name.c_str());
}
::shm_unlink(name.c_str());
}
}
void remove(char const * name) noexcept {
if (!is_valid_string(name)) {
void remove(char const * name) {
if (name == nullptr || name[0] == '\0') {
ipc::error("fail remove: name is empty\n");
return;
}
// For portable use, a shared memory object should be identified by name of the form /somename.
ipc::string op_name;
if (name[0] == '/') {
op_name = name;
} else {
op_name = ipc::string{"/"} + name;
}
int unlink_ret = ::shm_unlink(op_name.c_str());
if (unlink_ret == -1) {
ipc::error("fail shm_unlink[%d]: %s\n", errno, op_name.c_str());
}
::shm_unlink((ipc::string{"__IPC_SHM__"} + name).c_str());
}
} // namespace shm

22
src/libipc/platform/win/condition.h
View File

@ -4,11 +4,7 @@
#include <string>
#include <mutex>
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include "libipc/utility/log.h"
#include "libipc/utility/scope_guard.h"
@ -48,15 +44,15 @@ public:
bool open(char const *name) noexcept {
close();
if (!sem_.open((std::string{name} + "_COND_SEM_").c_str())) {
if (!sem_.open((std::string{"_cond_sem_"} + name).c_str())) {
return false;
}
auto finally_sem = ipc::guard([this] { sem_.close(); }); // close when failed
if (!lock_.open((std::string{name} + "_COND_LOCK_").c_str())) {
if (!lock_.open((std::string{"_cond_lock_"} + name).c_str())) {
return false;
}
auto finally_lock = ipc::guard([this] { lock_.close(); }); // close when failed
if (!shm_.acquire((std::string{name} + "_COND_SHM_").c_str(), sizeof(std::int32_t))) {
if (!shm_.acquire((std::string{"_cond_shm_"} + name).c_str(), sizeof(std::int32_t))) {
return false;
}
finally_lock.dismiss();
@ -71,16 +67,6 @@ public:
shm_.release();
}
void clear() noexcept {
close();
}
static void clear_storage(char const *name) noexcept {
ipc::shm::handle::clear_storage(name);
ipc::sync::mutex::clear_storage(name);
ipc::sync::semaphore::clear_storage(name);
}
bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
if (!valid()) return false;
auto &cnt = counter();
@ -90,7 +76,7 @@ public:
}
DWORD ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
/**
* \see
* @see
* - https://www.microsoft.com/en-us/research/wp-content/uploads/2004/12/ImplementingCVs.pdf
* - https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-signalobjectandwait
*/

15
src/libipc/platform/win/mutex.h
View File

@ -3,11 +3,7 @@
#include <cstdint>
#include <system_error>
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include "libipc/utility/log.h"
@ -25,8 +21,6 @@ public:
mutex() noexcept = default;
~mutex() noexcept = default;
static void init() {}
HANDLE native() const noexcept {
return h_;
}
@ -37,7 +31,7 @@ public:
bool open(char const *name) noexcept {
close();
h_ = ::CreateMutex(detail::get_sa(), FALSE, detail::to_tchar(name).c_str());
h_ = ::CreateMutex(detail::get_sa(), FALSE, ipc::detail::to_tchar(name).c_str());
if (h_ == NULL) {
ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
return false;
@ -51,13 +45,6 @@ public:
h_ = NULL;
}
void clear() noexcept {
close();
}
static void clear_storage(char const */*name*/) noexcept {
}
bool lock(std::uint64_t tm) noexcept {
DWORD ret, ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
for(;;) {

13
src/libipc/platform/win/semaphore.h
View File

@ -2,11 +2,7 @@
#include <cstdint>
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include "libipc/utility/log.h"
@ -36,7 +32,7 @@ public:
close();
h_ = ::CreateSemaphore(detail::get_sa(),
static_cast<LONG>(count), LONG_MAX,
detail::to_tchar(name).c_str());
ipc::detail::to_tchar(name).c_str());
if (h_ == NULL) {
ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
return false;
@ -50,13 +46,6 @@ public:
h_ = NULL;
}
void clear() noexcept {
close();
}
static void clear_storage(char const */*name*/) noexcept {
}
bool wait(std::uint64_t tm) noexcept {
DWORD ret, ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
switch ((ret = ::WaitForSingleObject(h_, ms))) {

320
src/libipc/platform/win/shm_win.cpp
View File

@ -1,185 +1,135 @@
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include <atomic>
#include <string>
#include <utility>
#include "libipc/shm.h"
#include "libipc/def.h"
#include "libipc/pool_alloc.h"
#include "libipc/utility/log.h"
#include "libipc/memory/resource.h"
#include "to_tchar.h"
#include "get_sa.h"
namespace {
struct info_t {
std::atomic<std::int32_t> acc_;
};
struct id_info_t {
HANDLE h_ = NULL;
void* mem_ = nullptr;
std::size_t size_ = 0;
};
constexpr std::size_t calc_size(std::size_t size) {
return ((((size - 1) / alignof(info_t)) + 1) * alignof(info_t)) + sizeof(info_t);
}
inline auto& acc_of(void* mem, std::size_t size) {
return reinterpret_cast<info_t*>(static_cast<ipc::byte_t*>(mem) + size - sizeof(info_t))->acc_;
}
} // internal-linkage
namespace ipc {
namespace shm {
id_t acquire(char const * name, std::size_t size, unsigned mode) {
if (!is_valid_string(name)) {
ipc::error("fail acquire: name is empty\n");
return nullptr;
}
HANDLE h;
auto fmt_name = ipc::detail::to_tchar(name);
// Opens a named file mapping object.
if (mode == open) {
h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
if (h == NULL) {
ipc::error("fail OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
return nullptr;
}
}
// Creates or opens a named file mapping object for a specified file.
else {
std::size_t alloc_size = calc_size(size);
h = ::CreateFileMapping(INVALID_HANDLE_VALUE, detail::get_sa(), PAGE_READWRITE | SEC_COMMIT,
0, static_cast<DWORD>(alloc_size), fmt_name.c_str());
DWORD err = ::GetLastError();
// If the object exists before the function call, the function returns a handle to the existing object
// (with its current size, not the specified size), and GetLastError returns ERROR_ALREADY_EXISTS.
if ((mode == create) && (err == ERROR_ALREADY_EXISTS)) {
if (h != NULL) ::CloseHandle(h);
h = NULL;
}
if (h == NULL) {
ipc::error("fail CreateFileMapping[%d]: %s\n", static_cast<int>(err), name);
return nullptr;
}
}
auto ii = mem::alloc<id_info_t>();
ii->h_ = h;
ii->size_ = size;
return ii;
}
std::int32_t get_ref(id_t id) {
if (id == nullptr) {
return 0;
}
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ == nullptr || ii->size_ == 0) {
return 0;
}
return acc_of(ii->mem_, calc_size(ii->size_)).load(std::memory_order_acquire);
}
void sub_ref(id_t id) {
if (id == nullptr) {
ipc::error("fail sub_ref: invalid id (null)\n");
return;
}
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ == nullptr || ii->size_ == 0) {
ipc::error("fail sub_ref: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
return;
}
acc_of(ii->mem_, calc_size(ii->size_)).fetch_sub(1, std::memory_order_acq_rel);
}
void * get_mem(id_t id, std::size_t * size) {
if (id == nullptr) {
ipc::error("fail get_mem: invalid id (null)\n");
return nullptr;
}
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ != nullptr) {
if (size != nullptr) *size = ii->size_;
return ii->mem_;
}
if (ii->h_ == NULL) {
ipc::error("fail to_mem: invalid id (h = null)\n");
return nullptr;
}
LPVOID mem = ::MapViewOfFile(ii->h_, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (mem == NULL) {
ipc::error("fail MapViewOfFile[%d]\n", static_cast<int>(::GetLastError()));
return nullptr;
}
MEMORY_BASIC_INFORMATION mem_info;
if (::VirtualQuery(mem, &mem_info, sizeof(mem_info)) == 0) {
ipc::error("fail VirtualQuery[%d]\n", static_cast<int>(::GetLastError()));
return nullptr;
}
std::size_t actual_size = static_cast<std::size_t>(mem_info.RegionSize);
if (ii->size_ == 0) {
// Opening existing shared memory
ii->size_ = actual_size - sizeof(info_t);
}
// else: Keep user-requested size (already set in acquire)
ii->mem_ = mem;
if (size != nullptr) *size = ii->size_;
// Initialize or increment reference counter
acc_of(mem, calc_size(ii->size_)).fetch_add(1, std::memory_order_release);
return static_cast<void *>(mem);
}
std::int32_t release(id_t id) noexcept {
if (id == nullptr) {
ipc::error("fail release: invalid id (null)\n");
return -1;
}
std::int32_t ret = -1;
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ == nullptr || ii->size_ == 0) {
ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
}
else {
ret = acc_of(ii->mem_, calc_size(ii->size_)).fetch_sub(1, std::memory_order_acq_rel);
::UnmapViewOfFile(static_cast<LPCVOID>(ii->mem_));
}
if (ii->h_ == NULL) {
ipc::error("fail release: invalid id (h = null)\n");
}
else ::CloseHandle(ii->h_);
mem::free(ii);
return ret;
}
void remove(id_t id) noexcept {
if (id == nullptr) {
ipc::error("fail release: invalid id (null)\n");
return;
}
release(id);
}
void remove(char const * name) noexcept {
if (!is_valid_string(name)) {
ipc::error("fail remove: name is empty\n");
return;
}
// Do Nothing.
}
} // namespace shm
} // namespace ipc
#include <Windows.h>
#include <string>
#include <utility>
#include "libipc/shm.h"
#include "libipc/def.h"
#include "libipc/pool_alloc.h"
#include "libipc/utility/log.h"
#include "libipc/memory/resource.h"
#include "to_tchar.h"
#include "get_sa.h"
namespace {
struct id_info_t {
HANDLE h_ = NULL;
void* mem_ = nullptr;
std::size_t size_ = 0;
};
} // internal-linkage
namespace ipc {
namespace shm {
id_t acquire(char const * name, std::size_t size, unsigned mode) {
if (name == nullptr || name[0] == '\0') {
ipc::error("fail acquire: name is empty\n");
return nullptr;
}
HANDLE h;
auto fmt_name = ipc::detail::to_tchar(ipc::string{"__IPC_SHM__"} + name);
// Opens a named file mapping object.
if (mode == open) {
h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
}
// Creates or opens a named file mapping object for a specified file.
else {
h = ::CreateFileMapping(INVALID_HANDLE_VALUE, detail::get_sa(), PAGE_READWRITE | SEC_COMMIT,
0, static_cast<DWORD>(size), fmt_name.c_str());
// If the object exists before the function call, the function returns a handle to the existing object
// (with its current size, not the specified size), and GetLastError returns ERROR_ALREADY_EXISTS.
if ((mode == create) && (::GetLastError() == ERROR_ALREADY_EXISTS)) {
::CloseHandle(h);
h = NULL;
}
}
if (h == NULL) {
ipc::error("fail CreateFileMapping/OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
return nullptr;
}
auto ii = mem::alloc<id_info_t>();
ii->h_ = h;
ii->size_ = size;
return ii;
}
std::int32_t get_ref(id_t) {
return 0;
}
void sub_ref(id_t) {
// Do Nothing.
}
void * get_mem(id_t id, std::size_t * size) {
if (id == nullptr) {
ipc::error("fail get_mem: invalid id (null)\n");
return nullptr;
}
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ != nullptr) {
if (size != nullptr) *size = ii->size_;
return ii->mem_;
}
if (ii->h_ == NULL) {
ipc::error("fail to_mem: invalid id (h = null)\n");
return nullptr;
}
LPVOID mem = ::MapViewOfFile(ii->h_, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (mem == NULL) {
ipc::error("fail MapViewOfFile[%d]\n", static_cast<int>(::GetLastError()));
return nullptr;
}
MEMORY_BASIC_INFORMATION mem_info;
if (::VirtualQuery(mem, &mem_info, sizeof(mem_info)) == 0) {
ipc::error("fail VirtualQuery[%d]\n", static_cast<int>(::GetLastError()));
return nullptr;
}
ii->mem_ = mem;
ii->size_ = static_cast<std::size_t>(mem_info.RegionSize);
if (size != nullptr) *size = ii->size_;
return static_cast<void *>(mem);
}
std::int32_t release(id_t id) {
if (id == nullptr) {
ipc::error("fail release: invalid id (null)\n");
return -1;
}
auto ii = static_cast<id_info_t*>(id);
if (ii->mem_ == nullptr || ii->size_ == 0) {
ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
}
else ::UnmapViewOfFile(static_cast<LPCVOID>(ii->mem_));
if (ii->h_ == NULL) {
ipc::error("fail release: invalid id (h = null)\n");
}
else ::CloseHandle(ii->h_);
mem::free(ii);
return 0;
}
void remove(id_t id) {
if (id == nullptr) {
ipc::error("fail release: invalid id (null)\n");
return;
}
release(id);
}
void remove(char const * name) {
if (name == nullptr || name[0] == '\0') {
ipc::error("fail remove: name is empty\n");
return;
}
// Do Nothing.
}
} // namespace shm
} // namespace ipc

8
src/libipc/platform/win/to_tchar.h
View File

@ -1,10 +1,6 @@
#pragma once
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include <type_traits>
#include <string>
@ -45,8 +41,8 @@ constexpr auto to_tchar(ipc::string &&str) -> IsSameChar<T, ipc::string, ipc::st
}
/**
* \remarks codecvt_utf8_utf16/std::wstring_convert is deprecated
* \see https://codingtidbit.com/2020/02/09/c17-codecvt_utf8-is-deprecated/
* @remarks codecvt_utf8_utf16/std::wstring_convert is deprecated
* @see https://codingtidbit.com/2020/02/09/c17-codecvt_utf8-is-deprecated/
* https://stackoverflow.com/questions/42946335/deprecated-header-codecvt-replacement
* https://en.cppreference.com/w/cpp/locale/codecvt/in
* https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar

4
src/libipc/pool_alloc.cpp
View File

@ -5,11 +5,11 @@
namespace ipc {
namespace mem {
void* pool_alloc::alloc(std::size_t size) noexcept {
void* pool_alloc::alloc(std::size_t size) {
return async_pool_alloc::alloc(size);
}
void pool_alloc::free(void* p, std::size_t size) noexcept {
void pool_alloc::free(void* p, std::size_t size) {
async_pool_alloc::free(p, size);
}

39
src/libipc/queue.h
View File

@ -18,7 +18,6 @@
#include "libipc/utility/log.h"
#include "libipc/platform/detail.h"
#include "libipc/circ/elem_def.h"
#include "libipc/memory/resource.h"
namespace ipc {
namespace detail {
@ -30,7 +29,7 @@ protected:
template <typename Elems>
Elems* open(char const * name) {
if (!is_valid_string(name)) {
if (name == nullptr || name[0] == '\0') {
ipc::error("fail open waiter: name is empty!\n");
return nullptr;
}
@ -55,17 +54,8 @@ public:
queue_conn(const queue_conn&) = delete;
queue_conn& operator=(const queue_conn&) = delete;
void clear() noexcept {
elems_h_.clear();
}
static void clear_storage(char const *name) noexcept {
shm::handle::clear_storage(name);
}
template <typename Elems>
bool connected(Elems* elems) const noexcept {
return elems->connected(connected_);
bool connected() const noexcept {
return connected_ != 0;
}
circ::cc_t connected_id() const noexcept {
@ -78,16 +68,16 @@ public:
-> std::tuple<bool, bool, decltype(std::declval<Elems>().cursor())> {
if (elems == nullptr) return {};
// if it's already connected, just return
if (connected(elems)) return {connected(elems), false, 0};
if (connected()) return {connected(), false, 0};
connected_ = elems->connect_receiver();
return {connected(elems), true, elems->cursor()};
return {connected(), true, elems->cursor()};
}
template <typename Elems>
bool disconnect(Elems* elems) noexcept {
if (elems == nullptr) return false;
// if it's already disconnected, just return false
if (!connected(elems)) return false;
if (!connected()) return false;
elems->disconnect_receiver(std::exchange(connected_, 0));
return true;
}
@ -113,7 +103,7 @@ public:
explicit queue_base(char const * name)
: queue_base{} {
elems_ = queue_conn::template open<elems_t>(name);
elems_ = open<elems_t>(name);
}
explicit queue_base(elems_t * elems) noexcept
@ -126,17 +116,6 @@ public:
base_t::close();
}
bool open(char const * name) noexcept {
base_t::close();
elems_ = queue_conn::template open<elems_t>(name);
return elems_ != nullptr;
}
void clear() noexcept {
base_t::clear();
elems_ = nullptr;
}
elems_t * elems() noexcept { return elems_; }
elems_t const * elems() const noexcept { return elems_; }
@ -151,10 +130,6 @@ public:
elems_->disconnect_sender();
}
bool connected() const noexcept {
return base_t::connected(elems_);
}
bool connect() noexcept {
auto tp = base_t::connect(elems_);
if (std::get<0>(tp) && std::get<1>(tp)) {

28
src/libipc/shm.cpp
View File

@ -5,7 +5,6 @@
#include "libipc/shm.h"
#include "libipc/utility/pimpl.h"
#include "libipc/utility/log.h"
#include "libipc/memory/resource.h"
namespace ipc {
@ -69,21 +68,8 @@ void handle::sub_ref() noexcept {
}
bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
if (!is_valid_string(name)) {
ipc::error("fail acquire: name is empty\n");
return false;
}
if (size == 0) {
ipc::error("fail acquire: size is 0\n");
return false;
}
release();
const auto id = shm::acquire(name, size, mode);
if (!id) {
return false;
}
impl(p_)->id_ = id;
impl(p_)->n_ = name;
impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
impl(p_)->m_ = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
return valid();
}
@ -93,18 +79,6 @@ std::int32_t handle::release() {
return shm::release(detach());
}
void handle::clear() noexcept {
if (impl(p_)->id_ == nullptr) return;
shm::remove(detach());
}
void handle::clear_storage(char const * name) noexcept {
if (name == nullptr) {
return;
}
shm::remove(name);
}
void* handle::get() const {
return impl(p_)->m_;
}

15
src/libipc/sync/condition.cpp
View File

@ -2,14 +2,13 @@
#include "libipc/condition.h"
#include "libipc/utility/pimpl.h"
#include "libipc/utility/log.h"
#include "libipc/memory/resource.h"
#include "libipc/platform/detail.h"
#if defined(IPC_OS_WINDOWS_)
#include "libipc/platform/win/condition.h"
#elif defined(IPC_OS_LINUX_)
#include "libipc/platform/linux/condition.h"
#elif defined(IPC_OS_QNX_) || defined(IPC_OS_FREEBSD_)
#elif defined(IPC_OS_QNX_)
#include "libipc/platform/posix/condition.h"
#else/*IPC_OS*/
# error "Unsupported platform."
@ -50,10 +49,6 @@ bool condition::valid() const noexcept {
}
bool condition::open(char const *name) noexcept {
if (!is_valid_string(name)) {
ipc::error("fail condition open: name is empty\n");
return false;
}
return impl(p_)->cond_.open(name);
}
@ -61,14 +56,6 @@ void condition::close() noexcept {
impl(p_)->cond_.close();
}
void condition::clear() noexcept {
impl(p_)->cond_.clear();
}
void condition::clear_storage(char const * name) noexcept {
ipc::detail::sync::condition::clear_storage(name);
}
bool condition::wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
return impl(p_)->cond_.wait(mtx, tm);
}

15
src/libipc/sync/mutex.cpp
View File

@ -2,14 +2,13 @@
#include "libipc/mutex.h"
#include "libipc/utility/pimpl.h"
#include "libipc/utility/log.h"
#include "libipc/memory/resource.h"
#include "libipc/platform/detail.h"
#if defined(IPC_OS_WINDOWS_)
#include "libipc/platform/win/mutex.h"
#elif defined(IPC_OS_LINUX_)
#include "libipc/platform/linux/mutex.h"
#elif defined(IPC_OS_QNX_) || defined(IPC_OS_FREEBSD_)
#elif defined(IPC_OS_QNX_)
#include "libipc/platform/posix/mutex.h"
#else/*IPC_OS*/
# error "Unsupported platform."
@ -50,10 +49,6 @@ bool mutex::valid() const noexcept {
}
bool mutex::open(char const *name) noexcept {
if (!is_valid_string(name)) {
ipc::error("fail mutex open: name is empty\n");
return false;
}
return impl(p_)->lock_.open(name);
}
@ -61,14 +56,6 @@ void mutex::close() noexcept {
impl(p_)->lock_.close();
}
void mutex::clear() noexcept {
impl(p_)->lock_.clear();
}
void mutex::clear_storage(char const * name) noexcept {
ipc::detail::sync::mutex::clear_storage(name);
}
bool mutex::lock(std::uint64_t tm) noexcept {
return impl(p_)->lock_.lock(tm);
}

15
src/libipc/sync/semaphore.cpp
View File

@ -2,12 +2,11 @@
#include "libipc/semaphore.h"
#include "libipc/utility/pimpl.h"
#include "libipc/utility/log.h"
#include "libipc/memory/resource.h"
#include "libipc/platform/detail.h"
#if defined(IPC_OS_WINDOWS_)
#include "libipc/platform/win/semaphore.h"
#elif defined(IPC_OS_LINUX_) || defined(IPC_OS_QNX_) || defined(IPC_OS_FREEBSD_)
#elif defined(IPC_OS_LINUX_) || defined(IPC_OS_QNX_)
#include "libipc/platform/posix/semaphore_impl.h"
#else/*IPC_OS*/
# error "Unsupported platform."
@ -48,10 +47,6 @@ bool semaphore::valid() const noexcept {
}
bool semaphore::open(char const *name, std::uint32_t count) noexcept {
if (!is_valid_string(name)) {
ipc::error("fail semaphore open: name is empty\n");
return false;
}
return impl(p_)->sem_.open(name, count);
}
@ -59,14 +54,6 @@ void semaphore::close() noexcept {
impl(p_)->sem_.close();
}
void semaphore::clear() noexcept {
impl(p_)->sem_.clear();
}
void semaphore::clear_storage(char const * name) noexcept {
ipc::detail::sync::semaphore::clear_storage(name);
}
bool semaphore::wait(std::uint64_t tm) noexcept {
return impl(p_)->sem_.wait(tm);
}

22
src/libipc/sync/waiter.cpp
View File

@ -1,22 +0,0 @@
#include "libipc/waiter.h"
#include "libipc/platform/detail.h"
#if defined(IPC_OS_WINDOWS_)
#include "libipc/platform/win/mutex.h"
#elif defined(IPC_OS_LINUX_)
#include "libipc/platform/linux/mutex.h"
#elif defined(IPC_OS_QNX_) || defined(IPC_OS_FREEBSD_)
#include "libipc/platform/posix/mutex.h"
#else/*IPC_OS*/
# error "Unsupported platform."
#endif
namespace ipc {
namespace detail {
void waiter::init() {
ipc::detail::sync::mutex::init();
}
} // namespace detail
} // namespace ipc

24
src/libipc/waiter.h
View File

@ -19,8 +19,6 @@ class waiter {
std::atomic<bool> quit_ {false};
public:
static void init();
waiter() = default;
waiter(char const *name) {
open(name);
@ -36,10 +34,10 @@ public:
bool open(char const *name) noexcept {
quit_.store(false, std::memory_order_relaxed);
if (!cond_.open((std::string{name} + "_WAITER_COND_").c_str())) {
if (!cond_.open((std::string{"_waiter_cond_"} + name).c_str())) {
return false;
}
if (!lock_.open((std::string{name} + "_WAITER_LOCK_").c_str())) {
if (!lock_.open((std::string{"_waiter_lock_"} + name).c_str())) {
cond_.close();
return false;
}
@ -51,16 +49,6 @@ public:
lock_.close();
}
void clear() noexcept {
cond_.clear();
lock_.clear();
}
static void clear_storage(char const *name) noexcept {
ipc::sync::condition::clear_storage((std::string{name} + "_WAITER_COND_").c_str());
ipc::sync::mutex::clear_storage((std::string{name} + "_WAITER_LOCK_").c_str());
}
template <typename F>
bool wait_if(F &&pred, std::uint64_t tm = ipc::invalid_value) noexcept {
IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_};
@ -74,16 +62,12 @@ public:
}
bool notify() noexcept {
{
IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> barrier{lock_}; // barrier
}
std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
return cond_.notify(lock_);
}
bool broadcast() noexcept {
{
IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> barrier{lock_}; // barrier
}
std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
return cond_.broadcast(lock_);
}

10
test/CMakeLists.txt Normal file → Executable file
View File

@ -15,15 +15,11 @@ include_directories(
${LIBIPC_PROJECT_DIR}/3rdparty
${LIBIPC_PROJECT_DIR}/3rdparty/gtest/include)
# Collect only new test files (exclude archive directory)
file(GLOB SRC_FILES
${LIBIPC_PROJECT_DIR}/test/test_*.cpp
${LIBIPC_PROJECT_DIR}/test/*.cpp
# ${LIBIPC_PROJECT_DIR}/test/profiler/*.cpp
)
file(GLOB HEAD_FILES ${LIBIPC_PROJECT_DIR}/test/test_*.h)
# Ensure we don't include archived tests
list(FILTER SRC_FILES EXCLUDE REGEX "archive")
list(FILTER HEAD_FILES EXCLUDE REGEX "archive")
file(GLOB HEAD_FILES ${LIBIPC_PROJECT_DIR}/test/*.h)
add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})

28
test/archive/CMakeLists.txt.old
View File

@ -1,28 +0,0 @@
project(test-ipc)
if(NOT MSVC)
add_compile_options(
-Wno-attributes
-Wno-missing-field-initializers
-Wno-unused-variable
-Wno-unused-function)
endif()
include_directories(
${LIBIPC_PROJECT_DIR}/include
${LIBIPC_PROJECT_DIR}/src
${LIBIPC_PROJECT_DIR}/test
${LIBIPC_PROJECT_DIR}/3rdparty
${LIBIPC_PROJECT_DIR}/3rdparty/gtest/include)
file(GLOB SRC_FILES
${LIBIPC_PROJECT_DIR}/test/*.cpp
# ${LIBIPC_PROJECT_DIR}/test/profiler/*.cpp
)
file(GLOB HEAD_FILES ${LIBIPC_PROJECT_DIR}/test/*.h)
add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
link_directories(${LIBIPC_PROJECT_DIR}/3rdparty/gperftools)
target_link_libraries(${PROJECT_NAME} gtest gtest_main ipc)
#target_link_libraries(${PROJECT_NAME} tcmalloc_minimal)

134
test/archive/test_shm.cpp
View File

@ -1,134 +0,0 @@
#include <cstring>
#include <cstdint>
#include <thread>
#include "libipc/shm.h"
#include "test.h"
using namespace ipc::shm;
namespace {
TEST(SHM, acquire) {
handle shm_hd;
EXPECT_FALSE(shm_hd.valid());
EXPECT_TRUE(shm_hd.acquire("my-test-1", 1024));
EXPECT_TRUE(shm_hd.valid());
EXPECT_STREQ(shm_hd.name(), "my-test-1");
EXPECT_TRUE(shm_hd.acquire("my-test-2", 2048));
EXPECT_TRUE(shm_hd.valid());
EXPECT_STREQ(shm_hd.name(), "my-test-2");
EXPECT_TRUE(shm_hd.acquire("my-test-3", 4096));
EXPECT_TRUE(shm_hd.valid());
EXPECT_STREQ(shm_hd.name(), "my-test-3");
}
TEST(SHM, release) {
handle shm_hd;
EXPECT_FALSE(shm_hd.valid());
shm_hd.release();
EXPECT_FALSE(shm_hd.valid());
EXPECT_TRUE(shm_hd.acquire("release-test-1", 512));
EXPECT_TRUE(shm_hd.valid());
shm_hd.release();
EXPECT_FALSE(shm_hd.valid());
}
TEST(SHM, get) {
handle shm_hd;
EXPECT_TRUE(shm_hd.get() == nullptr);
EXPECT_TRUE(shm_hd.acquire("get-test", 2048));
auto mem = shm_hd.get();
EXPECT_TRUE(mem != nullptr);
EXPECT_TRUE(mem == shm_hd.get());
std::uint8_t buf[1024] = {};
EXPECT_TRUE(memcmp(mem, buf, sizeof(buf)) == 0);
handle shm_other(shm_hd.name(), shm_hd.size());
EXPECT_TRUE(shm_other.get() != shm_hd.get());
}
TEST(SHM, hello) {
handle shm_hd;
EXPECT_TRUE(shm_hd.acquire("hello-test", 128));
auto mem = shm_hd.get();
EXPECT_TRUE(mem != nullptr);
constexpr char hello[] = "hello!";
std::memcpy(mem, hello, sizeof(hello));
EXPECT_STREQ((char const *)shm_hd.get(), hello);
shm_hd.release();
EXPECT_TRUE(shm_hd.get() == nullptr);
EXPECT_TRUE(shm_hd.acquire("hello-test", 1024));
mem = shm_hd.get();
EXPECT_TRUE(mem != nullptr);
std::uint8_t buf[1024] = {};
EXPECT_TRUE(memcmp(mem, buf, sizeof(buf)) == 0);
std::memcpy(mem, hello, sizeof(hello));
EXPECT_STREQ((char const *)shm_hd.get(), hello);
}
TEST(SHM, mt) {
handle shm_hd;
EXPECT_TRUE(shm_hd.acquire("mt-test", 256));
constexpr char hello[] = "hello!";
std::memcpy(shm_hd.get(), hello, sizeof(hello));
std::thread {
[&shm_hd] {
handle shm_mt(shm_hd.name(), shm_hd.size());
shm_hd.release();
constexpr char hello[] = "hello!";
EXPECT_STREQ((char const *)shm_mt.get(), hello);
}
}.join();
EXPECT_TRUE(shm_hd.get() == nullptr);
EXPECT_FALSE(shm_hd.valid());
EXPECT_TRUE(shm_hd.acquire("mt-test", 1024));
std::uint8_t buf[1024] = {};
EXPECT_TRUE(memcmp(shm_hd.get(), buf, sizeof(buf)) == 0);
}
TEST(SHM, remove) {
{
auto id = ipc::shm::acquire("hello-remove", 111);
EXPECT_TRUE(ipc_ut::expect_exist("hello-remove", true));
ipc::shm::remove(id);
EXPECT_TRUE(ipc_ut::expect_exist("hello-remove", false));
}
{
auto id = ipc::shm::acquire("hello-remove", 111);
EXPECT_TRUE(ipc_ut::expect_exist("hello-remove", true));
ipc::shm::release(id);
EXPECT_TRUE(ipc_ut::expect_exist("hello-remove", true));
ipc::shm::remove("hello-remove");
EXPECT_TRUE(ipc_ut::expect_exist("hello-remove", false));
}
{
handle shm_hd;
EXPECT_TRUE(shm_hd.acquire("mt-test", 256));
EXPECT_TRUE(ipc_ut::expect_exist("mt-test", true));
shm_hd.clear();
EXPECT_TRUE(ipc_ut::expect_exist("mt-test", false));
}
{
handle shm_hd;
EXPECT_TRUE(shm_hd.acquire("mt-test", 256));
EXPECT_TRUE(ipc_ut::expect_exist("mt-test", true));
shm_hd.clear_storage("mt-test");
EXPECT_TRUE(ipc_ut::expect_exist("mt-test", false));
}
}
} // internal-linkage

196
test/archive/test.h → test/test.h
View File

@ -1,110 +1,86 @@
#pragma once
#include <iostream>
#include <atomic>
#include <thread>
#include <string>
#include <memory>
#include <mutex>
#include <utility>
#include "gtest/gtest.h"
#include "capo/stopwatch.hpp"
#include "thread_pool.h"
#include "libipc/platform/detail.h"
#ifdef IPC_OS_LINUX_
#include <fcntl.h> // ::open
#endif
namespace ipc_ut {
template <typename Dur>
struct unit;
template <> struct unit<std::chrono::nanoseconds> {
constexpr static char const * str() noexcept {
return "ns";
}
};
template <> struct unit<std::chrono::microseconds> {
constexpr static char const * str() noexcept {
return "us";
}
};
template <> struct unit<std::chrono::milliseconds> {
constexpr static char const * str() noexcept {
return "ms";
}
};
template <> struct unit<std::chrono::seconds> {
constexpr static char const * str() noexcept {
return "sec";
}
};
struct test_stopwatch {
capo::stopwatch<> sw_;
std::atomic_flag started_ = ATOMIC_FLAG_INIT;
void start() {
if (!started_.test_and_set()) {
sw_.start();
}
}
template <typename ToDur = std::chrono::nanoseconds>
void print_elapsed(int N, int Loops, char const * message = "") {
auto ts = sw_.elapsed<ToDur>();
std::cout << "[" << N << ", \t" << Loops << "] " << message << "\t"
<< (double(ts) / double(Loops)) << " " << unit<ToDur>::str() << std::endl;
}
template <int Factor, typename ToDur = std::chrono::nanoseconds>
void print_elapsed(int N, int M, int Loops, char const * message = "") {
auto ts = sw_.elapsed<ToDur>();
std::cout << "[" << N << "-" << M << ", \t" << Loops << "] " << message << "\t"
<< (double(ts) / double(Factor ? (Loops * Factor) : (Loops * N))) << " " << unit<ToDur>::str() << std::endl;
}
template <typename ToDur = std::chrono::nanoseconds>
void print_elapsed(int N, int M, int Loops, char const * message = "") {
print_elapsed<0, ToDur>(N, M, Loops, message);
}
};
inline static thread_pool & sender() {
static thread_pool pool;
return pool;
}
inline static thread_pool & reader() {
static thread_pool pool;
return pool;
}
#ifdef IPC_OS_LINUX_
inline bool check_exist(char const *name) noexcept {
int fd = ::open((std::string{"/dev/shm/"} + name).c_str(), O_RDONLY);
if (fd == -1) {
return false;
}
::close(fd);
return true;
}
#endif
inline bool expect_exist(char const *name, bool expected) noexcept {
#ifdef IPC_OS_LINUX_
return ipc_ut::check_exist(name) == expected;
#else
return true;
#endif
}
} // namespace ipc_ut
#pragma once
#include <iostream>
#include <atomic>
#include <thread>
#include <string>
#include <memory>
#include <mutex>
#include <utility>
#include "gtest/gtest.h"
#include "capo/stopwatch.hpp"
#include "thread_pool.h"
namespace ipc_ut {
template <typename Dur>
struct unit;
template <> struct unit<std::chrono::nanoseconds> {
constexpr static char const * str() noexcept {
return "ns";
}
};
template <> struct unit<std::chrono::microseconds> {
constexpr static char const * str() noexcept {
return "us";
}
};
template <> struct unit<std::chrono::milliseconds> {
constexpr static char const * str() noexcept {
return "ms";
}
};
template <> struct unit<std::chrono::seconds> {
constexpr static char const * str() noexcept {
return "sec";
}
};
struct test_stopwatch {
capo::stopwatch<> sw_;
std::atomic_flag started_ = ATOMIC_FLAG_INIT;
void start() {
if (!started_.test_and_set()) {
sw_.start();
}
}
template <typename ToDur = std::chrono::nanoseconds>
void print_elapsed(int N, int Loops, char const * message = "") {
auto ts = sw_.elapsed<ToDur>();
std::cout << "[" << N << ", \t" << Loops << "] " << message << "\t"
<< (double(ts) / double(Loops)) << " " << unit<ToDur>::str() << std::endl;
}
template <int Factor, typename ToDur = std::chrono::nanoseconds>
void print_elapsed(int N, int M, int Loops, char const * message = "") {
auto ts = sw_.elapsed<ToDur>();
std::cout << "[" << N << "-" << M << ", \t" << Loops << "] " << message << "\t"
<< (double(ts) / double(Factor ? (Loops * Factor) : (Loops * N))) << " " << unit<ToDur>::str() << std::endl;
}
template <typename ToDur = std::chrono::nanoseconds>
void print_elapsed(int N, int M, int Loops, char const * message = "") {
print_elapsed<0, ToDur>(N, M, Loops, message);
}
};
inline static thread_pool & sender() {
static thread_pool pool;
return pool;
}
inline static thread_pool & reader() {
static thread_pool pool;
return pool;
}
} // namespace ipc_ut

384
test/test_buffer.cpp
View File

@ -1,384 +0,0 @@
/**
* @file test_buffer.cpp
* @brief Comprehensive unit tests for ipc::buffer class
*
* This test suite covers all public interfaces of the buffer class including:
* - Constructors (default, with pointer and destructor, from array, from char)
* - Move semantics
* - Copy operations through assignment
* - Basic operations (empty, data, size)
* - Conversion methods (to_tuple, to_vector, get<T>)
* - Comparison operators
*/
#include <gtest/gtest.h>
#include <cstring>
#include <vector>
#include "libipc/buffer.h"
using namespace ipc;
namespace {
// Custom destructor tracker for testing
struct DestructorTracker {
static int count;
static void reset() { count = 0; }
static void destructor(void* p, std::size_t) {
++count;
delete[] static_cast<char*>(p);
}
};
int DestructorTracker::count = 0;
} // anonymous namespace
class BufferTest : public ::testing::Test {
protected:
void SetUp() override {
DestructorTracker::reset();
}
};
// Test default constructor
TEST_F(BufferTest, DefaultConstructor) {
buffer buf;
EXPECT_TRUE(buf.empty());
EXPECT_EQ(buf.size(), 0u);
EXPECT_EQ(buf.data(), nullptr);
}
// Test constructor with pointer, size, and destructor
TEST_F(BufferTest, ConstructorWithDestructor) {
const char* test_data = "Hello, World!";
std::size_t size = std::strlen(test_data) + 1;
char* data = new char[size];
std::strcpy(data, test_data);
buffer buf(data, size, DestructorTracker::destructor);
EXPECT_FALSE(buf.empty());
EXPECT_EQ(buf.size(), size);
EXPECT_NE(buf.data(), nullptr);
EXPECT_STREQ(static_cast<const char*>(buf.data()), test_data);
}
// Test destructor is called
TEST_F(BufferTest, DestructorCalled) {
{
char* data = new char[100];
buffer buf(data, 100, DestructorTracker::destructor);
EXPECT_EQ(DestructorTracker::count, 0);
}
EXPECT_EQ(DestructorTracker::count, 1);
}
// Test constructor with mem_to_free parameter
// Scenario: allocate a large block, but only use a portion as data
TEST_F(BufferTest, ConstructorWithMemToFree) {
// Allocate a block of 100 bytes
char* allocated_block = new char[100];
// But only use the middle 50 bytes as data (offset 25)
char* data_start = allocated_block + 25;
std::strcpy(data_start, "Offset data");
// When destroyed, should free the entire allocated_block, not just data_start
buffer buf(data_start, 50, DestructorTracker::destructor, allocated_block);
EXPECT_FALSE(buf.empty());
EXPECT_EQ(buf.size(), 50u);
EXPECT_EQ(buf.data(), data_start);
EXPECT_STREQ(static_cast<const char*>(buf.data()), "Offset data");
// Destructor will be called with allocated_block (not data_start)
// This correctly frees the entire allocation
}
// Test constructor without destructor
TEST_F(BufferTest, ConstructorWithoutDestructor) {
char stack_data[20] = "Stack data";
buffer buf(stack_data, 20);
EXPECT_FALSE(buf.empty());
EXPECT_EQ(buf.size(), 20u);
EXPECT_EQ(buf.data(), stack_data);
}
// Test constructor from byte array
TEST_F(BufferTest, ConstructorFromByteArray) {
byte_t data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
buffer buf(data);
EXPECT_FALSE(buf.empty());
EXPECT_EQ(buf.size(), 10u);
const byte_t* buf_data = buf.get<const byte_t*>();
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(buf_data[i], i);
}
}
// Test constructor from single char
TEST_F(BufferTest, ConstructorFromChar) {
char c = 'X';
buffer buf(c);
EXPECT_FALSE(buf.empty());
EXPECT_EQ(buf.size(), sizeof(char));
EXPECT_EQ(*buf.get<const char*>(), 'X');
}
// Test move constructor
TEST_F(BufferTest, MoveConstructor) {
char* data = new char[30];
std::strcpy(data, "Move test");
buffer buf1(data, 30, DestructorTracker::destructor);
void* original_ptr = buf1.data();
std::size_t original_size = buf1.size();
buffer buf2(std::move(buf1));
// buf2 should have the original data
EXPECT_EQ(buf2.data(), original_ptr);
EXPECT_EQ(buf2.size(), original_size);
EXPECT_FALSE(buf2.empty());
// buf1 should be empty after move
EXPECT_TRUE(buf1.empty());
EXPECT_EQ(buf1.size(), 0u);
}
// Test swap
TEST_F(BufferTest, Swap) {
char* data1 = new char[20];
char* data2 = new char[30];
std::strcpy(data1, "Buffer 1");
std::strcpy(data2, "Buffer 2");
buffer buf1(data1, 20, DestructorTracker::destructor);
buffer buf2(data2, 30, DestructorTracker::destructor);
void* ptr1 = buf1.data();
void* ptr2 = buf2.data();
std::size_t size1 = buf1.size();
std::size_t size2 = buf2.size();
buf1.swap(buf2);
EXPECT_EQ(buf1.data(), ptr2);
EXPECT_EQ(buf1.size(), size2);
EXPECT_EQ(buf2.data(), ptr1);
EXPECT_EQ(buf2.size(), size1);
}
// Test assignment operator (move semantics)
TEST_F(BufferTest, AssignmentOperator) {
char* data = new char[40];
std::strcpy(data, "Assignment test");
buffer buf1(data, 40, DestructorTracker::destructor);
void* original_ptr = buf1.data();
buffer buf2;
buf2 = std::move(buf1);
EXPECT_EQ(buf2.data(), original_ptr);
EXPECT_FALSE(buf2.empty());
}
// Test empty() method
TEST_F(BufferTest, EmptyMethod) {
buffer buf1;
EXPECT_TRUE(buf1.empty());
char* data = new char[10];
buffer buf2(data, 10, DestructorTracker::destructor);
EXPECT_FALSE(buf2.empty());
}
// Test data() const method
TEST_F(BufferTest, DataConstMethod) {
const char* test_str = "Const data test";
std::size_t size = std::strlen(test_str) + 1;
char* data = new char[size];
std::strcpy(data, test_str);
const buffer buf(data, size, DestructorTracker::destructor);
const void* const_data = buf.data();
EXPECT_NE(const_data, nullptr);
EXPECT_STREQ(static_cast<const char*>(const_data), test_str);
}
// Test get<T>() template method
TEST_F(BufferTest, GetTemplateMethod) {
int* int_data = new int[5]{1, 2, 3, 4, 5};
buffer buf(int_data, 5 * sizeof(int), [](void* p, std::size_t) {
delete[] static_cast<int*>(p);
});
int* retrieved = buf.get<int*>();
EXPECT_NE(retrieved, nullptr);
EXPECT_EQ(retrieved[0], 1);
EXPECT_EQ(retrieved[4], 5);
}
// Test to_tuple() non-const version
TEST_F(BufferTest, ToTupleNonConst) {
char* data = new char[25];
std::strcpy(data, "Tuple test");
buffer buf(data, 25, DestructorTracker::destructor);
// C++14 compatible: use std::get instead of structured binding
auto tuple = buf.to_tuple();
auto ptr = std::get<0>(tuple);
auto size = std::get<1>(tuple);
EXPECT_EQ(ptr, buf.data());
EXPECT_EQ(size, buf.size());
EXPECT_EQ(size, 25u);
}
// Test to_tuple() const version
TEST_F(BufferTest, ToTupleConst) {
char* data = new char[30];
std::strcpy(data, "Const tuple");
const buffer buf(data, 30, DestructorTracker::destructor);
// C++14 compatible: use std::get instead of structured binding
auto tuple = buf.to_tuple();
auto ptr = std::get<0>(tuple);
auto size = std::get<1>(tuple);
EXPECT_EQ(ptr, buf.data());
EXPECT_EQ(size, buf.size());
EXPECT_EQ(size, 30u);
}
// Test to_vector() method
TEST_F(BufferTest, ToVector) {
byte_t data_arr[5] = {10, 20, 30, 40, 50};
buffer buf(data_arr, 5);
std::vector<byte_t> vec = buf.to_vector();
ASSERT_EQ(vec.size(), 5u);
EXPECT_EQ(vec[0], 10);
EXPECT_EQ(vec[1], 20);
EXPECT_EQ(vec[2], 30);
EXPECT_EQ(vec[3], 40);
EXPECT_EQ(vec[4], 50);
}
// Test equality operator
TEST_F(BufferTest, EqualityOperator) {
byte_t data1[5] = {1, 2, 3, 4, 5};
byte_t data2[5] = {1, 2, 3, 4, 5};
byte_t data3[5] = {5, 4, 3, 2, 1};
buffer buf1(data1, 5);
buffer buf2(data2, 5);
buffer buf3(data3, 5);
EXPECT_TRUE(buf1 == buf2);
EXPECT_FALSE(buf1 == buf3);
}
// Test inequality operator
TEST_F(BufferTest, InequalityOperator) {
byte_t data1[5] = {1, 2, 3, 4, 5};
byte_t data2[5] = {1, 2, 3, 4, 5};
byte_t data3[5] = {5, 4, 3, 2, 1};
buffer buf1(data1, 5);
buffer buf2(data2, 5);
buffer buf3(data3, 5);
EXPECT_FALSE(buf1 != buf2);
EXPECT_TRUE(buf1 != buf3);
}
// Test size mismatch in equality
TEST_F(BufferTest, EqualityWithDifferentSizes) {
byte_t data1[5] = {1, 2, 3, 4, 5};
byte_t data2[3] = {1, 2, 3};
buffer buf1(data1, 5);
buffer buf2(data2, 3);
EXPECT_FALSE(buf1 == buf2);
EXPECT_TRUE(buf1 != buf2);
}
// Test empty buffers comparison
TEST_F(BufferTest, EmptyBuffersComparison) {
buffer buf1;
buffer buf2;
EXPECT_TRUE(buf1 == buf2);
EXPECT_FALSE(buf1 != buf2);
}
// Test large buffer
TEST_F(BufferTest, LargeBuffer) {
const std::size_t large_size = 1024 * 1024; // 1MB
char* large_data = new char[large_size];
// Fill with pattern
for (std::size_t i = 0; i < large_size; ++i) {
large_data[i] = static_cast<char>(i % 256);
}
buffer buf(large_data, large_size, [](void* p, std::size_t) {
delete[] static_cast<char*>(p);
});
EXPECT_FALSE(buf.empty());
EXPECT_EQ(buf.size(), large_size);
// Verify pattern
const char* data_ptr = buf.get<const char*>();
for (std::size_t i = 0; i < 100; ++i) { // Check first 100 bytes
EXPECT_EQ(data_ptr[i], static_cast<char>(i % 256));
}
}
// Test multiple move operations
TEST_F(BufferTest, MultipleMoves) {
char* data = new char[15];
std::strcpy(data, "Multi-move");
void* original_ptr = data;
buffer buf1(data, 15, DestructorTracker::destructor);
buffer buf2(std::move(buf1));
buffer buf3(std::move(buf2));
buffer buf4(std::move(buf3));
EXPECT_EQ(buf4.data(), original_ptr);
EXPECT_TRUE(buf1.empty());
EXPECT_TRUE(buf2.empty());
EXPECT_TRUE(buf3.empty());
EXPECT_FALSE(buf4.empty());
}
// Test self-assignment safety
TEST_F(BufferTest, SelfAssignment) {
char* data = new char[20];
std::strcpy(data, "Self-assign");
buffer buf(data, 20, DestructorTracker::destructor);
void* original_ptr = buf.data();
std::size_t original_size = buf.size();
buf = std::move(buf); // Self-assignment
// Should remain valid
EXPECT_EQ(buf.data(), original_ptr);
EXPECT_EQ(buf.size(), original_size);
}

550
test/test_condition.cpp
View File

@ -1,550 +0,0 @@
/**
* @file test_condition.cpp
* @brief Comprehensive unit tests for ipc::sync::condition class
*
* This test suite covers:
* - Condition variable construction (default and named)
* - Wait, notify, and broadcast operations
* - Timed wait with timeout
* - Integration with mutex
* - Producer-consumer patterns with condition variables
* - Resource cleanup
*/
#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <vector>
#include "libipc/condition.h"
#include "libipc/mutex.h"
#include "libipc/def.h"
using namespace ipc;
using namespace ipc::sync;
namespace {
std::string generate_unique_cv_name(const char* prefix) {
static int counter = 0;
return std::string(prefix) + "_cv_" + std::to_string(++counter);
}
} // anonymous namespace
class ConditionTest : public ::testing::Test {
protected:
void TearDown() override {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
};
// Test default constructor
TEST_F(ConditionTest, DefaultConstructor) {
condition cv;
}
// Test named constructor
TEST_F(ConditionTest, NamedConstructor) {
std::string name = generate_unique_cv_name("named");
condition cv(name.c_str());
EXPECT_TRUE(cv.valid());
}
// Test native() methods
TEST_F(ConditionTest, NativeHandle) {
std::string name = generate_unique_cv_name("native");
condition cv(name.c_str());
ASSERT_TRUE(cv.valid());
const void* const_handle = static_cast<const condition&>(cv).native();
void* handle = cv.native();
EXPECT_NE(const_handle, nullptr);
EXPECT_NE(handle, nullptr);
}
// Test valid() method
TEST_F(ConditionTest, Valid) {
condition cv1;
std::string name = generate_unique_cv_name("valid");
condition cv2(name.c_str());
EXPECT_TRUE(cv2.valid());
}
// Test open() method
TEST_F(ConditionTest, Open) {
std::string name = generate_unique_cv_name("open");
condition cv;
bool result = cv.open(name.c_str());
EXPECT_TRUE(result);
EXPECT_TRUE(cv.valid());
}
// Test close() method
TEST_F(ConditionTest, Close) {
std::string name = generate_unique_cv_name("close");
condition cv(name.c_str());
ASSERT_TRUE(cv.valid());
cv.close();
EXPECT_FALSE(cv.valid());
}
// Test clear() method
TEST_F(ConditionTest, Clear) {
std::string name = generate_unique_cv_name("clear");
condition cv(name.c_str());
ASSERT_TRUE(cv.valid());
cv.clear();
EXPECT_FALSE(cv.valid());
}
// Test clear_storage() static method
TEST_F(ConditionTest, ClearStorage) {
std::string name = generate_unique_cv_name("clear_storage");
{
condition cv(name.c_str());
EXPECT_TRUE(cv.valid());
}
condition::clear_storage(name.c_str());
}
// Test basic wait and notify
TEST_F(ConditionTest, WaitNotify) {
std::string cv_name = generate_unique_cv_name("wait_notify");
std::string mtx_name = generate_unique_cv_name("wait_notify_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<bool> notified{false};
std::thread waiter([&]() {
mtx.lock();
cv.wait(mtx);
notified.store(true);
mtx.unlock();
});
std::this_thread::sleep_for(std::chrono::milliseconds(50));
mtx.lock();
cv.notify(mtx);
mtx.unlock();
waiter.join();
EXPECT_TRUE(notified.load());
}
// Test broadcast to multiple waiters
TEST_F(ConditionTest, Broadcast) {
std::string cv_name = generate_unique_cv_name("broadcast");
std::string mtx_name = generate_unique_cv_name("broadcast_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<int> notified_count{0};
const int num_waiters = 5;
std::vector<std::thread> waiters;
for (int i = 0; i < num_waiters; ++i) {
waiters.emplace_back([&]() {
mtx.lock();
cv.wait(mtx);
++notified_count;
mtx.unlock();
});
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
mtx.lock();
cv.broadcast(mtx);
mtx.unlock();
for (auto& t : waiters) {
t.join();
}
EXPECT_EQ(notified_count.load(), num_waiters);
}
// Test timed wait with timeout
TEST_F(ConditionTest, TimedWait) {
std::string cv_name = generate_unique_cv_name("timed_wait");
std::string mtx_name = generate_unique_cv_name("timed_wait_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
auto start = std::chrono::steady_clock::now();
mtx.lock();
bool result = cv.wait(mtx, 100); // 100ms timeout
mtx.unlock();
auto end = std::chrono::steady_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
EXPECT_FALSE(result); // Should timeout
EXPECT_GE(elapsed, 80); // Allow some tolerance
}
// Test wait with immediate notify
TEST_F(ConditionTest, ImmediateNotify) {
std::string cv_name = generate_unique_cv_name("immediate");
std::string mtx_name = generate_unique_cv_name("immediate_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<bool> wait_started{false};
std::atomic<bool> notified{false};
std::thread waiter([&]() {
mtx.lock();
wait_started.store(true);
cv.wait(mtx, 1000); // 1 second timeout
notified.store(true);
mtx.unlock();
});
// Wait for waiter to start
while (!wait_started.load()) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
std::this_thread::sleep_for(std::chrono::milliseconds(10));
mtx.lock();
cv.notify(mtx);
mtx.unlock();
waiter.join();
EXPECT_TRUE(notified.load());
}
// Test producer-consumer with condition variable
TEST_F(ConditionTest, ProducerConsumer) {
std::string cv_name = generate_unique_cv_name("prod_cons");
std::string mtx_name = generate_unique_cv_name("prod_cons_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<int> buffer{0};
std::atomic<bool> ready{false};
std::atomic<int> consumed_value{0};
std::thread producer([&]() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
mtx.lock();
buffer.store(42);
ready.store(true);
cv.notify(mtx);
mtx.unlock();
});
std::thread consumer([&]() {
mtx.lock();
while (!ready.load()) {
cv.wait(mtx, 2000);
}
consumed_value.store(buffer.load());
mtx.unlock();
});
producer.join();
consumer.join();
EXPECT_EQ(consumed_value.load(), 42);
}
// Test multiple notify operations
TEST_F(ConditionTest, MultipleNotify) {
std::string cv_name = generate_unique_cv_name("multi_notify");
std::string mtx_name = generate_unique_cv_name("multi_notify_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<int> notify_count{0};
const int num_notifications = 3;
std::thread waiter([&]() {
for (int i = 0; i < num_notifications; ++i) {
mtx.lock();
cv.wait(mtx, 1000);
++notify_count;
mtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
});
for (int i = 0; i < num_notifications; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
mtx.lock();
cv.notify(mtx);
mtx.unlock();
}
waiter.join();
EXPECT_EQ(notify_count.load(), num_notifications);
}
// Test notify vs broadcast
TEST_F(ConditionTest, NotifyVsBroadcast) {
std::string cv_name = generate_unique_cv_name("notify_vs_broadcast");
std::string mtx_name = generate_unique_cv_name("notify_vs_broadcast_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
// Test notify (should wake one)
std::atomic<int> notify_woken{0};
std::vector<std::thread> notify_waiters;
for (int i = 0; i < 3; ++i) {
notify_waiters.emplace_back([&]() {
mtx.lock();
cv.wait(mtx, 100);
++notify_woken;
mtx.unlock();
});
}
std::this_thread::sleep_for(std::chrono::milliseconds(50));
mtx.lock();
cv.notify(mtx); // Wake one
mtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(150));
for (auto& t : notify_waiters) {
t.join();
}
// At least one should be woken by notify
EXPECT_GE(notify_woken.load(), 1);
}
// Test condition variable with spurious wakeups pattern
TEST_F(ConditionTest, SpuriousWakeupPattern) {
std::string cv_name = generate_unique_cv_name("spurious");
std::string mtx_name = generate_unique_cv_name("spurious_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<bool> predicate{false};
std::atomic<bool> done{false};
std::thread waiter([&]() {
mtx.lock();
while (!predicate.load()) {
if (!cv.wait(mtx, 100)) {
// Timeout - check predicate again
if (predicate.load()) break;
}
}
done.store(true);
mtx.unlock();
});
std::this_thread::sleep_for(std::chrono::milliseconds(50));
mtx.lock();
predicate.store(true);
cv.notify(mtx);
mtx.unlock();
waiter.join();
EXPECT_TRUE(done.load());
}
// Test reopen after close
TEST_F(ConditionTest, ReopenAfterClose) {
std::string name = generate_unique_cv_name("reopen");
condition cv;
ASSERT_TRUE(cv.open(name.c_str()));
EXPECT_TRUE(cv.valid());
cv.close();
EXPECT_FALSE(cv.valid());
ASSERT_TRUE(cv.open(name.c_str()));
EXPECT_TRUE(cv.valid());
}
// Test named condition variable sharing between threads
TEST_F(ConditionTest, NamedSharing) {
std::string cv_name = generate_unique_cv_name("sharing");
std::string mtx_name = generate_unique_cv_name("sharing_mtx");
std::atomic<int> value{0};
std::thread t1([&]() {
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
mtx.lock();
cv.wait(mtx, 1000);
value.store(100);
mtx.unlock();
});
std::thread t2([&]() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
mtx.lock();
cv.notify(mtx);
mtx.unlock();
});
t1.join();
t2.join();
EXPECT_EQ(value.load(), 100);
}
// Test infinite wait
TEST_F(ConditionTest, InfiniteWait) {
std::string cv_name = generate_unique_cv_name("infinite");
std::string mtx_name = generate_unique_cv_name("infinite_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<bool> woken{false};
std::thread waiter([&]() {
mtx.lock();
cv.wait(mtx, invalid_value); // Infinite wait
woken.store(true);
mtx.unlock();
});
std::this_thread::sleep_for(std::chrono::milliseconds(100));
mtx.lock();
cv.notify(mtx);
mtx.unlock();
waiter.join();
EXPECT_TRUE(woken.load());
}
// Test broadcast with sequential waiters
TEST_F(ConditionTest, BroadcastSequential) {
std::string cv_name = generate_unique_cv_name("broadcast_seq");
std::string mtx_name = generate_unique_cv_name("broadcast_seq_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
ASSERT_TRUE(mtx.valid());
std::atomic<int> processed{0};
const int num_threads = 4;
std::vector<std::thread> threads;
for (int i = 0; i < num_threads; ++i) {
threads.emplace_back([&]() {
mtx.lock();
cv.wait(mtx, 2000);
++processed;
mtx.unlock();
});
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
mtx.lock();
cv.broadcast(mtx);
mtx.unlock();
for (auto& t : threads) {
t.join();
}
EXPECT_EQ(processed.load(), num_threads);
}
// Test operations after clear
TEST_F(ConditionTest, AfterClear) {
std::string cv_name = generate_unique_cv_name("after_clear");
std::string mtx_name = generate_unique_cv_name("after_clear_mtx");
condition cv(cv_name.c_str());
mutex mtx(mtx_name.c_str());
ASSERT_TRUE(cv.valid());
cv.clear();
EXPECT_FALSE(cv.valid());
// Operations after clear should fail gracefully
mtx.lock();
EXPECT_FALSE(cv.wait(mtx, 10));
EXPECT_FALSE(cv.notify(mtx));
EXPECT_FALSE(cv.broadcast(mtx));
mtx.unlock();
}

54
test/archive/test_ipc.cpp → test/test_ipc.cpp
View File

@ -151,59 +151,11 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {
} // internal-linkage
TEST(IPC, clear) {
{
chan<relat::single, relat::single, trans::unicast> c{"ssu"};
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__AC_CONN__ssu", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_LOCK_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_LOCK_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_LOCK_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__QU_CONN__ssu__64__16", true));
c.clear();
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__AC_CONN__ssu", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_LOCK_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_LOCK_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_LOCK_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__QU_CONN__ssu__64__16", false));
}
{
chan<relat::single, relat::single, trans::unicast> c{"ssu"};
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__AC_CONN__ssu", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_LOCK_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_LOCK_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_LOCK_", true));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__QU_CONN__ssu__64__16", true));
chan<relat::single, relat::single, trans::unicast>::clear_storage("ssu");
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__AC_CONN__ssu", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__CC_CONN__ssu_WAITER_LOCK_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__RD_CONN__ssu_WAITER_LOCK_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__WT_CONN__ssu_WAITER_LOCK_", false));
EXPECT_TRUE(ipc_ut::expect_exist("__IPC_SHM__QU_CONN__ssu__64__16", false));
c.release(); // Call this interface to prevent destruction-time exceptions.
}
}
TEST(IPC, basic_ssu) {
TEST(IPC, basic) {
test_basic<relat::single, relat::single, trans::unicast >("ssu");
}
TEST(IPC, basic_smb) {
//test_basic<relat::single, relat::multi , trans::unicast >("smu");
//test_basic<relat::multi , relat::multi , trans::unicast >("mmu");
test_basic<relat::single, relat::multi , trans::broadcast>("smb");
}
TEST(IPC, basic_mmb) {
test_basic<relat::multi , relat::multi , trans::broadcast>("mmb");
}

643
test/test_ipc_channel.cpp
View File

@ -1,643 +0,0 @@
/**
* @file test_ipc_channel.cpp
* @brief Comprehensive unit tests for ipc::route and ipc::channel classes
*
* This test suite covers:
* - Route (single producer, multiple consumer) functionality
* - Channel (multiple producer, multiple consumer) functionality
* - Construction, connection, and disconnection
* - Send and receive operations (blocking and non-blocking)
* - Timeout handling
* - Named channels with prefix
* - Resource cleanup and storage management
* - Clone operations
* - Wait for receiver functionality
* - Error conditions
*/
#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <vector>
#include <string>
#include <cstring>
#include <mutex>
#include <condition_variable>
#include "libipc/ipc.h"
#include "libipc/buffer.h"
using namespace ipc;
namespace {
// Simple latch implementation for C++14 (similar to C++20 std::latch)
class latch {
public:
explicit latch(std::ptrdiff_t count) : count_(count) {}
void count_down() {
std::unique_lock<std::mutex> lock(mutex_);
if (--count_ <= 0) {
cv_.notify_all();
}
}
void wait() {
std::unique_lock<std::mutex> lock(mutex_);
cv_.wait(lock, [this] { return count_ <= 0; });
}
private:
std::ptrdiff_t count_;
std::mutex mutex_;
std::condition_variable cv_;
};
std::string generate_unique_ipc_name(const char* prefix) {
static int counter = 0;
return std::string(prefix) + "_ipc_" + std::to_string(++counter);
}
// Helper to create a test buffer with data
buffer make_test_buffer(const std::string& data) {
char* mem = new char[data.size() + 1];
std::strcpy(mem, data.c_str());
return buffer(mem, data.size() + 1, [](void* p, std::size_t) {
delete[] static_cast<char*>(p);
});
}
// Helper to check buffer content
bool check_buffer_content(const buffer& buf, const std::string& expected) {
if (buf.empty() || buf.size() != expected.size() + 1) {
return false;
}
return std::strcmp(static_cast<const char*>(buf.data()), expected.c_str()) == 0;
}
} // anonymous namespace
// ========== Route Tests (Single Producer, Multiple Consumer) ==========
class RouteTest : public ::testing::Test {
protected:
void TearDown() override {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
};
// Test default construction
TEST_F(RouteTest, DefaultConstruction) {
route r;
EXPECT_FALSE(r.valid());
}
// Test construction with name
TEST_F(RouteTest, ConstructionWithName) {
std::string name = generate_unique_ipc_name("route_ctor");
route r(name.c_str(), sender);
EXPECT_TRUE(r.valid());
EXPECT_STREQ(r.name(), name.c_str());
}
// Test construction with prefix
TEST_F(RouteTest, ConstructionWithPrefix) {
std::string name = generate_unique_ipc_name("route_prefix");
route r(prefix{"my_prefix"}, name.c_str(), sender);
EXPECT_TRUE(r.valid());
}
// Test move constructor
TEST_F(RouteTest, MoveConstructor) {
std::string name = generate_unique_ipc_name("route_move");
route r1(name.c_str(), sender);
ASSERT_TRUE(r1.valid());
const char* name_ptr = r1.name();
route r2(std::move(r1));
EXPECT_TRUE(r2.valid());
EXPECT_STREQ(r2.name(), name_ptr);
}
// Test assignment operator
TEST_F(RouteTest, Assignment) {
std::string name = generate_unique_ipc_name("route_assign");
route r1(name.c_str(), sender);
route r2;
r2 = std::move(r1);
EXPECT_TRUE(r2.valid());
}
// Test connect method
TEST_F(RouteTest, Connect) {
std::string name = generate_unique_ipc_name("route_connect");
route r;
bool connected = r.connect(name.c_str(), sender);
EXPECT_TRUE(connected);
EXPECT_TRUE(r.valid());
}
// Test connect with prefix
TEST_F(RouteTest, ConnectWithPrefix) {
std::string name = generate_unique_ipc_name("route_connect_prefix");
route r;
bool connected = r.connect(prefix{"test"}, name.c_str(), sender);
EXPECT_TRUE(connected);
EXPECT_TRUE(r.valid());
}
// Test reconnect
TEST_F(RouteTest, Reconnect) {
std::string name = generate_unique_ipc_name("route_reconnect");
route r(name.c_str(), sender);
ASSERT_TRUE(r.valid());
bool reconnected = r.reconnect(sender | receiver);
EXPECT_TRUE(reconnected);
}
// Test disconnect
TEST_F(RouteTest, Disconnect) {
std::string name = generate_unique_ipc_name("route_disconnect");
route r(name.c_str(), sender);
ASSERT_TRUE(r.valid());
r.disconnect();
// After disconnect, behavior depends on implementation
}
// Test clone
TEST_F(RouteTest, Clone) {
std::string name = generate_unique_ipc_name("route_clone");
route r1(name.c_str(), sender);
ASSERT_TRUE(r1.valid());
route r2 = r1.clone();
EXPECT_TRUE(r2.valid());
EXPECT_STREQ(r1.name(), r2.name());
}
// Test mode accessor
TEST_F(RouteTest, Mode) {
std::string name = generate_unique_ipc_name("route_mode");
route r(name.c_str(), sender);
EXPECT_EQ(r.mode(), sender);
}
// Test release
TEST_F(RouteTest, Release) {
std::string name = generate_unique_ipc_name("route_release");
route r(name.c_str(), sender);
ASSERT_TRUE(r.valid());
r.release();
EXPECT_FALSE(r.valid());
}
// Test clear
TEST_F(RouteTest, Clear) {
std::string name = generate_unique_ipc_name("route_clear");
route r(name.c_str(), sender);
ASSERT_TRUE(r.valid());
r.clear();
EXPECT_FALSE(r.valid());
}
// Test clear_storage static method
TEST_F(RouteTest, ClearStorage) {
std::string name = generate_unique_ipc_name("route_clear_storage");
{
route r(name.c_str(), sender);
EXPECT_TRUE(r.valid());
}
route::clear_storage(name.c_str());
}
// Test clear_storage with prefix
TEST_F(RouteTest, ClearStorageWithPrefix) {
std::string name = generate_unique_ipc_name("route_clear_prefix");
{
route r(prefix{"test"}, name.c_str(), sender);
EXPECT_TRUE(r.valid());
}
route::clear_storage(prefix{"test"}, name.c_str());
}
// Test send without receiver (should fail)
TEST_F(RouteTest, SendWithoutReceiver) {
std::string name = generate_unique_ipc_name("route_send_no_recv");
route r(name.c_str(), sender);
ASSERT_TRUE(r.valid());
buffer buf = make_test_buffer("test");
bool sent = r.send(buf, 10); // 10ms timeout
EXPECT_FALSE(sent); // Should fail - no receiver
}
// Test try_send without receiver
TEST_F(RouteTest, TrySendWithoutReceiver) {
std::string name = generate_unique_ipc_name("route_try_send_no_recv");
route r(name.c_str(), sender);
ASSERT_TRUE(r.valid());
buffer buf = make_test_buffer("test");
bool sent = r.try_send(buf, 10);
EXPECT_FALSE(sent);
}
// Test send and receive with buffer
TEST_F(RouteTest, SendReceiveBuffer) {
std::string name = generate_unique_ipc_name("route_send_recv_buf");
route sender_r(name.c_str(), sender);
route receiver_r(name.c_str(), receiver);
ASSERT_TRUE(sender_r.valid());
ASSERT_TRUE(receiver_r.valid());
buffer send_buf = make_test_buffer("Hello Route");
std::thread sender_thread([&]() {
bool sent = sender_r.send(send_buf);
EXPECT_TRUE(sent);
});
std::thread receiver_thread([&]() {
buffer recv_buf = receiver_r.recv();
EXPECT_TRUE(check_buffer_content(recv_buf, "Hello Route"));
});
sender_thread.join();
receiver_thread.join();
}
// Test send and receive with string
TEST_F(RouteTest, SendReceiveString) {
std::string name = generate_unique_ipc_name("route_send_recv_str");
route sender_r(name.c_str(), sender);
route receiver_r(name.c_str(), receiver);
ASSERT_TRUE(sender_r.valid());
ASSERT_TRUE(receiver_r.valid());
std::string test_str = "Test String";
std::thread sender_thread([&]() {
bool sent = sender_r.send(test_str);
EXPECT_TRUE(sent);
});
std::thread receiver_thread([&]() {
buffer recv_buf = receiver_r.recv();
EXPECT_TRUE(check_buffer_content(recv_buf, test_str));
});
sender_thread.join();
receiver_thread.join();
}
// Test send and receive with raw data
TEST_F(RouteTest, SendReceiveRawData) {
std::string name = generate_unique_ipc_name("route_send_recv_raw");
route sender_r(name.c_str(), sender);
route receiver_r(name.c_str(), receiver);
ASSERT_TRUE(sender_r.valid());
ASSERT_TRUE(receiver_r.valid());
const char* data = "Raw Data Test";
std::size_t size = std::strlen(data) + 1;
std::thread sender_thread([&]() {
bool sent = sender_r.send(data, size);
EXPECT_TRUE(sent);
});
std::thread receiver_thread([&]() {
buffer recv_buf = receiver_r.recv();
EXPECT_EQ(recv_buf.size(), size);
EXPECT_STREQ(static_cast<const char*>(recv_buf.data()), data);
});
sender_thread.join();
receiver_thread.join();
}
// Test try_recv when empty
TEST_F(RouteTest, TryRecvEmpty) {
std::string name = generate_unique_ipc_name("route_try_recv_empty");
route r(name.c_str(), receiver);
ASSERT_TRUE(r.valid());
buffer buf = r.try_recv();
EXPECT_TRUE(buf.empty());
}
// Test recv_count
TEST_F(RouteTest, RecvCount) {
std::string name = generate_unique_ipc_name("route_recv_count");
route sender_r(name.c_str(), sender);
route receiver_r(name.c_str(), receiver);
ASSERT_TRUE(sender_r.valid());
ASSERT_TRUE(receiver_r.valid());
std::size_t count = sender_r.recv_count();
EXPECT_GE(count, 0u);
}
// Test wait_for_recv
TEST_F(RouteTest, WaitForRecv) {
std::string name = generate_unique_ipc_name("route_wait_recv");
route sender_r(name.c_str(), sender);
std::thread receiver_thread([&]() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
route receiver_r(name.c_str(), receiver);
});
bool waited = sender_r.wait_for_recv(1, 500);
receiver_thread.join();
// Result depends on timing
}
// Test static wait_for_recv
TEST_F(RouteTest, StaticWaitForRecv) {
std::string name = generate_unique_ipc_name("route_static_wait");
std::thread receiver_thread([&]() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
route receiver_r(name.c_str(), receiver);
});
bool waited = route::wait_for_recv(name.c_str(), 1, 500);
receiver_thread.join();
}
// Test one sender, multiple receivers
TEST_F(RouteTest, OneSenderMultipleReceivers) {
std::string name = generate_unique_ipc_name("route_1_to_n");
route sender_r(name.c_str(), sender);
ASSERT_TRUE(sender_r.valid());
const int num_receivers = 3;
std::vector<std::atomic<bool>> received(num_receivers);
for (auto& r : received) r.store(false);
std::vector<std::thread> receivers;
for (int i = 0; i < num_receivers; ++i) {
receivers.emplace_back([&, i]() {
route receiver_r(name.c_str(), receiver);
buffer buf = receiver_r.recv(1000);
if (check_buffer_content(buf, "Broadcast")) {
received[i].store(true);
}
});
}
std::this_thread::sleep_for(std::chrono::milliseconds(50));
sender_r.send(std::string("Broadcast"));
for (auto& t : receivers) {
t.join();
}
// All receivers should receive the message (broadcast)
for (const auto& r : received) {
EXPECT_TRUE(r.load());
}
}
// ========== Channel Tests (Multiple Producer, Multiple Consumer) ==========
class ChannelTest : public ::testing::Test {
protected:
void TearDown() override {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
};
// Test default construction
TEST_F(ChannelTest, DefaultConstruction) {
channel ch;
EXPECT_FALSE(ch.valid());
}
// Test construction with name
TEST_F(ChannelTest, ConstructionWithName) {
std::string name = generate_unique_ipc_name("channel_ctor");
channel ch(name.c_str(), sender);
EXPECT_TRUE(ch.valid());
EXPECT_STREQ(ch.name(), name.c_str());
}
// Test send and receive
TEST_F(ChannelTest, SendReceive) {
std::string name = generate_unique_ipc_name("channel_send_recv");
channel sender_ch(name.c_str(), sender);
channel receiver_ch(name.c_str(), receiver);
ASSERT_TRUE(sender_ch.valid());
ASSERT_TRUE(receiver_ch.valid());
std::thread sender_thread([&]() {
sender_ch.send(std::string("Channel Test"));
});
std::thread receiver_thread([&]() {
buffer buf = receiver_ch.recv();
EXPECT_TRUE(check_buffer_content(buf, "Channel Test"));
});
sender_thread.join();
receiver_thread.join();
}
// Test multiple senders
TEST_F(ChannelTest, MultipleSenders) {
std::string name = generate_unique_ipc_name("channel_multi_send");
channel receiver_ch(name.c_str(), receiver);
ASSERT_TRUE(receiver_ch.valid());
const int num_senders = 3;
std::atomic<int> received_count{0};
std::vector<std::thread> senders;
for (int i = 0; i < num_senders; ++i) {
senders.emplace_back([&, i]() {
channel sender_ch(name.c_str(), sender);
std::string msg = "Sender" + std::to_string(i);
sender_ch.send(msg);
});
}
std::thread receiver([&]() {
for (int i = 0; i < num_senders; ++i) {
buffer buf = receiver_ch.recv(1000);
if (!buf.empty()) {
++received_count;
}
}
});
for (auto& t : senders) {
t.join();
}
receiver.join();
EXPECT_EQ(received_count.load(), num_senders);
}
// Test multiple senders and receivers
TEST_F(ChannelTest, MultipleSendersReceivers) {
std::string name = generate_unique_ipc_name("channel_m_to_n");
const int num_senders = 2;
const int num_receivers = 2;
const int messages_per_sender = 5;
const int total_messages = num_senders * messages_per_sender; // Each receiver should get all messages
std::atomic<int> sent_count{0};
std::atomic<int> received_count{0};
// Use latch to ensure receivers are ready before senders start
latch receivers_ready(num_receivers);
std::vector<std::thread> receivers;
for (int i = 0; i < num_receivers; ++i) {
receivers.emplace_back([&, i]() {
channel ch(name.c_str(), receiver);
receivers_ready.count_down(); // Signal this receiver is ready
// Each receiver should receive ALL messages from ALL senders (broadcast mode)
for (int j = 0; j < total_messages; ++j) {
buffer buf = ch.recv(2000);
if (!buf.empty()) {
++received_count;
}
}
});
}
// Wait for all receivers to be ready
receivers_ready.wait();
std::vector<std::thread> senders;
for (int i = 0; i < num_senders; ++i) {
senders.emplace_back([&, i]() {
channel ch(name.c_str(), sender);
for (int j = 0; j < messages_per_sender; ++j) {
std::string msg = "S" + std::to_string(i) + "M" + std::to_string(j);
if (ch.send(msg, 1000)) {
++sent_count;
}
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
});
}
for (auto& t : senders) {
t.join();
}
for (auto& t : receivers) {
t.join();
}
EXPECT_EQ(sent_count.load(), num_senders * messages_per_sender);
// All messages should be received (broadcast mode)
EXPECT_EQ(received_count.load(), num_senders * messages_per_sender * num_receivers);
}
// Test try_send and try_recv
TEST_F(ChannelTest, TrySendTryRecv) {
std::string name = generate_unique_ipc_name("channel_try");
channel sender_ch(name.c_str(), sender);
channel receiver_ch(name.c_str(), receiver);
ASSERT_TRUE(sender_ch.valid());
ASSERT_TRUE(receiver_ch.valid());
bool sent = sender_ch.try_send(std::string("Try Test"));
if (sent) {
buffer buf = receiver_ch.try_recv();
EXPECT_FALSE(buf.empty());
}
}
// Test timeout scenarios
TEST_F(ChannelTest, SendTimeout) {
std::string name = generate_unique_ipc_name("channel_timeout");
channel ch(name.c_str(), sender);
ASSERT_TRUE(ch.valid());
// Send with very short timeout (may fail without receiver)
bool sent = ch.send(std::string("Timeout Test"), 1);
}
// Test clear and clear_storage
TEST_F(ChannelTest, ClearStorage) {
std::string name = generate_unique_ipc_name("channel_clear");
{
channel ch(name.c_str(), sender);
EXPECT_TRUE(ch.valid());
}
channel::clear_storage(name.c_str());
}
// Test handle() method
TEST_F(ChannelTest, Handle) {
std::string name = generate_unique_ipc_name("channel_handle");
channel ch(name.c_str(), sender);
ASSERT_TRUE(ch.valid());
handle_t h = ch.handle();
EXPECT_NE(h, nullptr);
}

613
test/test_locks.cpp
View File

@ -1,613 +0,0 @@
/**
* @file test_locks.cpp
* @brief Comprehensive unit tests for ipc::rw_lock and ipc::spin_lock classes
*
* This test suite covers:
* - spin_lock: basic lock/unlock operations
* - rw_lock: read-write lock functionality
* - rw_lock: exclusive (write) locks
* - rw_lock: shared (read) locks
* - Concurrent access patterns
* - Reader-writer scenarios
*/
#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <vector>
#include "libipc/rw_lock.h"
using namespace ipc;
// ========== spin_lock Tests ==========
class SpinLockTest : public ::testing::Test {
protected:
void TearDown() override {
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
};
// Test basic lock and unlock
TEST_F(SpinLockTest, BasicLockUnlock) {
spin_lock lock;
lock.lock();
lock.unlock();
// Should complete without hanging
}
// Test multiple lock/unlock cycles
TEST_F(SpinLockTest, MultipleCycles) {
spin_lock lock;
for (int i = 0; i < 100; ++i) {
lock.lock();
lock.unlock();
}
}
// Test critical section protection
TEST_F(SpinLockTest, CriticalSection) {
spin_lock lock;
int counter = 0;
const int iterations = 1000;
auto increment_task = [&]() {
for (int i = 0; i < iterations; ++i) {
lock.lock();
++counter;
lock.unlock();
}
};
std::thread t1(increment_task);
std::thread t2(increment_task);
t1.join();
t2.join();
EXPECT_EQ(counter, iterations * 2);
}
// Test mutual exclusion
TEST_F(SpinLockTest, MutualExclusion) {
spin_lock lock;
std::atomic<bool> thread1_in_cs{false};
std::atomic<bool> thread2_in_cs{false};
std::atomic<bool> violation{false};
auto cs_task = [&](std::atomic<bool>& my_flag, std::atomic<bool>& other_flag) {
for (int i = 0; i < 100; ++i) {
lock.lock();
my_flag.store(true);
if (other_flag.load()) {
violation.store(true);
}
std::this_thread::sleep_for(std::chrono::microseconds(10));
my_flag.store(false);
lock.unlock();
std::this_thread::yield();
}
};
std::thread t1(cs_task, std::ref(thread1_in_cs), std::ref(thread2_in_cs));
std::thread t2(cs_task, std::ref(thread2_in_cs), std::ref(thread1_in_cs));
t1.join();
t2.join();
EXPECT_FALSE(violation.load());
}
// Test concurrent access
TEST_F(SpinLockTest, ConcurrentAccess) {
spin_lock lock;
std::atomic<int> shared_data{0};
const int num_threads = 4;
const int ops_per_thread = 100;
std::vector<std::thread> threads;
for (int i = 0; i < num_threads; ++i) {
threads.emplace_back([&]() {
for (int j = 0; j < ops_per_thread; ++j) {
lock.lock();
int temp = shared_data.load();
std::this_thread::yield();
shared_data.store(temp + 1);
lock.unlock();
}
});
}
for (auto& t : threads) {
t.join();
}
EXPECT_EQ(shared_data.load(), num_threads * ops_per_thread);
}
// Test rapid lock/unlock
TEST_F(SpinLockTest, RapidLockUnlock) {
spin_lock lock;
auto rapid_task = [&]() {
for (int i = 0; i < 10000; ++i) {
lock.lock();
lock.unlock();
}
};
std::thread t1(rapid_task);
std::thread t2(rapid_task);
t1.join();
t2.join();
// Should complete without deadlock
}
// Test contention scenario
TEST_F(SpinLockTest, Contention) {
spin_lock lock;
std::atomic<int> work_done{0};
const int num_threads = 8;
std::vector<std::thread> threads;
for (int i = 0; i < num_threads; ++i) {
threads.emplace_back([&]() {
for (int j = 0; j < 50; ++j) {
lock.lock();
++work_done;
std::this_thread::sleep_for(std::chrono::microseconds(100));
lock.unlock();
std::this_thread::yield();
}
});
}
for (auto& t : threads) {
t.join();
}
EXPECT_EQ(work_done.load(), num_threads * 50);
}
// ========== rw_lock Tests ==========
class RWLockTest : public ::testing::Test {
protected:
void TearDown() override {
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
};
// Test basic write lock and unlock
TEST_F(RWLockTest, BasicWriteLock) {
rw_lock lock;
lock.lock();
lock.unlock();
// Should complete without hanging
}
// Test basic read lock and unlock
TEST_F(RWLockTest, BasicReadLock) {
rw_lock lock;
lock.lock_shared();
lock.unlock_shared();
// Should complete without hanging
}
// Test multiple write cycles
TEST_F(RWLockTest, MultipleWriteCycles) {
rw_lock lock;
for (int i = 0; i < 100; ++i) {
lock.lock();
lock.unlock();
}
}
// Test multiple read cycles
TEST_F(RWLockTest, MultipleReadCycles) {
rw_lock lock;
for (int i = 0; i < 100; ++i) {
lock.lock_shared();
lock.unlock_shared();
}
}
// Test write lock protects data
TEST_F(RWLockTest, WriteLockProtection) {
rw_lock lock;
int data = 0;
const int iterations = 500;
auto writer_task = [&]() {
for (int i = 0; i < iterations; ++i) {
lock.lock();
++data;
lock.unlock();
}
};
std::thread t1(writer_task);
std::thread t2(writer_task);
t1.join();
t2.join();
EXPECT_EQ(data, iterations * 2);
}
// Test multiple readers can access concurrently
TEST_F(RWLockTest, ConcurrentReaders) {
rw_lock lock;
std::atomic<int> concurrent_readers{0};
std::atomic<int> max_concurrent{0};
const int num_readers = 5;
std::vector<std::thread> readers;
for (int i = 0; i < num_readers; ++i) {
readers.emplace_back([&]() {
for (int j = 0; j < 20; ++j) {
lock.lock_shared();
int current = ++concurrent_readers;
// Track maximum concurrent readers
int current_max = max_concurrent.load();
while (current > current_max) {
if (max_concurrent.compare_exchange_weak(current_max, current)) {
break;
}
}
std::this_thread::sleep_for(std::chrono::microseconds(100));
--concurrent_readers;
lock.unlock_shared();
std::this_thread::yield();
}
});
}
for (auto& t : readers) {
t.join();
}
// Should have had multiple concurrent readers
EXPECT_GT(max_concurrent.load(), 1);
}
// Test writers have exclusive access
TEST_F(RWLockTest, WriterExclusiveAccess) {
rw_lock lock;
std::atomic<bool> writer_in_cs{false};
std::atomic<bool> violation{false};
auto writer_task = [&]() {
for (int i = 0; i < 50; ++i) {
lock.lock();
if (writer_in_cs.exchange(true)) {
violation.store(true);
}
std::this_thread::sleep_for(std::chrono::microseconds(50));
writer_in_cs.store(false);
lock.unlock();
std::this_thread::yield();
}
};
std::thread t1(writer_task);
std::thread t2(writer_task);
t1.join();
t2.join();
EXPECT_FALSE(violation.load());
}
// Test readers and writers don't overlap
TEST_F(RWLockTest, ReadersWritersNoOverlap) {
rw_lock lock;
std::atomic<int> readers{0};
std::atomic<bool> writer_active{false};
std::atomic<bool> violation{false};
auto reader_task = [&]() {
for (int i = 0; i < 30; ++i) {
lock.lock_shared();
++readers;
if (writer_active.load()) {
violation.store(true);
}
std::this_thread::sleep_for(std::chrono::microseconds(50));
--readers;
lock.unlock_shared();
std::this_thread::yield();
}
};
auto writer_task = [&]() {
for (int i = 0; i < 15; ++i) {
lock.lock();
writer_active.store(true);
if (readers.load() > 0) {
violation.store(true);
}
std::this_thread::sleep_for(std::chrono::microseconds(50));
writer_active.store(false);
lock.unlock();
std::this_thread::yield();
}
};
std::thread r1(reader_task);
std::thread r2(reader_task);
std::thread w1(writer_task);
r1.join();
r2.join();
w1.join();
EXPECT_FALSE(violation.load());
}
// Test read-write-read pattern
TEST_F(RWLockTest, ReadWriteReadPattern) {
rw_lock lock;
int data = 0;
std::atomic<int> iterations{0};
auto pattern_task = [&](int id) {
for (int i = 0; i < 20; ++i) {
// Write: increment based on thread id
lock.lock();
data += id;
lock.unlock();
iterations.fetch_add(1);
std::this_thread::yield();
// Read: verify data is consistent
lock.lock_shared();
int read_val = data;
EXPECT_GE(read_val, 0); // Data should be non-negative
lock.unlock_shared();
std::this_thread::yield();
}
};
std::thread t1(pattern_task, 1);
std::thread t2(pattern_task, 2);
t1.join();
t2.join();
// Each thread increments by its id (1 or 2), 20 times each
// Total = 1*20 + 2*20 = 20 + 40 = 60
EXPECT_EQ(data, 60);
EXPECT_EQ(iterations.load(), 40);
}
// Test many readers, one writer
TEST_F(RWLockTest, ManyReadersOneWriter) {
rw_lock lock;
std::atomic<int> data{0};
std::atomic<int> read_count{0};
const int num_readers = 10;
std::vector<std::thread> readers;
for (int i = 0; i < num_readers; ++i) {
readers.emplace_back([&]() {
for (int j = 0; j < 50; ++j) {
lock.lock_shared();
int val = data.load();
++read_count;
lock.unlock_shared();
std::this_thread::yield();
}
});
}
std::thread writer([&]() {
for (int i = 0; i < 100; ++i) {
lock.lock();
data.store(data.load() + 1);
lock.unlock();
std::this_thread::yield();
}
});
for (auto& t : readers) {
t.join();
}
writer.join();
EXPECT_EQ(data.load(), 100);
EXPECT_EQ(read_count.load(), num_readers * 50);
}
// Test rapid read lock/unlock
TEST_F(RWLockTest, RapidReadLocks) {
rw_lock lock;
auto rapid_read = [&]() {
for (int i = 0; i < 5000; ++i) {
lock.lock_shared();
lock.unlock_shared();
}
};
std::thread t1(rapid_read);
std::thread t2(rapid_read);
std::thread t3(rapid_read);
t1.join();
t2.join();
t3.join();
}
// Test rapid write lock/unlock
TEST_F(RWLockTest, RapidWriteLocks) {
rw_lock lock;
auto rapid_write = [&]() {
for (int i = 0; i < 2000; ++i) {
lock.lock();
lock.unlock();
}
};
std::thread t1(rapid_write);
std::thread t2(rapid_write);
t1.join();
t2.join();
}
// Test mixed rapid operations
TEST_F(RWLockTest, MixedRapidOperations) {
rw_lock lock;
auto rapid_read = [&]() {
for (int i = 0; i < 1000; ++i) {
lock.lock_shared();
lock.unlock_shared();
}
};
auto rapid_write = [&]() {
for (int i = 0; i < 500; ++i) {
lock.lock();
lock.unlock();
}
};
std::thread r1(rapid_read);
std::thread r2(rapid_read);
std::thread w1(rapid_write);
r1.join();
r2.join();
w1.join();
}
// Test write lock doesn't allow concurrent readers
TEST_F(RWLockTest, WriteLockBlocksReaders) {
rw_lock lock;
std::atomic<bool> write_locked{false};
std::atomic<bool> reader_entered{false};
std::thread writer([&]() {
lock.lock();
write_locked.store(true);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
write_locked.store(false);
lock.unlock();
});
std::thread reader([&]() {
std::this_thread::sleep_for(std::chrono::milliseconds(20));
lock.lock_shared();
if (write_locked.load()) {
reader_entered.store(true);
}
lock.unlock_shared();
});
writer.join();
reader.join();
// Reader should not have entered while writer held the lock
EXPECT_FALSE(reader_entered.load());
}
// Test multiple write lock upgrades
TEST_F(RWLockTest, MultipleWriteLockPattern) {
rw_lock lock;
int data = 0;
for (int i = 0; i < 100; ++i) {
// Read
lock.lock_shared();
int temp = data;
lock.unlock_shared();
// Write
lock.lock();
data = temp + 1;
lock.unlock();
}
EXPECT_EQ(data, 100);
}
// Test concurrent mixed operations
TEST_F(RWLockTest, ConcurrentMixedOperations) {
rw_lock lock;
std::atomic<int> data{0};
std::atomic<int> reads{0};
std::atomic<int> writes{0};
auto mixed_task = [&](int id) {
for (int i = 0; i < 50; ++i) {
if (i % 3 == 0) {
// Write operation
lock.lock();
data.store(data.load() + 1);
++writes;
lock.unlock();
} else {
// Read operation
lock.lock_shared();
int val = data.load();
++reads;
lock.unlock_shared();
}
std::this_thread::yield();
}
};
std::thread t1(mixed_task, 1);
std::thread t2(mixed_task, 2);
std::thread t3(mixed_task, 3);
std::thread t4(mixed_task, 4);
t1.join();
t2.join();
t3.join();
t4.join();
EXPECT_GT(reads.load(), 0);
EXPECT_GT(writes.load(), 0);
}

0
test/archive/test_mem.cpp → test/test_mem.cpp
View File

501
test/test_mutex.cpp
View File

@ -1,501 +0,0 @@
/**
* @file test_mutex.cpp
* @brief Comprehensive unit tests for ipc::sync::mutex class
*
* This test suite covers:
* - Mutex construction (default and named)
* - Lock/unlock operations
* - Try-lock functionality
* - Timed lock with timeout
* - Named mutex for inter-process synchronization
* - Resource cleanup (clear, clear_storage)
* - Native handle access
* - Concurrent access scenarios
*/
#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <vector>
#include "libipc/mutex.h"
#include "libipc/def.h"
using namespace ipc;
using namespace ipc::sync;
namespace {
// Generate unique mutex names for tests
std::string generate_unique_mutex_name(const char* prefix) {
static int counter = 0;
return std::string(prefix) + "_mutex_" + std::to_string(++counter);
}
} // anonymous namespace
class MutexTest : public ::testing::Test {
protected:
void TearDown() override {
// Allow time for cleanup
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
};
// Test default constructor
TEST_F(MutexTest, DefaultConstructor) {
mutex mtx;
// Default constructed mutex may or may not be valid depending on implementation
// Just ensure it doesn't crash
}
// Test named constructor
TEST_F(MutexTest, NamedConstructor) {
std::string name = generate_unique_mutex_name("named_ctor");
mutex mtx(name.c_str());
EXPECT_TRUE(mtx.valid());
}
// Test native() const method
TEST_F(MutexTest, NativeConst) {
std::string name = generate_unique_mutex_name("native_const");
const mutex mtx(name.c_str());
const void* native_handle = mtx.native();
EXPECT_NE(native_handle, nullptr);
}
// Test native() non-const method
TEST_F(MutexTest, NativeNonConst) {
std::string name = generate_unique_mutex_name("native_nonconst");
mutex mtx(name.c_str());
void* native_handle = mtx.native();
EXPECT_NE(native_handle, nullptr);
}
// Test valid() method
TEST_F(MutexTest, Valid) {
mutex mtx1;
// May or may not be valid without open
std::string name = generate_unique_mutex_name("valid");
mutex mtx2(name.c_str());
EXPECT_TRUE(mtx2.valid());
}
// Test open() method
TEST_F(MutexTest, Open) {
std::string name = generate_unique_mutex_name("open");
mutex mtx;
bool result = mtx.open(name.c_str());
EXPECT_TRUE(result);
EXPECT_TRUE(mtx.valid());
}
// Test close() method
TEST_F(MutexTest, Close) {
std::string name = generate_unique_mutex_name("close");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
mtx.close();
EXPECT_FALSE(mtx.valid());
}
// Test clear() method
TEST_F(MutexTest, Clear) {
std::string name = generate_unique_mutex_name("clear");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
mtx.clear();
EXPECT_FALSE(mtx.valid());
}
// Test clear_storage() static method
TEST_F(MutexTest, ClearStorage) {
std::string name = generate_unique_mutex_name("clear_storage");
{
mutex mtx(name.c_str());
EXPECT_TRUE(mtx.valid());
}
mutex::clear_storage(name.c_str());
// Try to open after clear - should create new or fail gracefully
mutex mtx2(name.c_str());
}
// Test basic lock and unlock
TEST_F(MutexTest, LockUnlock) {
std::string name = generate_unique_mutex_name("lock_unlock");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
bool locked = mtx.lock();
EXPECT_TRUE(locked);
bool unlocked = mtx.unlock();
EXPECT_TRUE(unlocked);
}
// Test try_lock
TEST_F(MutexTest, TryLock) {
std::string name = generate_unique_mutex_name("try_lock");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
bool locked = mtx.try_lock();
EXPECT_TRUE(locked);
if (locked) {
mtx.unlock();
}
}
// Test timed lock with infinite timeout
TEST_F(MutexTest, TimedLockInfinite) {
std::string name = generate_unique_mutex_name("timed_lock_inf");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
bool locked = mtx.lock(invalid_value);
EXPECT_TRUE(locked);
if (locked) {
mtx.unlock();
}
}
// Test timed lock with timeout
TEST_F(MutexTest, TimedLockTimeout) {
std::string name = generate_unique_mutex_name("timed_lock_timeout");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
// Lock with 100ms timeout
bool locked = mtx.lock(100);
EXPECT_TRUE(locked);
if (locked) {
mtx.unlock();
}
}
// Test mutex protects critical section
TEST_F(MutexTest, CriticalSection) {
std::string name = generate_unique_mutex_name("critical_section");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
int shared_counter = 0;
const int iterations = 100;
auto increment_task = [&]() {
for (int i = 0; i < iterations; ++i) {
mtx.lock();
++shared_counter;
mtx.unlock();
}
};
std::thread t1(increment_task);
std::thread t2(increment_task);
t1.join();
t2.join();
EXPECT_EQ(shared_counter, iterations * 2);
}
// Test concurrent try_lock
TEST_F(MutexTest, ConcurrentTryLock) {
std::string name = generate_unique_mutex_name("concurrent_try");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
std::atomic<int> success_count{0};
std::atomic<int> fail_count{0};
auto try_lock_task = [&]() {
for (int i = 0; i < 10; ++i) {
if (mtx.try_lock()) {
++success_count;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
mtx.unlock();
} else {
++fail_count;
}
std::this_thread::yield();
}
};
std::thread t1(try_lock_task);
std::thread t2(try_lock_task);
std::thread t3(try_lock_task);
t1.join();
t2.join();
t3.join();
EXPECT_GT(success_count.load(), 0);
// Some try_locks should succeed
}
// Test lock contention
TEST_F(MutexTest, LockContention) {
std::string name = generate_unique_mutex_name("contention");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
std::atomic<bool> thread1_in_cs{false};
std::atomic<bool> thread2_in_cs{false};
std::atomic<bool> violation{false};
auto contention_task = [&](std::atomic<bool>& my_flag,
std::atomic<bool>& other_flag) {
for (int i = 0; i < 50; ++i) {
mtx.lock();
my_flag.store(true);
if (other_flag.load()) {
violation.store(true);
}
std::this_thread::sleep_for(std::chrono::microseconds(10));
my_flag.store(false);
mtx.unlock();
std::this_thread::yield();
}
};
std::thread t1(contention_task, std::ref(thread1_in_cs), std::ref(thread2_in_cs));
std::thread t2(contention_task, std::ref(thread2_in_cs), std::ref(thread1_in_cs));
t1.join();
t2.join();
// Should never have both threads in critical section
EXPECT_FALSE(violation.load());
}
// Test multiple lock/unlock cycles
TEST_F(MutexTest, MultipleCycles) {
std::string name = generate_unique_mutex_name("cycles");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
for (int i = 0; i < 100; ++i) {
ASSERT_TRUE(mtx.lock());
ASSERT_TRUE(mtx.unlock());
}
}
// Test timed lock timeout scenario
TEST_F(MutexTest, TimedLockTimeoutScenario) {
std::string name = generate_unique_mutex_name("timeout_scenario");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
// Lock in main thread
ASSERT_TRUE(mtx.lock());
std::atomic<bool> timeout_occurred{false};
std::thread t([&]() {
// Try to lock with short timeout - should timeout
bool locked = mtx.lock(50); // 50ms timeout
if (!locked) {
timeout_occurred.store(true);
} else {
mtx.unlock();
}
});
std::this_thread::sleep_for(std::chrono::milliseconds(100));
mtx.unlock();
t.join();
// Timeout should have occurred since we held the lock
EXPECT_TRUE(timeout_occurred.load());
}
// Test reopen after close
TEST_F(MutexTest, ReopenAfterClose) {
std::string name = generate_unique_mutex_name("reopen");
mutex mtx;
ASSERT_TRUE(mtx.open(name.c_str()));
EXPECT_TRUE(mtx.valid());
mtx.close();
EXPECT_FALSE(mtx.valid());
ASSERT_TRUE(mtx.open(name.c_str()));
EXPECT_TRUE(mtx.valid());
}
// Test named mutex inter-thread synchronization
TEST_F(MutexTest, NamedMutexInterThread) {
std::string name = generate_unique_mutex_name("inter_thread");
int shared_data = 0;
std::atomic<bool> t1_done{false};
std::atomic<bool> t2_done{false};
std::thread t1([&]() {
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
mtx.lock();
shared_data = 100;
std::this_thread::sleep_for(std::chrono::milliseconds(50));
mtx.unlock();
t1_done.store(true);
});
std::thread t2([&]() {
// Wait a bit to ensure t1 starts first
std::this_thread::sleep_for(std::chrono::milliseconds(10));
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
mtx.lock();
EXPECT_TRUE(t1_done.load() || shared_data == 100);
shared_data = 200;
mtx.unlock();
t2_done.store(true);
});
t1.join();
t2.join();
EXPECT_EQ(shared_data, 200);
}
// Test exception safety of try_lock
TEST_F(MutexTest, TryLockExceptionSafety) {
std::string name = generate_unique_mutex_name("try_lock_exception");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
bool exception_thrown = false;
try {
mtx.try_lock();
} catch (const std::system_error&) {
exception_thrown = true;
} catch (...) {
FAIL() << "Unexpected exception type";
}
// try_lock may throw system_error
// Just ensure we can handle it
}
// Test concurrent open/close operations
TEST_F(MutexTest, ConcurrentOpenClose) {
std::vector<std::thread> threads;
std::atomic<int> success_count{0};
for (int i = 0; i < 5; ++i) {
threads.emplace_back([&, i]() {
std::string name = generate_unique_mutex_name("concurrent");
name += std::to_string(i);
mutex mtx;
if (mtx.open(name.c_str())) {
++success_count;
mtx.close();
}
});
}
for (auto& t : threads) {
t.join();
}
EXPECT_EQ(success_count.load(), 5);
}
// Test mutex with zero timeout
TEST_F(MutexTest, ZeroTimeout) {
std::string name = generate_unique_mutex_name("zero_timeout");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
// Lock with zero timeout (should try once and return)
bool locked = mtx.lock(0);
if (locked) {
mtx.unlock();
}
// Result may vary, just ensure it doesn't hang
}
// Test rapid lock/unlock sequence
TEST_F(MutexTest, RapidLockUnlock) {
std::string name = generate_unique_mutex_name("rapid");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
auto rapid_task = [&]() {
for (int i = 0; i < 1000; ++i) {
mtx.lock();
mtx.unlock();
}
};
std::thread t1(rapid_task);
std::thread t2(rapid_task);
t1.join();
t2.join();
// Should complete without deadlock or crash
}
// Test lock after clear
TEST_F(MutexTest, LockAfterClear) {
std::string name = generate_unique_mutex_name("lock_after_clear");
mutex mtx(name.c_str());
ASSERT_TRUE(mtx.valid());
mtx.lock();
mtx.unlock();
mtx.clear();
EXPECT_FALSE(mtx.valid());
// Attempting to lock after clear should fail gracefully
bool locked = mtx.lock();
EXPECT_FALSE(locked);
}

0
test/archive/test_platform.cpp → test/test_platform.cpp
View File

615
test/archive/test_queue.cpp → test/test_queue.cpp
View File

@ -1,311 +1,304 @@
#include <iostream>
#include <string>
#include <type_traits>
#include <memory>
#include <new>
#include <vector>
#include <unordered_map>
#include <climits> // CHAR_BIT
#include "libipc/prod_cons.h"
#include "libipc/policy.h"
#include "libipc/circ/elem_array.h"
#include "libipc/queue.h"
#include "test.h"
namespace {
struct msg_t {
int pid_;
int dat_;
msg_t() = default;
msg_t(int p, int d) : pid_(p), dat_(d) {}
};
template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
using queue_t = ipc::queue<msg_t, ipc::policy::choose<ipc::circ::elem_array, ipc::wr<Rp, Rc, Ts>>>;
template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
struct elems_t : public queue_t<Rp, Rc, Ts>::elems_t {};
bool operator==(msg_t const & m1, msg_t const & m2) noexcept {
return (m1.pid_ == m2.pid_) && (m1.dat_ == m2.dat_);
}
bool operator!=(msg_t const & m1, msg_t const & m2) noexcept {
return !(m1 == m2);
}
constexpr int LoopCount = 1000000;
constexpr int PushRetry = 1000000;
constexpr int ThreadMax = 8;
template <typename Que>
void push(Que & que, int p, int d) {
for (int n = 0; !que.push([](void*) { return true; }, p, d); ++n) {
ASSERT_NE(n, PushRetry);
std::this_thread::yield();
}
}
template <typename Que>
msg_t pop(Que & que) {
msg_t msg;
while (!que.pop(msg)) {
std::this_thread::yield();
}
return msg;
}
template <ipc::trans Ts>
struct quitter;
template <>
struct quitter<ipc::trans::unicast> {
template <typename Que>
static void emit(Que && que, int r_cnt) {
for (int k = 0; k < r_cnt; ++k) {
push(que, -1, -1);
}
}
};
template <>
struct quitter<ipc::trans::broadcast> {
template <typename Que>
static void emit(Que && que, int /*r_cnt*/) {
push(que, -1, -1);
}
};
template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
void test_sr(elems_t<Rp, Rc, Ts> && elems, int s_cnt, int r_cnt, char const * message) {
ipc_ut::sender().start(static_cast<std::size_t>(s_cnt));
ipc_ut::reader().start(static_cast<std::size_t>(r_cnt));
ipc_ut::test_stopwatch sw;
for (int k = 0; k < s_cnt; ++k) {
ipc_ut::sender() << [&elems, &sw, r_cnt, k] {
queue_t<Rp, Rc, Ts> que { &elems };
while (que.conn_count() != static_cast<std::size_t>(r_cnt)) {
std::this_thread::yield();
}
sw.start();
for (int i = 0; i < LoopCount; ++i) {
push(que, k, i);
}
};
}
for (int k = 0; k < r_cnt; ++k) {
ipc_ut::reader() << [&elems, k] {
queue_t<Rp, Rc, Ts> que { &elems };
ASSERT_TRUE(que.connect());
while (pop(que).pid_ >= 0) ;
ASSERT_TRUE(que.disconnect());
};
}
ipc_ut::sender().wait_for_done();
quitter<Ts>::emit(queue_t<Rp, Rc, Ts> { &elems }, r_cnt);
ipc_ut::reader().wait_for_done();
sw.print_elapsed(s_cnt, r_cnt, LoopCount, message);
}
} // internal-linkage
TEST(Queue, check_size) {
using el_t = elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast>;
std::cout << "cq_t::head_size = " << el_t::head_size << std::endl;
std::cout << "cq_t::data_size = " << el_t::data_size << std::endl;
std::cout << "cq_t::elem_size = " << el_t::elem_size << std::endl;
std::cout << "cq_t::block_size = " << el_t::block_size << std::endl;
EXPECT_EQ(static_cast<std::size_t>(el_t::data_size), sizeof(msg_t));
std::cout << "sizeof(elems_t<s, m, b>) = " << sizeof(el_t) << std::endl;
}
TEST(Queue, el_connection) {
{
elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
EXPECT_TRUE(el.connect_sender());
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_FALSE(el.connect_sender());
}
el.disconnect_sender();
EXPECT_TRUE(el.connect_sender());
}
{
elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::unicast> el;
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(el.connect_sender());
}
}
{
elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
auto cc = el.connect_receiver();
EXPECT_NE(cc, 0);
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_EQ(el.connect_receiver(), 0);
}
EXPECT_EQ(el.disconnect_receiver(cc), 0);
EXPECT_EQ(el.connect_receiver(), cc);
}
{
elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast> el;
for (std::size_t i = 0; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {
ASSERT_NE(el.connect_receiver(), 0);
}
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_EQ(el.connect_receiver(), 0);
}
}
}
TEST(Queue, connection) {
{
elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
// sending
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
ASSERT_FALSE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
que.shut_sending();
}
{
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
EXPECT_TRUE(que.ready_sending());
}
// receiving
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
ASSERT_FALSE(que.connect());
}
EXPECT_TRUE(que.disconnect());
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_FALSE(que.disconnect());
}
{
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
EXPECT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
ASSERT_FALSE(que.connect());
}
}
{
elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> el;
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
// sending
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
que.shut_sending();
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.ready_sending());
}
// receiving
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 1; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_FALSE(que.connect());
}
ASSERT_TRUE(que.disconnect());
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_FALSE(que.disconnect());
}
{
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_FALSE(que.connect());
}
}
}
TEST(Queue, prod_cons_1v1_unicast) {
test_sr(elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast>{}, 1, 1, "ssu");
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::unicast>{}, 1, 1, "smu");
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, 1, "mmu");
}
TEST(Queue, prod_cons_1v1_broadcast) {
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::broadcast>{}, 1, 1, "smb");
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, 1, "mmb");
}
TEST(Queue, prod_cons_1vN_unicast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "smu");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "mmu");
}
}
TEST(Queue, prod_cons_1vN_broadcast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "smb");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "mmb");
}
}
TEST(Queue, prod_cons_NvN_unicast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "mmu");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, i, 1, "mmu");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, i, i, "mmu");
}
}
TEST(Queue, prod_cons_NvN_broadcast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "mmb");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, i, 1, "mmb");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, i, i, "mmb");
}
}
TEST(Queue, clear) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{"test-queue-clear"};
EXPECT_TRUE(ipc_ut::expect_exist("test-queue-clear", true));
que.clear();
EXPECT_TRUE(ipc_ut::expect_exist("test-queue-clear", false));
}
#include <iostream>
#include <string>
#include <type_traits>
#include <memory>
#include <new>
#include <vector>
#include <unordered_map>
#include <climits> // CHAR_BIT
#include "libipc/prod_cons.h"
#include "libipc/policy.h"
#include "libipc/circ/elem_array.h"
#include "libipc/queue.h"
#include "test.h"
namespace {
struct msg_t {
int pid_;
int dat_;
msg_t() = default;
msg_t(int p, int d) : pid_(p), dat_(d) {}
};
template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
using queue_t = ipc::queue<msg_t, ipc::policy::choose<ipc::circ::elem_array, ipc::wr<Rp, Rc, Ts>>>;
template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
struct elems_t : public queue_t<Rp, Rc, Ts>::elems_t {};
bool operator==(msg_t const & m1, msg_t const & m2) noexcept {
return (m1.pid_ == m2.pid_) && (m1.dat_ == m2.dat_);
}
bool operator!=(msg_t const & m1, msg_t const & m2) noexcept {
return !(m1 == m2);
}
constexpr int LoopCount = 1000000;
constexpr int PushRetry = 1000000;
constexpr int ThreadMax = 8;
template <typename Que>
void push(Que & que, int p, int d) {
for (int n = 0; !que.push([](void*) { return true; }, p, d); ++n) {
ASSERT_NE(n, PushRetry);
std::this_thread::yield();
}
}
template <typename Que>
msg_t pop(Que & que) {
msg_t msg;
while (!que.pop(msg)) {
std::this_thread::yield();
}
return msg;
}
template <ipc::trans Ts>
struct quitter;
template <>
struct quitter<ipc::trans::unicast> {
template <typename Que>
static void emit(Que && que, int r_cnt) {
for (int k = 0; k < r_cnt; ++k) {
push(que, -1, -1);
}
}
};
template <>
struct quitter<ipc::trans::broadcast> {
template <typename Que>
static void emit(Que && que, int /*r_cnt*/) {
push(que, -1, -1);
}
};
template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
void test_sr(elems_t<Rp, Rc, Ts> && elems, int s_cnt, int r_cnt, char const * message) {
ipc_ut::sender().start(static_cast<std::size_t>(s_cnt));
ipc_ut::reader().start(static_cast<std::size_t>(r_cnt));
ipc_ut::test_stopwatch sw;
for (int k = 0; k < s_cnt; ++k) {
ipc_ut::sender() << [&elems, &sw, r_cnt, k] {
queue_t<Rp, Rc, Ts> que { &elems };
while (que.conn_count() != static_cast<std::size_t>(r_cnt)) {
std::this_thread::yield();
}
sw.start();
for (int i = 0; i < LoopCount; ++i) {
push(que, k, i);
}
};
}
for (int k = 0; k < r_cnt; ++k) {
ipc_ut::reader() << [&elems, k] {
queue_t<Rp, Rc, Ts> que { &elems };
ASSERT_TRUE(que.connect());
while (pop(que).pid_ >= 0) ;
ASSERT_TRUE(que.disconnect());
};
}
ipc_ut::sender().wait_for_done();
quitter<Ts>::emit(queue_t<Rp, Rc, Ts> { &elems }, r_cnt);
ipc_ut::reader().wait_for_done();
sw.print_elapsed(s_cnt, r_cnt, LoopCount, message);
}
} // internal-linkage
TEST(Queue, check_size) {
using el_t = elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast>;
std::cout << "cq_t::head_size = " << el_t::head_size << std::endl;
std::cout << "cq_t::data_size = " << el_t::data_size << std::endl;
std::cout << "cq_t::elem_size = " << el_t::elem_size << std::endl;
std::cout << "cq_t::block_size = " << el_t::block_size << std::endl;
EXPECT_EQ(static_cast<std::size_t>(el_t::data_size), sizeof(msg_t));
std::cout << "sizeof(elems_t<s, m, b>) = " << sizeof(el_t) << std::endl;
}
TEST(Queue, el_connection) {
{
elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
EXPECT_TRUE(el.connect_sender());
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_FALSE(el.connect_sender());
}
el.disconnect_sender();
EXPECT_TRUE(el.connect_sender());
}
{
elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::unicast> el;
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(el.connect_sender());
}
}
{
elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
auto cc = el.connect_receiver();
EXPECT_NE(cc, 0);
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_EQ(el.connect_receiver(), 0);
}
EXPECT_EQ(el.disconnect_receiver(cc), 0);
EXPECT_EQ(el.connect_receiver(), cc);
}
{
elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast> el;
for (std::size_t i = 0; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {
ASSERT_NE(el.connect_receiver(), 0);
}
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_EQ(el.connect_receiver(), 0);
}
}
}
TEST(Queue, connection) {
{
elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
// sending
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
ASSERT_FALSE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
que.shut_sending();
}
{
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
EXPECT_TRUE(que.ready_sending());
}
// receiving
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
ASSERT_FALSE(que.connect());
}
EXPECT_TRUE(que.disconnect());
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_FALSE(que.disconnect());
}
{
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
EXPECT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
ASSERT_FALSE(que.connect());
}
}
{
elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> el;
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
// sending
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.ready_sending());
}
for (std::size_t i = 0; i < 10000; ++i) {
que.shut_sending();
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.ready_sending());
}
// receiving
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 1; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_FALSE(que.connect());
}
ASSERT_TRUE(que.disconnect());
for (std::size_t i = 0; i < 10000; ++i) {
ASSERT_FALSE(que.disconnect());
}
{
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_TRUE(que.connect());
}
for (std::size_t i = 0; i < 10000; ++i) {
queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
ASSERT_FALSE(que.connect());
}
}
}
TEST(Queue, prod_cons_1v1_unicast) {
test_sr(elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast>{}, 1, 1, "ssu");
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::unicast>{}, 1, 1, "smu");
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, 1, "mmu");
}
TEST(Queue, prod_cons_1v1_broadcast) {
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::broadcast>{}, 1, 1, "smb");
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, 1, "mmb");
}
TEST(Queue, prod_cons_1vN_unicast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "smu");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "mmu");
}
}
TEST(Queue, prod_cons_1vN_broadcast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "smb");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "mmb");
}
}
TEST(Queue, prod_cons_NvN_unicast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "mmu");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, i, 1, "mmu");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, i, i, "mmu");
}
}
TEST(Queue, prod_cons_NvN_broadcast) {
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "mmb");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, i, 1, "mmb");
}
for (int i = 1; i <= ThreadMax; ++i) {
test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, i, i, "mmb");
}
}

487
test/test_semaphore.cpp
View File

@ -1,487 +0,0 @@
/**
* @file test_semaphore.cpp
* @brief Comprehensive unit tests for ipc::sync::semaphore class
*
* This test suite covers:
* - Semaphore construction (default and named with count)
* - Wait and post operations
* - Timed wait with timeout
* - Named semaphore for inter-process synchronization
* - Resource cleanup (clear, clear_storage)
* - Producer-consumer patterns
* - Multiple wait/post scenarios
*/
#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <vector>
#include "libipc/semaphore.h"
#include "libipc/def.h"
using namespace ipc;
using namespace ipc::sync;
namespace {
std::string generate_unique_sem_name(const char* prefix) {
static int counter = 0;
return std::string(prefix) + "_sem_" + std::to_string(++counter);
}
} // anonymous namespace
class SemaphoreTest : public ::testing::Test {
protected:
void TearDown() override {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
};
// Test default constructor
TEST_F(SemaphoreTest, DefaultConstructor) {
semaphore sem;
// Default constructed semaphore
}
// Test named constructor with count
TEST_F(SemaphoreTest, NamedConstructorWithCount) {
std::string name = generate_unique_sem_name("named_count");
semaphore sem(name.c_str(), 5);
EXPECT_TRUE(sem.valid());
}
// Test named constructor with zero count
TEST_F(SemaphoreTest, NamedConstructorZeroCount) {
std::string name = generate_unique_sem_name("zero_count");
semaphore sem(name.c_str(), 0);
EXPECT_TRUE(sem.valid());
}
// Test native() methods
TEST_F(SemaphoreTest, NativeHandle) {
std::string name = generate_unique_sem_name("native");
semaphore sem(name.c_str(), 1);
ASSERT_TRUE(sem.valid());
const void* const_handle = static_cast<const semaphore&>(sem).native();
void* handle = sem.native();
EXPECT_NE(const_handle, nullptr);
EXPECT_NE(handle, nullptr);
}
// Test valid() method
TEST_F(SemaphoreTest, Valid) {
semaphore sem1;
std::string name = generate_unique_sem_name("valid");
semaphore sem2(name.c_str(), 1);
EXPECT_TRUE(sem2.valid());
}
// Test open() method
TEST_F(SemaphoreTest, Open) {
std::string name = generate_unique_sem_name("open");
semaphore sem;
bool result = sem.open(name.c_str(), 3);
EXPECT_TRUE(result);
EXPECT_TRUE(sem.valid());
}
// Test close() method
TEST_F(SemaphoreTest, Close) {
std::string name = generate_unique_sem_name("close");
semaphore sem(name.c_str(), 1);
ASSERT_TRUE(sem.valid());
sem.close();
EXPECT_FALSE(sem.valid());
}
// Test clear() method
TEST_F(SemaphoreTest, Clear) {
std::string name = generate_unique_sem_name("clear");
semaphore sem(name.c_str(), 1);
ASSERT_TRUE(sem.valid());
sem.clear();
EXPECT_FALSE(sem.valid());
}
// Test clear_storage() static method
TEST_F(SemaphoreTest, ClearStorage) {
std::string name = generate_unique_sem_name("clear_storage");
{
semaphore sem(name.c_str(), 1);
EXPECT_TRUE(sem.valid());
}
semaphore::clear_storage(name.c_str());
}
// Test basic wait and post
TEST_F(SemaphoreTest, WaitPost) {
std::string name = generate_unique_sem_name("wait_post");
semaphore sem(name.c_str(), 1);
ASSERT_TRUE(sem.valid());
bool waited = sem.wait();
EXPECT_TRUE(waited);
bool posted = sem.post();
EXPECT_TRUE(posted);
}
// Test post with count
TEST_F(SemaphoreTest, PostWithCount) {
std::string name = generate_unique_sem_name("post_count");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
bool posted = sem.post(5);
EXPECT_TRUE(posted);
// Now should be able to wait 5 times
for (int i = 0; i < 5; ++i) {
EXPECT_TRUE(sem.wait(10)); // 10ms timeout
}
}
// Test timed wait with timeout
TEST_F(SemaphoreTest, TimedWait) {
std::string name = generate_unique_sem_name("timed_wait");
semaphore sem(name.c_str(), 1);
ASSERT_TRUE(sem.valid());
bool waited = sem.wait(100); // 100ms timeout
EXPECT_TRUE(waited);
}
// Test wait timeout scenario
TEST_F(SemaphoreTest, WaitTimeout) {
std::string name = generate_unique_sem_name("wait_timeout");
semaphore sem(name.c_str(), 0); // Zero count
ASSERT_TRUE(sem.valid());
auto start = std::chrono::steady_clock::now();
bool waited = sem.wait(50); // 50ms timeout
auto end = std::chrono::steady_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
// Should timeout
EXPECT_FALSE(waited);
EXPECT_GE(elapsed, 40); // Allow some tolerance
}
// Test infinite wait
TEST_F(SemaphoreTest, InfiniteWait) {
std::string name = generate_unique_sem_name("infinite_wait");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
std::atomic<bool> wait_started{false};
std::atomic<bool> wait_succeeded{false};
std::thread waiter([&]() {
wait_started.store(true);
bool result = sem.wait(invalid_value);
wait_succeeded.store(result);
});
// Wait for thread to start waiting
while (!wait_started.load()) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
std::this_thread::sleep_for(std::chrono::milliseconds(50));
// Post to release the waiter
sem.post();
waiter.join();
EXPECT_TRUE(wait_succeeded.load());
}
// Test producer-consumer pattern
TEST_F(SemaphoreTest, ProducerConsumer) {
std::string name = generate_unique_sem_name("prod_cons");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
std::atomic<int> produced{0};
std::atomic<int> consumed{0};
const int count = 10;
std::thread producer([&]() {
for (int i = 0; i < count; ++i) {
++produced;
sem.post();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
});
std::thread consumer([&]() {
for (int i = 0; i < count; ++i) {
sem.wait();
++consumed;
}
});
producer.join();
consumer.join();
EXPECT_EQ(produced.load(), count);
EXPECT_EQ(consumed.load(), count);
}
// Test multiple producers and consumers
TEST_F(SemaphoreTest, MultipleProducersConsumers) {
std::string name = generate_unique_sem_name("multi_prod_cons");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
std::atomic<int> total_produced{0};
std::atomic<int> total_consumed{0};
const int items_per_producer = 5;
const int num_producers = 3;
const int num_consumers = 3;
std::vector<std::thread> producers;
for (int i = 0; i < num_producers; ++i) {
producers.emplace_back([&]() {
for (int j = 0; j < items_per_producer; ++j) {
++total_produced;
sem.post();
std::this_thread::yield();
}
});
}
std::vector<std::thread> consumers;
for (int i = 0; i < num_consumers; ++i) {
consumers.emplace_back([&]() {
for (int j = 0; j < items_per_producer; ++j) {
if (sem.wait(1000)) {
++total_consumed;
}
}
});
}
for (auto& t : producers) t.join();
for (auto& t : consumers) t.join();
EXPECT_EQ(total_produced.load(), items_per_producer * num_producers);
EXPECT_EQ(total_consumed.load(), items_per_producer * num_producers);
}
// Test semaphore with initial count
TEST_F(SemaphoreTest, InitialCount) {
std::string name = generate_unique_sem_name("initial_count");
const uint32_t initial = 3;
semaphore sem(name.c_str(), initial);
ASSERT_TRUE(sem.valid());
// Should be able to wait 'initial' times without blocking
for (uint32_t i = 0; i < initial; ++i) {
EXPECT_TRUE(sem.wait(10));
}
// Next wait should timeout
EXPECT_FALSE(sem.wait(10));
}
// Test rapid post operations
TEST_F(SemaphoreTest, RapidPost) {
std::string name = generate_unique_sem_name("rapid_post");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
const int post_count = 100;
for (int i = 0; i < post_count; ++i) {
EXPECT_TRUE(sem.post());
}
// Should be able to wait post_count times
int wait_count = 0;
for (int i = 0; i < post_count; ++i) {
if (sem.wait(10)) {
++wait_count;
}
}
EXPECT_EQ(wait_count, post_count);
}
// Test concurrent post operations
TEST_F(SemaphoreTest, ConcurrentPost) {
std::string name = generate_unique_sem_name("concurrent_post");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
std::atomic<int> post_count{0};
const int threads = 5;
const int posts_per_thread = 10;
std::vector<std::thread> posters;
for (int i = 0; i < threads; ++i) {
posters.emplace_back([&]() {
for (int j = 0; j < posts_per_thread; ++j) {
if (sem.post()) {
++post_count;
}
}
});
}
for (auto& t : posters) t.join();
EXPECT_EQ(post_count.load(), threads * posts_per_thread);
// Verify by consuming
int consumed = 0;
for (int i = 0; i < threads * posts_per_thread; ++i) {
if (sem.wait(10)) {
++consumed;
}
}
EXPECT_EQ(consumed, threads * posts_per_thread);
}
// Test reopen after close
TEST_F(SemaphoreTest, ReopenAfterClose) {
std::string name = generate_unique_sem_name("reopen");
semaphore sem;
ASSERT_TRUE(sem.open(name.c_str(), 2));
EXPECT_TRUE(sem.valid());
sem.close();
EXPECT_FALSE(sem.valid());
ASSERT_TRUE(sem.open(name.c_str(), 3));
EXPECT_TRUE(sem.valid());
}
// Test named semaphore sharing between threads
TEST_F(SemaphoreTest, NamedSemaphoreSharing) {
std::string name = generate_unique_sem_name("sharing");
std::atomic<int> value{0};
std::thread t1([&]() {
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
sem.wait(); // Wait for signal
value.store(100);
});
std::thread t2([&]() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
sem.post(); // Signal t1
});
t1.join();
t2.join();
EXPECT_EQ(value.load(), 100);
}
// Test post multiple count at once
TEST_F(SemaphoreTest, PostMultiple) {
std::string name = generate_unique_sem_name("post_multiple");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
const uint32_t count = 10;
bool posted = sem.post(count);
EXPECT_TRUE(posted);
// Consume all
for (uint32_t i = 0; i < count; ++i) {
EXPECT_TRUE(sem.wait(10));
}
// Should be empty now
EXPECT_FALSE(sem.wait(10));
}
// Test semaphore after clear
TEST_F(SemaphoreTest, AfterClear) {
std::string name = generate_unique_sem_name("after_clear");
semaphore sem(name.c_str(), 5);
ASSERT_TRUE(sem.valid());
sem.wait();
sem.clear();
EXPECT_FALSE(sem.valid());
// Operations after clear should fail gracefully
EXPECT_FALSE(sem.wait(10));
EXPECT_FALSE(sem.post());
}
// Test zero timeout
TEST_F(SemaphoreTest, ZeroTimeout) {
std::string name = generate_unique_sem_name("zero_timeout");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
bool waited = sem.wait(0);
// Should return immediately (either success or timeout)
}
// Test high-frequency wait/post
TEST_F(SemaphoreTest, HighFrequency) {
std::string name = generate_unique_sem_name("high_freq");
semaphore sem(name.c_str(), 0);
ASSERT_TRUE(sem.valid());
std::thread poster([&]() {
for (int i = 0; i < 1000; ++i) {
sem.post();
}
});
std::thread waiter([&]() {
for (int i = 0; i < 1000; ++i) {
sem.wait(100);
}
});
poster.join();
waiter.join();
}

623
test/test_shm.cpp Normal file → Executable file
View File

@ -1,521 +1,102 @@
/**
* @file test_shm.cpp
* @brief Comprehensive unit tests for ipc::shm (shared memory) functionality
*
* This test suite covers:
* - Low-level shared memory functions (acquire, get_mem, release, remove)
* - Reference counting (get_ref, sub_ref)
* - High-level handle class interface
* - Create and open modes
* - Resource cleanup and error handling
*/
#include <gtest/gtest.h>
#include <cstring>
#include <memory>
#include <string>
#include "libipc/shm.h"
using namespace ipc;
namespace {
// Generate unique shared memory names for tests
std::string generate_unique_name(const char* prefix) {
static int counter = 0;
return std::string(prefix) + "_test_" + std::to_string(++counter);
}
} // anonymous namespace
class ShmTest : public ::testing::Test {
protected:
void TearDown() override {
// Clean up any leftover shared memory segments
}
};
// ========== Low-level API Tests ==========
// Test acquire with create mode
TEST_F(ShmTest, AcquireCreate) {
std::string name = generate_unique_name("acquire_create");
const std::size_t size = 1024;
shm::id_t id = shm::acquire(name.c_str(), size, shm::create);
ASSERT_NE(id, nullptr);
std::size_t actual_size = 0;
void* mem = shm::get_mem(id, &actual_size);
EXPECT_NE(mem, nullptr);
EXPECT_GE(actual_size, size);
// Use remove(id) to clean up - it internally calls release()
shm::remove(id);
}
// Test acquire with open mode (should fail if not exists)
TEST_F(ShmTest, AcquireOpenNonExistent) {
std::string name = generate_unique_name("acquire_open_fail");
shm::id_t id = shm::acquire(name.c_str(), 1024, shm::open);
// Opening non-existent shared memory should return nullptr or handle failure gracefully
if (id != nullptr) {
shm::release(id);
}
}
// Test acquire with both create and open modes
TEST_F(ShmTest, AcquireCreateOrOpen) {
std::string name = generate_unique_name("acquire_both");
const std::size_t size = 2048;
shm::id_t id = shm::acquire(name.c_str(), size, shm::create | shm::open);
ASSERT_NE(id, nullptr);
std::size_t actual_size = 0;
void* mem = shm::get_mem(id, &actual_size);
EXPECT_NE(mem, nullptr);
EXPECT_GE(actual_size, size);
// Use remove(id) to clean up - it internally calls release()
shm::remove(id);
}
// Test get_mem function
TEST_F(ShmTest, GetMemory) {
std::string name = generate_unique_name("get_mem");
const std::size_t size = 512;
shm::id_t id = shm::acquire(name.c_str(), size, shm::create);
ASSERT_NE(id, nullptr);
std::size_t returned_size = 0;
void* mem = shm::get_mem(id, &returned_size);
EXPECT_NE(mem, nullptr);
EXPECT_GE(returned_size, size);
// Write and read test data
const char* test_data = "Shared memory test data";
std::strcpy(static_cast<char*>(mem), test_data);
EXPECT_STREQ(static_cast<char*>(mem), test_data);
// Use remove(id) to clean up - it internally calls release()
shm::remove(id);
}
// Test get_mem without size parameter
TEST_F(ShmTest, GetMemoryNoSize) {
std::string name = generate_unique_name("get_mem_no_size");
shm::id_t id = shm::acquire(name.c_str(), 256, shm::create);
ASSERT_NE(id, nullptr);
void* mem = shm::get_mem(id, nullptr);
EXPECT_NE(mem, nullptr);
// Use remove(id) to clean up - it internally calls release()
shm::remove(id);
}
// Test release function
TEST_F(ShmTest, ReleaseMemory) {
std::string name = generate_unique_name("release");
shm::id_t id = shm::acquire(name.c_str(), 128, shm::create);
ASSERT_NE(id, nullptr);
// Must call get_mem to map memory and set reference count
void* mem = shm::get_mem(id, nullptr);
ASSERT_NE(mem, nullptr);
// release returns the reference count before decrement, or -1 on error
std::int32_t ref_count = shm::release(id);
EXPECT_EQ(ref_count, 1); // Should be 1 (set by get_mem, before decrement)
shm::remove(name.c_str());
}
// Test remove by id
TEST_F(ShmTest, RemoveById) {
std::string name = generate_unique_name("remove_by_id");
shm::id_t id = shm::acquire(name.c_str(), 256, shm::create);
ASSERT_NE(id, nullptr);
// remove(id) internally calls release(id), so we don't need to call release first
shm::remove(id); // Should succeed
}
// Test remove by name
TEST_F(ShmTest, RemoveByName) {
std::string name = generate_unique_name("remove_by_name");
shm::id_t id = shm::acquire(name.c_str(), 256, shm::create);
ASSERT_NE(id, nullptr);
shm::release(id);
shm::remove(name.c_str()); // Should succeed
}
// Test reference counting
TEST_F(ShmTest, ReferenceCount) {
std::string name = generate_unique_name("ref_count");
shm::id_t id1 = shm::acquire(name.c_str(), 512, shm::create);
ASSERT_NE(id1, nullptr);
// Reference count is 0 after acquire (memory not mapped yet)
std::int32_t ref_before_get_mem = shm::get_ref(id1);
EXPECT_EQ(ref_before_get_mem, 0);
// get_mem maps memory and sets reference count to 1
void* mem1 = shm::get_mem(id1, nullptr);
ASSERT_NE(mem1, nullptr);
std::int32_t ref1 = shm::get_ref(id1);
EXPECT_EQ(ref1, 1);
// Acquire again and get_mem (should increase reference count)
shm::id_t id2 = shm::acquire(name.c_str(), 512, shm::open);
if (id2 != nullptr) {
void* mem2 = shm::get_mem(id2, nullptr);
ASSERT_NE(mem2, nullptr);
std::int32_t ref2 = shm::get_ref(id2);
EXPECT_EQ(ref2, 2); // Should be 2 now
shm::release(id2);
}
shm::release(id1);
shm::remove(name.c_str());
}
// Test sub_ref function
TEST_F(ShmTest, SubtractReference) {
std::string name = generate_unique_name("sub_ref");
shm::id_t id = shm::acquire(name.c_str(), 256, shm::create);
ASSERT_NE(id, nullptr);
// Must call get_mem first to map memory and initialize reference count
void* mem = shm::get_mem(id, nullptr);
ASSERT_NE(mem, nullptr);
std::int32_t ref_before = shm::get_ref(id);
EXPECT_EQ(ref_before, 1); // Should be 1 after get_mem
shm::sub_ref(id);
std::int32_t ref_after = shm::get_ref(id);
EXPECT_EQ(ref_after, 0); // Should be 0 after sub_ref
// Use remove(id) to clean up - it internally calls release()
shm::remove(id);
}
// ========== High-level handle class Tests ==========
// Test default handle constructor
TEST_F(ShmTest, HandleDefaultConstructor) {
shm::handle h;
EXPECT_FALSE(h.valid());
EXPECT_EQ(h.size(), 0u);
EXPECT_EQ(h.get(), nullptr);
}
// Test handle constructor with name and size
TEST_F(ShmTest, HandleConstructorWithParams) {
std::string name = generate_unique_name("handle_ctor");
const std::size_t size = 1024;
shm::handle h(name.c_str(), size);
EXPECT_TRUE(h.valid());
EXPECT_GE(h.size(), size);
EXPECT_NE(h.get(), nullptr);
EXPECT_STREQ(h.name(), name.c_str());
}
// Test handle move constructor
TEST_F(ShmTest, HandleMoveConstructor) {
std::string name = generate_unique_name("handle_move");
shm::handle h1(name.c_str(), 512);
ASSERT_TRUE(h1.valid());
void* ptr1 = h1.get();
std::size_t size1 = h1.size();
shm::handle h2(std::move(h1));
EXPECT_TRUE(h2.valid());
EXPECT_EQ(h2.get(), ptr1);
EXPECT_EQ(h2.size(), size1);
// h1 should be invalid after move
EXPECT_FALSE(h1.valid());
}
// Test handle swap
TEST_F(ShmTest, HandleSwap) {
std::string name1 = generate_unique_name("handle_swap1");
std::string name2 = generate_unique_name("handle_swap2");
shm::handle h1(name1.c_str(), 256);
shm::handle h2(name2.c_str(), 512);
void* ptr1 = h1.get();
void* ptr2 = h2.get();
std::size_t size1 = h1.size();
std::size_t size2 = h2.size();
h1.swap(h2);
EXPECT_EQ(h1.get(), ptr2);
EXPECT_EQ(h1.size(), size2);
EXPECT_EQ(h2.get(), ptr1);
EXPECT_EQ(h2.size(), size1);
}
// Test handle assignment operator
TEST_F(ShmTest, HandleAssignment) {
std::string name = generate_unique_name("handle_assign");
shm::handle h1(name.c_str(), 768);
void* ptr1 = h1.get();
shm::handle h2;
h2 = std::move(h1);
EXPECT_TRUE(h2.valid());
EXPECT_EQ(h2.get(), ptr1);
EXPECT_FALSE(h1.valid());
}
// Test handle valid() method
TEST_F(ShmTest, HandleValid) {
shm::handle h1;
EXPECT_FALSE(h1.valid());
std::string name = generate_unique_name("handle_valid");
shm::handle h2(name.c_str(), 128);
EXPECT_TRUE(h2.valid());
}
// Test handle size() method
TEST_F(ShmTest, HandleSize) {
std::string name = generate_unique_name("handle_size");
const std::size_t requested_size = 2048;
shm::handle h(name.c_str(), requested_size);
EXPECT_GE(h.size(), requested_size);
}
// Test handle name() method
TEST_F(ShmTest, HandleName) {
std::string name = generate_unique_name("handle_name");
shm::handle h(name.c_str(), 256);
EXPECT_STREQ(h.name(), name.c_str());
}
// Test handle ref() method
TEST_F(ShmTest, HandleRef) {
std::string name = generate_unique_name("handle_ref");
shm::handle h(name.c_str(), 256);
std::int32_t ref = h.ref();
EXPECT_GT(ref, 0);
}
// Test handle sub_ref() method
TEST_F(ShmTest, HandleSubRef) {
std::string name = generate_unique_name("handle_sub_ref");
shm::handle h(name.c_str(), 256);
std::int32_t ref_before = h.ref();
h.sub_ref();
std::int32_t ref_after = h.ref();
EXPECT_EQ(ref_after, ref_before - 1);
}
// Test handle acquire() method
TEST_F(ShmTest, HandleAcquire) {
shm::handle h;
EXPECT_FALSE(h.valid());
std::string name = generate_unique_name("handle_acquire");
bool result = h.acquire(name.c_str(), 512);
EXPECT_TRUE(result);
EXPECT_TRUE(h.valid());
EXPECT_GE(h.size(), 512u);
}
// Test handle release() method
TEST_F(ShmTest, HandleRelease) {
std::string name = generate_unique_name("handle_release");
shm::handle h(name.c_str(), 256);
ASSERT_TRUE(h.valid());
std::int32_t ref_count = h.release();
EXPECT_GE(ref_count, 0);
}
// Test handle clear() method
TEST_F(ShmTest, HandleClear) {
std::string name = generate_unique_name("handle_clear");
shm::handle h(name.c_str(), 256);
ASSERT_TRUE(h.valid());
h.clear();
EXPECT_FALSE(h.valid());
}
// Test handle clear_storage() static method
TEST_F(ShmTest, HandleClearStorage) {
std::string name = generate_unique_name("handle_clear_storage");
{
shm::handle h(name.c_str(), 256);
EXPECT_TRUE(h.valid());
}
shm::handle::clear_storage(name.c_str());
// Try to open - should fail or create new
shm::handle h2(name.c_str(), 256, shm::open);
// Behavior depends on implementation
}
// Test handle get() method
TEST_F(ShmTest, HandleGet) {
std::string name = generate_unique_name("handle_get");
shm::handle h(name.c_str(), 512);
void* mem = h.get();
EXPECT_NE(mem, nullptr);
// Write and read test
const char* test_str = "Handle get test";
std::strcpy(static_cast<char*>(mem), test_str);
EXPECT_STREQ(static_cast<char*>(mem), test_str);
}
// Test handle detach() and attach() methods
TEST_F(ShmTest, HandleDetachAttach) {
std::string name = generate_unique_name("handle_detach_attach");
shm::handle h1(name.c_str(), 256);
ASSERT_TRUE(h1.valid());
shm::id_t id = h1.detach();
EXPECT_NE(id, nullptr);
EXPECT_FALSE(h1.valid()); // Should be invalid after detach
shm::handle h2;
h2.attach(id);
EXPECT_TRUE(h2.valid());
// Clean up - use h2.clear() or shm::remove(id) alone, not both
// Option 1: Use handle's clear() which calls shm::remove(id) internally
id = h2.detach(); // Detach first to get the id without releasing
shm::remove(id); // Then remove to clean up both memory and disk file
}
// Test writing and reading data through shared memory
TEST_F(ShmTest, WriteReadData) {
std::string name = generate_unique_name("write_read");
const std::size_t size = 1024;
shm::handle h1(name.c_str(), size);
ASSERT_TRUE(h1.valid());
// Write test data
struct TestData {
int value;
char text[64];
};
TestData* data1 = static_cast<TestData*>(h1.get());
data1->value = 42;
std::strcpy(data1->text, "Shared memory data");
// Open in another "shm::handle" (simulating different process)
shm::handle h2(name.c_str(), size, shm::open);
if (h2.valid()) {
TestData* data2 = static_cast<TestData*>(h2.get());
EXPECT_EQ(data2->value, 42);
EXPECT_STREQ(data2->text, "Shared memory data");
}
}
// Test handle with different modes
TEST_F(ShmTest, HandleModes) {
std::string name = generate_unique_name("handle_modes");
// Create only
shm::handle h1(name.c_str(), 256, shm::create);
EXPECT_TRUE(h1.valid());
// Open existing
shm::handle h2(name.c_str(), 256, shm::open);
EXPECT_TRUE(h2.valid());
// Both modes
shm::handle h3(name.c_str(), 256, shm::create | shm::open);
EXPECT_TRUE(h3.valid());
}
// Test multiple handles to same shared memory
TEST_F(ShmTest, MultipleHandles) {
std::string name = generate_unique_name("multiple_handles");
const std::size_t size = 512;
shm::handle h1(name.c_str(), size);
shm::handle h2(name.c_str(), size, shm::open);
ASSERT_TRUE(h1.valid());
ASSERT_TRUE(h2.valid());
// Should point to same memory
int* data1 = static_cast<int*>(h1.get());
int* data2 = static_cast<int*>(h2.get());
*data1 = 12345;
EXPECT_EQ(*data2, 12345);
}
// Test large shared memory segment
TEST_F(ShmTest, LargeSegment) {
std::string name = generate_unique_name("large_segment");
const std::size_t size = 10 * 1024 * 1024; // 10 MB
shm::handle h(name.c_str(), size);
if (h.valid()) {
EXPECT_GE(h.size(), size);
// Write pattern to a portion of memory
char* mem = static_cast<char*>(h.get());
for (std::size_t i = 0; i < 1024; ++i) {
mem[i] = static_cast<char>(i % 256);
}
// Verify pattern
for (std::size_t i = 0; i < 1024; ++i) {
EXPECT_EQ(mem[i], static_cast<char>(i % 256));
}
}
}
#include <cstring>
#include <cstdint>
#include <thread>
#include "libipc/shm.h"
#include "test.h"
using namespace ipc::shm;
namespace {
TEST(SHM, acquire) {
handle shm_hd;
EXPECT_FALSE(shm_hd.valid());
EXPECT_TRUE(shm_hd.acquire("my-test-1", 1024));
EXPECT_TRUE(shm_hd.valid());
EXPECT_STREQ(shm_hd.name(), "my-test-1");
EXPECT_TRUE(shm_hd.acquire("my-test-2", 2048));
EXPECT_TRUE(shm_hd.valid());
EXPECT_STREQ(shm_hd.name(), "my-test-2");
EXPECT_TRUE(shm_hd.acquire("my-test-3", 4096));
EXPECT_TRUE(shm_hd.valid());
EXPECT_STREQ(shm_hd.name(), "my-test-3");
}
TEST(SHM, release) {
handle shm_hd;
EXPECT_FALSE(shm_hd.valid());
shm_hd.release();
EXPECT_FALSE(shm_hd.valid());
EXPECT_TRUE(shm_hd.acquire("release-test-1", 512));
EXPECT_TRUE(shm_hd.valid());
shm_hd.release();
EXPECT_FALSE(shm_hd.valid());
}
TEST(SHM, get) {
handle shm_hd;
EXPECT_TRUE(shm_hd.get() == nullptr);
EXPECT_TRUE(shm_hd.acquire("get-test", 2048));
auto mem = shm_hd.get();
EXPECT_TRUE(mem != nullptr);
EXPECT_TRUE(mem == shm_hd.get());
std::uint8_t buf[1024] = {};
EXPECT_TRUE(memcmp(mem, buf, sizeof(buf)) == 0);
handle shm_other(shm_hd.name(), shm_hd.size());
EXPECT_TRUE(shm_other.get() != shm_hd.get());
}
TEST(SHM, hello) {
handle shm_hd;
EXPECT_TRUE(shm_hd.acquire("hello-test", 128));
auto mem = shm_hd.get();
EXPECT_TRUE(mem != nullptr);
constexpr char hello[] = "hello!";
std::memcpy(mem, hello, sizeof(hello));
EXPECT_STREQ((char const *)shm_hd.get(), hello);
shm_hd.release();
EXPECT_TRUE(shm_hd.get() == nullptr);
EXPECT_TRUE(shm_hd.acquire("hello-test", 1024));
mem = shm_hd.get();
EXPECT_TRUE(mem != nullptr);
std::uint8_t buf[1024] = {};
EXPECT_TRUE(memcmp(mem, buf, sizeof(buf)) == 0);
std::memcpy(mem, hello, sizeof(hello));
EXPECT_STREQ((char const *)shm_hd.get(), hello);
}
TEST(SHM, mt) {
handle shm_hd;
EXPECT_TRUE(shm_hd.acquire("mt-test", 256));
constexpr char hello[] = "hello!";
std::memcpy(shm_hd.get(), hello, sizeof(hello));
std::thread {
[&shm_hd] {
handle shm_mt(shm_hd.name(), shm_hd.size());
shm_hd.release();
constexpr char hello[] = "hello!";
EXPECT_STREQ((char const *)shm_mt.get(), hello);
}
}.join();
EXPECT_TRUE(shm_hd.get() == nullptr);
EXPECT_FALSE(shm_hd.valid());
EXPECT_TRUE(shm_hd.acquire("mt-test", 1024));
std::uint8_t buf[1024] = {};
EXPECT_TRUE(memcmp(shm_hd.get(), buf, sizeof(buf)) == 0);
}
} // internal-linkage

8
test/archive/test_sync.cpp → test/test_sync.cpp
View File

@ -37,11 +37,7 @@ TEST(PThread, Robust) {
pthread_mutex_destroy(&mutex);
}
#elif defined(IPC_OS_WINDOWS_)
#if defined(__MINGW32__)
#include <windows.h>
#else
#include <Windows.h>
#endif
#include <tchar.h>
TEST(PThread, Robust) {
@ -135,7 +131,7 @@ TEST(Sync, Condition) {
{
std::lock_guard<ipc::sync::mutex> guard {lock};
while (que.empty()) {
ASSERT_TRUE(cond.wait(lock, 1000));
EXPECT_TRUE(cond.wait(lock, 1000));
}
val = que.front();
que.pop_front();
@ -209,4 +205,4 @@ TEST(Sync, ConditionRobust) {
ASSERT_TRUE(lock.unlock());
printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 6\n");
unlock.join();
}
}

0
test/archive/test_thread_utility.cpp → test/test_thread_utility.cpp
View File

23
test/archive/test_waiter.cpp → test/test_waiter.cpp
View File

@ -4,6 +4,8 @@
#include "libipc/waiter.h"
#include "test.h"
namespace {
TEST(Waiter, broadcast) {
for (int i = 0; i < 10; ++i) {
ipc::detail::waiter waiter;
@ -63,23 +65,4 @@ TEST(Waiter, quit_waiting) {
std::cout << "quit... \n";
}
TEST(Waiter, clear) {
{
ipc::detail::waiter w{"my-waiter"};
ASSERT_TRUE(w.valid());
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_LOCK_", true));
w.clear();
ASSERT_TRUE(!w.valid());
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_LOCK_", false));
}
{
ipc::detail::waiter w{"my-waiter"};
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_COND_", true));
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_LOCK_", true));
ipc::detail::waiter::clear_storage("my-waiter");
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_COND_", false));
EXPECT_TRUE(ipc_ut::expect_exist("my-waiter_WAITER_LOCK_", false));
}
}
} // internal-linkage

0
test/archive/thread_pool.h → test/thread_pool.h
View File