The chief data structure used by the build pipeline is the ModuleList (source:trunk/modules/leap/build-support/project/ModuleList.py). The ModuleList data structure is a representation of the entire module instantiation hierarchy in a form that build pipeline “stages” can manipulate. The format is a tree where each node is a list of subnodes.

The top-level module list is populated by AWB at configure time. The top-level SConstruct is basically just responsible for building the data structure representation and invoking the build pipeline.

ModuleList is comprised of a set of source modules which are passed to and manipulated by the various stages of the build pipeline.

The current LEAP compilation flow operates on latency-insensitive modules, computational entities which communicate only by way of latency-insensitive channels.

(source:trunk/modules/leap/build-support/build-pipelines/stages/li_module/liGraph.py)

A representation of a LEAP program in the formed by the set of modules comprising the program and their interconnected channels and chains. The LEAP compilation flow currently forms a latency-insensitive graph by analyzing Bluespec compilation logs.

(source:trunk/modules/leap/build-support/build-pipelines/stages/li_module/liModule.py)

A computational entity communicating only by way of latency-insensitive channels. Many computational structures can be captured as latency-insensitive modules, include hardware, FPGA-based softcores, and general purpose processors.

(source:trunk/modules/leap/build-support/build-pipelines/stages/li_module/liChannel.py)

LEAP programs currently uses the SoftConnections syntax to describe latency-insensitive channels. Latency-insensitive channels guarantee in-order, FIFO delivery, but do not specify an implementation. Rather this implementation is chosen by the compiler at compile time. Implementation could be as simple as a register, but could be as complicated as a FIFO spanning multiple chips and involving software management layers.

(source:trunk/modules/leap/build-support/build-pipelines/stages/li_module/liChain.py)

Chains are used as a form of low-cost broadcast for services like STDIO. Conceptually, each declaration of a chain in user code creates a single, unconnected link. At compile time, the LIM compiler will gather these links and physically connect them into a ring topology.