diff --git a/kernel/src/test.rs b/kernel/src/test.rs index cac764ba4..80ed4e93e 100644 --- a/kernel/src/test.rs +++ b/kernel/src/test.rs @@ -196,11 +196,13 @@ fn try_receive_message() { move || { let sid = xous_kernel::create_server(b"send_scalar_mesg") .expect("couldn't create test server"); - let maybe_envelope = xous_kernel::try_receive_message(sid).expect("couldn't receive messages"); + let maybe_envelope = + xous_kernel::try_receive_message(sid).expect("couldn't receive messages"); assert!(maybe_envelope.is_none(), "some message came back"); server_addr_send.send(sid).unwrap(); client_sent_recv.recv().unwrap(); - let maybe_envelope = xous_kernel::try_receive_message(sid).expect("couldn't receive messages"); + let maybe_envelope = + xous_kernel::try_receive_message(sid).expect("couldn't receive messages"); let envelope = maybe_envelope.expect("got None as an envelope"); assert_eq!( envelope.body, @@ -233,7 +235,9 @@ fn try_receive_message() { }), ) .expect("couldn't send message"); - client_sent_send.send(()).expect("couldn't notify them we sent a message"); + client_sent_send + .send(()) + .expect("couldn't notify them we sent a message"); }, )) .expect("couldn't spawn client process"); @@ -335,6 +339,117 @@ fn send_blocking_scalar_message() { main_thread.join().expect("couldn't join kernel process"); } +#[test] +fn message_ordering() { + // Start the server in another thread + let main_thread = start_kernel(SERVER_SPEC); + + let (server_addr_send, server_addr_recv) = channel(); + let (server_can_start_send, server_can_start_recv) = channel(); + let (client_total_send, client_total_recv) = channel(); + let (server_total_send, server_total_recv) = channel(); + + // Spawn the server "process" (which just lives in a separate thread) + // and receive the message. Note that we need to communicate to the + // "Client" what our server ID is. Normally this would be done via + // an external nameserver. + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( + "send_scalar_message server", + move || { + let sid = xous_kernel::create_server(b"send_scalar_mesg") + .expect("couldn't create test server"); + server_addr_send.send(sid).unwrap(); + // Sync point waiting to start receiving. + server_can_start_recv.recv().unwrap(); + + let mut previous_value = 0; + // Keep receiving messages until we get a BlockingScalar message + loop { + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); + match envelope.body { + xous_kernel::Message::Scalar(sm) => { + assert_eq!(sm.id, previous_value, "messages were not ordered"); + previous_value += 1; + } + xous_kernel::Message::BlockingScalar(sm) => { + assert_eq!(sm.id, previous_value, "blocking message were not ordered"); + previous_value += 1; + xous_kernel::return_scalar(envelope.sender, 0).expect("couldn't return scalar"); + break; + } + _ => panic!("unexpected message received"), + } + } + + // Return the total number of messages we've seen to the parent + server_total_send.send(previous_value).unwrap(); + }, + )) + .expect("couldn't spawn server process"); + + // Spawn the client "process" and wait for the server address. + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( + "send_scalar_message client", + move || { + let sid = server_addr_recv.recv().unwrap(); + let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server"); + + // Determine the length of the kernel queue. + let mut queue_length = 0; + for i in 0.. { + if xous_kernel::try_send_message( + conn, + xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { + id: i, + arg1: 0, + arg2: 0, + arg3: 0, + arg4: 0, + }), + ) + .is_err() + { + break; + } + queue_length += 1; + } + queue_length += 1; + println!("detected kernel queue_length: {}", queue_length); + + // Let the server process messages + server_can_start_send.send(()).ok(); + + // Send one more message, but make it non-blocking so it gets retried. + xous_kernel::send_message( + conn, + xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { + id: queue_length, + arg1: 0, + arg2: 0, + arg3: 0, + arg4: 0, + }), + ) + .expect("couldn't send message"); + + client_total_send.send(queue_length).unwrap(); + }, + )) + .expect("couldn't spawn client process"); + + let server_total = server_total_recv.recv().unwrap(); + let client_total = client_total_recv.recv().unwrap(); + + + // 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_client).expect("couldn't join client process"); + shutdown_kernel(); + assert_eq!(client_total, server_total, "client and server processed a different number of messages"); + + main_thread.join().expect("couldn't join kernel process"); +} + #[test] fn send_interleved_blocking_scalar_message() { // Start the server in another thread @@ -376,9 +491,8 @@ fn send_interleved_blocking_scalar_message() { // Spawn the client "process" and wait for the server address. This one will have // 1 added to the `id` field. - let xous_client_1 = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( - "send_scalar_message client 1", - move || { + let xous_client_1 = xous_kernel::create_process_as_thread( + xous_kernel::ProcessArgsAsThread::new("send_scalar_message client 1", move || { let conn = xous_kernel::try_connect(sid_client_1).expect("couldn't connect to server"); let result = xous_kernel::try_send_message( conn, @@ -392,15 +506,14 @@ fn send_interleved_blocking_scalar_message() { ) .expect("couldn't send message"); assert_eq!(result, xous_kernel::Result::Scalar1(2)); - }, - )) + }), + ) .expect("couldn't spawn client 1 process"); // Spawn the client "process" and wait for the server address. This one // will have `10` added to the value when it is returned. - let xous_client_2 = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( - "send_scalar_message client 2", - move || { + let xous_client_2 = xous_kernel::create_process_as_thread( + xous_kernel::ProcessArgsAsThread::new("send_scalar_message client 2", move || { let conn = xous_kernel::try_connect(sid_client_2).expect("couldn't connect to server"); let result = xous_kernel::try_send_message( conn, @@ -414,8 +527,8 @@ fn send_interleved_blocking_scalar_message() { ) .expect("couldn't send message"); assert_eq!(result, xous_kernel::Result::Scalar1(20)); - }, - )) + }), + ) .expect("couldn't spawn client 2 process"); // Wait for both processes to finish @@ -582,7 +695,8 @@ fn send_mutableborrow_message() { // println!("Received message from {}", envelope.sender); let message = envelope.body; if let xous_kernel::Message::MutableBorrow(m) = message { - let bt = unsafe { core::slice::from_raw_parts_mut(m.buf.as_mut_ptr(), m.buf.len()) }; + let bt = + unsafe { core::slice::from_raw_parts_mut(m.buf.as_mut_ptr(), m.buf.len()) }; // eprintln!("SERVER: UPDATING VALUES"); for letter in bt.iter_mut() { *letter += 1;