[WIP] optimize validation decimal 128 and benchmark validation decimal128

arrow/benches/decimal_validate.rs

@@ -18,28 +18,91 @@
 #[macro_use]
 extern crate criterion;
 
-use arrow::array::{Array, Decimal128Array, Decimal256Array, Decimal256Builder};
+use arrow::array::{
+    Array, Decimal128Array, Decimal128Builder, Decimal256Array, Decimal256Builder,
+};
+use arrow::datatypes::{
+    validate_decimal_precision, validate_decimal_precision_with_bytes,
+};
 use criterion::Criterion;
+use rand::Rng;
 
 extern crate arrow;
 
-use arrow::util::decimal::Decimal256;
+use arrow::util::decimal::{Decimal128, Decimal256};
 
-fn validate_decimal128_array(array: Decimal128Array) {
-    array.with_precision_and_scale(35, 0).unwrap();
+// fn validate_decimal128_array(array: Decimal128Array) {
+//     array.with_precision_and_scale(35, 0).unwrap();
+// }
+
+fn validate_decimal128_array_fast(array: &Decimal128Array) {
+    array.validate_decimal_with_bytes(35).unwrap();
+}
+
+fn validate_decimal128_array_slow(array: &Decimal128Array) {
+    array.validate_decimal_precision(35).unwrap();
 }
 
 fn validate_decimal256_array(array: Decimal256Array) {
     array.with_precision_and_scale(35, 0).unwrap();
 }
 
+// remove from the commit
+// https://github.com/apache/arrow-rs/pull/2360/commits/364929e918bdb0e96bc931424de615cbc18af8cb
+fn validate_decimal128_using_bytes(array: &[[u8; 16]], precision: usize) {
+    for value in array {
+        validate_decimal_precision_with_bytes(value, precision).unwrap();
+    }
+}
+
+fn validate_decimal128_using_i128(array: &[[u8; 16]], precision: usize) {
+    // convert the the element to decimal128
+    for v in array {
+        let decimal = Decimal128::new(precision, 0, v);
+        validate_decimal_precision(decimal.as_i128(), precision).unwrap();
+    }
+}
+
+fn validate_decimal128_cmp_i128_with_bytes_benchmark(c: &mut Criterion) {
+    // create the [u8;16] array
+    let mut array: Vec<[u8; 16]> = vec![];
+    let mut rng = rand::thread_rng();
+    for i in 0..200000 {
+        // array.push((i as i128).to_le_bytes());
+        array.push((rng.gen_range::<i128, _>(0..999999999999)).to_le_bytes());
+    }
+
+    c.bench_function("validate_decimal128_bytes 20000", |b| {
+        b.iter(|| validate_decimal128_using_bytes(&array, 35))
+    });
+
+    c.bench_function("validate_decimal128_i128 20000", |b| {
+        b.iter(|| validate_decimal128_using_i128(&array, 35))
+    });
+}
+
 fn validate_decimal128_benchmark(c: &mut Criterion) {
-    let decimal_array = Decimal128Array::from_iter_values(vec![12324; 20000]);
-    let data = decimal_array.into_data();
-    c.bench_function("validate_decimal128_array 20000", |b| {
+    let mut rng = rand::thread_rng();
+    let size: i128 = 200000;
+    let mut decimal_builder = Decimal128Builder::new(size as usize, 38, 0);
+    for i in 0..size {
+        decimal_builder
+            .append_value(rng.gen_range::<i128, _>(0..999999999999))
+            .unwrap();
+    }
+    let decimal_array = decimal_builder.finish();
+    // let decimal_array = Decimal128Array::from_iter_values(vec![12324; size as usize]);
+    c.bench_function("validate_decimal128_array_fast 20000", |b| {
+        b.iter(|| {
+            // let array = Decimal128Array::from(data.clone());
+            validate_decimal128_array_fast(&decimal_array);
+        })
+    });
+
+    c.bench_function("validate_decimal256_array_slow 20000", |b| {
         b.iter(|| {
-            let array = Decimal128Array::from(data.clone());
-            validate_decimal128_array(array);
+            // let array = Decimal128Array::from(data.clone());
+            validate_decimal128_array_slow(&decimal_array);
         })
     });
 }
@@ -66,6 +129,7 @@ fn validate_decimal256_benchmark(c: &mut Criterion) {
 criterion_group!(
     benches,
     validate_decimal128_benchmark,
-    validate_decimal256_benchmark,
+    // validate_decimal256_benchmark,
+    validate_decimal128_cmp_i128_with_bytes_benchmark,
 );
 criterion_main!(benches);