TL;DR
This paper introduces the Network Code Processor (NCP), a hardware accelerator for conditional state-based communication schedules on real-time Ethernet. By offloading complex scheduling logic from the CPU to dedicated hardware, the NCP significantly reduces communication jitter and increases throughput, making it suitable for demanding industrial real-time applications.
What Problem Does This Paper Address?
Modern real-time systems, especially distributed ones, demand deterministic communication with bounded delays. While Ethernet is a ubiquitous and cost-effective network technology, its inherent nondeterminism (due to collision detection and backoff mechanisms) makes guaranteeing these bounded delays challenging. Existing software-based solutions for real-time Ethernet often introduce significant processing overhead and jitter, limiting their applicability in critical industrial scenarios. The paper addresses this by proposing a hardware acceleration approach for a specific type of real-time communication scheduling language called "Network Code," which allows for expressive, verifiable, and conditional communication schedules.
Methods
The core of the paper is the design and implementation of the Network Code Processor (NCP). The NCP is a custom application-specific instruction set processor (ASIP) synthesized onto an FPGA (XILINX Virtex 4). Key methodological aspects include:
- Hardware Acceleration: The NCP offloads the execution of Network Code programs from the main CPU to dedicated hardware. This allows for much faster and more deterministic execution of scheduling logic.
- Superscalar Architecture: The NCP employs a superscalar design with multiple autonomous execution units to exploit instruction-level parallelism and execute instructions concurrently.
- Dependency Analysis: A thorough analysis of control-flow, data, and mode dependencies between Network Code instructions was performed to identify opportunities for parallel execution and to ensure correct synchronization.
- Data Pipelining: For frequently occurring instruction sequences like "create(); send();", a data pipeline with a FIFO queue was implemented to allow concurrent execution, overcoming sequential dependencies.
- Integration with Legacy Systems: The NCP is designed to interface with standard operating system network drivers, allowing existing drivers to be reused without modification.
Datasets
Not discussed in the paper. The evaluation uses a ping-pong program for communication between two nodes, and robustness tests involve injecting rogue traffic.
Key Insights and Ideas
- Hardware is Key for Determinism: The paper strongly advocates for hardware acceleration to achieve the necessary determinism and low jitter for real-time Ethernet communication, especially when dealing with complex conditional schedules.
- Instruction-Level Parallelism in Scheduling: By treating communication scheduling as a program that can be parallelized, significant performance gains can be achieved, even for seemingly sequential operations.
- Dependency Analysis is Crucial: A deep understanding of instruction dependencies is fundamental to designing efficient hardware for parallel execution and avoiding system failures.
- Trade-offs in Hardware Design: The authors highlight the necessity of making design choices (e.g., limiting concurrent
future()instructions, single send buffer) to manage resource constraints on FPGAs while still achieving significant benefits. - Verification Simplifies Hardware: The existence of a verification framework for Network Code programs reduces the need for extensive error detection and recovery mechanisms in the hardware, leading to a more compact and efficient design.
Key Results
- Reduced Jitter: The hardware implementation (NCP) achieved significantly lower execution jitter compared to a software prototype, as evidenced by box plots showing jitter in the nanosecond range.
- Increased Throughput: The NCP demonstrated a higher throughput, especially at high reliability levels, outperforming the software implementation. For example, at 99.9994% reliability, the FPGA implementation achieved approximately 80 Mbit/s, while the software implementation reached around 30 Mbit/s.
- Predictable Performance: The execution speed of instructions was shown to grow linearly with data size, contributing to predictable system behavior.
- Robustness: The system showed good robustness against injected rogue traffic, with smaller packet sizes having no impact and larger packet sizes showing a linear correlation between injection rate and packet loss.
- Resource Efficiency: The NCP implementation on the XILINX Virtex 4 FPGA utilized a moderate amount of resources (30% of CLBs), leaving ample space for host system integration.
Limitations and Future Work
- Limited Concurrent
future()Instructions: The hardware implementation limits the number of concurrentfuture()instructions to at most four, a simplification from the software prototype. - Single Send Buffer: The
create()andsend()instructions share a single send buffer, meaning one packet must be prepared after the other has been sent. - Predefined Branching Functions: While the system allows extending branching functions, it primarily relies on a predefined set of frequently used conditions.
- Future Work: The authors suggest exploring the benefits of conditional state-based schedules on the development cycle and investigating the integration of multiple concurrent threads via multiple
future()instructions by synthesizing multiple NCPs. They also mention the potential for further research into using tools like MESCAL or Tensilica cores for ASIP design.
Summary updated