Add benchmark for cast from/to decimals by klion26 · Pull Request #9729 · apache/arrow-rs

klion26 · 2026-04-15T12:45:57Z

Which issue does this PR close?

Closes Add benchmark for cast from/to decimals #9728.

What changes are included in this PR?

Add benchmarks for cast from/to decimals

Are these changes tested?

This is benchmarks, no need to add tests

Are there any user-facing changes?

No

scovich

I don't know if the small input sizes are too small to give stable/meaningful results? I would imagine most "real life" arrow arrays will have O(100) or O(1000) entries, not O(10)?

But I'll defer to @alamb who has a lot more experience with these kinds of benchmarks.

alamb · 2026-04-16T10:26:25Z

I don't know if the small input sizes are too small to give stable/meaningful results? I would imagine most "real life" arrow arrays will have O(100) or O(1000) entries, not O(10)?

Yeah I think most benchmarks we have use something like 8K rows as that mirrors what happens in most real world systems. Otherwise the per-array overhead dominates the actual work

Also I think we have found that if the iteration time per benchmark is less than a few hundred microseconds, the results are very suceptabel to system noise.

klion26 · 2026-04-16T12:42:18Z

Thanks for the review and information. I've updated the code and made the time per-iter hundreds(or bigger) microseconds on my local laptop

string2decimal128(38, 3)         time:   [2.0216 ms 2.0831 ms 2.1535 ms]
....
decimal128(38, 3)_to_int64    time:   [211.44 µs 212.62 µs 213.87 µs]

scovich

High level question: Do we want two classes of benches? One that exercises error/invalid paths heavily and one that does not? (right now, they all bias heavily toward error paths)

scovich · 2026-04-16T15:15:50Z

+                let r = arrow_cast::cast(&array, &bench.1);
+                std::hint::black_box(r)


Looking at https://doc.rust-lang.org/beta/std/hint/fn.black_box.html, I think this should be

Suggested change

let r = arrow_cast::cast(&array, &bench.1);

std::hint::black_box(r)

black_box(arrow_cast::cast(black_box(&array), black_box(&bench.1)));

(prevents compiler from making any assumptions about the input or the output of cast)

Will change it.

scovich · 2026-04-16T15:17:12Z

+        1 => Some("".to_string()),
+        2 => Some(" ".to_string()),
+        3 => Some("-1.-23499999".to_string()),
+        4 => Some("--1.23456789".to_string()),
+        5 => Some("1.-23456789".to_string()),
+        6 => Some("000.123".to_string()),
+        7 => Some("+123".to_string()),
+        8 => Some("+123.12345000".to_string()),
+        9 => Some("0".to_string()),
+        10 => Some("000.000".to_string()),
+        11 => Some("0000000000000000012345.000".to_string()),


Fully half the values in the array are invalid, so this bench will mostly measure the cost of the error paths. Is that intentional? Do we have a happy path bench to complement it?

Will improve this.

scovich · 2026-04-16T15:29:46Z

+        1 => Some(f32::MIN),
+        2 => Some(f32::MAX),
+        _ => match x % 2 {
+            0 => Some((x as f32) * rng.random::<f32>()),
+            _ => Some(-(x as f32) * rng.random::<f32>()),
+        },


The random values are uniformly distributed over 0..1 (floating point) so this exercises mostly values in -5..5 with exponentially decreasing probability of large negative exponents (e.g. 1e-6). Do we want any coverage of large positive exponents (e.g. 1e6) as well?

Will Improve this data coverage.

scovich · 2026-04-16T15:47:46Z

+        1 => Some(i32::MIN),
+        2 => Some(i32::MAX),


These are out of gamut values, so 20% of the values will exercise error path

Will improve this.

alamb

Thanks @klion26

Can we please move this code into the existing cast_kernels before we merge it (we can do it as a follow on PR if needed but I think it would be better to do before)

I also ran it locally and it seems to be capturing the time spent to convert to decimial 👍

The only thing I ssee is that now maybe each iteration is perhaps too long (criterion wants it to be 5ms or less). Maybe we could reduce the batch size to 8K

However, I think it is fine

Benchmarking string2decimal32(9, 2): Warming up for 3.0000 s
Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 8.5s, enable flat sampling, or reduce sample count to 50.
string2decimal32(9, 2)  time:   [1.6175 ms 1.6220 ms 1.6264 ms]
Found 3 outliers among 100 measurements (3.00%)
  3 (3.00%) high mild

