Lock-Free Polling for Interdependent Hardware State Monitoring
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing hardware monitoring techniques face challenges in maintaining atomicity and consistency when polling interdependent hardware components, often resulting in blocking issues that hinder efficient data access and processing.
Innovation Solution
A polling process that utilizes a poller loop to maintain aggregate state information through a shared data structure, employing a lock-free routine to collect and update state information while using additional data structures to ensure atomicity without blocking, allowing for contradiction-free and non-blocking access.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If atomicity is enforced through locking mechanisms to maintain consistency of aggregate state information, then data consistency is improved, but system performance deteriorates due to blocking
Solution Approach 1:
The patent divides the aggregate state data structure into multiple components: a shared read-only aggregate state structure and per-thread local copies. This segmentation allows multiple threads to read from the shared structure simultaneously without blocking, while each thread maintains its own local copy for writing operations, eliminating the need for global locks during polling operations.
Solution Approach 2:
The patent employs copying by having each polling thread maintain a local copy of the aggregate state structure. Instead of all threads sharing a single mutable structure that requires locking, each thread has its own copy that it can read and write without blocking other threads. The shared structure is copied to local memory at initialization, and updates are propagated asynchronously.
2Reliability
If locking mechanisms are used to ensure atomic access to aggregate state information, then data integrity is improved, but access time increases due to blocking
Solution Approach 1:
The patent segments the data access pattern into read operations on shared immutable data and write operations on local private data. This segmentation eliminates the need for locks during read operations, allowing O(1) time complexity for reading aggregate state information without blocking other threads.
Solution Approach 2:
The patent performs preliminary action by copying the aggregate state structure to local memory at thread initialization or at intervals when changes occur. This pre-copying ensures that threads have immediate access to the latest state information without needing to acquire locks during their polling operations, significantly reducing access time.
3Device complexity
If a single shared data structure is used for aggregate state information, then device complexity is reduced, but concurrency capability deteriorates due to blocking
Solution Approach 1:
The patent segments the single shared data structure into a shared read-only aggregate state structure and multiple private local copies, one per polling thread. This segmentation enables concurrent read-write operations without blocking, as each thread operates on its own local copy while reading from the shared structure, significantly improving concurrency capability.
Solution Approach 2:
The patent uses copying to create private local copies of the aggregate state structure for each polling thread. These local copies are initialized from the shared structure and updated asynchronously, allowing multiple threads to perform polling operations concurrently without blocking each other, thereby enhancing concurrency capability while maintaining manageable data structure complexity.
Data Source
AI summary
Systems and methods are provided to implement a polling process for monitoring a system of interdependent hardware components. A shared aggregate state data structure comprising information of an aggregate state of the interdependent hardware components is maintained in a system memory. A poller loop process generates and utilizes two local instances in system memory of the shared aggregate state data structure, including a current state data structure and a previous state data structure. The current state data structure is utilized during a lock-free polling routine to store current aggregate state data of the interdependent hardware components, while other executing threads outside the poller loop process can access the shared aggregate state data structure. The shared aggregate state data structure is updated by performing a merge of state information contained in the shared aggregate state, current aggregate state, and previous aggregate state data structures.