Interface Description Language Compiler for Multi-Core Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In multi-core systems, inefficient communication occurs between software component instances due to the use of a single communication mechanism regardless of core mapping, leading to slow and resource-intensive interactions.
Innovation Solution
An interface description language compiler system that customizes communication by generating stubs based on unit-core mapping, allowing direct or remote invocations depending on instance core locations and method properties, and optimizes channel monitoring using historical usage data.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a single communication mechanism is used for all unit instances regardless of core mapping, then the communication mechanism is simple and universal, but the communication speed and efficiency deteriorate
Solution Approach 1:
The patent applies dynamics by making the communication mechanism adaptive rather than static. The stub dynamically selects between direct and remote invocation based on runtime core mapping information. When source and target instances are mapped to the same core, direct invocation is used; when mapped to different cores, remote invocation is used. This dynamic adaptation resolves the contradiction by allowing the system to switch communication mechanisms based on actual core mapping, thereby improving communication speed without permanently increasing system complexity.
Solution Approach 2:
The patent changes the parameter of communication mechanism selection based on core mapping parameters. By incorporating core mapping information into the stub generation process, the system adjusts the communication approach (direct vs. remote) according to the spatial parameter of core assignment. This parameter-based adaptation allows the system to optimize communication speed for different core mapping scenarios while maintaining a unified stub interface.
2Ease of manufacture
If a single communication mechanism is used for all unit instances, then implementation is simple and universal, but resource consumption increases due to inefficient communication
Solution Approach 1:
The patent applies preliminary action by pre-generating stubs with embedded core mapping information during the compilation phase. The IDL compiler incorporates unit-core mapping data into the stub code before runtime, so that the optimal communication path is predetermined based on known core assignments. This preliminary preparation allows the runtime system to execute efficient communication without complex runtime decisions, thereby reducing resource consumption while maintaining implementation simplicity through automated stub generation.
Solution Approach 2:
The patent uses copying by generating customized stub copies for different unit instances based on their specific core mapping. Each stub is a copy of the base communication interface but tailored with specific core mapping information for that instance. This copying approach allows the system to maintain a simple universal interface definition while creating optimized instances for each unit, reducing resource consumption through instance-specific optimization without complicating the overall implementation.
3Productivity
If communication mechanisms are customized based on core mapping, then communication efficiency improves, but device complexity increases
Solution Approach 1:
The patent introduces an intermediary - the IDL compiler - that handles the complexity of core mapping and communication mechanism selection. The compiler acts as a mediator between the high-level unit definitions and the low-level communication implementation. It automatically generates optimized stubs based on unit-core mapping information, shielding the application developer from complexity while achieving efficient communication. This intermediary approach resolves the contradiction by concentrating complexity in the compilation phase rather than the runtime system.
Solution Approach 2:
The patent applies segmentation by separating the communication mechanism selection logic into the stub generation phase handled by the IDL compiler. The overall system is segmented into: (1) unit definition, (2) core mapping specification, (3) stub generation with optimized communication logic, and (4) runtime execution. This segmentation allows communication efficiency to be optimized in the stub generation phase without increasing runtime system complexity, as the optimization logic is embedded in the generated code rather than the runtime framework.
4Speed
If direct invocation is used for same-core instances, then communication speed improves, but a single universal communication mechanism is lost
Solution Approach 1:
The patent achieves universality through the stub, which serves multiple functions depending on the core mapping. The same stub interface can perform both direct invocation (when source and target are on the same core) and remote invocation (when on different cores). This multi-functionality is embedded in the stub generation process, which incorporates core mapping information to determine the appropriate invocation type. The result is a universal stub interface that adapts its behavior based on runtime conditions, maintaining versatility while enabling fast direct invocation when applicable.
Data Source
AI summary
An interface description language (IDL) compiler generates a descriptor for invoking a method implemented by a software component or a target unit by source units, where the descriptor customizes the invocation by one or more source units based on, at least in part, whether a respective source unit and the target unit are mapped to the same core or to different cores, as specified by a unit-core map. Additionally or in the alternative, the invocation may depend on whether the method is synchronous, asynchronous, or unspecified. Using the unit-core map, a channel associated with a method may be monitored efficiently by avoiding monitoring of the source units that are mapped to the same core as the target unit is.