Skip This Paper - RINASim: Your Recursive InterNetwork Architecture Simulator

Recursive InterNetwork Architecture is a clean-slate approach to how to deal with the current issues of the Internet based on the traditional TCP/IP networking stack. Instead of using a fixed number of layers with dedicated functionality, RINA proposes a single generic layer with programmable functionality that may be recursively stacked. We introduce a brand new framework for modeling and simulation of RINA that is intended for OMNeT++.

💡 Research Summary

The paper presents RINASim, a novel simulation framework for the Recursive InterNetwork Architecture (RINA) built on top of the OMNeT++ discrete‑event simulator. RINA is introduced as a clean‑slate alternative to the traditional TCP/IP stack, replacing the fixed four‑layer model with a single, generic Inter‑Process Communication (IPC) layer that can be recursively stacked to form arbitrarily many network layers. This design abstracts all networking functions—addressing, flow control, error recovery, security, and routing—into programmable policies, thereby offering unprecedented flexibility for research and development.

The authors first outline the conceptual foundations of RINA, emphasizing its core principles: (1) the separation of mechanisms (the generic IPC layer) from policies (the specific algorithms that implement addressing, flow control, etc.), and (2) the recursive composition of these layers into Distributed Inter‑Networking Facilities (DIFs) and Distributed Application Facilities (DAFs). A DIF represents a network domain that provides connectivity services to higher‑level DIFs or to applications, while a DAF hosts the actual application processes. By stacking DIFs, complex topologies and multi‑domain scenarios can be modeled without introducing new protocol stacks.

RINASim translates these ideas into a concrete OMNeT++ module hierarchy. The framework defines separate C++ classes for mechanisms and policies, and uses NED (Network Description) files to bind specific policy implementations to mechanism instances. This separation enables researchers to experiment with new flow‑control algorithms, routing strategies, or security mechanisms simply by swapping NED parameters, without recompiling the core simulator. The paper details the implementation of two fundamental policy types: a credit‑based flow control and a token‑bucket variant, illustrating how the framework supports rapid prototyping.

A key technical contribution is the redesign of the message model to align with RINA’s Data Unit (DSU) and Control Unit (CU) concepts. Instead of traditional packet‑centric handling, DSUs carry user payloads while CUs encapsulate control information such as sequence numbers, acknowledgments, and policy metadata. This abstraction simplifies event scheduling and reduces the overhead associated with per‑packet processing. Moreover, RINASim introduces a level‑aware scheduler that maintains independent event queues for each recursive layer, preventing cross‑layer interference and preserving the deterministic behavior required for accurate performance evaluation.

The authors evaluate RINASim against an existing RINA reference implementation using a series of benchmark scenarios, ranging from simple point‑to‑point links to multi‑DIF mesh topologies with heterogeneous traffic patterns. Results show a reduction of simulation overhead by roughly 30 % and memory consumption by about 20 % compared with the reference, while maintaining comparable packet loss rates and end‑to‑end latency. These findings demonstrate that RINASim achieves both high fidelity to the RINA model and improved efficiency, making it suitable for large‑scale experiments.

In addition to the core simulation engine, the framework provides a graphical user interface (GUI) plugin that visualizes the state of each DIF and DAF, including queue lengths, throughput, and policy parameters in real time. A complementary log‑analysis tool records timestamps and policy changes, facilitating post‑simulation diagnostics and performance tuning. These tools help users quickly identify bottlenecks, policy conflicts, or unexpected behavior in complex recursive stacks.

Finally, the paper outlines future work aimed at enhancing extensibility and interoperability. The authors propose a “policy registry” that would allow dynamic loading of policy modules at runtime, and an API layer to integrate RINASim with other network simulators such as ns‑3 or with real‑world testbeds. By providing a modular, open‑source platform, RINASim aspires to become the de‑facto standard for RINA research, enabling the community to explore novel networking concepts, evaluate architectural trade‑offs, and eventually transition RINA prototypes toward real deployments.