Increase coverage of TileLink traffic generator

Signed-off-by: Daniel Bates <Daniel.Bates@cl.cam.ac.uk>

Author: db434

test/tilelink/rtl/tl_assert.sv

@@ -92,38 +92,9 @@ module tl_assert import tl_pkg::*; #(
 
   // Copy input TileLink fields to local variables.
   `TL_DECLARE(DataWidth, AddrWidth, SourceWidth, SinkWidth, tl);
-  // `TL_BIND_TAP_PORT(tl, tl);
 
   // Latch the previous input so we can look at transitions.
   `TL_DECLARE(DataWidth, AddrWidth, SourceWidth, SinkWidth, prev_tl);
-  `TL_DECLARE(DataWidth, AddrWidth, SourceWidth, SinkWidth, prev_accepted);
-  `TL_DECLARE(DataWidth, AddrWidth, SourceWidth, SinkWidth, prev_declined);
-
-  // Capture the last accepted/declined beats from a named channel.
-  // TODO: this is for functional coverage. Not tested yet.
-  // TODO: focus on non-continuous matches.
-  // TODO: accepted being valid doesn't make declined invalid.
-  `define COVERAGE_CAPTURE(CHANNEL)                                      \
-    if (tl_``CHANNEL``_valid) begin                             \
-      prev_accepted_``CHANNEL``_valid <= tl_``CHANNEL``_ready;  \
-      prev_declined_``CHANNEL``_valid <= !tl_``CHANNEL``_ready; \
-                                                                \
-      if (tl_``CHANNEL``_ready) begin                           \
-        prev_accepted_``CHANNEL`` <= tl_``CHANNEL``;            \
-      end else begin                                            \
-        prev_declined_``CHANNEL`` <= tl_``CHANNEL``;            \
-      end                                                       \
-    end
-
-  always_ff @(posedge clk_i) begin
-    `COVERAGE_CAPTURE(a);
-    `COVERAGE_CAPTURE(b);
-    `COVERAGE_CAPTURE(c);
-    `COVERAGE_CAPTURE(d);
-    `COVERAGE_CAPTURE(e);
-  end
-
-  `undef COVERAGE_CAPTURE
 
   ////////////////////////////////////
   // Keep track of pending requests //
@@ -883,15 +854,13 @@ module tl_assert import tl_pkg::*; #(
     `S_COVER(``CHANNEL``BackToBack_C, ``CHANNEL``BackToBack_S)
 
   // A valid signal is deasserted before it is accepted by the recipient.
-  // TODO: check that this is doing what we expect
   `define VALID_NOT_ACCEPTED(CHANNEL) \
     `SEQUENCE(``CHANNEL``ValidNotAccepted_S, \
       prev_tl_``CHANNEL``_valid && !prev_tl_``CHANNEL``_ready && !tl_``CHANNEL``_valid \
     ); \
     `S_COVER(``CHANNEL``ValidNotAccepted_C, ``CHANNEL``ValidNotAccepted_S)
 
   // Content is changed without being accepted.
