kernel: test: fix message ordering test

It turns out that it was working fine, the test was just broken.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-12-01 13:18:49 +08:00
parent e7744b25ec
commit d5f82b7972

View file

@ -362,19 +362,23 @@ fn message_ordering() {
// Sync point waiting to start receiving. // Sync point waiting to start receiving.
server_can_start_recv.recv().unwrap(); server_can_start_recv.recv().unwrap();
let mut previous_value = 0; let mut queue_length = 1;
// Keep receiving messages until we get a BlockingScalar message // Keep receiving messages until we get a BlockingScalar message
loop { loop {
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); let envelope =
xous_kernel::receive_message(sid).expect("couldn't receive messages");
match envelope.body { match envelope.body {
xous_kernel::Message::Scalar(sm) => { xous_kernel::Message::Scalar(sm) => {
assert_eq!(sm.id, previous_value, "messages were not ordered"); assert_eq!(sm.id, queue_length, "messages were not ordered");
previous_value += 1; queue_length += 1;
} }
xous_kernel::Message::BlockingScalar(sm) => { xous_kernel::Message::BlockingScalar(sm) => {
assert_eq!(sm.id, previous_value, "blocking message were not ordered"); assert_eq!(sm.id, queue_length, "blocking message were not ordered");
previous_value += 1; // The BlockingScalar has exceeded the queue length, so subtract
xous_kernel::return_scalar(envelope.sender, 0).expect("couldn't return scalar"); // 1 from the running total.
queue_length -= 1;
xous_kernel::return_scalar(envelope.sender, queue_length)
.expect("couldn't return scalar");
break; break;
} }
_ => panic!("unexpected message received"), _ => panic!("unexpected message received"),
@ -382,7 +386,7 @@ fn message_ordering() {
} }
// Return the total number of messages we've seen to the parent // Return the total number of messages we've seen to the parent
server_total_send.send(previous_value).unwrap(); server_total_send.send(queue_length).unwrap();
}, },
)) ))
.expect("couldn't spawn server process"); .expect("couldn't spawn server process");
@ -396,7 +400,7 @@ fn message_ordering() {
// Determine the length of the kernel queue. // Determine the length of the kernel queue.
let mut queue_length = 0; let mut queue_length = 0;
for i in 0.. { for i in 1.. {
if xous_kernel::try_send_message( if xous_kernel::try_send_message(
conn, conn,
xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
@ -413,17 +417,16 @@ fn message_ordering() {
} }
queue_length += 1; queue_length += 1;
} }
queue_length += 1;
println!("detected kernel queue_length: {}", queue_length);
// Let the server process messages // Let the server process messages
server_can_start_send.send(()).ok(); server_can_start_send.send(()).ok();
// Send one more message, but make it non-blocking so it gets retried. // Send one more message, but make it blocking. This acts as a sentinal
// value to let the kernel know things are done.
xous_kernel::send_message( xous_kernel::send_message(
conn, conn,
xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage {
id: queue_length, id: queue_length + 1,
arg1: 0, arg1: 0,
arg2: 0, arg2: 0,
arg3: 0, arg3: 0,
@ -432,6 +435,7 @@ fn message_ordering() {
) )
.expect("couldn't send message"); .expect("couldn't send message");
// Report the number of messages to the main thread.
client_total_send.send(queue_length).unwrap(); client_total_send.send(queue_length).unwrap();
}, },
)) ))
@ -440,12 +444,14 @@ fn message_ordering() {
let server_total = server_total_recv.recv().unwrap(); let server_total = server_total_recv.recv().unwrap();
let client_total = client_total_recv.recv().unwrap(); let client_total = client_total_recv.recv().unwrap();
// Wait for both processes to finish // Wait for both processes to finish
crate::wait_process_as_thread(xous_server).expect("couldn't join server process"); crate::wait_process_as_thread(xous_server).expect("couldn't join server process");
crate::wait_process_as_thread(xous_client).expect("couldn't join client process"); crate::wait_process_as_thread(xous_client).expect("couldn't join client process");
shutdown_kernel(); shutdown_kernel();
assert_eq!(client_total, server_total, "client and server processed a different number of messages"); assert_eq!(
client_total, server_total,
"client and server processed a different number of messages"
);
main_thread.join().expect("couldn't join kernel process"); main_thread.join().expect("couldn't join kernel process");
} }