Packet Processing Epoch Updates Without Throughput Jitter
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing packet processing data structures face challenges in handling updates without adversely impacting concurrent throughput, leading to packet timing jitter or complete processing halts.
Innovation Solution
Implementing an epoch-based garbage collection method with lock-free updates, using packet processing epochs to manage updates and deletions, allowing uninterrupted packet processing through multi-core environments.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If updates are performed on the packet processing data structure by adding or removing nodes, then the data structure can be maintained and updated, but packet processing throughput is adversely impacted causing timing jitter or complete processing halts
Solution Approach 1:
The system segments packet processing into multiple independent epochs, where each epoch represents a snapshot of the packet processing data structure at a specific point in time. Multiple epochs can coexist and be processed in parallel, allowing updates to one epoch without blocking processing in other epochs. This segmentation enables concurrent packet processing while maintaining data structure integrity.
Solution Approach 2:
The system performs preliminary actions by creating complete epoch snapshots before making any updates to the packet processing data structure. Each epoch is fully constructed and validated before being activated for packet processing. This preliminary preparation ensures that when updates occur, they do not interfere with ongoing packet processing operations, as the processing threads are already working with stable, pre-defined epoch data.
2Quantity of substance
If objects are deleted from the packet processing data structure to free memory, then memory availability is improved, but packet processing may be interrupted or halted
Solution Approach 1:
The system performs preliminary actions by pre-allocating and preparing multiple epoch snapshots in advance. Each epoch is fully constructed with all necessary objects and data structures before being activated. This allows the system to maintain multiple complete copies of processing data in memory simultaneously, ensuring that when one epoch is being processed, others are already ready or being prepared, eliminating the need to interrupt processing to free or reallocate memory.
Solution Approach 2:
The system implements a mechanism where obsolete epochs are discarded and their memory resources are recovered only after confirming that no packet processing operations are referencing them. The system maintains a reference counting mechanism that tracks active usage of each epoch, allowing safe memory reclamation of discarded epochs while ensuring active epochs retain their memory resources for uninterrupted packet processing.
Data Source
AI summary
In operation, packets traverse the packet processing data structure, and the network processing represented by each object in the data structure is applied to each packet. From time to time, the packet processing data structure may need to be updated. Embodiments of the present disclosure provide for lock-free updating of a packet processing data structure by means of epoch-based garbage collection. In embodiments, a particular past packet processing epoch is considered to be no longer referenced by any cores when the sequence numbers recorded in each said memory location are different to the sequence number of that particular past packet processing epoch. The deletion thread checks both whether a past epoch is being referenced by any packets and whether it is being reference by any cores. Thus memory is safely freed without having any impact on any packet processing which may be occurring in parallel to the deletion thread.