Virtual Processor Memory Isolation for Simulation Models
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing simulation methods for integrated circuits face challenges such as data corruption and complex instantiation processes due to the combination of simulation models and simulator code, particularly when using C or C++ programming languages, which can lead to memory conflicts and require complex library support.
Innovation Solution
The approach involves executing simulation models on virtual processors with unique memory spaces, allowing them to interface with the simulator without being combined with the simulator code, thereby avoiding memory conflicts and enabling easy multi-instantiation of models across different programming languages.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If simulation models are combined with simulator code, then the simulation can be executed, but data corruption and memory conflicts occur
Solution Approach 1:
The system separates simulation models from simulator code by introducing virtual processors as intermediate execution environments. Each simulation model runs in its own virtual processor instance with isolated memory space, preventing memory conflicts and data corruption while maintaining execution capability. This segmentation resolves the contradiction by allowing both simulation execution and data integrity.
Solution Approach 2:
Virtual processors act as intermediaries between simulation models and the simulator environment. The virtual processor provides a controlled interface that allows simulation models to execute without directly accessing or corrupting simulator memory spaces. This intermediary layer enables reliable simulation execution while protecting against harmful memory conflicts.
2Adaptability or versatility
If simulation models are written in C or C++, then modeling flexibility is improved, but complex instantiation processes and library support requirements increase
Solution Approach 1:
The virtual processor architecture provides a universal execution environment that can run simulation models written in various programming languages including C and C++. The virtual processor abstracts away language-specific instantiation complexities, providing a standardized interface for model execution. This allows modeling flexibility while reducing instantiation complexity through language-agnostic virtualization.
Solution Approach 2:
The system creates virtual copies of processor environments that can execute different programming language models without requiring complex instantiation procedures for each language. The virtual processor instance acts as a portable execution context that simplifies the deployment of C/C++ models and other languages uniformly.
3Productivity
If multiple simulation models run in shared memory space, then resource utilization is improved, but memory conflicts and data corruption increase
Solution Approach 1:
The system segments the shared memory space into isolated virtual memory spaces, each associated with a specific virtual processor instance. This segmentation allows multiple simulation models to run concurrently with improved resource utilization while preventing memory conflicts through virtual memory isolation. Each virtual processor manages its own memory space, ensuring data integrity while maintaining efficient resource sharing at the physical level.
Data Source
AI summary
Simulating a system involves running a simulation model on a virtual processor that interfaces to a simulator, the virtual processor being associated with a unique memory space in the memory space used by the simulator. The virtual processor technique gives the developer a simple technique for ensuring the model and simulator interactions are managed effectively, i.e. that no unintentional corruptions of each other's memory space are possible. It also facilitates making multiple instantiations of a C, C++ or other general purpose programming language model. The resulting environment also resolves one of the limitations on the use of third party models within the SystemC environment.