Endpoints¶

Endpoints represent the interfaces where external IP blocks (like processors, memories, or peripherals) connect to the NoC. They define the role of the connected IP (Manager, Subordinate, or both), the protocols used for communication, and the address ranges they serve.

Configuration¶

Endpoints are defined under the endpoints list in the configuration file.

`EndpointDesc` ¶

Endpoint class to describe an endpoint with adress ranges and configuration parameters.

Attributes:

Name	Type	Description
`name`	`str`	Unique identifier for the endpoint. Used in connection definitions.
`description`	`Optional[str]`	Optional description of the endpoint.
`array`	`Optional[Union[Tuple[int], Tuple[int, int]]]`	Defines the endpoint as an array (1D or 2D). E.g., `[4]` for a 1D array of size 4, or `[4, 4]` for a 4x4 grid.
`addr_range`	`List[AddrRange]`	Defines the address regions served by this endpoint (required if it acts as a Subordinate).
`xy_id_offset`	`Optional[Union[SimpleId, Coord]]`	Offsets for XY coordinates or IDs, used to manually adjust the logical position of the endpoint in the network.
`mgr_port_protocol`	`Optional[List[str]]`	List of protocol names (defined in `protocols`) that this endpoint uses to send requests (Manager role).
`sbr_port_protocol`	`Optional[List[str]]`	List of protocol names (defined in `protocols`) that this endpoint uses to receive requests (Subordinate role).

Address Ranges¶

If an endpoint acts as a Subordinate (i.e., it receives requests), it must define at least one address range. This is used to generate the system address map and routing tables. Address ranges can be defined explicitly or relative to a base address for arrays.

Address range class.

Attributes:

Name	Type	Description
`start`	`int`	Absolute start address of the range.
`end`	`int`	Absolute end address of the range.
`size`	`int`	Size of the address range.
`base`	`Optional[int]`	Base address used for calculating ranges in endpoint arrays.
`en_collective`	`bool`	If true, marks this range as a multicast/collective destination.

Examples¶

Basic Endpoint¶

A simple memory endpoint that acts as a subordinate (Slave) answering to a specific address range.

endpoints:
  - name: "hbm"
    addr_range:
      start: 0x8000_0000
      size: 0x1000_0000 # 256 MB
    sbr_port_protocol:
      - "axi_out"

Processor Endpoint (Manager)¶

A processor core that only issues requests (Manager) and does not receive them.

endpoints:
  - name: "cva6"
    mgr_port_protocol:
      - "narrow_in"

Endpoint Arrays¶

FlooGen supports defining arrays of endpoints, which is useful for multi-core clusters or tiled architectures. When defining an address range for an array, you typically provide a base address and a size. FlooGen automatically calculates the specific range for each instance in the array.

endpoints:
  - name: "cluster"
    array: [4, 4] # 4x4 Grid of clusters
    addr_range:
      base: 0x1000_0000
      size: 0x0004_0000 # Size per cluster
    mgr_port_protocol:
      - "axi_in"
    sbr_port_protocol:
      - "axi_out"
  - name: "hbm_channels"
    array: [8] # 8 HBM channels
    addr_range:
      base: 0x8000_0000
      size: 0x0200_0000 # Size per channel
    sbr_port_protocol:
      - "axi_out"

Narrow-wide Interfaces¶

If the narrow-wide configuration is used in the network, endpoints can define both/either narrow/wide protocols for their ports.

endpoints:
  - name: "dma"
    mgr_port_protocol:
      - "narrow_in"
      - "wide_in"
    sbr_port_protocol:
      - "narrow_out"
      - "wide_out"

Multiple (non-contiguous) Address Ranges¶

Endpoints can define multiple address ranges to represent non-contiguous memory regions or peripherals.

endpoints:
  - name: "peripheral_block"
    addr_range:
      - start: 0x4000_0000
        size: 0x0001_0000
        desc: "Control Registers"
      - start: 0x5000_0000
        size: 0x0001_0000
        desc: "Status Registers"
    sbr_port_protocol:
      - "axi_out"

SystemRDL Generation¶

The rdl CLI command generates a SystemRDL description of the network's address map, with one addrmap entry per subordinate address range. By default, an address range without further annotation is either skipped or rendered as an anonymous external mem block (if --as-mem is passed on the command line). Two addr_range fields give finer control over how each range is rendered:

rdl_name: instantiates an externally-defined SystemRDL component (e.g. a register file described in its own .rdl file) at this address range. FlooGen emits an `include for it in the generated file.
rdl_as_mem: renders this specific range as an anonymous external mem block, overriding the global --as-mem flag for this range only (true forces it on, false forces it off, regardless of the CLI flag).

rdl_name and rdl_as_mem are mutually exclusive on the same address range.

endpoints:
  - name: "cluster"
    addr_range:
      - base: 0x1000_0000
        size: 0x0004_0000
        rdl_name: "cluster_regs" # instantiate an externally-defined `cluster_regs.rdl`
      - base: 0x1000_4000
        size: 0x0000_1000
        rdl_as_mem: true # always render as `external mem`, regardless of --as-mem
    sbr_port_protocol:
      - "axi_out"

SystemRDL Addrmap Groups¶

Each address range can be tagged with one or more rdl_addrmap_grp values to control which generated SystemRDL addrmap(s) it appears in (see the rdl CLI command). This is a per-addr_range field, not a per-endpoint one, since different address ranges of the same endpoint (e.g. its main registers vs. a debug-only region) may need to be reachable from different views. A single group can be given as a plain string, or multiple groups as a list. Address ranges without rdl_addrmap_grp are considered common and are included in every group's file.

endpoints:
  - name: "cluster"
    addr_range:
      - base: 0x1000_0000
        size: 0x0004_0000
        rdl_name: "cluster_regs"
        rdl_addrmap_grp: ["32b", "64b"] # visible in both the 32b and 64b addrmaps
      - base: 0x1000_4000
        size: 0x0000_1000
        rdl_name: "cluster_debug_regs"
        rdl_addrmap_grp: "64b" # only visible in the 64b addrmap
    sbr_port_protocol:
      - "axi_out"
  - name: "hbm"
    addr_range:
      base: 0x8000_0000
      size: 0x1000_0000
      rdl_name: "hbm_regs"
      rdl_addrmap_grp: "64b" # only visible in the 64b addrmap
    sbr_port_protocol:
      - "axi_out"