greek64/rtps-fpga
2
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add test 3 of the DDS Reader

Browse Source 
Test the DDS READ, TAKE, READ_NEXT_SAMPLE, TAKE_NEXT_SAMPLE,
READ_INSTANCE, TAKE_INSTANCE, READ_NEXT_INSTANCE, TAKE_NEXT_INSTANCE
Operations.
Backport fixes to previous testbenches.
Change handling of DISPOSE Samples of unknown Instances.
This commit is contained in:
Greek 2021-04-23 19:56:51 +02:00
parent 5a0eeef1e6
commit 0beafe13b3
31 changed files with 10978 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sim/L0_dds_reader_test1_abzkriu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

3
sim/L0_dds_reader_test1_arzkriu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

3
sim/L0_dds_reader_test1_arzksiu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

3
sim/L0_dds_reader_test1_arznriu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

3
sim/L0_dds_reader_test1_lbzkriu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

3
sim/L0_dds_reader_test1_lrzkriu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

3
sim/L0_dds_reader_test2_arpkriu.do
View File

@ -18,17 +18,20 @@ radix define DDS_RETCODE {
radix define SAMPLE_STATE {
"16#00000001#" "READ_SAMPLE_STATE",
"16#00000002#" "NOT_READ_SAMPLE_STATE",
"16#FFFFFFFF#" "ANY_SAMPLE_STATE",
-default binary
}
radix define VIEW_STATE {
"16#00000001#" "NEW_VIEW_STATE",
"16#00000002#" "NOT_NEW_VIEW_STATE",
"16#FFFFFFFF#" "ANY_VIEW_STATE",
-default binary
}
radix define INSTANCE_STATE {
"16#00000001#" "ALIVE_INSTANCE_STATE",
"16#00000002#" "NOT_ALIVE_DISPOSED_INSTANCE_STATE",
"16#00000004#" "NOT_ALIVE_NO_WRITERS_INSTANCE_STATE",
"16#FFFFFFFF#" "ANY_INSTANCE_STATE",
-default binary
}
quietly WaveActivateNextPane {} 0

199
sim/L0_dds_reader_test3_arzkrio.do Normal file
View File

File diff suppressed because one or more lines are too long

199
sim/L0_dds_reader_test3_arzkriu.do Normal file
View File

File diff suppressed because one or more lines are too long

199
sim/L0_dds_reader_test3_arzkrto.do Normal file
View File

File diff suppressed because one or more lines are too long

199
sim/L0_dds_reader_test3_arzkrtu.do Normal file
View File

File diff suppressed because one or more lines are too long

201
sim/L0_dds_reader_test3_arzksto.do Normal file
View File

File diff suppressed because one or more lines are too long

178
sim/L0_dds_reader_test3_arznriu.do Normal file
View File

File diff suppressed because one or more lines are too long

22
src/TODO.txt
View File

@ -345,9 +345,8 @@ DESIGN DECISIONS
that it now has a live writer again. On the other hand there is no transition from NOT_ALIVE_DISPOSED
to NOT_ALIVE_NO_WRITERS.
* Unregister/Dispose/Filtered Samples of unknown Instances are droped. Note that if a previous ALIVE
instance went to an NOT_ALIVE_NO_WRITERS state and was subsequently pushed out of the memory will
miss the transition to NOT_ALIVE_DISPOSED if a writer than decides to sent a Dispose Sample.
* Unregister/Filtered Samples of unknown Instances are droped. On the other hand, Dispose Samples of
unknown Instances are accepted (Implicitly adding the new Instance).
* The DDS Specification is not entirely clear on what happens in the DDS Reader on reception of
Meta Samples (Unregister/Dispose Samples). One simple solution would be to make Data-less Samples for
@ -355,14 +354,22 @@ DESIGN DECISIONS
visible from the Sample info (e.g. Unregister on Instance with still alive Writers or Dispose from
another Writer on already disposed Instance), it does not seem practical. (In effect only the source
timestamp and publication handle of the Sample Info could be different).
Taking this into consideration, thsi DDS Reader implementation only generates data-less samples if
Taking this into consideration, this DDS Reader implementation only generates data-less samples if
an Instance State is triggered. Filtered Cache Changes also do not produce any Samples visible to the
user (But affect internal state, like DEADLINE and LIVELINESS state).
* In BY_SOURCE_TIMESTAMP DESTINATION_ORDER_QOS we only allow NOT_ALIVE Samples (Unregister/Dispose) to
be added to the memory, if no newer sample of the same Instance exists. This decision was made,
because otherwise we would have to rewrite the entire Instance History and recalculate State and
Generation Counters. By dropping NOT_ALIVE samples that are in the past the Instance State is always
valid and does not have to be recalculated.
This is the only case in which a Dispose Sample can be missed/dropped, and may lead to different
Data Readers having different Generation Counters (depending on their reception order).
PROTOCOL UNCOMPLIANCE
=====================
* Partition QoS
* Coherent Sets
* Partition QoS Not Supported
* Coherent Sets Not Supported
* Built-in Endpoint is NOT the same as a normal Endpoint
-> No User access to Data
* Known but unused Submessage IDs are treated as uknown
@ -370,7 +377,8 @@ PROTOCOL UNCOMPLIANCE
* Inline QoS validated in Endpoint
-> Cannot invalidate Rest of Message/Packet
* RESOURCE_LIMITS applies also to "empty" samples (Samples with no valid data).
* Write/Dispose/Untergister Operation do not return (TIMEOUT). I.e. the MAX_BLOCKING_TIME is not used.
* Write/Dispose/Untergister Operations do not return (TIMEOUT). I.e. the MAX_BLOCKING_TIME is not used.
RTPS ENDPOINT

81
src/Tests/Level_0/L0_dds_reader_test1_abzkriu.vhd
View File

@ -629,24 +629,6 @@ begin
start_rtps;
wait_on_rtps;
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(8,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 1, Writer 0] (IGNORED)", 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;
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := FALSE;
cc.kind := ALIVE;
@ -1148,14 +1130,73 @@ begin
-- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE
-- WRITER: W0:I2, W2:I1,I3
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := TRUE;
cc.kind := NOT_ALIVE_UNREGISTERED;
cc.instance := kh2;
cc.payload := gen_payload(kh2,5);
cc.src_timestamp := gen_duration(27,0);
Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 2, Writer 0] (ACCEPTED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 0;
s := to_sample(cc,NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I1S4-, I1S5-, I3S3, I2S2-
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation TAKE [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: 0, 0, 0, 0
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
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(28,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 4, Writer 1] (ACCPETED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 1;
s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I4S1-, 0, 0, 0
-- ISTATE: I1:ALIVE, I3: ALIVE, I4:DISPOSED
-- WRITER: W1:I4, W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;

81
src/Tests/Level_0/L0_dds_reader_test1_arzkriu.vhd
View File

@ -636,24 +636,6 @@ begin
start_rtps;
wait_on_rtps;
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(8,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 1, Writer 0] (IGNORED)", 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;
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := FALSE;
cc.kind := ALIVE;
@ -1157,14 +1139,73 @@ begin
-- ISTATE: I1:ALIVE, I2:ALIVE, I3: ALIVE
-- WRITER: W0:I2, W2:I1,I3
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := TRUE;
cc.kind := NOT_ALIVE_UNREGISTERED;
cc.instance := kh2;
cc.payload := gen_payload(kh2,5);
cc.src_timestamp := gen_duration(21,0);
Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 2, Writer 0] (ACCEPTED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 0;
s := to_sample(cc,NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I1S4-, I1S5-, I3S3, I2S2-
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation TAKE [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: 0, 0, 0, 0
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
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(22,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 4, Writer 1] (ACCPETED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 1;
s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I4S1-, 0, 0, 0
-- ISTATE: I1:ALIVE, I3: ALIVE, I4:DISPOSED
-- WRITER: W1:I4, W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;

81
src/Tests/Level_0/L0_dds_reader_test1_arzksiu.vhd
View File

@ -636,24 +636,6 @@ begin
start_rtps;
wait_on_rtps;
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(8,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 1, Writer 0] (IGNORED)", 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;
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := FALSE;
cc.kind := ALIVE;
@ -1152,14 +1134,73 @@ begin
start_rtps;
wait_on_rtps;
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := TRUE;
cc.kind := NOT_ALIVE_UNREGISTERED;
cc.instance := kh2;
cc.payload := gen_payload(kh2,5);
cc.src_timestamp := gen_duration(21,0);
Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 2, Writer 0] (ACCEPTED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 0;
s := to_sample(cc,NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I1S4-, I1S5-, I2S2-, 0
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation TAKE [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: 0, 0, 0, 0
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
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(22,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 4, Writer 1] (ACCPETED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 1;
s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I4S1-, 0, 0, 0
-- ISTATE: I1:ALIVE, I3: ALIVE, I4:DISPOSED
-- WRITER: W1:I4, W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;

21
src/Tests/Level_0/L0_dds_reader_test1_arznriu.vhd
View File

@ -13,6 +13,27 @@ use work.rtps_test_package.all;
-- This testbench tests the RTPS handling of the DDS Reader. It tests the correctness of the RTPS ADD_CACHE_CHANGE, and REMOVE_WRITER Operations.
-- Implicitly some DDS Operations are also tested, since they are used for state checking.
-- More specifically the testbench covers following tests:
-- TEST: NORMAL ADD_CACHE_CHANGE
-- TEST: ADD_CACHE_CHANGE ON PAYLOAD MEMORY FULL
-- TEST: REMOVE_WRITER [UNKNOWN WRITER]
-- TEST: REMOVE_WRITER [KNOWN WRITER]
-- TEST: SAMPLE WITH ALIGNED PAYLOAD
-- TEST: SAMPLE WITH UNALIGNED PAYLOAD [<1 SLOT]
-- TEST: SAMPLE WITH UNALIGNED PAYLOAD [>1 SLOT]
-- TEST: NORMAL SAMPLE
-- TEST: UNREGISTER SAMPLE [UNKNOWN WRITER]
-- TEST: UNREGISTER SAMPLE [KNOWN WRITER]
-- TEST: UNREGISTER SAMPLE [NOT_ALIVE_NO_WRITERS INSTANCE]
-- TEST: UNREGISTER SAMPLE [NOT_ALIVE_DISPOSED INSTANCE]
-- TEST: DISPOSE SAMPLE
-- TEST: DISPOSE SAMPLE [NOT_ALIVE_NO_WRITERS INSTANCE]
-- TEST: DISPOSE SAMPLE [NOT_ALIVE_DISPOSED INSTANCE]
-- TEST: FILTER SAMPLE
-- TEST: FILTER SAMPLE [NOT_ALIVE_DISPOSED INSTANCE]
-- TEST: FILTER SAMPLE [NOT_ALIVE_NO_WRITERS INSTANCE]
-- TEST: SAMPLE WITH EARLY TIMESTAMP [TIMESTAMP EARLIER THAN LAST READ]
-- TEST: ADD SAMPLE ON MAX_SAMPLES
-- TEST: ADD SAMPLE BIGGER THAN AVAILABLE MEMORY SPACE
entity L0_dds_reader_test1_arznriu is
end entity;

81
src/Tests/Level_0/L0_dds_reader_test1_lbzkriu.vhd
View File

@ -628,24 +628,6 @@ begin
start_rtps;
wait_on_rtps;
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(8,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 1, Writer 0] (IGNORED)", 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;
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := FALSE;
cc.kind := ALIVE;
@ -1147,14 +1129,73 @@ begin
-- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE
-- WRITER: W0:I2, W2:I1,I3
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := TRUE;
cc.kind := NOT_ALIVE_UNREGISTERED;
cc.instance := kh2;
cc.payload := gen_payload(kh2,5);
cc.src_timestamp := gen_duration(27,0);
Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 2, Writer 0] (ACCEPTED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 0;
s := to_sample(cc,NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I1S4-, I1S5-, I3S3, I2S2-
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation TAKE [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: 0, 0, 0, 0
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
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(28,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 4, Writer 1] (ACCPETED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 1;
s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I4S1-, 0, 0, 0
-- ISTATE: I1:ALIVE, I3: ALIVE, I4:DISPOSED
-- WRITER: W1:I4, W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;

81
src/Tests/Level_0/L0_dds_reader_test1_lrzkriu.vhd
View File

@ -629,24 +629,6 @@ begin
start_rtps;
wait_on_rtps;
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(8,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 1, Writer 0] (IGNORED)", 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;
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := FALSE;
cc.kind := ALIVE;
@ -1148,14 +1130,73 @@ begin
-- ISTATE: I1:ALIVE, I2:ALIVE, I3:ALIVE
-- WRITER: W0:I2, W2:I1,I3
cc := DEFAULT_CACHE_CHANGE;
cc.serialized_key := TRUE;
cc.kind := NOT_ALIVE_UNREGISTERED;
cc.instance := kh2;
cc.payload := gen_payload(kh2,5);
cc.src_timestamp := gen_duration(27,0);
Log("RTPS Operation ADD_CACHE_CHANGE [UNREGISTER, Instance 2, Writer 0] (ACCEPTED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 0;
s := to_sample(cc,NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I1S4-, I1S5-, I3S3, I2S2-
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation TAKE [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: 0, 0, 0, 0
-- ISTATE: I1:ALIVE, I2:NO_WRITERS, I3: ALIVE
-- WRITER: W2:I1,I3
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(28,0);
-- TEST: DISPOSE SAMPLE [UNKNOWN INSTANCE]
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, Instance 4, Writer 1] (ACCPETED)", INFO);
rtps := DEFAULT_RTPS_READER_TEST;
rtps.opcode := ADD_CACHE_CHANGE;
rtps.cc := cc;
rtps.writer_pos := 1;
s := to_sample(cc,NOT_ALIVE_DISPOSED_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
rtps.ret_code := OK;
start_rtps;
wait_on_rtps;
-- MEM: I4S1-, 0, 0, 0
-- ISTATE: I1:ALIVE, I3: ALIVE, I4:DISPOSED
-- WRITER: W1:I4, W2:I1,I3
-- VALIDATE STATE
Log("DDS Operation READ [MAX_SAMPLES 4, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE]", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.opcode := TAKE;
dds.max_samples := 4;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.istate := NOT_ALIVE_DISPOSED_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;

1
src/Tests/Level_0/L0_dds_reader_test2_arpkriu.vhd
View File

@ -10,6 +10,7 @@ use work.user_config.all;
use work.rtps_config_package.all;
use work.rtps_test_package.all;
-- This testbench tests the handling of the TIME_BASED_FILTER QoS.
entity L0_dds_reader_test2_arpkriu is
end entity;

1564
src/Tests/Level_0/L0_dds_reader_test3_arzkrio.vhd Normal file
View File

File diff suppressed because it is too large Load Diff

1563
src/Tests/Level_0/L0_dds_reader_test3_arzkriu.vhd Normal file
View File

File diff suppressed because it is too large Load Diff

1563
src/Tests/Level_0/L0_dds_reader_test3_arzkrto.vhd Normal file
View File

File diff suppressed because it is too large Load Diff

1563
src/Tests/Level_0/L0_dds_reader_test3_arzkrtu.vhd Normal file
View File

File diff suppressed because it is too large Load Diff

1582
src/Tests/Level_0/L0_dds_reader_test3_arzksto.vhd Normal file
View File

File diff suppressed because it is too large Load Diff

923
src/Tests/Level_0/L0_dds_reader_test3_arznriu.vhd Normal file
View File

@ -0,0 +1,923 @@
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 [MAX_SAMPLES < SAMPLES]
-- TEST: READ [MAX_SAMPLES > SAMPLES]
-- TEST: READ [NO COMPATIBLE SAMPLES]
-- TEST: READ [NO SAMPLES]
-- TEST: TAKE
-- TEST: TAKE [NO SAMPLES]
-- TEST: TAKE_NEXT_SAMPLE
-- TEST: TAKE_NEXT_SAMPLE [NO SAMPLE]
-- TEST: READ_NEXT_SAMPLE [WITH UNREAD SAMPLE]
-- TEST: READ_NEXT_SAMPLE [WITHOUT UNREAD SAMPLE]
-- TEST: READ_NEXT_SAMPLE [NO SAMPLE]
-- TEST: READ_INSTANCE
-- TEST: TAKE_INSTANCE
-- TEST: READ_NEXT_INSTANCE
-- TEST: TAKE_NEXT_INSTANCE
-- TEST: READ MARKS SAMPLES AS READ
-- TEST: TAKE REMOVES SAMPLE
-- TEST: READ MODIFIES VIEW STATE [READ CURRENT GENERATION]
-- TEST: READ MODIFIES VIEW STATE [READ PREVIOUS GENERATION]
entity L0_dds_reader_test3_arznriu is
end entity;
architecture testbench of L0_dds_reader_test3_arznriu 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);
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 : 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 => FALSE,
WITH_KEY => FALSE,
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 kh1, kh2, kh3, kh4, kh5 : INSTANCE_HANDLE_TYPE := HANDLE_NIL;
variable cc : CACHE_CHANGE_TYPE := DEFAULT_CACHE_CHANGE;
variable s : SAMPLE_TYPE := DEFAULT_SAMPLE;
alias idle_sig is <<signal uut.idle_sig : std_logic>>;
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
begin
loop
if (idle_sig /= '1') then
wait until idle_sig = '1';
else
exit;
end if;
wait until rising_edge(clk);
wait until rising_edge(clk);
end loop;
end procedure;
begin
SetAlertLogName("dds_reader - (KEEP ALL, Reliable, Zero TIME_BASED_FILTER, Keyless, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER, ACCESS SCOPE Instance, Unordered) - Level 0 - 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.payload := gen_payload(HANDLE_NIL,10);
cc.src_timestamp := gen_duration(0,0);
Log("RTPS Operation ADD_CACHE_CHANGE [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: S0
-- ISTATE: ALIVE
-- VIEW: NEW
-- WRITER: 0
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 := FALSE;
cc.kind := NOT_ALIVE_DISPOSED;
cc.src_timestamp := gen_duration(1,0);
Log("RTPS Operation ADD_CACHE_CHANGE [DISPOSE, 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,NOT_ALIVE_DISPOSED_INSTANCE_STATE);
add_sample(s,mem, BY_RECEPTION_TIMESTAMP_DESTINATION_ORDER_QOS);
start_rtps;
wait_on_rtps;
wait_on_idle;
-- MEM: S0, S1-
-- ISTATE: DISPOSED
-- VIEW: NEW
-- WRITER: 0
-- TEST: READ [MAX_SAMPLES < SAMPLES]
Log("DDS Operation READ [MAX_SAMPLES 1, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID0)", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.max_samples := 1;
dds.sstate := ANY_SAMPLE_STATE;
dds.istate := ANY_INSTANCE_STATE;
dds.vstate := ANY_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: S0, S1-
-- ISTATE: DISPOSED
-- VIEW: NOT_NEW
-- WRITER: 0
-- TEST: READ [NO COMPATIBLE SAMPLES]
-- TEST: READ MODIFIES VIEW STATE [READ CURRENT GENERATION]
Log("DDS Operation READ [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, NEW_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 := NEW_VIEW_STATE;
dds.ret_code := RETCODE_NO_DATA;
start_dds;
wait_on_dds;
-- MEM: S0, S1-
-- ISTATE: DISPOSED
-- VIEW: NOT_NEW
-- WRITER: 0
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.payload := gen_payload(HANDLE_NIL,10);
cc.src_timestamp := gen_duration(2,0);
Log("RTPS Operation ADD_CACHE_CHANGE [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: S0, S1-, S2
-- ISTATE: ALIVE
-- VIEW: NEW
-- WRITER: 0
-- TEST: READ_NEXT_SAMPLE [WITH UNREAD SAMPLE]
Log("DDS Operation READ_NEXT_SAMPLE (Expected ID1)", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ_NEXT_SAMPLE;
start_dds;
wait_on_dds;
-- MEM: S0, S1-, S2
-- ISTATE: ALIVE
-- VIEW: NEW
-- WRITER: 0
-- TEST: READ MARKS SAMPLES AS READ
-- TEST: READ MODIFIES VIEW STATE [READ PREVIOUS GENERATION]
-- TEST: READ [MAX_SAMPLES > SAMPLES]
Log("DDS Operation READ [MAX_SAMPLES 20, READ_SAMPLE_STATE, ALIVE_INSTANCE_STATE, NEW_VIEW_STATE] (Expected ID0,ID1)", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := READ;
dds.max_samples := 20;
dds.sstate := READ_SAMPLE_STATE;
dds.istate := ALIVE_INSTANCE_STATE;
dds.vstate := NEW_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: S0, S1-, S2
-- ISTATE: ALIVE
-- VIEW: NEW
-- WRITER: 0
-- TEST: TAKE
Log("DDS Operation TAKE [MAX_SAMPLES 1, READ_SAMPLE_STATE, ALIVE_INSTANCE_STATE, NEW_VIEW_STATE] (Expected ID0)", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE;
dds.max_samples := 1;
dds.sstate := READ_SAMPLE_STATE;
dds.istate := ALIVE_INSTANCE_STATE;
dds.vstate := NEW_VIEW_STATE;
start_dds;
wait_on_dds;
-- MEM: S1-, S2
-- ISTATE: ALIVE
-- VIEW: NEW
-- WRITER: 0
-- TEST: TAKE_NEXT_SAMPLE
Log("DDS Operation TAKE_NEXT_SAMPLE (Expected ID2)", INFO);
dds := DEFAULT_DDS_READER_TEST;
dds.opcode := TAKE_NEXT_SAMPLE;
start_dds;
wait_on_dds;
-- MEM: S1-
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- 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: S1-
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
Log("DDS Operation TAKE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE] (Expected ID1)", 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;
start_dds;
wait_on_dds;
-- MEM: -
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- TEST: TAKE REMOVES SAMPLE
-- 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: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- 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: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- 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: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- 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: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- TEST: READ_INSTANCE
Log("DDS Operation READ_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 1] (Illegal Operation)", 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 := kh1;
dds.ret_code := RETCODE_ILLEGAL_OPERATION;
start_dds;
wait_on_dds;
-- MEM: -
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- TEST: TAKE_INSTANCE
Log("DDS Operation TAKE_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 1] (Illegal Operation)", 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 := kh1;
dds.ret_code := RETCODE_ILLEGAL_OPERATION;
start_dds;
wait_on_dds;
-- MEM: -
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- TEST: READ_NEXT_INSTANCE
Log("DDS Operation READ_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 1] (Illegal Operation)", 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_ILLEGAL_OPERATION;
start_dds;
wait_on_dds;
-- MEM: -
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
-- TEST: TAKE_NEXT_INSTANCE
Log("DDS Operation TAKE_NEXT_INSTANCE [MAX_SAMPLES 20, ANY_SAMPLE_STATE, ANY_INSTANCE_STATE, ANY_VIEW_STATE, Instance 1] (Illegal Operation)", 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 := kh1;
dds.ret_code := RETCODE_ILLEGAL_OPERATION;
start_dds;
wait_on_dds;
-- MEM: -
-- ISTATE: ALIVE
-- VIEW: NOT_NEW
-- WRITER: 0
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, FALSE);
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, 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;
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;
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;

54
src/Tests/Level_0/dds_reader_tests.txt
View File

@ -54,4 +54,56 @@
-- TEST: ADD SAMPLE BIGGER THAN AVAILABLE MEMORY SPACE
-- TEST: ADD SAMPLE ON PAYLOAD MEMORY FULL & MAX_SAMPLES_PER_INSTANCE (Induce Double Remove)
-- TEST: ADD SAMPLE ON PAYLOAD MEMORY FULL & MAX_SAMPLES_PER_INSTANCE (Induce Double Remove)
-----------------------------------------------------------------------
-- 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]
-- TEST: OUT OF ORDER SAMPLE AFTER DISPOSE

117
src/Tests/testbench.pro
View File

@ -20,58 +20,63 @@ analyze ../rtps_reader.vhd
analyze ../rtps_writer.vhd
analyze ../dds_writer.vhd
analyze ../dds_reader.vhd
analyze Level_0/L0_rtps_handler_test1.vhd
analyze Level_0/L0_rtps_handler_test2.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test1.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test2.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test3.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test4.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test5.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test6.vhd
analyze Level_0/L0_rtps_builtin_endpoint_test7.vhd
analyze Level_0/L0_rtps_out_test1.vhd
analyze Level_1/L1_rtps_builtin_endpoint_test1.vhd
analyze Level_0/L0_mem_ctrl_test1.vhd
analyze Level_0/L0_rtps_reader_test1_vrk.vhd
analyze Level_0/L0_rtps_reader_test1_vbk.vhd
analyze Level_0/L0_rtps_reader_test2_vrk.vhd
analyze Level_0/L0_rtps_reader_test2_trk.vhd
analyze Level_0/L0_rtps_reader_test2_vbk.vhd
analyze Level_0/L0_rtps_reader_test2_tbk.vhd
analyze Level_0/L0_rtps_reader_test2_vrn.vhd
analyze Level_0/L0_rtps_reader_test3_a.vhd
analyze Level_0/L0_rtps_reader_test3_m.vhd
analyze Level_1/L1_rtps_reader_test1_vrk.vhd
analyze Level_1/L1_rtps_reader_test1_trk.vhd
analyze Level_0/L0_rtps_writer_test1_vrkdp.vhd
analyze Level_0/L0_rtps_writer_test1_vbkdp.vhd
analyze Level_1/L1_rtps_writer_test1_vrkdp.vhd
analyze Level_1/L1_rtps_writer_test1_trkdp.vhd
analyze Level_1/L1_rtps_writer_test1_tbkdp.vhd
analyze Level_1/L1_rtps_writer_test1_vbkdp.vhd
analyze Level_1/L1_rtps_writer_test1_vrndp.vhd
analyze Level_1/L1_rtps_writer_test1_vrksp.vhd
analyze Level_1/L1_rtps_writer_test1_vrkdn.vhd
analyze Level_1/L1_rtps_writer_test1_trkdn.vhd
analyze Level_1/L1_rtps_writer_test2_vrkdn.vhd
analyze Level_0/L0_rtps_writer_test2_vrkdp.vhd
analyze Level_0/L0_dds_writer_test1_aik.vhd
analyze Level_0/L0_dds_writer_test1_ain.vhd
analyze Level_0/L0_dds_writer_test1_lik.vhd
analyze Level_0/L0_dds_writer_test1_afk.vhd
analyze Level_0/L0_dds_writer_test2_aik.vhd
analyze Level_0/L0_dds_writer_test3_aik.vhd
analyze Level_0/L0_dds_writer_test3_ain.vhd
analyze Level_0/L0_dds_writer_test4_aik.vhd
analyze Level_0/L0_dds_writer_test5_afk.vhd
analyze Level_0/L0_dds_reader_test1_arzkriu.vhd
analyze Level_0/L0_dds_reader_test1_lrzkriu.vhd
analyze Level_0/L0_dds_reader_test1_lbzkriu.vhd
analyze Level_0/L0_dds_reader_test1_abzkriu.vhd
analyze Level_0/L0_dds_reader_test1_arznriu.vhd
analyze Level_0/L0_dds_reader_test1_arzksiu.vhd
analyze Level_0/L0_dds_reader_test2_arpkriu.vhd
#analyze Level_0/L0_rtps_handler_test1.vhd
#analyze Level_0/L0_rtps_handler_test2.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test1.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test2.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test3.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test4.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test5.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test6.vhd
#analyze Level_0/L0_rtps_builtin_endpoint_test7.vhd
#analyze Level_0/L0_rtps_out_test1.vhd
#analyze Level_1/L1_rtps_builtin_endpoint_test1.vhd
#analyze Level_0/L0_mem_ctrl_test1.vhd
#analyze Level_0/L0_rtps_reader_test1_vrk.vhd
#analyze Level_0/L0_rtps_reader_test1_vbk.vhd
#analyze Level_0/L0_rtps_reader_test2_vrk.vhd
#analyze Level_0/L0_rtps_reader_test2_trk.vhd
#analyze Level_0/L0_rtps_reader_test2_vbk.vhd
#analyze Level_0/L0_rtps_reader_test2_tbk.vhd
#analyze Level_0/L0_rtps_reader_test2_vrn.vhd
#analyze Level_0/L0_rtps_reader_test3_a.vhd
#analyze Level_0/L0_rtps_reader_test3_m.vhd
#analyze Level_1/L1_rtps_reader_test1_vrk.vhd
#analyze Level_1/L1_rtps_reader_test1_trk.vhd
#analyze Level_0/L0_rtps_writer_test1_vrkdp.vhd
#analyze Level_0/L0_rtps_writer_test1_vbkdp.vhd
#analyze Level_1/L1_rtps_writer_test1_vrkdp.vhd
#analyze Level_1/L1_rtps_writer_test1_trkdp.vhd
#analyze Level_1/L1_rtps_writer_test1_tbkdp.vhd
#analyze Level_1/L1_rtps_writer_test1_vbkdp.vhd
#analyze Level_1/L1_rtps_writer_test1_vrndp.vhd
#analyze Level_1/L1_rtps_writer_test1_vrksp.vhd
#analyze Level_1/L1_rtps_writer_test1_vrkdn.vhd
#analyze Level_1/L1_rtps_writer_test1_trkdn.vhd
#analyze Level_1/L1_rtps_writer_test2_vrkdn.vhd
#analyze Level_0/L0_rtps_writer_test2_vrkdp.vhd
#analyze Level_0/L0_dds_writer_test1_aik.vhd
#analyze Level_0/L0_dds_writer_test1_ain.vhd
#analyze Level_0/L0_dds_writer_test1_lik.vhd
#analyze Level_0/L0_dds_writer_test1_afk.vhd
#analyze Level_0/L0_dds_writer_test2_aik.vhd
#analyze Level_0/L0_dds_writer_test3_aik.vhd
#analyze Level_0/L0_dds_writer_test3_ain.vhd
#analyze Level_0/L0_dds_writer_test4_aik.vhd
#analyze Level_0/L0_dds_writer_test5_afk.vhd
#analyze Level_0/L0_dds_reader_test1_arzkriu.vhd
#analyze Level_0/L0_dds_reader_test1_lrzkriu.vhd
#analyze Level_0/L0_dds_reader_test1_lbzkriu.vhd
#analyze Level_0/L0_dds_reader_test1_abzkriu.vhd
#analyze Level_0/L0_dds_reader_test1_arznriu.vhd
#analyze Level_0/L0_dds_reader_test1_arzksiu.vhd
#analyze Level_0/L0_dds_reader_test2_arpkriu.vhd
analyze Level_0/L0_dds_reader_test3_arzkriu.vhd
analyze Level_0/L0_dds_reader_test3_arzkrio.vhd
analyze Level_0/L0_dds_reader_test3_arzkrtu.vhd
analyze Level_0/L0_dds_reader_test3_arzkrto.vhd
analyze Level_0/L0_dds_reader_test3_arznriu.vhd
analyze Level_0/L0_dds_reader_test3_arzksto.vhd
#simulate L0_rtps_handler_test1
#simulate L0_rtps_handler_test2
@ -123,4 +128,10 @@ analyze Level_0/L0_dds_reader_test2_arpkriu.vhd
#simulate L0_dds_reader_test1_abzkriu
#simulate L0_dds_reader_test1_arznriu
#simulate L0_dds_reader_test1_arzksiu
simulate L0_dds_reader_test2_arpkriu
#simulate L0_dds_reader_test2_arpkriu
simulate L0_dds_reader_test3_arzkriu
#simulate L0_dds_reader_test3_arzkrio
#simulate L0_dds_reader_test3_arzkrtu
#simulate L0_dds_reader_test3_arzkrto
#simulate L0_dds_reader_test3_arznriu
#simulate L0_dds_reader_test3_arzksto

734
src/dds_reader.vhd
View File

File diff suppressed because it is too large Load Diff

154
src/rtps_test_package.vhd
View File

@ -245,7 +245,7 @@ package rtps_test_package is
constant DEFAULT_SAMPLE : SAMPLE_TYPE; -- Deferred to Package Body
type SAMPLE_ARRAY_TYPE is array (0 to 10) of SAMPLE_TYPE;
type SAMPLE_ARRAY_TYPE is array (0 to 15) of SAMPLE_TYPE;
type COLLECTION_TYPE is record
s : SAMPLE_ARRAY_TYPE;
@ -264,7 +264,7 @@ package rtps_test_package is
constant DEFAULT_INSTANCE_CACHE_TYPE : INSTANCE_CACHE_TYPE; -- Deferred to Package Body
type INSTANCE_CACHE_ARRAY_TYPE is array (0 to 10) of INSTANCE_CACHE_TYPE;
type INSTANCE_CACHE_ARRAY_TYPE is array (0 to 15) of INSTANCE_CACHE_TYPE;
type DDS_READER_MEM_TYPE is record
s : SAMPLE_ARRAY_TYPE;
@ -364,7 +364,7 @@ package rtps_test_package is
function int(n : integer; width : natural) return std_logic_vector;
function to_string1 (input : std_logic_vector) return string;
--procedure add_instance(inst : inout INSTANCE_HANDLE_TYPE; mem : inout DDS_READER_MEM_TYPE);
--procedure add_instance(inst : inout INSTANCE_HANDLE_TYPE; istate : in std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0); mem : inout DDS_READER_MEM_TYPE);
function to_sample(cc : CACHE_CHANGE_TYPE; istate : std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0)) return SAMPLE_TYPE;
procedure change_istate(inst : INSTANCE_HANDLE_TYPE; istate : in std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0); mem : inout DDS_READER_MEM_TYPE);
procedure add_sample(sample : inout SAMPLE_TYPE; mem : inout DDS_READER_MEM_TYPE; DESTINATION_ORDER_QOS : in std_logic_vector(CDR_ENUMERATION_WIDTH-1 downto 0));
@ -2786,7 +2786,7 @@ package body rtps_test_package is
return "wr: " & to_string(input(0 to NUM_ENDPOINTS-1)) & ", last_word: " & to_string(input(NUM_ENDPOINTS)) & ", data: " & to_hstring(input(NUM_ENDPOINTS+1 to input'length-1));
end function;
procedure add_instance(inst : in INSTANCE_HANDLE_TYPE; mem : inout DDS_READER_MEM_TYPE) is
procedure add_instance(inst : in INSTANCE_HANDLE_TYPE; istate : in std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0); mem : inout DDS_READER_MEM_TYPE) is
variable ind : natural := 0;
begin
-- Find Position
@ -2803,9 +2803,10 @@ package body rtps_test_package is
mem.inst(i+1) := mem.inst(i);
end loop;
-- Insert at desired index
mem.inst(ind) := DEFAULT_INSTANCE_CACHE_TYPE;
mem.inst(ind).inst := inst;
mem.ilen := mem.ilen + 1;
mem.inst(ind) := DEFAULT_INSTANCE_CACHE_TYPE;
mem.inst(ind).inst := inst;
mem.inst(ind).istate := istate;
mem.ilen := mem.ilen + 1;
end procedure;
function to_sample(cc : CACHE_CHANGE_TYPE; istate : std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0)) return SAMPLE_TYPE is
@ -2822,8 +2823,9 @@ package body rtps_test_package is
procedure change_istate(inst : in INSTANCE_HANDLE_TYPE; istate : in std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0); mem : inout DDS_READER_MEM_TYPE) is
begin
-- Check Instance State
for i in 0 to mem.ilen-1 loop
for i in 0 to max(mem.ilen-1,0) loop
-- Instance Found
if (inst = mem.inst(i).inst) then
case (istate) is
@ -2878,10 +2880,12 @@ package body rtps_test_package is
sample.agrank := 0;
sample.sstate := NOT_READ_SAMPLE_STATE;
-- NOTE: We change the Instance State here, because we need the new Sample needs the updated Generation Counters/View State
change_istate(sample.inst, sample.istate, mem);
-- NOTE: We always check at least the first index for keyless cases (instance = HANDLE_NIL)
-- Check Instance State
for i in 0 to mem.ilen-1 loop
for i in 0 to max(mem.ilen-1,0) loop
-- Instance Found
if (sample.inst = mem.inst(i).inst) then
found := TRUE;
@ -2894,7 +2898,7 @@ package body rtps_test_package is
-- New Instance
if (not found) then
add_instance(sample.inst, mem);
add_instance(sample.inst, sample.istate, mem);
end if;
-- Add Sample
@ -2905,11 +2909,11 @@ package body rtps_test_package is
mem.s(ind) := sample;
when BY_SOURCE_TIMESTAMP_DESTINATION_ORDER_QOS =>
-- Find Position
for i in 0 to mem.slen-1 loop
if (sample.ts > mem.s(i).ts) then
ind := i;
for i in mem.slen-1 downto 0 loop
if (sample.ts >= mem.s(i).ts) then
exit;
end if;
ind := i;
end loop;
-- Move elements to make Space
@ -2929,10 +2933,10 @@ package body rtps_test_package is
assert (ind < mem.slen) report "Index is out of Bounds" severity FAILURE;
assert (mem.slen /= 0) report "Remove on empty array" severity FAILURE;
-- NOTE: Assumes i+1 is in bounds
for i in ind to mem.slen-1 loop
for i in ind to mem.slen-2 loop
mem.s(i) := mem.s(i+1);
end loop;
mem.s(mem.slen-1) := DEFAULT_SAMPLE;
mem.slen := mem.slen - 1;
end procedure;
@ -2951,17 +2955,18 @@ package body rtps_test_package is
end loop;
if (ind /= mem.ilen) then
-- NOTE: Assumes i+1 is in bounds
for i in ind to mem.ilen-1 loop
for i in ind to mem.ilen-2 loop
mem.inst(i) := mem.inst(i+1);
end loop;
mem.inst(mem.ilen-1) := DEFAULT_INSTANCE_CACHE_TYPE;
mem.ilen := mem.ilen - 1;
end if;
end procedure;
function check_instance(istate : std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0); vstate : std_logic_vector(VIEW_STATE_KIND_WIDTH-1 downto 0); mem : DDS_READER_MEM_TYPE; inst : INSTANCE_HANDLE_TYPE) return boolean is
begin
for i in 0 to mem.ilen-1 loop
-- NOTE: We always check at least the first index for keyless cases (instance = HANDLE_NIL)
for i in 0 to max(mem.ilen-1,0) loop
-- Instance Found
if (inst = mem.inst(i).inst) then
if (((mem.inst(i).istate and istate) /= (istate'range => '0')) and ((mem.inst(i).vstate and vstate) /= (vstate'range => '0'))) then
@ -2974,7 +2979,8 @@ package body rtps_test_package is
function find_instance(mem : DDS_READER_MEM_TYPE; inst : INSTANCE_HANDLE_TYPE) return natural is
begin
for i in 0 to mem.ilen-1 loop
-- NOTE: We always check at least the first index for keyless cases (instance = HANDLE_NIL)
for i in 0 to max(mem.ilen-1,0) loop
-- Instance Found
if (inst = mem.inst(i).inst) then
return i;
@ -2986,86 +2992,77 @@ package body rtps_test_package is
procedure gen_collection (mem : inout DDS_READER_MEM_TYPE; col : inout COLLECTION_TYPE; inst : INSTANCE_HANDLE_TYPE; sstate : in std_logic_vector(SAMPLE_STATE_KIND_WIDTH-1 downto 0); istate : in std_logic_vector(INSTANCE_STATE_KIND_WIDTH-1 downto 0); vstate : in std_logic_vector(VIEW_STATE_KIND_WIDTH-1 downto 0); max_samples : in natural; remove : in boolean; sort : in boolean) is
variable i,j : natural := 0;
variable tmp_inst : INSTANCE_HANDLE_TYPE := HANDLE_NIL;
variable tmp_col : COLLECTION_TYPE := DEFAULT_COLLECTION;
variable rank, mrsic_gen, mrs_gen : natural := 0;
variable done : std_logic_vector(0 to max_samples-1) := (others => '0');
variable no_inst : boolean := FALSE;
variable sel : std_logic_vector(0 to mem.slen-1) := (others => '0');
variable no_inst : boolean := TRUE;
begin
col := DEFAULT_COLLECTION;
i := 0;
loop
-- Sample is in Collection
if (((mem.s(i).sstate and sstate) /= (sstate'range => '0')) and check_instance(istate, vstate, mem, mem.s(i).inst) and ((inst /= HANDLE_NIL and inst = mem.s(i).inst) or inst = HANDLE_NIL)) then
if (no_inst) then
-- Sample and Instance Compatible
if (((mem.s(i).sstate and sstate) /= (sstate'range => '0')) and check_instance(istate, vstate, mem, mem.s(i).inst) and ((inst /= HANDLE_NIL and inst = mem.s(i).inst) or inst = HANDLE_NIL) and (sel(i) /= '1')) then
col.s(col.len) := mem.s(i);
col.s(col.len).istate := mem.inst(find_instance(mem,mem.s(i).inst)).istate;
col.s(col.len).vstate := mem.inst(find_instance(mem,mem.s(i).inst)).vstate;
col.len := col.len + 1;
-- Change READ STATE
mem.s(i).sstate := READ_SAMPLE_STATE;
-- Mark as Selected
sel(i) := '1';
tmp_inst := mem.s(i).inst;
-- NOTE: If we sort by Instance, we need to first get all compatible Samples from one Instance, before moving to the next compatible Instance.
-- This is achieved by toggling no_inst.
if (sort) then
no_inst := FALSE;
end if;
end if;
-- Sample Compatible (and belonging to specified Instance)
elsif (((mem.s(i).sstate and sstate) /= (sstate'range => '0')) and (mem.s(i).inst = tmp_inst) and (sel(i) /= '1')) then
col.s(col.len) := mem.s(i);
col.s(col.len).istate := mem.inst(find_instance(mem,mem.s(i).inst)).istate;
col.s(col.len).vstate := mem.inst(find_instance(mem,mem.s(i).inst)).vstate;
col.len := col.len + 1;
-- Change READ STATE
mem.s(i).sstate := READ_SAMPLE_STATE;
-- Remove Sample
if (remove) then
remove_sample(i, mem);
-- NOTE: We do not increment the loop invariant
else
i := i + 1;
end if;
else
i := i + 1;
-- Mark as Selected
sel(i) := '1';
tmp_inst := mem.s(i).inst;
end if;
i := i + 1;
-- Loop Exit Condition
if (i >= mem.slen or col.len >= max_samples) then
if (col.len >= max_samples) then
exit;
elsif (i >= mem.slen) then
-- No more compatible Samples
if (no_inst) then
exit;
-- Check next instance
else
i := 0;
no_inst := TRUE;
tmp_inst := HANDLE_NIL;
end if;
end if;
end loop;
-- Remove Selected Samples
if (remove) then
for i in mem.slen-1 downto 0 loop
if (sel(i) = '1') then
remove_sample(i,mem);
end if;
end loop;
end if;
if (col.len = 0) then
report "Empty Collection" severity NOTE;
return;
end if;
-- No Instances (WITH_KEY=FALSE testing)
if (col.s(0).inst = HANDLE_NIL) then
no_inst := TRUE;
end if;
-- Sort
if (sort and not no_inst) then
i := 1;
j := 1;
tmp_inst := col.s(0).inst;
tmp_col := DEFAULT_COLLECTION;
tmp_col.len := col.len;
tmp_col.s(0):= col.s(0);
col.s(0) := DEFAULT_SAMPLE;
loop
-- Select Next Instance
if (tmp_inst = HANDLE_NIL) then
if (col.s(i).inst /= HANDLE_NIL) then
tmp_inst := col.s(i).inst;
i := 0; --Reset
end if;
elsif (col.s(i).inst = tmp_inst) then
tmp_col.s(j) := col.s(i);
col.s(i) := DEFAULT_SAMPLE;
j := j + 1;
end if;
i := i + 1;
-- DONE
if (j >= col.len) then
col := tmp_col;
exit;
-- Reset Index
elsif (i >= col.len) then
i := 0;
tmp_inst := HANDLE_NIL;
end if;
end loop;
end if;
-- Calculate Ranks
i := col.len-1;
tmp_inst := col.s(i).inst;
@ -3079,6 +3076,7 @@ package body rtps_test_package is
mem.inst(j).vstate := NOT_NEW_VIEW_STATE;
end if;
done(col.len-1 to done'length-1) := (others => '1');
no_inst := FALSE;
-- Single Sample
if (col.len-1 = 0) then
return;
@ -3086,10 +3084,11 @@ package body rtps_test_package is
loop
i := i - 1;
-- Select Next Instance
if (not no_inst and tmp_inst = HANDLE_NIL) then
if (no_inst) then
if (done(i) = '0') then
tmp_inst := col.s(i).inst;
j := find_instance(mem, tmp_inst);
no_inst := FALSE;
-- Reset
rank := 1;
mrs_gen := mem.inst(j).dis_gen_cnt + mem.inst(j).no_w_gen_cnt;
@ -3114,6 +3113,7 @@ package body rtps_test_package is
-- Reset
elsif (i = 0) then
tmp_inst := HANDLE_NIL;
no_inst := TRUE;
i := col.len-1;
end if;
end loop;
@ -3142,12 +3142,12 @@ package body rtps_test_package is
when TAKE_INSTANCE =>
gen_collection(mem, col, opcode.inst, opcode.sstate, opcode.istate, opcode.vstate, opcode.max_samples, TRUE, sort);
when READ_NEXT_INSTANCE =>
tmp_inst := mem.inst(find_instance(mem,opcode.inst)+1).inst;
tmp_inst := mem.inst(find_instance(mem,opcode.inst)+1).inst when (opcode.inst /= HANDLE_NIL) else mem.inst(0).inst;
if (tmp_inst /= HANDLE_NIL) then
gen_collection(mem, col, tmp_inst, opcode.sstate, opcode.istate, opcode.vstate, opcode.max_samples, FALSE, sort);
end if;
when TAKE_NEXT_INSTANCE =>
tmp_inst := mem.inst(find_instance(mem,opcode.inst)+1).inst;
tmp_inst := mem.inst(find_instance(mem,opcode.inst)+1).inst when (opcode.inst /= HANDLE_NIL) else mem.inst(0).inst;
if (tmp_inst /= HANDLE_NIL) then
gen_collection(mem, col, tmp_inst, opcode.sstate, opcode.istate, opcode.vstate, opcode.max_samples, TRUE, sort);
end if;