Message Pattern Extraction for Idle Process Matching
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In message passing environments, efficiently matching incoming messages with waiting processes is computationally expensive when large numbers of processes are involved, as existing systems often require awakening each idle process for comparison, leading to performance issues.
Innovation Solution
Extracting and storing patterns of data expected by waiting processes during compilation or runtime, allowing for pattern matching without bringing processes into an executable state, and using a data structure to identify matching processes, which can then be moved to a runnable queue for execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If each idle process is awakened for message comparison, then message matching can be performed, but computational overhead increases significantly
Solution Approach 1:
The patent extracts and stores message pattern information from executable code during compilation or runtime before actual message matching occurs. This preliminary extraction creates a static representation of what messages processes are waiting for, eliminating the need to awaken processes during runtime for pattern analysis, thus reducing computational overhead while maintaining matching accuracy
Solution Approach 2:
The patent extracts pattern information (such as expected message types, data formats, and matching criteria) from the executable code and stores it separately in a data structure. This extraction separates the static pattern information from the dynamic process execution, allowing the system to compare messages against stored patterns without involving the actual processes, thereby reducing computational overhead
2Use of energy by moving object
If processes remain in idle state without being awakened, then computational overhead is reduced, but message matching efficiency decreases
Solution Approach 1:
The patent creates a copy of the message matching functionality by storing pattern information in a data structure that can be queried independently of the actual processes. Instead of awakening processes to perform matching, the system uses this stored pattern copy to filter and identify matching messages, maintaining efficiency while keeping processes in idle state
Solution Approach 2:
The patent introduces an intermediary data structure that stores extracted pattern information and mediates between incoming messages and idle processes. This intermediary handles the matching operation by comparing messages against stored patterns, eliminating the need to involve actual processes in the matching decision while maintaining accurate matching efficiency
3Loss of time
If pattern extraction is performed during compilation, then runtime overhead is reduced, but compilation complexity increases
Solution Approach 1:
The patent performs pattern extraction during compilation or runtime initialization, analyzing executable code to identify and store message patterns before actual message processing begins. This preliminary action shifts the computational burden from runtime to compilation time, reducing runtime overhead while the increased compilation complexity is acceptable as it occurs only once
Solution Approach 2:
The patent segments the pattern extraction process into distinct phases: analyzing executable code to identify message waiting points, extracting pattern information (message types, data formats), and storing this information in a structured data format. This segmentation makes the compilation process more manageable and systematic, reducing the perceived complexity while enabling efficient runtime performance
Data Source
AI summary
Processes in a message passing system may be launched when messages having data patterns match a function on a receiving process. The function may be identified by an execution pointer within the process. When the match occurs, the process may be added to a runnable queue, and in some embodiments, may be raised to the top of a runnable queue. When a match does not occur, the process may remain in a blocked or non-executing state. In some embodiments, a blocked process may be placed in an idle queue and may not be executed until a process scheduler determines that a message has been received that fulfills a function waiting for input. When the message fulfills the function, the process may be moved to a runnable queue.