eytzinger binary search for span lines

Author: xunilrj

sway-types/src/eytzinger.rs

@@ -0,0 +1,81 @@
+#[derive(Default)]
+pub struct Eytzinger<T>(Vec<T>, Vec<usize>);
+
+#[derive(Debug)]
+pub struct Index {
+    pub index: usize,
+    pub original: usize,
+}
+
+fn eytzinger<T: Copy>(a: &[T], b: &mut [T], mut i: usize, k: usize) -> usize {
+    if k <= a.len() {
+        i = eytzinger(a, b, i, 2 * k);
+        b[k] = a[i];
+        i += 1;
+        i = eytzinger(a, b, i, 2 * k + 1);
+    }
+    i
+}
+
+impl<T: Copy + Default> From<&[T]> for Eytzinger<T> {
+    fn from(input: &[T]) -> Self {
+        let mut result = vec![T::default(); input.len() + 1];
+        eytzinger(&input[..], &mut result[..], 0, 1);
+        let original = (0..input.len()).into_iter().collect::<Vec<_>>();
+        let mut order = vec![input.len(); input.len() + 1];
+        eytzinger(&original[..], &mut order[..], 0, 1);
+        Self(result, order)
+    }
+}
+
+impl<T: Copy + Ord> Eytzinger<T> {
+    pub fn get(&self, idx: usize) -> Option<&T> {
+        self.0.get(idx)
+    }
+
+    #[inline]
+    pub fn binary_search(&self, target: T) -> Result<Index, Index> {
+        let mut idx = 1;
+
+        while idx < self.0.len() {
+            #[cfg(target_arch = "x86_64")]
+            unsafe {
+                use std::arch::x86_64::*;
+                let prefetch = self.0.as_ptr().wrapping_offset(2 * idx as isize);
+                _mm_prefetch::<_MM_HINT_T0>(std::ptr::addr_of!(prefetch) as *const i8);
+            }
+            let current = self.0[idx];
+            idx = 2 * idx + usize::from(current < target);
+        }
+
+        idx >>= idx.trailing_ones() + 1;
+
+        let r = Index {
+            index: idx,
+            original: self.1[idx],
+        };
+
+        if self.0[idx] == target {
+            Ok(r)
+        } else {
+            Err(r)
+        }
+    }
+}
+
+#[test]
+fn ok_binary_search() {
+    let v = Eytzinger::from(vec![1, 5, 10].as_slice());
+    assert_eq!(v.binary_search(1).unwrap().original, 0);
+    assert_eq!(v.binary_search(5).unwrap().original, 1);
+    assert_eq!(v.binary_search(10).unwrap().original, 2);
+
+    assert_eq!(v.binary_search(0).unwrap_err().original, 0);
+    assert_eq!(v.binary_search(2).unwrap_err().original, 1);
+
+    assert_eq!(v.binary_search(4).unwrap_err().original, 1);
+    assert_eq!(v.binary_search(6).unwrap_err().original, 2);
+
+    assert_eq!(v.binary_search(9).unwrap_err().original, 2);
+    assert_eq!(v.binary_search(11).unwrap_err().original, 3);
+}

sway-types/src/lib.rs

@@ -24,6 +24,8 @@ pub mod style;
 
 pub mod ast;
 
+mod eytzinger;
+
 pub type Id = [u8; Bytes32::LEN];
 pub type Contract = [u8; ContractId::LEN];
 

sway-types/src/span.rs

@@ -1,3 +1,4 @@
+use crate::eytzinger::{Eytzinger, Index};
 use crate::SourceId;
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
@@ -12,7 +13,7 @@ lazy_static! {
     static ref DUMMY_SPAN: Span = Span::new(
         Source {
             text: Arc::from(""),
-            line_starts: Arc::new(vec![])
+            line_starts: Arc::new(<_>::default())
         },
         0,
         0,
@@ -28,7 +29,7 @@ lazy_static! {
 pub struct Source {
     pub text: Arc<str>,
     #[serde(skip)]
-    pub line_starts: Arc<Vec<usize>>,
+    pub line_starts: Arc<Eytzinger<usize>>,
 }
 
 impl serde::Serialize for Source {
@@ -49,15 +50,15 @@ impl<'de> serde::Deserialize<'de> for Source {
 }
 
 impl Source {
-    fn calc_line_starts(text: &str) -> Arc<Vec<usize>> {
+    fn calc_line_starts(text: &str) -> Arc<Eytzinger<usize>> {
         let mut lines_starts = Vec::with_capacity(text.len() / 80);
         lines_starts.push(0);
         for (idx, c) in text.char_indices() {
             if c == '\n' {
                 lines_starts.push(idx + c.len_utf8())
             }
         }
-        Arc::new(lines_starts)
+        Arc::new(lines_starts.as_slice().into())
     }
 
     pub fn new(text: &str) -> Self {
@@ -72,10 +73,10 @@ impl Source {
         if position > self.text.len() || self.text.is_empty() {
             LineCol { line: 0, col: 0 }
         } else {
-            let (line, line_start) = match self.line_starts.binary_search(&position) {
-                Ok(line) => (line, self.line_starts.get(line)),
-                Err(0) => (0, None),
-                Err(line) => (line - 1, self.line_starts.get(line - 1)),
+            let (line, line_start) = match self.line_starts.binary_search(position) {
+                Ok(Index { original: line, .. }) => (line, self.line_starts.get(line)),
+                Err(Index { original: 0, .. }) => (0, None),
+                Err(Index { original: line, .. }) => (line - 1, self.line_starts.get(line - 1)),
             };
             line_start.map_or(LineCol { line: 0, col: 0 }, |line_start| LineCol {
                 line,