Kiwi: Synthesis of Circuits from Parallel Programs
Project members:
The Kiwi project aims to make reconfigurable computing
technology like Field Programmable Gate Arrays (FPGAs) more
accessible to mainstream programmers. FPGAs have a huge
potential for quickly performing many interesting
computations in parallel but their exploitation by computer
programmers is limited by the need to think like a hardware
engineer and the need to use hardware description languages
rather than conventional programming languages. We target
audience for our work are people writing computational
intensive programs in areas like software scientific
computing and executable biology. The Kiwi project is part
of a wider project that is researching programming models
for heterogeneous many-core architectures.
Our system starts from a parallel description of the
computation to be implemented in hardware:
- We start from a parallel description of a
computation expressed in C# using the standard
concurrency constructs provided by .NET and the System.Threading library.
- This description can be debugged, verified and
analyzed using conventional software concepts and tools.
- The same parallel program can now also be compiled
into a circuit. Each thread in the program corresponds
directly to a distinct sub-circuit and inter-thread
communication is mapped into appropriate circuit
elements using registers and a hand-shaking protocol.
- The generated circuit in the Verilog hardware
description format which can then be fed into vendor
tools to generate a programming bit-stream. This
bit-stream can be used to program a real FPGA circuit
which can then perform the computation in parallel in
hardware.
We do not take arbitrary C# code and
convert it into gates. Our system requires the C# parallel
program to be a sensible model of a circuit which has to
conform to many restrictions that we place to make sure that
at compile time we can compute the size of arrays, the
number of threads etc.
Once we have a solid implementation of the
basic low level concurrency primitives our aim to build
higher level parallel programming constructs which provide a
more civilized way for users to write parallel programs.
We also have a project that Sutirtha
Sanyal is working on that is investigating compiling part of
a C# program into a circuit and the rest into software for
execution on the same FPGA with the possibility of
communication between the hardware and software components
expressed as regular static method calls.
Here are some papers about Kiwi:
| 