-  // TODO: check that this is doing what we expect
   `define CHANGED_WITHOUT_ACCEPTED(CHANNEL, NAME) \
     `SEQUENCE(``CHANNEL``_``NAME``ChangedNotAccepted_S, \
       tl_``CHANNEL``_valid && prev_declined_``CHANNEL``_valid && \
@@ -997,9 +966,9 @@ module tl_assert import tl_pkg::*; #(
 
   // TODO: current macro can't accept multibit properties.
   if (Protocol == TL_C) begin : gen_tlc_simultaneous_cov
-    `S_COVER(tlc_simultaneous, tlc_accepted);
+    //`S_COVER(tlc_simultaneous, tlc_accepted);
   end else begin : gen_tluh_simultaneous_cov
-    `S_COVER(tluh_simultaneous, tluh_accepted);
+    //`S_COVER(tluh_simultaneous, tluh_accepted);
   end
 
 endmodule

test/tilelink/rtl/tl_wrapper.sv

@@ -7,7 +7,7 @@ module tl_wrapper #(
     parameter int unsigned DataWidth = 64,
     parameter int unsigned HostSourceWidth = 3,
     parameter int unsigned DeviceSourceWidth = 7, // HSW + 2 (TL-UH) + 2 (TL-UL)
-    parameter int unsigned SinkWidth = 2,
+    parameter int unsigned SinkWidth = 3,
     parameter int unsigned MaxSize = 5
 ) (
   // Clock and reset
@@ -116,7 +116,7 @@ module tl_wrapper #(
 
 // TileLink structure:
 //
-//  host0 (TL-C)              host1 (TL-UH)             host2 (TL-UL)
+//  host0 (TL-C)              host1 (TL-C)              host2 (TL-UL)
 //       |_________________________|_________________________|
 //                                 | (host_tl)
 //                             socket_m1
@@ -142,12 +142,16 @@ module tl_wrapper #(
     .MaxSize     (MaxSize),
 
     // TODO: Not 100% sure of the difference between these two
-    .NumCachedHosts (1),
-    .NumCachedLinks (1),
-
-    .NumSourceRange (2),  // Excluding default source 0
-    .SourceBase ({{{HostSourceWidth-2{1'b0}}, 2'd1}, {{HostSourceWidth-2{1'b0}}, 2'd2}}),
-    .SourceMask ({{HostSourceWidth{1'b0}}, {HostSourceWidth{1'b0}}}),
+    .NumCachedHosts (2),
+    .NumCachedLinks (2),
+
+    // Routing table:
+    //   Source IDs 0-3: host 0 (default)
+    //   Source IDs 4-5: host 1
+    //   Source IDs 6-7: host 2
+    .NumSourceRange (2),  // Excludes default host
+    .SourceBase ({3'd4, 3'd6}),       //
+    .SourceMask ({3'b001, 3'b001}),   // TODO: ensure this matches HostSourceWidth
     .SourceLink ({2'd1, 2'd2})
   ) socket_m1 (
     .clk_i,
@@ -163,13 +167,18 @@ module tl_wrapper #(
     .SinkWidth   (SinkWidth),
     .MaxSize     (MaxSize),
     .NumLinks    (3),
-    .NumAddressRange (2),  // Excluding default sink 0
+
+    // Routing tables:
+    //   Addresses 0x0xxxxxxx, sink IDs 0-3: device 0 (default)
+    //   Addresses 0x1xxxxxxx, sink IDs 4-5: device 1
+    //   Addresses 0x2xxxxxxx, sink IDs 6-7: device 2
+    .NumAddressRange (2),  // Excludes default device 0
     .AddressBase ({56'h10000000, 56'h20000000}),
     .AddressMask ({56'h0fffffff, 56'h0fffffff}),
     .AddressLink ({2'd        1, 2'd        2}),
     .NumSinkRange (2),
-    .SinkBase ({{{SinkWidth-2{1'b0}}, 2'd1}, {{SinkWidth-2{1'b0}}, 2'd2}}),
-    .SinkMask ({{SinkWidth{1'b0}}, {SinkWidth{1'b0}}}),
+    .SinkBase ({3'd4, 3'd6}),       //
+    .SinkMask ({3'b001, 3'b001}),   // TODO: ensure this matches SinkWidth
     .SinkLink ({2'd1, 2'd2})
   ) socket_1n (
     .clk_i,

test/tilelink/src/tl_channels.cc

@@ -127,7 +127,10 @@ void TileLinkSenderB::queue_request(bool randomise,
 
   tl_message<tl_b> request(*this, randomise, requirements);
 
-  // Send Probe requests out to all masters.
+  // Prepare to send Probe requests out to all masters.
+  // Don't send anything yet though - first need to confirm that transaction
+  // IDs are available.
+  vector<tl_message<tl_b>> pending;
   for (int i=0; i<the_sim->num_hosts(); i++) {
     auto& host = the_sim->host(i);
     if (host.protocol != TL_C)
@@ -137,6 +140,16 @@ void TileLinkSenderB::queue_request(bool randomise,
     //       associated with the host, or just the index of the host.
     request.header.source = host.c.get_routing_id(randomise);
 
+    int id = get_b_id(request.header.source, request.header.address);
+
+    if (this->transaction_id_available(id))
+      pending.push_back(request);
+    else
+      return; // Could try another source/address, but this is simpler.
+  }
+
+  // Send requests now that everything is confirmed safe.
+  for (auto request : pending) {
     // We only support a subset of B requests, which are all single beats.
     this->to_send.push(request);
     this->start_transaction(get_b_id(request.header.source, request.header.address));
@@ -250,12 +263,28 @@ extern bool requires_response(tl_d_op_e opcode);
 void TileLinkSenderD::respond(bool randomise, tl_a& request) {
   tl_message<tl_d> response(*this, request, randomise);
   this->to_send.push(response);
+
+  // ArithmeticData and LogicalData are multibeat requests, but we respond to
+  // each beat individually, so we need to lock the output buffer until we
+  // have responded to all beats.
+  if (request.opcode == ArithmeticData || request.opcode == LogicalData) {
+    // First beat.
+    if (beats_remaining == 0)
+      beats_remaining = std::max(1, (1 << request.size) / (this->bit_width() / 8));
+    
+    beats_remaining--;
+
+    lock_output_buffer = (beats_remaining > 0);
+  }
+  else
+    assert(!lock_output_buffer);
 
   if (requires_response(response.header.opcode))
     this->start_transaction(response.header.sink);
 }
 
 void TileLinkSenderD::respond(bool randomise, tl_c& request) {
+  assert(!lock_output_buffer);
   tl_message<tl_d> response(*this, request, randomise);
   this->to_send.push(response);
 
@@ -283,6 +312,11 @@ void TileLinkSenderD::respond() {
     }
   }
 
+  // The output buffer may become locked if only a partial response has been
+  // queued so far.
+  if (lock_output_buffer)
+    return;
+
   int num_c_requests = c_requests.size();
   for (int i=0; i<num_c_requests; i++) {
     auto request = c_requests.front();