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 Lifespan Handling of the DDS Reader. entity L0_dds_reader_test6 is end entity; architecture testbench of L0_dds_reader_test6 is -- *CONSTANT DECLARATION* constant MAX_REMOTE_ENDPOINTS : natural := 3; constant NUM_READERS : natural := 1; impure function gen_test_config return CONFIG_ARRAY_TYPE is variable ret : CONFIG_ARRAY_TYPE(0 to NUM_READERS-1) := (others => DEFAULT_WRITER_CONFIG); begin -- arzkriu ret(0).TIME_BASED_FILTER_QOS := DURATION_ZERO; ret(0).DEADLINE_QOS := DURATION_INFINITE; ret(0).MAX_SAMPLES := std_logic_vector(to_unsigned(2,CDR_LONG_WIDTH)); ret(0).MAX_INSTANCES := std_logic_vector(to_unsigned(3,CDR_LONG_WIDTH)); ret(0).MAX_SAMPLES_PER_INSTANCE := std_logic_vector(to_unsigned(1,CDR_LONG_WIDTH)); ret(0).HISTORY_QOS := KEEP_ALL_HISTORY_QOS; ret(0).RELIABILITY_QOS := RELIABLE_RELIABILITY_QOS; ret(0).PRESENTATION_QOS := INSTANCE_PRESENTATION_QOS; ret(0).DESTINATION_ORDER_QOS := BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS; ret(0).COHERENT_ACCESS := FALSE; ret(0).ORDERED_ACCESS := FALSE; ret(0).WITH_KEY := TRUE; ret(0).MAX_PAYLOAD_SIZE := 40; return ret; end function; constant TEST_CONFIG : CONFIG_ARRAY_TYPE := gen_test_config; -- *TYPE DECLARATION* type DDS_STAGE_TYPE is (IDLE, START, DONE, CHECK_SI, CHECK_DATA, WAIT_EOC); type RTPS_STAGE_TYPE is (IDLE, START, PUSH, DONE); type DDS_READER_MEM_ARRAY_TYPE is array (0 to NUM_READERS-1) of DDS_READER_MEM_TYPE; -- *SIGNAL DECLARATION* signal clk : std_logic := '0'; signal reset : std_logic := '1'; signal check_time : TIME_TYPE := TIME_ZERO; signal start_rtps, start_dds, ack_rtps, ack_dds, done_rtps, done_dds : std_logic_vector(0 to NUM_READERS-1) := (others => '0'); signal opcode_rtps : HISTORY_CACHE_OPCODE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => NOP); signal opcode_dds : DDS_READER_OPCODE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => NOP); signal ret_rtps : HISTORY_CACHE_RESPONSE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => ERROR); signal ready_in_rtps, valid_in_rtps, last_word_in_rtps : std_logic_vector(0 to NUM_READERS-1) := (others => '0'); signal ready_out_dds, valid_out_dds, last_word_out_dds : std_logic_vector(0 to NUM_READERS-1) := (others => '0'); signal data_in_rtps, data_out_dds : WORD_ARRAY_TYPE(0 to NUM_READERS-1) := (others => (others => '0')); signal get_data_dds, si_valid, eoc : std_logic_vector(0 to NUM_READERS-1) := (others => '0'); signal return_code_dds : RETURN_CODE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => (others => '0')); signal status : STATUS_KIND_ARRAY_TYPE(0 to NUM_READERS-1) := (others => (others => '0')); signal instance_state_dds : INSTANCE_STATE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => ANY_INSTANCE_STATE); signal view_state_dds : VIEW_STATE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => ANY_VIEW_STATE); signal sample_state_dds : SAMPLE_STATE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => ANY_SAMPLE_STATE); signal instance_handle_dds : INSTANCE_HANDLE_ARRAY_TYPE(0 to NUM_READERS-1) := (others => HANDLE_NIL); signal max_samples_dds : MAX_SAMPLES_ARRAY_TYPE(0 to NUM_READERS-1) := (others => (others => '0')); signal sample_info : SAMPLE_INFO_ARRAY_TYPE(0 to NUM_READERS-1); signal ind : natural := 0; signal dds_start , dds_done , rtps_start, rtps_done : std_logic := '0'; signal dds_cnt, dds_cnt2, rtps_cnt : natural := 0; signal dds_stage : DDS_STAGE_TYPE := IDLE; signal rtps_stage : RTPS_STAGE_TYPE := IDLE; shared variable dds : DDS_READER_TEST_TYPE := DEFAULT_DDS_READER_TEST; shared variable rtps : RTPS_READER_TEST_TYPE := DEFAULT_RTPS_READER_TEST; shared variable mem : DDS_READER_MEM_ARRAY_TYPE := (others => DEFAULT_DDS_READER_MEM); signal data_id, ret_id, sstate_id, vstate_id, istate_id, inst_id, ts_id, pub_id, dis_gen_cnt_id, no_w_gen_cnt_id, srank_id, grank_id, agrank_id, eoc_id, valid_id, status_id : AlertLogIDType; -- *FUNCTION DECLARATION* function extract_key_hash (payload : TEST_PACKET_TYPE) return INSTANCE_HANDLE_TYPE is variable ret : INSTANCE_HANDLE_TYPE := HANDLE_NIL; begin for i in 0 to 3 loop ret(i) := not payload.data(i); end loop; return ret; end function; 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.dds_reader(arch) generic map ( NUM_READERS => NUM_READERS, CONFIG_ARRAY => to_QUARTUS_CONFIG_ARRAY_TYPE(TEST_CONFIG), MAX_REMOTE_ENDPOINTS => MAX_REMOTE_ENDPOINTS ) port map ( clk => clk, reset => reset, time => check_time, start_rtps => start_rtps, opcode_rtps => opcode_rtps, ack_rtps => ack_rtps, done_rtps => done_rtps, ret_rtps => ret_rtps, data_in_rtps => data_in_rtps, valid_in_rtps => valid_in_rtps, ready_in_rtps => ready_in_rtps, last_word_in_rtps => last_word_in_rtps, start_dds => start_dds, ack_dds => ack_dds, opcode_dds => opcode_dds, instance_state_dds => instance_state_dds, view_state_dds => view_state_dds, sample_state_dds => sample_state_dds, instance_handle_dds => instance_handle_dds, max_samples_dds => max_samples_dds, get_data_dds => get_data_dds, done_dds => done_dds, return_code_dds => return_code_dds, ready_out_dds => ready_out_dds, valid_out_dds => valid_out_dds, data_out_dds => data_out_dds, last_word_out_dds => last_word_out_dds, sample_info => sample_info, sample_info_valid => si_valid, sample_info_ack => (others => '1'), eoc => eoc, status => status ); stimulus_prc : process variable RV : RandomPType; variable cc : CACHE_CHANGE_TYPE := DEFAULT_CACHE_CHANGE; variable s : SAMPLE_TYPE := DEFAULT_SAMPLE; variable kh1, kh2, kh3, kh4, kh5 : INSTANCE_HANDLE_TYPE := HANDLE_NIL; alias idle_sig is <>; impure function gen_payload(key_hash : INSTANCE_HANDLE_TYPE; len : natural) return TEST_PACKET_TYPE is variable ret : TEST_PACKET_TYPE := EMPTY_TEST_PACKET; begin assert (len >= 4) report "Payload length has to be at least 16 Bytes long" severity FAILURE; for i in 0 to len-1 loop if (i < 4) then -- NOTE: Beginning of payload is negated key to allow deterministic Key Hash generation from the kh_prc ret.data(ret.length) := not key_hash(i); else ret.data(ret.length) := RV.RandSlv(WORD_WIDTH); end if; ret.length := ret.length + 1; end loop; ret.last(ret.length-1) := '1'; 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; procedure start_dds is begin dds_start <= '1'; wait until rising_edge(clk); dds_start <= '0'; wait until rising_edge(clk); end procedure; procedure start_rtps is begin rtps_start <= '1'; wait until rising_edge(clk); rtps_start <= '0'; wait until rising_edge(clk); end procedure; procedure wait_on_completion is begin if (rtps_done /= '1' or dds_done /= '1') then wait until rtps_done = '1' and dds_done = '1'; end if; 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; begin SetAlertLogName("L0_dds_reader_test6 - Sample Rejected Status Handling"); SetAlertEnable(FAILURE, TRUE); SetAlertEnable(ERROR, TRUE); SetAlertEnable(WARNING, TRUE); SetLogEnable(DEBUG, FALSE); SetLogEnable(PASSED, FALSE); SetLogEnable(INFO, TRUE); RV.InitSeed(RV'instance_name); sstate_id <= GetAlertLogID("Sample State", ALERTLOG_BASE_ID); vstate_id <= GetAlertLogID("View State", ALERTLOG_BASE_ID); istate_id <= GetAlertLogID("Instance State", ALERTLOG_BASE_ID); ts_id <= GetAlertLogID("Source Timestamp", ALERTLOG_BASE_ID); inst_id <= GetAlertLogID("Instance Handle", ALERTLOG_BASE_ID); pub_id <= GetAlertLogID("Publication Hanlde", ALERTLOG_BASE_ID); dis_gen_cnt_id <= GetAlertLogID("Disposed Generation Count", ALERTLOG_BASE_ID); no_w_gen_cnt_id <= GetAlertLogID("No Writers Generation Count", ALERTLOG_BASE_ID); srank_id <= GetAlertLogID("Sample Rank", ALERTLOG_BASE_ID); grank_id <= GetAlertLogID("Generation Rank", ALERTLOG_BASE_ID); agrank_id <= GetAlertLogID("Absolute Generation Rank", ALERTLOG_BASE_ID); eoc_id <= GetAlertLogID("End of Collection", ALERTLOG_BASE_ID); valid_id <= GetAlertLogID("Valid Data", ALERTLOG_BASE_ID); data_id <= GetAlertLogID("Data Out", ALERTLOG_BASE_ID); ret_id <= GetAlertLogID("Return Code", ALERTLOG_BASE_ID); status_id <= GetAlertLogID("Communication Status", ALERTLOG_BASE_ID); -- Key Hashes kh1 := gen_key_hash; kh2 := gen_key_hash; kh3 := gen_key_hash; kh4 := gen_key_hash; kh5 := gen_key_hash; Log("Initiating Test", INFO); Log("Current Time: 0s", INFO); check_time <= TIME_ZERO; reset <= '1'; wait until rising_edge(clk); wait until rising_edge(clk); reset <= '0'; wait_on_idle; -- MEM: - -- ISTATE: - -- WRITER: - cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh1; cc.payload := gen_payload(kh1,10); cc.src_timestamp := gen_duration(1 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 0, Aligned Payload]", INFO); Log("R0: ACCEPTED", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 0; rtps.lifespan := gen_duration(2 sec); rtps.ret_code := OK; s := to_sample(cc,ALIVE_INSTANCE_STATE); add_sample(s,mem(0), BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I1S1 -- ISTATE: I1:ALIVE -- WRITER: W0:I1 cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh2; cc.payload := gen_payload(kh2,10); cc.src_timestamp := gen_duration(2 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 2, Writer 1, Aligned Payload]", INFO); Log("R0: ACCEPTED", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 1; rtps.lifespan := gen_duration(3 sec); rtps.ret_code := OK; s := to_sample(cc,ALIVE_INSTANCE_STATE); add_sample(s,mem(0), BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I1S1, I2S1 -- ISTATE: I1:ALIVE, I2:ALIVE -- WRITER: W0:I1, W1:I2 Log("Current Time: 1s", INFO); check_time <= gen_duration(1 sec); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh3; cc.payload := gen_payload(kh3,10); cc.src_timestamp := gen_duration(3 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 3, Writer 2, Aligned Payload]", INFO); Log("R0: REJECTED [MAX_SAMPLES exceeded]", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; rtps.lifespan := gen_duration(1 sec); rtps.ret_code := REJECTED; -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I1S1, I2S1 -- ISTATE: I1:ALIVE, I2:ALIVE -- WRITER: W0:I1, W1:I2 Log("Current Time: 2s", INFO); check_time <= gen_duration(2 sec); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh3; cc.payload := gen_payload(kh3,10); cc.src_timestamp := gen_duration(4 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 3, Writer 2, Aligned Payload]", INFO); Log("R0: ACCEPTED", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; rtps.lifespan := gen_duration(1 sec); rtps.ret_code := OK; s := to_sample(cc,ALIVE_INSTANCE_STATE); add_sample(s,mem(0), BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I2S1, I3S1 -- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE -- WRITER: W0:I1, W1:I2, W2:I3 cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh1; cc.payload := gen_payload(kh1,10); cc.src_timestamp := gen_duration(5 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 0, Aligned Payload]", INFO); Log("R0: REJECTED [MAX_SAMPLES exceeded]", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 0; rtps.lifespan := gen_duration(1 sec); rtps.ret_code := REJECTED; -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I2S1, I3S1 -- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE -- WRITER: W0:I1, W1:I2, W2:I3 Log("Current Time: 3s", INFO); check_time <= gen_duration(3 sec); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh1; cc.payload := gen_payload(kh1,10); cc.src_timestamp := gen_duration(6 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 0, Aligned Payload]", INFO); Log("R0: ACCEPTED", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 0; rtps.lifespan := gen_duration(2 sec); rtps.ret_code := OK; s := to_sample(cc,ALIVE_INSTANCE_STATE); add_sample(s,mem(0), BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I1S2, 0 -- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE -- WRITER: W0:I1, W1:I2, W2:I3 cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := FALSE; cc.kind := ALIVE; cc.instance := kh3; cc.payload := gen_payload(kh3,10); cc.src_timestamp := gen_duration(7 sec); Log("R0: RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 3, Writer 2, Aligned Payload]", INFO); Log("R0: ACCEPTED", DEBUG); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; rtps.lifespan := gen_duration(1 sec); rtps.ret_code := OK; s := to_sample(cc,ALIVE_INSTANCE_STATE); add_sample(s,mem(0), BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); -- READER 0 ind <= 0; start_rtps; wait_on_sig(rtps_done); wait_on_idle; -- MEM: I1S2, I3S2 -- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE -- WRITER: W0:I1, W1:I2, W2:I3 wait_on_completion; 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; dds_prc : process(all) variable col : COLLECTION_TYPE := DEFAULT_COLLECTION; begin if rising_edge(clk) then dds_done <= '0'; case (dds_stage ) is when IDLE => if (dds_start = '1') then dds_stage <= START; else dds_done <= '1'; end if; when START => if (ack_dds(ind) = '1') then dds_stage <= DONE; dds_cnt <= 0; end if; when DONE => if (done_dds(ind) = '1') then AffirmIfEqual(ret_id, return_code_dds(ind), dds.ret_code); case (dds.ret_code) is when RETCODE_OK => gen_collection(mem(ind), col, dds, TEST_CONFIG(ind).PRESENTATION_QOS, TEST_CONFIG(ind).ORDERED_ACCESS); dds_stage <= CHECK_SI; dds_cnt <= 0; when others => dds_stage <= IDLE; end case; end if; when CHECK_SI => if (si_valid(ind) = '1') then AffirmIfEqual(sstate_id, sample_info(ind).sample_state, col.s(dds_cnt).sstate); AffirmIfEqual(vstate_id, sample_info(ind).view_state, col.s(dds_cnt).vstate); AffirmIfEqual(istate_id, sample_info(ind).instance_state, col.s(dds_cnt).istate); AffirmIfEqual(ts_id, to_unsigned(sample_info(ind).source_timestamp), to_unsigned(col.s(dds_cnt).ts)); AffirmIfEqual(inst_id, to_unsigned(sample_info(ind).instance_handle), to_unsigned(col.s(dds_cnt).inst)); AffirmIfEqual(pub_id, to_unsigned(sample_info(ind).publication_handle), to_unsigned(HANDLE_NIL)); AffirmIfEqual(dis_gen_cnt_id, sample_info(ind).disposed_generation_count, std_logic_vector(to_unsigned(col.s(dds_cnt).dis_gen_cnt,WORD_WIDTH))); AffirmIfEqual(no_w_gen_cnt_id, sample_info(ind).no_writers_generation_count, std_logic_vector(to_unsigned(col.s(dds_cnt).no_w_gen_cnt,WORD_WIDTH))); AffirmIfEqual(srank_id, sample_info(ind).sample_rank, std_logic_vector(to_unsigned(col.s(dds_cnt).srank,WORD_WIDTH))); AffirmIfEqual(grank_id, sample_info(ind).generation_rank, std_logic_vector(to_unsigned(col.s(dds_cnt).grank,WORD_WIDTH))); AffirmIfEqual(agrank_id, sample_info(ind).absolute_generation_rank, std_logic_vector(to_unsigned(col.s(dds_cnt).agrank,WORD_WIDTH))); if (sample_info(ind).valid_data = '1') then AffirmIf(valid_id, col.s(dds_cnt).data /= EMPTY_TEST_PACKET, "Sample with Data not expected"); dds_stage <= CHECK_DATA; dds_cnt2 <= 0; else AffirmIf(valid_id, col.s(dds_cnt).data = EMPTY_TEST_PACKET, "Sample with Data expected"); if (dds_cnt = col.len-1) then -- DONE dds_stage <= WAIT_EOC; else dds_cnt <= dds_cnt + 1; end if; end if; end if; AffirmIf(eoc_id, eoc(ind) = '0', "EOC pulled high"); when CHECK_DATA => if (valid_out_dds(ind) = '1') then AffirmIfEqual(data_id, data_out_dds(ind), col.s(dds_cnt).data.data(dds_cnt2)); dds_cnt2 <= dds_cnt2 + 1; if (dds_cnt2 = col.s(dds_cnt).data.length-1) then AlertIf(data_id, last_word_out_dds(ind) /= '1', "Last Word Signal not pulled High", ERROR); if (dds_cnt = col.len-1) then -- DONE dds_stage <= WAIT_EOC; else dds_stage <= CHECK_SI; dds_cnt <= dds_cnt + 1; end if; end if; end if; when WAIT_EOC => if (eoc(ind) = '1') then dds_stage <= IDLE; end if; end case; end if; -- DEFAULT start_dds <= (others => '0'); opcode_dds <= (others => NOP); instance_state_dds <= (others => ANY_INSTANCE_STATE); view_state_dds <= (others => ANY_VIEW_STATE); sample_state_dds <= (others => ANY_SAMPLE_STATE); instance_handle_dds <= (others => HANDLE_NIL); max_samples_dds <= (others => (others => '0')); get_data_dds <= (others => '0'); ready_out_dds <= (others => '0'); case (dds_stage ) is when START => start_dds(ind) <= '1'; opcode_dds(ind) <= dds.opcode; instance_state_dds(ind) <= dds.istate; view_state_dds(ind) <= dds.vstate; sample_state_dds(ind) <= dds.sstate; instance_handle_dds(ind) <= dds.inst; max_samples_dds(ind) <= std_logic_vector(to_unsigned(dds.max_samples, WORD_WIDTH)); when CHECK_SI => if (si_valid(ind) = '1' and sample_info(ind).valid_data = '1') then get_data_dds(ind) <= '1'; end if; when CHECK_DATA => ready_out_dds(ind) <= '1'; when others => null; end case; end process; rtps_prc : process(all) variable stimulus : TEST_PACKET_TYPE := EMPTY_TEST_PACKET; begin if rising_edge(clk) then rtps_done <= '0'; case (rtps_stage) is when IDLE => if (rtps_start = '1') then rtps_stage <= START; else rtps_done <= '1'; end if; when START => if (ack_rtps(ind) = '1') then case (rtps.opcode) is when ADD_CACHE_CHANGE => gen_add_cache_change_dds(rtps.cc, rtps.lifespan, rtps.writer_pos, stimulus); rtps_stage <= PUSH; when others => rtps_stage <= DONE; end case; end if; when PUSH => if (ready_in_rtps(ind) = '1') then rtps_cnt <= rtps_cnt + 1; if (rtps_cnt = stimulus.length-1) then rtps_stage <= DONE; end if; end if; when DONE => if (done_rtps(ind) = '1') then AffirmIfEqual(ret_id, HISTORY_CACHE_RESPONSE_TYPE'pos(ret_rtps(ind)), HISTORY_CACHE_RESPONSE_TYPE'pos(rtps.ret_code)); rtps_stage <= IDLE; end if; end case; end if; -- DEFAULT start_rtps <= (others => '0'); opcode_rtps <= (others => NOP); valid_in_rtps <= (others => '0'); last_word_in_rtps <= (others => '0'); data_in_rtps <= (others => (others => '0')); case (rtps_stage) is when START => start_rtps(ind) <= '1'; opcode_rtps(ind) <= rtps.opcode; case (rtps.opcode) is when REMOVE_WRITER => data_in_rtps(ind) <= std_logic_vector(to_unsigned(rtps.writer_pos,WORD_WIDTH)); when others => null; end case; when PUSH => valid_in_rtps(ind) <= '1'; data_in_rtps(ind) <= stimulus.data(rtps_cnt); last_word_in_rtps(ind) <= stimulus.last(rtps_cnt); when others => null; end case; end process; watchdog : process begin wait for 1 ms; Alert("Test timeout", FAILURE); std.env.stop; end process; end architecture;