ipc.h File Reference

Aggregated header for inter-process communication primitives under jh::sync. More...

#include "jh/synchronous/ipc/ipc_limits.h"
#include "jh/synchronous/ipc/process_mutex.h"
#include "jh/synchronous/ipc/process_cond_var.h"
#include "jh/synchronous/ipc/process_counter.h"
#include "jh/synchronous/ipc/process_shm_obj.h"
#include "jh/synchronous/ipc/shared_process_mutex.h"
#include "jh/synchronous/ipc/process_launcher.h"

Go to the source code of this file.

Namespaces
namespace	jh::sync
	Aggregated entry point for synchronization and coordination facilities.
namespace	jh::sync::ipc
	Synchronous inter-process coordination primitives.

Detailed Description

Aggregated header for inter-process communication primitives under jh::sync.

Copyright

Copyright 2025 JeongHan-Bae <mastropseudo@gmail.com>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Full license: GitHub

This header collects all IPC-related synchronous primitives into a single entry point:

#include <jh/synchronous/ipc.h>

It includes and re-exports all IPC components under jh::sync::ipc, such as shared-memory synchronization and inter-process coordination utilities.

Included Components

• ipc_limits — compile-time IPC capacity and name validation utilities.
• process_mutex — basic inter-process mutex, functionally similar to std::timed_mutex; non-recursive and minimal, used as the fundamental synchronization primitive.
• process_cond_var — condition variable for processes.
• process_counter — atomic counter for process coordination.
• process_shm_obj — shared memory allocator and container.
• shared_process_mutex — engineering-grade reader-writer lock built on shared memory, conceptually similar to std::shared_timed_mutex but supporting reentrancy and privileged read-to-write promotion under elevated contexts.
• process_launcher — process orchestration utilities.

Philosophy

Unlike Boost.Interprocess, which centralizes resource management within a managed shared memory segment, the jh::sync::ipc system implements compile-time named, process-independent primitives built directly on OS-level shared memory and semaphores.

Each primitive (mutex, condition, counter, shared memory) is a self-contained, globally addressable IPC object. No central allocator or parent process is required — all participants synchronize via shared OS namespaces.

This design enables decentralized, single-machine distributed coordination with compile-time safety and zero runtime registration. The system itself, not a supervising process, performs the scheduling. Daemons only perform minimal orchestration, reducing cognitive overhead.

Compile-time naming contract

All IPC primitives in jh::sync::ipc rely on a compile-time naming convention enforced by jh::sync::ipc::limits::valid_object_name.

• Each synchronization object (e.g., semaphore, shared memory region, condition) is bound to a name known at compile time.
• The name serves as the linkage contract between processes — identical template literals across binaries guarantee consistent mapping.
• Invalid or conflicting names produce compile-time errors, ensuring namespace safety and deterministic inter-process behavior.
• Names may be hardcoded or provided through macros at build time, but must be resolvable during compilation to ensure deterministic layout.

This model guarantees mapping consistency, eliminates runtime name collisions, and provides a static coordination topology — effectively compile-time declared IPC fabric.