This repository provides modules for the FlooNoC, a Network-on-Chip (NoC) which is part of the PULP (Parallel Ultra-Low Power) Platform. The repository includes Network Interface IPs (named chimneys), Routers and further NoC components to build a complete NoC. FlooNoC mainly supports AXI4+ATOPs, but can be easily extended to other On-Chip protocols. Arbitrary topologies are supported with several routing algorithms. FlooNoC is designed to be scalable and modular, and can be easily extended with new components. Additionally, FlooNoC provides a generation framework for creating customized NoC configurations.
Our NoC design is grounded in the following key principles:
- Full AXI4 Support: Our design fully supports AXI4+ATOPs from AXI5 as outlined here, particularly multiple outstanding burst transactions. It utilizes low-complexity routers and a decoupled link-level protocol to ensure scalability, thereby enabling tolerance to high-latency off-chip accesses.
- Decoupled Links and Networks: We use a link-level protocol that is decoupled from the network-level protocol. This allows us to move the complexity of the network-level protocol into the network interfaces, while deploying low-complexity routers in the network, that enable better scalability.
- Wide Physical Channels: We incorporate wide physical channels in order to meet the high-bandwidth requirements at network endpoints without being constrained by the operating frequency. This is in contrast to the traditional narrow link approach. Further, the NoC avoids any kind of serialization and sends entire messages in a single flit including header and tail information.
- Separation of traffic: Our design acknowledges the diversity in traffic patterns, as it decouples links and networks to handle wide, high-bandwidth, burst-based traffic and narrow, latency-sensitive traffic with separate physical channels.
- Modularity: Our design principles also emphasize modularity. We have developed a set of IPs that can be instantiated together to build a NoC. This approach not only promotes reusability but also facilitates flexibility in designing custom NoCs to cater to a variety of specific system requirements.
The names of the IPs are inspired by the Harry Potter universe, where the Floo Network is a magical transportation system. The Network interfaces are named after the fireplaces and chimneys used to access the Floo Network.
In use for centuries, the Floo Network, while somewhat uncomfortable, has many advantages. Firstly, unlike broomsticks, the Network can be used without fear of breaking the International Statute of Secrecy. Secondly, unlike Apparition, there is little to no danger of serious injury. Thirdly, it can be used to transport children, the elderly and the infirm."
All code checked into this repository is made available under a permissive license. All software sources are licensed under the Apache License 2.0 (see LICENSE-APACHE), and all hardware sources in the hw folder are licensed under the Solderpad Hardware License 0.51 (see LICENSE-SHL).
If you use FlooNoC in your research, please cite the following paper:
FlooNoC: A Multi-Tbps Wide NoC for Heterogeneous AXI4 Traffic
@misc{fischer2023floonoc,
title={FlooNoC: A Multi-Tbps Wide NoC for Heterogeneous AXI4 Traffic},
author={Tim Fischer and Michael Rogenmoser and Matheus Cavalcante and Frank K. Gürkaynak and Luca Benini},
year={2023},
eprint={2305.08562},
archivePrefix={arXiv},
primaryClass={cs.AR}
}
FlooNoC uses bender to manage its dependencies and to automatically generate compilation scripts. Further Python >= 3.10 is required to install the generation framework.
Currently, we do not provide any open-source simulation setup. Internally, the FlooNoC was tested using QuestaSim, which can be launched with the following command:
# Compile the sources
make compile-sim
# Run the simulation
make run-sim-batch VSIM_TB_DUT=tb_floo_dutor in the GUI, with prepared waveforms:
# Compile the sources
make compile-sim
# Run the simulation
make run-sim VSIM_TB_DUT=tb_floo_dutBy replacing tb_floo_dut with the name of the testbench you want to simulate.
This repository includes the following NoC IPs:
- Routers: A collection of different NoC router designs with varying features such as virtual channels, input/output buffering, and adaptive routing algorithms.
- Network Interfaces (NIs): A set of NoC network interfaces for connecting IPs to the NoC.
- Topologies: A collection of NoC topologies, such as mesh, to enable the creation of various on-chip interconnects.
- Common IPs A set of IPs used by the NoC IPs, such as FIFOs, Cuts and arbiters.
- Verification IPs (VIPs): A set of VIPs to verify the correct functionality of the NoC IPs.
- Testbenches: A set of testbenches to evaluate the performance of the NoC IPs, including throughput, latency.
| Name | Description | Doc |
|---|---|---|
| floo_router | A simple router with configurable number of ports, physical and virtual channels, and input/output buffers | |
| floo_narrow_wide_router | Wrapper of a multi-link router for narrow and wide links |
| Name | Description | Doc |
|---|---|---|
| floo_axi_chimney | A bidirectional network interface for connecting AXI4 Buses to the NoC | |
| floo_narrow_wide_chimney | A bidirectional network interface for connecting narrow & wide AXI Buses to the multi-link NoC |
| Name | Description | Doc |
|---|---|---|
| floo_mesh | A mesh topology with configurable number of rows and columns | |
| floo_mesh_ruche | A mesh topology with ruche channels and a configurable number of rows and columns |
| Name | Description | Doc |
|---|---|---|
| floo_fifo | A FIFO buffer with configurable depth | |
| floo_cut | Elastic buffers for cuting timing paths | |
| floo_cdc | A Clock-Domain-Crossing (CDC) module implemented with a gray-counter based FIFO. | |
| floo_wormhole_arbiter | A wormhole arbiter | |
| floo_vc_arbiter | A virtual channel arbiter | |
| floo_route_comp | A helper module to compute the packet destination | |
| floo_rob | A table-based Reorder Buffer | |
| floo_simple_rob | A simplistic low-complexity Reorder Buffer | |
| floo_rob_wrapper | A wrapper of all available types of RoBs including RoB-less version | |
| floo_narrow_wide_join | A mux for joining a narrow and wide AXI bus a single wide bus |
| Name | Description | Doc |
|---|---|---|
| axi_bw_monitor | A AXI4 Bus Monitor for measuring the throughput and latency of the AXI4 Bus | |
| axi_reorder_compare | A AXI4 Bus Monitor for verifying the order of AXI transactions with the same ID | |
| floo_axi_rand_slave | A AXI4 Bus Multi-Slave generating random AXI respones with configurable response time | |
| floo_axi_test_node | A AXI4 Bus Master-Slave Node for generating random AXI transactions | |
| floo_dma_test_node | An endpoint node with a DMA master port and a Simulation Memory Slave port | |
| floo_hbm_model | A very simple model of the HBM memory controller with configurable delay |
FlooNoC comes with a generation framework called floogen. It allows to create complex network configurations with a simple configuration file.
floogen has a graph-based internal representation of the network configuration. This allows to easily add new features and capabilities to the generation framework. The following list shows the a couple of the current capabilities of floogen:
- Validation: The configuration is validated before the generation to ensure that the configuration is valid. For instance, the configuration is checked for invalid user input, overlapping address ranges
- Routing: XY-Routing and ID-Table routing are supported.
floogenautomatically generates the routing tables for the routers, as well as the address map for the network interfaces. - Package Generation:
floogenautomatically generates a SystemVerilog package with all the needed types and constants for the network configuration. - Top Module Generation:
floogenautomatically generates a top module that contains all router and network interfaces. The interfaces of the top module are AXI4 interfaces for all the enpdoints specified in the configuration.
The following example shows the configuration for a simple mesh topology with 4x4 routers and 4x4 chimneys with XY-Routing.
name: example_system
description: "Example of a configuration file"
routing:
route_algo: "XY"
use_id_table: true
protocols:
- name: "example_axi"
type: "AXI4"
direction: "manager"
data_width: 64
addr_width: 32
id_width: 3
user_width: 1
- name: "example_axi"
type: "AXI4"
direction: "subordinate"
data_width: 64
addr_width: 32
id_width: 3
user_width: 1
endpoints:
- name: "cluster"
array: [4, 4]
addr_range:
base: 0x1000_0000
size: 0x0004_0000
mgr_port_protocol:
- "example_axi"
sbr_port_protocol:
- "example_axi"
routers:
- name: "router"
array: [4, 4]
connections:
- src: "cluster"
dst: "router"
src_range:
- [0, 3]
- [0, 3]
dst_range:
- [0, 3]
- [0, 3]
bidirectional: trueTo install floogen run the following command:
pip install .which allows you to use floogen with the following command:
floogen -c <config_file> -o <output_dir>The example configuration above shows the basic structure of a configuration file. A more detailed description of the configuration file can be found in the documentation.