Thread Management System Virtual Actual Priority Mapping
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current operating systems lack a robust and flexible thread prioritization mechanism, particularly for applications requiring a broad range of priority levels and strict adherence, which can lead to thread starvation and inefficiencies in multithreaded environments.
Innovation Solution
The implementation of a thread management system that utilizes a combination of virtual and actual priorities, where threads select virtual priorities and are associated with actual priorities through a thread selection algorithm, allowing for dynamic scheduling and execution based on priority levels, enabling efficient execution and preventing thread starvation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If operating systems use a limited number of priority levels (e.g., 6-32 levels), then the system complexity is reduced and ease of operation is improved, but the ability to provide broad range of priority levels and strict adherence to priority scheduling is worsened
Solution Approach 1:
The patent segments the priority level system into two distinct components: virtual priority levels (used by threads for selection) and actual priority levels (used by the operating system for scheduling). This segmentation allows threads to operate with a broad range of virtual priorities while the OS manages a smaller set of actual priorities, resolving the contradiction between versatility and ease of operation.
Solution Approach 2:
The patent introduces a thread selection algorithm as an intermediary layer between threads and the operating system scheduler. This algorithm maps virtual priorities to actual priorities, allowing threads to select from many virtual priority levels while the OS only needs to manage a limited number of actual priority levels. The intermediary resolves the contradiction by decoupling the thread's priority selection freedom from the OS's scheduling complexity.
2Reliability
If operating systems run lower-priority threads to avoid thread starvation and pursue fairness, then system fairness is improved, but the strict adherence to priority-based scheduling is worsened
Solution Approach 1:
The patent changes the parameter space by introducing virtual priorities that operate differently from traditional priority levels. Threads select virtual priorities from a broad range, and the thread selection algorithm maps these to actual priorities used for scheduling. This parameter transformation allows the system to maintain strict priority-based scheduling for most threads while providing mechanisms to prevent starvation through the virtual/actual priority mapping.
3Adaptability or versatility
If operating systems provide user-mode scheduling for soft real-time applications, then the ability to host priority-based scheduling is improved, but the system complexity and device complexity are worsened
Solution Approach 1:
The patent implements self-service by allowing threads to autonomously select their own virtual priority levels. This eliminates the need for complex OS-level priority assignment mechanisms, as threads independently determine their priority preferences. The thread selection algorithm then automatically maps these self-selected virtual priorities to actual scheduling priorities, reducing the complexity of OS-managed scheduling while maintaining real-time capabilities.
Data Source
AI summary
A method includes using processing circuitry and at least one memory configured to store a plurality of threads. The method includes providing an environment associated with an operating system to execute one or more threads of the plurality of threads. The environment includes a plurality of virtual priorities and a plurality of actual priorities. Each of the plurality of threads is allowed to select a virtual priority of the plurality of virtual priorities. The method also includes associating an actual priority of the plurality of actual priorities to one of the plurality of threads based on the plurality of virtual priorities assigned to the plurality of threads. The method also includes executing the one of the plurality of threads associated with the actual priority.