Distributed Peek-Poller Threads for CPU Resource Sharing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In data storage systems, block-storage applications that constantly poll interfaces lead to 100% CPU core utilization, making it challenging to dynamically adapt and efficiently share resources with other applications, resulting in potential CPU power loss and inefficient use of processing resources.
Innovation Solution
Implementing a scheduling architecture with provider threads and peek-poller threads that distribute workload across CPU cores, allowing block threads to release CPU resources when idle and enabling other applications to utilize them, while ensuring quick detection and handling of new events to maintain performance.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If provider threads constantly poll interfaces for application events, then event detection speed is improved, but CPU core utilization reaches 100% preventing other applications from using processing resources
Solution Approach 1:
The provider thread alternates between active polling phases and sleep states, creating periodic action patterns. During active phases, the thread polls interfaces for events at high speed. When no events are present, the thread enters sleep state, allowing CPU cores to be released for other applications. This periodic activation and deactivation resolves the contradiction between maintaining fast event detection and enabling CPU resource sharing.
Solution Approach 2:
The peek-poller thread acts as an intermediary between the sleeping provider thread and the interface events. Instead of the provider thread continuously polling, the peek-poller thread periodically checks interfaces and wakes up the provider thread only when events are detected. This intermediary mechanism maintains fast event response while allowing the provider thread to sleep during idle periods, enabling CPU resource sharing with other applications.
2Loss of energy
If provider threads enter sleep state to release CPU resources, then CPU power efficiency is improved, but event detection latency increases
Solution Approach 1:
The peek-poller thread performs preliminary checking of interfaces before waking up the provider thread. By proactively detecting events and preparing to activate the provider thread, the system minimizes the actual latency experienced. The peek-poller thread stays in readiness and can immediately wake the provider thread when events occur, rather than relying on the sleeping thread to wake up on its own schedule.
Solution Approach 2:
The system implements feedback through the peek-poller thread monitoring interface events and providing wake-up signals to sleeping provider threads. This feedback mechanism ensures that when events occur, the sleeping provider thread is quickly activated. The continuous monitoring and selective wake-up creates a feedback loop that balances energy efficiency with timely event response, reducing detection latency while maintaining power savings during idle periods.
3Reliability
If dedicated cores are assigned to peek-poller functionality, then event monitoring reliability is improved, but available CPU power for other applications decreases
Solution Approach 1:
The peek-poller threads are distributed across all available CPU cores rather than being confined to dedicated cores. Each core can execute both provider thread workloads and peek-poller monitoring functions. This multi-functional approach allows CPU cores to dynamically serve both event monitoring and application processing roles, maintaining reliable event detection while maximizing the available processing power for other applications.
Solution Approach 2:
The functionality of provider threads and peek-poller threads is merged at the core level. Instead of separating monitoring functions into dedicated cores, the system combines both polling and peek-poller capabilities within the same CPU core infrastructure. This merging allows efficient utilization of CPU resources, where cores can switch between provider and peek-poller roles as needed, ensuring reliable event monitoring without sacrificing available processing power.
Data Source
AI summary
A method of multitasked operation of a data storage node includes executing provider threads of an application, the provider threads distributed among processing cores along with respective peek-poller threads, each provider thread having regular operations of (1) continually polling interfaces of the data storage node for application events requiring processing, and (2) performing processing tasks for the application events until there are no unprocessed additional events for the provider thread, and thereupon entering a sleep state. The method further includes regularly executing the peek-poller threads on the processing cores, each peek-poller thread having operations of (1) checking interfaces of the data storage node for new application events to be processed by respective provider threads currently in the sleep state, and (2) for each new application event, activating the respective provider thread on the respective processing core.