Decentralized Task Scheduling via Compiler-Embedded State Control
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing techniques for controlling tasks in computing systems incur processing time costs due to spawning new processes and switching between task processes and a scheduler, which hampers efficient execution of concurrent tasks.
Innovation Solution
A decentralized scheduling mechanism is implemented using a compiler to selectively spawn or reuse processes, leveraging state information stored in counters and flags to determine task execution, effectively creating a state machine that manages task subroutines without the overhead of a central scheduler.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If a centralized scheduler is used to manage task dependency and ordering, then task control and scheduling is simplified, but processing time increases due to frequent context switching between task processes and the scheduler
Solution Approach 1:
The patent extracts the scheduling logic from a centralized scheduler and embeds it directly into task subroutines. Each task subroutine now contains its own dependency checking and task spawning logic, eliminating the need for a separate centralized scheduling process and reducing context switching overhead.
Solution Approach 2:
Task subroutines become self-sufficient by containing their own control logic for checking dependencies and spawning subsequent tasks. Instead of relying on an external scheduler, each task manages its own execution flow and automatically triggers dependent tasks when their prerequisites are met.
2Reliability
If new processes are spawned for each task to ensure isolation and control, then task independence is maintained, but system overhead increases due to process creation and termination costs
Solution Approach 1:
The patent merges the task execution logic with the process control mechanism by embedding scheduling and dependency management directly within task subroutines. This consolidation eliminates the overhead of separate process creation while maintaining task independence through structured control flow within the subroutine framework.
3Productivity
If fine-grained concurrent tasks are implemented to improve parallelism, then computational efficiency increases, but the complexity of managing task dependencies and synchronization increases
Solution Approach 1:
The patent segments the scheduling complexity into individual task subroutine components, where each task independently manages its own dependencies and triggers. This segmentation distributes the control logic across multiple simple units rather than requiring a single complex centralized scheduler, making fine-grained concurrent task management more tractable.
Data Source
Figure 1
Figure 2A
Figure 2B
AI summary
A graph-based program specification (104) specifies at least a partial ordering among a plurality of tasks represented by its nodes. Executing a specified program includes: executing a first subroutine corresponding to a first task, including a first task section for performing the first task; storing state information indicating a state of the first task selected from a set of possible states that includes: a pending state in which the first task section is waiting to perform the first task, and a suppressed state in which the first task section has been prevented from performing the first task; and executing a second subroutine corresponding to a second task, including a second task section for performing the second task, and a control section that controls execution of the second task section based at least in part on the state of the first task indicated by the stored state information.