In-situ Peripheral Software Development via Memory-Mapped Hardware Models
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current SoC software development relies on hardware emulation or co-simulation, which is slow and inefficient, especially for booting up complex code, due to the lack of direct access to target hardware during development, leading to time-consuming debugging and inefficient code execution.
Innovation Solution
The method involves using a preexisting integrated system with a similar base operating environment to load and execute peripheral development code, mapping a model of new peripheral hardware into a register space within memory, allowing interaction and execution at near-full system speeds, utilizing a CPU and memory with a central processing unit and memory-mapped I/O space.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of time
If hardware emulation or co-simulation is used for SoC software development, then software can be developed in parallel with hardware, but development speed becomes excessively slow
Solution Approach 1:
The system is divided into two distinct environments: a fast simulation environment for initial software development and a real hardware environment for final validation. This segmentation allows developers to work in parallel by developing software on simulated/peripheral devices while hardware is being manufactured, eliminating the sequential dependency that causes time loss.
Solution Approach 2:
A peripheral device or simulated device acts as an intermediary between the software development process and the actual target hardware. This intermediary provides a functional equivalent that allows software to be developed and tested without direct access to the target hardware, maintaining development productivity while reducing time loss.
2Reliability
If complex code such as operating system code is executed on emulator/co-simulation, then software can be tested before hardware is ready, but the execution time becomes excessively long
Solution Approach 1:
Different execution environments are used for different code segments and development stages. Simple peripheral code is executed on fast simulated devices for initial testing, while complex operating system code is eventually executed on real hardware. This local quality approach allows reliable software testing without the excessive execution times associated with full emulation of complex code.
Solution Approach 2:
Peripheral device drivers and initialization code are developed and tested in advance on simulated peripheral devices before the target hardware is available. This preliminary action allows the software development team to prepare code segments independently, enabling reliable testing without waiting for hardware readiness, while avoiding the time penalty of executing complex code on slow emulators.
3Ease of operation
If development code is broken into small segments for emulation execution, then code can run on limited hardware resources, but the segmentation process becomes very time-consuming
Solution Approach 1:
The simulated peripheral device automatically manages the execution of development code without requiring manual segmentation by developers. The simulation environment handles code loading and execution independently, eliminating the time-consuming manual segmentation process while maintaining the ability to execute code on limited hardware resources through automated resource management.
4Adaptability or versatility
If debugging is performed via simulation software, then software can be tested without target hardware, but execution cannot occur at full system operating speeds
Solution Approach 1:
The system dynamically transitions between simulation and real hardware execution based on development needs. During initial debugging, the simulated environment provides adaptability for testing without target hardware. As development progresses, the system transitions to real hardware execution to achieve full system operating speeds, combining the adaptability of simulation with the speed of actual hardware.
Data Source
AI summary
A development system for developing new peripheral software code for new peripheral hardware that will be used in a new integrated system. The development system includes a legacy, or preexisting, integrated system substantially the same as the new integrated system. A model of the new peripheral hardware is made. Each I/O register of the model is mapped into memory-mapped I/O space. Development code corresponding to the new peripheral software code is executed on the preexisting hardware so as to interact with the model via the memory-mapped I/O space. In one embodiment, the model is executed as an embedded model on the preexisting integrated system. In another embodiment, the model is executed as a non-embedded model on a hardware descriptive language simulator.