Merge pull request #3166 from ProvableHQ/perf/bigint_cmp

[Perf] Optimize BigInteger comparisons

Author: vicsn

Cargo.lock

@@ -23,6 +23,11 @@ include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
 license = "Apache-2.0"
 edition = "2024"
 
+[[bench]]
+name = "bigint"
+path = "benches/bigint.rs"
+harness = false
+
 [dependencies.snarkvm-utilities-derives]
 workspace = true
 optional = true
@@ -78,6 +83,9 @@ default-features = false
 workspace = true
 features = [ "derive" ]
 
+[dev-dependencies.criterion]
+workspace = true
+
 [dev-dependencies.tracing-test]
 workspace = true
 

utilities/Cargo.toml

@@ -0,0 +1,67 @@
+// Copyright (c) 2019-2026 Provable Inc.
+// This file is part of the snarkVM library.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Silences the false positives caused by black_box.
+#![allow(clippy::unit_arg)]
+
+use snarkvm_utilities::{BigInteger256, BigInteger384, TestRng};
+
+use criterion::*;
+use rand::Rng;
+use std::hint::black_box;
+
+fn bigint_256(c: &mut Criterion) {
+    let rng = &mut TestRng::default();
+
+    let n = 900_000;
+    let values: Vec<BigInteger256> = (0..n).map(|_| rng.r#gen()).collect();
+
+    c.bench_function("bigint_256_cmp", |b| {
+        b.iter_batched(
+            || values.clone(),
+            |mut data_to_sort| {
+                data_to_sort.sort_unstable();
+                black_box(data_to_sort)
+            },
+            criterion::BatchSize::LargeInput,
+        )
+    });
+}
+
+fn bigint_384(c: &mut Criterion) {
+    let rng = &mut TestRng::default();
+
+    let n = 500_000;
+    let values: Vec<BigInteger384> = (0..n).map(|_| rng.r#gen()).collect();
+
+    c.bench_function("bigint_384_cmp", |b| {
+        b.iter_batched(
+            || values.clone(),
+            |mut data_to_sort| {
+                data_to_sort.sort_unstable();
+                black_box(data_to_sort)
+            },
+            criterion::BatchSize::LargeInput,
+        )
+    });
+}
+
+criterion_group! {
+    name = bigint;
+    config = Criterion::default();
+    targets = bigint_256, bigint_384
+}
+
+criterion_main!(bigint);

utilities/benches/bigint.rs

@@ -13,7 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::io::{Read, Result as IoResult, Write};
+use std::{
+    cmp,
+    io::{Read, Result as IoResult, Write},
+};
 
 use crate::{
     FromBits,
@@ -311,16 +314,15 @@ impl Display for BigInteger256 {
 
 impl Ord for BigInteger256 {
     #[inline]
-    #[allow(clippy::comparison_chain)]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
         for (a, b) in self.0.iter().rev().zip(other.0.iter().rev()) {
-            if a < b {
-                return std::cmp::Ordering::Less;
-            } else if a > b {
-                return std::cmp::Ordering::Greater;
+            match a.cmp(b) {
+                cmp::Ordering::Less => return cmp::Ordering::Less,
+                cmp::Ordering::Greater => return cmp::Ordering::Greater,
+                _ => continue,
             }
         }
-        std::cmp::Ordering::Equal
+        cmp::Ordering::Equal
     }
 }
 

utilities/src/biginteger/bigint_256.rs

@@ -14,6 +14,7 @@
 // limitations under the License.
 
 use std::{
+    cmp,
     fmt::{Debug, Display},
     io::{Read, Result as IoResult, Write},
 };
@@ -309,16 +310,15 @@ impl Display for BigInteger384 {
 }
 impl Ord for BigInteger384 {
     #[inline]
-    #[allow(clippy::comparison_chain)]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
         for (a, b) in self.0.iter().rev().zip(other.0.iter().rev()) {
-            if a < b {
-                return std::cmp::Ordering::Less;
-            } else if a > b {
-                return std::cmp::Ordering::Greater;
+            match a.cmp(b) {
+                cmp::Ordering::Less => return cmp::Ordering::Less,
+                cmp::Ordering::Greater => return cmp::Ordering::Greater,
+                _ => continue,
             }
         }
-        std::cmp::Ordering::Equal
+        cmp::Ordering::Equal
     }
 }
 impl PartialOrd for BigInteger384 {