Processes, threads and shared memory

Threads share one address space: passing data is a pointer and a queue, and a crash or memory corruption in one takes down all of them. Processes have separate address spaces: a crash in one leaves the others running, they can be restarted and deployed independently, and one can be written in a different language, but passing data needs an inter-process mechanism.

Trading systems use both. A common shape is one process per function (market-data handling, each strategy, order gateway, risk), with several pinned threads inside each, communicating through shared memory. The question's design reflects that.

Every mechanism that goes through the kernel costs at least two system calls and two copies per message, plus a wake-up if the reader sleeps. That is microseconds. Shared memory costs what a cache line transfer between cores costs.

Both processes map the same physical pages, so a data structure placed in that region is visible to both. The SPSC ring from Module 4 works unchanged, as long as it uses only atomics and plain data and contains no pointers.

// both processes
int fd = shm_open("/md_to_strat", O_CREAT | O_RDWR, 0600);
ftruncate(fd, sizeof(Ring));
void* p = mmap(nullptr, sizeof(Ring), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, fd, 0);
// creator only: placement-new the ring so its atomics are constructed once
Ring* ring = static_cast<Ring*>(p);

Rules for structures in shared memory:

• No pointers. The region may be mapped at different addresses in each process. Use offsets or indices.
• Only lock-free atomics, and check std::atomic<T>::is_always_lock_free; an atomic implemented with a hidden lock would put the lock in one process's memory.
• Trivially copyable, fixed-layout data, checked with static_assert on sizes, since the two sides may be built separately.
• A version and layout check in a header at the start of the region, so a reader built against an old layout refuses to attach.
• Huge pages and pre-faulting for large regions, as in the previous lessons.

Shared memory makes crash isolation partial. If the strategy dies, the ring keeps its state, the feed keeps writing, and the ring fills; the feed must treat a full ring as "consumer gone or slow" and drop rather than block. If the feed dies, the strategy sees no new data and needs a heartbeat to tell silence from a dead producer. A restarted process must be able to attach to an existing region and resume, or start from a clean one. A mutex in shared memory is particularly dangerous: if a process dies holding it, the others wait for ever unless it is a robust mutex (PTHREAD_MUTEX_ROBUST), which is one more reason the hot path uses lock-free structures.

Market data is usually consumed by several strategies. Rather than one ring per reader written by the feed, a common design is a single broadcast ring: the feed writes each message once, each reader keeps its own read position, and the writer never waits for readers. A reader that falls a full lap behind detects that its position has been overwritten (from a sequence number in each slot) and resynchronises from a snapshot. This is the same idea as the seqlock, applied to a log of messages.