Merge branch 'cabal-oth' into 'devel'

Cabal oth

See merge request ndk/ndk-fpga!418

Author: jakubcabal

comp/axis_tools/flow/discard/Modules.tcl

@@ -0,0 +1,10 @@
+# Modules.tcl: Components include script
+# Copyright (C) 2026 CESNET z. s. p. o.
+# Author(s): Jakub Cabal <cabal@cesnet.cz>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+lappend PACKAGES "$OFM_PATH/comp/base/pkg/math_pack.vhd"
+lappend PACKAGES "$OFM_PATH/comp/base/pkg/type_pack.vhd"
+
+lappend MOD "$ENTITY_BASE/axis_discard.vhd"

comp/axis_tools/flow/discard/axis_discard.vhd

@@ -0,0 +1,142 @@
+-- Copyright (C) 2026 CESNET z. s. p. o.
+-- Author(s): Jakub Cabal <cabal@cesnet.cz>
+-- SPDX-License-Identifier: BSD-3-Clause
+
+library IEEE;
+use IEEE.std_logic_1164.all;
+use IEEE.numeric_std.all;
+
+use work.math_pack.all;
+use work.type_pack.all;
+
+-- The AXIS_DISCARD component filters (drops) AXI-Stream packets based on a
+-- per-packet discard control signal. When RX_AXI_DISCARD is asserted at
+-- Start-of-Packet, the entire packet is consumed from the RX interface
+-- without being forwarded to the TX interface. When RX_AXI_DISCARD is
+-- deasserted at SOP, the packet passes through unchanged.
+--
+-- The discard decision is sampled only at the first word of each packet
+-- (SOP) and remains active for the entire packet duration. Discarded
+-- packets are consumed immediately regardless of TX backpressure,
+-- ensuring that discarded packets never block the pipeline.
+--
+-- Guaranteed throughput: 1 word per clock cycle.
+--
+entity AXIS_DISCARD is
+    generic (
+        -- AXI-Stream data bus width in bits; must be a multiple of 8.
+        AXI_TDATA_WIDTH  : natural := 512;
+        -- AXI-Stream user signal width in bits. Set to 0 to disable TUSER.
+        AXI_TUSER_WIDTH  : natural := 64;
+        -- Target device.
+        DEVICE           : string  := "AGILEX"
+    );
+    port (
+        CLK              : in  std_logic;
+        RESET            : in  std_logic;
+
+        -- =====================================================================
+        -- RX AXI-Stream Interface
+        -- =====================================================================
+        RX_AXI_TDATA     : in  std_logic_vector(AXI_TDATA_WIDTH-1 downto 0);
+        RX_AXI_TKEEP     : in  std_logic_vector(AXI_TDATA_WIDTH/8-1 downto 0);
+        RX_AXI_TUSER     : in  std_logic_vector(AXI_TUSER_WIDTH-1 downto 0) := (others => '0');
+        RX_AXI_TLAST     : in  std_logic;
+        RX_AXI_TVALID    : in  std_logic;
+        RX_AXI_TREADY    : out std_logic;
+
+        -- =====================================================================
+        -- Discard control (sampled only at the first word of each packet)
+        -- When '1' at SOP, the entire packet is dropped.
+        -- =====================================================================
+        RX_AXI_DISCARD   : in  std_logic;
+
+        -- =====================================================================
+        -- TX AXI-Stream Interface
+        -- =====================================================================
+        TX_AXI_TDATA     : out std_logic_vector(AXI_TDATA_WIDTH-1 downto 0);
+        TX_AXI_TKEEP     : out std_logic_vector(AXI_TDATA_WIDTH/8-1 downto 0);
+        TX_AXI_TUSER     : out std_logic_vector(AXI_TUSER_WIDTH-1 downto 0);
+        TX_AXI_TLAST     : out std_logic;
+        TX_AXI_TVALID    : out std_logic;
+        TX_AXI_TREADY    : in  std_logic
+    );
+end entity;
+
+architecture FULL of AXIS_DISCARD is
+
+    -- Active discard flag: combinatorial at SOP, registered during packet
+    signal discard      : std_logic;
+    signal discard_reg  : std_logic;
+
+    -- Packet tracking
+    signal in_pkt       : std_logic;
+    signal rx_transfer  : std_logic;
+
+begin
+
+    -- =====================================================================
+    -- Discard Flag Muxing
+    -- At SOP (in_pkt=0): use combinatorial RX_AXI_DISCARD input
+    -- During packet (in_pkt=1): use registered value captured at SOP
+    -- =====================================================================
+    discard <= RX_AXI_DISCARD when in_pkt = '0' else discard_reg;
+
+    -- =====================================================================
+    -- AXI-Stream Handshake
+    --
+    -- When discarding: RX_AXI_TREADY = '1' (consume immediately, bypass
+    --                  TX backpressure) and TX_AXI_TVALID = '0' (suppress
+    --                  output).
+    -- When not discarding: Normal pass-through with backpressure
+    --                      propagation from TX to RX.
+    -- =====================================================================
+    RX_AXI_TREADY <= '1' when discard = '1' else TX_AXI_TREADY;
+    TX_AXI_TVALID <= RX_AXI_TVALID and not discard;
+
+    -- Transfer occurs when both VALID and READY are asserted
+    rx_transfer <= RX_AXI_TVALID and RX_AXI_TREADY;
+
+    -- =====================================================================
+    -- Data Pass-Through (combinatorial, no pipeline)
+    -- Output data is only visible when TX_AXI_TVALID is asserted (i.e.,
+    -- when not discarding), so discarded data never appears on TX.
+    -- =====================================================================
+    TX_AXI_TDATA <= RX_AXI_TDATA;
+    TX_AXI_TKEEP <= RX_AXI_TKEEP;
+    TX_AXI_TLAST <= RX_AXI_TLAST;
+
+    -- TUSER pass-through (conditional generate for zero-width case)
+    tuser_g : if AXI_TUSER_WIDTH > 0 generate
+        TX_AXI_TUSER <= RX_AXI_TUSER;
+    else generate
+        TX_AXI_TUSER <= (others => '0');
+    end generate;
+
+    -- =====================================================================
+    -- Packet Tracking and Discard Flag Registration
+    --
+    -- Tracks whether we are currently inside a packet and captures the
+    -- discard flag at SOP for the duration of the packet.
+    -- =====================================================================
+    process (CLK)
+    begin
+        if rising_edge(CLK) then
+            if (RESET = '1') then
+                in_pkt      <= '0';
+                discard_reg <= '0';
+            elsif (rx_transfer = '1') then
+                if (RX_AXI_TLAST = '1') then
+                    -- EOP: no longer inside a packet
+                    in_pkt <= '0';
+                elsif (in_pkt = '0') then
+                    -- SOP accept: entering a multi-word packet, capture discard
+                    in_pkt      <= '1';
+                    discard_reg <= RX_AXI_DISCARD;
+                end if;
+                -- Middle of packet (in_pkt=1, TLAST=0): hold registered values
+            end if;
+        end if;
+    end process;
+
+end architecture;

