Initial Dever 0.0.1

test/rust/performance/package/mod.rs

@@ -0,0 +1,152 @@
+fn fault() -> Fault {
+    &FaultInfo {
+        message: "integer arithmetic fault",
+        source: "reference.dever",
+        line: 1,
+        column: 1,
+    }
+}
+
+fn map_reference(values: &[i64]) -> Result<Vec<i64>, Fault> {
+    let mut output = Vec::with_capacity(values.len());
+    for value in values {
+        output.push(value.checked_add(1).ok_or_else(fault)?);
+    }
+    Ok(output)
+}
+
+fn total_reference(values: &[i64]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        let adjusted = value.checked_add(1).ok_or_else(fault)?;
+        total = total.checked_add(adjusted).ok_or_else(fault)?;
+    }
+    Ok(total)
+}
+
+// 与跨包调用一致，投影失败和累计失败必须能定位到不同来源。
+fn total_reference_distinct_faults(values: &[i64]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        let adjusted = value.checked_add(1).ok_or(&FaultInfo {
+            message: "integer arithmetic fault",
+            source: "reference/value.rs",
+            line: 1,
+            column: 1,
+        })?;
+        total = total.checked_add(adjusted).ok_or(&FaultInfo {
+            message: "integer arithmetic fault",
+            source: "reference/batch.rs",
+            line: 2,
+            column: 1,
+        })?;
+    }
+    Ok(total)
+}
+
+fn dispatch_generated(values: &[i64]) -> Result<i64, Fault> {
+    GENERATED_DISPATCH(values.first().copied().unwrap_or(0))
+}
+
+fn dispatch_reference(values: &[i64]) -> Result<i64, Fault> {
+    values
+        .first()
+        .copied()
+        .unwrap_or(0)
+        .checked_mul(2)
+        .ok_or_else(fault)
+}
+
+fn dispatch_total_reference(values: &[i64]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        let doubled = value.checked_mul(2).ok_or_else(fault)?;
+        total = total.checked_add(doubled).ok_or(&FaultInfo {
+            message: "integer overflow",
+            source: "reference/dispatch.rs",
+            line: 2,
+            column: 1,
+        })?;
+    }
+    Ok(total)
+}
+
+fn main() {
+    let values: Vec<i64> = (0..1024).map(|value| value % 17).collect();
+    for values in [&[i64::MAX][..], &[i64::MAX - 1, 1][..], &[i64::MIN][..]] {
+        assert_eq!(
+            GENERATED_MAP(values).map_err(|_| ()),
+            map_reference(values).map_err(|_| ())
+        );
+        assert_eq!(
+            GENERATED_TOTAL(values).map_err(|_| ()),
+            total_reference(values).map_err(|_| ())
+        );
+        assert_eq!(
+            GENERATED_TOTAL(values).map_err(|fault| fault.message),
+            total_reference_distinct_faults(values).map_err(|fault| fault.message)
+        );
+        assert_eq!(
+            dispatch_generated(values).map_err(|_| ()),
+            dispatch_reference(values).map_err(|_| ())
+        );
+    }
+    let projection = GENERATED_TOTAL(&[i64::MAX]).unwrap_err();
+    let sum = GENERATED_TOTAL(&[i64::MAX - 1, 1]).unwrap_err();
+    assert_ne!(projection.source, sum.source);
+    assert_ne!(
+        total_reference_distinct_faults(&[i64::MAX])
+            .unwrap_err()
+            .source,
+        total_reference_distinct_faults(&[i64::MAX - 1, 1])
+            .unwrap_err()
+            .source
+    );
+    for values in [&[i64::MAX][..], &[i64::MAX / 2, 1][..], &[i64::MIN][..]] {
+        assert_eq!(
+            GENERATED_DISPATCH_TOTAL(values).map_err(|fault| fault.message),
+            dispatch_total_reference(values).map_err(|fault| fault.message)
+        );
+    }
+    println!("case,sample,implementation,elapsed_ns,checksum");
+    compare(
+        "package_map",
+        &values,
+        20000,
+        GENERATED_MAP,
+        map_reference,
+        |value| value.iter().map(|value| *value as u64).sum(),
+    );
+    compare(
+        "package_total",
+        &values,
+        20000,
+        GENERATED_TOTAL,
+        total_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "package_total_distinct_faults",
+        &values,
+        20000,
+        GENERATED_TOTAL,
+        total_reference_distinct_faults,
+        |value| *value as u64,
+    );
+    compare(
+        "package_dispatch",
+        &[21],
+        3000000,
+        dispatch_generated,
+        dispatch_reference,
+        |value| *value as u64,
+    );
+    compare(
+        "package_dispatch_batch",
+        &values,
+        20000,
+        GENERATED_DISPATCH_TOTAL,
+        dispatch_total_reference,
+        |value| *value as u64,
+    );
+}