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 DDS handling of the DDS Reader. It tests the correctness of the DDS READ, TAKE, READ_NEXT_SAMPLE, TAKE_NEXT_SAMPLE, -- READ_INSTANCE, TAKE_INSTANCE, READ_NEXT_INSTANCE, TAKE_NEXT_INSTANCE Operations. -- More specifically the testbench covers following tests: -- TEST: READ [NO COMPATIBLE SAMPLES] -- TEST: READ [NO SAMPLES] -- TEST: READ [MAX_SAMPLES < SAMPLES] -- TEST: READ [MAX_SAMPLES > SAMPLES] -- TEST: TAKE [NO SAMPLES] -- TEST: TAKE -- TEST: READ [ANY SSTATE, ANY ISTATE, ANY VIEW] -- TEST: READ [ANY SSTATE, ANY ISTATE, SPECIFIED VIEW] -- TEST: READ [ANY SSTATE, SPECIFIED ISTATE, ANY VIEW] -- TEST: READ [ANY SSTATE, SPECIFIED ISTATE, SPECIFIED VIEW] -- TEST: READ [SPECIFIED SSTATE, ANY ISTATE, ANY VIEW] -- TEST: READ [SPECIFIED SSTATE, ANY ISTATE, SPECIFIED VIEW] -- TEST: READ [SPECIFIED SSTATE, SPECIFIED ISTATE, ANY VIEW] -- TEST: READ [SPECIFIED SSTATE, SPECIFIED ISTATE, SPECIFIED VIEW] -- TEST: READ_NEXT_SAMPLE [WITH UNREAD SAMPLE] -- TEST: READ_NEXT_SAMPLE [WITHOUT UNREAD SAMPLE] -- TEST: READ_NEXT_SAMPLE [NO SAMPLE] -- TEST: TAKE_NEXT_SAMPLE [NO SAMPLE] -- TEST: TAKE_NEXT_SAMPLE -- TEST: READ_INSTANCE [UNKNOWN INSTANCE] -- TEST: READ_INSTANCE [KNOWN INSTANCE, UNCOMPATIBLE SAMPLES] -- TEST: READ_INSTANCE [KNOWN INSTANCE, COMPATIBLE SAMPLES] -- TEST: READ_INSTANCE [NO SAMPLES] -- TEST: TAKE_INSTANCE [NO SAMPLES] -- TEST: TAKE_INSTANCE -- TEST: READ_NEXT_INSTANCE [WITH SAMPLES, WITHOUT NEXT INSTANCE] -- TEST: READ_NEXT_INSTANCE [WITH NEXT INSTANCE, UNCOMPATIBLE SAMPLES] -- TEST: READ_NEXT_INSTANCE [WITH NEXT INSTANCE, COMPATIBLE SAMPLES] -- TEST: READ_NEXT_INSTANCE [HANDLE_NIL] -- TEST: READ_NEXT_INSTANCE [WITH NEXT INSTANCE, WITH COMPATIBLE SAMPLE, NOT DIRECT NEXT INSTANCE] -- TEST: READ_NEXT_INSTANCE [NO SAMPLE] -- TEST: TAKE_NEXT_INSTANCE [NO SAMPLE] -- TEST: TAKE_NEXT_INSTANCE -- TEST: GET ALL DATA WITH READ_NEXT_INSTANCE -- TEST: READ MARKS SAMPLES AS READ -- TEST: TAKE REMOVES SAMPLE -- TEST: READ MODIFIES VIEW STATE [READ PREVIOUS GENERATION] -- TEST: READ MODIFIES VIEW STATE [READ CURRENT GENERATION] entity L0_dds_reader_test3_arzkrio is end entity; architecture testbench of L0_dds_reader_test3_arzkrio is -- *CONSTANT DECLARATION* constant MAX_REMOTE_ENDPOINTS : natural := 3; -- *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); -- *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 := '0'; signal opcode_rtps : HISTORY_CACHE_OPCODE_TYPE := NOP; signal opcode_dds : DDS_READER_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 data_in_rtps, data_out_dds : std_logic_vector(WORD_WIDTH-1 downto 0) := (others => '0'); signal get_data_dds, si_valid_data, si_valid, eoc : 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 : INSTANCE_HANDLE_TYPE := HANDLE_NIL; 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 : 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_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 : 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(15,CDR_LONG_WIDTH)), MAX_INSTANCES => std_logic_vector(to_unsigned(4,CDR_LONG_WIDTH)), MAX_SAMPLES_PER_INSTANCE => std_logic_vector(to_unsigned(15,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 => TRUE, 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_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_state => si_sample_state, sample_info.view_state => si_view_state, sample_info.instance_state => si_instance_state, sample_info.source_timestamp => si_source_timestamp, sample_info.instance_handle => si_instance_handle, sample_info.publication_handle => si_publication_handle, sample_info.disposed_generation_count => si_disposed_generation_count, sample_info.no_writers_generation_count => si_no_writers_generation_count, sample_info.sample_rank => si_sample_rank, sample_info.generation_rank => si_generation_rank, sample_info.absolute_generation_rank => si_absolute_generation_rank, sample_info.valid_data => si_valid_data, sample_info_valid => si_valid, sample_info_ack => '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_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("L0_dds_reader_test3_arzkrio - (KEEP ALL, Reliable, Zero TIME_BASED_FILTER, Keyed, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER, ACCESS SCOPE Instance, Ordered) - DDS Handling"); SetAlertEnable(FAILURE, TRUE); SetAlertEnable(ERROR, TRUE); SetAlertEnable(WARNING, TRUE); SetLogEnable(DEBUG, TRUE); 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); -- Key Hashes kh1 := (x"F12C31DA", x"E3FE0F3F", x"01F36685", x"446518CA"); kh2 := (x"BC070AC4", x"0BAB5811", x"14EA8D61", x"F669189B"); kh3 := (x"0CEAB0C6", x"FA04B9AD", x"A96EB495", x"4E0EB999"); kh4 := (x"A7EB605C", x"FF4BEF3A", x"3C5E8724", x"CCA0CA67"); 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: - -- VIEW: - -- 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(0,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 0, Aligned Payload, ID 0] (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(0) -- ISTATE: I1:ALIVE -- VIEW: I1:NEW -- WRITER: W0:I1 Log("Current Time: 1s", INFO); check_time <= gen_duration(1,0); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := TRUE; cc.kind := NOT_ALIVE_DISPOSED; cc.instance := kh1; cc.payload := gen_payload(kh1,5); cc.src_timestamp := gen_duration(1,0); Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 1, Writer 0, ID 1] (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,NOT_ALIVE_DISPOSED_INSTANCE_STATE); add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); start_rtps; wait_on_rtps; wait_on_idle; -- MEM: I1S1(0), I1S2-(1) -- ISTATE: I1:DISPOSED -- VIEW: I1:NEW -- WRITER: W0:I1 Log("Current Time: 2s", INFO); check_time <= gen_duration(2,0); 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 := kh2; cc.payload := gen_payload(kh2,10); cc.src_timestamp := gen_duration(2,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 2, Writer 1, Aligned Payload, ID 2] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 1; 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(0), I1S2-(1), I2S1(2) -- ISTATE: I1:DISPOSED, I2:ALIVE -- VIEW: I1:NEW, I2:NEW -- WRITER: W0:I1, W1:I2 Log("Current Time: 3s", INFO); check_time <= gen_duration(3,0); 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,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 3, Writer 2, Aligned Payload, ID 3] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; 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(0), I1S2-(1), I2S1(2), I3S1(3) -- ISTATE: I1:DISPOSED, I2:ALIVE, I3:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW -- WRITER: W0:I1, W1:I2, W2:I3 Log("Current Time: 4s", INFO); check_time <= gen_duration(4,0); 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 := kh4; cc.payload := gen_payload(kh4,10); cc.src_timestamp := gen_duration(4,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 4, Writer 2, Aligned Payload, ID 4] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; 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(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), -- ISTATE: I1:DISPOSED, I2:ALIVE, I3:ALIVE, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 5s", INFO); check_time <= gen_duration(5,0); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := TRUE; cc.kind := NOT_ALIVE_DISPOSED; cc.instance := kh2; cc.payload := gen_payload(kh2,5); cc.src_timestamp := gen_duration(5,0); Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 2, Writer 1, ID 5] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 1; rtps.ret_code := OK; s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE); add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); start_rtps; wait_on_rtps; wait_on_idle; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5) -- ISTATE: I1:DISPOSED, I2:DISPOSED, I3:ALIVE, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 6s", INFO); check_time <= gen_duration(6,0); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := TRUE; cc.kind := NOT_ALIVE_DISPOSED; cc.instance := kh3; cc.payload := gen_payload(kh3,5); cc.src_timestamp := gen_duration(6,0); Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 3, Writer 2, ID 6] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; rtps.ret_code := OK; s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE); add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); start_rtps; wait_on_rtps; wait_on_idle; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6) -- ISTATE: I1:DISPOSED, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 7s", INFO); check_time <= gen_duration(7,0); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := TRUE; cc.kind := NOT_ALIVE_DISPOSED; cc.instance := kh4; cc.payload := gen_payload(kh4,5); cc.src_timestamp := gen_duration(7,0); Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 4, Writer 2, ID 7] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; rtps.ret_code := OK; s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE); add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); start_rtps; wait_on_rtps; wait_on_idle; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7) -- ISTATE: I1:DISPOSED, I2:DISPOSED, I3:DISPOSED, I4:DISPOSED -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 8s", INFO); check_time <= gen_duration(8,0); 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 := kh4; cc.payload := gen_payload(kh4,10); cc.src_timestamp := gen_duration(8,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 4, Writer 2, Aligned Payload, ID 8] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 2; 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(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8) -- ISTATE: I1:DISPOSED, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 9s", INFO); check_time <= gen_duration(9,0); 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(9,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 1, Writer 0, Aligned Payload, ID 9] (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(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 10s", INFO); check_time <= gen_duration(10,0); 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 := kh2; cc.payload := gen_payload(kh2,10); cc.src_timestamp := gen_duration(10,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 2, Writer 1, Aligned Payload, ID 10] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 1; 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(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10) -- ISTATE: I1:ALIVE, I2:ALIVE, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 11s", INFO); check_time <= gen_duration(11,0); wait until rising_edge(clk); wait until rising_edge(clk); wait_on_idle; cc := DEFAULT_CACHE_CHANGE; cc.serialized_key := TRUE; cc.kind := NOT_ALIVE_DISPOSED; cc.instance := kh2; cc.payload := gen_payload(kh2,5); cc.src_timestamp := gen_duration(11,0); Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 2, Writer 1, ID 11] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 1; rtps.ret_code := OK; s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE); add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS); start_rtps; wait_on_rtps; wait_on_idle; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [MAX_SAMPLES < SAMPLES] -- TEST: READ [ANY SSTATE, ANY ISTATE, ANY VIEW] Log("DDS Operation READ [MAX_SAMPLES 1, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID0,ID1,ID9)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 3; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ MARKS SAMPLES AS READ -- TEST: READ_NEXT_SAMPLE [WITH UNREAD SAMPLE] Log("DDS Operation READ_NEXT_SAMPLE (Expected ID2)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_SAMPLE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_INSTANCE [KNOWN INSTANCE, COMPATIBLE SAMPLES] Log("DDS Operation READ_INSTANCE [MAX_SAMPLES 1, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 3] (Expected ID3)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_INSTANCE; dds.max_samples := 1; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh3; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_INSTANCE [WITH NEXT INSTANCE, COMPATIBLE SAMPLES] Log("DDS Operation READ_NEXT_INSTANCE [MAX_SAMPLES 1, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 3] (Expected ID4)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_INSTANCE; dds.max_samples := 1; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh3; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [SPECIFIED SSTATE, ANY ISTATE, ANY VIEW] -- TEST: READ [MAX_SAMPLES > SAMPLES] Log("DDS Operation READ [MAX_SAMPLES 20, READ_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID0,ID1,ID9,ID2,ID3,ID4)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := READ_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [SPECIFIED SSTATE, SPECIFIED ISTATE, ANY VIEW] Log("DDS Operation READ [MAX_SAMPLES 20, READ_SAMPLE_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID2,ID3)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := READ_SAMPLE_STATE; dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [SPECIFIED SSTATE, ANY ISTATE, SPECIFIED VIEW] -- TEST: READ MODIFIES VIEW STATE [READ CURRENT GENERATION] -- TEST: READ MODIFIES VIEW STATE [READ PREVIOUS GENERATION] Log("DDS Operation READ [MAX_SAMPLES 20, READ_SAMPLE_STATE, ANY_INSTANCE_STATE, NEW_VIEW_STATE] (Expected ID2,ID4)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := READ_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := NEW_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [SPECIFIED SSTATE, SPECIFIED ISTATE, SPECIFIED VIEW] Log("DDS Operation READ [MAX_SAMPLES 20, READ_SAMPLE_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE, NEW_VIEW_STATE] (Expected ID2)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := READ_SAMPLE_STATE; dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds.vstate := NEW_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [ANY SSTATE, ANY ISTATE, SPECIFIED VIEW] Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, NOT_NEW_VIEW_STATE] (Expected ID0,ID1,ID9,ID3,ID6)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := NOT_NEW_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [ANY SSTATE, SPECIFIED ISTATE, SPECIFIED VIEW] Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE, NOT_NEW_VIEW_STATE] (Expected ID3,ID6)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds.vstate := NOT_NEW_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [ANY SSTATE, SPECIFIED ISTATE, ANY VIEW] Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID2,ID5,ID10,ID11,ID3,ID6)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_INSTANCE [UNKNOWN INSTANCE] Log("DDS Operation READ_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Unknown Instance] (Bad Parameter)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh5; dds.ret_code := RETCODE_BAD_PARAMETER; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_INSTANCE [KNOWN INSTANCE, UNCOMPATIBLE SAMPLES] Log("DDS Operation READ_INSTANCE [MAX_SAMPLES 20, NOT_READ_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 1] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_INSTANCE; dds.max_samples := 20; dds.sstate := NOT_READ_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh1; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_INSTANCE [WITH NEXT INSTANCE, UNCOMPATIBLE SAMPLES] Log("DDS Operation READ_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE, ANY_VIEW_STATE, Instance 2] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh2; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_INSTANCE [WITH NEXT INSTANCE, WITH COMPATIBLE SAMPLE, NOT DIRECT NEXT INSTANCE] Log("DDS Operation READ_NEXT_INSTANCE [MAX_SAMPLES 20, NOT_READ_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 3] (Expected ID7,ID8)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := NOT_READ_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh3; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ [NO COMPATIBLE SAMPLES] Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, NOT_ALIVE_NO_WRITERS_INSTANCE_STATE, ANY_VIEW_STATE] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; 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; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_SAMPLE [WITHOUT UNREAD SAMPLE] Log("DDS Operation READ_NEXT_SAMPLE (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_SAMPLE; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S1(0), I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE Log("DDS Operation TAKE [MAX_SAMPLES 1, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID0)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE; dds.max_samples := 1; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: I1S2-(1), I2S1(2), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE_INSTANCE Log("DDS Operation TAKE_INSTANCE [MAX_SAMPLES 1, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 2] (Expected ID2)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_INSTANCE; dds.max_samples := 1; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh2; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: I1S2-(1), I3S1(3), I4S1(4), I2S2-(5), I3S2-(6), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE_NEXT_INSTANCE -- TEST: READ_NEXT_INSTANCE [HANDLE_NIL] Log("DDS Operation TAKE_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, HANDLE_NIL] (Expected ID3,ID6)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := HANDLE_NIL; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: I1S2-(1), I4S1(4), I2S2-(5), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE REMOVES SAMPLE -- TEST: READ_INSTANCE [NO SAMPLES] Log("DDS Operation READ_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 3] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh3; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S2-(1), I4S1(4), I2S2-(5), I4S2-(7), I4S3(8), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("DDS Operation TAKE_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 3] (Expected ID4,ID7,ID8)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh3; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: I1S2-(1), I2S2-(5), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE_INSTANCE [NO SAMPLES] Log("DDS Operation TAKE_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 4] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh4; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S2-(1), I2S2-(5), I1S3(9), I2S3(10), I2S4-(11) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("DDS Operation TAKE_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 4] (Expected ID5,ID10,ID11)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh4; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: I1S2-(1), I1S3(9) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("DDS Operation READ_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 2] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh2; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S2-(1), I1S3(9) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_INSTANCE [WITH SAMPLES, WITHOUT NEXT INSTANCE] Log("DDS Operation READ_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 1] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh1; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: I1S2-(1), I1S3(9) -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("DDS Operation TAKE_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 2] (Expected ID1,ID9)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := kh2; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: GET ALL DATA WITH READ_NEXT_INSTANCE -- TEST: READ [NO SAMPLES] Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE [NO SAMPLES] Log("DDS Operation TAKE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_INSTANCE [NO SAMPLE] Log("DDS Operation READ_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, HANDLE_NIL] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := HANDLE_NIL; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE_NEXT_INSTANCE [NO SAMPLE] Log("DDS Operation TAKE_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, HANDLE_NIL] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_INSTANCE; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.inst := HANDLE_NIL; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: READ_NEXT_SAMPLE [NO SAMPLE] Log("DDS Operation READ_NEXT_SAMPLE (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ_NEXT_SAMPLE; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE_NEXT_SAMPLE [NO SAMPLE] Log("DDS Operation TAKE_NEXT_SAMPLE (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_SAMPLE; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:DISPOSED, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("Current Time: 12s", INFO); check_time <= gen_duration(12,0); 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 := kh2; cc.payload := gen_payload(kh2,10); cc.src_timestamp := gen_duration(12,0); Log("RTPS Operation ADD_CACHE_CHANGE [KEY_HASH, Instance 2, Writer 1, Aligned Payload, ID 12] (ACCEPTED)", INFO); rtps := DEFAULT_RTPS_READER_TEST; rtps.opcode := ADD_CACHE_CHANGE; rtps.cc := cc; rtps.writer_pos := 1; 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: I2S5(12) -- ISTATE: I1:ALIVE, I2:ALIVE, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 -- TEST: TAKE_NEXT_SAMPLE Log("DDS Operation TAKE_NEXT_SAMPLE (Expected ID12)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := TAKE_NEXT_SAMPLE; dds.ret_code := RETCODE_OK; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:ALIVE, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (No Data)", INFO); dds := DEFAULT_DDS_READER_TEST; dds.opcode := READ; dds.max_samples := 20; dds.sstate := ANY_SAMPLE_STATE; dds.istate := ANY_INSTANCE_STATE; dds.vstate := ANY_VIEW_STATE; dds.ret_code := RETCODE_NO_DATA; start_dds; wait_on_dds; -- MEM: - -- ISTATE: I1:ALIVE, I2:ALIVE, I3:DISPOSED, I4:ALIVE -- VIEW: I1:NOT_NEW, I2:NOT_NEW, I3:NOT_NEW, I4:NOT_NEW -- WRITER: W0:I1, W1:I2, W2:I3,I4 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 => gen_collection(mem, col, dds, INSTANCE_PRESENTATION_QOS, TRUE); dds_stage <= CHECK_SI; dds_cnt <= 0; when others => dds_stage <= IDLE; end case; end if; when CHECK_SI => if (si_valid = '1') then Log("Read Sample ID" & to_string(to_integer(si_source_timestamp(0))), DEBUG); 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, to_unsigned(si_source_timestamp), to_unsigned(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; 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 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; watchdog : process begin wait for 1 ms; Alert("Test timeout", FAILURE); std.env.stop; end process; end architecture;