Refactoring

Author: LarsAsplund

vunit/vhdl/verification_components/src/axi_stream_master.vhd

@@ -94,18 +94,51 @@ begin
     variable reply_msg : msg_t;
     variable msg_type : msg_type_t;
     variable rnd : RandomPType;
-    variable inactive_axi_stream_policy : inactive_axi_stream_policy_t := get_inactive_axi_stream_policy(master);
     variable inactive_bus_policy : inactive_bus_policy_t;
     variable axi_stream_signal : axi_stream_signal_t;
     variable stall_config : integer_vector_ptr_t;
 
-    procedure probability_stall_axi_stream(
-      signal aclk : in std_logic;
-      axi_stream  : in axi_stream_master_t;
-      rnd         : inout RandomPType) is
+    impure function get_inactive_axi_stream_policy(master : axi_stream_master_t) return inactive_axi_stream_policy_t is
+      impure function to_inactive_axi_stream_policy(vec : integer_vector_ptr_t) return inactive_axi_stream_policy_t is
+        variable inactive_policy : inactive_axi_stream_policy_t;
+      begin
+        for sig in inactive_policy'range loop
+          inactive_policy(sig) := inactive_bus_policy_t'val(get(vec, axi_stream_signal_t'pos(sig)));
+        end loop;
+
+        return inactive_policy;
+      end;
     begin
