Link Efficiency — Naming the Denominator Before Quoting the Number

A − B = 3.62 points   ← the replay tax
B − C = 0.95 points   ← the control-traffic tax
C − D = 9.55 points   ← idle and everything else (22.1's question)

// SYNTHESIZABLE. Efficiency measurement types.
// Four independent accumulators. The generation basis is a compile-time
// selection because Gen6 is NOT the Gen3-5 model with a different constant
// (§9) -- an unsupported combination must fail to elaborate, not silently
// compute the wrong thing.
package eff_pkg;
 
  parameter int CNT_W  = 48;
  parameter int BYTES_W = 13;
 
  typedef enum logic [1:0] {
    BASIS_LINECODE = 2'd0,   // Gen1-Gen5: a line code expands every byte
    BASIS_FLIT     = 2'd1,   // Gen6: no line code; overhead inside the FLIT
    BASIS_NONE     = 2'd2    // byte-domain only; no physical-layer claim
  } basis_e;
 
  function automatic logic [CNT_W-1:0] sat_add(input logic [CNT_W-1:0] v,
                                               input logic [CNT_W-1:0] inc);
    logic [CNT_W:0] wide;
    wide = {1'b0, v} + {1'b0, inc};
    return wide[CNT_W] ? {CNT_W{1'b1}} : wide[CNT_W-1:0];
  endfunction
 
  function automatic bit is_sat(input logic [CNT_W-1:0] v);
    return (v == {CNT_W{1'b1}});
  endfunction
 
endpackage

import eff_pkg::*;
 
// SYNTHESIZABLE. UNIQUE application payload -- the NUMERATOR (§6).
// Increments on FIRST successful delivery only. A replay of the same
// packet must not increment it: §13 Model 9 shows a counter that does is
// blind to the exact condition it exists to detect.
module unique_payload_counter (
  input  logic clk,
  input  logic rst_n,
  input  logic               measuring,
  input  logic               tlp_accepted,     // handshake at the measurement point
  input  logic               is_replay,        // this transmission is a retransmit
  input  logic [BYTES_W-1:0] payload_bytes,
 
  output logic [CNT_W-1:0]   unique_payload,
  output logic               saturated,
  output logic               replay_seen       // sticky: qualifies the whole window
);
  logic [CNT_W-1:0] p_q;
  logic             rs_q;
 
  assign unique_payload = p_q;
  assign saturated      = is_sat(p_q);
  assign replay_seen    = rs_q;
 
  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin p_q <= '0; rs_q <= 1'b0; end
    else if (measuring && tlp_accepted) begin
      if (is_replay) rs_q <= 1'b1;                       // qualify, do not count
      else p_q <= sat_add(p_q, CNT_W'(payload_bytes));   // FIRST delivery only
    end
  end
endmodule

import eff_pkg::*;
 
// SYNTHESIZABLE. Transport bytes -- the DENOMINATOR's core term (§5).
// Counts EVERY transmission, including replays. The measurement point is
// the local transmit interface, which sits ABOVE the physical layer: this
// is represented transport, NOT a wire capture (§1, mutation 16).
module transport_byte_counter (
  input  logic clk,
  input  logic rst_n,
  input  logic               measuring,
  input  logic               tx_valid,
  input  logic               tx_ready,
  input  logic [BYTES_W-1:0] tx_bytes,          // header + payload for this packet
 
  output logic [CNT_W-1:0]   transport_bytes,
  output logic               saturated
);
  logic [CNT_W-1:0] t_q;
  assign transport_bytes = t_q;
  assign saturated       = is_sat(t_q);
 
  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) t_q <= '0;
    // The HANDSHAKE, never valid alone -- Chapter 22.1 §7's rule, unchanged.
    else if (measuring && tx_valid && tx_ready) t_q <= sat_add(t_q, CNT_W'(tx_bytes));
  end
endmodule

import eff_pkg::*;
 
// SYNTHESIZABLE. Replay bytes, counted SEPARATELY so the replay tax is
// isolable (§5: A - B is exactly this quantity). Diagnostic only -- the
// functional replay controller is Chapter 14.4's and is untouched here.
module replay_byte_counter (
  input  logic clk,
  input  logic rst_n,
  input  logic               measuring,
  input  logic               tx_valid,
  input  logic               tx_ready,
  input  logic               is_replay,
  input  logic [BYTES_W-1:0] tx_bytes,
 
  output logic [CNT_W-1:0]   replay_bytes,
  output logic [31:0]        replay_packets,
  output logic               saturated
);
  logic [CNT_W-1:0] r_q; logic [31:0] n_q;
  assign replay_bytes   = r_q;
  assign replay_packets = n_q;
  assign saturated      = is_sat(r_q);
 
  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin r_q <= '0; n_q <= '0; end
    else if (measuring && tx_valid && tx_ready && is_replay) begin
      r_q <= sat_add(r_q, CNT_W'(tx_bytes));
      if (!(&n_q)) n_q <= n_q + 32'd1;
    end
  end
endmodule

import eff_pkg::*;
 
// SYNTHESIZABLE, CONDITIONAL ON INTERFACE VISIBILITY (§1, §7).
// Only instantiate where the controller exposes categorized control
// transmissions. Where it does not, the honest design has NO counter --
// claiming to measure invisible traffic is mutation 16.
module control_byte_counter #(parameter bit HAS_CONTROL_VISIBILITY = 1'b1) (
  input  logic clk,
  input  logic rst_n,
  input  logic               measuring,
  input  logic               ctrl_valid,
  input  logic               ctrl_ready,
  input  logic [BYTES_W-1:0] ctrl_bytes,
 
  output logic [CNT_W-1:0]   control_bytes,
  output logic               control_measured   // 0 => the field is UNKNOWN
);
  logic [CNT_W-1:0] c_q;
  assign control_bytes   = HAS_CONTROL_VISIBILITY ? c_q : '0;
  assign control_measured = HAS_CONTROL_VISIBILITY;
 
  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) c_q <= '0;
    else if (HAS_CONTROL_VISIBILITY && measuring && ctrl_valid && ctrl_ready)
      c_q <= sat_add(c_q, CNT_W'(ctrl_bytes));
  end
endmodule

import eff_pkg::*;
 
// SYNTHESIZABLE. Atomic snapshot of the whole window (§5, §10).
// ALL counters are published from ONE cycle. A ratio assembled from two
// different windows is meaningless, and it is the easiest bug to commit
// when counters are read one register at a time.
module efficiency_snapshot #(parameter basis_e BASIS = BASIS_NONE) (
  input  logic clk,
  input  logic rst_n,
  input  logic window_close,
 
  input  logic [CNT_W-1:0] unique_payload,
  input  logic [CNT_W-1:0] transport_bytes,
  input  logic [CNT_W-1:0] replay_bytes,
  input  logic [CNT_W-1:0] control_bytes,
  input  logic [CNT_W-1:0] active_cycles,      // 22.1's denominator, kept apart (§8)
  input  logic             control_measured,
  input  logic             replay_seen,
  input  logic             any_saturated,
 
  output logic             snap_valid,
  output logic [CNT_W-1:0] snap_unique,
  output logic [CNT_W-1:0] snap_transport,
  output logic [CNT_W-1:0] snap_replay,
  output logic [CNT_W-1:0] snap_control,
  output logic [CNT_W-1:0] snap_active,
  output logic             snap_control_valid,
  output logic             snap_replay_seen,
  output logic             snap_saturated,
  output basis_e           snap_basis
);
  assign snap_basis = BASIS;
 
  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      snap_valid<=1'b0; snap_unique<='0; snap_transport<='0; snap_replay<='0;
      snap_control<='0; snap_active<='0; snap_control_valid<=1'b0;
      snap_replay_seen<=1'b0; snap_saturated<=1'b0;
    end else begin
      snap_valid <= window_close;
      if (window_close) begin
        // ONE cycle, ALL fields. This is the whole point of the block.
        snap_unique        <= unique_payload;
        snap_transport     <= transport_bytes;
        snap_replay        <= replay_bytes;
        snap_control       <= control_bytes;
        snap_active        <= active_cycles;
        snap_control_valid <= control_measured;
        snap_replay_seen   <= replay_seen;
        snap_saturated     <= any_saturated;
      end
    end
  end
endmodule

import eff_pkg::*;
 
// VERIFICATION-ONLY. Sanity monitor for the ratios software will form.
// Payload can never exceed the transport that carried it, and replay
// bytes are a SUBSET of transport -- not an addition to it.
module efficiency_sanity_monitor (
  input logic [CNT_W-1:0] snap_unique,
  input logic [CNT_W-1:0] snap_transport,
  input logic [CNT_W-1:0] snap_replay,
  input logic             snap_saturated,
  output logic            err_payload_exceeds_transport,
  output logic            err_replay_exceeds_transport
);
  always_comb begin
    err_payload_exceeds_transport =
      !snap_saturated && (snap_unique > snap_transport);
    err_replay_exceeds_transport  =
      !snap_saturated && (snap_replay > snap_transport);
  end
endmodule

// ==================================================================
// NUMERATOR (§6) -- unique payload, once.
// ==================================================================
 
// P1: unique payload advances only on an accepted, NON-replay TLP.
property p_unique_on_first_delivery;
  @(posedge clk) disable iff (!rst_n)
    (unique_payload != $past(unique_payload)) |->
      $past(measuring && tlp_accepted && !is_replay);
endproperty
 
// P2: a replay NEVER advances unique payload. §13 Model 9: a counter that
// breaks this reports 94.12% at every replay rate.
property p_replay_adds_no_payload;
  @(posedge clk) disable iff (!rst_n)
    (measuring && tlp_accepted && is_replay) |=> $stable(unique_payload);
endproperty
 
// P3: the increment is exactly the payload accepted.
property p_unique_increment_exact;
  @(posedge clk) disable iff (!rst_n)
    (measuring && tlp_accepted && !is_replay && !saturated) |=>
      (unique_payload == $past(unique_payload) + CNT_W'($past(payload_bytes)));
endproperty
 
// P4: a replay in the window is REPORTED stickily -- the window is
// qualified even if the replay bytes are small.
property p_replay_seen_sticky;
  @(posedge clk) disable iff (!rst_n)
    replay_seen |=> replay_seen;
endproperty
 
// ==================================================================
// DENOMINATOR (§5) -- transport, on the handshake.
// ==================================================================
 
// P5: transport advances only on an accepted transmission.
property p_transport_on_handshake;
  @(posedge clk) disable iff (!rst_n)
    (transport_bytes != $past(transport_bytes)) |->
      $past(measuring && tx_valid && tx_ready);
endproperty
 
// P6: an offered but unaccepted packet adds nothing (Chapter 22.1 §7).
property p_no_transport_on_stall;
  @(posedge clk) disable iff (!rst_n)
    (tx_valid && !tx_ready) |=> $stable(transport_bytes);
endproperty
 
// P7: transport counts replays TOO -- that asymmetry against P2 is the
// entire mechanism by which replay shows up as efficiency loss.
property p_transport_includes_replay;
  @(posedge clk) disable iff (!rst_n)
    (measuring && tx_valid && tx_ready && is_replay && !saturated) |=>
      (transport_bytes != $past(transport_bytes));
endproperty
 
// P8: replay bytes are a SUBSET of transport, never an addition.
property p_replay_subset_of_transport;
  @(posedge clk) disable iff (!rst_n)
    (!saturated) |-> (replay_bytes <= transport_bytes);
endproperty
 
// P9: control bytes accumulate independently of TLP transport.
property p_control_independent;
  @(posedge clk) disable iff (!rst_n)
    (ctrl_valid && ctrl_ready && measuring && control_measured) |=>
      (control_bytes != $past(control_bytes));
endproperty
 
// ==================================================================
// COUNTER HYGIENE.
// ==================================================================
 
// P10: counters saturate, never wrap.
property p_no_wrap;
  @(posedge clk) disable iff (!rst_n)
    (transport_bytes == {CNT_W{1'b1}}) |=> (transport_bytes == {CNT_W{1'b1}});
endproperty
 
// P11: saturation invalidates the window explicitly, so software discards
// it rather than computing a ratio from a truncated denominator.
property p_saturation_flagged;
  @(posedge clk) disable iff (!rst_n)
    (snap_valid && $past(any_saturated)) |-> snap_saturated;
endproperty
 
// P12: payload can never exceed the transport that carried it. This is
// the cheapest possible check that the two counters share a window.
property p_payload_le_transport;
  @(posedge clk) disable iff (!rst_n)
    (snap_valid && !snap_saturated) |-> (snap_unique <= snap_transport);
endproperty
 
// ==================================================================
// SNAPSHOT ATOMICITY (§5) -- one window, one set of numbers.
// ==================================================================
 
// P13: every published field comes from the SAME cycle.
property p_snapshot_atomic;
  @(posedge clk) disable iff (!rst_n)
    snap_valid |-> ((snap_unique    == $past(unique_payload))
                 && (snap_transport == $past(transport_bytes))
                 && (snap_replay    == $past(replay_bytes))
                 && (snap_active    == $past(active_cycles)));
endproperty
 
// P14: exactly one snapshot per window close -- no double publication.
property p_one_snapshot_per_close;
  @(posedge clk) disable iff (!rst_n)
    snap_valid |-> $past(window_close);
endproperty
 
// P15: a boundary-cycle transfer is inside the CLOSING window (§12).
property p_boundary_transfer_in_closing_window;
  @(posedge clk) disable iff (!rst_n)
    (window_close && tx_valid && tx_ready) |=>
      (snap_transport >= CNT_W'($past(tx_bytes)));
endproperty
 
// P16: the unmeasured control field is marked UNKNOWN, not zero-as-fact.
// Reporting an unobservable quantity as 0 is mutation 16.
property p_control_validity_declared;
  @(posedge clk) disable iff (!rst_n)
    (snap_valid && !snap_control_valid) |-> (snap_control == '0);
endproperty
 
// P17: reset publishes nothing and clears every accumulator.
property p_reset_clears_window;
  @(posedge clk)
    (!rst_n) |=> (!snap_valid && (unique_payload == '0) && (transport_bytes == '0));
endproperty
 
// P18: a window with no traffic yields a zero denominator -- defined, and
// the consumer's problem, not a fabricated 100%.
property p_zero_traffic_defined;
  @(posedge clk) disable iff (!rst_n)
    (snap_valid && (snap_transport == '0)) |-> (snap_unique == '0);
endproperty
 
// P19: the generation basis travels WITH the snapshot, so a consumer
// cannot apply the Gen1-Gen5 model to a Gen6 window (§9).
property p_basis_accompanies_snapshot;
  @(posedge clk) disable iff (!rst_n)
    snap_valid |-> (snap_basis inside {BASIS_LINECODE, BASIS_FLIT, BASIS_NONE});
endproperty
 
// P20: the monitor never drives the transmit interface.
property p_monitor_does_not_drive;
  @(posedge clk) disable iff (!rst_n)
    $stable({tx_valid, tx_ready}) or !$stable({transport_bytes, unique_payload});
endproperty