Added getters.

Author: LarsAsplund

vunit/vhdl/verification_components/src/axi_stream_master.vhd

@@ -14,6 +14,7 @@ use work.axi_stream_pkg.all;
 use work.axi_stream_private_pkg.all;
 use work.com_pkg.net;
 use work.com_pkg.receive;
+use work.com_pkg.reply;
 use work.com_types_pkg.all;
 use work.id_pkg.all;
 use work.integer_vector_ptr_pkg.all;
@@ -72,7 +73,9 @@ begin
       msg_type = push_axi_stream_msg or
       msg_type = wait_for_time_msg or
       msg_type = set_inactive_axi_stream_policy_msg or
-      msg_type = set_stall_config_msg then
+      msg_type = get_inactive_axi_stream_policy_msg or
+      msg_type = set_stall_config_msg or
+      msg_type = get_stall_config_msg then
 
       push(message_queue, request_msg);
 
@@ -88,11 +91,13 @@ begin
 
   bus_process : process
     variable msg : msg_t;
+    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;
@@ -210,10 +215,23 @@ begin
             set_inactive_axi_stream_policy(master, inactive_bus_policy, axi_stream_signal);
             inactive_axi_stream_policy := get_inactive_axi_stream_policy(master);
 
+          elsif msg_type = get_inactive_axi_stream_policy_msg then
+            reply_msg := new_msg(get_inactive_axi_stream_policy_reply_msg);
+            axi_stream_signal := axi_stream_signal_t'val(pop_integer(msg));
+            inactive_bus_policy := inactive_axi_stream_policy(axi_stream_signal);
+            push(reply_msg, inactive_bus_policy_t'pos(inactive_bus_policy));
+            reply(net, msg, reply_msg);
+
           elsif msg_type = set_stall_config_msg then
             deallocate(to_integer_vector_ptr(get(master.p_config, p_stall_config_idx)));
             set(master.p_config, p_stall_config_idx, to_integer(pop_integer_vector_ptr_ref(msg)));
 
+          elsif msg_type = get_stall_config_msg then
+            reply_msg := new_msg(get_stall_config_reply_msg);
+            stall_config := to_integer_vector_ptr(get(master.p_config, p_stall_config_idx));
+            push(reply_msg, stall_config);
+            reply(net, msg, reply_msg);
+
           else
             unexpected_msg_type(msg_type);
           end if;

vunit/vhdl/verification_components/src/axi_stream_pkg.vhd

@@ -246,11 +246,21 @@ package axi_stream_pkg is
     master : axi_stream_master_t;
     stall_config : stall_config_t
   );
+  procedure get_stall_config(
+    signal net : inout network_t;
+    master : axi_stream_master_t;
+    stall_config : out stall_config_t
+  );
   procedure set_stall_config(
     signal net : inout network_t;
     slave : axi_stream_slave_t;
     stall_config : stall_config_t
   );
+  procedure get_stall_config(
+    signal net : inout network_t;
+    slave : axi_stream_slave_t;
+    stall_config : out stall_config_t
+  );
 
   procedure set_inactive_axi_stream_policy(
     signal net : inout network_t;
@@ -259,12 +269,26 @@ package axi_stream_pkg is
     axi_stream_signal : axi_stream_signal_t := all_signals
   );
 
+  procedure get_inactive_axi_stream_policy(
+    signal net : inout network_t;
+    master : axi_stream_master_t;
+    inactive_policy : out inactive_bus_policy_t;
+    axi_stream_signal : axi_stream_signal_t range tdata to tuser
+  );
+
+
   constant push_axi_stream_msg : msg_type_t := new_msg_type("push axi stream");
   constant pop_axi_stream_msg : msg_type_t := new_msg_type("pop axi stream");
   constant check_axi_stream_msg : msg_type_t := new_msg_type("check axi stream");
   constant axi_stream_transaction_msg : msg_type_t := new_msg_type("axi stream transaction");
   constant set_inactive_axi_stream_policy_msg : msg_type_t := new_msg_type("set inactive axi stream policy");
+  constant get_inactive_axi_stream_policy_msg : msg_type_t := new_msg_type("get inactive axi stream policy");
+  constant get_inactive_axi_stream_policy_reply_msg : msg_type_t := new_msg_type(
+    "get inactive axi stream policy reply"
+  );
   constant set_stall_config_msg : msg_type_t := new_msg_type("set stall config");
