mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
optimize kernel message passing times
Based on this benchmark of elapsed_ms():
```rust
pub fn elapsed_ms(&self) -> u64 {
let response = send_message(
self.conn,
xous::Message::new_blocking_scalar(api::Opcode::ElapsedMs.to_usize().unwrap(), 0, 0, 0, 0),
)
.expect("Ticktimer: failure to send message to Ticktimer");
if let xous::Result::Scalar2(upper, lower) = response {
upper as u64 | ((lower as u64) << 32)
} else {
panic!("Ticktimer elapsed_ms(): unexpected return value.");
}
}
```
We find the following context switches:
1. send_message -> kernel/src/syscall.rs @ 166 - ss.remember_server_message()
- *context switch round trip* to enqueue the message into the target thread's space, then switch back.
- takes 546ns just in the target context, out of 4430ns round-trip
(measured as leave userspace of caller to enter userspace of callee) (12% of total time)
- emplaces the message in the target queue
- generates "sender_idx" which is the index in the message queue to find the message, which is put into Envelope
2. send_message -> kernel/src/syscall.rs @ 222 - ss.activate_process_thread()
- activates the thread to run
- Total penalty is closer to 1us - 22% of total time - once pre/amble/post-amble overhead considered
This set of patches removes the context-switch round trip to emplace messages in the target's thread
space, as well as to set thread results, by passing them as arguments to `activate_process_thread`.
What then happens is that these items are emplaced after the activation privot to the target
process space occurs, saving a set of TLB-flushes and page table walks.
More testing is required, but at least on a reasonable set of cases the system seems to be stable
with these patcehs, and we get a 24% speedup on blocking scalar messages and 8% speedup on
mutable lends in the case that the target is waiting to receive messages.
This commit is contained in:
parent
0e1018797e
commit
126896bf54
2 changed files with 169 additions and 74 deletions
|
|
@ -66,6 +66,14 @@ pub struct SystemServices {
|
||||||
pub servers: [Option<Server>; MAX_SERVER_COUNT],
|
pub servers: [Option<Server>; MAX_SERVER_COUNT],
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub enum PostActivateOp<'a> {
|
||||||
|
None,
|
||||||
|
// (result)
|
||||||
|
SetThreadResult(xous_kernel::Result),
|
||||||
|
// (sidx, current_pid, current_thread, message, client_address)
|
||||||
|
RememberServerMessage(usize, PID, TID, &'a Message, Option<MemoryAddress>),
|
||||||
|
}
|
||||||
|
|
||||||
#[derive(Copy, Clone, PartialEq)]
|
#[derive(Copy, Clone, PartialEq)]
|
||||||
pub enum ProcessState {
|
pub enum ProcessState {
|
||||||
/// This is an unallocated, free process
|
/// This is an unallocated, free process
|
||||||
|
|
@ -1042,13 +1050,21 @@ impl SystemServices {
|
||||||
|
|
||||||
/// Resume the given process, picking up exactly where it left off. If the
|
/// Resume the given process, picking up exactly where it left off. If the
|
||||||
/// process is in the Setup state, set it up and then resume.
|
/// process is in the Setup state, set it up and then resume.
|
||||||
|
///
|
||||||
|
/// `lazy_arg` is an argument that should be placed in the activated target process,
|
||||||
|
/// after the activation is complete. The purpose of this is to reduce the incidence
|
||||||
|
/// of the idiom where we swap into the a target process' memory state just to emplace
|
||||||
|
/// a small argument or piece of data, only to swap back to then return to it on activation.
|
||||||
|
/// This optimization improves message latency by around 15% in the fast path.
|
||||||
pub fn activate_process_thread(
|
pub fn activate_process_thread(
|
||||||
&mut self,
|
&mut self,
|
||||||
previous_tid: TID,
|
previous_tid: TID,
|
||||||
new_pid: PID,
|
new_pid: PID,
|
||||||
mut new_tid: TID,
|
mut new_tid: TID,
|
||||||
can_resume: bool,
|
can_resume: bool,
|
||||||
|
lazy_arg: PostActivateOp,
|
||||||
) -> Result<TID, xous_kernel::Error> {
|
) -> Result<TID, xous_kernel::Error> {
|
||||||
|
let mut sender_idx: Option<usize> = None;
|
||||||
let previous_pid = self.current_pid();
|
let previous_pid = self.current_pid();
|
||||||
|
|
||||||
#[cfg(feature = "debug-print")]
|
#[cfg(feature = "debug-print")]
|
||||||
|
|
@ -1060,59 +1076,63 @@ impl SystemServices {
|
||||||
|
|
||||||
// Save state if the PID has changed. This will activate the new memory
|
// Save state if the PID has changed. This will activate the new memory
|
||||||
// space.
|
// space.
|
||||||
let new = self.get_process_mut(new_pid)?;
|
|
||||||
if new_pid != previous_pid {
|
if new_pid != previous_pid {
|
||||||
klog!("New process original state: {:?}", new.state);
|
{
|
||||||
|
let new = self.get_process_mut(new_pid)?;
|
||||||
|
klog!("New process original state: {:?}", new.state);
|
||||||
|
|
||||||
// Ensure the new process can be run.
|
// Ensure the new process can be run.
|
||||||
match new.state {
|
match new.state {
|
||||||
ProcessState::Free => {
|
ProcessState::Free => {
|
||||||
klog!("PID {} was free", new_pid);
|
klog!("PID {} was free", new_pid);
|
||||||
return Err(xous_kernel::Error::ProcessNotFound);
|
return Err(xous_kernel::Error::ProcessNotFound);
|
||||||
}
|
}
|
||||||
ProcessState::Setup(_) | ProcessState::Allocated => new_tid = INITIAL_TID,
|
ProcessState::Setup(_) | ProcessState::Allocated => new_tid = INITIAL_TID,
|
||||||
ProcessState::Exception(_) => {
|
ProcessState::Exception(_) => {
|
||||||
new_tid = crate::arch::process::EXCEPTION_TID;
|
new_tid = crate::arch::process::EXCEPTION_TID;
|
||||||
// new.current_thread = new_tid;
|
// new.current_thread = new_tid;
|
||||||
}
|
}
|
||||||
ProcessState::Ready(x) => {
|
ProcessState::Ready(x) => {
|
||||||
// If no new context is specified, take the previous
|
// If no new context is specified, take the previous
|
||||||
// context. If that is not runnable, do a round-robin
|
// context. If that is not runnable, do a round-robin
|
||||||
// search for the next available context.
|
// search for the next available context.
|
||||||
assert!(x != 0, "process was {:?} but had no runnable threads", new.state);
|
assert!(x != 0, "process was {:?} but had no runnable threads", new.state);
|
||||||
if new_tid == 0 {
|
if new_tid == 0 {
|
||||||
new_tid = Self::find_next_thread(x, new.current_thread);
|
new_tid = Self::find_next_thread(x, new.current_thread);
|
||||||
}
|
}
|
||||||
if x & (1 << new_tid) == 0 {
|
if x & (1 << new_tid) == 0 {
|
||||||
println!(
|
println!(
|
||||||
"process state is {:?}, but new thread {} is not runnable",
|
"process state is {:?}, but new thread {} is not runnable",
|
||||||
new.state, new_tid
|
new.state, new_tid
|
||||||
);
|
);
|
||||||
|
return Err(xous_kernel::Error::ProcessNotFound);
|
||||||
|
}
|
||||||
|
new.current_thread = new_tid as _;
|
||||||
|
}
|
||||||
|
ProcessState::Running(_) => {
|
||||||
|
panic!("process was running even though the pid was different")
|
||||||
|
}
|
||||||
|
#[cfg(feature = "gdb-stub")]
|
||||||
|
ProcessState::Debug(_) | ProcessState::DebugIrq(_) => {
|
||||||
|
return Err(xous_kernel::Error::ProcessNotFound);
|
||||||
|
}
|
||||||
|
ProcessState::Sleeping | ProcessState::BlockedException(_) => {
|
||||||
|
// println!("PID {} was sleeping or being debugged", new_pid);
|
||||||
return Err(xous_kernel::Error::ProcessNotFound);
|
return Err(xous_kernel::Error::ProcessNotFound);
|
||||||
}
|
}
|
||||||
new.current_thread = new_tid as _;
|
|
||||||
}
|
|
||||||
ProcessState::Running(_) => {
|
|
||||||
panic!("process was running even though the pid was different")
|
|
||||||
}
|
|
||||||
#[cfg(feature = "gdb-stub")]
|
|
||||||
ProcessState::Debug(_) | ProcessState::DebugIrq(_) => {
|
|
||||||
return Err(xous_kernel::Error::ProcessNotFound);
|
|
||||||
}
|
|
||||||
ProcessState::Sleeping | ProcessState::BlockedException(_) => {
|
|
||||||
// println!("PID {} was sleeping or being debugged", new_pid);
|
|
||||||
return Err(xous_kernel::Error::ProcessNotFound);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Perform the actual switch to the new memory space. From this
|
// Perform the actual switch to the new memory space. From this
|
||||||
// point onward, we will need to activate the previous memory space
|
// point onward, we will need to activate the previous memory space
|
||||||
// if we encounter an error.
|
// if we encounter an error.
|
||||||
|
let new = self.get_process(new_pid)?;
|
||||||
new.mapping.activate()?;
|
new.mapping.activate()?;
|
||||||
|
|
||||||
// Set up the new process, if necessary. Remove the new thread from
|
// Set up the new process, if necessary. Remove the new thread from
|
||||||
// the list of ready threads.
|
// the list of ready threads.
|
||||||
// let old_state = new.state;
|
// let old_state = new.state;
|
||||||
|
let new = self.get_process_mut(new_pid)?;
|
||||||
new.state = match new.state {
|
new.state = match new.state {
|
||||||
ProcessState::Setup(thread_init) => {
|
ProcessState::Setup(thread_init) => {
|
||||||
// klog!("Setting up new process...");
|
// klog!("Setting up new process...");
|
||||||
|
|
@ -1141,6 +1161,27 @@ impl SystemServices {
|
||||||
};
|
};
|
||||||
// log_process_update(file!(), line!(), new, old_state);
|
// log_process_update(file!(), line!(), new, old_state);
|
||||||
new.activate()?;
|
new.activate()?;
|
||||||
|
match lazy_arg {
|
||||||
|
PostActivateOp::RememberServerMessage(
|
||||||
|
sidx,
|
||||||
|
current_pid,
|
||||||
|
current_thread,
|
||||||
|
message,
|
||||||
|
client_address,
|
||||||
|
) => {
|
||||||
|
let si = {
|
||||||
|
let server =
|
||||||
|
self.server_from_sidx_mut(sidx).expect("couldn't re-discover server index");
|
||||||
|
server.queue_response(current_pid, current_thread, message, client_address)?
|
||||||
|
};
|
||||||
|
sender_idx = Some(si);
|
||||||
|
}
|
||||||
|
PostActivateOp::SetThreadResult(result) => {
|
||||||
|
let mut arch_process = ArchProcess::current();
|
||||||
|
arch_process.set_thread_result(new_tid, result);
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
|
||||||
// Mark the previous process as ready to run, since we just switched
|
// Mark the previous process as ready to run, since we just switched
|
||||||
// away
|
// away
|
||||||
|
|
@ -1196,6 +1237,26 @@ impl SystemServices {
|
||||||
// can_resume
|
// can_resume
|
||||||
// );
|
// );
|
||||||
} else {
|
} else {
|
||||||
|
match lazy_arg {
|
||||||
|
PostActivateOp::RememberServerMessage(
|
||||||
|
sidx,
|
||||||
|
current_pid,
|
||||||
|
current_thread,
|
||||||
|
message,
|
||||||
|
client_address,
|
||||||
|
) => {
|
||||||
|
let si = {
|
||||||
|
let server =
|
||||||
|
self.server_from_sidx_mut(sidx).expect("couldn't re-discover server index");
|
||||||
|
server.queue_response(current_pid, current_thread, message, client_address)?
|
||||||
|
};
|
||||||
|
sender_idx = Some(si);
|
||||||
|
}
|
||||||
|
PostActivateOp::SetThreadResult(result) => {
|
||||||
|
ArchProcess::current().set_thread_result(new_tid, result);
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
let new = self.get_process_mut(new_pid)?;
|
let new = self.get_process_mut(new_pid)?;
|
||||||
|
|
||||||
// If we wanted to switch to a "new" thread, and it's the same
|
// If we wanted to switch to a "new" thread, and it's the same
|
||||||
|
|
@ -1253,7 +1314,9 @@ impl SystemServices {
|
||||||
self.get_process_mut(new_pid)?.state
|
self.get_process_mut(new_pid)?.state
|
||||||
);
|
);
|
||||||
|
|
||||||
Ok(new_tid)
|
// return argument based upon the lazy_arg type
|
||||||
|
// we get "lucky" in that sender_idx *and* new_tid are both `usize` types underneath
|
||||||
|
if let Some(si) = sender_idx { Ok(si) } else { Ok(new_tid) }
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Move memory from one process to another.
|
/// Move memory from one process to another.
|
||||||
|
|
@ -1725,7 +1788,7 @@ impl SystemServices {
|
||||||
if arch_process.thread_exists(join_tid) {
|
if arch_process.thread_exists(join_tid) {
|
||||||
// The target thread exists -- put this thread to sleep
|
// The target thread exists -- put this thread to sleep
|
||||||
let ppid = self.get_process(pid).unwrap().ppid;
|
let ppid = self.get_process(pid).unwrap().ppid;
|
||||||
self.activate_process_thread(tid, ppid, 0, false)
|
self.activate_process_thread(tid, ppid, 0, false, PostActivateOp::None)
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
||||||
} else {
|
} else {
|
||||||
|
|
|
||||||
|
|
@ -11,7 +11,7 @@ use crate::arch::process::Process as ArchProcess;
|
||||||
use crate::irq::{interrupt_claim, interrupt_free};
|
use crate::irq::{interrupt_claim, interrupt_free};
|
||||||
use crate::mem::MemoryManager;
|
use crate::mem::MemoryManager;
|
||||||
use crate::server::{SenderID, WaitingMessage};
|
use crate::server::{SenderID, WaitingMessage};
|
||||||
use crate::services::SystemServices;
|
use crate::services::{PostActivateOp, SystemServices};
|
||||||
#[cfg(feature = "swap")]
|
#[cfg(feature = "swap")]
|
||||||
use crate::swap::{Swap, SwapAbi};
|
use crate::swap::{Swap, SwapAbi};
|
||||||
|
|
||||||
|
|
@ -70,7 +70,7 @@ fn do_yield(_pid: PID, tid: TID) -> SysCallResult {
|
||||||
SystemServices::with_mut(|ss| {
|
SystemServices::with_mut(|ss| {
|
||||||
// TODO: Advance thread
|
// TODO: Advance thread
|
||||||
let result = ss
|
let result = ss
|
||||||
.activate_process_thread(tid, parent_pid, parent_ctx, true)
|
.activate_process_thread(tid, parent_pid, parent_ctx, true, PostActivateOp::None)
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
||||||
|
|
||||||
|
|
@ -162,17 +162,7 @@ fn send_message(pid: PID, tid: TID, cid: CID, message: Message) -> SysCallResult
|
||||||
// "there are threads available in PID {} to handle this message -- marking as Ready",
|
// "there are threads available in PID {} to handle this message -- marking as Ready",
|
||||||
// server_pid
|
// server_pid
|
||||||
// );
|
// );
|
||||||
let sender_idx = if message.is_blocking() {
|
let sender_idx = 0; // lazy-evaluate to a real number for blocking messages; eagerly set to 0 for non-blocking
|
||||||
ss.remember_server_message(sidx, pid, tid, &message, client_address).map_err(|e| {
|
|
||||||
klog!("error remembering server message: {:?}", e);
|
|
||||||
ss.server_from_sidx_mut(sidx)
|
|
||||||
.expect("server couldn't be located")
|
|
||||||
.return_available_thread(server_tid);
|
|
||||||
e
|
|
||||||
})?
|
|
||||||
} else {
|
|
||||||
0
|
|
||||||
};
|
|
||||||
let sender = SenderID::new(sidx, sender_idx, Some(pid));
|
let sender = SenderID::new(sidx, sender_idx, Some(pid));
|
||||||
klog!("server connection data: sidx: {}, idx: {}, server pid: {}", sidx, sender_idx, server_pid);
|
klog!("server connection data: sidx: {}, idx: {}, server pid: {}", sidx, sender_idx, server_pid);
|
||||||
let envelope = MessageEnvelope { sender: sender.into(), body: message };
|
let envelope = MessageEnvelope { sender: sender.into(), body: message };
|
||||||
|
|
@ -191,19 +181,33 @@ fn send_message(pid: PID, tid: TID, cid: CID, message: Message) -> SysCallResult
|
||||||
// --- NOTE: Returning this value //
|
// --- NOTE: Returning this value //
|
||||||
return if blocking && cfg!(baremetal) {
|
return if blocking && cfg!(baremetal) {
|
||||||
if !runnable {
|
if !runnable {
|
||||||
|
// re-bind the envelope because the sender_idx binding is lazily evaluated
|
||||||
|
let message = envelope.take_message();
|
||||||
|
let sender_idx = ss
|
||||||
|
.remember_server_message(sidx, pid, tid, &message, client_address)
|
||||||
|
.map_err(|e| {
|
||||||
|
klog!("error remembering server message: {:?}", e);
|
||||||
|
ss.server_from_sidx_mut(sidx)
|
||||||
|
.expect("server couldn't be located")
|
||||||
|
.return_available_thread(server_tid);
|
||||||
|
e
|
||||||
|
})?;
|
||||||
|
let sender = SenderID::new(sidx, sender_idx, Some(pid));
|
||||||
|
let envelope = MessageEnvelope { sender: sender.into(), body: message };
|
||||||
|
|
||||||
// If it's not runnable (e.g. it's being debugged), switch to the parent.
|
// If it's not runnable (e.g. it's being debugged), switch to the parent.
|
||||||
let (ppid, ptid) = unsafe { (&mut *(&raw mut SWITCHTO_CALLER)).take().unwrap() };
|
let (ppid, ptid) = unsafe { (&mut *(&raw mut SWITCHTO_CALLER)).take().unwrap() };
|
||||||
klog!(
|
klog!(
|
||||||
"Activating Server parent process (server is blocked) and switching away from Client"
|
"Activating Server parent process (server is blocked) and switching away from Client"
|
||||||
);
|
);
|
||||||
ss.set_thread_result(
|
|
||||||
server_pid,
|
|
||||||
server_tid,
|
|
||||||
xous_kernel::Result::MessageEnvelope(envelope),
|
|
||||||
)
|
|
||||||
.expect("couldn't set result for server thread");
|
|
||||||
let result = ss
|
let result = ss
|
||||||
.activate_process_thread(tid, ppid, ptid, false)
|
.activate_process_thread(
|
||||||
|
tid,
|
||||||
|
ppid,
|
||||||
|
ptid,
|
||||||
|
false,
|
||||||
|
PostActivateOp::SetThreadResult(xous_kernel::Result::MessageEnvelope(envelope)),
|
||||||
|
)
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
||||||
|
|
||||||
|
|
@ -219,11 +223,36 @@ fn send_message(pid: PID, tid: TID, cid: CID, message: Message) -> SysCallResult
|
||||||
} else {
|
} else {
|
||||||
// Switch to the server, since it's in a state to be run.
|
// Switch to the server, since it's in a state to be run.
|
||||||
klog!("Activating Server context and switching away from Client");
|
klog!("Activating Server context and switching away from Client");
|
||||||
ss.activate_process_thread(tid, server_pid, server_tid, false)
|
let message = envelope.take_message();
|
||||||
.map(|_| Ok(xous_kernel::Result::MessageEnvelope(envelope)))
|
match ss.activate_process_thread(
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
tid,
|
||||||
|
server_pid,
|
||||||
|
server_tid,
|
||||||
|
false,
|
||||||
|
PostActivateOp::RememberServerMessage(sidx, pid, tid, &message, client_address),
|
||||||
|
) {
|
||||||
|
Ok(sender_idx) => {
|
||||||
|
let sender = SenderID::new(sidx, sender_idx, Some(pid));
|
||||||
|
let envelope = MessageEnvelope { sender: sender.into(), body: message };
|
||||||
|
Ok(xous_kernel::Result::MessageEnvelope(envelope))
|
||||||
|
}
|
||||||
|
_ => Err(xous_kernel::Error::ProcessNotFound),
|
||||||
|
}
|
||||||
}
|
}
|
||||||
} else if blocking && !cfg!(baremetal) {
|
} else if blocking && !cfg!(baremetal) {
|
||||||
|
// re-bind the envelope: lazy eval has to happen now.
|
||||||
|
let message = envelope.take_message();
|
||||||
|
let sender_idx =
|
||||||
|
ss.remember_server_message(sidx, pid, tid, &message, client_address).map_err(|e| {
|
||||||
|
klog!("error remembering server message: {:?}", e);
|
||||||
|
ss.server_from_sidx_mut(sidx)
|
||||||
|
.expect("server couldn't be located")
|
||||||
|
.return_available_thread(server_tid);
|
||||||
|
e
|
||||||
|
})?;
|
||||||
|
let sender = SenderID::new(sidx, sender_idx, Some(pid));
|
||||||
|
let envelope = MessageEnvelope { sender: sender.into(), body: message };
|
||||||
|
|
||||||
klog!("Blocking client, since it sent a blocking message");
|
klog!("Blocking client, since it sent a blocking message");
|
||||||
ss.unschedule_thread(pid, tid)?;
|
ss.unschedule_thread(pid, tid)?;
|
||||||
ss.switch_to_thread(server_pid, Some(server_tid))?;
|
ss.switch_to_thread(server_pid, Some(server_tid))?;
|
||||||
|
|
@ -262,7 +291,7 @@ fn send_message(pid: PID, tid: TID, cid: CID, message: Message) -> SysCallResult
|
||||||
let ppid = process.ppid;
|
let ppid = process.ppid;
|
||||||
unsafe { SWITCHTO_CALLER = None };
|
unsafe { SWITCHTO_CALLER = None };
|
||||||
let result = ss
|
let result = ss
|
||||||
.activate_process_thread(tid, ppid, 0, false)
|
.activate_process_thread(tid, ppid, 0, false, PostActivateOp::None)
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
||||||
|
|
||||||
|
|
@ -590,13 +619,16 @@ fn reply_and_receive_next(
|
||||||
} else {
|
} else {
|
||||||
// For baremetal targets, switch away from this process.
|
// For baremetal targets, switch away from this process.
|
||||||
if cfg!(baremetal) {
|
if cfg!(baremetal) {
|
||||||
// Set the thread result for the client
|
// Set the thread result for the client and activate the client thread and switch to it
|
||||||
ss.set_thread_result(response.pid, response.tid, response.result)?;
|
ss.activate_process_thread(
|
||||||
|
server_tid,
|
||||||
// Activate the client thread and switch to it
|
response.pid,
|
||||||
ss.activate_process_thread(server_tid, response.pid, response.tid, false)
|
response.tid,
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
false,
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
crate::services::PostActivateOp::SetThreadResult(response.result),
|
||||||
|
)
|
||||||
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
||||||
}
|
}
|
||||||
// For hosted targets, simply return `BlockedProcess` indicating we'll make
|
// For hosted targets, simply return `BlockedProcess` indicating we'll make
|
||||||
// a callback to their socket at a later time.
|
// a callback to their socket at a later time.
|
||||||
|
|
@ -650,7 +682,7 @@ fn receive_message(pid: PID, tid: TID, sid: SID, blocking: ExecutionType) -> Sys
|
||||||
let ppid = ss.get_process(pid).expect("Can't get current process").ppid;
|
let ppid = ss.get_process(pid).expect("Can't get current process").ppid;
|
||||||
// TODO: Advance thread
|
// TODO: Advance thread
|
||||||
let result = ss
|
let result = ss
|
||||||
.activate_process_thread(tid, ppid, 0, false)
|
.activate_process_thread(tid, ppid, 0, false, PostActivateOp::None)
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
||||||
ss.set_last_thread(PID::new(ORIGINAL_PID.load(Relaxed)).unwrap(), ORIGINAL_TID.load(Relaxed))
|
ss.set_last_thread(PID::new(ORIGINAL_PID.load(Relaxed)).unwrap(), ORIGINAL_TID.load(Relaxed))
|
||||||
|
|
@ -841,7 +873,7 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
||||||
// "Activating process thread {} in pid {} coming from pid {} thread {}",
|
// "Activating process thread {} in pid {} coming from pid {} thread {}",
|
||||||
// new_context, new_pid, pid, tid
|
// new_context, new_pid, pid, tid
|
||||||
// );
|
// );
|
||||||
let new_tid = ss.activate_process_thread(tid, new_pid, new_tid, true)?;
|
let new_tid = ss.activate_process_thread(tid, new_pid, new_tid, true, PostActivateOp::None)?;
|
||||||
ORIGINAL_PID.store(new_pid.get(), Relaxed);
|
ORIGINAL_PID.store(new_pid.get(), Relaxed);
|
||||||
ORIGINAL_TID.store(new_tid, Relaxed);
|
ORIGINAL_TID.store(new_tid, Relaxed);
|
||||||
Ok(xous_kernel::Result::ResumeProcess)
|
Ok(xous_kernel::Result::ResumeProcess)
|
||||||
|
|
@ -870,7 +902,7 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
||||||
// TODO: Advance thread
|
// TODO: Advance thread
|
||||||
if cfg!(baremetal) {
|
if cfg!(baremetal) {
|
||||||
let result = ss
|
let result = ss
|
||||||
.activate_process_thread(tid, ppid, 0, false)
|
.activate_process_thread(tid, ppid, 0, false, PostActivateOp::None)
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound));
|
||||||
ss.set_last_thread(PID::new(ORIGINAL_PID.load(Relaxed)).unwrap(), ORIGINAL_TID.load(Relaxed))
|
ss.set_last_thread(PID::new(ORIGINAL_PID.load(Relaxed)).unwrap(), ORIGINAL_TID.load(Relaxed))
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue