Zero-Copy Communication for Efficient Compound Processes

Modern software systems increasingly depend on components that communicate frequently and at high speed. Yet most systems still rely on traditional process isolation, where communication passes through kernel-managed interfaces. These interfaces introduce user–kernel transitions, disturb caches, and repeatedly copy data, overheads that quickly become dominant in data-intensive workloads. The Compound Processes framework reduces some of these costs by allowing multiple cooperating guests to run inside a shared, trusted environment, but its current communication paths still require one or more data-copy operations. This thesis presents the first thorough exploration of zero-copy communication within Compound Processes. It introduces two new mechanisms that remove data duplication entirely: a wait-based protocol, and a scheduler-assisted protocol that moves computation to the core where the data already resides. These approaches are evaluated alongside the existing syscall-based, double-copy, and single-copy strategies. To make zero-copy usable by unmodified applications, the work also develops a fully automated binary rewriting pipeline that combines conservative static analysis with targeted ELF code injection, enabling executables to benefit from zero-copy without needing source code changes. After examining the architectural constraints of Compound and the behavior of its guests, the thesis evaluates all communication mechanisms across a range of message sizes, hardware placements, and usage scenarios. The results show how cache hierarchy, NUMA effects, and producer–consumer patterns shape latency and correctness. The scheduler-assisted design delivers near-ideal locality by running the reader’s usage phase directly on the writer’s core, while the wait-based design provides a simpler option that performs best when both guests share a core. Across four benchmarks, message passing, allocation, usage, and round-trip, the zero-copy mechanisms reduce inter-guest communication costs by up to 1300× compared to traditional syscalls for large message sizes. Overall, the findings highlight the core trade-offs of zero-copy within a trusted multi-guest environment: removing data movement unlocks large performance gains, but maintaining correctness requires careful synchronization and conservative safety checks. Through its combination of analysis, rewriting, and runtime support, this work shows that zero-copy can be integrated transparently and safely into existing binaries, providing a practical path toward significantly faster communication in cooperative software systems.

Author dc:creator

• Marco Laurenzi (24399728)

• Computer Science

Statement dc:rights

• In Copyright

DOI dc:identifier

https://doi.org/10.25417/uic.32994215.v1

OAI identifier oai:identifier

oai:figshare.com:article/32994215