Multicore Task Activation Using First-Ready Core Selection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing multicore processor systems in automotive on-board systems face challenges in optimizing the use of cores to minimize pending times for asynchronously defined tasks while adhering to real-time constraints, particularly due to the static nature of task definitions and the complexity of these systems.
Innovation Solution
A multicore processor system with an initiating task and multiple sets of implementation tasks, each allocated to different cores, dynamically selects the first-ready core to execute asynchronous processing operations, managing initiation requests through flags, counters, or tables to optimize core usage and reduce pending times.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If tasks are statically defined in advance, then system configuration and reliability are improved, but task creation flexibility and response time are worsened
Solution Approach 1:
The patent applies preliminary action by pre-defining multiple implementation tasks for each asynchronous processing operation before the system runs. These tasks are prepared in advance with their allocations to different cores, allowing immediate execution without dynamic task creation delays while maintaining real-time responsiveness.
Solution Approach 2:
The patent introduces dynamics into the static task definition framework by enabling the scheduler to dynamically select which pre-defined implementation task to execute based on core availability and task readiness states. This allows the system to adapt to runtime conditions while sticking to the static task architecture, resolving the contradiction between reliability and response time.
2Productivity
If multiple implementation tasks are allocated to different cores, then core utilization and productivity are improved, but task management complexity is worsened
Solution Approach 1:
The patent applies segmentation by dividing the implementation of a single asynchronous processing operation into multiple separate implementation tasks, each allocated to different cores. This allows parallel execution across cores, improving productivity. The segmentation is managed through a structured approach where each implementation task is independently tracked but coordinated through the scheduler.
Solution Approach 2:
The patent introduces an intermediary scheduler component that mediates between the initiating task and multiple implementation tasks on different cores. The scheduler manages the complexity by tracking which implementation tasks are ready, which cores are available, and coordinating execution without requiring complex direct management of all task-core mappings.
3Loss of time
If the first-ready implementation task executes the operation, then pending time is reduced, but coordination overhead is worsened
Solution Approach 1:
The patent applies self-service by allowing implementation tasks to autonomously determine their readiness state and compete for execution based on their own conditions. Each implementation task independently tracks its readiness status, and the scheduler simply selects the first-ready task without requiring complex coordination signals between tasks, reducing coordination overhead while minimizing pending time.
Data Source
AI summary
The description relates to a method and a multicore processor computer system configured to activate statically defined tasks comprising at least one initiating task for initiating one or more asynchronous processing operations, and at least one set of identical implementation tasks that implement the one or the same asynchronous processing operations, and that are each allocated to a different core of the multicore processor. The initiating task activates the implementation tasks of a given set when a given asynchronous processing operation has to be initiated, and the implementation task of the given set that is ready first implements the given asynchronous processing operation, while the one or more other implementation tasks of the given set disregard the given asynchronous processing operation.This allows the use of the cores to be optimized, and on execution allows dynamic selection of the core responsible for executing a given asynchronous processing operation, and therefore allows the pending time period to be reduced to a minimum.