Initial Dever 0.0.1

test/rust/performance/package/scalar.rs

@@ -0,0 +1,233 @@
+// 隔离同一受检翻倍在内联表达式、Rust 函数边界和 Dever 生成路径上的差异。
+// 共享故障元数据以排除错误对象大小和来源内容，原 packages 参照保持不变。
+
+fn shared_fault() -> Fault {
+    GENERATED_DISPATCH(i64::MAX).unwrap_err()
+}
+
+fn dispatch_generated(values: &[i64]) -> Result<i64, Fault> {
+    GENERATED_DISPATCH(values.first().copied().unwrap_or(0))
+}
+
+fn adjust_generated(values: &[i64]) -> Result<i64, Fault> {
+    GENERATED_ADJUST(values.first().copied().unwrap_or(0))
+}
+
+fn inline_reference(values: &[i64]) -> Result<i64, Fault> {
+    values
+        .first()
+        .copied()
+        .unwrap_or(0)
+        .checked_mul(2)
+        .ok_or_else(shared_fault)
+}
+
+fn propagated_reference(values: &[i64]) -> Result<i64, Fault> {
+    let answer = values
+        .first()
+        .copied()
+        .unwrap_or(0)
+        .checked_mul(2)
+        .ok_or_else(shared_fault)?;
+    Ok(answer)
+}
+
+fn helper(value: i64) -> Result<i64, Fault> {
+    value.checked_mul(2).ok_or_else(shared_fault)
+}
+
+fn helper_reference(values: &[i64]) -> Result<i64, Fault> {
+    helper(values.first().copied().unwrap_or(0))
+}
+
+#[inline(always)]
+fn early_helper(value: i64) -> Result<i64, Fault> {
+    value.checked_mul(2).ok_or_else(shared_fault)
+}
+
+fn early_helper_reference(values: &[i64]) -> Result<i64, Fault> {
+    early_helper(values.first().copied().unwrap_or(0))
+}
+
+fn independent_helper(value: i64) -> Result<i64, Fault> {
+    value.checked_mul(2).ok_or(&FaultInfo {
+        message: "integer arithmetic fault",
+        source: "reference.dever",
+        line: 1,
+        column: 1,
+    })
+}
+
+fn independent_helper_reference(values: &[i64]) -> Result<i64, Fault> {
+    independent_helper(values.first().copied().unwrap_or(0))
+}
+
+fn propagated_helper(value: i64) -> Result<i64, Fault> {
+    let answer = value.checked_mul(2).ok_or_else(shared_fault)?;
+    Ok(answer)
+}
+
+fn propagated_helper_reference(values: &[i64]) -> Result<i64, Fault> {
+    propagated_helper(values.first().copied().unwrap_or(0))
+}
+
+fn batch_generated(values: &[i64]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        total = total
+            .checked_add(GENERATED_DISPATCH(*value)?)
+            .ok_or_else(shared_fault)?;
+    }
+    Ok(total)
+}
+
+fn batch_reference(values: &[i64]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        let doubled = value.checked_mul(2).ok_or_else(shared_fault)?;
+        total = total.checked_add(doubled).ok_or_else(shared_fault)?;
+    }
+    Ok(total)
+}
+
+fn main() {
+    let operations = [
+        dispatch_generated as fn(&[i64]) -> Result<i64, Fault>,
+        adjust_generated,
+        inline_reference,
+        propagated_reference,
+        helper_reference,
+        early_helper_reference,
+        propagated_helper_reference,
+    ];
+    for value in [
+        i64::MIN,
+        i64::MIN / 2 - 1,
+        i64::MIN / 2,
+        -1,
+        0,
+        1,
+        21,
+        i64::MAX / 2,
+        i64::MAX / 2 + 1,
+        i64::MAX,
+    ] {
+        for operation in operations {
+            assert_eq!(
+                operation(&[value]).map_err(|fault| fault.to_string()),
+                inline_reference(&[value]).map_err(|fault| fault.to_string())
+            );
+        }
+        assert_eq!(
+            independent_helper_reference(&[value]).map_err(|_| ()),
+            inline_reference(&[value]).map_err(|_| ())
+        );
+    }
+    for (name, operation) in [
+        (
+            "dispatch",
+            dispatch_generated as fn(&[i64]) -> Result<i64, Fault>,
+        ),
+        ("adjust", adjust_generated),
+        ("propagated", propagated_reference),
+        ("helper", helper_reference),
+        ("early_helper", early_helper_reference),
+        ("independent_helper", independent_helper_reference),
+        ("propagated_helper", propagated_helper_reference),
+    ] {
+        eprintln!(
+            "{name}_equals_dispatch={}",
+            std::ptr::fn_addr_eq(
+                operation,
+                dispatch_generated as fn(&[i64]) -> Result<i64, Fault>
+            )
+        );
+    }
+    let values = (0..256).map(|index| index * 17 - 2000).collect::<Vec<_>>();
+    for input in [
+        vec![],
+        vec![i64::MAX],
+        vec![i64::MIN],
+        vec![i64::MAX / 2, 1],
+        values.clone(),
+    ] {
+        assert_eq!(
+            batch_generated(&input).map_err(|fault| fault.to_string()),
+            batch_reference(&input).map_err(|fault| fault.to_string())
+        );
+    }
+    println!("case,sample,implementation,elapsed_ns,checksum");
+    compare(
+        "scalar_matched_hot_path",
+        &[21],
+        3000000,
+        adjust_generated,
+        independent_helper_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "scalar_inline",
+        &[21],
+        3000000,
+        dispatch_generated,
+        inline_reference,
+        |value| *value as u64,
+    );
+    compare_named(
+        "scalar_direct",
+        &[21],
+        3000000,
+        dispatch_generated,
+        adjust_generated,
+        |value| *value as u64,
+        "direct",
+    );
+    compare(
+        "scalar_propagated",
+        &[21],
+        3000000,
+        dispatch_generated,
+        propagated_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "scalar_helper",
+        &[21],
+        3000000,
+        dispatch_generated,
+        helper_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "scalar_early_helper",
+        &[21],
+        3000000,
+        dispatch_generated,
+        early_helper_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "scalar_independent_helper",
+        &[21],
+        3000000,
+        dispatch_generated,
+        independent_helper_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "scalar_propagated_helper",
+        &[21],
+        3000000,
+        dispatch_generated,
+        propagated_helper_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "scalar_batch",
+        &values,
+        30000,
+        batch_generated,
+        batch_reference,
+        |value| *value as u64,
+    );
+}