Benchmarking string2decimal64(18, 2): Warming up for 3.0000 s
Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 8.1s, enable flat sampling, or reduce sample count to 50.
Benchmarking string2decimal64(18, 2): Collecting 100 samples in estimated 8.0689 s (5050 iterations)

alamb · 2026-04-16T15:43:35Z

@@ -0,0 +1,346 @@
+// Licensed to the Apache Software Foundation (ASF) under one


Sorry I missed this in a previous review, but I think the other benchmarks for cast are in the cast_kernels.rs benchmark: https://github.com/apache/arrow-rs/blob/main/arrow/benches/cast_kernels.rs

Can we please add these benchmarks to the existing benchmark (e.g.

arrow-rs/arrow/benches/cast_kernels.rs

Lines 283 to 324 in c5fed03

c.bench_function("cast decimal32 to decimal32 512", |b| {

b.iter(|| cast_array(&decimal32_array, DataType::Decimal32(9, 4)))

});

c.bench_function("cast decimal32 to decimal32 512 lower precision", |b| {

b.iter(|| cast_array(&decimal32_array, DataType::Decimal32(6, 5)))

});

c.bench_function("cast decimal32 to decimal64 512", |b| {

b.iter(|| cast_array(&decimal32_array, DataType::Decimal64(11, 5)))

});

c.bench_function("cast decimal64 to decimal32 512", |b| {

b.iter(|| cast_array(&decimal64_array, DataType::Decimal32(9, 2)))

});

c.bench_function("cast decimal64 to decimal64 512", |b| {

b.iter(|| cast_array(&decimal64_array, DataType::Decimal64(12, 4)))

});

c.bench_function("cast decimal128 to decimal128 512", |b| {

b.iter(|| cast_array(&decimal128_array, DataType::Decimal128(30, 5)))

});

c.bench_function("cast decimal128 to decimal128 512 lower precision", |b| {

b.iter(|| cast_array(&decimal128_array, DataType::Decimal128(6, 5)))

});

c.bench_function("cast decimal128 to decimal256 512", |b| {

b.iter(|| cast_array(&decimal128_array, DataType::Decimal256(50, 5)))

});

c.bench_function("cast decimal256 to decimal128 512", |b| {

b.iter(|| cast_array(&decimal256_array, DataType::Decimal128(38, 2)))

});

c.bench_function("cast decimal256 to decimal256 512", |b| {

b.iter(|| cast_array(&decimal256_array, DataType::Decimal256(50, 5)))

});

c.bench_function("cast decimal128 to decimal128 512 with same scale", |b| {

b.iter(|| cast_array(&decimal128_array, DataType::Decimal128(30, 3)))

});

c.bench_function(

"cast decimal128 to decimal128 512 with lower scale (infallible)",

|b| b.iter(|| cast_array(&decimal128_array, DataType::Decimal128(7, -1))),

);

c.bench_function("cast decimal256 to decimal256 512 with same scale", |b| {

)?

Will move to the cast_kernel.rs

klion26

@scovich @alamb thanks for the review. There are some unexpected matters to handle today, so I will deal with this as soon as possible.

Do we want two classes of benches? One that exercises error/invalid paths heavily and one that does not?

Will improve this, separate the benchmarks into two

The only thing I ssee is that now maybe each iteration is perhaps too long (criterion wants it to be 5ms or less). Maybe we could reduce the batch size to 8K

Will reduce the batch size so that the time is hundreds microsecond

klion26 · 2026-04-17T07:59:51Z

@@ -0,0 +1,346 @@
+// Licensed to the Apache Software Foundation (ASF) under one


Will move to the cast_kernel.rs

klion26 · 2026-04-17T08:02:42Z

+        1 => Some("".to_string()),
+        2 => Some(" ".to_string()),
+        3 => Some("-1.-23499999".to_string()),
+        4 => Some("--1.23456789".to_string()),
+        5 => Some("1.-23456789".to_string()),
+        6 => Some("000.123".to_string()),
+        7 => Some("+123".to_string()),
+        8 => Some("+123.12345000".to_string()),
+        9 => Some("0".to_string()),
+        10 => Some("000.000".to_string()),
+        11 => Some("0000000000000000012345.000".to_string()),


Will improve this.

klion26 · 2026-04-17T08:08:40Z

+        1 => Some(i32::MIN),
+        2 => Some(i32::MAX),


Will improve this.

klion26 · 2026-04-17T08:45:38Z

+        1 => Some(f32::MIN),
+        2 => Some(f32::MAX),
+        _ => match x % 2 {
+            0 => Some((x as f32) * rng.random::<f32>()),
+            _ => Some(-(x as f32) * rng.random::<f32>()),
+        },


Will Improve this data coverage.

klion26 · 2026-04-17T09:09:27Z

+                let r = arrow_cast::cast(&array, &bench.1);
+                std::hint::black_box(r)


Will change it.

add decimal benchmark

844729d

github-actions bot added the arrow Changes to the arrow crate label Apr 15, 2026

klion26 mentioned this pull request Apr 15, 2026

[Variant] Align cast logic for from/to_decimal for variant #9689

Open

scovich reviewed Apr 15, 2026

View reviewed changes

address comment

b61ae4d

klion26 requested a review from scovich April 16, 2026 12:42

scovich reviewed Apr 16, 2026

View reviewed changes

alamb approved these changes Apr 16, 2026

View reviewed changes

klion26 commented Apr 17, 2026

View reviewed changes

		let r = arrow_cast::cast(&array, &bench.1);
		std::hint::black_box(r)

	let r = arrow_cast::cast(&array, &bench.1);
	std::hint::black_box(r)
	black_box(arrow_cast::cast(black_box(&array), black_box(&bench.1)));

		@@ -0,0 +1,346 @@
		// Licensed to the Apache Software Foundation (ASF) under one

	c.bench_function("cast decimal32 to decimal32 512", \|b\| {
	b.iter(\|\| cast_array(&decimal32_array, DataType::Decimal32(9, 4)))
	});
	c.bench_function("cast decimal32 to decimal32 512 lower precision", \|b\| {
	b.iter(\|\| cast_array(&decimal32_array, DataType::Decimal32(6, 5)))
	});
	c.bench_function("cast decimal32 to decimal64 512", \|b\| {
	b.iter(\|\| cast_array(&decimal32_array, DataType::Decimal64(11, 5)))
	});
	c.bench_function("cast decimal64 to decimal32 512", \|b\| {
	b.iter(\|\| cast_array(&decimal64_array, DataType::Decimal32(9, 2)))
	});
	c.bench_function("cast decimal64 to decimal64 512", \|b\| {
	b.iter(\|\| cast_array(&decimal64_array, DataType::Decimal64(12, 4)))
	});

	c.bench_function("cast decimal128 to decimal128 512", \|b\| {
	b.iter(\|\| cast_array(&decimal128_array, DataType::Decimal128(30, 5)))
	});
	c.bench_function("cast decimal128 to decimal128 512 lower precision", \|b\| {
	b.iter(\|\| cast_array(&decimal128_array, DataType::Decimal128(6, 5)))
	});
	c.bench_function("cast decimal128 to decimal256 512", \|b\| {
	b.iter(\|\| cast_array(&decimal128_array, DataType::Decimal256(50, 5)))
	});
	c.bench_function("cast decimal256 to decimal128 512", \|b\| {
	b.iter(\|\| cast_array(&decimal256_array, DataType::Decimal128(38, 2)))
	});
	c.bench_function("cast decimal256 to decimal256 512", \|b\| {
	b.iter(\|\| cast_array(&decimal256_array, DataType::Decimal256(50, 5)))
	});

	c.bench_function("cast decimal128 to decimal128 512 with same scale", \|b\| {
	b.iter(\|\| cast_array(&decimal128_array, DataType::Decimal128(30, 3)))
	});

	c.bench_function(
	"cast decimal128 to decimal128 512 with lower scale (infallible)",
	\|b\| b.iter(\|\| cast_array(&decimal128_array, DataType::Decimal128(7, -1))),
	);

	c.bench_function("cast decimal256 to decimal256 512 with same scale", \|b\| {

Conversation

klion26 commented Apr 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Which issue does this PR close?

What changes are included in this PR?

Are these changes tested?

Are there any user-facing changes?

Uh oh!

scovich left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alamb commented Apr 16, 2026

Uh oh!

klion26 commented Apr 16, 2026

Uh oh!

scovich left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alamb left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

klion26 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

klion26 commented Apr 15, 2026 •

edited

Loading

scovich left a comment •

edited

Loading