Shrink Node struct to reduce binary size

Signed-off-by: Simon Wülker <[email protected]>

Author: simonwuelker

html5ever/build/main.rs

@@ -238,14 +238,6 @@ impl DafsaBuilder {
     /// Computes all numbers needed for minimal perfect hashing
     fn compute_numbers(&mut self) {
         self.compute_numbers_for(0);
-        // // Compute numbers for all nodes except the root node
-        // for edge in self.nodes[0].edges {
-        //     let Some(edge) = edge else {
-        //         continue;
-        //     };
-
-        //     self.compute_numbers_for(edge);
-        // }
     }
 
     /// Returns the perfect hash value for the input, or `None` if
@@ -343,18 +335,8 @@ fn main() {
     )
     .unwrap();
 
-    // Define the root node
-    write!(
-        &mut result,
-        "Node {{
-        code_point: 0,
-        first_child_index: 1,
-        is_last_child: true,
-        is_terminal: false,
-        num_nodes: 0
-    }},"
-    )
-    .unwrap();
+    // Define all nodes by traversing the DAFSA graph
+    write!(&mut result, "Node::new(0, 0, false, true, 1),").unwrap();
     while let Some(handle) = stack.pop_front() {
         let node = &dafsa_builder.nodes[handle];
         let num_children = node.edges().count();
@@ -389,13 +371,7 @@ fn main() {
 
             write!(
                 &mut result,
-                "Node {{
-                code_point: {code_point},
-                first_child_index: {first_child_index},
-                is_last_child: {is_last_child},
-                is_terminal: {is_terminal},
-                num_nodes: {hash_value}
-            }},",
+                "Node::new({code_point}, {hash_value}, {is_terminal}, {is_last_child}, {first_child_index}),",
                 is_terminal = child.is_terminal,
                 hash_value = child.num_nodes
             )

html5ever/src/tokenizer/char_ref/codegen.rs

@@ -11,26 +11,62 @@ use crate::tokenizer::CharRef;
 
 include!(concat!(env!("OUT_DIR"), "/named_entities_graph.rs"));
 
+/// A single node in the DAFSA.
+///
+/// For memory efficiency reasons, this is packed in 32 bits. The memory representation is as follows:
+/// * 8 bits: code point
+/// * 8 bits: hash value
 #[derive(Clone, Copy, Debug)]
-pub(crate) struct Node {
-    first_child_index: usize,
-    code_point: u8,
-    is_last_child: bool,
-    is_terminal: bool,
-    num_nodes: u8,
-}
+pub(crate) struct Node(u32);
 
 impl Node {
+    const IS_TERMINAL: u32 = 1 << 15;
+    const IS_LAST_CHILD: u32 = 1 << 14;
+
+    pub(crate) const fn new(
+        code_point: u8,
+        hash_value: u8,
+        is_terminal: bool,
+        is_last_child: bool,
+        first_child_index: u16,
+    ) -> Self {
+        let mut value = 0;
+        value |= (code_point as u32) << 24;
+        value |= (hash_value as u32) << 16;
+
+        if is_terminal {
+            value |= Self::IS_TERMINAL;
+        }
+
+        if is_last_child {
+            value |= Self::IS_LAST_CHILD;
+        }
+
+        assert!(first_child_index <= 0xFFF);
+
+        value |= first_child_index as u32;
+
+        Self(value)
+    }
+
     pub(crate) const fn code_point(&self) -> u8 {
-        self.code_point
+        (self.0 >> 24) as u8
     }
 
-    pub(crate) const fn num_nodes(&self) -> usize {
-        self.num_nodes as usize
+    pub(crate) const fn hash_value(&self) -> usize {
+        ((self.0 >> 16) & 0xFF) as usize
     }
 
     pub(crate) const fn is_terminal(&self) -> bool {
-        self.is_terminal
+        (self.0 & Self::IS_TERMINAL) != 0
+    }
+
+    const fn is_last_child(&self) -> bool {
+        (self.0 & Self::IS_LAST_CHILD) != 0
+    }
+
+    const fn first_child_index(&self) -> u16 {
+        (self.0 & 0xFFF) as u16
     }
 
     pub(crate) fn children(&self) -> impl Iterator<Item = &'static Node> {
@@ -49,51 +85,22 @@ impl Node {
                 let node = &DAFSA_NODES[self.index];
                 self.index += 1;
 
-                if node.is_last_child {
+                if node.is_last_child() {
                     self.done = true;
                 }
 
                 Some(node)
             }
         }
 
+        let first_child_index = self.first_child_index();
         ChildIterator {
-            index: self.first_child_index,
-            done: self.first_child_index == 0,
+            index: first_child_index as usize,
+            done: first_child_index == 0,
         }
     }
 }
 
-// fn compute_unique_index(input: &str) -> Option<usize> {
-//     debug_assert!(input.is_ascii());
-
-//     let mut index = 0;
-//     let mut current = &DAFSA_NODES[0];
-//     for code_point in input.as_bytes() {
-//         let mut next_node = None;
-//         for child in current.children() {
-//             if child.code_point == *code_point {
-//                 next_node = Some(child);
-//                 break;
-//             } else {
-//                 index += child.num_nodes as usize;
-//             }
-//         }
-
-//         current = next_node?;
-
-//         if current.is_terminal {
-//             index += 1;
-//         }
-//     }
-
-//     if current.is_terminal {
-//         Some(index)
-//     } else {
-//         None
-//     }
-// }
-
 pub(crate) fn resolve_unique_hash_value(value: usize) -> CharRef {
     let (first, second) = REFERENCES[value];
 

html5ever/src/tokenizer/char_ref/named.rs

@@ -80,7 +80,7 @@ impl NamedReferenceTokenizerState {
                 next_node = Some(child);
                 break;
             } else {
-                self.hash_value += child.num_nodes() as usize;
+                self.hash_value += child.hash_value() as usize;
             }
         }