+  constant get_stall_config_msg : msg_type_t := new_msg_type("get stall config");
+  constant get_stall_config_reply_msg : msg_type_t := new_msg_type("get stall config reply");
 
   alias axi_stream_reference_t is msg_t;
 
@@ -378,6 +402,7 @@ package axi_stream_pkg is
   -- Private
   constant p_stall_config_idx : natural := 0;
   constant p_interactive_policy_idx : natural := 1;
+  impure function p_to_stall_config(vec : integer_vector_ptr_t) return stall_config_t;
 
 end package;
 
@@ -944,6 +969,20 @@ package body axi_stream_pkg is
     end loop;
   end;
 
+  procedure get_inactive_axi_stream_policy(
+    signal net : inout network_t;
+    master : axi_stream_master_t;
+    inactive_policy : out inactive_bus_policy_t;
+    axi_stream_signal : axi_stream_signal_t range tdata to tuser
+  ) is
+    variable request_msg : msg_t := new_msg(get_inactive_axi_stream_policy_msg);
+    variable reply_msg : msg_t;
+  begin
+    push(request_msg, axi_stream_signal_t'pos(axi_stream_signal));
+    request(net, master.p_actor, request_msg, reply_msg);
+    inactive_policy := inactive_bus_policy_t'val(pop_integer(reply_msg));
+  end;
+
   procedure set_stall_config(
     signal net : inout network_t;
     master : axi_stream_master_t;
@@ -956,6 +995,28 @@ package body axi_stream_pkg is
     send(net, master.p_actor, msg);
   end;
 
+  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);
+
+    return stall_config;
+  end;
+
+  procedure get_stall_config(
+    signal net : inout network_t;
+    master : axi_stream_master_t;
+    stall_config : out stall_config_t
+  ) is
+    variable request_msg : msg_t := new_msg(get_stall_config_msg);
+    variable reply_msg : msg_t;
+  begin
+    request(net, master.p_actor, request_msg, reply_msg);
+    stall_config := p_to_stall_config(pop_integer_vector_ptr_ref(reply_msg));
+  end;
+
   procedure set_stall_config(
     signal net : inout network_t;
     slave : axi_stream_slave_t;
@@ -968,6 +1029,18 @@ package body axi_stream_pkg is
     send(net, slave.p_actor, msg);
   end;
 
+ procedure get_stall_config(
+    signal net : inout network_t;
+    slave : axi_stream_slave_t;
+    stall_config : out stall_config_t
+  ) is
+    variable request_msg : msg_t := new_msg(get_stall_config_msg);
+    variable reply_msg : msg_t;
+  begin
+    request(net, slave.p_actor, request_msg, reply_msg);
+    stall_config := p_to_stall_config(pop_integer_vector_ptr_ref(reply_msg));
+  end;
+
   procedure push_axi_stream_transaction(msg : msg_t; axi_stream_transaction : axi_stream_transaction_t) is
   begin
     push_std_ulogic_vector(msg, axi_stream_transaction.tdata);

vunit/vhdl/verification_components/src/axi_stream_private_pkg.vhd

@@ -84,23 +84,13 @@ package body axi_stream_private_pkg is
     return to_inactive_axi_stream_policy(to_integer_vector_ptr(get(master.p_config, p_interactive_policy_idx)));
   end;
 
-  impure function 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);
-
-    return stall_config;
-  end;
-
   impure function get_stall_config(master : axi_stream_master_t) return stall_config_t is
   begin
-    return to_stall_config(to_integer_vector_ptr(get(master.p_config, p_stall_config_idx)));
+    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 to_stall_config(to_integer_vector_ptr(get(slave.p_config, p_stall_config_idx)));
+    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_slave.vhd

@@ -66,7 +66,8 @@ begin
       msg_type = pop_axi_stream_msg or
       msg_type = check_axi_stream_msg or
       msg_type = wait_for_time_msg or
-      msg_type = set_stall_config_msg then
+      msg_type = set_stall_config_msg or
+      msg_type = get_stall_config_msg  then
 
       push(message_queue, request_msg);
 
@@ -111,6 +112,7 @@ begin
     variable expected_tdata : std_logic_vector(tdata'range);
     variable mismatch : boolean;
     variable tstrb_resolved : std_logic_vector(tstrb'range);
+    variable stall_config : integer_vector_ptr_t;
   begin
     rnd.InitSeed(rnd'instance_name);
     loop
@@ -181,6 +183,12 @@ begin
           deallocate(to_integer_vector_ptr(get(slave.p_config, p_stall_config_idx)));
           set(slave.p_config, p_stall_config_idx, to_integer(pop_integer_vector_ptr_ref(msg)));
 
+        elsif msg_type = get_stall_config_msg then
+          reply_msg := new_msg(get_stall_config_reply_msg);
+          stall_config := to_integer_vector_ptr(get(slave.p_config, p_stall_config_idx));
+          push(reply_msg, stall_config);
+          reply(net, msg, reply_msg);
+
         else
           unexpected_msg_type(msg_type);
         end if;

vunit/vhdl/verification_components/test/tb_axi_stream.vhd

@@ -128,8 +128,10 @@ begin
     variable mock_logger : logger_t;
     variable rnd : RandomPtype;
     variable stall_config : stall_config_t;
+    variable stall_config_read_back : stall_config_t;
     variable stall_probability_percent : natural;
     variable previous_inactive_policy : inactive_bus_policy_t := 'X';
+    variable inactive_policy_read_back : inactive_bus_policy_t;
     variable loop_count : natural := 0;
 
     impure function select_policy(
@@ -686,11 +688,17 @@ begin
       wait until rising_edge(aclk);
       stall_probability_percent := 30;
       stall_config := new_stall_config(real(stall_probability_percent) / 100.0, min_stall_cycles, max_stall_cycles);
+
       if running_test_case = "test random stall on master" then
         set_stall_config(net, master_axi_stream, stall_config);
+        get_stall_config(net, master_axi_stream, stall_config_read_back);
       else
         set_stall_config(net, slave_axi_stream, stall_config);
+        get_stall_config(net, slave_axi_stream, stall_config_read_back);
       end if;
+      check_equal(stall_config_read_back.stall_probability, stall_config.stall_probability, max_diff => 0.0001);
+      check_equal(stall_config_read_back.min_stall_cycles, stall_config.min_stall_cycles);
+      check_equal(stall_config_read_back.max_stall_cycles, stall_config.max_stall_cycles);
       for i in 0 to 100 loop
         pop_stream(net, slave_stream, reference);
         push(reference_queue, reference);
@@ -772,6 +780,8 @@ begin
       for inactive_policy in inactive_bus_policy_t'left to inactive_bus_policy_t'right loop
         for axi_stream_signal in work.axi_stream_pkg.tuser downto work.axi_stream_pkg.tdata loop
           set_inactive_axi_stream_policy(net, master_axi_stream, inactive_policy, axi_stream_signal);
+          get_inactive_axi_stream_policy(net, master_axi_stream, inactive_policy_read_back, axi_stream_signal);
+          check(inactive_policy_read_back = inactive_policy);
 
           axi_stream_transaction := (
             tdata => x"99", tlast => true, tkeep => "1", tstrb => "1",
@@ -896,7 +906,9 @@ begin
 
   axi_stream_master_inst : entity work.axi_stream_master
     generic map(
-      master => master_axi_stream)
+      master => master_axi_stream,
+      drive_invalid => false
+    )
     port map(
       aclk     => aclk,
       areset_n => areset_n,

vunit/vhdl/verification_components/test/tb_axi_stream_protocol_checker.vhd

@@ -255,7 +255,8 @@ begin
 
     elsif run("Test failing check of that tlast remains stable when tvalid is asserted and tready is low") then
       fail_stable_test(
-        d(0) => tlast, rule_name => ":rule 2", signal_name => "tlast", zero_string => "1", one_string => "0", zero_value => '1', one_value => '0'
+        d(0) => tlast, rule_name => ":rule 2", signal_name => "tlast", zero_string => "1",
+        one_string => "0", zero_value => '1', one_value => '0'
       );
 
     elsif run("Test passing check of that tvalid remains asserted until tready is high") then