Dynamic Code Linking for Programmable Control Devices
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for programming microcontroller/microprocessor boards are inefficient, requiring repetitive linking processes that result in wasteful memory usage and runtime delays, especially when using high-level programming languages.
Innovation Solution
The method involves performing the linking operation during the upload of binary code rather than in a previous phase, using a memory allocation system that tracks code lengths and module boundaries, allowing for dynamic code combination during runtime and optimizing memory and runtime efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of time
If the linking operation is performed before code upload as in conventional systems, then the code can be prepared in advance, but the entire code must be re-transferred even when only minor modifications are made, increasing lead time and reducing productivity
Solution Approach 1:
The patent segments the code transfer process into two distinct phases: (1) uploading the complete unlinked code to non-volatile memory, and (2) performing the linking operation after upload. This segmentation allows the memory to retain the complete code structure while enabling selective linking of only modified modules during updates, thereby reducing transfer time and improving productivity.
Solution Approach 2:
The patent performs the code upload action before the linking operation, reversing the conventional sequence. By uploading the complete code structure first and linking afterward, the system establishes a baseline that can be efficiently updated by transferring only differential changes and performing selective relinking, thus reducing subsequent update times.
2Device complexity
If static linking is used to link all modules together, then the code structure is fixed and simple, but unused drivers and modules occupy memory space, increasing memory occupation
Solution Approach 1:
The patent implements dynamic linking where the code structure can be reconfigured based on runtime requirements. Modules and drivers are linked only when needed rather than being statically connected, allowing the system to adapt its memory usage dynamically. This enables unused drivers to remain unlinked and occupy minimal memory while maintaining the ability to link them when required.
3Quantity of substance
If dynamic linking with symbol resolution mechanism is implemented, then only necessary modules are linked reducing memory waste, but runtime symbol resolution causes delays, increasing runtime time
Solution Approach 1:
The patent performs symbol resolution and linking operations before code execution rather than during runtime. By completing the linking process in advance during the upload phase or system initialization, the runtime execution can directly reference pre-resolved symbols without incurring lookup delays, thus eliminating runtime performance penalties.
4Reliability
If the entire machine code is re-transferred whenever any part of the program is modified, then the code integrity is maintained, but the transfer time increases significantly, reducing productivity
Solution Approach 1:
The patent extracts and separates the linking operation from the code upload process. By taking out the linking step and performing it independently after upload, the system can maintain complete code integrity in memory while allowing incremental updates of only modified portions without requiring complete re-transfers, thus improving update efficiency while preserving reliability.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Method for defining a code to be executed by programmable control devices comprising: - providing a programming language; - providing a code written in that programming language; - compiling such code in machine language; - transferring said machine language code on a program memory for its execution by the control device, wherein said machine language code is divided into core code and application code, said application code being loaded into the program memory regardless of the core code, without performing a linking operation of the two codes before said transfer. A corresponding system is also disclosed.