Get The Source

Our code is hosted at Github:

NOTE: The Rigel tools are known to work well out of the box on Ubuntu versions 8.04 and later on 32- and 64-bit x86. Our dependency on x86 is very minimal (a few lines of inline assembly in the simulator) and can be worked around quickly. Other Linux distributions should work well too, but aren't explicitly supported yet, as we don't have test machines for them. Most things work out of the box on FreeBSD 9, but a small amount of manual tweaking in the build scripts may be required. We welcome patches to improve the install and usage experience on other platforms, and volunteers to help us maintain portability to many platforms by testing the tools regularly.

High-level Organization

The project's source code is broken up into repositories with mostly disjoint functionality.

The rigel repository acts as a container; all other repositories are stored and .gitignored as subdirectories. rigel also contains documentation and utility scripts that cut across repositories, and scripts to install and update the tools contained in the other repositories.

The codegen repository contains everything needed to cross-compile C and assembly code for Rigel on a host machine. Our compilation toolchain is pictured below; we use clang 2.8 as a C89, C99, and assembly front-end, LLVM 2.8 for middle-end optimizations, an LLVM backend to generate assembly code, and GNU binutils 2.18 to assemble and link binaries.

The targetcode repository contains all C and assembly code intended to run on Rigel. This includes libraries and application code.

The targetcode/lib subdirectory includes:
  • a newlib 1.19-based standard C library with a high-performance, thread-caching heap allocator based on nedmalloc.
  • libpthread, a port of a subset of POSIX Threads thread management, thread-local storage, mutexes, and condition variables
  • compiler-rt, an LLVM project providing the runtime functions the compiler uses to support double-precision floating point, 64-bit integer arithmetic, C99 complex arithmetic, and unaligned loads and stores. We have also adapted compiler-rt's implementation of Blocks, a language extension to C, Objective-C, and C++ that implements a type of closure.
  • libpar, a library implementing the RTM task-based programming model
  • taskmodel-x86, an incomplete pthreads port of the RTM programming model to enable faster validation of RTM-based programs that what can be achieved on a simulator
  • linker, a place to put linker scripts for laying out and aligning Rigel binaries
  • rigel-crt0-mp.S, the startup code run by all Rigel binaries before jumping into newlib's pre-main() setup code. The primary function of this file is to set stack pointers for all threads in the system.

The targetcode/src subdirectory includes a small set of data- and task-parallel benchmarks useful in evaluating many-core designs like Rigel, a larger set of test codes useful for evaluating the correctness and performance of library and compiler features, and a Makefile.common with environment variables and compiler toolchain flags. The benchmarks are:

  • fft, a 2D Danielson-Lanczos-based Complex-to-Complex Fast Fourier Transform. This benchmark comes with a test data and golden output generator, fft_host, based on FFTW3. The simulator's output can be checked against the golden output using fpdiff, a tool for comparing binary files of single-precision floats with user-specified tolerance.
  • march, an implementation of Marching Cubes scalar field isosurface polygonization. This parallel implementation is based on a serial implementation by Paul Bourke and Cory Bloyd. This benchmark comes with a tool to convert volume data as found in the Stanford volume data archive to a binary format suitable for Rigel, as well as a tool to convert RigelSim's list of output triangles into a .obj file suitable for viewing. Our sample data set, a CT image of the head, comes from the UNC Volume Rendering Test Data Set by way of the Stanford volume data archive.
  • stencil, a 3D 7-point stencil computation modeling, for example, heat diffusion over time in 3D.

The sim repository contains RigelSim, an execution-driven simulator for the Rigel architecture written in C++. The repository also contains RigelSim-specific dependencies without wide packaging support, such as RandomLib.

RigelSim has a fast functional mode that simulates at around 2 MIPS, and a structural timing mode (the default) that simulates at 100-200 KIPS. To switch between the two, set the RIGEL_CFG_NUM variable in $RIGEL_SIM/rigel-sim/user.config.


All standalone tools in the Rigel repositories are licensed under the permissive University of Illinois Open Source License.

Our modifications to existing tools are under the same license as the tool; for instance, Rigel assembler and linker support in GNU Binutils 2.18 is licensed under GPLv3.

RigelSim can optionally link against GPLv3 tools — like GNU Binutils for instruction disassembly — these dependencies can be enabled with the --enable-gplv3 flag to RigelSim's configure script. Without this flag, the resulting combined work is licensed under the University of Illinois Open Source License. With this flag, the resulting combined work must be licensed under GPLv3.

For more details, see the LICENSE.TXT file in the main Rigel repository.


Here is a video showing the history of our repository from 2007 through early 2012, at normal and 4x speed.