If you ask designers of embedded systems or systems-on-chip what would be the tool of their dreams, they would certainly describe a tool that could take whatever abstract system-level model (mathematical model, algorithm, state chart, class diagram, schematics, etc.) and would convert it directly into implementation-ready hardware and software descriptions.
Although such a dream may not come true any time soon, it is significant of the main problem these designers face today: the gap from specification to implementation. How to get from an ideal view of the system, the models listed above, very often non-executable and thus non-verifiable, to descriptions of hardware and software implementations with all their real-world constraints (programming abstraction, runtime environments, timing, performance, cost, power, area, physics, etc.)?
Anyway, designers have to move forward in their project and have to take decisions for implementing their system. It's an admitted fact that 80% of design decisions are taken in a project's first 20%, when making the right choices will make the difference between success and failure. How to take decisions so early in a project on the base of so few data? Designers have basically two choices: guess or model.
This is the main challenge System-Level Design (SLD) tools have to address: bridging the gap from specification to implementation and reducing the guessing as much as possible.
Research work has shown that an efficient path to bridge the gap from specification to implementation has to follow 2 distinct steps:
First, obtaining timed-executable specifications (in the form of a platform-independent model) of the system for defining and verifying its behavior and time properties;
Next, finding the optimal architecture (in the form of a platform-specific model) that delivers the right functionality on the right platform for the best cost/performance ratio.
However, very few methodologies and tools support the above paradigm in a satisfactory way for mixed hardware/software and real-time systems.
Embedded software tools and EDA tools are complementary tools in many respects, because both sets of tools are required to design, verify and test any electronic system that has software content. Unfortunately, SLD has failed so far at providing a unified flow for hardware/software system-level design that would support the required transition from the specifications to the traditional embedded software and EDA flows.
Indeed, tool vendors have tended to stay within their respective markets, and SLD finds itself "instantiated" differently and separately in the hardware and software domains. In the semiconductors field, Electronic System-Level (ESL) design tools address system-on-chip platforms only. On the embedded software side, Model-Driven Architecture/Design (MDA/MDD) tools only start addressing mixed hardware/software systems and are still very immature.
MDA/MDD tools come from the specifications domain and usually reach the embedded software application development field. They have limited hardware modeling capabilities and usually do not support time properties in models. Thus, such tools can only partially help in the early decision process. Furthermore, analyzing performance requires using real hardware targets, when implementation is almost complete, way past the project's first 20% when choices are made.
ESL tools come from the EDA space and are moving up the abstraction layers, from RTL to Transaction Level Modeling (TLM). Simulating hardware/software SoCs with ESL tools implies the availability of hardware models (for buses, processors, logic IPs, etc.) and the almost completed application software and firmware. It takes time and money to obtain such models and code, at usually 50% or more of the project's duration. At this stage, such tools can only deliver a confirmation of whether the already taken design decisions were the right ones or not, but they don't really help take those decisions when needed, earlier on the project.
In summary, to address the previously identified challenge faced by system designers, the ideal SLD tool should help designers take decisions in their project's first 20% and help them easily transition from specification to implementation, by allowing them to:
- Capture and execute a behavioral Platform-Independent Model (PIM) of their system including time information
- Capture and execute an architectural Platform-Specific Model (PSM) of their hardware/software system including cost/performance information
- Search for and find the optimal system architecture (architecture exploration)
- Translate the resulting PSM of their system into implementation-ready hardware and software descriptions
|
The following table shows how existing MDA/MDD and ESL tools compare against the above requirements:
CoFluent Design provides CoFluent Studio, a system modeling and simulation toolset that results from 30 years of research focusing on the challenge described in this paper. CoFluent Studio is available in different packages aimed at the different stages helping bridge the gap from specification to implementation:
CoFluent Studio's high abstraction level allows designers to create models of their system in their project's first 20% and thus, let them take the right decisions when it matters, before it's too late.
