To be successful in today's global economy, new products must reach the market faster than ever before, forcing a compression of the design cycle. At the same time, silicon gate costs continue to decline as densities increase. So, heterogeneous devices with multiple processors and FPGAs are becoming more common, resulting in design with greater complexity and longer development cycles.
For years, designers have hoped that approaching product design from a more software-oriented perspective would improve productivity. But any improvement so far has been modest at best, due mostly to increased computer performance. Traditional software development tools haven't improved productivity at anywhere near the pace that design complexity is increasing, let alone enough to shorten the design cycle.
Traditional software development using a text-based sequential programming language may be sufficient for a single small processor, but it's poor at exploiting parallelism. Adding threads for parallelism greatly compromises the semantics of the language and increases complexity. In the end, it's a poor model for highly parallel devices like FPGAs. The Von Neumann model, which is the foundation of sequential programming languages, simply isn't appropriate for parallel, distributed, heterogeneous devices.
What's needed is an order of magnitude improvement in productivity, and the key to that is working at a higher level of abstraction. This level must naturally represent parallelism, in addition to timing and synchronization. It also must be equally appropriate for implementation on processors and FPGAs in systems where they are tightly coupled as well as in a distributed environment.
The only way to achieve this type of productivity increase is through the use of graphical tools. It's obvious how much the graphical user interface has made computers more accessible and users more productive. The same benefits are available to designers using graphical design tools.
Graphical dataflow programming lets engineers and domain experts rapidly develop and iterate designs, reducing the time from idea to prototype. Graphical programming also is a highly interactive and responsive process that facilitates greater exploration, leading to a more optimized design.
Ideally, one would work at a higher level of abstraction for the entire design. But it may be necessary to gain access to finer-grained details for the critical portions of the design that require the highest performance. Graphical programming is well suited to represent system components at different levels of abstraction.
Dataflow is a powerful model of computation. It's Turing-complete like any text-based language, but more flexible and inherently parallel. It's also a natural model for distributed systems. With the addition of a timed-loop structure, it can elegantly represent distributed multirate systems.
Graphical tools typically include a rich library of user interface components for displaying-data in many forms. Being able to probe and modify design parameters interactively through the user interface while the model runs is a very effective way to develop intuition about the design and explore alternatives quickly.
The unique combination of an interactive front-panel user interface and graphical structured dataflow diagrams has led to dramatic productivity gains. The continued refinement of graphical design tools, supported by computers with high-speed graphics engines, will be how design engineers achieve the high productivity levels required to reduce time-to-market with more complex designs in our highly competitive world.