Linker Hierarchical Resource Pools for Multiprocessor Symbol Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In multiprocessor systems, existing methods lack efficient mechanisms to manage memory accessibility across multiple processors, leading to manual management of symbol usage and potential name collisions, which complicates the generation of executable code for embedded processors.
Innovation Solution
A linker program that uses scope level information to uniquify symbols and allocate resource instances, allowing for hierarchical declaration and allocation of non-memory resources, ensuring correct loading and execution of code across multiple processors.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If manual header file management is used to control symbol accessibility, then memory resource accessibility can be managed, but device complexity and programming burden increase
Solution Approach 1:
The linker automatically manages symbol visibility and uniqueness across processors by reading scope level annotations from declare instructions. The system self-services the complexity of managing symbol accessibility, eliminating the need for manual header file management while maintaining precise control over which symbols are accessible to which processors.
Solution Approach 2:
The invention introduces scope level as a new parameter in symbol declarations that automatically controls accessibility. By changing the scope level parameter (e.g., processor-specific vs. global), the system automatically adjusts symbol visibility and uniqueness requirements, replacing manual header file management with automated parameter-driven control.
2Reliability
If symbol uniquification is performed for all symbols, then name collisions are prevented, but processing time and linker complexity increase
Solution Approach 1:
The linker applies symbol uniquification selectively based on scope level annotations. Symbols marked with processor-specific scope levels are uniquified only within their designated processor context, while global symbols remain unchanged. This local quality approach ensures name collision prevention only where necessary, reducing unnecessary processing overhead.
Solution Approach 2:
Instead of applying symbol uniquification universally to all symbols (excessive action), the linker performs partial uniquification only on symbols with processor-specific scope levels. This partial action approach maintains reliability for symbols that need it while minimizing processing time for symbols that don't require uniquification.
3Adaptability or versatility
If hierarchical resource pools are implemented, then resource allocation flexibility improves, but linker program complexity increases
Solution Approach 1:
The linker implements hierarchical resource pools using a nested structure where global resource pools contain processor-specific sub-pools, which in turn contain individual symbol allocations. This nesting allows the linker to manage resources at multiple levels of abstraction, providing flexible allocation while organizing complexity in a manageable hierarchical manner.
Solution Approach 2:
The resource pool is segmented into hierarchical levels (global pools, processor-specific sub-pools, and individual symbol allocations). This segmentation breaks down the complex task of resource management into manageable segments at different levels, allowing flexible allocation while keeping the linker program structure organized and maintainable.
Data Source
AI summary
A novel declare instruction can be used in source code to declare a sub-pool of resource instances to be taken from the resource instances of a larger declared pool. Using such declare instructions, a hierarchy of pools and sub-pools can be declared. A novel allocate instruction can then be used in the source code to instruct a novel linker to make resource instance allocations from a desired pool or a desired sub-pool of the hierarchy. After compilation, the declare and allocate instructions appear in the object code. The linker uses the declare and allocate instructions in the object code to set up the hierarchy of pools and to make the indicated allocations of resource instances to symbols. After resource allocation, the linker replaces instances of a symbol in the object code with the address of the allocated resource instance, thereby generating executable code.