New Tools

Signed in as:

filler@godaddy.com

Account

Why New Tools for FPGA?

The development or programs for FPGA is currently based on low level languages like VHDL and Verilog. These languages are hard to master, and their use has led to the creation of multiple add-on tools. For example, there are core generators to help in the design of simple counter, digital filters or video processing functions. There are also high-level-tools for fix-point and floating-point computations or system design. In addition, to simplify programmer's work, C-Like languages have been used to translate sequential algorithms and synthesize hardware.

Use of Low-Level Hardware Description Languages (HDL) has prevented the development of a software engineering discipline for hardware programming and C-like language synthesizers have failed to deliver the performance and efficiency to replace HDL.

Need of a software engineering discipline

A single High-Level Language spanning the whole design hierarchy from Register Transfer to complex parallel or sequential algorithms is required.

The psC language is a true "High-Level HDL" capable of replacing low-level languages.

What's required to be qualified as next generation?

To illustrate our point, let's have a look at computer programming. In the beginning, computers were programmed using assembly language. Programmers quickly realized they needed a simpler way.

A new generation of languages and tools has been invented: High-Level Languages and Compilers. These new tools enabled the design of more complex programs with new algorithms. These tools allowed exploration of the design space, and finally hit their limits. Then another generation was invented: Object Oriented Programming, and so on.

From this example, we can enumerate some criteria for the next generation of languages and tools.

First and most important, the compiled code must be as efficient as the assembly code, in our case VHDL.

A new generation of tools should also facilitate design:

Easier to code
Easier to debug
Easier to simulate
Easier to document
Easier to explore the design space

And finally, adequate abstraction mechanisms must exist for:

Hiding low level details
Parametrization and code generation: pre-processing, templates, ...
Abstraction of hierarchical design
The support of software engineering good practices, like source code reuse and libraries

The psC language is to VHDL what C++ is to assembly language

The psC language supports a new abstraction mechanism that makes programming hardware easier. The main feature of psC is to abstract the clock and introduce an event-based control mechanism.

The programmer does not have to manage clock cycles, only events.

An efficient compiler is the key

A High-Level Language is meant to replace a Low-Level Languages and facilitate programming. In addition, new HLL programs must be as efficient as the low level implementations. See what Bjarne Stroustrup, the inventor of the C++ language has to say about language design goals.

Wong: What were/are the major design goals for C++?
Stroustrup: A way of mapping C++ language features to machine facilities that is at least as direct and efficient as C’s, plus abstraction mechanisms that allows programmers to express ideas beyond what I can imagine with no overhead compared to hand-crafted code.

Have a look at the full article for insightful details.

Stroustrup answer gives us two basic requirements for the new language :

The language must compile efficiently for any algorithms.
The language must support abstraction mechanisms to facilitate the creation of new algorithms.

The question is : How to achieve it? Bjarne Stroustrup gives the answer:

Mapping efficiently the language features on the machine is the most important objective.

The psC Language was designed with this objective in mind.

Therefore, the first question we should be asking ourselves is: What kind of machine is a FPGA? A FPGA is a parallel and synchronous machine. It is not a sequential machine. Therefore, if one wants to map language features on such a machine, the language execution model must be parallel and synchronous. Second, everything in an FPGA is organized as components with IO ports. The language must therefore support the component model and its hierarchical abstraction. Finally, all operations in a FPGA are based on a clock. Somehow, the language must keep this notion of steps.

The psC language maps directly on the FPGA

As with low-level HDL, a psC program consists of interconnected components with IO ports. The execution model is "parallel and synchronous". Even if the programmer does not manage clock cycles, the execution is based on "steps" and is triggered by events transmitted between components.

A psC component consists of functions and memory elements: variables, ports and arrays.

A new programming paradigm : Parallel and Synchronous

As discussed in the previous section, the FPGA machine consists of components communicating using signals. In addition, execution on the FPGA is based on a clock and all states synchronously change with the clock in a sequence of steps. Here are the fundamental rules defining the new execution model of the synchronous and parallel paradigm.

As for most HDL, the psC language is structured in components with ports.
Components are interconnected by signals.
The signals carry values and events.
An event triggers the execution of a function
If triggered, a function executes parallel assignments to variables and ports.
Each assignment to a port may include an event, used to trigger functions in other components.
All assignments in all functions for all components execute in a single clock or step.

These rules define the "Parallel and Synchronous Paradigm". Without a lengthy discussion, it can be observed how such paradigm maps directly on a FPGA machine. As a real FPGA, the execution of a psC program is identical to a synchronous sequential machine.

The parallel and synchronous paradigm makes possible true hardware compilation.

VHDL programmers might say: What's the difference since VHDL already supports synchronous sequential machine. The difference lays in the language implementation. For example, in sequential programming, the C++ language does the same thing as assembly language but differently, in a more abstract way.

This is the essence of the psC language: abstraction of the digital circuit world so programmers don't need any hardware knowledge.