Aggregation-Based Message Synchronization for Distributed Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In distributed computing systems, software polling on event counters causes cache line bouncing between networking hardware and processor cache, reducing message processing rates due to per-message overhead and requiring long delays between polling events.
Innovation Solution
Implementing an aggregation-based message synchronization system that offloads event aggregation to networking hardware, allowing processor cores to sleep and reducing polling rates, thereby preventing cache line bouncing and enabling fast buffer reuse.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If processor cores poll the event counter frequently to detect message arrivals, then message detection responsiveness is improved, but cache line bouncing between networking hardware and processor cache increases, reducing message processing rate
Solution Approach 1:
The patent merges multiple individual message completion events into a single aggregated event that triggers when a threshold number of messages are received. This consolidation reduces the frequency of processor interventions from potentially every message arrival to only when the aggregation threshold is met, thereby eliminating cache line bouncing while maintaining effective message detection.
Solution Approach 2:
Instead of continuous or frequent polling of the event counter, the system implements periodic action through event aggregation where the processor is notified only at periodic intervals defined by the aggregation threshold. This periodic notification mechanism reduces cache line invalidations while ensuring the processor is informed of message arrivals in a timely manner.
2Productivity
If the polling rate is reduced to prevent cache line bouncing, then message processing rate is improved, but delay between message arrival and processor detection increases
Solution Approach 1:
By merging multiple message completion events into a single aggregated event, the system reduces processor intervention frequency to prevent cache line bouncing, thereby improving message processing rate. The aggregation threshold is configured to balance between reducing polling frequency and maintaining acceptable detection delay.
Solution Approach 2:
The system changes the parameter of event detection from individual message-level granularity to aggregated threshold-level granularity. This parameter change allows the processor to operate at higher speeds by reducing cache line bouncing, while the configurable aggregation threshold ensures that detection delay remains within acceptable bounds for the application.
3Productivity
If software polling is used on event counters, then per-message software overhead is incurred, but hardware event counters are available to reduce or eliminate this overhead
Solution Approach 1:
The patent extracts the event aggregation function from software polling and implements it in hardware within the networking device. This extraction eliminates per-message software overhead by allowing hardware to automatically track message completions and generate aggregated events, freeing the processor to focus on message processing rather than event monitoring.
Solution Approach 2:
The hardware event counter system provides self-service by automatically counting message completions and generating aggregated events without requiring software intervention for each message. This self-service mechanism eliminates the need for software polling and associated overhead, improving overall system efficiency.
Data Source
AI summary
Technologies for aggregation-based message processing include multiple computing nodes in communication over a network. A computing node receives a message from a remote computing node, increments an event counter in response to receiving the message, determines whether an event trigger is satisfied in response to incrementing the counter, and writes a completion event to an event queue if the event trigger is satisfied. An application of the computing node monitors the event queue for the completion event. The application may be executed by a processor core of the computing node, and the other operations may be performed by a host fabric interface of the computing node. The computing node may be a target node and count one-sided messages received from an initiator node, or the computing node may be an initiator node and count acknowledgement messages received from a target node. Other embodiments are described and claimed.