finalize rkyv 0.4.1 refactor

This commit is contained in:
bunnie 2021-03-18 03:54:48 +08:00
parent 8fbd900a4c
commit ea8b208a15
20 changed files with 203 additions and 172 deletions

6
Cargo.lock generated
View file

@ -83,7 +83,7 @@ version = "0.1.0"
dependencies = [
"log",
"log-server",
"rkyv 0.3.1",
"rkyv 0.4.1",
"utralib",
"xous",
"xous-names",
@ -654,7 +654,7 @@ dependencies = [
"heapless",
"log",
"log-server",
"rkyv 0.3.1",
"rkyv 0.4.1",
"ticktimer-server",
"utralib",
"xous",
@ -1155,7 +1155,7 @@ dependencies = [
"llio",
"log",
"log-server",
"rkyv 0.3.1",
"rkyv 0.4.1",
"ticktimer-server",
"utralib",
"xous",

85
kernel/Cargo.lock generated
View file

@ -218,26 +218,6 @@ version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724"
[[package]]
name = "hash32"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4041af86e63ac4298ce40e5cca669066e75b6f1aa3390fe2561ffa5e1d9f4cc"
dependencies = [
"byteorder",
]
[[package]]
name = "hash32-derive"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebc0efbd154a17cddc3616d83faef479c0076d871a2143c157b310cc7ca799a2"
dependencies = [
"proc-macro2 0.3.8",
"quote 0.5.2",
"syn 0.13.11",
]
[[package]]
name = "hermit-abi"
version = "0.1.17"
@ -330,22 +310,13 @@ version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
[[package]]
name = "proc-macro2"
version = "0.3.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b06e2f335f48d24442b35a19df506a835fb3547bc3c06ef27340da9acf5cae7"
dependencies = [
"unicode-xid 0.1.0",
]
[[package]]
name = "proc-macro2"
version = "1.0.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12"
dependencies = [
"unicode-xid 0.2.1",
"unicode-xid",
]
[[package]]
@ -363,9 +334,9 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7bcd6232fa7d7fcd15703da5c07c9f10d203ee4fdf6ecf6d7ac5056db78089a3"
dependencies = [
"proc-macro2 1.0.19",
"quote 1.0.7",
"syn 1.0.38",
"proc-macro2",
"quote",
"syn",
]
[[package]]
@ -377,22 +348,13 @@ dependencies = [
"memchr",
]
[[package]]
name = "quote"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9949cfe66888ffe1d53e6ec9d9f3b70714083854be20fd5e271b232a017401e8"
dependencies = [
"proc-macro2 0.3.8",
]
[[package]]
name = "quote"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
dependencies = [
"proc-macro2 1.0.19",
"proc-macro2",
]
[[package]]
@ -473,9 +435,9 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "95a169f6bc5a81033e86ed39d0f4150e2608160b73d2b93c6e8e6a3efa873f14"
dependencies = [
"proc-macro2 1.0.19",
"quote 1.0.7",
"syn 1.0.38",
"proc-macro2",
"quote",
"syn",
]
[[package]]
@ -542,26 +504,15 @@ dependencies = [
"quick-xml",
]
[[package]]
name = "syn"
version = "0.13.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14f9bf6292f3a61d2c716723fdb789a41bbe104168e6f496dc6497e531ea1b9b"
dependencies = [
"proc-macro2 0.3.8",
"quote 0.5.2",
"unicode-xid 0.1.0",
]
[[package]]
name = "syn"
version = "1.0.38"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e69abc24912995b3038597a7a593be5053eb0fb44f3cc5beec0deb421790c1f4"
dependencies = [
"proc-macro2 1.0.19",
"quote 1.0.7",
"unicode-xid 0.2.1",
"proc-macro2",
"quote",
"unicode-xid",
]
[[package]]
@ -585,12 +536,6 @@ version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
[[package]]
name = "unicode-xid"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
[[package]]
name = "unicode-xid"
version = "0.2.1"
@ -653,8 +598,6 @@ name = "xous"
version = "0.1.2"
dependencies = [
"bitflags",
"hash32",
"hash32-derive",
"hex",
"lazy_static",
"rkyv",
@ -665,8 +608,8 @@ dependencies = [
name = "xous-macros"
version = "0.1.0"
dependencies = [
"proc-macro2 1.0.19",
"quote 1.0.7",
"proc-macro2",
"quote",
"rand",
"syn 1.0.38",
"syn",
]

View file

@ -7,11 +7,15 @@ description = "Benchmark target for Xous"
[dependencies]
xous = { path = "../../xous-rs" }
rkyv = { version = "0.3.1", default_features = false }
xous-names = { path = "../xous-names" }
log-server = { path = "../log-server" }
log = "0.4"
[dependencies.rkyv]
version = "0.4.1"
default-features = false
features = ["const_generics"]
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}

View file

@ -4,6 +4,7 @@ pub mod api;
use api::*;
use xous::{CID, send_message};
use rkyv::ser::Serializer;
pub fn test_scalar(cid: CID, testvar: u32) -> Result<u32, xous::Error> {
let response = send_message(cid, api::Opcode::TestScalar(testvar).into())?;
@ -20,8 +21,9 @@ pub fn test_memory(cid: CID, testvar: u32) -> Result<u32, xous::Error> {
reg.challenge[0] = testvar;
let reg_opcode = api::Opcode::TestMemory(reg);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&reg_opcode).expect("couldn't archive test structure");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&reg_opcode).expect("couldn't archive test structure");
let mut xous_buffer = writer.into_inner();
xous_buffer.lend_mut(cid, pos as u32).expect("test failure");

View file

@ -11,7 +11,8 @@ use log::{error, info};
use rkyv::archived_value_mut;
use core::pin::Pin;
use core::convert::TryInto;
use rkyv::Serialize, rkyv::Deserialize;
use rkyv::{Serialize, Deserialize};
use rkyv::ser::Serializer;
#[xous::xous_main]
fn xmain() -> ! {
@ -44,8 +45,8 @@ fn xmain() -> ! {
ret.challenge[0] = reg.challenge[0] + 1;
let retop = Opcode::TestMemory(ret);
let mut writer = rkyv::ArchiveBuffer::new(buf);
let pos = writer.archive(&retop).expect("couldn't archive return value");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
let pos = writer.serialize_value(&retop).expect("couldn't archive return value");
unsafe{ rkyv::archived_value::<api::Opcode>(writer.into_inner().as_ref(), pos) };
}
_ => panic!("Invalid response from server -- corruption occurred"),

View file

@ -4,8 +4,8 @@ pub mod api;
use api::*;
use xous::send_message;
use rkyv::Write;
use rkyv::Serialize, rkyv::Deserialize;
use rkyv::Deserialize;
use rkyv::ser::Serializer;
use graphics_server::api::{TextOp, TextView};
use graphics_server::api::{Point, Gid, Line, Rectangle, Circle, RoundedRectangle};
@ -34,8 +34,9 @@ pub fn powerdown_request(gam_cid: xous::CID) -> Result<bool, xous::Error> {
pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::Error> {
tv.set_op(TextOp::Render);
let rkyv_tv = api::Opcode::RenderTextView(*tv);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive textview");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive textview");
let mut xous_buffer = writer.into_inner();
xous_buffer.lend_mut(gam_cid, pos as u32).expect("GAM_API: RenderTextView operation failure");
@ -43,7 +44,7 @@ pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::
// recover the mutable values and mirror the ones we care about back into our local structure
let returned = unsafe { rkyv::archived_value::<api::Opcode>(xous_buffer.as_ref(), pos)};
if let rkyv::Archived::<api::Opcode>::RenderTextView(result) = returned {
let tvr: TextView = result.deserialize();
let tvr: TextView = result.deserialize(&mut xous::XousDeserializer).unwrap();
tv.bounds_computed = tvr.bounds_computed;
tv.cursor = tvr.cursor;
} else {
@ -60,8 +61,9 @@ pub fn draw_line(gam_cid: xous::CID, gid: Gid, line: Line) -> Result<(), xous::E
canvas: gid,
obj: GamObjectType::Line(line),
});
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let xous_buffer = writer.into_inner();
xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure");
Ok(())
@ -72,8 +74,9 @@ pub fn draw_rectangle(gam_cid: xous::CID, gid: Gid, rect: Rectangle) -> Result<(
canvas: gid,
obj: GamObjectType::Rect(rect),
});
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let xous_buffer = writer.into_inner();
xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure");
Ok(())
@ -84,8 +87,9 @@ pub fn draw_rouded_rectangle(gam_cid: xous::CID, gid: Gid, rr: RoundedRectangle)
canvas: gid,
obj: GamObjectType::RoundRect(rr),
});
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let xous_buffer = writer.into_inner();
xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure");
Ok(())
@ -96,8 +100,9 @@ pub fn draw_circle(gam_cid: xous::CID, gid: Gid, circ: Circle) -> Result<(), xou
canvas: gid,
obj: GamObjectType::Circ(circ),
});
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject");
let xous_buffer = writer.into_inner();
xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure");
Ok(())
@ -119,15 +124,16 @@ pub fn get_canvas_bounds(gam_cid: xous::CID, gid: Gid) -> Result<Point, xous::Er
pub fn set_canvas_bounds_request(gam_cid: xous::CID, req: &mut SetCanvasBoundsRequest) -> Result<(), xous::Error> {
let rkyv = api::Opcode::SetCanvasBounds((*req).clone());
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv).expect("GAM_API: couldn't archive SetCanvasBounds");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv).expect("GAM_API: couldn't archive SetCanvasBounds");
let mut xous_buffer = writer.into_inner();
xous_buffer.lend_mut(gam_cid, pos as u32).expect("GAM_API: SetCanvasBounds operation failure");
// recover the mutable values and mirror the ones we care about back into our local structure
let returned = unsafe { rkyv::archived_value::<api::Opcode>(xous_buffer.as_ref(), pos)};
if let rkyv::Archived::<api::Opcode>::SetCanvasBounds(result) = returned {
let ret: SetCanvasBoundsRequest = result.deserialize();
let ret: SetCanvasBoundsRequest = result.deserialize(&mut xous::XousDeserializer).unwrap();
req.granted = ret.granted;
} else {
panic!("GAM_API: set_canvas_bounds_request view got a return value from the server that isn't expected or handled");
@ -145,15 +151,16 @@ pub fn request_content_canvas(gam_cid: xous::CID, requestor_name: &str) -> Resul
};
let rkyv = api::Opcode::RequestContentCanvas(req);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv).expect("GAM_API: couldn't archive RequestContentCanvas");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv).expect("GAM_API: couldn't archive RequestContentCanvas");
let mut xous_buffer = writer.into_inner();
xous_buffer.lend_mut(gam_cid, pos as u32).expect("GAM_API: RequestContentCanvas operation failure");
// recover the mutable values and mirror the ones we care about back into our local structure
let returned = unsafe { rkyv::archived_value::<api::Opcode>(xous_buffer.as_ref(), pos)};
if let rkyv::Archived::<api::Opcode>::RequestContentCanvas(result) = returned {
let ret: ContentCanvasRequest = result.deserialize();
let ret: ContentCanvasRequest = result.deserialize(&mut xous::XousDeserializer).unwrap();
Ok(ret.canvas)
} else {
log::error!("GAM_API: request_content_canvas got a return value from the server that isn't expected or handled");

View file

@ -22,7 +22,9 @@ use core::convert::TryFrom;
use heapless::FnvIndexMap;
use heapless::consts::*;
use rkyv::{Unarchive, archived_value, archived_value_mut};
use rkyv::{archived_value, archived_value_mut};
use rkyv::Deserialize;
use rkyv::ser::Serializer;
use core::pin::Pin;
#[derive(Debug)]
@ -291,7 +293,7 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<api::Opcode>::RenderTextView(rtv) => {
let mut tv = rtv.deserialize();
let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: rendertextview {:?}", tv);}
match tv.get_op() {
TextOp::Nop => (),
@ -322,9 +324,8 @@ fn xmain() -> ! {
tv.bounds_computed = tv_clone.bounds_computed;
// pack our data back into the buffer to return
use rkyv::Write;
let mut writer = rkyv::ArchiveBuffer::new(buf);
writer.archive(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value");
canvas.do_drawn().expect("GAM: couldn't set canvas to drawn");
} else {
info!("GAM: attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored.");
@ -337,7 +338,7 @@ fn xmain() -> ! {
};
},
rkyv::Archived::<api::Opcode>::SetCanvasBounds(rcb) => {
let mut cb: SetCanvasBoundsRequest = rcb.deserialize();
let mut cb: SetCanvasBoundsRequest = rcb.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: SetCanvasBoundsRequest {:?}", cb);}
// ASSUME:
// very few canvases allow dynamic resizing, so we special case these
@ -353,12 +354,11 @@ fn xmain() -> ! {
cb.granted = None;
}
// pack our data back into the buffer to return
use rkyv::Write;
let mut writer = rkyv::ArchiveBuffer::new(buf);
writer.archive(&api::Opcode::SetCanvasBounds(cb)).expect("GAM: SetCanvasBoundsRequest couldn't re-archive return value");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::SetCanvasBounds(cb)).expect("GAM: SetCanvasBoundsRequest couldn't re-archive return value");
},
rkyv::Archived::<api::Opcode>::RequestContentCanvas(rcc) => {
let mut req: ContentCanvasRequest = rcc.deserialize();
let mut req: ContentCanvasRequest = rcc.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: RequestContentCanvas {:?}", req);}
// for now, we do nothing with the incoming gid value; but, in the future, we can use it
// as an authentication token perhaps to control access
@ -373,9 +373,8 @@ fn xmain() -> ! {
req.canvas = chatlayout.content;
// pack our data back into the buffer to return
use rkyv::Write;
let mut writer = rkyv::ArchiveBuffer::new(buf);
writer.archive(&api::Opcode::RequestContentCanvas(req)).expect("GAM: RequestContentCanvas couldn't re-archive return value");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::RequestContentCanvas(req)).expect("GAM: RequestContentCanvas couldn't re-archive return value");
},
_ => panic!("GAM: invalid mutable borrow message"),
};
@ -387,7 +386,7 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<api::Opcode>::RenderObject(rtv) => {
let obj: GamObject = rtv.deserialize();
let obj: GamObject = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: renderobject {:?}", obj);}
if let Some(canvas) = canvases.get_mut(&obj.canvas) {
// first, figure out if we should even be drawing to this canvas.

View file

@ -8,7 +8,8 @@ pub use blitstr::{ClipRect, Cursor, GlyphStyle};
use xous::String;
pub mod op;
use xous::{send_message, CID};
use xous::{send_message, CID, XousDeserializer};
use rkyv::Deserialize;
use core::fmt::Write;
pub fn draw_line(cid: CID, line: Line) -> Result<(), xous::Error> {
@ -134,13 +135,13 @@ pub fn draw_textview(cid: CID, tv: &mut TextView) -> Result<(), xous::Error> {
let returned = unsafe { rkyv::archived_value::<api::Opcode>(xous_buffer.as_ref(), pos)};
if let rkyv::Archived::<api::Opcode>::DrawTextView(result) = returned {
let tvr: TextView = result.deserialize();
let tvr: TextView = result.deserialize(&mut XousDeserializer).expect("draw_textview couldn't deserialize result");
//log::info!("draw_textview: got cursor of {:?}, bounds of {:?}", tvr.cursor, tvr.bounds_computed);
tv.bounds_computed = tvr.bounds_computed;
tv.cursor = tvr.cursor;
Ok(())
} else {
let tvr = returned.deserialize();
let tvr = returned.deserialize(&mut XousDeserializer).expect("draw_textview couldn't deserialize result");
log::info!("draw_textview saw an unhandled return type of {:?}", tvr);
Err(xous::Error::InternalError)
}

View file

@ -7,7 +7,9 @@ mod api;
use api::{Opcode, ClipObject, ClipObjectType};
use core::pin::Pin;
use rkyv::{archived_value, Unarchive, archived_value_mut};
use rkyv::{archived_value, archived_value_mut};
use rkyv::Deserialize;
use rkyv::ser::Serializer;
mod backend;
use backend::XousDisplay;
@ -107,7 +109,7 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<api::Opcode>::String(rkyv_s) => {
let s: xous::String<4096> = rkyv_s.deserialize();
let s: xous::String<4096> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap();
//info!("GFX: unarchived string: {:?}", s);
blitstr::paint_str(
display.native_buffer(),
@ -123,7 +125,7 @@ fn xmain() -> ! {
//info!("GFX: string painted");
},
rkyv::Archived::<api::Opcode>::StringXor(rkyv_s) => {
let s: xous::String<4096> = rkyv_s.deserialize();
let s: xous::String<4096> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap();
blitstr::paint_str(
display.native_buffer(),
current_string_clip.into(),
@ -137,7 +139,7 @@ fn xmain() -> ! {
);
},
rkyv::Archived::<api::Opcode>::DrawClipObject(rco) => {
let obj: ClipObject = rco.deserialize();
let obj: ClipObject = rco.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GFX: DrawClipObject {:?}", obj);}
match obj.obj {
ClipObjectType::Line(line) => {
@ -164,7 +166,7 @@ fn xmain() -> ! {
let debugtv: bool = false;
match &*value {
rkyv::Archived::<api::Opcode>::DrawTextView(rtv) => {
let mut tv = rtv.deserialize();
let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if tv.clip_rect.is_none() { continue } // if no clipping rectangle is specified, nothing to draw
let clip_rect = tv.clip_rect.unwrap(); // this is the clipping rectangle of the canvas
@ -367,9 +369,8 @@ fn xmain() -> ! {
if debugtv{info!("GFX(TV): returning cursor of {:?}", tv.cursor);}
// pack our data back into the buffer to return
use rkyv::Write;
let mut writer = rkyv::ArchiveBuffer::new(buf);
writer.archive(&api::Opcode::DrawTextView(tv)).expect("GFX: couldn't re-archive return value");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::DrawTextView(tv)).expect("GFX: couldn't re-archive return value");
},
_ => panic!("GFX: invalid mutable borrow message"),
};

View file

@ -15,7 +15,7 @@ use blitstr_ref as blitstr;
use core::pin::Pin;
use ime_plugin_api::{PredictionTriggers, PredictionPlugin, PredictionApi};
use rkyv::Serialize, rkyv::Deserialize;
use rkyv::Deserialize;
use rkyv::archived_value;
use heapless::Vec;
@ -621,14 +621,14 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<ImefOpcode>::SetPredictionServer(rkyv_s) => {
let s: xous::String<256> = rkyv_s.deserialize();
let s: xous::String<256> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap();
match xous_names::request_connection(s.as_str().expect("IMEF: SetPrediction received malformed server name")) {
Ok(pc) => tracker.set_predictor(ime_plugin_api::PredictionPlugin {connection: Some(pc)}),
_ => error!("IMEF: can't find predictive engine {}, retaining existing one.", s.as_str().expect("IMEF: SetPrediction received malformed server name")),
}
},
rkyv::Archived::<ImefOpcode>::RegisterListener(registration) => {
let s: xous::String<256> = registration.deserialize();
let s: xous::String<256> = registration.deserialize(&mut xous::XousDeserializer).unwrap();
if dbglistener{info!("IMEF: registering listener {:?}", s);}
// note second copy down below, this is put in early-init because we're likely to get these requests early on
let cid = xous_names::request_connection_blocking(s.as_str().expect("IMEF: can't decode RegisterListener string"))
@ -677,14 +677,14 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<ImefOpcode>::SetPredictionServer(rkyv_s) => {
let s: xous::String<256> = rkyv_s.deserialize();
let s: xous::String<256> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap();
match xous_names::request_connection(s.as_str().expect("IMEF: SetPrediction received malformed server name")) {
Ok(pc) => tracker.set_predictor(ime_plugin_api::PredictionPlugin {connection: Some(pc)}),
_ => error!("IMEF: can't find predictive engine {}, retaining existing one.", s.as_str().expect("IMEF: SetPrediction received malformed server name")),
}
},
rkyv::Archived::<ImefOpcode>::RegisterListener(registration) => {
let s: xous::String<256> = registration.deserialize();
let s: xous::String<256> = registration.deserialize(&mut xous::XousDeserializer).unwrap();
if dbglistener{info!("IMEF: registering listener {:?}", s);}
// note first copy above, put in early-init because we're likely to get these requests early on
let cid = xous_names::request_connection_blocking(s.as_str().expect("IMEF: can't decode RegisterListener string"))
@ -700,10 +700,11 @@ fn xmain() -> ! {
if let Some(line) = tracker.update(keys).expect("IMEF: couldn't update input tracker with latest key presses") {
if dbglistener{info!("IMEF: sending listeners {:?}", line);}
for &conn in listeners.iter() {
use rkyv::Write;
let op = ImefOpcode::GotInputLine(line);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&op).expect("IMEF: couldn't archive line for sending");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
use rkyv::ser::Serializer;
let pos = writer.serialize_value(&op).expect("IMEF: couldn't archive line for sending");
if dbglistener{info!("IMEF: sending to conn {:?}", conn);}
writer.into_inner().lend(conn, pos as u32).expect("IMEF: couldn't send input line to listener");
}

View file

@ -2,6 +2,7 @@
use xous::{Message, ScalarMessage, String, CID};
use graphics_server::Gid;
use rkyv::ser::Serializer;
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub struct Prediction {
@ -137,12 +138,12 @@ impl PredictionApi for PredictionPlugin {
}
fn set_input(&self, s: String<4000>) -> Result<(), xous::Error> {
use rkyv::Write;
match self.connection {
Some(cid) => {
let rkyv_input = Opcode::Input(s);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_input).expect("IME|API: couldn't archive input string");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_input).expect("IME|API: couldn't archive input string");
let xous_buffer = writer.into_inner();
xous_buffer.lend(cid, pos as u32).expect("IME|API: set_input operation failure");
@ -153,12 +154,12 @@ impl PredictionApi for PredictionPlugin {
}
fn feedback_picked(&self, s: String<4000>) -> Result<(), xous::Error> {
use rkyv::Write;
match self.connection {
Some(cid) => {
let rkyv_picked = Opcode::Picked(s);
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&rkyv_picked).expect("IME|API: couldn't archive picked string");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&rkyv_picked).expect("IME|API: couldn't archive picked string");
let xous_buffer = writer.into_inner();
xous_buffer.lend(cid, pos as u32).expect("IME|API: feedback_picked operation failure");
@ -169,8 +170,7 @@ impl PredictionApi for PredictionPlugin {
}
fn get_prediction(&self, index: u32) -> Result<Option<xous::String<4000>>, xous::Error> {
use rkyv::Write;
use rkyv::Serialize, rkyv::Deserialize;
use rkyv::Deserialize;
let debug1 = false;
match self.connection {
Some(cid) => {
@ -181,8 +181,9 @@ impl PredictionApi for PredictionPlugin {
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 writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&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);}
@ -191,7 +192,7 @@ impl PredictionApi for PredictionPlugin {
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.deserialize();
let pred_r: Prediction = result.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{log::info!("IME|API: got {:?}", pred_r);}
if pred_r.valid {
let mut ret = xous::String::<4000>::new();
@ -202,7 +203,7 @@ impl PredictionApi for PredictionPlugin {
Ok(None)
}
} else {
let r = returned.deserialize();
let r = returned.deserialize(&mut xous::XousDeserializer).unwrap();
log::error!("IME: API get_prediction returned an invalid result {:?}", r);
Err(xous::Error::InvalidString)
}
@ -306,9 +307,9 @@ impl ImeFrontEndApi for ImeFrontEnd {
write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name");
let ime_op = ImefOpcode::SetPredictionServer(server);
use rkyv::Write as ArchiveWrite;
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&ime_op).expect("IMEF: couldn't archive SetPredictionServer");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&ime_op).expect("IMEF: couldn't archive SetPredictionServer");
writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredictionServer request failure");
Ok(())
},
@ -324,9 +325,9 @@ impl ImeFrontEndApi for ImeFrontEnd {
write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name");
let ime_op = ImefOpcode::RegisterListener(server);
use rkyv::Write as ArchiveWrite;
let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096));
let pos = writer.archive(&ime_op).expect("IMEF: couldn't archive SetPredictionServer");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096));
let pos = writer.serialize_value(&ime_op).expect("IMEF: couldn't archive SetPredictionServer");
writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredicitonServer request failure");
Ok(())
},

View file

@ -8,7 +8,8 @@ use log::{error, info};
use heapless::spsc::Queue;
use heapless::consts::U4;
use rkyv::Serialize, rkyv::Deserialize;
use rkyv::Deserialize;
use rkyv::ser::Serializer;
use core::pin::Pin;
use rkyv::{archived_value, archived_value_mut};
@ -59,7 +60,7 @@ fn xmain() -> ! {
// the picked results
},
rkyv::Archived::<Opcode>::Picked(rkyv_s) => {
let s: xous::String<4000> = rkyv_s.deserialize();
let s: xous::String<4000> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap();
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");
@ -79,7 +80,7 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<Opcode>::Prediction(pred_r) => {
let mut prediction: Prediction = pred_r.deserialize();
let mut prediction: Prediction = pred_r.deserialize(&mut xous::XousDeserializer).unwrap();
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()) {
@ -131,10 +132,9 @@ fn xmain() -> ! {
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");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
let _pos = writer.serialize_value(&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: Got invalid MutableBorrow")

View file

@ -12,7 +12,11 @@ log-server = { path = "../log-server" }
ticktimer-server = { path = "../ticktimer-server" }
xous-names = { path = "../xous-names" }
log = "0.4"
rkyv = { version = "0.3.1", default_features = false }
[dependencies.rkyv]
version = "0.4.1"
default-features = false
features = ["const_generics"]
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}

View file

@ -4,8 +4,9 @@
/// are calling these functions inside a different process.
pub mod api;
use api::*;
use rkyv::Deserialize;
use xous::{send_message, CID};
use xous::{send_message, CID, XousDeserializer};
// used by the LLIO to send a response to other servers
pub fn send_i2c_response(cid: CID, transaction: I2cTransaction) -> Result<(), xous::Error> {
@ -28,13 +29,13 @@ pub fn send_i2c_request(cid: CID, transaction: I2cTransaction) -> Result<I2cStat
use rkyv::ser::Serializer;
writer.serialize_value(&op).expect("LLIO_API: couldn't archive I2cTxRx")
};
let buf = writer.into_inner();
let mut buf = writer.into_inner();
buf.lend_mut(cid, pos as u32).expect("LLIO_API: I2cTxRx operation failure");
let returned = unsafe { rkyv::archived_value::<api::Opcode>(buf.as_ref(), pos)};
if let rkyv::Archived::<api::Opcode>::I2cTxRx(result) = returned {
let transaction = result.deserialise();
let transaction = result.deserialize(&mut XousDeserializer).expect("LLIO_API: Can't deserialize result in send_i2c_request");
Ok(transaction.status())
} else {
log::info!("send_i2c_request saw an unhandled return type of {:?}", buf);

View file

@ -9,7 +9,8 @@ use i2c::*;
use core::convert::TryFrom;
use core::pin::Pin;
use rkyv::archived_value;
use rkyv::Unarchive;
use rkyv::ser::Serializer;
use rkyv::Deserialize;
use log::{error, info};
@ -597,15 +598,16 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<Opcode>::I2cTxRx(rkyv_i2c) => {
let mut i2c_txrx: I2cTransaction = rkyv_i2c.deserialize();
let mut i2c_txrx: I2cTransaction = rkyv_i2c.deserialize(&mut xous::XousDeserializer).unwrap();
let status = i2c_machine.initiate(i2c_txrx);
i2c_txrx.status = status;
// pack our data back into the buffer to return
use rkyv::Write;
let mut writer = rkyv::ArchiveBuffer::new(buf);
writer.archive(&Opcode::I2cTxRx(i2c_txrx)).expect("LLIO: couldn't re-archive return value to I2cTxRx");
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
let pos = writer
.serialize_value(&Opcode::I2cTxRx(i2c_txrx))
.expect("LLIO: couldn't archive self");
},
_ => panic!("LLIO: invalid MutableBorrow memory message")
};
@ -617,7 +619,7 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<api::Opcode>::I2cSubscribe(registration) => {
let reg: xous::String::<64> = registration.unarchive();
let reg: xous::String::<64> = registration.deserialize(&mut xous::XousDeserializer).unwrap();
let cid = xous_names::request_connection_blocking(reg.to_str()).expect("KBD: can't connect to requested listener for reporting events");
i2c_machine.register_listener(cid).expect("LLIO: probably ran out of slots for I2C event reporting");
},

View file

@ -16,10 +16,13 @@ graphics-server = {path="../graphics-server"}
ime-plugin-api = {path="../ime-plugin-api"}
content-plugin-api = {path="../content-plugin-api"} # all content canvas providers must provide this API
log = "0.4"
rkyv = { version = "0.3.1", default_features = false }
com={path="../com"}
llio={path="../llio"}
[dependencies.rkyv]
version = "0.4.1"
default-features = false
features = ["const_generics"]
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}

View file

@ -6,7 +6,7 @@ use log::{error, info};
use core::fmt::Write;
use core::convert::TryFrom;
use rkyv::Serialize, rkyv::Deserialize;
use rkyv::Deserialize;
use rkyv::archived_value;
use core::pin::Pin;
@ -220,7 +220,7 @@ fn xmain() -> ! {
};
match &*value {
rkyv::Archived::<ime_plugin_api::ImefOpcode>::GotInputLine(rkyv_s) => {
let s: xous::String<4000> = rkyv_s.deserialize();
let s: xous::String<4000> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap();
repl.input(s.as_str().expect("SHCH: couldn't convert incoming string")).expect("SHCH: REPL couldn't accept input string");
update_repl = true; // set a flag, instead of calling here, so message can drop and calling server is released
},

View file

@ -1,6 +1,7 @@
#![allow(dead_code)]
use xous::CID;
use hash32::{Hash, Hasher};
// bottom 16 bits are reserved for structure re-use by other servers
pub const ID_REGISTER_NAME: u32 = 0x1_0000;
@ -86,6 +87,52 @@ impl XousServerName {
})
.unwrap()
}
pub fn new() -> XousServerName {
XousServerName {
value: [0; 64],
length: 0,
}
}
pub fn from_str(src: &str) -> XousServerName {
let mut s = Self::new();
// Copy the string into our backing store.
for (&src_byte, dest_byte) in src.as_bytes().iter().zip(&mut s.value) {
*dest_byte = src_byte;
}
// Set the string length to the length of the passed-in String,
// or the maximum possible length. Which ever is smaller.
s.length = s.value.len().min(src.as_bytes().len()) as u32;
// If the string is not valid, set its length to 0.
if s.as_str().is_err() {
s.length = 0;
}
s
}
pub fn as_bytes(&self) -> [u8; 64] {
self.value
}
pub fn as_str(&self) -> core::result::Result<&str, core::str::Utf8Error> {
core::str::from_utf8(&self.value[0..self.length as usize])
}
pub fn len(&self) -> usize {
self.length as usize
}
pub fn is_empty(&self) -> bool {
self.length == 0
}
/// Clear the contents and set the length to 0
pub fn clear(&mut self) {
self.length = 0;
self.value = [0; 64];
}
}
// Allow using the `write!()` macro to write into a `&XousServerName`

View file

@ -4,6 +4,7 @@
extern crate hash32_derive;
mod api;
use api::*;
use xous::buffer;
// use heapless::String;
@ -44,7 +45,7 @@ fn xmain() -> ! {
};
let new_value = match &*value {
rkyv::Archived::<api::Request>::Register(registration_name) => {
let name = xous::String::<64>::from_str(registration_name.as_str());
let name = XousServerName::from_str(registration_name.as_str());
if debug1{info!("NS: registration request for '{}'", name);}
if !name_table.contains_key(&name) {
let new_sid =
@ -70,7 +71,7 @@ fn xmain() -> ! {
}
}
rkyv::Archived::<api::Request>::Lookup(lookup_name) => {
let name = xous::String::<64>::from_str(lookup_name.as_str());
let name = XousServerName::from_str(lookup_name.as_str());
if debug1{info!("NS: Lookup request for '{}'", name);}
if let Some(server_sid) = name_table.get(&name) {
let sender_pid = envelope

View file

@ -274,6 +274,12 @@ impl<S: rkyv::ser::Serializer + ?Sized, const N: usize> rkyv::Serialize<S> for S
})
}
}
use rkyv::Fallible;
impl<D: Fallible + ?Sized, const N: usize> rkyv::Deserialize<String<N>, D> for ArchivedString {
fn deserialize(&self, _deserializer: &mut D) -> core::result::Result<String<N>, D::Error> {
Ok(String::<N>::from_str(self.as_str()))
}
}
impl<const N: usize> PartialEq for String<N> {
fn eq(&self, other: &Self) -> bool {
@ -282,4 +288,11 @@ impl<const N: usize> PartialEq for String<N> {
}
}
impl<const N: usize> Eq for String<N> {}
impl<const N: usize> Eq for String<N> {}
// a "no-op" deserializer for in-place data, required for rkyv 0.4.1
// perhaps in rkyv 0.5 this will go away, see https://github.com/djkoloski/rkyv/issues/67
pub struct XousDeserializer;
impl rkyv::Fallible for XousDeserializer {
type Error = crate::Error;
}