library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; library osvvm; -- Utility Library context osvvm.OsvvmContext; use work.rtps_package.all; use work.user_config.all; use work.rtps_config_package.all; use work.rtps_test_package.all; -- This testbench tests the RTPS Message generation of the RTPS Writer (DATA and GAP Generation). -- This testbench covers following: -- * ACKNACK Handling (Request Handling) -- NOTE: Simulated Cache Changes are not necessarily removed on REMOVE_CACHE_CHANGE opcodes for test purposes (Has no effect in Handling) entity L1_rtps_writer_test2 is end entity; architecture testbench of L1_rtps_writer_test2 is -- *CONSTANT DECLARATION* constant MAX_REMOTE_ENDPOINTS : natural := 5; constant MAX_CC : natural := 10; constant NUM_WRITERS : natural := 2; impure function gen_test_config return CONFIG_ARRAY_TYPE is variable ret : CONFIG_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => DEFAULT_WRITER_CONFIG); begin -- vrkdn ret(0).RELIABILITY_QOS := RELIABLE_RELIABILITY_QOS; ret(0).LIVELINESS_QOS := AUTOMATIC_LIVELINESS_QOS; ret(0).DURABILITY_QOS := VOLATILE_DURABILITY_QOS; ret(0).DESTINATION_ORDER_QOS := BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS; ret(0).ACKNACK_RESPONSE_DELAY := gen_duration(0.9 sec); ret(0).ACKNACK_SUPPRESSION_DELAY := gen_duration(0.9 sec); ret(0).LEASE_DURATION := DURATION_INFINITE; ret(0).HEARTBEAT_PERIOD := DURATION_INFINITE; ret(0).WITH_KEY := TRUE; ret(0).PUSH_MODE := FALSE; -- vrksn ret(1).RELIABILITY_QOS := RELIABLE_RELIABILITY_QOS; ret(1).LIVELINESS_QOS := AUTOMATIC_LIVELINESS_QOS; ret(1).DURABILITY_QOS := VOLATILE_DURABILITY_QOS; ret(1).DESTINATION_ORDER_QOS := BY_SOURCE_TIMESTAMP_DESTINATION_ORDER_QOS; ret(1).ACKNACK_RESPONSE_DELAY := gen_duration(0.9 sec); ret(1).ACKNACK_SUPPRESSION_DELAY := gen_duration(0.9 sec); ret(1).LEASE_DURATION := DURATION_INFINITE; ret(1).HEARTBEAT_PERIOD := DURATION_INFINITE; ret(1).WITH_KEY := TRUE; ret(1).PUSH_MODE := FALSE; return ret; end function; constant TEST_CONFIG : CONFIG_ARRAY_TYPE := gen_test_config; constant ENTITYID : ENTITYID_ARRAY_TYPE(0 to NUM_WRITERS-1) := (0 => x"2b6f0403", 1 => x"e9e7d903"); -- *TYPE DECLARATION* type SEND_STAGE_TYPE is (IDLE, BUSY); type TEST_CC_ARRAY_TYPE is array (0 to MAX_CC-1) of CACHE_CHANGE_TYPE; type TEST_CC_ARRAY_ARRAY_TYPE is array (0 to NUM_WRITERS-1) of TEST_CC_ARRAY_TYPE; type HC_STAGE_TYPE is (IDLE, PUSH, DONE, INVALID); type TEST_CC_FILL_ARRAY_TYPE is array (0 to NUM_WRITERS-1) of natural; -- *SIGNAL DECLARATION* signal clk, rd_user, rd_meta, last_word_in_user, last_word_in_meta, last_word_out_rtps : std_logic := '0'; signal empty_user, empty_meta, w_map : std_logic_vector(0 to NUM_WRITERS-1) := (others => '0'); signal reset : std_logic := '1'; signal data_in_user, data_in_meta, data_out : std_logic_vector(WORD_WIDTH-1 downto 0) := (others => '0'); signal data_in_hc : WORD_ARRAY_TYPE(0 to NUM_WRITERS-1); signal wr_sig, full : std_logic := '0'; signal ready_in_hc, valid_in_hc, ack_hc, done_hc, get_data_hc, start_hc, data_available, last_word_in_hc : std_logic_vector(0 to NUM_WRITERS-1) := (others => '0'); signal seq_nr_hc, cc_seq_nr : SEQUENCENUMBER_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => SEQUENCENUMBER_UNKNOWN); signal stim_stage_user, stim_stage_meta : SEND_STAGE_TYPE := IDLE; signal opcode_hc : HISTORY_CACHE_OPCODE_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => NOP); signal ret_hc : HISTORY_CACHE_RESPONSE_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => ERROR); signal cc_instance_handle : INSTANCE_HANDLE_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => HANDLE_NIL); signal cc_kind : CACHE_CHANGE_KIND_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => ALIVE); signal cc_source_timestamp : TIME_ARRAY_TYPE(0 to NUM_WRITERS-1) := (others => TIME_INVALID); shared variable stimulus_user, stimulus_meta, reference : TEST_PACKET_TYPE := EMPTY_TEST_PACKET; signal packet_sent_user, packet_sent_meta : std_logic := '0'; signal cnt_stim_meta, cnt_stim_user, count : natural := 0; signal start_meta, start_user : std_logic := '0'; shared variable SB_out, SB_hc : osvvm.ScoreBoardPkg_slv.ScoreBoardPType; signal stim_done, out_check_done, test_done : std_logic := '0'; signal test_time : TIME_TYPE := TIME_ZERO; signal fifo_in, fifo_out : std_logic_vector(WORD_WIDTH downto 0) := (others => '0'); signal fifo_wr, fifo_empty, fifo_full : std_logic := '0'; signal rtps_out_data : WORD_ARRAY_TYPE(0 to NUM_ENDPOINTS) := (others => (others => '0')); signal rtps_out_rd, rtps_out_last_word_in, rtps_out_empty : std_logic_vector(0 to NUM_ENDPOINTS) := (others => '0'); signal test_cc : TEST_CC_ARRAY_ARRAY_TYPE := (others => (others => DEFAULT_CACHE_CHANGE)); -- Signal containing the current fill level of the test_cc array signal test_cc_fill, hb_count : TEST_CC_FILL_ARRAY_TYPE := (others => 0); signal stage_hc : HC_STAGE_TYPE := IDLE; signal new_cc : std_logic := '0'; signal cnt : natural := 0; -- *FUNCTION DECLARATION* function gen_sn(input : natural) return SEQUENCENUMBER_TYPE is variable ret : SEQUENCENUMBER_TYPE; begin ret(0) := (others => '0'); ret(1) := unsigned(int(input, WORD_WIDTH)); return ret; end function; procedure wait_on_sig(signal sig : std_logic) is begin if (sig /= '1') then wait on sig until sig = '1'; end if; end procedure; begin -- Unit Under Test uut : entity work.rtps_writer(arch) generic map ( NUM_WRITERS => NUM_WRITERS, CONFIG_ARRAY => to_QUARTUS_CONFIG_ARRAY_TYPE(TEST_CONFIG), ENTITYID => ENTITYID, INLINE_QOS => (0 to NUM_WRITERS-1 => gen_inline_qos(NUM_READERS+7)), MAX_REMOTE_ENDPOINTS => MAX_REMOTE_ENDPOINTS ) port map ( clk => clk, reset => reset, time => test_time, empty_user => empty_user or (empty_user'range => packet_sent_user), rd_user => rd_user, data_in_user => data_in_user, last_word_in_user => last_word_in_user, empty_meta => empty_meta or (empty_meta'range => packet_sent_meta), rd_meta => rd_meta, data_in_meta => data_in_meta, last_word_in_meta => last_word_in_meta, alive_sig => open, wr_ro => fifo_wr, full_ro => fifo_full, last_word_out_ro => fifo_in(WORD_WIDTH), data_out_ro => fifo_in(WORD_WIDTH-1 downto 0), liveliness_assertion => (others => '0'), data_available => data_available, start_hc => start_hc, opcode_hc => opcode_hc, ack_hc => ack_hc, seq_nr_hc => seq_nr_hc, done_hc => done_hc, ret_hc => ret_hc, get_data_hc => get_data_hc, data_in_hc => data_in_hc, valid_in_hc => valid_in_hc, ready_in_hc => ready_in_hc, last_word_in_hc => last_word_in_hc, cc_instance_handle => cc_instance_handle, cc_kind => cc_kind, cc_source_timestamp => cc_source_timestamp, cc_seq_nr => cc_seq_nr ); fifo_inst : configuration work.FWFT_FIFO_cfg generic map ( FIFO_DEPTH => 2, DATA_WIDTH => WORD_WIDTH+1 ) port map ( reset => reset, clk => clk, data_in => fifo_in, write => fifo_wr, read => rtps_out_rd(0), data_out => fifo_out, empty => fifo_empty, full => fifo_full, free => open ); rtps_out_data <= (0 => fifo_out(WORD_WIDTH-1 downto 0), others => (others => '0')); rtps_out_last_word_in <= (0 => fifo_out(WORD_WIDTH), others => '0'); rtps_out_empty <= (0 => fifo_empty, others => '1'); rtps_out_inst : entity work.rtps_out(arch) port map ( clk => clk, reset => reset, data_in => rtps_out_data, last_word_in=> rtps_out_last_word_in, rd => rtps_out_rd, empty => rtps_out_empty, data_out => data_out, wr => wr_sig, full => full ); stimulus_prc : process variable RV : RandomPType; --variable OUTPUT, HC : AlertLogIDType; variable e0, e1, e2, e3, e4, endpoint : ENDPOINT_DATA_TYPE := DEFAULT_ENDPOINT_DATA; variable sub : RTPS_SUBMESSAGE_TYPE := DEFAULT_RTPS_SUBMESSAGE; variable cc : CACHE_CHANGE_TYPE := DEFAULT_CACHE_CHANGE; variable OUT_HEADER : OUTPUT_HEADER_TYPE := DEFAULT_OUTPUT_HEADER; variable rtps_header : RTPS_HEADER_TYPE := DEFAULT_RTPS_HEADER; alias idle_sig is <>; alias gsn is <>; -- Wrapper to use procedure as function impure function gen_rand_loc_2 return LOCATOR_TYPE is variable ret : LOCATOR_TYPE := EMPTY_LOCATOR; begin gen_rand_loc(RV, ret); return ret; end function; impure function gen_rand_entityid_2(reader : boolean) return std_logic_vector is variable ret : std_logic_vector(ENTITYID_WIDTH-1 downto 0) := (others => '0'); begin gen_rand_entityid(RV, reader, ret); return ret; end function; impure function gen_rand_guid_prefix return GUIDPREFIX_TYPE is variable ret : GUIDPREFIX_TYPE; begin ret := (0 => RV.RandSlv(WORD_WIDTH), 1 => RV.RandSlv(WORD_WIDTH), 2 => RV.RandSlv(WORD_WIDTH)); return ret; end function; impure function gen_key_hash return KEY_HASH_TYPE is variable ret : KEY_HASH_TYPE := KEY_HASH_NIL; begin for i in 0 to KEY_HASH_TYPE'length-1 loop ret(i) := RV.RandSlv(WORD_WIDTH); end loop; return ret; end function; impure function gen_payload return TEST_PACKET_TYPE is variable ret : TEST_PACKET_TYPE := EMPTY_TEST_PACKET; begin for i in 0 to RV.RandInt(1,10) loop ret.data(ret.length) := RV.RandSlv(WORD_WIDTH); ret.length := ret.length + 1; end loop; ret.last(ret.length-1) := '1'; return ret; end function; impure function gen_cc(sn : natural; kind : CACHE_CHANGE_KIND_TYPE; i : natural) return CACHE_CHANGE_TYPE is variable ret : CACHE_CHANGE_TYPE := DEFAULT_CACHE_CHANGE; begin ret.kind := kind; if (TEST_CONFIG(i).WITH_KEY) then ret.instance := gen_key_hash; end if; ret.writer_guid := to_guid(GUIDPREFIX, ENTITYID(i)); ret.seq_nr := gen_sn(sn); ret.src_timestamp := gen_duration(sn * sec); if (kind = ALIVE or (kind /= ALIVE and TEST_CONFIG(i).WITH_KEY)) then ret.payload := gen_payload; end if; return ret; end function; procedure start_meta_test is begin start_meta <= '1'; wait until rising_edge(clk); start_meta <= '0'; wait until rising_edge(clk); end procedure; procedure start_user_test is begin start_user <= '1'; wait until rising_edge(clk); start_user <= '0'; wait until rising_edge(clk); end procedure; procedure trigger_hc is begin new_cc <= '1'; wait until rising_edge(clk); new_cc <= '0'; wait until rising_edge(clk); end procedure; -- NOTE: This procedure waits until the idle_sig is high for at least -- two consecutive clock cycles. procedure wait_on_idle is variable first : boolean := TRUE; begin loop if (idle_sig /= '1') then wait until idle_sig = '1'; elsif (not first) then exit; end if; wait until rising_edge(clk); wait until rising_edge(clk); first := FALSE; end loop; end procedure; procedure push_hc(opcode : in HISTORY_CACHE_OPCODE_TYPE; sn : in SEQUENCENUMBER_TYPE; i : natural) is variable t : std_logic_vector(0 to NUM_WRITERS-1); begin t := (i => '1', others => '0'); SB_hc.push(t); SB_hc.push(std_logic_vector(to_unsigned(HISTORY_CACHE_OPCODE_TYPE'pos(opcode),WORD_WIDTH))); SB_hc.push(std_logic_vector(sn(0))); SB_hc.push(std_logic_vector(sn(1))); end procedure; procedure gen_header(endpoint : in ENDPOINT_DATA_TYPE) is begin reference := EMPTY_TEST_PACKET; -- OUTPUT HEADER OUT_HEADER := DEFAULT_OUTPUT_HEADER; OUT_HEADER := (dest => get_loc(endpoint), src => DEST_LOC.user.locator(1)); gen_output_header(OUT_HEADER, reference); -- RTPS HEADER rtps_header := DEFAULT_RTPS_HEADER; rtps_header.guidPrefix := GUIDPREFIX; gen_rtps_header(rtps_header, reference); end procedure; procedure gen_data(endpoint : in ENDPOINT_DATA_TYPE; ref : in CACHE_CHANGE_TYPE) is begin sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_DATA; sub.writerId := ref.writer_guid(3); sub.readerId := ENTITYID_UNKNOWN; sub.submessageLength := (others => '0'); sub.writerSN := ref.seq_nr; sub.flags(SUBMESSAGE_DATA_FLAG_POS) := '1' when (ref.kind = ALIVE) else '0'; sub.flags(SUBMESSAGE_KEY_FLAG_POS) := '1' when (ref.kind /= ALIVE and ref.instance /= HANDLE_NIL) else '0'; if (ref.kind /= ALIVE or ref.instance /= HANDLE_NIL or endpoint.expectsInlineQoS(0) = '1') then sub.flags(SUBMESSAGE_INLINE_QOS_FLAG_POS) := '1'; gen_inline_qos(ref, gen_endpoint(NUM_READERS+7), (endpoint.expectsInlineQoS(0) = '1'), '0', sub.inlineQos); gen_sentinel(sub.inlineQos); end if; --assert (ref.payload /= EMPTY_TEST_PACKET) severity FAILURE; sub.data := ref.payload; gen_rtps_submessage(sub, reference); end procedure; procedure gen_ts(ts : TIME_TYPE) is begin sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_INFO_TS; sub.timestamp := ts; gen_rtps_submessage(sub, reference); end procedure; procedure gen_gap(first : SEQUENCENUMBER_TYPE; last : SEQUENCENUMBER_TYPE; i : natural) is begin sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_GAP; sub.writerId := ENTITYID(i); sub.readerId := ENTITYID_UNKNOWN; sub.gapStart := first; sub.gapList := (base => last, numBits => int(0, CDR_LONG_WIDTH), bitmap => (others => '0')); gen_rtps_submessage(sub, reference); end procedure; procedure push_hb(endpoint : in ENDPOINT_DATA_TYPE; first : in SEQUENCENUMBER_TYPE; last : in SEQUENCENUMBER_TYPE; liveliness_assertion : in boolean; i : natural) is begin reference := EMPTY_TEST_PACKET; -- OUTPUT HEADER OUT_HEADER := DEFAULT_OUTPUT_HEADER; OUT_HEADER := (dest => get_loc(endpoint), src => DEST_LOC.user.locator(1)); gen_output_header(OUT_HEADER, reference); -- RTPS HEADER rtps_header := DEFAULT_RTPS_HEADER; rtps_header.guidPrefix := GUIDPREFIX; gen_rtps_header(rtps_header, reference); -- HEARTBEAT sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_HEARTBEAT; sub.writerId := ENTITYID(i); sub.readerId := ENTITYID_UNKNOWN; sub.firstSN := first; sub.lastSN := last; sub.flags(SUBMESSAGE_LIVELINESS_FLAG_POS) := '1' when (liveliness_assertion) else '0'; sub.count := std_logic_vector(to_unsigned(hb_count(i), CDR_LONG_WIDTH)); hb_count(i) <= hb_count(i) + 1; wait for 0 ns; -- Latch Signal gen_rtps_submessage(sub, reference); fix_output_packet(reference); for i in 0 to reference.length-1 loop SB_out.Push(reference.data(i)); end loop; end procedure; procedure push_reference is begin fix_output_packet(reference); for i in 0 to reference.length-1 loop SB_out.Push(reference.data(i)); end loop; end procedure; procedure check_gsn(ref : SEQUENCENUMBER_TYPE; i : natural) is begin AffirmIf(gsn(i) = ref, "Global ACK SN: " & to_hstring(to_unsigned(gsn(i))) & " Expected: " & to_hstring(to_unsigned(ref))); end procedure; begin SetAlertLogName("L1_rtps_writer_test2 - ACKNACK Handling"); SetAlertEnable(FAILURE, TRUE); SetAlertEnable(ERROR, TRUE); SetAlertEnable(WARNING, TRUE); SetLogEnable(DEBUG, FALSE); SetLogEnable(PASSED, FALSE); SetLogEnable(INFO, TRUE); RV.InitSeed(RV'instance_name); SB_hc.SetAlertLogID(Name => "HC", ParentID => OSVVM_ALERTLOG_ID); SB_out.SetAlertLogID(Name => "OUTPUT", ParentID => OSVVM_ALERTLOG_ID); -- Endpoint 0 e0 := DEFAULT_ENDPOINT_DATA; e0.nr := 0; e0.match := MATCH; e0.entityid := RV.RandSlv(ENTITYID_WIDTH); e0.participant.guidPrefix := gen_rand_guid_prefix; e0.unicastLocatorList := (numLocators => int(1,CDR_LONG_WIDTH), locator => (0 => gen_rand_loc_2, others => EMPTY_LOCATOR)); e0.reliability := RELIABLE_RELIABILITY_QOS; -- Endpoint 1 e1 := DEFAULT_ENDPOINT_DATA; e1.nr := 1; e1.match := MATCH; e1.entityid := RV.RandSlv(ENTITYID_WIDTH); e1.participant.guidPrefix := gen_rand_guid_prefix; e1.unicastLocatorList := (numLocators => int(1,CDR_LONG_WIDTH), locator => (0 => gen_rand_loc_2, others => EMPTY_LOCATOR)); e2.expectsInlineQoS(0) := '1'; e1.reliability := RELIABLE_RELIABILITY_QOS; -- Endpoint 2 e2 := DEFAULT_ENDPOINT_DATA; e2.nr := 2; e2.match := MATCH; e2.entityid := RV.RandSlv(ENTITYID_WIDTH); e2.participant.guidPrefix := gen_rand_guid_prefix; e2.unicastLocatorList := (numLocators => int(1,CDR_LONG_WIDTH), locator => (0 => gen_rand_loc_2, others => EMPTY_LOCATOR)); e2.reliability := RELIABLE_RELIABILITY_QOS; Log("Initiating Test", INFO); Log("Current Time: 0s", INFO); hb_count <= (others => 1); count <= 1; test_time <= TIME_ZERO; new_cc <= '0'; stim_done <= '0'; start_meta <= '0'; start_user <= '0'; reset <= '1'; w_map <= (others => '0'); wait until rising_edge(clk); wait until rising_edge(clk); reset <= '0'; check_gsn(SEQUENCENUMBER_UNKNOWN,0); check_gsn(SEQUENCENUMBER_UNKNOWN,1); Log("Add Cache Change [SN 1] {W0,W1}", INFO); -- HC0 test_cc(0)(0) <= gen_cc(1,ALIVE,0); test_cc_fill(0) <= 1; -- HC1 test_cc(1)(0) <= gen_cc(1,ALIVE,1); test_cc_fill(1) <= 1; w_map <= "11"; trigger_hc; push_hc(REMOVE_CACHE_CHANGE, gen_sn(1),0); push_hc(REMOVE_CACHE_CHANGE, gen_sn(1),1); wait_on_idle; check_gsn(SEQUENCENUMBER_UNKNOWN,0); check_gsn(SEQUENCENUMBER_UNKNOWN,1); Log("Insert Endpoint 0,1,2 {W0,W1}", INFO); Log("W0,W1: Global ACK SN 1", DEBUG); gen_endpoint_match_frame(e0, stimulus_meta); gen_endpoint_match_frame(e1, stimulus_meta); gen_endpoint_match_frame(e2, stimulus_meta); w_map <= "11"; start_meta_test; push_hb(e0, gen_sn(1), gen_sn(1), FALSE,0); push_hb(e0, gen_sn(1), gen_sn(1), FALSE,1); push_hb(e1, gen_sn(1), gen_sn(1), FALSE,0); push_hb(e1, gen_sn(1), gen_sn(1), FALSE,1); push_hb(e2, gen_sn(1), gen_sn(1), FALSE,0); push_hb(e2, gen_sn(1), gen_sn(1), FALSE,1); wait_on_sig(packet_sent_meta); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Endpoint 0 sent ACKNACK [ACK SN <1, Request SN 1] {W0,W1}", INFO); endpoint := e0; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(1), numBits => int(1, CDR_LONG_WIDTH), bitmap => (0 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Remove Cache Change [SN 1], Add Cache Change [SN 2] {W0,W1}", INFO); -- HC0 test_cc(0)(0) <= gen_cc(2,ALIVE,0); test_cc_fill(0) <= 1; -- HC1 test_cc(1)(0) <= gen_cc(2,ALIVE,1); test_cc_fill(1) <= 1; w_map <= "11"; trigger_hc; wait_on_idle; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Endpoint 1 sent ACKNACK [ACK SN <1, Request SN 2] {W0,W1}", INFO); endpoint := e1; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(1), numBits => int(2, CDR_LONG_WIDTH), bitmap => (1 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Current Time: 1s", INFO); Log("W0,W1: Send GAP (SN 1) to Endpoint 0", DEBUG); Log("W0,W1: Send SN 2 to Endpoint 1", DEBUG); test_time <= gen_duration(1 sec); wait until rising_edge(clk); wait until rising_edge(clk); -- Allow idle_sig to go low -- W0 gen_header(e1); gen_data(e1, test_cc(0)(0)); push_reference; gen_header(e0); gen_gap(gen_sn(1), gen_sn(2),0); push_reference; -- W0 gen_header(e1); gen_ts(test_cc(1)(0).src_timestamp); gen_data(e1, test_cc(1)(0)); push_reference; gen_header(e0); gen_gap(gen_sn(1), gen_sn(2),1); push_reference; wait_on_sig(out_check_done); wait_on_idle; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Add Cache Change [SN 3,4,10,15,50] {W0,W1}", INFO); -- HC0 test_cc(0)(1) <= gen_cc(3,ALIVE,0); test_cc(0)(2) <= gen_cc(4,ALIVE,0); test_cc(0)(3) <= gen_cc(10,NOT_ALIVE_DISPOSED,0); test_cc(0)(4) <= gen_cc(15,NOT_ALIVE_UNREGISTERED,0); test_cc(0)(5) <= gen_cc(50,ALIVE_FILTERED,0); test_cc_fill(0) <= 6; -- HC1 test_cc(1)(1) <= gen_cc(3,ALIVE,1); test_cc(1)(2) <= gen_cc(4,ALIVE,1); test_cc(1)(3) <= gen_cc(10,NOT_ALIVE_DISPOSED,1); test_cc(1)(4) <= gen_cc(15,NOT_ALIVE_UNREGISTERED,1); test_cc(1)(5) <= gen_cc(50,ALIVE_FILTERED,1); test_cc_fill(1) <= 6; w_map <= "11"; trigger_hc; wait_on_idle; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Endpoint 0 sent ACKNACK [ACK SN <2, Request SN 2] {W0,W1}", INFO); Log("W0,W1: Ignore Request", DEBUG); endpoint := e0; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(2), numBits => int(1, CDR_LONG_WIDTH), bitmap => (0 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Endpoint 1 sent ACKNACK [ACK SN <3, Request SN 3] {W0,W1}", INFO); Log("W0,W1: Ignore Request", DEBUG); endpoint := e1; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(3), numBits => int(1, CDR_LONG_WIDTH), bitmap => (0 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Endpoint 2 sent ACKNACK [ACK SN <3, Request SN 3,4] {W0,W1}", INFO); endpoint := e2; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(3), numBits => int(2, CDR_LONG_WIDTH), bitmap => (0 => '1', 1 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Current Time: 2s", INFO); Log("W0,W1: Send SN 3,4 to Endpoint 2", DEBUG); test_time <= gen_duration(2 sec); wait until rising_edge(clk); wait until rising_edge(clk); -- Allow idle_sig to go low -- W0 gen_header(e2); gen_data(e2, test_cc(0)(1)); push_reference; gen_header(e2); gen_data(e2, test_cc(0)(2)); push_reference; -- W1 gen_header(e2); gen_ts(test_cc(1)(1).src_timestamp); gen_data(e2, test_cc(1)(1)); push_reference; gen_header(e2); gen_ts(test_cc(1)(2).src_timestamp); gen_data(e2, test_cc(1)(2)); push_reference; wait_on_sig(out_check_done); wait_on_idle; check_gsn(gen_sn(1),0); check_gsn(gen_sn(1),1); Log("Endpoint 0 sent ACKNACK [ACK SN <10, Request SN 10] {W0,W1}", INFO); endpoint := e0; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(10), numBits => int(1, CDR_LONG_WIDTH), bitmap => (0 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); push_hc(REMOVE_CACHE_CHANGE, gen_sn(2),0); push_hc(REMOVE_CACHE_CHANGE, gen_sn(2),1); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(2),0); check_gsn(gen_sn(2),1); Log("Endpoint 1 sent ACKNACK [ACK SN <4, Request SN 15] {W0,W1}", INFO); endpoint := e1; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(4), numBits => int(12, CDR_LONG_WIDTH), bitmap => (11 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(2),0); check_gsn(gen_sn(2),1); Log("Endpoint 2 sent ACKNACK [ACK SN <15, Request SN 16] {W0,W1}", INFO); Log("W0,W1: Ignore Request", DEBUG); endpoint := e2; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(15), numBits => int(2, CDR_LONG_WIDTH), bitmap => (1 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); push_hc(REMOVE_CACHE_CHANGE, gen_sn(3),0); push_hc(REMOVE_CACHE_CHANGE, gen_sn(3),1); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(3),0); check_gsn(gen_sn(3),1); Log("Current Time: 3s", INFO); Log("W0,W1: Send SN 10 to Endpoint 0", INFO); Log("W0,W1: Send SN 15 to Endpoint 1", INFO); test_time <= gen_duration(3 sec); wait until rising_edge(clk); wait until rising_edge(clk); -- Allow idle_sig to go low -- W0 gen_header(e1); gen_data(e1, test_cc(0)(4)); push_reference; gen_header(e0); gen_data(e0, test_cc(0)(3)); push_reference; -- W1 gen_header(e1); gen_ts(test_cc(1)(4).src_timestamp); gen_data(e1, test_cc(1)(4)); push_reference; gen_header(e0); gen_ts(test_cc(1)(3).src_timestamp); gen_data(e0, test_cc(1)(3)); push_reference; wait_on_sig(out_check_done); wait_on_idle; check_gsn(gen_sn(3),0); check_gsn(gen_sn(3),1); Log("Endpoint 2 sent ACKNACK [ACK SN <1, Request SN 1-32] {W0,W1}", INFO); endpoint := e2; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(1), numBits => int(32, CDR_LONG_WIDTH), bitmap => (0 to 31 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(3),0); check_gsn(gen_sn(3),1); Log("Current Time: 4s", INFO); Log("W0,W1: Send SN 2,3,4,10,15 to Endpoint 2 (GAP for SN 1, 5-9, 11-14, 16-32)", INFO); test_time <= gen_duration(4 sec); wait until rising_edge(clk); wait until rising_edge(clk); -- Allow idle_sig to go low -- W0 gen_header(e2); gen_gap(gen_sn(1), gen_sn(2),0); gen_data(e2, test_cc(0)(0)); push_reference; gen_header(e2); gen_data(e2, test_cc(0)(1)); push_reference; gen_header(e2); gen_data(e2, test_cc(0)(2)); push_reference; gen_header(e2); gen_gap(gen_sn(5), gen_sn(10),0); gen_data(e2, test_cc(0)(3)); push_reference; gen_header(e2); gen_gap(gen_sn(11), gen_sn(15),0); gen_data(e2, test_cc(0)(4)); push_reference; gen_header(e2); gen_gap(gen_sn(16), gen_sn(33),0); push_reference; -- W1 gen_header(e2); gen_gap(gen_sn(1), gen_sn(2),1); gen_ts(test_cc(1)(0).src_timestamp); gen_data(e2, test_cc(1)(0)); push_reference; gen_header(e2); gen_ts(test_cc(1)(1).src_timestamp); gen_data(e2, test_cc(1)(1)); push_reference; gen_header(e2); gen_ts(test_cc(1)(2).src_timestamp); gen_data(e2, test_cc(1)(2)); push_reference; gen_header(e2); gen_gap(gen_sn(5), gen_sn(10),1); gen_ts(test_cc(1)(3).src_timestamp); gen_data(e2, test_cc(1)(3)); push_reference; gen_header(e2); gen_gap(gen_sn(11), gen_sn(15),1); gen_ts(test_cc(1)(4).src_timestamp); gen_data(e2, test_cc(1)(4)); push_reference; gen_header(e2); gen_gap(gen_sn(16), gen_sn(33),1); push_reference; wait_on_sig(out_check_done); wait_on_idle; check_gsn(gen_sn(3),0); check_gsn(gen_sn(3),1); Log("Endpoint 0 sent ACKNACK [ACK SN <11, Request SN 15] {W0,W1}", INFO); endpoint := e0; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(11), numBits => int(5, CDR_LONG_WIDTH), bitmap => (4 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(3),0); check_gsn(gen_sn(3),1); Log("Endpoint 1 sent ACKNACK [ACK SN <11, Request SN 10] {W0,W1}", INFO); endpoint := e1; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(10), numBits => int(1, CDR_LONG_WIDTH), bitmap => (0 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); for i in 4 to 9 loop push_hc(REMOVE_CACHE_CHANGE, gen_sn(i),0); end loop; for i in 4 to 9 loop push_hc(REMOVE_CACHE_CHANGE, gen_sn(i),1); end loop; w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(9),0); check_gsn(gen_sn(9),1); Log("Current Time: 4.5s", INFO); test_time <= gen_duration(4.5 sec); wait until rising_edge(clk); wait until rising_edge(clk); -- Allow idle_sig to go low wait_on_idle; check_gsn(gen_sn(9),0); check_gsn(gen_sn(9),1); Log("Endpoint 0 sent ACKNACK [ACK SN <11, Request SN 14,15,16] {W0,W1}", INFO); endpoint := e0; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(11), numBits => int(6, CDR_LONG_WIDTH), bitmap => (3 => '1', 4 => '1', 5 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(9),0); check_gsn(gen_sn(9),1); Log("Endpoint 1 sent ACKNACK [ACK SN <15, Request SN 50] {W0,W1}", INFO); endpoint := e1; sub := DEFAULT_RTPS_SUBMESSAGE; sub.submessageID := SID_ACKNACK; sub.writerId := ENTITYID_UNKNOWN; sub.readerId := endpoint.entityid; sub.count := std_logic_vector(to_unsigned(count, CDR_LONG_WIDTH)); sub.readerSNState := (base => gen_sn(15), numBits => int(36, CDR_LONG_WIDTH), bitmap => (35 => '1', others => '0')); sub.flags(SUBMESSAGE_FINAL_FLAG_POS) := '1'; gen_rtps_handler_out(sub, get_loc(endpoint), FALSE, TIME_INVALID, endpoint.participant.guidPrefix, stimulus_user); push_hc(REMOVE_CACHE_CHANGE, gen_sn(10),0); push_hc(REMOVE_CACHE_CHANGE, gen_sn(10),1); w_map <= "11"; start_user_test; wait_on_sig(packet_sent_user); wait_on_idle; stimulus_meta := EMPTY_TEST_PACKET; stimulus_user := EMPTY_TEST_PACKET; check_gsn(gen_sn(10),0); check_gsn(gen_sn(10),1); Log("Current Time: 5s", INFO); Log("W0,W1: Send SN 15 to Endpoint 0 (GAP for SN 14,16)", INFO); Log("W0,W1: Send SN 50 to Endpoint 1", INFO); test_time <= gen_duration(5 sec); wait until rising_edge(clk); wait until rising_edge(clk); -- Allow idle_sig to go low -- W0 gen_header(e1); gen_data(e1, test_cc(0)(5)); push_reference; gen_header(e0); gen_gap(gen_sn(14), gen_sn(15),0); gen_data(e0, test_cc(0)(4)); push_reference; gen_header(e0); gen_gap(gen_sn(16), gen_sn(17),0); push_reference; -- W1 gen_header(e1); gen_ts(test_cc(1)(5).src_timestamp); gen_data(e1, test_cc(1)(5)); push_reference; gen_header(e0); gen_gap(gen_sn(14), gen_sn(15),1); gen_ts(test_cc(1)(4).src_timestamp); gen_data(e0, test_cc(1)(4)); push_reference; gen_header(e0); gen_gap(gen_sn(16), gen_sn(17),1); push_reference; wait_on_sig(out_check_done); wait_on_idle; check_gsn(gen_sn(10),0); check_gsn(gen_sn(10),1); stim_done <= '1'; wait_on_sig(test_done); TranscriptOpen(RESULTS_FILE, APPEND_MODE); SetTranscriptMirror; ReportAlerts; TranscriptClose; std.env.stop; wait; end process; clock_prc : process begin clk <= '0'; wait for 25 ns; clk <= '1'; wait for 25 ns; end process; empty_meta_prc : process begin empty_meta <= not w_map; wait until rising_edge(clk); empty_meta <= (others => '1'); wait until rising_edge(clk); end process; empty_user_prc : process begin empty_user <= not w_map; wait until rising_edge(clk); empty_user <= (others => '1'); wait until rising_edge(clk); end process; rtps_full_prc : process begin full <= '0'; wait until rising_edge(clk); full <= '1'; wait until rising_edge(clk); end process; alert_prc : process(all) begin if rising_edge(clk) then alertif(empty_meta = (empty_meta'range => '1') and rd_meta = '1', "Input FIFO read signal high while empty signal high (meta)", FAILURE); alertif(empty_user = (empty_user'range => '1') and rd_user = '1', "Input FIFO read signal high while empty signal high (user)", FAILURE); alertif(full = '1' and wr_sig = '1', "Output FIFO write signal high while full signal high", FAILURE); end if; end process; input_meta_prc : process(all) begin data_in_meta <= stimulus_meta.data(cnt_stim_meta); last_word_in_meta <= stimulus_meta.last(cnt_stim_meta); if rising_edge(clk) then if (reset = '1') then cnt_stim_meta <= 0; stim_stage_meta <= IDLE; packet_sent_meta <= '1'; else case (stim_stage_meta) is when IDLE => if (start_meta = '1' and stimulus_meta.length /= 0) then stim_stage_meta <= BUSY; packet_sent_meta <= '0'; end if; when BUSY => if (rd_meta = '1') then if (cnt_stim_meta = stimulus_meta.length-1) then stim_stage_meta <= IDLE; packet_sent_meta <= '1'; cnt_stim_meta <= 0; else cnt_stim_meta <= cnt_stim_meta + 1; end if; end if; end case; end if; end if; end process; input_user_prc : process(all) begin data_in_user <= stimulus_user.data(cnt_stim_user); last_word_in_user <= stimulus_user.last(cnt_stim_user); if rising_edge(clk) then if (reset = '1') then cnt_stim_user <= 0; stim_stage_user <= IDLE; packet_sent_user <= '1'; else case (stim_stage_user) is when IDLE => if (start_user = '1' and stimulus_user.length /= 0) then stim_stage_user <= BUSY; packet_sent_user <= '0'; end if; when BUSY => if (rd_user = '1') then if (cnt_stim_user = stimulus_user.length-1) then stim_stage_user <= IDLE; packet_sent_user <= '1'; cnt_stim_user <= 0; else cnt_stim_user <= cnt_stim_user + 1; end if; end if; end case; end if; end if; end process; done_proc : process(clk) begin if rising_edge(clk) then if (stim_done = '1' and SB_out.empty and SB_hc.empty) then test_done <= '1'; else test_done <= '0'; end if; end if; end process; hc_prc : process (all) variable stimulus : TEST_PACKET_TYPE := EMPTY_TEST_PACKET; variable bool : boolean := FALSE; variable ind : natural := 0; variable start_latch : std_logic_vector(0 to NUM_WRITERS-1); function one_hot_converter(input : std_logic_vector) return natural is begin for i in 0 to input'length-1 loop if (input(i) = '1') then return i; end if; end loop; return 0; -- DEFAULT end function; begin if (new_cc = '1') then data_available <= w_map; end if; if rising_edge(clk) then case (stage_hc) is when IDLE => if (start_hc /= (start_hc'range => '0')) then alertif((signed(start_hc) and (- signed(start_hc))) = (start_hc'range => '0'), "start_hc not in one-hot encoding", FAILURE); start_latch := start_hc; ind := one_hot_converter(start_hc); case (opcode_hc(ind)) is when GET_CACHE_CHANGE => bool := FALSE; for i in 0 to test_cc_fill(ind)-1 loop if (test_cc(ind)(i).seq_nr = seq_nr_hc(ind)) then cc_instance_handle(ind) <= test_cc(ind)(i).instance; cc_source_timestamp(ind) <= test_cc(ind)(i).src_timestamp; cc_kind(ind) <= test_cc(ind)(i).kind; stimulus := test_cc(ind)(i).payload; stage_hc <= DONE; bool := TRUE; end if; end loop; if (not bool) then stage_hc <= INVALID; end if; when GET_MIN_SN => stimulus := EMPTY_TEST_PACKET; cc_seq_nr(ind) <= test_cc(ind)(0).seq_nr when (test_cc_fill(ind) /= 0) else SEQUENCENUMBER_UNKNOWN; stage_hc <= DONE; when GET_MAX_SN => data_available(ind) <= '0'; stimulus := EMPTY_TEST_PACKET; cc_seq_nr(ind) <= test_cc(ind)(test_cc_fill(ind)-1).seq_nr when (test_cc_fill(ind) /= 0) else SEQUENCENUMBER_UNKNOWN; stage_hc <= DONE; when others => SB_hc.Check(start_latch); SB_hc.Check(std_logic_vector(to_unsigned(HISTORY_CACHE_OPCODE_TYPE'pos(opcode_hc(ind)), WORD_WIDTH))); SB_hc.Check(std_logic_vector(seq_nr_hc(ind)(0))); SB_hc.Check(std_logic_vector(seq_nr_hc(ind)(1))); stage_hc <= DONE; end case; end if; when DONE => if (get_data_hc(ind) = '1') then alertif(stimulus = EMPTY_TEST_PACKET, "Requested empty Payload", FAILURE); stage_hc <= PUSH; cnt <= 0; else stage_hc <= IDLE; end if; when PUSH => if (ready_in_hc(ind) = '1') then cnt <= cnt + 1; if (cnt = stimulus.length-1) then stage_hc <= IDLE; end if; end if; when INVALID => stage_hc <= IDLE; when others => null; end case; end if; -- DEFAULT ack_hc <= (others => '0'); valid_in_hc <= (others => '0'); data_in_hc <= (others => (others => '0')); last_word_in_hc <= (others => '0'); done_hc <= (others => '0'); ret_hc <= (others => ERROR); case (stage_hc) is when IDLE => if (start_hc /= (start_hc'range => '0')) then -- HACK: We trigger all acks because we cannot use 'ind' variable in the same clock cycle -- Since the uut only interfaces with 1 HC at a time (one-hot encoded start_hc) this -- is still valid. ack_hc <= (others => '1'); end if; when DONE => done_hc(ind) <= '1'; ret_hc(ind) <= OK; when PUSH => valid_in_hc(ind) <= '1'; data_in_hc(ind) <= stimulus.data(cnt); last_word_in_hc(ind) <= stimulus.last(cnt); when INVALID => done_hc(ind) <= '1'; ret_hc(ind) <= INVALID; when others => null; end case; end process; output_check_prc : process(all) begin if (SB_out.empty) then out_check_done <= '1'; else out_check_done <= '0'; end if; if rising_edge(clk) then if (wr_sig = '1') then SB_out.Check(data_out); end if; end if; end process; watchdog : process begin wait for 1 ms; Alert("Test timeout", FAILURE); std.env.stop; end process; end architecture;