Dynamic RAM Sharing in Software-Defined TDD Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional software-defined TDD communication systems are expensive due to the high cost of RAM, as they require a large amount of costly RAM for dynamic state machine operations, and dynamic RAM sharing techniques are not effectively utilized due to the time overhead of copying program code from flash memory to RAM.
Innovation Solution
Implement dynamic RAM sharing by categorizing program code into groups based on execution timing and RAM availability, allowing only necessary code to be copied from flash memory to RAM during specific states of the TX and RX state machines, and overwriting unused code to free up RAM space.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If all program code is copied from flash memory to RAM before execution, then execution speed is improved, but RAM cost increases significantly
Solution Approach 1:
The program code is divided into multiple segments or categories (e.g., frequently executed code, occasionally executed code, rarely executed code). Only the necessary segments are copied to RAM at any given time, rather than loading the entire program. This segmentation allows the system to maintain high execution speed for critical functions while minimizing RAM usage by loading code segments on-demand or in advance only when needed.
Solution Approach 2:
The system performs preliminary actions by copying code segments to RAM in advance of when they are needed, based on prediction or scheduling. For example, code segments that are likely to be executed soon are pre-loaded into RAM during idle periods or low-utilization states. This preliminary action ensures that when the code is actually executed, it is already in RAM for fast access, maintaining execution speed without requiring all code to be permanently resident in RAM.
2Quantity of substance
If dynamic RAM sharing is implemented, then RAM cost is reduced, but time overhead for copying code increases
Solution Approach 1:
The system implements periodic action by copying code segments to RAM in advance during idle periods or low-utilization states, rather than copying them at the moment they are needed. The program is analyzed to identify code segments that can be pre-loaded, and these are copied during periodic intervals when the processor is not actively executing critical functions. This periodic pre-loading reduces the time overhead during actual execution while still enabling dynamic RAM sharing.
Solution Approach 2:
The system skips the time-consuming code copying operation by performing it in advance during idle periods. Rather than rushing to copy code when it is needed (which would cause time overhead), the system rushes through the copying process during non-critical periods when time is less constrained. This allows the actual execution phase to proceed without delays, as the code is already in RAM.
3Adaptability or versatility
If a DSP with high computational capability is selected, then headroom for computational power is increased, but system cost increases
Solution Approach 1:
The system implements dynamics by making the computational requirements adaptable rather than static. Instead of selecting a DSP with fixed high computational capability, the system dynamically adjusts the computational load by loading different code segments with different computational requirements into RAM as needed. This allows the system to use a lower-cost DSP for less demanding tasks while maintaining the capability to handle more computationally intensive tasks when necessary, by loading the appropriate code segments on-demand.
Data Source
Figure 1~5
Figure 2
Figure 4
AI summary
In described examples, dynamic sharing of RAM (75) in a software-defined communication system includes storing program code in a flash memory (71), categorizing parts of the code into groups of transmit categories according to when a part of the code needs to be copied into a section of a RAM (75) and then executed during a first state of a TX state machine and according to how another part of the code can be later fit into the same section and then executed during a second state. Similarly, parts of the code are categorized into groups of receive categories according to when a part of the code needs to be copied into a section of RAM (75) and then executed during a first state of a RX state machine and according to how another part of the code can be later fit into that section and then executed during a second state of the RX state machine, to reduce the amount of RAM (75) without sacrificing speed performance.