From e067952e49c614bae78615d63953e02496c7519e Mon Sep 17 00:00:00 2001 From: Greek Date: Fri, 30 Apr 2021 16:33:06 +0200 Subject: [PATCH] Add test 7 of DDS Reader Test the bitmap writer conversion to/from memory. --- .../Level_0/L0_dds_reader_test7_arzkriu.vhd | 722 ++++++++++++++++++ src/Tests/testbench.pro | 6 +- 2 files changed, 726 insertions(+), 2 deletions(-) create mode 100644 src/Tests/Level_0/L0_dds_reader_test7_arzkriu.vhd diff --git a/src/Tests/Level_0/L0_dds_reader_test7_arzkriu.vhd b/src/Tests/Level_0/L0_dds_reader_test7_arzkriu.vhd new file mode 100644 index 0000000..0cac98e --- /dev/null +++ b/src/Tests/Level_0/L0_dds_reader_test7_arzkriu.vhd @@ -0,0 +1,722 @@ +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 bitmap writer handling (bitmap conversion to/from memory) + +entity L0_dds_reader_test7_arzkriu is +end entity; + + +architecture testbench of L0_dds_reader_test7_arzkriu is + + -- *CONSTANT DECLARATION* + constant MAX_REMOTE_ENDPOINTS : natural := 33; + + -- *TYPE DECLARATION* + type DDS_STAGE_TYPE is (IDLE, START, DONE, CHECK_SI, CHECK_DATA, WAIT_EOC, CHECK_SAMPLE_REJECT); + type RTPS_STAGE_TYPE is (IDLE, START, PUSH, DONE); + type KH_STAGE_TYPE is (IDLE, READ_DATA, PUSH_KEY_HASH); + + -- *SIGNAL DECLARATION* + signal clk : std_logic := '0'; + signal reset : std_logic := '1'; + signal check_time : TIME_TYPE := TIME_ZERO; + signal start_rtps, start_dds, start_kh, ack_rtps, ack_dds, ack_kh, done_rtps, done_dds : std_logic := '0'; + signal opcode_rtps : HISTORY_CACHE_OPCODE_TYPE := NOP; + signal opcode_dds : DDS_READER_OPCODE_TYPE := NOP; + signal opcode_kh : KEY_HOLDER_OPCODE_TYPE := NOP; + signal ret_rtps : HISTORY_CACHE_RESPONSE_TYPE := ERROR; + signal ready_in_rtps, valid_in_rtps, last_word_in_rtps : std_logic := '0'; + signal ready_out_dds, valid_out_dds, last_word_out_dds : std_logic := '0'; + signal ready_in_kh, ready_out_kh, valid_in_kh, valid_out_kh, last_word_in_kh, last_word_out_kh : std_logic := '0'; + signal data_in_rtps, data_out_dds, data_in_kh, data_out_kh : std_logic_vector(WORD_WIDTH-1 downto 0) := (others => '0'); + signal get_data_dds, si_valid_data, si_valid, eoc, abort_kh : std_logic := '0'; + signal return_code_dds : std_logic_vector(RETURN_CODE_WIDTH-1 downto 0) := (others => '0'); + signal status : std_logic_vector(STATUS_KIND_WIDTH-1 downto 0) := (others => '0'); + signal instance_state_dds, si_instance_state : std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0) := ANY_INSTANCE_STATE; + signal view_state_dds, si_view_state : std_logic_vector(VIEW_STATE_KIND_WIDTH-1 downto 0) := ANY_VIEW_STATE; + signal sample_state_dds, si_sample_state : std_logic_vector(SAMPLE_STATE_KIND_WIDTH-1 downto 0) := ANY_SAMPLE_STATE; + signal instance_handle_dds, si_instance_handle : INSTANCE_HANDLE_TYPE := HANDLE_NIL; + signal max_samples_dds : std_logic_vector(MAX_SAMPLES_WIDTH-1 downto 0) := (others => '0'); + signal si_source_timestamp : TIME_TYPE := TIME_INVALID; + signal si_publication_handle : PUBLICATION_HANDLE_TYPE := (others => (others => '0')); + signal si_disposed_generation_count : std_logic_vector(DISPOSED_GENERATION_COUNT_WIDTH-1 downto 0) := (others => '0'); + signal si_no_writers_generation_count : std_logic_vector(NO_WRITERS_GENERATION_COUNT_WIDTH-1 downto 0) := (others => '0'); + signal si_sample_rank : std_logic_vector(SAMPLE_RANK_WIDTH-1 downto 0) := (others => '0'); + signal si_generation_rank : std_logic_vector(GENERATION_RANK_WIDTH-1 downto 0) := (others => '0'); + signal si_absolute_generation_rank: std_logic_vector(ABSOLUTE_GENERATION_COUNT_WIDTH-1 downto 0) := (others => '0'); + + signal dds_start , dds_done , rtps_start, rtps_done : std_logic := '0'; + signal dds_cnt, dds_cnt2, rtps_cnt, kh_cnt : natural := 0; + signal dds_stage : DDS_STAGE_TYPE := IDLE; + signal rtps_stage : RTPS_STAGE_TYPE := IDLE; + signal kh_stage : KH_STAGE_TYPE := IDLE; + signal kh_data : TEST_PACKET_TYPE := EMPTY_TEST_PACKET; + 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_TYPE := 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; + +begin + + -- Unit Under Test + uut : entity work.dds_reader(arch) + generic map ( + TIME_BASED_FILTER_QOS => DURATION_ZERO, + DEADLINE_QOS => DURATION_INFINITE, + MAX_SAMPLES => std_logic_vector(to_unsigned(4,CDR_LONG_WIDTH)), + MAX_INSTANCES => std_logic_vector(to_unsigned(3,CDR_LONG_WIDTH)), + MAX_SAMPLES_PER_INSTANCE => std_logic_vector(to_unsigned(4,CDR_LONG_WIDTH)), + HISTORY_QOS => KEEP_ALL_HISTORY_QOS, + RELIABILITY_QOS => RELIABLE_RELIABILITY_QOS, + PRESENTATION_QOS => INSTANCE_PRESENTATION_QOS, + DESTINATION_ORDER_QOS => BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS, + COHERENT_ACCESS => FALSE, + ORDERED_ACCESS => FALSE, + WITH_KEY => TRUE, + PAYLOAD_FRAME_SIZE => 11, + 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_kh => start_kh, + opcode_kh => opcode_kh, + ack_kh => ack_kh, + data_in_kh => data_in_kh, + valid_in_kh => valid_in_kh, + ready_in_kh => ready_in_kh, + last_word_in_kh => last_word_in_kh, + data_out_kh => data_out_kh, + valid_out_kh => valid_out_kh, + ready_out_kh => ready_out_kh, + last_word_out_kh => last_word_out_kh, + abort_kh => abort_kh, + 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, + si_sample_state => si_sample_state, + si_view_state => si_view_state, + si_instance_state => si_instance_state, + si_source_timestamp => si_source_timestamp, + si_instance_handle => si_instance_handle, + si_publication_handle => si_publication_handle, + si_disposed_generation_count => si_disposed_generation_count, + si_no_writers_generation_count => si_no_writers_generation_count, + si_sample_rank => si_sample_rank, + si_generation_rank => si_generation_rank, + si_absolute_generation_rank => si_absolute_generation_rank, + si_valid_data => si_valid_data, + si_valid => si_valid, + 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 := (others => (others => '0')); + 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_dds is + begin + if (dds_done /= '1') then + wait until dds_done = '1'; + end if; + end procedure; + + procedure wait_on_rtps is + begin + if (rtps_done /= '1') then + wait until rtps_done = '1'; + end if; + 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("dds_reader - (KEEP ALL, Reliable, Zero TIME_BASED_FILTER, Keyed, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER, ACCESS SCOPE Instance, Unordered) - Level 0 - 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'; + -- 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,0); + + Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 0, Aligned Payload] (ACCEPTED)", INFO); + rtps := DEFAULT_RTPS_READER_TEST; + rtps.opcode := ADD_CACHE_CHANGE; + rtps.cc := cc; + rtps.writer_pos := 0; + rtps.ret_code := OK; + s := to_sample(cc,ALIVE_INSTANCE_STATE); + add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); + start_rtps; + wait_on_rtps; + wait_on_idle; + -- MEM: I1S1 + -- ISTATE: I1:ALIVE + -- WRITER: W0:I1 + + 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(2,0); + + Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 32, Aligned Payload] (ACCEPTED)", INFO); + rtps := DEFAULT_RTPS_READER_TEST; + rtps.opcode := ADD_CACHE_CHANGE; + rtps.cc := cc; + rtps.writer_pos := 32; + rtps.ret_code := OK; + s := to_sample(cc,ALIVE_INSTANCE_STATE); + add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); + start_rtps; + wait_on_rtps; + wait_on_idle; + -- MEM: I1S1, I1S2 + -- ISTATE: I1:ALIVE + -- WRITER: W0:I1, W33:I1 + + cc := DEFAULT_CACHE_CHANGE; + cc.serialized_key := TRUE; + cc.kind := NOT_ALIVE_UNREGISTERED; + cc.instance := kh1; + cc.payload := gen_payload(kh1,5); + cc.src_timestamp := gen_duration(3,0); + + Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 1, Writer 0] (ACCEPTED)", INFO); + rtps := DEFAULT_RTPS_READER_TEST; + rtps.opcode := ADD_CACHE_CHANGE; + rtps.cc := cc; + rtps.writer_pos := 0; + rtps.ret_code := OK; + start_rtps; + wait_on_rtps; + wait_on_idle; + -- MEM: I1S1, I1S2 + -- ISTATE: I1:ALIVE + -- WRITER: W33:I1 + + Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, NOT_ALIVE_NO_WRITERS_INSTANCE_STATE, ANY_VIEW_STATE]", INFO); + dds := DEFAULT_DDS_READER_TEST; + dds.opcode := READ; + dds.max_samples := 4; + dds.sstate := ANY_SAMPLE_STATE; + dds.istate := NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; + dds.vstate := ANY_VIEW_STATE; + dds.ret_code := RETCODE_NO_DATA; + start_dds; + wait_on_dds; + wait_on_idle; + -- MEM: I1S1, I1S2 + -- ISTATE: I1:ALIVE + -- WRITER: W33:I1 + + cc := DEFAULT_CACHE_CHANGE; + cc.serialized_key := TRUE; + cc.kind := NOT_ALIVE_UNREGISTERED; + cc.instance := kh1; + cc.payload := gen_payload(kh1,5); + cc.src_timestamp := gen_duration(3,0); + + Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 1, Writer 32] (ACCEPTED)", INFO); + rtps := DEFAULT_RTPS_READER_TEST; + rtps.opcode := ADD_CACHE_CHANGE; + rtps.cc := cc; + rtps.writer_pos := 32; + rtps.ret_code := OK; + s := to_sample(cc,NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); + add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); + start_rtps; + wait_on_rtps; + wait_on_idle; + -- MEM: I1S1, I1S2, I1S3- + -- ISTATE: I1:NO_WRITERS + -- WRITER: - + + Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, NOT_ALIVE_NO_WRITERS_INSTANCE_STATE, ANY_VIEW_STATE]", INFO); + dds := DEFAULT_DDS_READER_TEST; + dds.opcode := READ; + dds.max_samples := 4; + dds.sstate := ANY_SAMPLE_STATE; + dds.istate := NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; + dds.vstate := ANY_VIEW_STATE; + dds.ret_code := RETCODE_OK; + start_dds; + wait_on_dds; + wait_on_idle; + -- MEM: I1S1, I1S2, I1S3- + -- ISTATE: I1:NO_WRITERS + -- WRITER: - + + 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; + + alert_prc : process(all) + begin + if rising_edge(clk) then + -- TODO + end if; + 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 = '1') then + dds_stage <= DONE; + dds_cnt <= 0; + end if; + when DONE => + if (done_dds = '1') then + AffirmIfEqual(ret_id, return_code_dds, dds.ret_code); + case (dds.ret_code) is + when RETCODE_OK => + case (dds.opcode) is + when GET_SAMPLE_REJECTED_STATUS => + dds_stage <= CHECK_SAMPLE_REJECT; + dds_cnt <= 0; + when others => + gen_collection(mem, col, dds, INSTANCE_PRESENTATION_QOS, FALSE); + dds_stage <= CHECK_SI; + dds_cnt <= 0; + end case; + when others => + dds_stage <= IDLE; + end case; + end if; + when CHECK_SI => + if (si_valid = '1') then + AffirmIfEqual(sstate_id, si_sample_state, col.s(dds_cnt).sstate); + AffirmIfEqual(vstate_id, si_view_state, col.s(dds_cnt).vstate); + AffirmIfEqual(istate_id, si_instance_state, col.s(dds_cnt).istate); + AffirmIfEqual(ts_id, convert_from_double_word(si_source_timestamp), convert_from_double_word(col.s(dds_cnt).ts)); + AffirmIfEqual(inst_id, to_unsigned(si_instance_handle), to_unsigned(col.s(dds_cnt).inst)); + AffirmIfEqual(pub_id, to_unsigned(si_publication_handle), to_unsigned(HANDLE_NIL)); + AffirmIfEqual(dis_gen_cnt_id, si_disposed_generation_count, std_logic_vector(to_unsigned(col.s(dds_cnt).dis_gen_cnt,WORD_WIDTH))); + AffirmIfEqual(no_w_gen_cnt_id, si_no_writers_generation_count, std_logic_vector(to_unsigned(col.s(dds_cnt).no_w_gen_cnt,WORD_WIDTH))); + AffirmIfEqual(srank_id, si_sample_rank, std_logic_vector(to_unsigned(col.s(dds_cnt).srank,WORD_WIDTH))); + AffirmIfEqual(grank_id, si_generation_rank, std_logic_vector(to_unsigned(col.s(dds_cnt).grank,WORD_WIDTH))); + AffirmIfEqual(agrank_id, si_absolute_generation_rank, std_logic_vector(to_unsigned(col.s(dds_cnt).agrank,WORD_WIDTH))); + if (si_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 = '0', "EOC pulled high"); + when CHECK_DATA => + if (valid_out_dds = '1') then + AffirmIfEqual(data_id, data_out_dds, 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 /= '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 = '1') then + dds_stage <= IDLE; + end if; + when CHECK_SAMPLE_REJECT => + if (valid_out_dds = '1') then + dds_cnt <= dds_cnt + 1; + case (dds_cnt) is + when 0 => + AffirmIfEqual(data_id, data_out_dds, std_logic_vector(to_unsigned(dds.count,CDR_LONG_WIDTH))); + when 1 => + AffirmIfEqual(data_id, data_out_dds, std_logic_vector(to_unsigned(dds.change,CDR_LONG_WIDTH))); + when 2 => + AffirmIfEqual(data_id, data_out_dds, dds.last_reason); + when 3 => + AffirmIfEqual(data_id, data_out_dds, std_logic_vector(dds.inst(0))); + when 4 => + AffirmIfEqual(data_id, data_out_dds, std_logic_vector(dds.inst(1))); + when 5 => + AffirmIfEqual(data_id, data_out_dds, std_logic_vector(dds.inst(2))); + when 6 => + AffirmIfEqual(data_id, data_out_dds, std_logic_vector(dds.inst(3))); + AlertIf(data_id, last_word_out_dds /= '1', "Last Word Signal not pulled High", ERROR); + dds_stage <= IDLE; + when others => + null; + end case; + end if; + end case; + end if; + + -- DEFAULT + start_dds <= '0'; + opcode_dds <= NOP; + instance_state_dds <= ANY_INSTANCE_STATE; + view_state_dds <= ANY_VIEW_STATE; + sample_state_dds <= ANY_SAMPLE_STATE; + instance_handle_dds <= HANDLE_NIL; + max_samples_dds <= (others => '0'); + get_data_dds <= '0'; + ready_out_dds <= '0'; + + + case (dds_stage ) is + when START => + start_dds <= '1'; + opcode_dds <= dds.opcode; + instance_state_dds <= dds.istate; + view_state_dds <= dds.vstate; + sample_state_dds <= dds.sstate; + instance_handle_dds <= dds.inst; + max_samples_dds <= std_logic_vector(to_unsigned(dds.max_samples, WORD_WIDTH)); + when CHECK_SI => + if (si_valid = '1' and si_valid_data = '1') then + get_data_dds <= '1'; + end if; + when CHECK_DATA => + ready_out_dds <= '1'; + when CHECK_SAMPLE_REJECT => + ready_out_dds <= '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 = '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 = '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 = '1') then + AffirmIfEqual(ret_id, HISTORY_CACHE_RESPONSE_TYPE'pos(ret_rtps), HISTORY_CACHE_RESPONSE_TYPE'pos(rtps.ret_code)); + rtps_stage <= IDLE; + end if; + end case; + end if; + + -- DEFAULT + start_rtps <= '0'; + opcode_rtps <= NOP; + valid_in_rtps <= '0'; + last_word_in_rtps <= '0'; + data_in_rtps <= (others => '0'); + + case (rtps_stage) is + when START => + start_rtps <= '1'; + opcode_rtps <= rtps.opcode; + case (rtps.opcode) is + when REMOVE_WRITER => + data_in_rtps <= std_logic_vector(to_unsigned(rtps.writer_pos,WORD_WIDTH)); + when others => + null; + end case; + when PUSH => + valid_in_rtps <= '1'; + data_in_rtps <= stimulus.data(rtps_cnt); + last_word_in_rtps <= stimulus.last(rtps_cnt); + when others => + null; + end case; + end process; + + kh_prc : process (all) + variable tmp_key_hash : INSTANCE_HANDLE_TYPE := HANDLE_NIL; + begin + if rising_edge(clk) then + case (kh_stage) is + when IDLE => + if (start_kh = '1') then + case (opcode_kh) is + when PUSH_DATA => + kh_stage <= READ_DATA; + kh_cnt <= 0; + kh_data <= EMPTY_TEST_PACKET; + when PUSH_SERIALIZED_KEY => + kh_stage <= READ_DATA; + kh_cnt <= 0; + kh_data <= EMPTY_TEST_PACKET; + when READ_KEY_HASH => + kh_stage <= PUSH_KEY_HASH; + kh_cnt <= 0; + when others => + Alert("Unexpected Key Holder Operation", FAILURE); + end case; + end if; + when READ_DATA => + if (valid_out_kh = '1') then + kh_data.data(kh_cnt) <= data_out_kh; + kh_data.last(kh_cnt) <= last_word_out_kh; + kh_data.length <= kh_data.length + 1; + + kh_cnt <= kh_cnt + 1; + if (last_word_out_kh = '1') then + kh_stage <= IDLE; + end if; + end if; + when PUSH_KEY_HASH => + if (ready_in_kh = '1') then + kh_cnt <= kh_cnt + 1; + if (kh_cnt = INSTANCE_HANDLE_TYPE'length-1) then + kh_stage <= IDLE; + end if; + end if; + end case; + end if; + + -- DEFAULT + ack_kh <= '0'; + ready_out_kh <= '0'; + valid_in_kh <= '0'; + data_in_kh <= (others => '0'); + last_word_in_kh <= '0'; + + case (kh_stage) is + when IDLE => + if (start_kh = '1') then + ack_kh <= '1'; + end if; + when READ_DATA => + ready_out_kh <= '1'; + when PUSH_KEY_HASH => + valid_in_kh <= '1'; + tmp_key_hash := extract_key_hash(kh_data); + data_in_kh <= tmp_key_hash(kh_cnt); + if (kh_cnt = INSTANCE_HANDLE_TYPE'length-1) then + last_word_in_kh <= '1'; + end if; + end case; + end process; + + watchdog : process + begin + wait for 1 ms; + Alert("Test timeout", FAILURE); + std.env.stop; + end process; + +end architecture; \ No newline at end of file diff --git a/src/Tests/testbench.pro b/src/Tests/testbench.pro index d1e01c8..36baa8a 100644 --- a/src/Tests/testbench.pro +++ b/src/Tests/testbench.pro @@ -80,7 +80,8 @@ analyze ../dds_reader.vhd #analyze Level_0/L0_dds_reader_test4_arzkriu.vhd #analyze Level_0/L0_dds_reader_test4_arznriu.vhd #analyze Level_0/L0_dds_reader_test5_arzkriu.vhd -analyze Level_0/L0_dds_reader_test6_arzkriu.vhd +#analyze Level_0/L0_dds_reader_test6_arzkriu.vhd +analyze Level_0/L0_dds_reader_test7_arzkriu.vhd #simulate L0_rtps_handler_test1 #simulate L0_rtps_handler_test2 @@ -142,4 +143,5 @@ analyze Level_0/L0_dds_reader_test6_arzkriu.vhd #simulate L0_dds_reader_test4_arzkriu #simulate L0_dds_reader_test4_arznriu #simulate L0_dds_reader_test5_arzkriu -simulate L0_dds_reader_test6_arzkriu \ No newline at end of file +#simulate L0_dds_reader_test6_arzkriu +simulate L0_dds_reader_test7_arzkriu \ No newline at end of file