Local Poll Flag for Resource Access in Multi-Node Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In large-scale shared memory architectures, maintaining coherence across multiple processing nodes is challenging due to non-coherent memory interconnects, leading to excessive cache contention and resource contention issues, which complicates mutual exclusion and efficient inter-processor communication.
Innovation Solution
Implementing a local lock node data structure on each processing node, where threads poll for resource availability using a linked list with flags and pointers, allowing for quick and efficient local polling, even for resources external to the node, and utilizing remote storage operations to manage shared resource access across nodes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If shared memory is scaled to support a very large number of processors, then data sharing capability is improved, but cache contention and resource contention increase
Solution Approach 1:
The system segments the lock management functionality by creating separate lock node data structures for each processing node. Each node maintains its own local lock nodes in local memory, dividing the global lock management problem into distributed local problems. This segmentation reduces cache contention by preventing all processors from accessing a single centralized lock structure.
Solution Approach 2:
The patent implements local quality by placing lock node data structures in local memory on each processing node rather than in shared memory. Threads poll local flags in local memory, which is faster and does not cause cache coherence traffic. This localizes the quality of lock access to be node-specific, improving scalability.
2Reliability
If traditional centralized locking is used across multiple processing nodes, then mutual exclusion is ensured, but overhead and delay increase
Solution Approach 1:
The patent introduces an intermediary mechanism where each processing node acts as an independent intermediary for its own lock nodes. Instead of a centralized lock manager, each node independently manages its local lock nodes, reducing communication overhead. The local poll flag acts as an intermediary signal that threads check locally rather than requiring remote synchronization.
Solution Approach 2:
Each processing node serves itself by maintaining and managing its own lock node data structures in local memory. Threads on a node poll local flags without requiring intervention from other nodes or centralized coordination. This self-service approach reduces the overhead of inter-node communication and centralized lock management.
3Adaptability or versatility
If non-coherent memory interconnects are used, then system scalability is improved, but coherence maintenance becomes challenging
Solution Approach 1:
The patent extracts the coherence problem by removing lock node data structures from shared coherent memory and placing them in local non-coherent memory on each processing node. This extraction eliminates the need for coherence maintenance across nodes for lock data, as each node independently manages its local lock nodes without requiring coherence protocols.
Data Source
AI summary
Examples disclosed herein relate to locally polling the value of a flag to determine whether a resource is free for a thread to use in a system with multiple processing nodes that are incoherent with regards to each other. A flag in a direct attached memory to one of the processing nodes is set to indicate that the resource is not free for the thread to use. A previous tail of a lock list is determined from a list master. The previous tail is located on another one of the processing nodes.