Thread Pool Component Execution for Robot Software Reliability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In robot software systems, a failure in one component can lead to system-wide failures due to inefficient thread allocation and frequent context switching, causing performance deterioration and obstruction of other component executions, even with added monitoring systems that require additional communication.
Innovation Solution
An apparatus and method utilizing a thread pool to execute components with set priorities and periods, where components are registered and executed based on allocated threads, with failure detection through internal memory information, allowing for seamless failure handling without additional communication, such as with a monitor.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a thread is allocated to each component, then component execution reliability is improved, but system resource waste increases and context switching frequency increases
Solution Approach 1:
The patent segments components into groups that share common execution periods and priorities, allowing multiple components to be executed together using a single thread. This segmentation by execution characteristics eliminates the need for dedicated threads for each component, reducing resource waste while maintaining reliable execution through structured group management.
Solution Approach 2:
A single thread is designed to serve multiple components within its execution period, making the thread a universal resource that can execute any component from its assigned group. This multi-functionality approach allows one thread to perform the work of multiple dedicated threads would have been needed, reducing overall system resource consumption.
2Reliability
If a thread is allocated to each component, then component execution reliability is improved, but context switching frequency increases deteriorating system performance
Solution Approach 1:
Components are segmented into execution groups based on their periods and priorities, allowing a single thread to execute multiple components from the same group without context switching between different period/priority groups. This segmentation strategy reduces context switching frequency while maintaining reliable execution through structured group management.
Solution Approach 2:
The patent implements periodic execution where threads execute components at predetermined periods. By organizing components into groups with matching periods, the system can execute multiple components within the same period using a single thread, minimizing context switching between periodic executions and improving overall system performance.
3Productivity
If components are processed using a single thread, then system performance is maintained, but failure in one component obstructs execution of other components
Solution Approach 1:
The patent segments components into independent execution groups based on their periods and priorities. Each group is executed by a dedicated thread, so a failure in one group does not affect other groups. This segmentation provides both performance efficiency (single thread per group) and reliability isolation (independent group execution).
Solution Approach 2:
The system prepares for potential component failures by executing components in isolated groups with independent threads. This beforehand cushioning ensures that if one component fails, the failure is contained within its group and does not propagate to other components, maintaining system-wide reliability while preserving performance benefits.
4Reliability
If a monitor is added to detect component abnormalities, then system reliability is improved, but additional communication overhead increases deteriorating system performance
Solution Approach 1:
Each thread monitors its own execution status and the status of components within its group, eliminating the need for a separate monitor system. The thread self-services by detecting abnormalities and managing its own group's execution, thereby achieving reliable monitoring without the communication overhead associated with external monitor systems.
Solution Approach 2:
The monitoring function is extracted from a separate monitor system and integrated directly into the thread execution mechanism. By taking out the monitoring capability and embedding it within the thread itself, the system achieves reliable component monitoring without the additional communication overhead that would result from a separate monitor architecture.
Data Source
AI summary
An apparatus for executing components based on a thread pool includes a component executor configured to have a set priority and period, to register components having the set priority and period, and to execute the registered components. Further, the apparatus for executing the components based on the thread pool includes a thread pool configured to allocate a thread for executing the component executor; and an Operating System (OS) configured to create an event for allocating the thread to the component executor in each set period.