-      probability_stall_axi_stream(aclk, get_stall_config(axi_stream), rnd);
-    end procedure;
+      return to_inactive_axi_stream_policy(to_integer_vector_ptr(get(master.p_config, p_inactive_policy_idx)));
+    end;
+
+    variable inactive_axi_stream_policy : inactive_axi_stream_policy_t := get_inactive_axi_stream_policy(master);
+
+    procedure set_inactive_axi_stream_policy(
+      master : axi_stream_master_t;
+      inactive_policy : inactive_bus_policy_t;
+      axi_stream_signal : axi_stream_signal_t
+    ) is
+      variable start, stop : axi_stream_signal_t := axi_stream_signal;
+    begin
+      if axi_stream_signal = all_signals then
+        start := work.axi_stream_pkg.tdata;
+        stop := work.axi_stream_pkg.tuser;
+      end if;
+
+      for sig in start to stop loop
+        set(
+          to_integer_vector_ptr(get(master.p_config, p_inactive_policy_idx)),
+          axi_stream_signal_t'pos(sig),
+          inactive_bus_policy_t'pos(inactive_policy)
+        );
+      end loop;
+    end;
+
+    impure function get_stall_config(master : axi_stream_master_t) return stall_config_t is
+    begin
+      return p_to_stall_config(to_integer_vector_ptr(get(master.p_config, p_stall_config_idx)));
+    end;
 
     procedure drive_inactive(
       signal l_tdata : out std_logic_vector(data_length(master)-1 downto 0);
@@ -159,7 +192,7 @@ begin
     rnd.InitSeed(rnd'instance_name);
     loop
       drive_inactive(tdata, tlast, tkeep, tstrb, tid, tdest, tuser);
-      if (areset_n = '0') then
+      if areset_n = '0' then
         tvalid <= '0';
         wait until areset_n = '1' and rising_edge(aclk);
       else
@@ -182,7 +215,7 @@ begin
 
           elsif msg_type = stream_push_msg or msg_type = push_axi_stream_msg then
             -- stall according to probability configuration
-            probability_stall_axi_stream(aclk, master, rnd);
+            probability_stall_axi_stream(aclk, get_stall_config(master), rnd);
 
             tvalid <= '1';
             tdata <= pop_std_ulogic_vector(msg);
@@ -194,11 +227,7 @@ begin
               tdest <= pop_std_ulogic_vector(msg);
               tuser <= pop_std_ulogic_vector(msg);
             else
-              if pop_boolean(msg) then
-                tlast <= '1';
-              else
-                tlast <= '0';
-              end if;
+              tlast <= '1' when pop_boolean(msg) else '0';
               tkeep <= (others => '1');
               tstrb <= (others => '1');
               tid   <= (others => '0');
@@ -207,7 +236,6 @@ begin
             end if;
             wait until ((tvalid and tready) = '1' or areset_n = '0') and rising_edge(aclk);
             tvalid <= '0';
-            drive_inactive(tdata, tlast, tkeep, tstrb, tid, tdest, tuser);
 
           elsif msg_type = set_inactive_axi_stream_policy_msg then
             inactive_bus_policy := inactive_bus_policy_t'val(pop_integer(msg));
@@ -283,12 +311,17 @@ begin
   end generate axi_stream_protocol_checker_generate;
 
   deprecation_message : process is
+    impure function default_generics return boolean is
+    begin
+      return drive_invalid and (drive_invalid_val = 'X') and (drive_invalid_val_user = '0');
+    end;
   begin
-    warning_if(
+    error_if(
       master.p_logger,
-      drive_invalid,
-      "The drive_invalid generics have been deprecated. Bus inactivity is now controlled " &
-      "by the inactive_bus_policy parameter to the new_axi_stream_master function."
+      not default_generics,
+      "The drive_invalid generics have been deprecated. Bus inactivity is now controlled " & LF &
+      "by the inactive_bus_policy parameter to the new_axi_stream_master function. Remove generics " & LF &
+      "assignments and use the inactive_bus_policy parameter to avoid this error."
     );
 
     wait;

vunit/vhdl/verification_components/src/axi_stream_monitor.vhd

@@ -8,6 +8,7 @@ library ieee;
 use ieee.std_logic_1164.all;
 
 use work.axi_stream_pkg.all;
+use work.axi_stream_private_pkg.all;
 use work.com_pkg.net;
 use work.com_pkg.publish;
 use work.com_types_pkg.msg_t;
@@ -55,7 +56,7 @@ begin
       );
     end if;
 
-    tstrb_resolved := tkeep when is_u(tstrb) else tstrb;
+    tstrb_resolved := resolve_tstrb(tkeep, tstrb);
     axi_stream_transaction := (
       tdata => tdata,
       tlast => tlast = '1',

vunit/vhdl/verification_components/src/axi_stream_pkg.vhd

@@ -397,16 +397,19 @@ package axi_stream_pkg is
     max_stall_cycles  : natural
   ) return stall_config_t;
 
-  function is_u(value : std_ulogic_vector) return boolean;
-
   -- Private
   constant p_stall_config_idx : natural := 0;
-  constant p_interactive_policy_idx : natural := 1;
+  constant p_inactive_policy_idx : natural := 1;
   impure function p_to_stall_config(vec : integer_vector_ptr_t) return stall_config_t;
 
 end package;
 
 package body axi_stream_pkg is
+  constant single_precision_mantissa_length : natural := 23;
+  constant stall_probability_idx : natural := 0;
+  constant min_stall_idx : natural := 1;
+  constant max_stall_idx : natural := 2;
+
   impure function get_valid_monitor(
     data_length      : natural;
     id_length        : natural  := 0;
@@ -472,19 +475,19 @@ package body axi_stream_pkg is
         axi_stream_checker,
         protocol_checker.p_id_length,
         id_length,
-        "ID length of monitor doesn't match that of the " & parent_component
+        "ID length of protocol checker doesn't match that of the " & parent_component
       );
       check_equal(
         axi_stream_checker,
         protocol_checker.p_dest_length,
         dest_length,
-        "Dest length of monitor doesn't match that of the " & parent_component
+        "Dest length of protocol checker doesn't match that of the " & parent_component
       );
       check_equal(
         axi_stream_checker,
         protocol_checker.p_user_length,
         user_length,
-        "User length of monitor doesn't match that of the " & parent_component
+        "User length of protocol checker doesn't match that of the " & parent_component
       );
       return protocol_checker;
     end if;
@@ -495,18 +498,17 @@ package body axi_stream_pkg is
   begin
     -- Since values are in the 0 - 1 range, we can have the full resolution of the mantissa fit within
     -- an integer if reals are implemented as single-precision floats.
-    set(result, 0, integer(stall_config.stall_probability * (2.0 ** 23)));
-    set(result, 1, stall_config.min_stall_cycles);
-    set(result, 2, stall_config.max_stall_cycles);
+    set(
+      result,
+      stall_probability_idx,
+      integer(stall_config.stall_probability * (2.0 ** single_precision_mantissa_length))
+    );
+    set(result, min_stall_idx, stall_config.min_stall_cycles);
+    set(result, max_stall_idx, stall_config.max_stall_cycles);
 
     return result;
   end;
 
-  procedure set_stall_config(master : axi_stream_master_t; stall_config : stall_config_t) is
-  begin
-    set(master.p_config, p_stall_config_idx, to_integer(to_integer_vector_ptr(stall_config)));
-  end;
-
   impure function to_integer_vector_ptr(inactive_policy : inactive_axi_stream_policy_t) return integer_vector_ptr_t is
     variable result : integer_vector_ptr_t := new_integer_vector_ptr(inactive_policy'length);
   begin
@@ -517,14 +519,6 @@ package body axi_stream_pkg is
     return result;
   end;
 
-  procedure set_inactive_axi_stream_policy(
-    master : axi_stream_master_t;
-    inactive_policy : inactive_axi_stream_policy_t
-  ) is
-  begin
-    set(master.p_config, p_interactive_policy_idx, to_integer(to_integer_vector_ptr(inactive_policy)));
-  end;
-
   impure function new_axi_stream_master(
     data_length      : natural;
     id_length        : natural                       := 0;
@@ -558,20 +552,15 @@ package body axi_stream_pkg is
       p_logger           => logger,
       p_monitor          => p_monitor,
       p_protocol_checker => p_protocol_checker,
-      p_config           => new_integer_vector_ptr(p_interactive_policy_idx + 1)
+      p_config           => new_integer_vector_ptr(p_inactive_policy_idx + 1)
     );
 
-    set_stall_config(handle, stall_config);
-    set_inactive_axi_stream_policy(handle, inactive_policy);
+    set(handle.p_config, p_stall_config_idx, to_integer(to_integer_vector_ptr(stall_config)));
+    set(handle.p_config, p_inactive_policy_idx, to_integer(to_integer_vector_ptr(inactive_policy)));
 
     return handle;
   end;
 
-  procedure set_stall_config(slave : axi_stream_slave_t; stall_config : stall_config_t) is
-  begin
-    set(slave.p_config, p_stall_config_idx, to_integer(to_integer_vector_ptr(stall_config)));
-  end;
-
   impure function new_axi_stream_slave(
     data_length      : natural;
     id_length        : natural                       := 0;
@@ -606,7 +595,7 @@ package body axi_stream_pkg is
       p_protocol_checker => p_protocol_checker,
       p_config => new_integer_vector_ptr(p_stall_config_idx + 1));
 
-    set_stall_config(handle, stall_config);
+    set(handle.p_config, p_stall_config_idx, to_integer(to_integer_vector_ptr(stall_config)));
 
     return handle;
   end;
@@ -998,9 +987,9 @@ package body axi_stream_pkg is
   impure function p_to_stall_config(vec : integer_vector_ptr_t) return stall_config_t is
     variable stall_config : stall_config_t;
   begin
-    stall_config.stall_probability := real(get(vec, 0)) * (2.0 ** (-23));
-    stall_config.min_stall_cycles := get(vec, 1);
-    stall_config.max_stall_cycles := get(vec, 2);
+    stall_config.stall_probability := real(get(vec, stall_probability_idx)) * (2.0 ** (-single_precision_mantissa_length));
+    stall_config.min_stall_cycles := get(vec, min_stall_idx);
+    stall_config.max_stall_cycles := get(vec, max_stall_idx);
 
     return stall_config;
   end;
@@ -1102,15 +1091,4 @@ package body axi_stream_pkg is
     return stall_config;
   end;
 
-  function is_u(value : std_ulogic_vector) return boolean is
-  begin
-    for idx in value'range loop
-      if value(idx) /= 'U' then
-        return false;
-      end if;
-    end loop;
-
-    return true;
-  end;
-
 end package body;

vunit/vhdl/verification_components/src/axi_stream_private_pkg.vhd

@@ -21,16 +21,10 @@ package axi_stream_private_pkg is
     rnd          : inout RandomPType
   );
 
-  procedure set_inactive_axi_stream_policy(
-    master : axi_stream_master_t;
-    inactive_policy : inactive_bus_policy_t;
-    axi_stream_signal : axi_stream_signal_t
-  );
-
-  impure function get_inactive_axi_stream_policy(master : axi_stream_master_t) return inactive_axi_stream_policy_t;
-
-  impure function get_stall_config(master : axi_stream_master_t) return stall_config_t;
-  impure function get_stall_config(slave : axi_stream_slave_t) return stall_config_t;
+  function resolve_tstrb(
+    tkeep : std_logic_vector;
+    tstrb : std_logic_vector
+  ) return std_logic_vector;
 end package;
 
 package body axi_stream_private_pkg is
@@ -48,49 +42,15 @@ package body axi_stream_private_pkg is
     end loop;
   end procedure;
 
-  procedure set_inactive_axi_stream_policy(
-    master : axi_stream_master_t;
-    inactive_policy : inactive_bus_policy_t;
-    axi_stream_signal : axi_stream_signal_t
-  ) is
-    variable start, stop : axi_stream_signal_t := axi_stream_signal;
+  function resolve_tstrb(
+    tkeep : std_logic_vector;
+    tstrb : std_logic_vector
+  ) return std_logic_vector is
   begin
-    if axi_stream_signal = all_signals then
-      start := tdata;
-      stop := tuser;
+    if tstrb = (tstrb'range => 'U') then
+      return tkeep;
+    else
+      return tstrb;
     end if;
-
-    for sig in start to stop loop
-      set(
-        to_integer_vector_ptr(get(master.p_config, p_interactive_policy_idx)),
-        axi_stream_signal_t'pos(sig),
-        inactive_bus_policy_t'pos(inactive_policy)
-      );
-    end loop;
-  end;
-
-  impure function to_inactive_axi_stream_policy(vec : integer_vector_ptr_t) return inactive_axi_stream_policy_t is
-    variable inactive_policy : inactive_axi_stream_policy_t;
-  begin
-    for sig in inactive_policy'range loop
-      inactive_policy(sig) := inactive_bus_policy_t'val(get(vec, axi_stream_signal_t'pos(sig)));
-    end loop;
-
-    return inactive_policy;
-  end;
-
-  impure function get_inactive_axi_stream_policy(master : axi_stream_master_t) return inactive_axi_stream_policy_t is
-  begin
-    return to_inactive_axi_stream_policy(to_integer_vector_ptr(get(master.p_config, p_interactive_policy_idx)));
-  end;
-
-  impure function get_stall_config(master : axi_stream_master_t) return stall_config_t is
-  begin
-    return p_to_stall_config(to_integer_vector_ptr(get(master.p_config, p_stall_config_idx)));
-  end;
-
-  impure function get_stall_config(slave : axi_stream_slave_t) return stall_config_t is
-  begin
-    return p_to_stall_config(to_integer_vector_ptr(get(slave.p_config, p_stall_config_idx)));
   end;
 end package body;

vunit/vhdl/verification_components/src/axi_stream_protocol_checker.vhd

@@ -11,6 +11,7 @@ use ieee.numeric_std_unsigned.all;
 use std.textio.all;
 
 use work.axi_stream_pkg.all;
+use work.axi_stream_private_pkg.all;
 use work.check_pkg.all;
 use work.checker_pkg.all;
 use work.event_common_pkg.is_active;
@@ -91,7 +92,7 @@ architecture a of axi_stream_protocol_checker is
     return ret;
   end function;
 begin
-  tstrb_resolved <= tkeep when is_u(tstrb) else tstrb;
+  tstrb_resolved <= resolve_tstrb(tkeep, tstrb);
   handshake_is_not_x <= '1' when not is_x(tvalid) and not is_x(tready) else '0';
 
   -- AXI4STREAM_ERRM_TDATA_STABLE TDATA remains stable when TVALID is asserted,