Programmable Data Plane Event Processing Architecture for Atomic State Updates
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current programmable data plane event processing systems face challenges in performing read-modify-write operations on stateful packet processing, particularly in ensuring atomicity and efficiency across multiple clock cycles, which limits the scope of applicable algorithms and can lead to performance bottlenecks.
Innovation Solution
A programmable data plane event processing architecture that includes packet or event processing units (PPUs/EPUs) capable of performing stateful operations, such as multi-instruction or multiple arithmetic logic unit (ALU) operations over multiple clock cycles, with integrated static random access memory (SRAM) and content-addressable memory (CAM) resources, allowing for atomic updates of state variables and efficient processing of event metadata fields in series or parallel.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If read-modify-write operations are implemented atomically per-packet within a single clock cycle, then atomicity and simplicity are improved, but the scope of applicable stateful packet processing algorithms is limited
Solution Approach 1:
The system dynamically adjusts the atomicity scope based on operation type: simple read-modify-write operations maintain single-cycle atomicity, while complex stateful operations allow multi-cycle execution with per-flow atomicity. This dynamic approach resolves the contradiction by adapting the atomicity guarantee to the specific operation requirements.
Solution Approach 2:
The system segments packet processing into per-flow state operations and per-packet operations. Per-flow state can be updated across multiple clock cycles with atomicity guaranteed at the flow level, while per-packet operations maintain single-cycle atomicity. This segmentation allows complex algorithms to operate on per-flow state without compromising overall system atomicity.
2Productivity
If simple read-modify-write operations are performed atomically per-packet, then processing speed is improved, but complex stateful packet processing algorithms cannot be implemented
Solution Approach 1:
The system dynamically selects between single-cycle atomic operations for simple cases and multi-cycle operations with per-flow atomicity for complex cases. This dynamic selection maintains high processing speed for simple operations while enabling complex stateful algorithms when needed.
Solution Approach 2:
Complex stateful algorithms are segmented into per-flow state updates that can span multiple clock cycles. The system maintains per-flow atomicity during these multi-cycle operations, allowing complex algorithms to be implemented without significantly impacting overall processing throughput.
3Productivity
If per-packet atomic read-modify-write operations are implemented, then simplicity and speed are improved, but head-of-line blocking occurs
Solution Approach 1:
The system segments atomicity guarantees into per-packet and per-flow levels. Per-flow state operations can be processed out of strict packet order, allowing packets from different flows to be processed in parallel without head-of-line blocking, while maintaining atomicity at the flow level.
Solution Approach 2:
The system dynamically determines the appropriate atomicity scope based on operation characteristics. Operations that can tolerate non-strict ordering benefit from per-flow atomicity with reduced blocking, while operations requiring strict per-packet atomicity maintain single-cycle execution.
Data Source
AI summary
Examples described herein relate to a network interface device that includes a programmable event processing architecture comprising a plurality of programmable event processors. When the plurality of programmable event processors are operational, one or more of the programmable event processors are to perform memory accesses separate from compute operations, group one or more events into at least one group, enforce atomic processing of other events within a group of the at least one group, wherein the atomic processing comprises propagation of state changes to among events of the group, and perform parallel processing of events belonging to different groups.