Concurrent Function-Call Generator Block for Graphical Model Parallelism
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional graphical models with single-threaded execution fail to utilize multi-processing capabilities, resulting in prolonged execution times for complex models with multiple function-call subsystems due to serial execution constraints.
Innovation Solution
The introduction of a concurrent function-call generator block (C-FCGB) allows for the parallel execution of function-call subsystems without data dependencies, utilizing multiple threads to execute specified subsystems concurrently on designated processing devices.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If serial execution on a single thread is used to maintain simplicity and determinism, then ease of operation is improved, but productivity deteriorates due to prolonged execution times
Solution Approach 1:
The patent segments the execution of function-call subsystems by creating separate threads for each subsystem. Instead of executing all subsystems sequentially on a single thread, the system divides them into independent executable units that can run concurrently on different threads, thereby improving productivity while maintaining operational simplicity through automated thread management.
Solution Approach 2:
The patent transitions from single-threaded serial execution to multi-threaded parallel execution by adding the dimension of concurrent processing. This dimensional change allows multiple function-call subsystems to execute simultaneously rather than sequentially, significantly improving execution speed and productivity without complicating the user interface or ease of operation.
2Productivity
If multi-threaded parallel execution is implemented to improve productivity, then productivity is improved, but device complexity increases due to thread management requirements
Solution Approach 1:
The patent implements self-service by enabling function-call subsystems to automatically manage their own thread execution without requiring external coordination or complex synchronization mechanisms. Each subsystem can independently initialize and execute on its designated thread, reducing the overall system complexity while maintaining high productivity through parallel execution.
3Loss of time
If concurrent execution of function-call subsystems is enabled to reduce execution time, then loss of time is reduced, but reliability may deteriorate due to potential race conditions and synchronization issues
Solution Approach 1:
The patent applies preliminary action by establishing thread-safe execution environments and defining clear execution protocols before concurrent execution begins. Function-call subsystems are prepared with appropriate synchronization mechanisms and execution contexts in advance, ensuring that race conditions and synchronization issues are prevented before they can occur during parallel execution, thus maintaining reliability while reducing execution time.
Data Source
AI summary
A method, tangible computer-readable medium and apparatus for concurrently executing subsystems in a graphical model is provided. An embodiment can transform a conventional graphical model supporting single threaded execution into a model supporting multi-threaded execution through the replacement of a single block. The transformed model may support concurrent execution of a plurality of subsystems using a plurality of threads when the graphical model executes. An embodiment provides a user interface that allows a user to intuitively configure a model for current execution of the subsystems.