Improve the performance of function accessors (#723)

CoreMark result: 37.404152 (in 18.937s)

Slight performance improvement on Linux compared to [the previous
state](#46 (comment)).

#46

---------

Co-authored-by: Zhou Fang <[email protected]>
Co-authored-by: Julien Cretin <[email protected]>

Author: zhouwfang

crates/interpreter/src/module.rs

@@ -116,14 +116,7 @@ impl<'m> Module<'m> {
     }
 
     pub(crate) fn func_type(&self, x: FuncIdx) -> FuncType<'m> {
-        let mut parser = self.section(SectionId::Function).unwrap();
-        for i in 0 .. parser.parse_vec().into_ok() {
-            let y = parser.parse_typeidx().into_ok();
-            if i == x as usize {
-                return self.types[y as usize];
-            }
-        }
-        unreachable!()
+        self.types[self.side_table[x as usize].type_idx]
     }
 
     pub(crate) fn table_type(&self, x: TableIdx) -> TableType {
@@ -183,17 +176,9 @@ impl<'m> Module<'m> {
         unreachable!()
     }
 
-    // TODO(dev/fast-interp): Improve the performance of such accessor functions from O(n) to O(1).
     pub(crate) fn func(&self, x: FuncIdx) -> (Parser<'m>, &'m [BranchTableEntry]) {
-        let mut parser = self.section(SectionId::Code).unwrap();
-        for i in 0 .. parser.parse_vec().into_ok() {
-            let size = parser.parse_u32().into_ok() as usize;
-            let parser = parser.split_at(size).into_ok();
-            if i == x as usize {
-                return (parser, &self.side_table[i].branch_table);
-            }
-        }
-        unreachable!()
+        let MetadataEntry { parser_range, branch_table, .. } = &self.side_table[x as usize];
+        (unsafe { Parser::new(&self.binary[parser_range.clone()]) }, branch_table)
     }
 
     pub(crate) fn data(&self, x: DataIdx) -> Parser<'m> {

crates/interpreter/src/side_table.rs

@@ -43,24 +43,22 @@ impl<'m> Metadata<'m> {
         self.0[0] as usize
     }
 
-    pub fn parser(&self, code: &'m [u8]) -> Parser<'m> {
-        unsafe { Parser::new(&code[self.parser_pos(1) .. self.parser_pos(3)]) }
+    pub fn parser(&self, module: &'m [u8]) -> Parser<'m> {
+        unsafe { Parser::new(&module[self.read_u32(1) .. self.read_u32(3)]) }
     }
 
     pub fn branch_table(&self) -> &[BranchTableEntry] {
         bytemuck::cast_slice(&self.0[5 ..])
     }
 
-    fn parser_pos(&self, idx: usize) -> usize {
+    fn read_u32(&self, idx: usize) -> usize {
         bytemuck::pod_read_unaligned::<u32>(bytemuck::cast_slice(&self.0[idx .. idx + 2])) as usize
     }
 }
 
 #[derive(Default, Debug)]
 pub struct MetadataEntry {
-    #[allow(dead_code)]
     pub type_idx: usize,
-    #[allow(dead_code)]
     pub parser_range: Range<usize>,
     pub branch_table: Vec<BranchTableEntry>,
 }

crates/interpreter/src/valid.rs

@@ -47,6 +47,7 @@ struct Context<'m> {
 impl<'m> Context<'m> {
     fn check_module(&mut self, parser: &mut Parser<'m>) -> MResult<Vec<MetadataEntry>, Check> {
         check(parser.parse_bytes(8)? == b"\0asm\x01\0\0\0")?;
+        let module_start = parser.save().as_ptr() as usize;
         if let Some(mut parser) = self.check_section(parser, SectionId::Type)? {
             let n = parser.parse_vec()?;
             self.types.reserve(n);
@@ -128,19 +129,17 @@ impl<'m> Context<'m> {
         let mut side_tables = vec![];
         if let Some(mut parser) = self.check_section(parser, SectionId::Code)? {
             check(self.funcs.len() == imported_funcs + parser.parse_vec()?)?;
-            let code_start = parser.save().as_ptr() as usize;
             for x in imported_funcs .. self.funcs.len() {
                 let size = parser.parse_u32()? as usize;
                 let mut parser = parser.split_at(size)?;
+                let parser_start = parser.save().as_ptr() as usize - module_start;
                 let t = self.functype(x as FuncIdx).unwrap();
                 let mut locals = t.params.to_vec();
                 parser.parse_locals(&mut locals)?;
-                let parser_start = parser.save().as_ptr() as usize - code_start;
                 let branch_table = Expr::check_body(self, &mut parser, &refs, locals, t.results)?;
-                let parser_end = parser.save().as_ptr() as usize - code_start;
                 side_tables.push(MetadataEntry {
                     type_idx: self.funcs[x] as usize,
-                    parser_range: Range { start: parser_start, end: parser_end },
+                    parser_range: Range { start: parser_start, end: parser_start + size },
                     branch_table,
                 });
                 check(parser.is_empty())?;