Multicore Task Scheduling via Contention Thresholds
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Complexity in computing architectures of safety-critical systems leads to predictability and determinism issues due to interference channels, making it challenging to manage mixed-criticality applications effectively, especially in multicore systems where contention scenarios increase worst-case execution time and hinder time determinism.
Innovation Solution
A method and system that determine the criticality level of each task, allocate tasks to processing cores based on criticality, assign unique contention thresholds, monitor contention, and suspend processing on cores reaching their thresholds, allowing for flexible scheduling and ensuring bounded worst-case execution time.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If static resource and time partition allocations are imposed to enforce determinism, then predictability and determinism are improved, but system flexibility and resource utilization deteriorate
Solution Approach 1:
The system dynamically adjusts the degree of partitioning and resource allocation based on the criticality level of tasks. High-criticality tasks receive strict deterministic guarantees through partitioning, while low-criticality tasks operate with greater flexibility and shared resource access, allowing the system to adapt its scheduling behavior to task requirements rather than imposing uniform static constraints
Solution Approach 2:
Different partitioning strategies and resource allocation policies are applied to different tasks based on their criticality levels. High-criticality tasks are assigned dedicated partitions with strict temporal guarantees, while low-criticality tasks share resources with more relaxed constraints, enabling each task to operate under the most appropriate scheduling conditions for its requirements
2Productivity
If more processing cores are added to handle mixed-criticality applications, then system capacity and task handling improve, but contention scenarios and interference increase
Solution Approach 1:
The system segments tasks into different criticality levels and allocates them to appropriate processing cores and resource partitions. This segmentation reduces contention by ensuring that high-criticality tasks on safety cores have dedicated access to critical shared resources, while low-criticality tasks on non-safety cores operate with separate resource pools, thereby isolating potential interference sources
Solution Approach 2:
The system introduces an intermediary scheduling layer that manages resource allocation and access between multiple processing cores. This intermediary enforces partitioning policies and controls access to shared resources, preventing direct contention between tasks on different cores by mediating resource requests according to criticality-based allocation rules
3Reliability
If strict static partitioning is applied to all cores, then determinism is improved, but resource utilization and system efficiency deteriorate
Solution Approach 1:
Strict static partitioning and deterministic scheduling are applied only to processing cores executing high-criticality safety tasks, while different, more flexible scheduling policies are applied to cores executing low-criticality non-safety tasks. This localized application of determinism ensures that deterministic guarantees are provided only where required by safety requirements, while other cores can achieve higher resource utilization through dynamic scheduling
Solution Approach 2:
The system employs dynamic scheduling for low-criticality tasks that allows flexible resource allocation and core migration, enabling these tasks to utilize available processing capacity efficiently without being constrained by rigid static partitions. Meanwhile, high-criticality tasks maintain deterministic execution on dedicated cores, creating a hybrid approach that optimizes both determinism and resource utilization according to task requirements
Data Source
AI summary
A method for managing software application tasks being performed in a multi-core processing system, the system comprising: a management core configured to manage the allocation of processing tasks in the system; a plurality of processing cores configured to execute instructions for performing processing tasks; at least one shared resource, wherein the at least one shared resource is connected to each of the processing cores; a contention assessment module configured to monitor the amount of contention in the system; and a processing suspension module configured to cause the suspension of processing on at least one of the processing cores; wherein the method comprises: determining a criticality level of each task to be performed; allocating each task to a respective processing core of the plurality of processing cores based on the determined criticality level; assigning a contention threshold to at least one processing core of the plurality of processing cores; monitoring the amount of contention caused by the at least one processing core that has been assigned a contention threshold; and if the amount of contention caused by the at least one processing core that has been assigned a contention threshold reaches the assigned contention threshold, suspending processing on that processing core.