Thread Scheduling Using Priority Weights and Instruction Counts

Solution Overview

Problem

Existing scheduling methods for multi-threaded systems are simplistic and lack flexibility, leading to performance issues in dynamic processing scenarios where greater control over resource allocation is needed.

Innovation Solution

Implementing dynamic scheduling with priority weights assigned to threads, using an instruction count in combination with priority weights to determine the prioritization order of instructions for processing, allowing for flexible and effective control over thread scheduling.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of operation

If simple scheduling algorithms like round-robin or lightest-workload-first are used, then the scheduling mechanism is easy to implement, but the system lacks flexibility and control in complicated processing scenarios

Engineering Contradiction:
Core Design Contradiction:
Ease of operationVSAdaptability or versatility

Solution Approach 1:

The patent implements dynamic scheduling by allowing runtime modification of thread priorities through software mechanisms. The scheduler can dynamically adjust which thread executes next based on changing workload conditions, moving beyond static algorithms like round-robin to an adaptive system that responds to real-time demands.

Inventive Principle:
Principle #15Dynamics

Solution Approach 2:

The patent changes the scheduling parameter from fixed algorithms to adjustable priority weights. By allowing the priority of threads to be modified as a controllable parameter, the system can adapt to different processing scenarios without changing the fundamental scheduling mechanism, thus maintaining simplicity while gaining flexibility.

Inventive Principle:
Principle #35Parameter changes

2Stability of the object's composition

If static allocation algorithms are used, then the scheduling mechanism is stable and predictable, but it cannot adapt to changing conditions and lacks flexibility in resource allocation

Engineering Contradiction:
Core Design Contradiction:
Stability of the object's compositionVSAdaptability or versatility

Solution Approach 1:

The patent introduces dynamic priority adjustment capabilities that allow the scheduling system to adapt to changing conditions. While maintaining a stable scheduler architecture, the system can modify thread priorities at runtime based on workload demands, enabling flexible resource allocation without redesigning the fundamental scheduling mechanism.

Inventive Principle:
Principle #15Dynamics

3Adaptability or versatility

If priority weights and instruction counts are combined for scheduling, then flexible and effective thread prioritization is achieved, but the scheduling complexity increases

Engineering Contradiction:
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent introduces an intermediary calculation mechanism that combines priority weights and instruction counts into a unified scheduling decision. This intermediary layer abstracts the complexity of combining multiple factors, allowing the scheduler to make informed prioritization decisions without exposing the underlying complexity to the rest of the system.

Inventive Principle:
Principle #24Intermediary (Mediator)

Data Source

PatentUS9069564B1Weighted instruction count scheduling
Publication Date: 2015.06.30
  • US9069564B1 patent drawing
  • US9069564B1 patent drawing
  • US9069564B1 patent drawing

AI summary

A method and system are provided for performing efficient and effective scheduling in a multi-threaded system. Dynamic control of scheduling is provided, in which priority weights can be assigned for some or all of the threads in the multi-threaded system. The priority weights are employed to control prioritization of threads and thread instructions by a scheduler. An instruction count for each thread is used in combination with the priority weights to determine the prioritization order in which instructions are fetched and assigned to execution units for processing.