TIL you can't return variable-length strings in an rkyv

rkyv does some optimization to not send all the data in
a string if you don't use it up.

xous assumes the same "pos" argument on the return type

thus a variable length string doesn't work as a return type
(you can send it, because you can specify a "pos" on the send
side).

fortunately, the application for the variable-length string
was getting predictions out of the predictor, and a short (31 element)
fixed-length array with a side companion of a len variable
should be more than sufficient for completion suggestions.
This commit is contained in:
bunnie 2021-03-08 04:25:58 +08:00
parent 8a8c1e6a66
commit d5d8e0ee86
2 changed files with 83 additions and 27 deletions

View file

@ -6,7 +6,11 @@ use graphics_server::Gid;
#[derive(Debug, rkyv::Archive, rkyv::Unarchive)]
pub struct Prediction {
pub index: u32,
pub string: xous::String<4096>,
pub valid: bool,
// to *return* a value in rkyv, we can't have a variable-length string, as the "pos" argument changes
// this is OK for predictions, we only show the first few characters anyways.
pub string: [u8; 31], // 31 is the longest fixed-length array rkyv supports
pub len: u32,
}
#[derive(Debug, Default, Copy, Clone)]
@ -42,10 +46,10 @@ impl From<usize> for PredictionTriggers {
#[derive(Debug, rkyv::Archive, rkyv::Unarchive)]
pub enum Opcode {
/// update with the latest input candidate. Replaces the previous input.
Input(xous::String<4096>),
Input(xous::String<4000>),
/// feed back to the IME plugin as to what was picked, so predictions can be updated
Picked(xous::String<4096>),
Picked(xous::String<4000>),
/// Undo the last Picked value. To be used when a user hits backspace after picking a prediction
/// note that repeated calls to Unpick will have an implementation-defined behavior
@ -96,9 +100,9 @@ impl Into<Message> for Opcode {
pub trait PredictionApi {
fn get_prediction_triggers(&self) -> Result<PredictionTriggers, xous::Error>;
fn unpick(&self) -> Result<(), xous::Error>;
fn set_input(&self, s: String<4096>) -> Result<(), xous::Error>;
fn feedback_picked(&self, s: String<4096>) -> Result<(), xous::Error>;
fn get_prediction(&self, index: u32) -> Result<xous::String<4096>, xous::Error>;
fn set_input(&self, s: String<4000>) -> Result<(), xous::Error>;
fn feedback_picked(&self, s: String<4000>) -> Result<(), xous::Error>;
fn get_prediction(&self, index: u32) -> Result<Option<xous::String<4000>>, xous::Error>;
}
// provide a convenience version of the API for generic/standard calls
@ -132,7 +136,7 @@ impl PredictionApi for PredictionPlugin {
}
}
fn set_input(&self, s: String<4096>) -> Result<(), xous::Error> {
fn set_input(&self, s: String<4000>) -> Result<(), xous::Error> {
use rkyv::Write;
match self.connection {
Some(cid) => {
@ -148,7 +152,7 @@ impl PredictionApi for PredictionPlugin {
}
}
fn feedback_picked(&self, s: String<4096>) -> Result<(), xous::Error> {
fn feedback_picked(&self, s: String<4000>) -> Result<(), xous::Error> {
use rkyv::Write;
match self.connection {
Some(cid) => {
@ -164,30 +168,42 @@ impl PredictionApi for PredictionPlugin {
}
}
fn get_prediction(&self, index: u32) -> Result<xous::String<4096>, xous::Error> {
fn get_prediction(&self, index: u32) -> Result<Option<xous::String<4000>>, xous::Error> {
use rkyv::Write;
use rkyv::Unarchive;
let debug1 = true;
match self.connection {
Some(cid) => {
let prediction = Prediction {
index,
string: xous::String::<4096>::new(),
string: [0; 31],
len: 0,
valid: false,
};
let pred_op = Opcode::Prediction(prediction);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&pred_op).expect("IME|API: couldn't archive prediction request");
let mut xous_buffer = writer.into_inner();
if debug1{log::info!("IME|API: lending Prediction with pos {}", pos);}
xous_buffer.lend_mut(cid, pos as u32).expect("IME|API: prediction fetch operation failure");
if debug1{log::info!("IME|API: returned from get_prediction");}
let returned = unsafe { rkyv::archived_value::<Opcode>(xous_buffer.as_ref(), pos)};
if let rkyv::Archived::<Opcode>::Prediction(result) = returned {
let pred_r: Prediction = result.unarchive();
let retstring: xous::String<4096> = pred_r.string.clone();
Ok(retstring)
if debug1{log::info!("IME|API: got {:?}", pred_r);}
if pred_r.valid {
let mut ret = xous::String::<4000>::new();
use core::fmt::Write as CoreWrite;
write!(ret, "{}", core::str::from_utf8(&pred_r.string[0..pred_r.len as usize]).unwrap()).unwrap();
Ok(Some(ret))
} else {
Ok(None)
}
} else {
let r = returned.unarchive();
log::error!("IME:API get_prediction returned an invalid result {:?}", r);
log::error!("IME: API get_prediction returned an invalid result {:?}", r);
Err(xous::Error::InvalidString)
}
},

View file

@ -6,7 +6,7 @@ use core::convert::TryFrom;
use log::{error, info};
use heapless::spsc::Queue;
use heapless::consts::U3;
use heapless::consts::U8;
use rkyv::Unarchive;
use core::pin::Pin;
@ -21,8 +21,8 @@ fn xmain() -> ! {
let ime_sh_sid = xous_names::register_name(xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("IME_SH: can't register server");
if debug1{info!("IME_SH: registered with NS -- {:?}", ime_sh_sid);}
let mut history: Queue<xous::String<4096>, U3> = Queue::new(); // this has 2^3 elements = 8
let history_max = 8;
let mut history: Queue<xous::String<64>, U4> = Queue::new(); // this has 2^4 elements = 16??? or does it just have 4 elements.
let history_max = 4;
let mytriggers = PredictionTriggers {
newline: true,
@ -46,11 +46,16 @@ fn xmain() -> ! {
// the picked results
},
rkyv::Archived::<Opcode>::Picked(rkyv_s) => {
let s: xous::String<4096> = rkyv_s.unarchive();
let s: xous::String<4000> = rkyv_s.unarchive();
let mut local_s: xous::String<64> = xous::String::new();
use core::fmt::Write;
write!(local_s, "{:32}", s).expect("IME_SH: overflowed history variable");
if debug1{info!("IME_SH: storing history value | {}", s);}
if history.len() == history_max {
history.dequeue().expect("IME_SH: couldn't dequeue history");
}
history.enqueue(s).expect("IME_SH: couldn't store history");
history.enqueue(local_s).expect("IME_SH: couldn't store history");
if debug1{info!("IME_SH: history has length {}", history.len());}
},
_ => error!("IME_SH: unknown Borrow message")
};
@ -62,29 +67,64 @@ fn xmain() -> ! {
match &*value {
rkyv::Archived::<Opcode>::Prediction(pred_r) => {
let mut prediction: Prediction = pred_r.unarchive();
if history.len() > 0 {
if debug1{info!("IME_SH: querying prediction index {}", prediction.index);}
if debug1{info!("IME_SH: {:?}", prediction);}
if history.len() > 0 && ((prediction.index as usize) < history.len()) {
let mut index = prediction.index;
if index >= history.len() as u32 {
index = history.len() as u32 - 1;
}
let mut i = history.len() as u32;
let mut retstr = xous::String::new();
for &s in history.iter() {
// iterator is from oldest to newest, so do some math to go from newest to oldest
if (history.len() as u32 - i) == index {
retstr = s;
// decompose the string into a character-by-character sequence
// and then stuff byte-by-byte, as fits, into the return array
prediction.len = 0;
for ch in s.as_str().unwrap().chars() {
match ch.len_utf8() {
1 => {
if prediction.len < prediction.string.len() as u32 {
prediction.string[prediction.len as usize] = ch as u8;
prediction.len += 1;
} else {
break;
}
},
_ => {
let mut data: [u8; 4] = [0; 4];
let subslice = ch.encode_utf8(&mut data);
if prediction.len + (subslice.len() as u32) < prediction.string.len() as u32 {
for c in subslice.bytes() {
prediction.string[prediction.len as usize] = c;
prediction.len += 1;
}
} else {
break;
}
},
}
}
prediction.valid = true;
break;
}
i = i + 1;
i = i - 1;
}
prediction.string = retstr;
} else { // there is no history
// return the empty string
prediction.string = xous::String::new();
prediction.valid = false;
if debug1{info!("IME_SH: no prediction found");}
}
if debug1{info!("IME_SH: returning index {} string {:?}", prediction.index, prediction.string);}
// pack our data back into the buffer to return
use rkyv::Write;
let ret_op = Opcode::Prediction(prediction);
let mut writer = rkyv::ArchiveBuffer::new(buf);
let _pos = writer.archive(&ret_op).expect("IME_SH: Prediction query couldn't re-archive return value");
if debug1{info!("IME_SH: archived with pos {}", _pos);}
},
_ => error!("IME_SH: unknown MutableBorrow message"),
}
_ => error!("IME_SH: Got invalid MutableBorrow")
};
} else if let Ok(opcode) = Opcode::try_from(&envelope.body) {
match opcode {
Opcode::Unpick => {