From b77b38552dad70541be09d705515e84f0c807832 Mon Sep 17 00:00:00 2001 From: bunnie Date: Sat, 15 Jan 2022 17:00:43 +0800 Subject: [PATCH] reduce pre-allocs in ime-frontend --- services/ime-frontend/src/main.rs | 89 +++++++++++++++++-------------- 1 file changed, 48 insertions(+), 41 deletions(-) diff --git a/services/ime-frontend/src/main.rs b/services/ime-frontend/src/main.rs index e71044a15..aac9ebcd6 100644 --- a/services/ime-frontend/src/main.rs +++ b/services/ime-frontend/src/main.rs @@ -14,7 +14,7 @@ use blitstr_ref as blitstr; use ime_plugin_api::{PredictionTriggers, PredictionPlugin, PredictionApi}; use num_traits::{ToPrimitive,FromPrimitive}; -use xous_ipc::{String, Buffer}; +use xous_ipc::Buffer; use xous::{CID, msg_scalar_unpack}; use core::fmt::Write; @@ -40,19 +40,19 @@ struct InputTracker { /// our current prediction engine predictor: Option, /// the name & token of our engine, so we can disconnect later on - pub predictor_conn: Option<(String::<64>, [u32; 4])>, + pub predictor_conn: Option<(xous_ipc::String::<64>, [u32; 4])>, /// cached copy of the predictor's triggers for predictions. Only valid if predictor is not None pred_triggers: Option, /// set if we're in a state where a backspace should trigger an unpredict can_unpick: bool, // note: untested as of Mar 7 2021 /// the predictor string -- this is different from the input line, because it can be broken up by spaces and punctuatino - pred_phrase: String::<4000>, // note: untested as of Mar 7 2021 + pred_phrase: String, // note: untested as of Mar 7 2021 /// character position of the last prediction trigger -- this is where the prediction overwrite starts /// if None, it means we were unable to determine the trigger (e.g., we went back and edited text manually) last_trigger_char: Option, /// track the progress of our input line - line: String::<4000>, + line: String, /// length of the line in *characters*, not bytes (which is what .len() returns), used to index char_locs characters: usize, /// the insertion point, 0 is inserting characters before the first, 1 inserts characters after the first, etc. @@ -62,8 +62,8 @@ struct InputTracker { /// keep track if our box was grown was_grown: bool, - /// render the predictions - pred_options: [Option>; MAX_PREDICTION_OPTIONS], + /// render the predictions. Slightly awkward because this code comes from before we had libstd + pred_options: [Option; MAX_PREDICTION_OPTIONS], } impl InputTracker { @@ -77,14 +77,14 @@ impl InputTracker { pred_triggers: None, gam_token: None, can_unpick: false, - pred_phrase: String::<4000>::new(), + pred_phrase: String::new(), last_trigger_char: Some(0), - line: String::<4000>::new(), + line: String::new(), characters: 0, insertion: 0, last_height: 0, was_grown: false, - pred_options: [None; MAX_PREDICTION_OPTIONS], + pred_options: [None, None, None, None], // this has to be manually inferred because String doesn't implement "copy" and can't be None-init automatically } } pub fn set_gam_token(&mut self, token: [u32; 4]) { @@ -169,7 +169,7 @@ impl InputTracker { fn insert_prediction(&mut self, index: usize) { let debug1 = false; if debug1{info!("IMEF|insert_prediction index {}", index);} - let pred_str = match self.pred_options[index] { + let pred_str = match &self.pred_options[index] { Some(s) => s, _ => return // if the index doesn't exist for some reason, do nothing without throwing an error }; @@ -177,8 +177,7 @@ impl InputTracker { if let Some(offset) = self.last_trigger_char { if offset < self.characters { // copy the bytes in the original string, up to the offset; and then copy the bytes in the selected predictor - let tempbytes: [u8; 4000] = self.line.as_bytes(); - let tempstr = unsafe { core::str::from_utf8_unchecked(&tempbytes[0..self.line.len()]) }.clone(); + let tempstr = self.line.to_string(); self.line.clear(); let mut chars = 0; let mut c_iter = tempstr.chars(); @@ -187,15 +186,15 @@ impl InputTracker { break; } if let Some(c) = c_iter.next() { - self.line.push(c).unwrap(); // this should be infallible + self.line.push(c); chars += 1; } else { break; } } // now push the characters in the predicted options onto the line - for c in pred_str.as_str().unwrap().chars() { - self.line.push(c).expect("ran out of space inserting prediction"); + for c in pred_str.as_str().chars() { + self.line.push(c); chars += 1; } // forward until we find the next prediction trigger in the original string @@ -204,7 +203,7 @@ impl InputTracker { if trigger.whitespace && c.is_ascii_whitespace() || trigger.punctuation && c.is_ascii_punctuation() { // include the trigger that was found - self.line.push(c).expect("ran out of space inserting prediction"); + self.line.push(c); chars += 1; break; } @@ -216,14 +215,14 @@ impl InputTracker { self.last_trigger_char = Some(chars); // copy the remainder of the line, if any while let Some(c) = c_iter.next() { - self.line.push(c).expect("ran out of space inserting prediction"); + self.line.push(c); chars += 1; } self.characters = chars; } else { // just append the prediction to the line - for c in pred_str.as_str().unwrap().chars() { - self.line.push(c).expect("ran out of space inserting prediction"); + for c in pred_str.as_str().chars() { + self.line.push(c); self.characters += 1; } self.last_trigger_char = Some(self.insertion); @@ -232,10 +231,10 @@ impl InputTracker { } } - pub fn update(&mut self, newkeys: [char; 4], force_redraw: bool) -> Result>, xous::Error> { + pub fn update(&mut self, newkeys: [char; 4], force_redraw: bool) -> Result>, xous::Error> { let debug1= false; let mut update_predictor = false; - let mut retstring: Option> = None; + let mut retstring: Option> = None; if let Some(ic) = self.input_canvas { if debug1{info!("updating input area");} let ic_bounds: Point = self.gam.get_canvas_bounds(ic).expect("Couldn't get input canvas bounds"); @@ -323,8 +322,7 @@ impl InputTracker { if debug1{info!("mid-string backspace case")} // awful O(N) algo because we have to decode variable-length utf8 strings to figure out character boundaries // first, make a copy of the string - let tempbytes: [u8; 4000] = self.line.as_bytes(); - let tempstr = unsafe { core::str::from_utf8_unchecked(&tempbytes[0..self.line.len()]) }.clone(); + let tempstr = self.line.to_string(); // clear the string self.line.clear(); @@ -346,7 +344,7 @@ impl InputTracker { } } if debug1{info!("copying char {}", c);} - self.line.push(c).expect("ran out of space inserting orignial characters into input line"); + self.line.push(c); } i += 1; } @@ -358,15 +356,17 @@ impl InputTracker { } } '\u{000d}' => { // carriage return - let mut ret = String::<4000>::new(); - write!(ret, "{}", self.line.as_str().expect("couldn't convert input line")).expect("couldn't copy input ilne to output"); + let mut ret = xous_ipc::String::<4000>::new(); + write!(ret, "{}", self.line.as_str()).expect("couldn't copy input ilne to output"); retstring = Some(ret); if let Some(trigger) = self.pred_triggers { if trigger.newline { - self.predictor.unwrap().feedback_picked(self.line).expect("couldn't send feedback to predictor"); + self.predictor.unwrap().feedback_picked( + xous_ipc::String::<4000>::from_str(&self.line)).expect("couldn't send feedback to predictor"); } else if trigger.punctuation { - self.predictor.unwrap().feedback_picked(self.pred_phrase).expect("couldn't send feedback to predictor"); + self.predictor.unwrap().feedback_picked( + xous_ipc::String::<4000>::from_str(&self.pred_phrase)).expect("couldn't send feedback to predictor"); } } self.can_unpick = false; @@ -400,7 +400,8 @@ impl InputTracker { if let Some(trigger) = self.pred_triggers { if trigger.whitespace && k.is_ascii_whitespace() { if self.pred_phrase.len() > 0 { - self.predictor.unwrap().feedback_picked(self.pred_phrase).expect("couldn't send feedback to predictor"); + self.predictor.unwrap().feedback_picked( + xous_ipc::String::<4000>::from_str(&self.pred_phrase)).expect("couldn't send feedback to predictor"); self.pred_phrase.clear(); self.can_unpick = true; update_predictor = true; @@ -409,7 +410,8 @@ impl InputTracker { } if trigger.punctuation && k.is_ascii_punctuation() { if self.pred_phrase.len() > 0 { - self.predictor.unwrap().feedback_picked(self.pred_phrase).expect("couldn't send feedback to predictor"); + self.predictor.unwrap().feedback_picked( + xous_ipc::String::<4000>::from_str(&self.pred_phrase)).expect("couldn't send feedback to predictor"); self.pred_phrase.clear(); self.can_unpick = true; update_predictor = true; @@ -418,11 +420,11 @@ impl InputTracker { } } if self.insertion == self.characters { - self.line.push(k).expect("ran out of space pushing character into input line"); + self.line.push(k); if let Some(trigger) = self.pred_triggers { if !(trigger.punctuation && k.is_ascii_punctuation() || trigger.whitespace && k.is_ascii_whitespace() ) { - self.pred_phrase.push(k).expect("ran out of space pushing character into prediction phrase"); + self.pred_phrase.push(k); update_predictor = true; } } @@ -444,8 +446,7 @@ impl InputTracker { if debug1{info!("handling case of inserting characters. insertion: {}", self.insertion)}; // awful O(N) algo because we have to decode variable-length utf8 strings to figure out character boundaries // first, make a copy of the string - let tempbytes: [u8; 4000] = self.line.as_bytes(); - let tempstr = unsafe { core::str::from_utf8_unchecked(&tempbytes[0..self.line.len()]) }.clone(); + let tempstr =self.line.to_string(); // clear the string self.line.clear(); @@ -455,11 +456,11 @@ impl InputTracker { if debug1{info!("checking index {}", i);} if i == self.insertion { if debug1{info!("inserting char {}", k);} - self.line.push(k).expect("ran out of space inserting new character into input line"); - self.line.push(c).expect("ran out of space inserting orignial characters into input line"); + self.line.push(k); + self.line.push(c); } else { if debug1{info!("copying char {}", c);} - self.line.push(c).expect("ran out of space inserting orignial characters into input line"); + self.line.push(c); } i += 1; } @@ -474,7 +475,7 @@ impl InputTracker { input_tv.insertion = Some(self.insertion as _); if debug1{info!("insertion point is {}, characters in string {}", self.insertion, self.characters);} if do_redraw || force_redraw { - write!(input_tv.text, "{}", self.line.as_str().expect("couldn't convert str")).expect("couldn't update TextView string in input canvas"); + write!(input_tv.text, "{}", self.line.as_str()).expect("couldn't update TextView string in input canvas"); self.gam.post_textview(&mut input_tv).expect("can't draw input TextView"); if debug1{info!("got computed cursor of {:?}", input_tv.cursor);} @@ -525,14 +526,20 @@ impl InputTracker { if update_predictor { if self.pred_phrase.len() > 0 { if let Some(pred) = self.predictor { - pred.set_input(self.pred_phrase).expect("couldn't update predictor with current input"); + pred.set_input( + xous_ipc::String::<4000>::from_str(&self.pred_phrase)).expect("couldn't update predictor with current input"); } } // Query the prediction engine for the latest predictions if let Some(pred) = self.predictor { for i in 0..self.pred_options.len() { - self.pred_options[i] = pred.get_prediction(i as u32).expect("couldn't query prediction engine"); + let p = if let Some(prediction) = pred.get_prediction(i as u32).expect("couldn't query prediction engine") { + Some(String::from(prediction.as_str().unwrap_or("UTF-8 Error"))) + } else { + None + }; + self.pred_options[i] = p; } } } @@ -658,7 +665,7 @@ fn xmain() -> ! { Ok((pc, token)) => { tracker.set_predictor( Some(ime_plugin_api::PredictionPlugin {connection: Some(pc)}) ); tracker.predictor_conn = Some( - (String::<64>::from_str(s.as_str().unwrap()), + (xous_ipc::String::<64>::from_str(s.as_str().unwrap()), token.expect("didn't get the disconnect token!")) ); },