The designer refines the system through several abstraction levels. At the system level the designer describes the desired functionality in an executable language like C. This is called system specification.

The designer refines this specification by distributing portions of it among several general and/or single purpose processors, yielding behavioural specifications for each processor.

The designer refines these specifications into register-transfer (RT) specifications by converting behaviour on general-purpose processors to assembly code, and by converting behaviour on single purpose processors to a connection of register-transfer components and state machines. The designer then refines the RT level specification into a logic specification.

Finally, the designer refines the remaining specifications into an implementation consisting of machine code for general purpose processors and a design gate level net list for single purpose processors.

There are three main approaches to improving the design process for increased productivity, which we label as compilation/synthesis, libraries/IP, and test/verification. Several other approaches also exist.

1.Compilation/Synthesis lets a designer specify desired functionality in an abstract manner, and automatically generates lower-level implementation details. Describing a system at high abstraction levels can improve productivity by reducing the amount of details, often by an order of magnitude, that a design must specify.

A logic synthesis tool converts Boolean expressions into a connection of logic gates (called a

netlist). A register-transfer (RT) synthesis tool converts finite-state machines and register- transfers into a datapath of RT components and a controller of Boolean equations. A behavioral synthesis tool converts a sequential program into finite-state machines and register transfers. Likewise, a software compiler converts a sequential program to assembly code, which is essentially register-transfer code. Finally, a system synthesis tool converts an abstract system specification into a set of sequential programs

on general and single-purpose processors.

The relatively recent maturation of RT and behavioral synthesis tools has enabled a unified view

of the design process for single-purpose and general-purpose processors. Design for the former is commonly known as "hardware design," and design for the latter as "software design." In the past, the design processes were radically different - software designers wrote sequential programs, while hardware designers connected components.

2.Libraries involve re-use of pre-existing implementations. Using libraries of existing implementations can improve productivity if the time it takes to find, acquire, integrate and test a library item is less than that of designing the item oneself. A logic-level library may consist of layouts for gates and cells. An RT-level library may consist of layouts for RT components, like registers, multiplexors, decoders, and functional units. A behavioral-level library may consist of commonly used components, such as compression components, bus interfaces, display controllers, and even general purpose processors. The advent of system-level integration has caused a great change in this level of library.

3.Test/Verification involves ensuring that functionality is correct. Such assurance can prevent time- consuming debugging at low abstraction levels and iterating back to high abstraction levels. Simulation is the most common method of testing for correct functionality, although more formal verification techniques are growing in popularity. At the logic level, gate level simulators provide output signal timing waveforms given input signal waveforms.

Likewise, general-purpose processor simulators execute machine code. At the RT-level,

hardware description language (HDL) simulators execute RT-level descriptions and provide output waveforms given input waveforms. At the behavioral level, HDL simulators simulate sequential programs, and co-simulators connect HDL and general purpose processor simulators to enable hardware/software co-verification. At the system level, a model simulator simulates the initial system specification using an abstract computation model, independent of any processor technology, to verify correctness and

completeness of the specification.

4.More productivity improvers

There are numerous additional approaches to improving designer productivity. Standards focus on developing well-defined methods for specification, synthesis and libraries. Such standards can reduce the problems that arise when a designer uses multiple tools, or retrieves or provides design information from or to other designers. Common standards include language standards, synthesis standards and library standards.

Languages focus on capturing desired functionality with minimum designer effort. For example, the sequential programming language of C is giving way to the object oriented language of C++, which in turn has given some ground to Java. As another example, state-machine languages permit direct capture of functionality as a set of states and transitions, which can then be translated to other languages like C.

Frameworks provide a software environment for the application of numerous tools throughout the design process and management of versions of implementations. For example, a framework might generate the UNIX directories needed for various simulators and synthesis tools, supporting application of those tools through menu selections in a single graphical user interface.

Resources

Top Categories

Product

Company