Initial Dever 0.0.1

test/rust/performance/storage.rs

@@ -0,0 +1,323 @@
+use indexmap::IndexMap;
+
+struct Lookup {
+    generated: Map<i64, i64>,
+    reference: IndexMap<i64, i64>,
+    keys: Vec<i64>,
+}
+
+struct TextLookup {
+    generated: Map<String, i64>,
+    reference: IndexMap<String, i64>,
+    keys: Vec<String>,
+}
+
+fn text_lookup_generated(values: &[TextLookup]) -> Result<i64, Fault> {
+    values.first().map_or(Ok(0), |value| {
+        GENERATED_TEXT_LOOKUP(&value.generated, &value.keys)
+    })
+}
+
+fn text_lookup_reference(values: &[TextLookup]) -> Result<i64, Fault> {
+    let Some(value) = values.first() else {
+        return Ok(0);
+    };
+    let mut total = 0i64;
+    for key in &value.keys {
+        total = total
+            .checked_add(value.reference.get(key.as_str()).copied().unwrap_or(0))
+            .ok_or_else(overflow)?;
+    }
+    Ok(total)
+}
+
+fn text_lookup_same_table(values: &[TextLookup]) -> Result<i64, Fault> {
+    let Some(value) = values.first() else {
+        return Ok(0);
+    };
+    let mut total = 0i64;
+    for key in &value.keys {
+        total = total
+            .checked_add(value.generated.get(key.as_str()).copied().unwrap_or(0))
+            .ok_or_else(overflow)?;
+    }
+    Ok(total)
+}
+
+fn text_lookup_comparisons() {
+    let reference_first = match std::env::var("DEVER_BENCH_MAP_ORDER")
+        .as_deref()
+        .unwrap_or("dever-first")
+    {
+        "dever-first" => false,
+        "rust-first" => true,
+        order => panic!("unknown table construction order: {order}"),
+    };
+    for count in [512, 1024, 2048, 4096] {
+        let keys: Vec<_> = (0..count)
+            .map(|index| format!("lookup-key-{index}"))
+            .collect();
+        let (mut generated, mut reference) = if reference_first {
+            let reference = IndexMap::with_capacity(count);
+            (Map::with_capacity(count), reference)
+        } else {
+            (Map::with_capacity(count), IndexMap::with_capacity(count))
+        };
+        for key in &keys {
+            if reference_first {
+                reference.insert(key.clone(), 120);
+                generated.insert(key.clone(), 120);
+            } else {
+                generated.insert(key.clone(), 120);
+                reference.insert(key.clone(), 120);
+            }
+        }
+        assert_eq!(
+            GENERATED_TEXT_LOOKUP(&generated, &["missing".to_owned()]).unwrap(),
+            0
+        );
+        let values = [TextLookup {
+            generated,
+            reference,
+            keys,
+        }];
+        compare(
+            &format!("map_text_lookup_{count}"),
+            &values,
+            200,
+            text_lookup_generated,
+            text_lookup_reference,
+            |value| *value as u64,
+        );
+        // 同表只隔离生成层；独立 IndexMap 参照不能被这个控制组替代。
+        compare_named(
+            &format!("map_text_lookup_{count}_same_table"),
+            &values,
+            200,
+            text_lookup_generated,
+            text_lookup_same_table,
+            |value| *value as u64,
+            "rust_runtime",
+        );
+    }
+}
+
+fn overflow() -> Fault {
+    &FaultInfo {
+        message: "integer overflow",
+        source: "reference.dever",
+        line: 1,
+        column: 1,
+    }
+}
+
+fn lookup_generated(values: &[Lookup]) -> Result<i64, Fault> {
+    match values.first() {
+        Some(value) => GENERATED_LOOKUP(&value.generated, &value.keys),
+        None => Ok(0),
+    }
+}
+
+fn lookup_reference(values: &[Lookup]) -> Result<i64, Fault> {
+    let Some(value) = values.first() else {
+        return Ok(0);
+    };
+    let mut answer = 0i64;
+    for key in &value.keys {
+        answer = answer
+            .checked_add(value.reference.get(key).copied().unwrap_or(0))
+            .ok_or_else(overflow)?;
+    }
+    Ok(answer)
+}
+
+fn lookup_same_table(values: &[Lookup]) -> Result<i64, Fault> {
+    let Some(value) = values.first() else {
+        return Ok(0);
+    };
+    let mut answer = 0i64;
+    for key in &value.keys {
+        answer = answer
+            .checked_add(value.generated.get(key).copied().unwrap_or(0))
+            .ok_or_else(overflow)?;
+    }
+    Ok(answer)
+}
+
+fn scan_generated(values: &[Lookup]) -> Result<i64, Fault> {
+    match values.first() {
+        Some(value) => GENERATED_SCAN(&value.generated),
+        None => Ok(0),
+    }
+}
+
+fn scan_reference(values: &[Lookup]) -> Result<i64, Fault> {
+    let Some(value) = values.first() else {
+        return Ok(0);
+    };
+    value.reference.values().try_fold(0i64, |total, item| {
+        total.checked_add(*item).ok_or_else(overflow)
+    })
+}
+
+fn map_generated(values: &[i64]) -> Result<Vec<(i64, i64)>, Fault> {
+    GENERATED_ENTRIES(values)
+}
+
+fn map_reference(values: &[i64]) -> Result<Vec<(i64, i64)>, Fault> {
+    let mut result = IndexMap::new();
+    for value in values {
+        result.insert(*value, *value);
+    }
+    Ok(result.into_iter().collect())
+}
+
+fn list_reference(values: &[i64]) -> Result<Vec<i64>, Fault> {
+    let mut result = Vec::new();
+    for value in values {
+        result.push(*value);
+    }
+    Ok(result)
+}
+
+fn buffer_reference(values: &dever_runtime::Bytes) -> Result<BUFFER_STATE, Fault> {
+    let mut items = Vec::new();
+    let mut count = 0i64;
+    for value in values.iter() {
+        items.push(i64::from(*value));
+        count = count.checked_add(1).ok_or_else(overflow)?;
+    }
+    Ok(BUFFER_STATE {
+        field0: items,
+        field1: count,
+    })
+}
+
+fn buffer_inspect_reference(values: &dever_runtime::Bytes) -> Result<BUFFER_STATE, Fault> {
+    let mut items = Vec::new();
+    let mut count = 0i64;
+    for value in values.iter() {
+        count = (items.len() as i64).checked_add(1).ok_or_else(overflow)?;
+        items.push(i64::from(*value));
+    }
+    Ok(BUFFER_STATE {
+        field0: items,
+        field1: count,
+    })
+}
+
+fn read_records_reference(values: &[SCALAR_ROW]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for row in values {
+        let projected = row
+            .field0
+            .checked_add(row.field1)
+            .ok_or_else(overflow)?
+            .checked_add(row.field2)
+            .ok_or_else(overflow)?;
+        total = total.checked_add(projected).ok_or_else(overflow)?;
+    }
+    Ok(total)
+}
+
+fn main() {
+    let values: Vec<i64> = (0..1024).collect();
+    let lookup = Lookup {
+        generated: GENERATED_BUILD_MAP(&values).unwrap(),
+        reference: values.iter().map(|value| (*value, *value)).collect(),
+        keys: (0..1024).map(|index| (index * 17) % 1152).collect(),
+    };
+    let lookups = [lookup];
+    let overflow_case = [Lookup {
+        generated: GENERATED_BUILD_MAP(&[i64::MAX, 1]).unwrap(),
+        reference: [(i64::MAX, i64::MAX), (1, 1)].into_iter().collect(),
+        keys: vec![i64::MAX, 1],
+    }];
+    assert!(scan_generated(&overflow_case).is_err());
+    assert!(scan_reference(&overflow_case).is_err());
+    assert!(lookup_generated(&overflow_case).is_err());
+    assert!(lookup_reference(&overflow_case).is_err());
+    assert_eq!(
+        map_generated(&[3, 1, 3, 2]).unwrap(),
+        map_reference(&[3, 1, 3, 2]).unwrap()
+    );
+    println!("case,sample,implementation,elapsed_ns,checksum");
+    text_lookup_comparisons();
+    for count in [512, 1024, 2048, 4096] {
+        let bytes = dever_runtime::Bytes::from(vec![120u8; count]);
+        let rows: Vec<_> = bytes
+            .iter()
+            .map(|value| SCALAR_ROW {
+                field0: i64::from(*value),
+                field1: 0,
+                field2: 0,
+            })
+            .collect();
+        compare(
+            &format!("list_record_read_{count}"),
+            &rows,
+            1000,
+            GENERATED_RECORD_READ,
+            read_records_reference,
+            |value| *value as u64,
+        );
+        compare_bytes(
+            &format!("record_update_{count}"),
+            &bytes,
+            1000,
+            GENERATED_BUFFER_BUILD,
+            buffer_reference,
+            |value| value.field1 as u64,
+        );
+        compare_bytes(
+            &format!("record_inspect_{count}"),
+            &bytes,
+            1000,
+            GENERATED_BUFFER_INSPECT,
+            buffer_inspect_reference,
+            |value| value.field1 as u64,
+        );
+    }
+    compare(
+        "map_lookup",
+        &lookups,
+        2000,
+        lookup_generated,
+        lookup_reference,
+        |value| *value as u64,
+    );
+    // 同一张表隔离随机哈希布局；独立 IndexMap 参照仍保留。
+    compare_named(
+        "map_lookup_same_table",
+        &lookups,
+        2000,
+        lookup_generated,
+        lookup_same_table,
+        |value| *value as u64,
+        "rust_runtime",
+    );
+    compare(
+        "map_scan",
+        &lookups,
+        20000,
+        scan_generated,
+        scan_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "map_build",
+        &values[..512],
+        400,
+        map_generated,
+        map_reference,
+        |value| value.len() as u64,
+    );
+    compare(
+        "list_build",
+        &values,
+        1000,
+        GENERATED_BUILD_LIST,
+        list_reference,
+        |value| value.len() as u64,
+    );
+}