comp/axis_tools/flow/discard/cocotb/Makefile

@@ -0,0 +1,12 @@
+# Copyright (C) 2026 CESNET z. s. p. o.
+# Author(s): Jakub Cabal <cabal@cesnet.cz>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+TOP_LEVEL_ENT=AXIS_DISCARD
+TARGET=cocotb
+
+.PHONY: all
+all: comp
+
+include ../../../../../build/Makefile

comp/axis_tools/flow/discard/cocotb/cocotb_test.py

@@ -0,0 +1,211 @@
+# Copyright (C) 2026 CESNET z. s. p. o.
+# Author(s): Jakub Cabal <cabal@cesnet.cz>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Cocotb tests for AXIS_DISCARD component."""
+
+import random
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import cocotb
+from cocotb.clock import Clock
+from cocotb.triggers import ClockCycles
+from cocotbext.ofm.base.generators import ItemRateLimiter
+from cocotbext.ofm.ver.generators import random_packets
+
+from testbench import Testbench, DiscardInstruction
+
+
+@dataclass
+class BPCfg:
+    """Backpressure configuration."""
+    min_hold: int = 1
+    max_hold: int = 5
+    low_prob: float = 0.5
+
+
+async def _backpressure(signal, clock, cfg: Optional[BPCfg] = None):
+    """Apply random backpressure to a ready signal."""
+    cfg = cfg or BPCfg()
+    while True:
+        hold_cycles = random.randint(cfg.min_hold, cfg.max_hold)
+        if random.random() < cfg.low_prob:
+            signal.value = 0
+        else:
+            signal.value = 1
+        await ClockCycles(clock, hold_cycles)
+
+
+async def _run_test(
+    dut,
+    pkt_count: int = 10,
+    pkt_range: Tuple[int, int] = (60, 8000),
+    discard_prob: float = 0.5,
+    tx_cfg: Optional[BPCfg] = None,
+    test_name: str = "",
+    zero_idles_chance: int = 50,
+    max_idles: int = 5
+):
+    """Run test with specified packet count and configuration."""
+    cocotb.log.info(f"Starting AXIS_DISCARD {test_name} test")
+    cocotb.start_soon(Clock(dut.CLK, 5, units="ns").start())
+
+    tb = Testbench(dut, debug=False)
+    await tb.reset()
+    cocotb.log.info("Reset completed")
+
+    tb.rx_driver.set_idle_generator(ItemRateLimiter(max_idles=max_idles, zero_idles_chance=zero_idles_chance))
+
+    tx_task = None
+    if tx_cfg:
+        tx_task = cocotb.start_soon(_backpressure(dut.TX_AXI_TREADY, dut.CLK, tx_cfg))
+
+    pkt_iter = random_packets(min_size=pkt_range[0], max_size=pkt_range[1], count=pkt_count)
+
+    for i, pkt_data in enumerate(pkt_iter):
+        discard = 1 if random.random() < discard_prob else 0
+
+        discard_instr = DiscardInstruction(discard=discard)
+
+        await tb.send_packet_with_discard(
+            pkt_data=pkt_data,
+            discard_instr=discard_instr
+        )
+
+        if (i + 1) % 500 == 0:
+            cocotb.log.info(f"Sent {i + 1}/{pkt_count} packets")
+
+    # Wait for all expected packets to be processed with timeout
+    timeout = 0
+    last_frame_cnt = 0
+    while tb.tx_monitor.frame_cnt < tb.pkts_expected and timeout < 1000000:
+        if tb.tx_monitor.frame_cnt % 200 == 0 and tb.tx_monitor.frame_cnt != last_frame_cnt:
+            last_frame_cnt = tb.tx_monitor.frame_cnt
+            cocotb.log.info(f"Frames received: {tb.tx_monitor.frame_cnt}/{tb.pkts_expected}")
+        await ClockCycles(dut.CLK, 10)
+        timeout += 1
+
+    if tx_task:
+        tx_task.kill()
+
+    cocotb.log.info(f"Test completed: {tb.tx_monitor.frame_cnt}/{tb.pkts_expected} packets "
+                    f"(total sent: {tb.pkts_sent}, discarded: {tb.pkts_sent - tb.pkts_expected})")
+
+    if tb.tx_monitor.frame_cnt < tb.pkts_expected:
+        raise AssertionError(f"Only {tb.tx_monitor.frame_cnt}/{tb.pkts_expected} packets processed")
+    if tb.scoreboard.errors > 0:
+        raise AssertionError(f"Test failed with {tb.scoreboard.errors} errors")
+
+
+@cocotb.test()
+async def run_test_random(dut, pkt_count=3000):
+    """Test with fully random packet lengths and ~50% discard probability."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 8000),
+        discard_prob=0.5,
+        tx_cfg=BPCfg(1, 5, 0.5),
+        test_name="random",
+        zero_idles_chance=50,
+        max_idles=5
+    )
+
+
+@cocotb.test()
+async def run_test_aggressive_backpressure(dut, pkt_count=3000):
+    """Test with aggressive backpressure on TX interface."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 8000),
+        discard_prob=0.5,
+        tx_cfg=BPCfg(10, 50, 0.8),
+        test_name="aggressive_backpressure",
+        zero_idles_chance=50,
+        max_idles=5
+    )
+
+
+@cocotb.test()
+async def run_test_high_discard_rate(dut, pkt_count=3000):
+    """Test with high discard probability (90%)."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 8000),
+        discard_prob=0.9,
+        tx_cfg=BPCfg(1, 5, 0.5),
+        test_name="high_discard_rate",
+        zero_idles_chance=50,
+        max_idles=5
+    )
+
+
+@cocotb.test()
+async def run_test_low_discard_rate(dut, pkt_count=3000):
+    """Test with low discard probability (10%)."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 8000),
+        discard_prob=0.1,
+        tx_cfg=BPCfg(1, 5, 0.5),
+        test_name="low_discard_rate",
+        zero_idles_chance=50,
+        max_idles=5
+    )
+
+
+@cocotb.test()
+async def run_test_no_discard(dut, pkt_count=2000):
+    """Test with no discards - all packets should pass through."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 8000),
+        discard_prob=0.0,
+        tx_cfg=BPCfg(1, 5, 0.5),
+        test_name="no_discard",
+        zero_idles_chance=50,
+        max_idles=5
+    )
+
+
+@cocotb.test()
+async def run_test_all_discard(dut, pkt_count=2000):
+    """Test with all packets discarded - no packets should appear on TX."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 8000),
+        discard_prob=1.0,
+        tx_cfg=BPCfg(1, 5, 0.5),
+        test_name="all_discard",
+        zero_idles_chance=50,
+        max_idles=5
+    )
+
+
+@cocotb.test()
+async def run_test_small_packets(dut, pkt_count=3000):
+    """Test with small packets from 60 to 75 bytes."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(60, 75),
+        discard_prob=0.5,
+        tx_cfg=BPCfg(1, 10, 0.3),
+        test_name="small_packets",
+        zero_idles_chance=0,
+        max_idles=10
+    )
+
+
+@cocotb.test()
+async def run_test_jumbo_packets(dut, pkt_count=1000):
+    """Test with jumbo packets up to 9216 bytes."""
+    await _run_test(
+        dut, pkt_count=pkt_count,
+        pkt_range=(4000, 9216),
+        discard_prob=0.5,
+        tx_cfg=BPCfg(1, 5, 0.5),
+        test_name="jumbo_packets",
+        zero_idles_chance=50,
+        max_idles=5
+    )

comp/axis_tools/flow/discard/cocotb/cocotb_test_sig.fdo

@@ -0,0 +1,11 @@
+# Copyright (C) 2026 CESNET z. s. p. o.
+# Author(s): Jakub Cabal <cabal@cesnet.cz>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+view wave
+delete wave *
+
+add_wave -group {ALL} -noupdate -hex /axis_discard/*
+
+config wave -signalnamewidth 1