Runtime IO (#189)

_Based on #173._

This PR experiments with how Input / Output can work. It is based on
MMIO - Memory-Mapped IO. It works by reading or writing to specific
memory addresses. The system recognizes this and can commit to the
content as part of the proof.

This can also be used for debug statements during development:

```
📜📜📜 Hello, World!
🌏🌍🌎
test test_ceno_rt_io ... ok
```

---------

Co-authored-by: Aurélien Nicolas <[email protected]>

ceno_emul/tests/test_elf.rs

@@ -30,6 +30,52 @@ fn test_ceno_rt_mem() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_ceno_rt_io() -> Result<()> {
+    let program_elf = include_bytes!("./data/ceno_rt_io");
+    let mut state = VMState::new_from_elf(CENO_PLATFORM, program_elf)?;
+    let _steps = run(&mut state)?;
+
+    let all_messages = read_all_messages(&state);
+    for msg in &all_messages {
+        print!("{}", String::from_utf8_lossy(msg));
+    }
+    assert_eq!(&all_messages[0], "📜📜📜 Hello, World!\n".as_bytes());
+    assert_eq!(&all_messages[1], "🌏🌍🌎\n".as_bytes());
+    Ok(())
+}
+
 fn run(state: &mut VMState) -> Result<Vec<StepRecord>> {
     state.iter_until_success().collect()
 }
+
+const WORD_SIZE: usize = 4;
+const INFO_OUT_ADDR: u32 = 0xC000_0000;
+
+fn read_all_messages(state: &VMState) -> Vec<Vec<u8>> {
+    let mut all_messages = Vec::new();
+    let mut word_offset = 0;
+    loop {
+        let out = read_message(state, word_offset);
+        if out.is_empty() {
+            break;
+        }
+        word_offset += out.len().div_ceil(WORD_SIZE) as u32 + 1;
+        all_messages.push(out);
+    }
+    all_messages
+}
+
+fn read_message(state: &VMState, word_offset: u32) -> Vec<u8> {
+    let out_addr = ByteAddr(INFO_OUT_ADDR).waddr() + word_offset;
+    let byte_len = state.peek_memory(out_addr);
+    let word_len_up = byte_len.div_ceil(4);
+
+    let mut info_out = Vec::with_capacity(WORD_SIZE * word_len_up as usize);
+    for i in 1..1 + word_len_up {
+        let value = state.peek_memory(out_addr + i);
+        info_out.extend_from_slice(&value.to_le_bytes());
+    }
+    info_out.truncate(byte_len as usize);
+    info_out
+}

ceno_rt/examples/ceno_rt_io.rs

@@ -0,0 +1,13 @@
+#![no_main]
+#![no_std]
+
+#[allow(unused_imports)]
+use ceno_rt;
+use ceno_rt::println;
+use core::fmt::Write;
+
+#[no_mangle]
+fn main() {
+    println!("📜📜📜 Hello, World!");
+    println!("🌏🌍🌎");
+}

ceno_rt/src/io.rs

@@ -0,0 +1,74 @@
+use crate::{INFO_OUT_ADDR, WORD_SIZE};
+use core::{cell::Cell, fmt, mem::size_of, slice};
+
+static INFO_OUT: IOWriter = IOWriter::new(INFO_OUT_ADDR);
+
+pub fn info_out() -> &'static IOWriter {
+    &INFO_OUT
+}
+
+pub struct IOWriter {
+    cursor: Cell<*mut u32>,
+}
+
+// Safety: Only single-threaded programs are supported.
+// TODO: There may be a better way to handle this.
+unsafe impl Sync for IOWriter {}
+
+impl IOWriter {
+    const fn new(addr: u32) -> Self {
+        assert!(addr % WORD_SIZE as u32 == 0);
+        IOWriter {
+            cursor: Cell::new(addr as *mut u32),
+        }
+    }
+
+    pub fn alloc<T>(&self, count: usize) -> &mut [T] {
+        let byte_len = count * size_of::<T>();
+        let word_len = byte_len.div_ceil(WORD_SIZE);
+        let cursor = self.cursor.get();
+
+        // Bump the cursor to the next word-aligned address.
+        self.cursor.set(unsafe { cursor.add(word_len) });
+
+        // Return a slice of the allocated memory.
+        unsafe { slice::from_raw_parts_mut(cursor as *mut T, count) }
+    }
+
+    pub fn write(&self, msg: &[u8]) {
+        let buf = self.alloc(msg.len());
+        buf.copy_from_slice(msg);
+    }
+
+    pub fn write_frame(&self, msg: &[u8]) {
+        let word_len = msg.len().div_ceil(WORD_SIZE);
+        let words: &mut [u32] = self.alloc(1 + word_len);
+        words[0] = msg.len() as u32;
+        let bytes =
+            unsafe { slice::from_raw_parts_mut(words[1..].as_mut_ptr() as *mut u8, msg.len()) };
+        bytes.copy_from_slice(msg);
+    }
+}
+
+impl fmt::Write for &IOWriter {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_frame(s.as_bytes());
+        Ok(())
+    }
+}
+
+mod macros {
+    #[macro_export]
+    macro_rules! print {
+        ($($arg:tt)*) => {
+            let _ = core::write!($crate::info_out(), $($arg)*);
+        };
+    }
+
+    #[macro_export]
+    macro_rules! println {
+        ($($arg:tt)*) => {
+            let _ = core::writeln!($crate::info_out(), $($arg)*);
+        };
+    }
+}

ceno_rt/src/lib.rs

@@ -1,7 +1,13 @@
-#![no_main]
 #![no_std]
+
+mod io;
+pub use io::info_out;
+
 use core::arch::{asm, global_asm};
 
+mod params;
+pub use params::*;
+
 #[cfg(not(test))]
 mod panic_handler {
     use core::panic::PanicInfo;

ceno_rt/src/params.rs

@@ -0,0 +1,3 @@
+pub const WORD_SIZE: usize = 4;
+
+pub const INFO_OUT_ADDR: u32 = 0xC000_0000;