About ReCoBus-Builder

The ReCoBusBuilder is implemented in C# using Microsoft Visual Studio 2005. Consequently, it requires the .net 2.0 framework. The first release was launched in September 2008 during the FPL conference.

Background

One major reason for the development of the ReCoBus-Builder was to close the design gap for building advanced reconfigurable Systems. With "advanced" we mean systems containing a plurality of different runtime reconfigurable modules having different demands with respect to the FPGA resources (LUTs, memory, DSP-primitives) and with respect to the module interface.
The problems to be solved are manifold, starting from a weak tool support over technical issues down to a powerful, but yet efficient communication architecture. In the past, these problems have prevented a wide use of runtime reconfiguration in commercial applications although the benefits are obvious.

However, with the ReCoBus-Builder tool, we solved these issues and are now able to present the first prototype systems capable for a flexible integration of multiple different modules into a FPGA based system at runtime.
Of course, we are not the first working on runtime reconfiguration, but we are the first being able to provide a communication architecture and an according tool chain that may easily link dozens of even hundreds of individually usable tiles on a FPGA into a system. With the ReCoBus technology, each tile may host a module that can contain a direct memory mapped interface to a system bus as well as some I/O connections. Note that the intention of tiny resource tiles is less to include let's say a hundred tiny reconfigurable modules into a system; it is manly required to allow tightening module bounding boxes. This minimizes the logic overhead resulting from fitting modules into a fixed tile grid.

Design Flow

Building advanced runtime reconfigurable FPGA-based systems with the ReCoBus-Builder is easy: firstly, assign a certain area for the reconfigurable modules in a floorplanning step, and then, divide this area into an arbitrary one- or two-dimensional tile grid. After this, include the communication architecture - including Buses and I/O bars - on top of this tile grid. Next, implement the static system strictly around the reconfigurable area. In the following, we can implement all reconfigurable modules, one after the other, within flexible bounding boxes that may be adjusted in terms of tiles of the grid. Note that these steps can be carried out in parallel design teams.
The result of the last step is a module repository that may be used at runtime as well as for composing an initial configuration for the system start. We call the initial bitstream generation "bitstream linking" as it has many similarities with linking known from the software domain.
As exemplarily illustrated in the next figure, these few steps can be plainly integrated into most typical existing design flows.

Tool support

As already mentioned, floorplanning, including the definition of the communication architecture, is the most important step that has to be carried out during the implementation of a runtime reconfigurable system. Consequently, the ReCoBus-Builder features a GUI for specifying the static-dynamic partition (the reconfigurable area), the tile grid, and the communication architecture.

With this system specification, the ReCoBus-Builder is capable to synthesize the communication architecture as a set of hard macros (completely routed modules). Together with automatically generated instantiation templates and some extracted area constraints, we are then able to generate the static system and also the module repository.


As we can constrain the timing of the ReCoBus and I/O bar macros, we can generate the module repository in such a way that the timing of a connected module will be valid regardless to the entire placement position. As a consequence, we can link together multiple partial modules for generating an initial configuration bitstream.
The bitstream linker works on bitstreams and is able to set module addresses and connections to I/O bars. The linker itself is implemented as a command line application and works together with the ReCoBus-Builder GUI.
Back to top