As system designers work to bring quality products to market on time, increasing complexity and shrinking market windows create significant obstacles. The rising intricacy in interactions between hardware and software, for example, has made it much more difficult to test and verify larger, more complex ASICs and system-on-a-chip (SoC) designs.
Designers faced with creating these products need tools that will allow them to develop and verify hardware and software simultaneously. A hardware/software (HW/SW) codesign methodology that encompasses the concurrent specification, partitioning, implementation, and verification of digital systems into cores and embedded logic, is one viable solution.
The first step in HW/SW codesign is at the system level, where the specification begins with the capture, analysis, optimization, and verification of the product's functionality. At this level, the designer also creates a preliminary architecture of the implementation that delineates how the candidate instruction-set processors, logic, and memory are tied together. Then comes partitioning, which refers to the mapping of functions into instruction-set processors (microcontrollers, microprocessors, digital signal processors) and logic blocks.
The implementation of the partitioned system requires taking the core(s) and logic blocks down to silicon, creating the memory map and object code for the software, and establishing the hardware and software interfaces. Verification refers to the concurrent design and verification of hardware and software blocks as they are refined from the system-level specification into an implementation.
At the system level, the functionality of the product is captured independently of its implementation. The focus here is on creating an executable system-level specification, typically using C or C++, in a block-based, domain-specific design tool. In this phase, designers create stable, well-conditioned systems, and optimize their performance to meet minimum performance standards (e.g., DVB, DVD, or GSM) or perceptive quality (speech and video).
Once the implementation-independent functionality has been captured, designers partition systems into hardware and software and define the HW/SW boundary. At this point, the analog and digital worlds, and their interfaces, are also defined. Often, portions of an old design, such as an algorithm for a motion estimator, a numerical oscillator, or models of interfaces to the analog or digital worlds, are reused.
While design tools help in specification, implementation, and verification, no tool today automatically partitions these systems into hardware and software. Tools do exist, however, that can bring critical information about the complexity of the system-level building blocks back to the HW/SW designers so they can explore possible candidate partitions without having to wait for a hardware platform. This reduces product cycle time and the risk of a HW/SW respin due to poor partitioning. After partitioning, several system-level optimization techniques are employed, such as minimizing word length, using low-complexity number representation systems for hardwired digital functions, or using fixed-point tools to optimize code targeted to instruction-set processors.
The partitioning task is one of the riskiest areas of product design. In fact, this is where market winners and losers are created. One viable option to aid the HW/SW coverification process is Synopsys' COSSAP tool, which contains Processor Developer Kits (PDKs) covering over 50 processors from seven vendors, including Texas Instruments, Lucent, Motorola and the ARM7 controller family from Advanced RISC Machines (ARM). These products are used for trial HW/SW mappings, profiling, and verifying software running on the vendor's own simulator. They also are used for cosimulating with the hardware in COSSAP C models.
NEC Technologies used COSSAP in this way to design the G8 and G9 GSM phones based on the Lucent Sceptre chipset. The design went from scratch to finished product in about 12 months.
Divide And Conquer Typically, designers use behavioral, RTL, and datapath synthesis for hardware implementation, and hand-coded assembly and compilers for software implementation. Within the system-level environment, designers find feedback about hardware costs (area, speed, power) and software costs (memory, latency, MOPS) using code-generation, synthesis, and cosimulation capabilities. It is critical that the tools that estimate system complexity are closely tied to the implementation tools so that the estimates are accurate and can be realized. While relative complexity measures are important in terms of "time-to-decision," an unrealizable decision could be fatal to the design.
At the system level, the designer can build a virtual prototype consisting of logic and core blocks. Interfaces between the blocks can be abstracted to achieve fast system-level coverification of the functionality, complete with a model of the real-world environment—like base-stations, cable-TV head-ends, and disk-drive channels. Processor cores are incorporated into this model using instruction-set processor models, and interfaced to the rest of the system using memory-mapped I/O interfaces. That simplifies the problem of debugging the assembler implementation of a function mapped to software.
Logic blocks are incorporated using behavioral, RTL, or gate-level models, and interfaced to the rest of the system using cosimulation interfaces. The speed of these interfaces depends closely on the simulation paradigm used in the system-level tools, ranging from dataflow to clock-cycle-based.
As the designer moves down in abstraction from the system-level, the interface models between the cores and logic become better defined. The virtual prototype now actually consists of the cores with a "pins-out" view, and embedded logic together with the buses and memory activity captured. This marks the beginning of the codevelopment and coverification stages of the design, where functions and processes have been mapped into a defined architecture.
Reprints
