From c62ebd7298f10d4c309d661c1717dc4f62ef0fca Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 01:25:06 +0000 Subject: [PATCH 01/11] feat: add BatchNormalizer for row- and byte-targeted batch re-chunking Adds a sans-IO BatchNormalizer plus a BatchNormalizerStream adapter that re-chunks a stream of RecordBatches towards a target row count AND byte size. Per input batch it either passes through (zero copy, wide acceptance band), coalesces small batches (flushing on rows or bytes, whichever first), splits oversized batches into compact ~target-sized copies, or compacts batches that pin far more memory than they use. Splitting/compaction copies via take + view-array GC: slice/concat are zero-copy for a single input and would keep the oversized parent buffers alive. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- .../physical-plan/src/batch_normalizer.rs | 873 ++++++++++++++++++ datafusion/physical-plan/src/lib.rs | 1 + 2 files changed, 874 insertions(+) create mode 100644 datafusion/physical-plan/src/batch_normalizer.rs diff --git a/datafusion/physical-plan/src/batch_normalizer.rs b/datafusion/physical-plan/src/batch_normalizer.rs new file mode 100644 index 0000000000000..afd9a43d58515 --- /dev/null +++ b/datafusion/physical-plan/src/batch_normalizer.rs @@ -0,0 +1,873 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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. + +//! [`BatchNormalizer`]: re-chunk a stream of [`RecordBatch`]es towards a +//! target row count *and* byte size. +//! +//! Operators generally bound their output batches by row count +//! (`datafusion.execution.batch_size`) only. With wide rows (large strings, +//! many columns) a batch within the row limit can still be arbitrarily large +//! in bytes (multiple GB), which breaks memory accounting assumptions and +//! causes OOMs. Conversely, streams of tiny batches waste per-batch overhead. +//! +//! [`BatchNormalizer`] addresses both with a single component that, per input +//! batch, takes one of four actions: +//! +//! 1. **Pass through** (zero copy): the batch is already acceptably sized. +//! The acceptance band is deliberately wide so that near-target batches +//! are never copied. +//! 2. **Coalesce**: small batches are buffered (copied) and emitted once the +//! buffer reaches the target row count *or* the target byte size, +//! whichever comes first. +//! 3. **Split**: oversized batches (by rows or by bytes) are re-emitted as +//! compact copies of roughly the target size. Note that copying is +//! load-bearing: `RecordBatch::slice` is zero-copy, so a plain slice of a +//! 4GB batch still pins the entire 4GB of buffers. Splitting must +//! materialize fresh buffers to actually release memory. +//! 4. **Compact**: batches whose logical (sliced) size is small but which +//! pin much larger buffers (e.g. a small slice of a huge batch, or a +//! StringView array referencing mostly-garbage data buffers) are copied +//! so the underlying buffers can be freed. +//! +//! The copy machinery is arrow's [`BatchCoalescer`], which compacts all +//! buffered data (including StringView garbage collection). + +use std::collections::VecDeque; +use std::pin::Pin; +use std::sync::Arc; +use std::task::{Context, Poll, ready}; + +use arrow::array::{ + Array, BinaryViewArray, GenericByteViewArray, RecordBatch, StringViewArray, + UInt64Array, +}; +use arrow::compute::{BatchCoalescer, take_record_batch}; +use arrow::datatypes::{ByteViewType, SchemaRef}; +use datafusion_common::utils::memory::get_record_batch_memory_size; +use datafusion_common::{Result, assert_or_internal_err}; +use datafusion_execution::{RecordBatchStream, SendableRecordBatchStream}; +use futures::{Stream, StreamExt}; + +use crate::metrics::{Count, ExecutionPlanMetricsSet, MetricBuilder}; +use crate::spill::gc_view_arrays; +use crate::stream::EmptyRecordBatchStream; + +/// Multiple of `target_bytes` above which a batch is split. +/// +/// The generous slop avoids wasting work copying batches that are only +/// somewhat over target (splitting copies data; see module docs). +const SPLIT_SLOP_FACTOR: usize = 2; + +/// A batch is "wasteful" (and gets compacted) when the memory it retains is +/// more than this multiple of its logical size... +const WASTE_RATIO: usize = 2; + +/// ...and the absolute waste exceeds this many bytes. Compaction copies data, +/// which is only worth it if it frees a meaningful amount of memory. +const MIN_WASTE_BYTES: usize = 1024 * 1024; + +/// Metrics for [`BatchNormalizer`] +#[derive(Debug, Clone, Default)] +pub struct BatchNormalizerMetrics { + /// Input batches emitted unchanged (zero copy) + pub batches_passed_through: Count, + /// Input batches buffered for coalescing + pub batches_coalesced: Count, + /// Input batches split because they exceeded the row or byte target + pub batches_split: Count, + /// Input batches copied to release pinned memory + pub batches_compacted: Count, +} + +impl BatchNormalizerMetrics { + pub fn new(metrics: &ExecutionPlanMetricsSet, partition: usize) -> Self { + Self { + batches_passed_through: MetricBuilder::new(metrics) + .counter("batches_passed_through", partition), + batches_coalesced: MetricBuilder::new(metrics) + .counter("batches_coalesced", partition), + batches_split: MetricBuilder::new(metrics) + .counter("batches_split", partition), + batches_compacted: MetricBuilder::new(metrics) + .counter("batches_compacted", partition), + } + } +} + +/// Logical (materialized) size of a batch in bytes: the number of bytes +/// needed if exactly the rows in this batch were copied into fresh, +/// minimally-sized buffers. +/// +/// This is intentionally different from +/// [`get_record_batch_memory_size`], which returns the memory the batch +/// *retains* (full backing buffers, including the parts a slice does not +/// reference). The ratio between the two is used to detect wasteful batches. +fn logical_batch_size(batch: &RecordBatch) -> Result { + let mut total = 0; + for array in batch.columns() { + let data = array.to_data(); + total += data.get_slice_memory_size()?; + // `get_slice_memory_size` does not count the variable-length data + // buffers of view arrays (arrow-rs#8230): add the bytes actually + // referenced by the (non-inlined) views. Nested view arrays are not + // corrected, matching the spill code's `GetSlicedSize`. + if let Some(a) = array.as_any().downcast_ref::() { + total += referenced_view_bytes(a); + } else if let Some(a) = array.as_any().downcast_ref::() { + total += referenced_view_bytes(a); + } + } + Ok(total) +} + +/// Total bytes in the data buffers referenced by non-null, non-inlined views +fn referenced_view_bytes(array: &GenericByteViewArray) -> usize { + let nulls = array.nulls(); + array + .views() + .iter() + .enumerate() + .map(|(i, v)| { + if nulls.map(|n| n.is_null(i)).unwrap_or(false) { + return 0; + } + // low 32 bits of a view are the value's length; values longer + // than 12 bytes live in the data buffers + let len = (*v as u32) as usize; + if len > 12 { len } else { 0 } + }) + .sum() +} + +/// Copy `length` rows of `batch` starting at `offset` into fresh, +/// minimally-sized buffers. +/// +/// This must NOT be implemented with `slice`/`concat`: `RecordBatch::slice` +/// is zero-copy and arrow's `concat` short-circuits a single input array to +/// a zero-copy slice, so neither releases the parent batch's buffers. `take` +/// materializes fresh buffers for all types; view arrays additionally need a +/// garbage-collection pass because `take` copies their (small) views while +/// still sharing the underlying data buffers. +fn compact_slice( + batch: &RecordBatch, + offset: usize, + length: usize, +) -> Result { + let indices = UInt64Array::from_iter_values(offset as u64..(offset + length) as u64); + let taken = take_record_batch(batch, &indices)?; + gc_view_arrays(&taken) +} + +/// An oversized batch being split incrementally: one chunk is copied out per +/// [`BatchNormalizer::produce`] call so that peak memory stays at the parent +/// batch plus ~one chunk, rather than the parent plus all its chunks. +#[derive(Debug)] +struct PendingSplit { + batch: RecordBatch, + offset: usize, + chunk_rows: usize, + /// If true the chunks are emitted as zero-copy slices instead of compact + /// copies. Only used for batches with no columns (row count only), where + /// a slice retains nothing. + zero_copy: bool, +} + +/// See [module docs](self) for details. +/// +/// This is the sans-IO core; [`BatchNormalizerStream`] adapts it to a +/// [`SendableRecordBatchStream`]. +/// +/// Call [`push_batch`](Self::push_batch) when [`produce`](Self::produce) +/// returns `Ok(None)`, and [`finish`](Self::finish) at end of input to flush +/// any buffered rows. +#[derive(Debug)] +pub struct BatchNormalizer { + schema: SchemaRef, + /// Copy/compaction machinery: buffers and compacts pushed batches + /// (including StringView garbage collection), auto-completing an output + /// batch whenever `target_rows` rows are buffered. + inner: BatchCoalescer, + target_rows: usize, + target_bytes: usize, + /// Logical bytes currently buffered in `inner` + buffered_bytes: usize, + /// Output batches ready to be returned by `produce` + completed: VecDeque, + /// Oversized batch currently being split, if any + pending_split: Option, + finished: bool, + metrics: BatchNormalizerMetrics, +} + +impl BatchNormalizer { + /// Create a new normalizer targeting `target_rows` rows and + /// `target_bytes` (logical) bytes per output batch. + pub fn new( + schema: SchemaRef, + target_rows: usize, + target_bytes: usize, + metrics: BatchNormalizerMetrics, + ) -> Self { + Self { + inner: BatchCoalescer::new(Arc::clone(&schema), target_rows), + schema, + target_rows, + target_bytes: target_bytes.max(1), + buffered_bytes: 0, + completed: VecDeque::new(), + pending_split: None, + finished: false, + metrics, + } + } + + pub fn schema(&self) -> SchemaRef { + Arc::clone(&self.schema) + } + + /// Push an input batch. + /// + /// Must only be called when [`produce`](Self::produce) returned + /// `Ok(None)` (i.e. all pending output has been drained) and before + /// [`finish`](Self::finish). + pub fn push_batch(&mut self, batch: RecordBatch) -> Result<()> { + assert_or_internal_err!( + !self.finished, + "BatchNormalizer: push_batch after finish" + ); + assert_or_internal_err!( + self.pending_split.is_none(), + "BatchNormalizer: push_batch while a split is pending; drain produce() first" + ); + + let rows = batch.num_rows(); + if rows == 0 { + return Ok(()); + } + + // Row-count-only batches: nothing to copy, split by rows if needed + if batch.num_columns() == 0 { + if rows > self.target_rows { + self.metrics.batches_split.add(1); + self.pending_split = Some(PendingSplit { + batch, + offset: 0, + chunk_rows: self.target_rows, + zero_copy: true, + }); + } else { + self.metrics.batches_passed_through.add(1); + self.completed.push_back(batch); + } + return Ok(()); + } + + let logical = logical_batch_size(&batch)?; + + // Oversized (by rows or bytes): split into ~target-sized chunks + if rows > self.target_rows || logical > SPLIT_SLOP_FACTOR * self.target_bytes { + let bytes_per_row = (logical / rows).max(1); + let chunk_rows = + (self.target_bytes / bytes_per_row).clamp(1, self.target_rows); + if chunk_rows < rows { + self.metrics.batches_split.add(1); + // Chunks are emitted directly (not via the coalescing + // buffer), so flush buffered rows first to preserve order + self.flush_buffer()?; + self.pending_split = Some(PendingSplit { + batch, + offset: 0, + chunk_rows, + zero_copy: false, + }); + return Ok(()); + } + // A single row wider than the split threshold cannot be split + // further: emit as-is. (`chunk_rows >= rows` is only reachable + // here for `rows == 1`.) + return self.pass_through(batch); + } + + // Acceptable size, but does it pin much more memory than it uses? + // (e.g. a small slice of a huge batch): copy it so the backing + // buffers can be freed. + let retained = get_record_batch_memory_size(&batch); + let wasteful = retained > WASTE_RATIO * logical + && retained.saturating_sub(logical) >= MIN_WASTE_BYTES; + let batch = if wasteful { + self.metrics.batches_compacted.add(1); + compact_slice(&batch, 0, rows)? + } else { + batch + }; + + // In the acceptance band: emit as-is + if rows >= self.target_rows / 2 || logical >= self.target_bytes / 2 { + if !wasteful { + self.metrics.batches_passed_through.add(1); + } + return self.emit(batch); + } + + // Small: buffer for coalescing + if !wasteful { + self.metrics.batches_coalesced.add(1); + } + self.buffer(batch, logical) + } + + /// Signal end of input, flushing any buffered rows. + pub fn finish(&mut self) -> Result<()> { + assert_or_internal_err!( + self.pending_split.is_none(), + "BatchNormalizer: finish while a split is pending; drain produce() first" + ); + self.flush_buffer()?; + self.finished = true; + Ok(()) + } + + /// Return the next output batch, doing incremental split work if an + /// oversized batch is pending. Returns `Ok(None)` when more input is + /// needed (or, after [`finish`](Self::finish), when fully drained). + pub fn produce(&mut self) -> Result> { + loop { + if let Some(batch) = self.completed.pop_front() { + return Ok(Some(batch)); + } + let Some(mut pending) = self.pending_split.take() else { + return Ok(None); + }; + // Copy out the next chunk of the pending oversized batch + let remaining = pending.batch.num_rows() - pending.offset; + let take = remaining.min(pending.chunk_rows); + let chunk = if pending.zero_copy { + pending.batch.slice(pending.offset, take) + } else { + compact_slice(&pending.batch, pending.offset, take)? + }; + pending.offset += take; + if pending.offset < pending.batch.num_rows() { + self.pending_split = Some(pending); + } + self.completed.push_back(chunk); + } + } + + /// Push `batch` (of logical size `logical`) into the copying buffer, + /// flushing if the byte target is reached. Arrow's coalescer flushes by + /// itself when the row target is reached. + fn buffer(&mut self, batch: RecordBatch, logical: usize) -> Result<()> { + self.inner.push_batch(batch)?; + self.buffered_bytes += logical; + self.drain_inner()?; + if self.buffered_bytes >= self.target_bytes { + self.flush_buffer()?; + } + Ok(()) + } + + /// Emit `batch` unchanged, zero copy + fn pass_through(&mut self, batch: RecordBatch) -> Result<()> { + self.metrics.batches_passed_through.add(1); + self.emit(batch) + } + + /// Emit `batch`, flushing any buffered rows first to preserve input order + fn emit(&mut self, batch: RecordBatch) -> Result<()> { + self.flush_buffer()?; + self.completed.push_back(batch); + Ok(()) + } + + /// Complete the currently buffered rows (if any) as an output batch + fn flush_buffer(&mut self) -> Result<()> { + if self.inner.get_buffered_rows() > 0 { + self.inner.finish_buffered_batch()?; + self.drain_inner()?; + } + self.buffered_bytes = 0; + Ok(()) + } + + /// Move batches completed by the inner coalescer into the output queue + fn drain_inner(&mut self) -> Result<()> { + while let Some(batch) = self.inner.next_completed_batch() { + // completed batches are freshly compacted: logical == retained + self.buffered_bytes = self + .buffered_bytes + .saturating_sub(logical_batch_size(&batch)?); + self.completed.push_back(batch); + } + Ok(()) + } +} + +/// Stream adapter for [`BatchNormalizer`]. +/// +/// Applies the normalizer to `input`, forwarding errors and flushing +/// buffered rows when the input is exhausted. +pub struct BatchNormalizerStream { + input: SendableRecordBatchStream, + normalizer: BatchNormalizer, + input_done: bool, +} + +impl BatchNormalizerStream { + pub fn new( + input: SendableRecordBatchStream, + target_rows: usize, + target_bytes: usize, + metrics: BatchNormalizerMetrics, + ) -> Self { + let normalizer = + BatchNormalizer::new(input.schema(), target_rows, target_bytes, metrics); + Self { + input, + normalizer, + input_done: false, + } + } +} + +impl Stream for BatchNormalizerStream { + type Item = Result; + + fn poll_next( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll> { + loop { + match self.normalizer.produce() { + Ok(Some(batch)) => return Poll::Ready(Some(Ok(batch))), + Ok(None) => {} + Err(e) => return Poll::Ready(Some(Err(e))), + } + if self.input_done { + return Poll::Ready(None); + } + match ready!(self.input.poll_next_unpin(cx)) { + Some(Ok(batch)) => { + if let Err(e) = self.normalizer.push_batch(batch) { + return Poll::Ready(Some(Err(e))); + } + } + Some(Err(e)) => return Poll::Ready(Some(Err(e))), + None => { + if let Err(e) = self.normalizer.finish() { + return Poll::Ready(Some(Err(e))); + } + // Release the input pipeline's resources + let input_schema = self.input.schema(); + self.input = Box::pin(EmptyRecordBatchStream::new(input_schema)); + self.input_done = true; + } + } + } + } +} + +impl RecordBatchStream for BatchNormalizerStream { + fn schema(&self) -> SchemaRef { + self.normalizer.schema() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use arrow::array::{ArrayRef, Int64Array, StringArray}; + use arrow::compute::concat_batches; + use arrow::datatypes::{DataType, Field, Schema}; + use futures::TryStreamExt; + + const TARGET_ROWS: usize = 100; + const TARGET_BYTES: usize = 10 * 1024; // 10 KiB + + fn test_schema() -> SchemaRef { + Arc::new(Schema::new(vec![ + Field::new("id", DataType::Int64, false), + Field::new("s", DataType::Utf8, false), + ])) + } + + /// Batch with `rows` rows where each string value is `str_len` bytes + fn string_batch(rows: usize, str_len: usize) -> RecordBatch { + let ids = Int64Array::from_iter_values(0..rows as i64); + let s = + StringArray::from_iter_values((0..rows).map(|i| format!("{i:0>str_len$}"))); + RecordBatch::try_new( + test_schema(), + vec![Arc::new(ids) as ArrayRef, Arc::new(s) as ArrayRef], + ) + .unwrap() + } + + fn normalizer() -> BatchNormalizer { + BatchNormalizer::new( + test_schema(), + TARGET_ROWS, + TARGET_BYTES, + BatchNormalizerMetrics::default(), + ) + } + + /// Push all batches, then finish, collecting every produced batch. + fn run( + normalizer: &mut BatchNormalizer, + batches: impl IntoIterator, + ) -> Vec { + let mut out = vec![]; + for batch in batches { + normalizer.push_batch(batch).unwrap(); + while let Some(b) = normalizer.produce().unwrap() { + out.push(b); + } + } + normalizer.finish().unwrap(); + while let Some(b) = normalizer.produce().unwrap() { + out.push(b); + } + out + } + + /// Assert that the concatenation of `outputs` equals concatenation of `inputs` + fn assert_same_data(inputs: &[RecordBatch], outputs: &[RecordBatch]) { + let schema = inputs[0].schema(); + let expected = concat_batches(&schema, inputs).unwrap(); + let actual = concat_batches(&schema, outputs).unwrap(); + assert_eq!(expected, actual); + } + + fn logical_size(batch: &RecordBatch) -> usize { + logical_batch_size(batch).unwrap() + } + + // === pass through === + + #[test] + fn passthrough_normal_batch_is_zero_copy() { + // rows == target, bytes within band -> exact same arrays out + let batch = string_batch(TARGET_ROWS, 20); + let out = run(&mut normalizer(), [batch.clone()]); + assert_eq!(out.len(), 1); + for (in_col, out_col) in batch.columns().iter().zip(out[0].columns()) { + assert!( + Arc::ptr_eq(in_col, out_col), + "expected zero-copy pass through" + ); + } + } + + #[test] + fn passthrough_by_bytes_with_few_rows() { + // Only 10 rows (< target_rows/2) but ~8KiB (> target_bytes/2): + // "few wide rows" is an acceptable batch, not one to coalesce + let batch = string_batch(10, 800); + assert!(logical_size(&batch) >= TARGET_BYTES / 2); + let out = run(&mut normalizer(), [batch.clone()]); + assert_eq!(out.len(), 1); + assert!(Arc::ptr_eq(batch.column(1), out[0].column(1))); + } + + #[test] + fn passthrough_slightly_oversized_batch() { + // ~1.6x target bytes: within the slop band, must NOT be split/copied + let batch = string_batch(TARGET_ROWS, 160); + let size = logical_size(&batch); + assert!(size > TARGET_BYTES && size < SPLIT_SLOP_FACTOR * TARGET_BYTES); + let out = run(&mut normalizer(), [batch.clone()]); + assert_eq!(out.len(), 1); + assert!(Arc::ptr_eq(batch.column(1), out[0].column(1))); + } + + // === coalesce === + + #[test] + fn coalesce_small_batches_by_rows() { + // 10-row tiny batches accumulate to target_rows + let inputs: Vec<_> = (0..25).map(|_| string_batch(10, 5)).collect(); + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert_eq!( + out.iter().map(|b| b.num_rows()).collect::>(), + vec![100, 100, 50], + ); + } + + #[test] + fn coalesce_flushes_on_bytes_before_rows() { + // 10 rows x ~400B = ~4KiB logical per batch; the byte target (10KiB) + // is reached after ~3 batches, well before 100 buffered rows + let inputs: Vec<_> = (0..6).map(|_| string_batch(10, 400)).collect(); + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert!(out.len() >= 2, "byte target should have forced a flush"); + for b in &out { + assert!(b.num_rows() < TARGET_ROWS); + assert!(logical_size(b) <= SPLIT_SLOP_FACTOR * TARGET_BYTES); + } + } + + // === split === + + #[test] + fn split_wide_batch_by_bytes() { + // 50 rows x ~1KiB = ~51KiB >> 2x target (20KiB): split into ~10-row + // chunks of ~target_bytes each + let batch = string_batch(50, 1024); + let inputs = [batch.clone()]; + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert!(out.len() > 1, "expected batch to be split"); + for b in &out { + assert!( + logical_size(b) <= SPLIT_SLOP_FACTOR * TARGET_BYTES, + "chunk of {} bytes exceeds split threshold", + logical_size(b) + ); + // chunks must be compact copies: they must not retain the + // original ~51KiB of buffers + assert!( + get_record_batch_memory_size(b) < logical_size(&batch) / 2, + "chunk retains the parent batch's buffers" + ); + } + } + + #[test] + fn split_by_rows() { + // 1000 tiny rows > target_rows: split into 100-row chunks + let batch = string_batch(1000, 5); + let inputs = [batch.clone()]; + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert_eq!(out.len(), 10); + for b in &out { + assert_eq!(b.num_rows(), TARGET_ROWS); + } + } + + #[test] + fn split_produces_output_incrementally() { + // Oversized batches must not materialize all chunks eagerly: + // after push, produce() yields chunks one at a time + let batch = string_batch(50, 1024); + let mut n = normalizer(); + n.push_batch(batch).unwrap(); + let first = n.produce().unwrap(); + assert!(first.is_some()); + // there must be more chunks pending + let second = n.produce().unwrap(); + assert!(second.is_some()); + } + + #[test] + fn giant_single_row_passes_through() { + // One row larger than the split threshold cannot be split further; + // it must be emitted as-is (and not loop or error) + let batch = string_batch(1, 5 * TARGET_BYTES); + let inputs = [batch.clone()]; + let out = run(&mut normalizer(), inputs.clone()); + assert_eq!(out.len(), 1); + assert_eq!(out[0].num_rows(), 1); + assert_same_data(&inputs, &out); + } + + #[test] + fn split_string_view_batch_releases_data_buffers() { + // View arrays need explicit GC when split: a copied chunk's views + // would otherwise still reference the parent's large data buffers + use arrow::array::StringViewArray; + let rows = 50; + let s = + StringViewArray::from_iter_values((0..rows).map(|i| format!("{i:0>1024}"))); + let schema = Arc::new(Schema::new(vec![Field::new( + "s", + DataType::Utf8View, + false, + )])); + let batch = + RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s) as ArrayRef]) + .unwrap(); + let parent_size = get_record_batch_memory_size(&batch); + let mut n = BatchNormalizer::new( + schema, + TARGET_ROWS, + TARGET_BYTES, + BatchNormalizerMetrics::default(), + ); + let inputs = [batch]; + let out = run(&mut n, inputs.clone()); + assert_same_data(&inputs, &out); + assert!(out.len() > 1, "expected batch to be split"); + for b in &out { + assert!( + get_record_batch_memory_size(b) < parent_size / 2, + "chunk retains the parent's view data buffers" + ); + } + } + + // === compact === + + #[test] + fn wasteful_slice_is_compacted() { + // A small slice of a big batch pins the whole parent buffer. + // logical size is in the pass-through band, but retained size is + // ~50x larger -> must be copied so the parent can be freed. + let parent = string_batch(10_000, 300); // ~3MB + let slice = parent.slice(0, 20); // ~6KiB logical + let logical = logical_size(&slice); + assert!(logical >= TARGET_BYTES / 2, "slice must be in pass band"); + assert!(get_record_batch_memory_size(&slice) > WASTE_RATIO * logical); + + let inputs = [slice.clone()]; + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert_eq!(out.len(), 1); + assert!( + get_record_batch_memory_size(&out[0]) < logical * 2, + "output still retains the parent's buffers" + ); + } + + #[test] + fn small_waste_is_not_compacted() { + // Waste below MIN_WASTE_BYTES is not worth a copy: a slice of a + // small parent should pass through zero-copy + let parent = string_batch(200, 60); + let slice = parent.slice(0, TARGET_ROWS); + let out = run(&mut normalizer(), [slice.clone()]); + assert_eq!(out.len(), 1); + assert!(Arc::ptr_eq(slice.column(1), out[0].column(1))); + } + + // === ordering / flush === + + #[test] + fn ordering_preserved_when_passthrough_interrupts_buffer() { + // buffered small batches must be flushed (as a runt batch) before a + // pass-through batch is emitted, preserving input order + let small1 = string_batch(10, 5); + let small2 = string_batch(10, 5); + let big = string_batch(TARGET_ROWS, 20); + let inputs = vec![small1, small2, big]; + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert_eq!( + out.iter().map(|b| b.num_rows()).collect::>(), + vec![20, TARGET_ROWS], + ); + } + + #[test] + fn finish_flushes_buffered_rows() { + let inputs = vec![string_batch(10, 5), string_batch(10, 5)]; + let out = run(&mut normalizer(), inputs.clone()); + assert_same_data(&inputs, &out); + assert_eq!(out.len(), 1); + assert_eq!(out[0].num_rows(), 20); + } + + #[test] + fn empty_batches_are_dropped() { + let inputs = vec![string_batch(0, 5), string_batch(10, 5)]; + let out = run(&mut normalizer(), inputs); + assert_eq!(out.len(), 1); + assert_eq!(out[0].num_rows(), 10); + } + + #[test] + fn no_column_batches_split_by_rows() { + use arrow::array::RecordBatchOptions; + let schema = Arc::new(Schema::empty()); + let batch = RecordBatch::try_new_with_options( + Arc::clone(&schema), + vec![], + &RecordBatchOptions::new().with_row_count(Some(250)), + ) + .unwrap(); + let mut n = BatchNormalizer::new( + schema, + TARGET_ROWS, + TARGET_BYTES, + BatchNormalizerMetrics::default(), + ); + let out = run(&mut n, [batch]); + assert_eq!( + out.iter().map(|b| b.num_rows()).collect::>(), + vec![100, 100, 50], + ); + } + + #[test] + fn metrics_are_recorded() { + let metrics = ExecutionPlanMetricsSet::new(); + let m = BatchNormalizerMetrics::new(&metrics, 0); + let mut n = + BatchNormalizer::new(test_schema(), TARGET_ROWS, TARGET_BYTES, m.clone()); + run( + &mut n, + [ + string_batch(TARGET_ROWS, 20), // pass through + string_batch(10, 5), // coalesce + string_batch(50, 1024), // split + ], + ); + assert_eq!(m.batches_passed_through.value(), 1); + assert_eq!(m.batches_coalesced.value(), 1); + assert_eq!(m.batches_split.value(), 1); + } + + // === stream adapter === + + #[tokio::test] + async fn stream_end_to_end() { + use crate::ExecutionPlan; + use crate::test::TestMemoryExec; + use datafusion_execution::TaskContext; + + let inputs: Vec<_> = (0..5) + .map(|_| string_batch(10, 5)) + .chain([string_batch(50, 1024)]) + .collect(); + let schema = test_schema(); + let exec = TestMemoryExec::try_new_exec( + std::slice::from_ref(&inputs), + Arc::clone(&schema), + None, + ) + .unwrap(); + let input_stream = exec.execute(0, Arc::new(TaskContext::default())).unwrap(); + + let stream = BatchNormalizerStream::new( + input_stream, + TARGET_ROWS, + TARGET_BYTES, + BatchNormalizerMetrics::default(), + ); + assert_eq!(stream.schema(), schema); + let out: Vec = Box::pin(stream).try_collect().await.unwrap(); + assert_same_data(&inputs, &out); + assert!(out.len() > 1); + for b in &out { + assert!(b.num_rows() <= TARGET_ROWS); + assert!(logical_size(b) <= SPLIT_SLOP_FACTOR * TARGET_BYTES); + } + } +} diff --git a/datafusion/physical-plan/src/lib.rs b/datafusion/physical-plan/src/lib.rs index 6cc6e44c32cc3..03b8335916551 100644 --- a/datafusion/physical-plan/src/lib.rs +++ b/datafusion/physical-plan/src/lib.rs @@ -64,6 +64,7 @@ mod visitor; pub mod aggregates; pub mod analyze; pub mod async_func; +pub mod batch_normalizer; pub mod buffer; pub mod coalesce; pub mod coalesce_batches; From 9e3c032eb04492265efc77f03e5a54a70c686868 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 01:45:14 +0000 Subject: [PATCH 02/11] feat: add datafusion.execution.target_batch_size_bytes to normalize source batches When set, DataSourceExec wraps its output in BatchNormalizerStream instead of the row-only BatchSplitStream, re-chunking scan output towards both the row target (batch_size) and the new byte target. Default is unset (row-based splitting only, unchanged behavior). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- datafusion/common/src/config.rs | 11 ++ .../core/tests/datasource/batch_normalizer.rs | 107 ++++++++++++++++++ datafusion/core/tests/datasource/mod.rs | 1 + datafusion/datasource/src/source.rs | 27 ++++- .../test_files/information_schema.slt | 2 + docs/source/user-guide/configs.md | 1 + 6 files changed, 148 insertions(+), 1 deletion(-) create mode 100644 datafusion/core/tests/datasource/batch_normalizer.rs diff --git a/datafusion/common/src/config.rs b/datafusion/common/src/config.rs index 454af28c14b4a..3ea6b88513071 100644 --- a/datafusion/common/src/config.rs +++ b/datafusion/common/src/config.rs @@ -732,6 +732,17 @@ config_namespace! { /// metadata memory consumption pub batch_size: ConfigNonZeroUsize, default = non_zero_usize_default(8192) + /// Soft target, in bytes, for the in-memory size of batches produced by data + /// sources, in addition to the row-based `batch_size` target. When set, data + /// source output batches are re-chunked towards both targets: batches much + /// larger than this (by in-memory size) are split into compact copies of + /// roughly this size even when within `batch_size` rows -- protecting + /// downstream operators from very large batches (e.g. wide rows with large + /// string values) -- and small batches are coalesced until they reach either + /// target. Batches near the targets are passed through without copying. + /// When `None` (the default), batches are only split by row count. + pub target_batch_size_bytes: Option, default = None + /// A perfect hash join (see `HashJoinExec` for more details) will be considered /// if the range of keys (max - min) on the build side is < this threshold. /// This provides a fast path for joins with very small key ranges, diff --git a/datafusion/core/tests/datasource/batch_normalizer.rs b/datafusion/core/tests/datasource/batch_normalizer.rs new file mode 100644 index 0000000000000..c96199c73f4ba --- /dev/null +++ b/datafusion/core/tests/datasource/batch_normalizer.rs @@ -0,0 +1,107 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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. + +//! End-to-end tests for `datafusion.execution.target_batch_size_bytes`: +//! byte-aware re-chunking of data source output batches + +use std::sync::Arc; + +use arrow::array::{ArrayRef, RecordBatch, StringArray}; +use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; +use datafusion::datasource::MemTable; +use datafusion::prelude::{SessionConfig, SessionContext}; +use datafusion_common::Result; +use datafusion_common::utils::memory::get_record_batch_memory_size; + +fn wide_schema() -> SchemaRef { + Arc::new(Schema::new(vec![Field::new("s", DataType::Utf8, false)])) +} + +/// Batch with `rows` rows of `str_len`-byte strings +fn wide_batch(rows: usize, str_len: usize) -> RecordBatch { + let s = StringArray::from_iter_values((0..rows).map(|i| format!("{i:0>str_len$}"))); + RecordBatch::try_new(wide_schema(), vec![Arc::new(s) as ArrayRef]).unwrap() +} + +async fn run_scan( + config: SessionConfig, + batches: Vec, +) -> Result> { + let ctx = SessionContext::new_with_config(config.with_target_partitions(1)); + let table = MemTable::try_new(wide_schema(), vec![batches])?; + ctx.register_table("t", Arc::new(table))?; + ctx.sql("SELECT * FROM t").await?.collect().await +} + +#[tokio::test] +async fn target_batch_size_bytes_splits_wide_batches() -> Result<()> { + // One ~1MB batch of 100 wide rows; a 64KiB byte target must split it + let input = wide_batch(100, 10 * 1024); + let target_bytes = 64 * 1024; + + let mut config = SessionConfig::new(); + config.options_mut().execution.target_batch_size_bytes = Some(target_bytes); + + let results = run_scan(config, vec![input.clone()]).await?; + assert!( + results.len() > 1, + "expected wide batch to be split, got {} batch(es)", + results.len() + ); + assert_eq!(results.iter().map(|b| b.num_rows()).sum::(), 100); + for batch in &results { + // each chunk must be a compact copy of roughly the target size, not + // a zero-copy slice pinning the ~1MB parent + assert!( + get_record_batch_memory_size(batch) <= 2 * target_bytes, + "output batch retains {} bytes, expected <= {}", + get_record_batch_memory_size(batch), + 2 * target_bytes + ); + } + Ok(()) +} + +#[tokio::test] +async fn wide_batches_not_split_by_default() -> Result<()> { + // Without a byte target, splitting is row-based only: a single wide + // batch within `batch_size` rows passes through whole + let input = wide_batch(100, 10 * 1024); + let results = run_scan(SessionConfig::new(), vec![input]).await?; + assert_eq!(results.len(), 1); + assert_eq!(results[0].num_rows(), 100); + Ok(()) +} + +#[tokio::test] +async fn target_batch_size_bytes_coalesces_small_batches() -> Result<()> { + // 50 batches of 10 tiny rows each: the normalizer coalesces them + let batches: Vec<_> = (0..50).map(|_| wide_batch(10, 8)).collect(); + + let mut config = SessionConfig::new(); + config.options_mut().execution.target_batch_size_bytes = Some(1024 * 1024); + + let results = run_scan(config, batches).await?; + assert_eq!(results.iter().map(|b| b.num_rows()).sum::(), 500); + assert_eq!( + results.len(), + 1, + "expected small batches to be coalesced, got {} batches", + results.len() + ); + Ok(()) +} diff --git a/datafusion/core/tests/datasource/mod.rs b/datafusion/core/tests/datasource/mod.rs index 3785aa0766182..6de4712828b6d 100644 --- a/datafusion/core/tests/datasource/mod.rs +++ b/datafusion/core/tests/datasource/mod.rs @@ -20,5 +20,6 @@ //! Note tests for the Parquet format are in `parquet_integration` binary // Include tests in csv module +mod batch_normalizer; mod csv; mod object_store_access; diff --git a/datafusion/datasource/src/source.rs b/datafusion/datasource/src/source.rs index 9eb92e7e3525d..cb7ee71f09b7c 100644 --- a/datafusion/datasource/src/source.rs +++ b/datafusion/datasource/src/source.rs @@ -23,6 +23,9 @@ use std::fmt::{Debug, Formatter}; use std::sync::{Arc, OnceLock}; use datafusion_physical_expr::projection::ProjectionExprs; +use datafusion_physical_plan::batch_normalizer::{ + BatchNormalizerMetrics, BatchNormalizerStream, +}; use datafusion_physical_plan::execution_plan::{ Boundedness, EmissionType, SchedulingType, }; @@ -408,11 +411,33 @@ impl ExecutionPlan for DataSourceExec { .with_shared_state(shared_state); let stream = self.data_source.open_with_args(args)?; let batch_size = context.session_config().batch_size(); + let metrics = self.data_source.metrics(); + + // With a byte target configured, normalize output batches by both + // row count and in-memory size (splitting oversized batches and + // coalescing small ones); otherwise only split by row count. + let target_batch_size_bytes = context + .session_config() + .options() + .execution + .target_batch_size_bytes; + if let Some(target_bytes) = target_batch_size_bytes { + log::debug!( + "Batch normalization enabled for partition {partition}: \ + batch_size={batch_size} target_batch_size_bytes={target_bytes}" + ); + let normalizer_metrics = BatchNormalizerMetrics::new(&metrics, partition); + return Ok(Box::pin(BatchNormalizerStream::new( + stream, + batch_size, + target_bytes, + normalizer_metrics, + ))); + } log::debug!( "Batch splitting enabled for partition {partition}: batch_size={batch_size}" ); - let metrics = self.data_source.metrics(); let split_metrics = SplitMetrics::new(&metrics, partition); Ok(Box::pin(BatchSplitStream::new( stream, diff --git a/datafusion/sqllogictest/test_files/information_schema.slt b/datafusion/sqllogictest/test_files/information_schema.slt index bf45564e26333..144e7e4ffe37b 100644 --- a/datafusion/sqllogictest/test_files/information_schema.slt +++ b/datafusion/sqllogictest/test_files/information_schema.slt @@ -281,6 +281,7 @@ datafusion.execution.sort_pushdown_buffer_capacity 1073741824 datafusion.execution.sort_spill_reservation_bytes 10485760 datafusion.execution.spill_compression uncompressed datafusion.execution.split_file_groups_by_statistics false +datafusion.execution.target_batch_size_bytes NULL datafusion.execution.target_partitions 7 datafusion.execution.time_zone NULL datafusion.execution.use_row_number_estimates_to_optimize_partitioning false @@ -440,6 +441,7 @@ datafusion.execution.sort_pushdown_buffer_capacity 1073741824 Maximum buffer cap datafusion.execution.sort_spill_reservation_bytes 10485760 Specifies the reserved memory for each spillable sort operation to facilitate an in-memory merge. When a sort operation spills to disk, the in-memory data must be sorted and merged before being written to a file. This setting reserves a specific amount of memory for that in-memory sort/merge process. Note: This setting is irrelevant if the sort operation cannot spill (i.e., if there's no `DiskManager` configured). datafusion.execution.spill_compression uncompressed Sets the compression codec used when spilling data to disk. Since datafusion writes spill files using the Arrow IPC Stream format, only codecs supported by the Arrow IPC Stream Writer are allowed. Valid values are: uncompressed, lz4_frame, zstd. Note: lz4_frame offers faster (de)compression, but typically results in larger spill files. In contrast, zstd achieves higher compression ratios at the cost of slower (de)compression speed. datafusion.execution.split_file_groups_by_statistics false Attempt to eliminate sorts by packing & sorting files with non-overlapping statistics into the same file groups. Currently experimental +datafusion.execution.target_batch_size_bytes NULL Soft target, in bytes, for the in-memory size of batches produced by data sources, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. When `None` (the default), batches are only split by row count. datafusion.execution.target_partitions 7 Number of partitions for query execution. Increasing partitions can increase concurrency. Defaults to the number of CPU cores on the system datafusion.execution.time_zone NULL The default time zone Some functions, e.g. `now` return timestamps in this time zone datafusion.execution.use_row_number_estimates_to_optimize_partitioning false Should DataFusion use row number estimates at the input to decide whether increasing parallelism is beneficial or not. By default, only exact row numbers (not estimates) are used for this decision. Setting this flag to `true` will likely produce better plans. if the source of statistics is accurate. We plan to make this the default in the future. diff --git a/docs/source/user-guide/configs.md b/docs/source/user-guide/configs.md index 03340c366d70f..e0d9154741ea4 100644 --- a/docs/source/user-guide/configs.md +++ b/docs/source/user-guide/configs.md @@ -74,6 +74,7 @@ The following configuration settings are available: | datafusion.catalog.has_header | true | Default value for `format.has_header` for `CREATE EXTERNAL TABLE` if not specified explicitly in the statement. | | datafusion.catalog.newlines_in_values | false | Specifies whether newlines in (quoted) CSV values are supported. This is the default value for `format.newlines_in_values` for `CREATE EXTERNAL TABLE` if not specified explicitly in the statement. Parsing newlines in quoted values may be affected by execution behaviour such as parallel file scanning. Setting this to `true` ensures that newlines in values are parsed successfully, which may reduce performance. | | datafusion.execution.batch_size | 8192 | Default batch size while creating new batches, it's especially useful for buffer-in-memory batches since creating tiny batches would result in too much metadata memory consumption | +| datafusion.execution.target_batch_size_bytes | NULL | Soft target, in bytes, for the in-memory size of batches produced by data sources, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. When `None` (the default), batches are only split by row count. | | datafusion.execution.perfect_hash_join_small_build_threshold | 1024 | A perfect hash join (see `HashJoinExec` for more details) will be considered if the range of keys (max - min) on the build side is < this threshold. This provides a fast path for joins with very small key ranges, bypassing the density check. Currently only supports cases where build_side.num_rows() < u32::MAX. Support for build_side.num_rows() >= u32::MAX will be added in the future. | | datafusion.execution.perfect_hash_join_min_key_density | 0.15 | The minimum required density of join keys on the build side to consider a perfect hash join (see `HashJoinExec` for more details). Density is calculated as: `(number of rows) / (max_key - min_key + 1)`. A perfect hash join may be used if the actual key density > this value. Currently only supports cases where build_side.num_rows() < u32::MAX. Support for build_side.num_rows() >= u32::MAX will be added in the future. | | datafusion.execution.coalesce_batches | true | When set to true, record batches will be examined between each operator and small batches will be coalesced into larger batches. This is helpful when there are highly selective filters or joins that could produce tiny output batches. The target batch size is determined by the configuration setting | From 075ac3220fb22d1b5f59b65fd05fc1f9b7cd91cf Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 10:24:20 -0500 Subject: [PATCH 03/11] feat: add large_values benchmark for very large row values Existing suites (TPC-H, ClickBench) decode to ~1MiB batches and never exercise the oversized-batch regime that target_batch_size_bytes addresses. This benchmark generates incompressible multi-KiB string values (default: 64k rows x 16KiB over 8 files, so each file decodes to a single ~134MiB batch within the 8192-row limit) and runs 5 queries stressing scan+filter, sort (small key / large key), aggregation, and hash join. Designed for A/B runs of target_batch_size_bytes, optionally under --memory-limit. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- benchmarks/src/bin/dfbench.rs | 5 +- benchmarks/src/large_values.rs | 322 +++++++++++++++++++++++++++++++++ benchmarks/src/lib.rs | 1 + 3 files changed, 327 insertions(+), 1 deletion(-) create mode 100644 benchmarks/src/large_values.rs diff --git a/benchmarks/src/bin/dfbench.rs b/benchmarks/src/bin/dfbench.rs index 50dd99368b7f0..3cd61e7478516 100644 --- a/benchmarks/src/bin/dfbench.rs +++ b/benchmarks/src/bin/dfbench.rs @@ -32,7 +32,8 @@ static ALLOC: snmalloc_rs::SnMalloc = snmalloc_rs::SnMalloc; static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc; use datafusion_benchmarks::{ - cancellation, clickbench, dict, h2o, hj, imdb, nlj, smj, sort_tpch, tpcds, tpch, + cancellation, clickbench, dict, h2o, hj, imdb, large_values, nlj, smj, sort_tpch, + tpcds, tpch, }; #[derive(Debug, Parser)] @@ -50,6 +51,7 @@ enum Options { H2o(h2o::RunOpt), HJ(hj::RunOpt), Imdb(imdb::RunOpt), + LargeValues(large_values::RunOpt), Nlj(nlj::RunOpt), Smj(smj::RunOpt), SortPushdown(sort_pushdown::RunOpt), @@ -71,6 +73,7 @@ pub async fn main() -> Result<()> { Options::H2o(opt) => opt.run().await, Options::HJ(opt) => opt.run().await, Options::Imdb(opt) => Box::pin(opt.run()).await, + Options::LargeValues(opt) => opt.run().await, Options::Nlj(opt) => opt.run().await, Options::Smj(opt) => opt.run().await, Options::SortPushdown(opt) => opt.run().await, diff --git a/benchmarks/src/large_values.rs b/benchmarks/src/large_values.rs new file mode 100644 index 0000000000000..594354a7ccebd --- /dev/null +++ b/benchmarks/src/large_values.rs @@ -0,0 +1,322 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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. + +//! Benchmark for tables with very large row values (multi-KiB strings). +//! +//! With such data, a batch that respects the row-based `batch_size` limit +//! (8192 rows) can still be hundreds of MiB in memory, which stresses +//! byte-blind operators: sorts reserve ~2x the batch size before buffering, +//! aggregations materialize huge transient state, and joins move huge +//! batches through their probe side. Existing suites (TPC-H, ClickBench) +//! have ~1MiB batches and never hit this regime. +//! +//! The dataset is generated on first use: `--gen-rows` rows of +//! (id BIGINT, key BIGINT, val VARCHAR) split over `--gen-files` files, +//! where `val` is a random alphanumeric string of `--gen-value-size` bytes +//! (incompressible, so decoded batches are as large as they look). +//! +//! Intended usage is an A/B of `datafusion.execution.target_batch_size_bytes` +//! (e.g. via the `DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES` environment +//! variable), optionally with `--memory-limit` to test whether queries that +//! exhaust memory on oversized batches can complete when batches are +//! normalized. + +use std::fs; +use std::fs::File; +use std::path::PathBuf; +use std::sync::Arc; + +use arrow::array::{ArrayRef, Int64Array, StringArray}; +use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; +use arrow::record_batch::RecordBatch; +use clap::Args; +use futures::StreamExt; +use parquet::arrow::ArrowWriter; +use parquet::basic::{Compression, ZstdLevel}; +use parquet::file::properties::WriterProperties; +use rand::SeedableRng; +use rand::distr::{Alphanumeric, SampleString}; +use rand::rngs::StdRng; + +use datafusion::error::Result; +use datafusion::execution::SessionStateBuilder; +use datafusion::physical_plan::display::DisplayableExecutionPlan; +use datafusion::physical_plan::{displayable, execute_stream}; +use datafusion::prelude::*; +use datafusion_common::instant::Instant; + +use crate::util::{BenchmarkRun, CommonOpt, QueryResult, print_memory_stats}; + +/// Key cardinality for the `key` column (`id % KEY_CARDINALITY`) +const KEY_CARDINALITY: i64 = 1000; + +/// Rows generated per append to keep generation memory bounded +const GEN_CHUNK_ROWS: usize = 512; + +#[derive(Debug, Args)] +pub struct RunOpt { + /// Common options + #[command(flatten)] + common: CommonOpt, + + /// Query number. If not specified, runs all queries + #[arg(short, long)] + pub query: Option, + + /// Directory for the generated dataset + #[arg(required = true, short = 'p', long = "path")] + path: PathBuf, + + /// Path to JSON benchmark result to be compared using `compare.py` + #[arg(short = 'o', long = "output")] + output_path: Option, + + /// Total number of rows to generate + #[arg(long = "gen-rows", default_value = "65536")] + gen_rows: usize, + + /// Number of parquet files to split the dataset into + #[arg(long = "gen-files", default_value = "8")] + gen_files: usize, + + /// Size in bytes of each `val` string value + #[arg(long = "gen-value-size", default_value = "16384")] + gen_value_size: usize, + + /// Regenerate the dataset even if it already exists + #[arg(long = "regenerate")] + regenerate: bool, +} + +pub const LARGE_VALUES_QUERY_START_ID: usize = 1; +pub const LARGE_VALUES_QUERY_END_ID: usize = 5; + +/// Queries chosen to stress one byte-blind operator each. `count(*)` / +/// drained-stream shapes keep result sets small so the benchmark measures +/// the operators, not result materialization. +const LARGE_VALUES_QUERIES: [&str; 5] = [ + // Q1: scan + filter on the large values (baseline for the cost of + // re-chunking itself: scan-bound, no stateful operator) + r#" + SELECT count(*) + FROM large_values + WHERE val LIKE '%qq%' + "#, + // Q2: full sort, small key, large payload rows + r#" + SELECT key, val + FROM large_values + ORDER BY key + "#, + // Q3: full sort keyed on the large values themselves + r#" + SELECT val + FROM large_values + ORDER BY val + "#, + // Q4: aggregation with large-value accumulator state + r#" + SELECT key, min(val), max(val) + FROM large_values + GROUP BY key + "#, + // Q5: hash join with a modest build side; huge batches flow through + // the probe side and the join output + r#" + SELECT count(*) + FROM large_values a + JOIN (SELECT id, val FROM large_values WHERE key < 20) b + ON a.id = b.id + WHERE a.val != b.val + "#, +]; + +impl RunOpt { + pub async fn run(&self) -> Result<()> { + self.generate_data_if_needed()?; + + let query_range = match self.query { + Some(query_id) => query_id..=query_id, + None => LARGE_VALUES_QUERY_START_ID..=LARGE_VALUES_QUERY_END_ID, + }; + + let mut benchmark_run = BenchmarkRun::new(); + for query_id in query_range { + benchmark_run.start_new_case(&format!("{query_id}")); + + match self.benchmark_query(query_id).await { + Ok(query_results) => { + for iter in query_results { + benchmark_run.write_iter(iter.elapsed, iter.row_count); + } + } + Err(e) => { + benchmark_run.mark_failed(); + eprintln!("Query {query_id} failed: {e}"); + } + } + } + + benchmark_run.maybe_write_json(self.output_path.as_ref())?; + benchmark_run.maybe_print_failures(); + Ok(()) + } + + async fn benchmark_query(&self, query_id: usize) -> Result> { + let config = self.common.config()?; + let rt = self.common.build_runtime()?; + let state = SessionStateBuilder::new() + .with_config(config) + .with_runtime_env(rt) + .with_default_features() + .build(); + let ctx = SessionContext::from(state); + + let path = self.path.to_str().unwrap(); + ctx.register_parquet("large_values", path, ParquetReadOptions::default()) + .await?; + + let mut millis = vec![]; + let mut query_results = vec![]; + for i in 0..self.common.iterations { + let start = Instant::now(); + let sql = LARGE_VALUES_QUERIES[query_id - 1]; + let row_count = self.execute_query(&ctx, sql).await?; + let elapsed = start.elapsed(); + let ms = elapsed.as_secs_f64() * 1000.0; + millis.push(ms); + + println!( + "Query {query_id} iteration {i} took {ms:.1} ms and returned {row_count} rows" + ); + query_results.push(QueryResult { elapsed, row_count }); + } + + let avg = millis.iter().sum::() / millis.len() as f64; + println!("Query {query_id} avg time: {avg:.2} ms"); + print_memory_stats(); + + Ok(query_results) + } + + async fn execute_query(&self, ctx: &SessionContext, sql: &str) -> Result { + let debug = self.common.debug; + let plan = ctx.sql(sql).await?; + let (state, plan) = plan.into_parts(); + let plan = state.optimize(&plan)?; + let physical_plan = state.create_physical_plan(&plan).await?; + if debug { + println!( + "=== Physical plan ===\n{}\n", + displayable(physical_plan.as_ref()).indent(true) + ); + } + + // Drain the stream instead of collecting: sorted output of this + // dataset is ~1GiB and buffering it would dominate the measurement + let mut row_count = 0; + let mut stream = execute_stream(physical_plan.clone(), state.task_ctx())?; + while let Some(batch) = stream.next().await { + row_count += batch?.num_rows(); + } + + if debug { + println!( + "=== Physical plan with metrics ===\n{}\n", + DisplayableExecutionPlan::with_metrics(physical_plan.as_ref()) + .indent(true) + ); + } + Ok(row_count) + } + + fn schema() -> SchemaRef { + Arc::new(Schema::new(vec![ + Field::new("id", DataType::Int64, false), + Field::new("key", DataType::Int64, false), + Field::new("val", DataType::Utf8, false), + ])) + } + + fn generate_data_if_needed(&self) -> Result<()> { + let marker = self.path.join(format!( + "large_values_r{}_f{}_v{}.ok", + self.gen_rows, self.gen_files, self.gen_value_size + )); + if marker.exists() && !self.regenerate { + return Ok(()); + } + if self.path.exists() { + fs::remove_dir_all(&self.path)?; + } + fs::create_dir_all(&self.path)?; + + println!( + "Generating {} rows x {} byte values over {} files in {}...", + self.gen_rows, + self.gen_value_size, + self.gen_files, + self.path.display() + ); + let start = Instant::now(); + let schema = Self::schema(); + let rows_per_file = self.gen_rows.div_ceil(self.gen_files); + let props = WriterProperties::builder() + .set_compression(Compression::ZSTD(ZstdLevel::try_new(1)?)) + .build(); + + for file_idx in 0..self.gen_files { + let file_path = self.path.join(format!("part-{file_idx}.parquet")); + let file = File::create(&file_path)?; + let mut writer = + ArrowWriter::try_new(file, Arc::clone(&schema), Some(props.clone()))?; + // deterministic per-file seed for reproducibility + let mut rng = StdRng::seed_from_u64(42 + file_idx as u64); + + let file_start = file_idx * rows_per_file; + let file_rows = rows_per_file.min(self.gen_rows.saturating_sub(file_start)); + let mut written = 0; + while written < file_rows { + let n = GEN_CHUNK_ROWS.min(file_rows - written); + let base = (file_start + written) as i64; + let ids = Int64Array::from_iter_values(base..base + n as i64); + let keys = Int64Array::from_iter_values( + (base..base + n as i64).map(|id| id % KEY_CARDINALITY), + ); + let vals = + StringArray::from_iter_values((0..n).map(|_| { + Alphanumeric.sample_string(&mut rng, self.gen_value_size) + })); + let batch = RecordBatch::try_new( + Arc::clone(&schema), + vec![ + Arc::new(ids) as ArrayRef, + Arc::new(keys) as ArrayRef, + Arc::new(vals) as ArrayRef, + ], + )?; + writer.write(&batch)?; + written += n; + } + writer.close()?; + } + + fs::write(&marker, b"")?; + println!("Generated in {:.1}s", start.elapsed().as_secs_f64()); + Ok(()) + } +} diff --git a/benchmarks/src/lib.rs b/benchmarks/src/lib.rs index 8d24d44a174e3..96426f6047b6d 100644 --- a/benchmarks/src/lib.rs +++ b/benchmarks/src/lib.rs @@ -22,6 +22,7 @@ pub mod dict; pub mod h2o; pub mod hj; pub mod imdb; +pub mod large_values; pub mod nlj; pub mod smj; pub mod sort_pushdown; From 88bdade5af02425e251de9d0b071a652d3483803 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 11:25:29 -0500 Subject: [PATCH 04/11] feat: bound sort and merge output batches by target_batch_size_bytes The sorter and streaming merge re-chunk their output at batch_size rows only, so wide rows rebuild oversized batches downstream of a normalized scan: sorting 536MB decoded batches under a 2GB limit failed in the merge phase with ~1.1GB ExternalSorterMerge reservations (sized by the largest spilled batch) and a single 639MB SortPreservingMergeExec grow. When datafusion.execution.target_batch_size_bytes is set: - IncrementalSortIterator (sorted-output chunking, also used by the aggregate spill path) reduces its chunk row count so chunks are about the byte target - BatchBuilder tracks the estimated bytes of in-progress rows and the streaming merge emits when the row count OR the byte target is reached, plumbed through StreamingMergeBuilder/MultiLevelMergeBuilder and read from session config by SortExec, SortPreservingMergeExec and GroupedHashAggregateStream Unset (default) keeps row-only chunking, byte-for-byte. With this, the large_values 64KiB benchmark (536MB decoded batches, 2GB memory limit) goes from ResourcesExhausted to completing: spill file batches shrink to the byte target, cutting merge reservations from ~1.1GB to ~128MB per partition. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- .../src/aggregates/grouped_hash_stream.rs | 13 ++ datafusion/physical-plan/src/sorts/builder.rs | 82 +++++++++++- datafusion/physical-plan/src/sorts/merge.rs | 14 +- .../src/sorts/multi_level_merge.rs | 6 + datafusion/physical-plan/src/sorts/sort.rs | 125 +++++++++++++++++- .../src/sorts/sort_preserving_merge.rs | 65 +++++++++ datafusion/physical-plan/src/sorts/stream.rs | 17 ++- .../src/sorts/streaming_merge.rs | 28 +++- 8 files changed, 331 insertions(+), 19 deletions(-) diff --git a/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs b/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs index 0d00e5c4d0d86..87cf9beb28f5d 100644 --- a/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs +++ b/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs @@ -306,6 +306,11 @@ pub(crate) struct GroupedHashAggregateStream { /// max rows in output RecordBatches batch_size: usize, + /// Soft byte-size target for spill and spill-merge batches (from + /// `datafusion.execution.target_batch_size_bytes`); `None` bounds + /// them by row count only + target_batch_size_bytes: Option, + /// Optional soft limit on the number of `group_values` in a batch /// If the number of `group_values` in a single batch exceeds this value, /// the `GroupedHashAggregateStream` operation immediately switches to @@ -390,6 +395,11 @@ impl GroupedHashAggregateStream { let agg_filter_expr = Arc::clone(&agg.filter_expr); let batch_size = context.session_config().batch_size(); + let target_batch_size_bytes = context + .session_config() + .options() + .execution + .target_batch_size_bytes; let input = agg.input.execute(partition, Arc::clone(context))?; let baseline_metrics = BaselineMetrics::new(&agg.metrics, partition); let group_by_metrics = GroupByMetrics::new(&agg.metrics, partition); @@ -605,6 +615,7 @@ impl GroupedHashAggregateStream { baseline_metrics, group_by_metrics, batch_size, + target_batch_size_bytes, group_ordering, input_done: false, spill_state, @@ -1204,6 +1215,7 @@ impl GroupedHashAggregateStream { emit, self.spill_state.spill_expr.clone(), self.batch_size, + self.target_batch_size_bytes, ); let spillfile = self .spill_state @@ -1297,6 +1309,7 @@ impl GroupedHashAggregateStream { .with_expressions(&self.spill_state.spill_expr) .with_metrics(self.baseline_metrics.clone()) .with_batch_size(self.batch_size) + .with_batch_size_bytes(self.target_batch_size_bytes) .with_reservation(self.reservation.new_empty()) .build()?; self.input_done = false; diff --git a/datafusion/physical-plan/src/sorts/builder.rs b/datafusion/physical-plan/src/sorts/builder.rs index 75eb2ff980325..e163ae39f1247 100644 --- a/datafusion/physical-plan/src/sorts/builder.rs +++ b/datafusion/physical-plan/src/sorts/builder.rs @@ -32,6 +32,9 @@ struct BatchCursor { batch_idx: usize, /// The row index within the given batch row_idx: usize, + /// Estimated in-memory bytes per row of the current batch, used to + /// track the byte size of in-progress output rows + bytes_per_row: usize, } /// Provides an API to incrementally build a [`RecordBatch`] from partitioned [`RecordBatch`] @@ -67,14 +70,26 @@ pub struct BatchBuilder { /// The accumulated stream indexes from which to pull rows /// Consists of a tuple of `(batch_idx, row_idx)` indices: Vec<(usize, usize)>, + + /// Emit an output batch once the estimated bytes of in-progress rows + /// reach this target, even if fewer than `batch_size` rows are buffered. + /// `None` disables byte-based emission (row-count only). + target_bytes: Option, + + /// Estimated in-memory bytes of the in-progress rows + in_progress_bytes: usize, } impl BatchBuilder { - /// Create a new [`BatchBuilder`] with the provided `stream_count` and `batch_size` + /// Create a new [`BatchBuilder`] with the provided `stream_count` and + /// `batch_size`. If `target_bytes` is set, [`Self::byte_target_reached`] + /// reports when the in-progress rows reach that estimated size so the + /// caller can emit byte-bounded batches. pub fn new( schema: SchemaRef, stream_count: usize, batch_size: usize, + target_bytes: Option, reservation: MemoryReservation, ) -> Self { let initial_reservation = reservation.size(); @@ -86,6 +101,8 @@ impl BatchBuilder { reservation, batches_mem_used: 0, initial_reservation, + target_bytes, + in_progress_bytes: 0, } } @@ -98,10 +115,12 @@ impl BatchBuilder { // pre-reserved bytes from sort_spill_reservation_bytes). try_grow_reservation_to_at_least(&mut self.reservation, self.batches_mem_used)?; let batch_idx = self.batches.len(); + let bytes_per_row = size / batch.num_rows().max(1); self.batches.push((stream_idx, batch)); self.cursors[stream_idx] = BatchCursor { batch_idx, row_idx: 0, + bytes_per_row, }; Ok(()) } @@ -112,6 +131,14 @@ impl BatchBuilder { let row_idx = cursor.row_idx; cursor.row_idx += 1; self.indices.push((cursor.batch_idx, row_idx)); + self.in_progress_bytes += cursor.bytes_per_row; + } + + /// Returns `true` if a byte target is configured and the estimated size + /// of the in-progress rows has reached it + pub fn byte_target_reached(&self) -> bool { + self.target_bytes + .is_some_and(|target| self.in_progress_bytes >= target) } /// Returns the number of in-progress rows in this [`BatchBuilder`] @@ -154,6 +181,17 @@ impl BatchBuilder { rows_to_emit: usize, columns: Vec, ) -> Result { + // Scale the in-progress byte estimate by the fraction of rows left + // behind (only the offset-overflow partial-emit path keeps any); + // exact per-row attribution is not worth tracking here. + let total_rows = self.indices.len(); + let remaining_rows = total_rows - rows_to_emit; + self.in_progress_bytes = if remaining_rows == 0 { + 0 + } else { + (self.in_progress_bytes / total_rows.max(1)) * remaining_rows + }; + // Remove consumed indices, keeping any remaining for the next call. self.indices.drain(..rows_to_emit); @@ -341,13 +379,53 @@ mod tests { assert!(matches!(error, DataFusionError::Execution(msg) if msg == "boom")); } + #[test] + fn test_byte_target_reached() { + use arrow::array::StringArray; + // 100 rows of ~1KiB strings + let s = StringArray::from_iter_values((0..100).map(|i| format!("{i:0>1024}"))); + let schema = Arc::new(Schema::new(vec![Field::new("s", DataType::Utf8, false)])); + let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s)]).unwrap(); + + let pool: Arc = Arc::new(UnboundedMemoryPool::default()); + let reservation = MemoryConsumer::new("test").register(&pool); + let mut builder = + BatchBuilder::new(Arc::clone(&schema), 1, 8192, Some(10 * 1024), reservation); + builder.push_batch(0, batch.clone()).unwrap(); + + let mut pushed = 0; + while !builder.byte_target_reached() && pushed < 100 { + builder.push_row(0); + pushed += 1; + } + // ~10 rows of ~1KiB reach the 10KiB byte target, far below the row target + assert!(builder.byte_target_reached()); + assert!((5..=20).contains(&pushed), "pushed {pushed} rows"); + + // building the pending rows resets byte progress + let out = builder.build_record_batch().unwrap().unwrap(); + assert_eq!(out.num_rows(), pushed); + assert!(!builder.byte_target_reached()); + + // without a byte target the check never fires + let pool: Arc = Arc::new(UnboundedMemoryPool::default()); + let reservation = MemoryConsumer::new("test").register(&pool); + let mut builder = + BatchBuilder::new(Arc::clone(&schema), 1, 8192, None, reservation); + builder.push_batch(0, batch).unwrap(); + for _ in 0..100 { + builder.push_row(0); + } + assert!(!builder.byte_target_reached()); + } + #[test] fn test_try_interleave_columns_surfaces_arrow_offset_overflow() { let batch = overflow_list_batch(); let schema = batch.schema(); let pool: Arc = Arc::new(UnboundedMemoryPool::default()); let reservation = MemoryConsumer::new("test").register(&pool); - let mut builder = BatchBuilder::new(schema, 1, 2, reservation); + let mut builder = BatchBuilder::new(schema, 1, 2, None, reservation); builder.push_batch(0, batch).unwrap(); let error = builder diff --git a/datafusion/physical-plan/src/sorts/merge.rs b/datafusion/physical-plan/src/sorts/merge.rs index 4583d19e91061..ab8d246a47294 100644 --- a/datafusion/physical-plan/src/sorts/merge.rs +++ b/datafusion/physical-plan/src/sorts/merge.rs @@ -161,6 +161,7 @@ impl SortPreservingMergeStream { schema: SchemaRef, metrics: BaselineMetrics, batch_size: usize, + batch_size_bytes: Option, fetch: Option, reservation: MemoryReservation, enable_round_robin_tie_breaker: bool, @@ -168,7 +169,13 @@ impl SortPreservingMergeStream { let stream_count = streams.partitions(); Self { - in_progress: BatchBuilder::new(schema, stream_count, batch_size, reservation), + in_progress: BatchBuilder::new( + schema, + stream_count, + batch_size, + batch_size_bytes, + reservation, + ), streams, metrics, done: false, @@ -318,7 +325,9 @@ impl SortPreservingMergeStream { if self.fetch_reached() { self.done = true; self.drain_in_progress_on_done = true; - } else if self.in_progress.len() < self.batch_size { + } else if self.in_progress.len() < self.batch_size + && !self.in_progress.byte_target_reached() + { continue; } } @@ -652,6 +661,7 @@ mod tests { Arc::clone(&schema), BaselineMetrics::new(&metrics, 0), 16, + None, Some(1), reservation, true, diff --git a/datafusion/physical-plan/src/sorts/multi_level_merge.rs b/datafusion/physical-plan/src/sorts/multi_level_merge.rs index 4d108ac046eb0..54eff2a042e62 100644 --- a/datafusion/physical-plan/src/sorts/multi_level_merge.rs +++ b/datafusion/physical-plan/src/sorts/multi_level_merge.rs @@ -143,6 +143,7 @@ pub(crate) struct MultiLevelMergeBuilder { expr: LexOrdering, metrics: BaselineMetrics, batch_size: usize, + batch_size_bytes: Option, reservation: MemoryReservation, fetch: Option, enable_round_robin_tie_breaker: bool, @@ -164,6 +165,7 @@ impl MultiLevelMergeBuilder { expr: LexOrdering, metrics: BaselineMetrics, batch_size: usize, + batch_size_bytes: Option, reservation: MemoryReservation, fetch: Option, enable_round_robin_tie_breaker: bool, @@ -176,6 +178,7 @@ impl MultiLevelMergeBuilder { expr, metrics, batch_size, + batch_size_bytes, reservation, enable_round_robin_tie_breaker, fetch, @@ -376,6 +379,7 @@ impl MultiLevelMergeBuilder { .with_schema(Arc::clone(&self.schema)) .with_expressions(&self.expr) .with_batch_size(self.batch_size) + .with_batch_size_bytes(self.batch_size_bytes) .with_fetch(self.fetch) .with_metrics(if is_output { // Only add the metrics to the last run @@ -759,6 +763,7 @@ mod tests { expr, BaselineMetrics::new(&ExecutionPlanMetricsSet::new(), 0), batch_size, + None, reservation, None, false, @@ -938,6 +943,7 @@ mod tests { expr, metrics, 1024, + None, reservation, None, false, diff --git a/datafusion/physical-plan/src/sorts/sort.rs b/datafusion/physical-plan/src/sorts/sort.rs index 792c432155a8b..e796633ab374e 100644 --- a/datafusion/physical-plan/src/sorts/sort.rs +++ b/datafusion/physical-plan/src/sorts/sort.rs @@ -218,6 +218,12 @@ struct ExternalSorter { expr: LexOrdering, /// The target number of rows for output batches batch_size: usize, + /// Soft byte-size target for output batches (from + /// `datafusion.execution.target_batch_size_bytes`): sorted output chunks + /// and merged batches are additionally bounded to about this many bytes, + /// so wide rows do not produce arbitrarily large batches. `None` bounds + /// output by row count only. + target_batch_size_bytes: Option, /// If the in size of buffered memory batches is below this size, /// the data will be concatenated and sorted in place rather than /// sort/merged. @@ -273,6 +279,7 @@ impl ExternalSorter { schema: SchemaRef, expr: LexOrdering, batch_size: usize, + target_batch_size_bytes: Option, sort_spill_reservation_bytes: usize, sort_in_place_threshold_bytes: usize, // Configured via `datafusion.execution.spill_compression`. @@ -308,6 +315,7 @@ impl ExternalSorter { merge_reservation, runtime, batch_size, + target_batch_size_bytes, sort_spill_reservation_bytes, sort_in_place_threshold_bytes, }) @@ -365,6 +373,7 @@ impl ExternalSorter { .with_expressions(&self.expr.clone()) .with_metrics(self.metrics.baseline.clone()) .with_batch_size(self.batch_size) + .with_batch_size_bytes(self.target_batch_size_bytes) .with_fetch(None) .with_reservation(self.merge_reservation.take()) .build() @@ -664,6 +673,7 @@ impl ExternalSorter { self.metrics.baseline.intermediate() }) .with_batch_size(self.batch_size) + .with_batch_size_bytes(self.target_batch_size_bytes) .with_fetch(None) .with_reservation(self.merge_reservation.new_empty()) .build() @@ -743,12 +753,14 @@ impl ExternalSorter { let schema = batch.schema(); let expressions = self.expr.clone(); let batch_size = self.batch_size; + let target_bytes = self.target_batch_size_bytes; let stream = futures::stream::once(async move { let schema = batch.schema(); // Sort the batch immediately and get all output batches - let sorted_batches = sort_batch_chunked(&batch, &expressions, batch_size)?; + let sorted_batches = + sort_batch_chunked(&batch, &expressions, batch_size, target_bytes)?; // Resize the reservation to match the actual sorted output size. // Using try_resize avoids a release-then-reacquire cycle, which @@ -916,12 +928,22 @@ pub fn sort_batch( /// Sort a batch and return the result as multiple batches of size `batch_size`. /// This is useful when you want to avoid creating one large sorted batch in memory, /// and instead want to process the sorted data in smaller chunks. +/// +/// If `target_bytes` is set, chunks are additionally bounded to about that +/// many bytes each (wide rows would otherwise produce huge chunks). pub fn sort_batch_chunked( batch: &RecordBatch, expressions: &LexOrdering, batch_size: usize, + target_bytes: Option, ) -> Result> { - IncrementalSortIterator::new(batch.clone(), expressions.clone(), batch_size).collect() + IncrementalSortIterator::new( + batch.clone(), + expressions.clone(), + batch_size, + target_bytes, + ) + .collect() } /// Sort execution plan. @@ -1381,6 +1403,7 @@ impl ExecutionPlan for SortExec { input.schema(), self.expr.clone(), context.session_config().batch_size(), + execution_options.target_batch_size_bytes, execution_options.sort_spill_reservation_bytes, execution_options.sort_in_place_threshold_bytes, context.session_config().spill_compression(), @@ -2889,6 +2912,93 @@ mod tests { Ok((sorted_batches, metrics)) } + #[tokio::test] + async fn test_sort_batch_chunked_byte_target() -> Result<()> { + use arrow::array::StringArray; + // 100 rows x ~1KiB strings (~100KiB): an 8KiB byte target must + // produce many small chunks even though 100 rows < batch_size + let schema = Arc::new(Schema::new(vec![Field::new("s", DataType::Utf8, false)])); + let s = + StringArray::from_iter_values((0..100).rev().map(|i| format!("{i:0>1024}"))); + let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s)])?; + + let expressions: LexOrdering = + [PhysicalSortExpr::new_default(Arc::new(Column::new("s", 0)))].into(); + + let target_bytes = 8 * 1024; + let result_batches = + sort_batch_chunked(&batch, &expressions, 1000, Some(target_bytes))?; + + assert!( + result_batches.len() > 1, + "expected byte target to split the sorted output" + ); + let mut total_rows = 0; + for chunk in &result_batches { + assert!( + get_record_batch_memory_size(chunk) <= 2 * target_bytes, + "chunk of {} bytes exceeds byte target", + get_record_batch_memory_size(chunk) + ); + total_rows += chunk.num_rows(); + } + assert_eq!(total_rows, 100); + + // Concatenated output must equal a full sort of the input + let expected = sort_batch(&batch, &expressions, None)?; + let actual = concat_batches(&schema, &result_batches)?; + assert_eq!(expected, actual); + Ok(()) + } + + #[tokio::test] + async fn test_sort_exec_byte_bounded_output() -> Result<()> { + use arrow::array::StringArray; + // Multiple wide-row input batches; with target_batch_size_bytes set, + // the sorted output batches must be bounded by bytes, not just rows + let schema = Arc::new(Schema::new(vec![Field::new("s", DataType::Utf8, false)])); + let batches: Vec = (0..4) + .map(|b| { + let s = StringArray::from_iter_values( + (0..50).map(|i| format!("{:0>1024}", (b * 50 + i * 7919) % 200)), + ); + RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s)]).unwrap() + }) + .collect(); + + let target_bytes = 16 * 1024; + let mut config = SessionConfig::new(); + config.options_mut().execution.target_batch_size_bytes = Some(target_bytes); + let task_ctx = Arc::new(TaskContext::default().with_session_config(config)); + + let plan = TestMemoryExec::try_new_exec( + std::slice::from_ref(&batches), + Arc::clone(&schema), + None, + )?; + let sort_exec = Arc::new(SortExec::new( + [PhysicalSortExpr::new_default(Arc::new(Column::new("s", 0)))].into(), + plan, + )); + let result = collect(sort_exec, task_ctx).await?; + + assert!( + result.len() > 1, + "expected byte-bounded output batches, got {}", + result.len() + ); + let total_rows: usize = result.iter().map(|b| b.num_rows()).sum(); + assert_eq!(total_rows, 200); + for batch in &result { + assert!( + get_record_batch_memory_size(batch) <= 2 * target_bytes, + "output batch of {} bytes exceeds byte target", + get_record_batch_memory_size(batch) + ); + } + Ok(()) + } + #[tokio::test] async fn test_sort_batch_chunked_basic() -> Result<()> { let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)])); @@ -2907,7 +3017,7 @@ mod tests { [PhysicalSortExpr::new_default(Arc::new(Column::new("a", 0)))].into(); // Sort with batch_size = 250 - let result_batches = sort_batch_chunked(&batch, &expressions, 250)?; + let result_batches = sort_batch_chunked(&batch, &expressions, 250, None)?; // Verify 4 batches are returned assert_eq!(result_batches.len(), 4); @@ -2960,7 +3070,7 @@ mod tests { [PhysicalSortExpr::new_default(Arc::new(Column::new("a", 0)))].into(); // Sort with batch_size = 100 - let result_batches = sort_batch_chunked(&batch, &expressions, 100)?; + let result_batches = sort_batch_chunked(&batch, &expressions, 100, None)?; // Should return exactly 1 batch assert_eq!(result_batches.len(), 1); @@ -2992,7 +3102,7 @@ mod tests { [PhysicalSortExpr::new_default(Arc::new(Column::new("a", 0)))].into(); // Sort with batch_size = 100 - let result_batches = sort_batch_chunked(&batch, &expressions, 100)?; + let result_batches = sort_batch_chunked(&batch, &expressions, 100, None)?; // Should return exactly 10 batches of 100 rows each assert_eq!(result_batches.len(), 10); @@ -3019,7 +3129,7 @@ mod tests { let expressions: LexOrdering = [PhysicalSortExpr::new_default(Arc::new(Column::new("a", 0)))].into(); - let result_batches = sort_batch_chunked(&batch, &expressions, 100)?; + let result_batches = sort_batch_chunked(&batch, &expressions, 100, None)?; // Empty input produces no output batches (0 chunks) assert_eq!(result_batches.len(), 0); @@ -3273,7 +3383,8 @@ mod tests { 0, Arc::clone(&schema), [PhysicalSortExpr::new_default(Arc::new(Column::new("x", 0)))].into(), - 128, // batch_size + 128, // batch_size + None, // target_batch_size_bytes sort_spill_reservation_bytes, usize::MAX, // sort_in_place_threshold_bytes (high to avoid concat path) SpillCompression::Uncompressed, diff --git a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs index 77a7d8f8f2e11..9fbdefab43d6c 100644 --- a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs +++ b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs @@ -363,6 +363,13 @@ impl ExecutionPlan for SortPreservingMergeExec { .with_expressions(&self.expr) .with_metrics(BaselineMetrics::new(&self.metrics, partition)) .with_batch_size(context.session_config().batch_size()) + .with_batch_size_bytes( + context + .session_config() + .options() + .execution + .target_batch_size_bytes, + ) .with_fetch(self.fetch) .with_reservation(reservation) .with_round_robin_tie_breaker(self.enable_round_robin_repartition) @@ -838,6 +845,64 @@ mod tests { Ok(()) } + #[tokio::test] + async fn test_merge_byte_bounded_output() { + use crate::spill::get_record_batch_memory_size; + use crate::stream::RecordBatchStreamAdapter; + use arrow::array::StringArray; + use datafusion_execution::memory_pool::{MemoryPool, UnboundedMemoryPool}; + + // Two sorted streams of wide rows (~1KiB strings). With a byte + // target set, merged output batches must be bounded by bytes even + // though the row target (8192) is never reached. + let schema = Arc::new(Schema::new(vec![Field::new("s", DataType::Utf8, false)])); + let make_stream = |offset: usize| -> SendableRecordBatchStream { + let s = StringArray::from_iter_values( + (0..100).map(|i| format!("{:0>1024}", 2 * i + offset)), + ); + let batch = + RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s)]).unwrap(); + Box::pin(RecordBatchStreamAdapter::new( + Arc::clone(&schema), + futures::stream::iter(vec![Ok(batch)]), + )) + }; + + let exprs: LexOrdering = + [PhysicalSortExpr::new_default(col("s", &schema).unwrap())].into(); + let target_bytes = 16 * 1024; + + let merged = StreamingMergeBuilder::new() + .with_streams(vec![make_stream(0), make_stream(1)]) + .with_schema(Arc::clone(&schema)) + .with_expressions(&exprs) + .with_metrics(BaselineMetrics::new(&ExecutionPlanMetricsSet::new(), 0)) + .with_batch_size(8192) + .with_batch_size_bytes(Some(target_bytes)) + .with_reservation({ + let pool: Arc = Arc::new(UnboundedMemoryPool::default()); + MemoryConsumer::new("test").register(&pool) + }) + .build() + .unwrap(); + + let batches = common::collect(merged).await.unwrap(); + assert!( + batches.len() > 1, + "expected byte target to bound merged batches, got {}", + batches.len() + ); + let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum(); + assert_eq!(total_rows, 200); + for batch in &batches { + assert!( + get_record_batch_memory_size(batch) <= 2 * target_bytes, + "merged batch of {} bytes exceeds byte target", + get_record_batch_memory_size(batch) + ); + } + } + // Split the provided record batch into multiple batch_size record batches fn split_batch(sorted: &RecordBatch, batch_size: usize) -> Vec { let batches = sorted.num_rows().div_ceil(batch_size); diff --git a/datafusion/physical-plan/src/sorts/stream.rs b/datafusion/physical-plan/src/sorts/stream.rs index 107631074ed3d..31da91523a606 100644 --- a/datafusion/physical-plan/src/sorts/stream.rs +++ b/datafusion/physical-plan/src/sorts/stream.rs @@ -16,6 +16,7 @@ // under the License. use crate::sorts::cursor::{ArrayValues, CursorArray, RowValues}; +use crate::spill::get_record_batch_memory_size; use crate::{EmptyRecordBatchStream, SendableRecordBatchStream}; use crate::{PhysicalExpr, PhysicalSortExpr}; use arrow::array::{Array, UInt32Array}; @@ -316,11 +317,25 @@ pub(crate) struct IncrementalSortIterator { } impl IncrementalSortIterator { + /// Create a new iterator yielding sorted chunks of at most `batch_size` + /// rows. If `target_bytes` is set, the chunk row count is further reduced + /// so each chunk's estimated in-memory size is about `target_bytes`, + /// bounding output batches by bytes as well as rows (wide rows would + /// otherwise produce arbitrarily large chunks). pub(crate) fn new( batch: RecordBatch, expressions: LexOrdering, batch_size: usize, + target_bytes: Option, ) -> Self { + let batch_size = match target_bytes { + Some(target) if batch.num_rows() > 0 => { + let bytes_per_row = + (get_record_batch_memory_size(&batch) / batch.num_rows()).max(1); + (target / bytes_per_row).clamp(1, batch_size) + } + _ => batch_size, + }; Self { batch, expressions, @@ -430,7 +445,7 @@ mod tests { .unwrap(); let mut total_rows = 0; - IncrementalSortIterator::new(batch.clone(), expressions, batch_size).try_for_each( + IncrementalSortIterator::new(batch.clone(), expressions, batch_size, None).try_for_each( |result| { let chunk = result?; total_rows += chunk.num_rows(); diff --git a/datafusion/physical-plan/src/sorts/streaming_merge.rs b/datafusion/physical-plan/src/sorts/streaming_merge.rs index ade24ff0534ff..461728c8480c3 100644 --- a/datafusion/physical-plan/src/sorts/streaming_merge.rs +++ b/datafusion/physical-plan/src/sorts/streaming_merge.rs @@ -43,7 +43,7 @@ macro_rules! primitive_merge_helper { } macro_rules! merge_helper { - ($t:ty, $sort:ident, $streams:ident, $schema:ident, $tracking_metrics:ident, $batch_size:ident, $fetch:ident, $reservation:ident, $enable_round_robin_tie_breaker:ident) => {{ + ($t:ty, $sort:ident, $streams:ident, $schema:ident, $tracking_metrics:ident, $batch_size:ident, $batch_size_bytes:ident, $fetch:ident, $reservation:ident, $enable_round_robin_tie_breaker:ident) => {{ let streams = FieldCursorStream::<$t>::new($sort, $streams, $reservation.new_empty()); return Ok(Box::pin(SortPreservingMergeStream::new( @@ -51,6 +51,7 @@ macro_rules! merge_helper { $schema, $tracking_metrics, $batch_size, + $batch_size_bytes, $fetch, $reservation, $enable_round_robin_tie_breaker, @@ -92,6 +93,7 @@ pub struct StreamingMergeBuilder<'a> { expressions: Option<&'a LexOrdering>, metrics: Option, batch_size: Option, + batch_size_bytes: Option, fetch: Option, reservation: Option, enable_round_robin_tie_breaker: bool, @@ -143,6 +145,15 @@ impl<'a> StreamingMergeBuilder<'a> { self } + /// Also emit an output batch whenever the estimated size of the + /// in-progress rows reaches `batch_size_bytes`, so that wide rows do not + /// produce arbitrarily large merged batches. `None` (the default) emits + /// on row count only. + pub fn with_batch_size_bytes(mut self, batch_size_bytes: Option) -> Self { + self.batch_size_bytes = batch_size_bytes; + self + } + pub fn with_fetch(mut self, fetch: Option) -> Self { self.fetch = fetch; self @@ -184,6 +195,7 @@ impl<'a> StreamingMergeBuilder<'a> { schema, metrics, batch_size, + batch_size_bytes, reservation, fetch, expressions, @@ -212,6 +224,7 @@ impl<'a> StreamingMergeBuilder<'a> { expressions.clone(), metrics, batch_size, + batch_size_bytes, reservation, fetch, enable_round_robin_tie_breaker, @@ -238,12 +251,12 @@ impl<'a> StreamingMergeBuilder<'a> { let sort = expressions[0].clone(); let data_type = sort.expr.data_type(schema.as_ref())?; downcast_primitive! { - data_type => (primitive_merge_helper, sort, streams, schema, metrics, batch_size, fetch, reservation, enable_round_robin_tie_breaker), - DataType::Utf8 => merge_helper!(StringArray, sort, streams, schema, metrics, batch_size, fetch, reservation, enable_round_robin_tie_breaker) - DataType::Utf8View => merge_helper!(StringViewArray, sort, streams, schema, metrics, batch_size, fetch, reservation, enable_round_robin_tie_breaker) - DataType::LargeUtf8 => merge_helper!(LargeStringArray, sort, streams, schema, metrics, batch_size, fetch, reservation, enable_round_robin_tie_breaker) - DataType::Binary => merge_helper!(BinaryArray, sort, streams, schema, metrics, batch_size, fetch, reservation, enable_round_robin_tie_breaker) - DataType::LargeBinary => merge_helper!(LargeBinaryArray, sort, streams, schema, metrics, batch_size, fetch, reservation, enable_round_robin_tie_breaker) + data_type => (primitive_merge_helper, sort, streams, schema, metrics, batch_size, batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker), + DataType::Utf8 => merge_helper!(StringArray, sort, streams, schema, metrics, batch_size, batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker) + DataType::Utf8View => merge_helper!(StringViewArray, sort, streams, schema, metrics, batch_size, batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker) + DataType::LargeUtf8 => merge_helper!(LargeStringArray, sort, streams, schema, metrics, batch_size, batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker) + DataType::Binary => merge_helper!(BinaryArray, sort, streams, schema, metrics, batch_size, batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker) + DataType::LargeBinary => merge_helper!(LargeBinaryArray, sort, streams, schema, metrics, batch_size, batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker) _ => {} } } @@ -259,6 +272,7 @@ impl<'a> StreamingMergeBuilder<'a> { schema, metrics, batch_size, + batch_size_bytes, fetch, reservation, enable_round_robin_tie_breaker, From 344402be74d97f0cd3f2744388c1d86bfdc10f23 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 11:33:39 -0500 Subject: [PATCH 05/11] docs: extend target_batch_size_bytes description to sort/merge/agg spill output Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- ab_results/clickbench_off_r1.json | 838 ++++++++ ab_results/clickbench_off_r2.json | 838 ++++++++ ab_results/clickbench_on_r1.json | 838 ++++++++ ab_results/clickbench_on_r2.json | 838 ++++++++ ab_results/lv-mem2g_off_r1.json | 78 + ab_results/lv-mem2g_off_r2.json | 78 + ab_results/lv-mem2g_on_r1.json | 78 + ab_results/lv-mem2g_on_r2.json | 78 + ab_results/lv-unlimited_off_r1.json | 114 + ab_results/lv-unlimited_off_r2.json | 114 + ab_results/lv-unlimited_on_r1.json | 114 + ab_results/lv-unlimited_on_r2.json | 114 + ab_results/tpcds_off_r1.json | 1891 +++++++++++++++++ ab_results/tpcds_off_r2.json | 1891 +++++++++++++++++ ab_results/tpcds_on_r1.json | 1891 +++++++++++++++++ ab_results/tpcds_on_r2.json | 1891 +++++++++++++++++ ab_results/tpch_off_r1.json | 439 ++++ ab_results/tpch_off_r2.json | 439 ++++ ab_results/tpch_on_r1.json | 439 ++++ ab_results/tpch_on_r2.json | 439 ++++ analyze_ab.py | 51 + bench_ab.log | 22 + bench_run.log | 568 +++++ datafusion/common/src/config.rs | 21 +- .../test_files/information_schema.slt | 2 +- docs/source/user-guide/configs.md | 2 +- lv_ab.log | 55 + pr_body.md | 48 + rerun_tpch.sh | 18 + run_benchmarks.sh | 49 + run_benchmarks2.sh | 52 + run_lv_ab.sh | 36 + test_suite2.log | 1 + test_suite_output.log | 81 + 34 files changed, 14435 insertions(+), 11 deletions(-) create mode 100644 ab_results/clickbench_off_r1.json create mode 100644 ab_results/clickbench_off_r2.json create mode 100644 ab_results/clickbench_on_r1.json create mode 100644 ab_results/clickbench_on_r2.json create mode 100644 ab_results/lv-mem2g_off_r1.json create mode 100644 ab_results/lv-mem2g_off_r2.json create mode 100644 ab_results/lv-mem2g_on_r1.json create mode 100644 ab_results/lv-mem2g_on_r2.json create mode 100644 ab_results/lv-unlimited_off_r1.json create mode 100644 ab_results/lv-unlimited_off_r2.json create mode 100644 ab_results/lv-unlimited_on_r1.json create mode 100644 ab_results/lv-unlimited_on_r2.json create mode 100644 ab_results/tpcds_off_r1.json create mode 100644 ab_results/tpcds_off_r2.json create mode 100644 ab_results/tpcds_on_r1.json create mode 100644 ab_results/tpcds_on_r2.json create mode 100644 ab_results/tpch_off_r1.json create mode 100644 ab_results/tpch_off_r2.json create mode 100644 ab_results/tpch_on_r1.json create mode 100644 ab_results/tpch_on_r2.json create mode 100644 analyze_ab.py create mode 100644 bench_ab.log create mode 100644 bench_run.log create mode 100644 lv_ab.log create mode 100644 pr_body.md create mode 100755 rerun_tpch.sh create mode 100755 run_benchmarks.sh create mode 100755 run_benchmarks2.sh create mode 100755 run_lv_ab.sh create mode 100644 test_suite2.log create mode 100644 test_suite_output.log diff --git a/ab_results/clickbench_off_r1.json b/ab_results/clickbench_off_r1.json new file mode 100644 index 0000000000000..c4d3c192f09ea --- /dev/null +++ b/ab_results/clickbench_off_r1.json @@ -0,0 +1,838 @@ +{ + "queries": [ + { + "query": "Query 0", + "iterations": [ + { + "elapsed": 10.636792000000002, + "row_count": 1 + }, + { + "elapsed": 0.996291, + "row_count": 1 + }, + { + "elapsed": 0.752083, + "row_count": 1 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 13.110958, + "row_count": 1 + }, + { + "elapsed": 9.677332999999999, + "row_count": 1 + }, + { + "elapsed": 9.441583, + "row_count": 1 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 40.527750000000005, + "row_count": 1 + }, + { + "elapsed": 35.489875, + "row_count": 1 + }, + { + "elapsed": 35.82, + "row_count": 1 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 50.697167, + "row_count": 1 + }, + { + "elapsed": 35.816375, + "row_count": 1 + }, + { + "elapsed": 33.748124999999995, + "row_count": 1 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 284.429958, + "row_count": 1 + }, + { + "elapsed": 246.957125, + "row_count": 1 + }, + { + "elapsed": 238.5355, + "row_count": 1 + } + ], + "start_time": 1783521320, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 408.82012499999996, + "row_count": 1 + }, + { + "elapsed": 308.69625, + "row_count": 1 + }, + { + "elapsed": 297.91925000000003, + "row_count": 1 + } + ], + "start_time": 1783521320, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 2.029875, + "row_count": 1 + }, + { + "elapsed": 1.01, + "row_count": 1 + }, + { + "elapsed": 0.733583, + "row_count": 1 + } + ], + "start_time": 1783521321, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 10.715916, + "row_count": 18 + }, + { + "elapsed": 10.89125, + "row_count": 18 + }, + { + "elapsed": 13.660709, + "row_count": 18 + } + ], + "start_time": 1783521321, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 369.200042, + "row_count": 10 + }, + { + "elapsed": 390.686875, + "row_count": 10 + }, + { + "elapsed": 356.26858300000004, + "row_count": 10 + } + ], + "start_time": 1783521321, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 441.60949999999997, + "row_count": 10 + }, + { + "elapsed": 437.158708, + "row_count": 10 + }, + { + "elapsed": 469.328792, + "row_count": 10 + } + ], + "start_time": 1783521323, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 68.55791699999999, + "row_count": 10 + }, + { + "elapsed": 70.536709, + "row_count": 10 + }, + { + "elapsed": 67.517125, + "row_count": 10 + } + ], + "start_time": 1783521324, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 87.96908400000001, + "row_count": 10 + }, + { + "elapsed": 102.623542, + "row_count": 10 + }, + { + "elapsed": 95.89625000000001, + "row_count": 10 + } + ], + "start_time": 1783521324, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 358.362917, + "row_count": 10 + }, + { + "elapsed": 311.256958, + "row_count": 10 + }, + { + "elapsed": 323.571458, + "row_count": 10 + } + ], + "start_time": 1783521324, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 462.247959, + "row_count": 10 + }, + { + "elapsed": 455.317542, + "row_count": 10 + }, + { + "elapsed": 411.10049999999995, + "row_count": 10 + } + ], + "start_time": 1783521325, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 313.504917, + "row_count": 10 + }, + { + "elapsed": 291.132167, + "row_count": 10 + }, + { + "elapsed": 308.518958, + "row_count": 10 + } + ], + "start_time": 1783521327, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 268.445084, + "row_count": 10 + }, + { + "elapsed": 287.097209, + "row_count": 10 + }, + { + "elapsed": 297.423125, + "row_count": 10 + } + ], + "start_time": 1783521328, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 875.591709, + "row_count": 10 + }, + { + "elapsed": 709.986667, + "row_count": 10 + }, + { + "elapsed": 671.4042919999999, + "row_count": 10 + } + ], + "start_time": 1783521328, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 680.3142909999999, + "row_count": 10 + }, + { + "elapsed": 681.31575, + "row_count": 10 + }, + { + "elapsed": 650.4926250000001, + "row_count": 10 + } + ], + "start_time": 1783521331, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 1926.9366670000002, + "row_count": 10 + }, + { + "elapsed": 1731.15825, + "row_count": 10 + }, + { + "elapsed": 1484.126375, + "row_count": 10 + } + ], + "start_time": 1783521333, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 23.231667, + "row_count": 4 + }, + { + "elapsed": 22.635375, + "row_count": 4 + }, + { + "elapsed": 23.23025, + "row_count": 4 + } + ], + "start_time": 1783521338, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 741.956625, + "row_count": 1 + }, + { + "elapsed": 587.169709, + "row_count": 1 + }, + { + "elapsed": 578.187959, + "row_count": 1 + } + ], + "start_time": 1783521338, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 666.699625, + "row_count": 10 + }, + { + "elapsed": 676.720125, + "row_count": 10 + }, + { + "elapsed": 603.946042, + "row_count": 10 + } + ], + "start_time": 1783521340, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 1305.983, + "row_count": 10 + }, + { + "elapsed": 1215.559292, + "row_count": 10 + }, + { + "elapsed": 1496.914458, + "row_count": 10 + } + ], + "start_time": 1783521342, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 4005.849459, + "row_count": 10 + }, + { + "elapsed": 3692.944416, + "row_count": 10 + }, + { + "elapsed": 3646.3434169999996, + "row_count": 10 + } + ], + "start_time": 1783521346, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 41.810125, + "row_count": 10 + }, + { + "elapsed": 38.102083, + "row_count": 10 + }, + { + "elapsed": 42.853625, + "row_count": 10 + } + ], + "start_time": 1783521357, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 130.636833, + "row_count": 10 + }, + { + "elapsed": 133.10312499999998, + "row_count": 10 + }, + { + "elapsed": 133.94508299999998, + "row_count": 10 + } + ], + "start_time": 1783521357, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 43.594750000000005, + "row_count": 10 + }, + { + "elapsed": 40.873667000000005, + "row_count": 10 + }, + { + "elapsed": 40.230792, + "row_count": 10 + } + ], + "start_time": 1783521358, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 854.735958, + "row_count": 25 + }, + { + "elapsed": 797.480375, + "row_count": 25 + }, + { + "elapsed": 779.8305, + "row_count": 25 + } + ], + "start_time": 1783521358, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 2999.923208, + "row_count": 25 + }, + { + "elapsed": 2904.0651669999997, + "row_count": 25 + }, + { + "elapsed": 2907.92525, + "row_count": 25 + } + ], + "start_time": 1783521360, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 36.826417, + "row_count": 1 + }, + { + "elapsed": 40.079334, + "row_count": 1 + }, + { + "elapsed": 36.367458, + "row_count": 1 + } + ], + "start_time": 1783521369, + "success": true + }, + { + "query": "Query 30", + "iterations": [ + { + "elapsed": 346.85958300000004, + "row_count": 10 + }, + { + "elapsed": 354.263459, + "row_count": 10 + }, + { + "elapsed": 504.59545800000006, + "row_count": 10 + } + ], + "start_time": 1783521369, + "success": true + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 439.88624999999996, + "row_count": 10 + }, + { + "elapsed": 378.638417, + "row_count": 10 + }, + { + "elapsed": 392.276, + "row_count": 10 + } + ], + "start_time": 1783521370, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 2563.318584, + "row_count": 10 + }, + { + "elapsed": 1827.5330840000001, + "row_count": 10 + }, + { + "elapsed": 1593.9350829999998, + "row_count": 10 + } + ], + "start_time": 1783521372, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 2299.922375, + "row_count": 10 + }, + { + "elapsed": 2168.455084, + "row_count": 10 + }, + { + "elapsed": 1983.3596249999998, + "row_count": 10 + } + ], + "start_time": 1783521378, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 2131.8048329999997, + "row_count": 10 + }, + { + "elapsed": 2047.6145419999998, + "row_count": 10 + }, + { + "elapsed": 2311.581875, + "row_count": 10 + } + ], + "start_time": 1783521384, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 434.33500000000004, + "row_count": 10 + }, + { + "elapsed": 340.65979200000004, + "row_count": 10 + }, + { + "elapsed": 359.275083, + "row_count": 10 + } + ], + "start_time": 1783521391, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 52.865959, + "row_count": 10 + }, + { + "elapsed": 55.3895, + "row_count": 10 + }, + { + "elapsed": 52.296625, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 26.106333999999997, + "row_count": 10 + }, + { + "elapsed": 25.077458, + "row_count": 10 + }, + { + "elapsed": 28.070208, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 37.545584, + "row_count": 10 + }, + { + "elapsed": 52.066250000000004, + "row_count": 10 + }, + { + "elapsed": 52.099667000000004, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 151.66299999999998, + "row_count": 10 + }, + { + "elapsed": 113.709292, + "row_count": 10 + }, + { + "elapsed": 103.79125, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 10.194666999999999, + "row_count": 10 + }, + { + "elapsed": 9.335958, + "row_count": 10 + }, + { + "elapsed": 8.99325, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 9.718417, + "row_count": 10 + }, + { + "elapsed": 10.039375, + "row_count": 10 + }, + { + "elapsed": 9.251083, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 12.940125, + "row_count": 10 + }, + { + "elapsed": 7.3825, + "row_count": 10 + }, + { + "elapsed": 6.9745, + "row_count": 10 + } + ], + "start_time": 1783521392, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521319, + "arguments": [ + "clickbench", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", + "--queries-path", + "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/clickbench_off_r1.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/clickbench_off_r2.json b/ab_results/clickbench_off_r2.json new file mode 100644 index 0000000000000..cb11c7a3cc3f0 --- /dev/null +++ b/ab_results/clickbench_off_r2.json @@ -0,0 +1,838 @@ +{ + "queries": [ + { + "query": "Query 0", + "iterations": [ + { + "elapsed": 7.757499999999999, + "row_count": 1 + }, + { + "elapsed": 0.887792, + "row_count": 1 + }, + { + "elapsed": 0.668875, + "row_count": 1 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 9.309125, + "row_count": 1 + }, + { + "elapsed": 8.767083, + "row_count": 1 + }, + { + "elapsed": 8.602625, + "row_count": 1 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 32.477125, + "row_count": 1 + }, + { + "elapsed": 31.701167, + "row_count": 1 + }, + { + "elapsed": 32.687917, + "row_count": 1 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 45.721083, + "row_count": 1 + }, + { + "elapsed": 31.109667, + "row_count": 1 + }, + { + "elapsed": 34.001125, + "row_count": 1 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 242.219625, + "row_count": 1 + }, + { + "elapsed": 227.345459, + "row_count": 1 + }, + { + "elapsed": 217.208167, + "row_count": 1 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 372.05287500000003, + "row_count": 1 + }, + { + "elapsed": 295.10479200000003, + "row_count": 1 + }, + { + "elapsed": 294.87575, + "row_count": 1 + } + ], + "start_time": 1783521466, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 1.2689590000000002, + "row_count": 1 + }, + { + "elapsed": 0.964833, + "row_count": 1 + }, + { + "elapsed": 0.855792, + "row_count": 1 + } + ], + "start_time": 1783521467, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 10.750417, + "row_count": 18 + }, + { + "elapsed": 10.834709, + "row_count": 18 + }, + { + "elapsed": 10.31625, + "row_count": 18 + } + ], + "start_time": 1783521467, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 337.553625, + "row_count": 10 + }, + { + "elapsed": 339.906, + "row_count": 10 + }, + { + "elapsed": 328.210084, + "row_count": 10 + } + ], + "start_time": 1783521467, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 446.8135, + "row_count": 10 + }, + { + "elapsed": 463.572083, + "row_count": 10 + }, + { + "elapsed": 428.645875, + "row_count": 10 + } + ], + "start_time": 1783521468, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 73.835167, + "row_count": 10 + }, + { + "elapsed": 76.976958, + "row_count": 10 + }, + { + "elapsed": 64.38408299999999, + "row_count": 10 + } + ], + "start_time": 1783521469, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 83.928, + "row_count": 10 + }, + { + "elapsed": 81.287375, + "row_count": 10 + }, + { + "elapsed": 91.643625, + "row_count": 10 + } + ], + "start_time": 1783521469, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 308.034208, + "row_count": 10 + }, + { + "elapsed": 290.759083, + "row_count": 10 + }, + { + "elapsed": 306.794959, + "row_count": 10 + } + ], + "start_time": 1783521470, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 415.42675, + "row_count": 10 + }, + { + "elapsed": 441.33691699999997, + "row_count": 10 + }, + { + "elapsed": 423.31125, + "row_count": 10 + } + ], + "start_time": 1783521471, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 332.197917, + "row_count": 10 + }, + { + "elapsed": 328.54358299999996, + "row_count": 10 + }, + { + "elapsed": 336.309625, + "row_count": 10 + } + ], + "start_time": 1783521472, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 311.306125, + "row_count": 10 + }, + { + "elapsed": 311.491875, + "row_count": 10 + }, + { + "elapsed": 284.06395899999995, + "row_count": 10 + } + ], + "start_time": 1783521473, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 771.392083, + "row_count": 10 + }, + { + "elapsed": 768.158416, + "row_count": 10 + }, + { + "elapsed": 834.558625, + "row_count": 10 + } + ], + "start_time": 1783521474, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 745.640292, + "row_count": 10 + }, + { + "elapsed": 756.891125, + "row_count": 10 + }, + { + "elapsed": 735.1555, + "row_count": 10 + } + ], + "start_time": 1783521476, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 1530.485292, + "row_count": 10 + }, + { + "elapsed": 1602.7038340000001, + "row_count": 10 + }, + { + "elapsed": 1597.295125, + "row_count": 10 + } + ], + "start_time": 1783521478, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 30.804917, + "row_count": 4 + }, + { + "elapsed": 43.208917, + "row_count": 4 + }, + { + "elapsed": 24.928333000000002, + "row_count": 4 + } + ], + "start_time": 1783521483, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 674.840833, + "row_count": 1 + }, + { + "elapsed": 629.004125, + "row_count": 1 + }, + { + "elapsed": 668.372417, + "row_count": 1 + } + ], + "start_time": 1783521483, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 688.529, + "row_count": 10 + }, + { + "elapsed": 687.582541, + "row_count": 10 + }, + { + "elapsed": 661.881375, + "row_count": 10 + } + ], + "start_time": 1783521485, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 1327.140708, + "row_count": 10 + }, + { + "elapsed": 1204.883666, + "row_count": 10 + }, + { + "elapsed": 1248.022709, + "row_count": 10 + } + ], + "start_time": 1783521487, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 4146.086334, + "row_count": 10 + }, + { + "elapsed": 4009.261917, + "row_count": 10 + }, + { + "elapsed": 3679.446584, + "row_count": 10 + } + ], + "start_time": 1783521491, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 45.77425, + "row_count": 10 + }, + { + "elapsed": 43.795666, + "row_count": 10 + }, + { + "elapsed": 46.308875, + "row_count": 10 + } + ], + "start_time": 1783521503, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 126.654875, + "row_count": 10 + }, + { + "elapsed": 127.692917, + "row_count": 10 + }, + { + "elapsed": 129.76, + "row_count": 10 + } + ], + "start_time": 1783521503, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 44.640083, + "row_count": 10 + }, + { + "elapsed": 49.238791, + "row_count": 10 + }, + { + "elapsed": 42.876042000000005, + "row_count": 10 + } + ], + "start_time": 1783521503, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 804.443375, + "row_count": 25 + }, + { + "elapsed": 864.3981670000001, + "row_count": 25 + }, + { + "elapsed": 861.303333, + "row_count": 25 + } + ], + "start_time": 1783521504, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 2986.4698750000002, + "row_count": 25 + }, + { + "elapsed": 2969.160083, + "row_count": 25 + }, + { + "elapsed": 2944.488125, + "row_count": 25 + } + ], + "start_time": 1783521506, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 41.269292, + "row_count": 1 + }, + { + "elapsed": 38.260417, + "row_count": 1 + }, + { + "elapsed": 36.20375, + "row_count": 1 + } + ], + "start_time": 1783521515, + "success": true + }, + { + "query": "Query 30", + "iterations": [ + { + "elapsed": 322.893583, + "row_count": 10 + }, + { + "elapsed": 315.17212500000005, + "row_count": 10 + }, + { + "elapsed": 326.89708299999995, + "row_count": 10 + } + ], + "start_time": 1783521515, + "success": true + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 348.918333, + "row_count": 10 + }, + { + "elapsed": 350.475375, + "row_count": 10 + }, + { + "elapsed": 332.85362499999997, + "row_count": 10 + } + ], + "start_time": 1783521516, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 2308.651792, + "row_count": 10 + }, + { + "elapsed": 1625.227333, + "row_count": 10 + }, + { + "elapsed": 1441.425709, + "row_count": 10 + } + ], + "start_time": 1783521517, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 2037.6407909999998, + "row_count": 10 + }, + { + "elapsed": 1997.130834, + "row_count": 10 + }, + { + "elapsed": 1937.249667, + "row_count": 10 + } + ], + "start_time": 1783521522, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 1836.23325, + "row_count": 10 + }, + { + "elapsed": 1765.4417919999999, + "row_count": 10 + }, + { + "elapsed": 2076.349208, + "row_count": 10 + } + ], + "start_time": 1783521528, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 309.540292, + "row_count": 10 + }, + { + "elapsed": 305.360125, + "row_count": 10 + }, + { + "elapsed": 345.27058300000004, + "row_count": 10 + } + ], + "start_time": 1783521534, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 59.661667, + "row_count": 10 + }, + { + "elapsed": 52.024375, + "row_count": 10 + }, + { + "elapsed": 52.012375, + "row_count": 10 + } + ], + "start_time": 1783521535, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 31.444209, + "row_count": 10 + }, + { + "elapsed": 30.575917, + "row_count": 10 + }, + { + "elapsed": 31.308999999999997, + "row_count": 10 + } + ], + "start_time": 1783521535, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 37.526583, + "row_count": 10 + }, + { + "elapsed": 36.711208, + "row_count": 10 + }, + { + "elapsed": 36.387, + "row_count": 10 + } + ], + "start_time": 1783521535, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 100.166417, + "row_count": 10 + }, + { + "elapsed": 96.452792, + "row_count": 10 + }, + { + "elapsed": 93.71625, + "row_count": 10 + } + ], + "start_time": 1783521535, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 9.978834, + "row_count": 10 + }, + { + "elapsed": 8.435625, + "row_count": 10 + }, + { + "elapsed": 8.873334, + "row_count": 10 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 12.264958, + "row_count": 10 + }, + { + "elapsed": 8.6085, + "row_count": 10 + }, + { + "elapsed": 8.641542000000001, + "row_count": 10 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 8.010417, + "row_count": 10 + }, + { + "elapsed": 6.773000000000001, + "row_count": 10 + }, + { + "elapsed": 6.683583, + "row_count": 10 + } + ], + "start_time": 1783521536, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521465, + "arguments": [ + "clickbench", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", + "--queries-path", + "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/clickbench_off_r2.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/clickbench_on_r1.json b/ab_results/clickbench_on_r1.json new file mode 100644 index 0000000000000..13f0f2afc0506 --- /dev/null +++ b/ab_results/clickbench_on_r1.json @@ -0,0 +1,838 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521393, + "arguments": [ + "clickbench", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", + "--queries-path", + "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/clickbench_on_r1.json" + ] + }, + "queries": [ + { + "query": "Query 0", + "iterations": [ + { + "elapsed": 8.096375, + "row_count": 1 + }, + { + "elapsed": 0.94425, + "row_count": 1 + }, + { + "elapsed": 0.692833, + "row_count": 1 + } + ], + "start_time": 1783521393, + "success": true + }, + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 14.858125, + "row_count": 1 + }, + { + "elapsed": 13.381625, + "row_count": 1 + }, + { + "elapsed": 11.821750000000002, + "row_count": 1 + } + ], + "start_time": 1783521393, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 45.389832999999996, + "row_count": 1 + }, + { + "elapsed": 42.562542, + "row_count": 1 + }, + { + "elapsed": 44.568916, + "row_count": 1 + } + ], + "start_time": 1783521393, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 62.50304199999999, + "row_count": 1 + }, + { + "elapsed": 42.210417, + "row_count": 1 + }, + { + "elapsed": 59.671833, + "row_count": 1 + } + ], + "start_time": 1783521393, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 352.002625, + "row_count": 1 + }, + { + "elapsed": 310.031292, + "row_count": 1 + }, + { + "elapsed": 303.825625, + "row_count": 1 + } + ], + "start_time": 1783521393, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 349.74158300000005, + "row_count": 1 + }, + { + "elapsed": 355.444791, + "row_count": 1 + }, + { + "elapsed": 363.875583, + "row_count": 1 + } + ], + "start_time": 1783521394, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 1.1741659999999998, + "row_count": 1 + }, + { + "elapsed": 0.827292, + "row_count": 1 + }, + { + "elapsed": 0.7476670000000001, + "row_count": 1 + } + ], + "start_time": 1783521395, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 17.519833, + "row_count": 18 + }, + { + "elapsed": 11.557375, + "row_count": 18 + }, + { + "elapsed": 12.088375000000001, + "row_count": 18 + } + ], + "start_time": 1783521395, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 388.138083, + "row_count": 10 + }, + { + "elapsed": 366.532709, + "row_count": 10 + }, + { + "elapsed": 383.436, + "row_count": 10 + } + ], + "start_time": 1783521395, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 477.423792, + "row_count": 10 + }, + { + "elapsed": 483.522834, + "row_count": 10 + }, + { + "elapsed": 467.36516700000004, + "row_count": 10 + } + ], + "start_time": 1783521396, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 69.372875, + "row_count": 10 + }, + { + "elapsed": 81.57725, + "row_count": 10 + }, + { + "elapsed": 77.326917, + "row_count": 10 + } + ], + "start_time": 1783521398, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 92.93254200000001, + "row_count": 10 + }, + { + "elapsed": 99.365958, + "row_count": 10 + }, + { + "elapsed": 88.337792, + "row_count": 10 + } + ], + "start_time": 1783521398, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 337.515375, + "row_count": 10 + }, + { + "elapsed": 362.82595899999995, + "row_count": 10 + }, + { + "elapsed": 337.64437499999997, + "row_count": 10 + } + ], + "start_time": 1783521398, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 621.530417, + "row_count": 10 + }, + { + "elapsed": 528.0484170000001, + "row_count": 10 + }, + { + "elapsed": 612.0186659999999, + "row_count": 10 + } + ], + "start_time": 1783521399, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 454.731542, + "row_count": 10 + }, + { + "elapsed": 361.203916, + "row_count": 10 + }, + { + "elapsed": 341.617375, + "row_count": 10 + } + ], + "start_time": 1783521401, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 332.865291, + "row_count": 10 + }, + { + "elapsed": 297.699541, + "row_count": 10 + }, + { + "elapsed": 288.36454200000003, + "row_count": 10 + } + ], + "start_time": 1783521402, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 759.308416, + "row_count": 10 + }, + { + "elapsed": 744.088166, + "row_count": 10 + }, + { + "elapsed": 758.176375, + "row_count": 10 + } + ], + "start_time": 1783521403, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 790.697833, + "row_count": 10 + }, + { + "elapsed": 814.461875, + "row_count": 10 + }, + { + "elapsed": 849.444792, + "row_count": 10 + } + ], + "start_time": 1783521405, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 2203.440209, + "row_count": 10 + }, + { + "elapsed": 1858.3045419999999, + "row_count": 10 + }, + { + "elapsed": 1456.971292, + "row_count": 10 + } + ], + "start_time": 1783521408, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 27.467583, + "row_count": 4 + }, + { + "elapsed": 28.034582999999998, + "row_count": 4 + }, + { + "elapsed": 26.727083, + "row_count": 4 + } + ], + "start_time": 1783521413, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 641.5, + "row_count": 1 + }, + { + "elapsed": 677.097042, + "row_count": 1 + }, + { + "elapsed": 693.2620000000001, + "row_count": 1 + } + ], + "start_time": 1783521413, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 845.369792, + "row_count": 10 + }, + { + "elapsed": 784.214666, + "row_count": 10 + }, + { + "elapsed": 757.29225, + "row_count": 10 + } + ], + "start_time": 1783521415, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 1522.309625, + "row_count": 10 + }, + { + "elapsed": 1412.0735, + "row_count": 10 + }, + { + "elapsed": 1426.077375, + "row_count": 10 + } + ], + "start_time": 1783521418, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 4141.845832999999, + "row_count": 10 + }, + { + "elapsed": 4124.703084, + "row_count": 10 + }, + { + "elapsed": 4048.6242920000004, + "row_count": 10 + } + ], + "start_time": 1783521422, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 47.3905, + "row_count": 10 + }, + { + "elapsed": 46.100541, + "row_count": 10 + }, + { + "elapsed": 47.743708000000005, + "row_count": 10 + } + ], + "start_time": 1783521435, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 140.448042, + "row_count": 10 + }, + { + "elapsed": 140.06004099999998, + "row_count": 10 + }, + { + "elapsed": 137.859792, + "row_count": 10 + } + ], + "start_time": 1783521435, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 43.605084000000005, + "row_count": 10 + }, + { + "elapsed": 54.127542, + "row_count": 10 + }, + { + "elapsed": 42.751459, + "row_count": 10 + } + ], + "start_time": 1783521435, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 917.45275, + "row_count": 25 + }, + { + "elapsed": 869.396791, + "row_count": 25 + }, + { + "elapsed": 856.466166, + "row_count": 25 + } + ], + "start_time": 1783521435, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 2903.5979159999997, + "row_count": 25 + }, + { + "elapsed": 2721.127458, + "row_count": 25 + }, + { + "elapsed": 2707.90175, + "row_count": 25 + } + ], + "start_time": 1783521438, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 38.071166, + "row_count": 1 + }, + { + "elapsed": 37.105542, + "row_count": 1 + }, + { + "elapsed": 46.108834, + "row_count": 1 + } + ], + "start_time": 1783521446, + "success": true + }, + { + "query": "Query 30", + "iterations": [ + { + "elapsed": 301.48225, + "row_count": 10 + }, + { + "elapsed": 299.395083, + "row_count": 10 + }, + { + "elapsed": 328.64887500000003, + "row_count": 10 + } + ], + "start_time": 1783521446, + "success": true + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 316.49725, + "row_count": 10 + }, + { + "elapsed": 307.586334, + "row_count": 10 + }, + { + "elapsed": 317.047041, + "row_count": 10 + } + ], + "start_time": 1783521447, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 2088.244, + "row_count": 10 + }, + { + "elapsed": 1202.19525, + "row_count": 10 + }, + { + "elapsed": 1169.632459, + "row_count": 10 + } + ], + "start_time": 1783521448, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 1887.4482079999998, + "row_count": 10 + }, + { + "elapsed": 1680.2657920000001, + "row_count": 10 + }, + { + "elapsed": 1611.361, + "row_count": 10 + } + ], + "start_time": 1783521453, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 1791.6960419999998, + "row_count": 10 + }, + { + "elapsed": 1692.4321249999998, + "row_count": 10 + }, + { + "elapsed": 1700.8285, + "row_count": 10 + } + ], + "start_time": 1783521458, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 310.654417, + "row_count": 10 + }, + { + "elapsed": 315.000084, + "row_count": 10 + }, + { + "elapsed": 266.73658300000005, + "row_count": 10 + } + ], + "start_time": 1783521463, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 82.258459, + "row_count": 10 + }, + { + "elapsed": 56.130291, + "row_count": 10 + }, + { + "elapsed": 55.778957999999996, + "row_count": 10 + } + ], + "start_time": 1783521464, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 27.695541000000002, + "row_count": 10 + }, + { + "elapsed": 26.696, + "row_count": 10 + }, + { + "elapsed": 29.5845, + "row_count": 10 + } + ], + "start_time": 1783521464, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 32.694624999999995, + "row_count": 10 + }, + { + "elapsed": 32.609375, + "row_count": 10 + }, + { + "elapsed": 32.107125, + "row_count": 10 + } + ], + "start_time": 1783521464, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 99.275042, + "row_count": 10 + }, + { + "elapsed": 96.879916, + "row_count": 10 + }, + { + "elapsed": 95.24354100000001, + "row_count": 10 + } + ], + "start_time": 1783521464, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 9.93125, + "row_count": 10 + }, + { + "elapsed": 8.338999999999999, + "row_count": 10 + }, + { + "elapsed": 8.761083, + "row_count": 10 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 9.358917, + "row_count": 10 + }, + { + "elapsed": 8.283541999999999, + "row_count": 10 + }, + { + "elapsed": 8.797374999999999, + "row_count": 10 + } + ], + "start_time": 1783521465, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 7.46475, + "row_count": 10 + }, + { + "elapsed": 6.543292, + "row_count": 10 + }, + { + "elapsed": 6.658583, + "row_count": 10 + } + ], + "start_time": 1783521465, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/clickbench_on_r2.json b/ab_results/clickbench_on_r2.json new file mode 100644 index 0000000000000..c27668b9823af --- /dev/null +++ b/ab_results/clickbench_on_r2.json @@ -0,0 +1,838 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521536, + "arguments": [ + "clickbench", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", + "--queries-path", + "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/clickbench_on_r2.json" + ] + }, + "queries": [ + { + "query": "Query 0", + "iterations": [ + { + "elapsed": 7.7271659999999995, + "row_count": 1 + }, + { + "elapsed": 0.890208, + "row_count": 1 + }, + { + "elapsed": 0.682708, + "row_count": 1 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 10.941374999999999, + "row_count": 1 + }, + { + "elapsed": 9.917709, + "row_count": 1 + }, + { + "elapsed": 9.989916999999998, + "row_count": 1 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 37.082042, + "row_count": 1 + }, + { + "elapsed": 40.037125, + "row_count": 1 + }, + { + "elapsed": 37.955000000000005, + "row_count": 1 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 47.134333, + "row_count": 1 + }, + { + "elapsed": 37.871125, + "row_count": 1 + }, + { + "elapsed": 33.410834, + "row_count": 1 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 245.83775, + "row_count": 1 + }, + { + "elapsed": 243.700667, + "row_count": 1 + }, + { + "elapsed": 255.754, + "row_count": 1 + } + ], + "start_time": 1783521536, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 370.58970899999997, + "row_count": 1 + }, + { + "elapsed": 397.89420800000005, + "row_count": 1 + }, + { + "elapsed": 422.11825, + "row_count": 1 + } + ], + "start_time": 1783521537, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 1.5801669999999999, + "row_count": 1 + }, + { + "elapsed": 1.452334, + "row_count": 1 + }, + { + "elapsed": 1.276583, + "row_count": 1 + } + ], + "start_time": 1783521538, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 17.379915999999998, + "row_count": 18 + }, + { + "elapsed": 15.438542, + "row_count": 18 + }, + { + "elapsed": 16.311166, + "row_count": 18 + } + ], + "start_time": 1783521538, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 490.116292, + "row_count": 10 + }, + { + "elapsed": 400.770167, + "row_count": 10 + }, + { + "elapsed": 403.71525, + "row_count": 10 + } + ], + "start_time": 1783521538, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 590.7842079999999, + "row_count": 10 + }, + { + "elapsed": 520.600958, + "row_count": 10 + }, + { + "elapsed": 507.06370899999996, + "row_count": 10 + } + ], + "start_time": 1783521540, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 76.241791, + "row_count": 10 + }, + { + "elapsed": 80.495833, + "row_count": 10 + }, + { + "elapsed": 72.38787500000001, + "row_count": 10 + } + ], + "start_time": 1783521541, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 92.851583, + "row_count": 10 + }, + { + "elapsed": 87.317375, + "row_count": 10 + }, + { + "elapsed": 88.511042, + "row_count": 10 + } + ], + "start_time": 1783521542, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 356.400125, + "row_count": 10 + }, + { + "elapsed": 345.653667, + "row_count": 10 + }, + { + "elapsed": 423.479041, + "row_count": 10 + } + ], + "start_time": 1783521542, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 572.4365, + "row_count": 10 + }, + { + "elapsed": 518.094167, + "row_count": 10 + }, + { + "elapsed": 512.337375, + "row_count": 10 + } + ], + "start_time": 1783521543, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 378.043666, + "row_count": 10 + }, + { + "elapsed": 393.452625, + "row_count": 10 + }, + { + "elapsed": 392.532375, + "row_count": 10 + } + ], + "start_time": 1783521545, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 324.45691700000003, + "row_count": 10 + }, + { + "elapsed": 328.474458, + "row_count": 10 + }, + { + "elapsed": 332.248042, + "row_count": 10 + } + ], + "start_time": 1783521546, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 814.551, + "row_count": 10 + }, + { + "elapsed": 828.122833, + "row_count": 10 + }, + { + "elapsed": 859.751709, + "row_count": 10 + } + ], + "start_time": 1783521547, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 841.892291, + "row_count": 10 + }, + { + "elapsed": 811.304542, + "row_count": 10 + }, + { + "elapsed": 899.85575, + "row_count": 10 + } + ], + "start_time": 1783521549, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 1890.0516249999998, + "row_count": 10 + }, + { + "elapsed": 1911.086542, + "row_count": 10 + }, + { + "elapsed": 1922.562041, + "row_count": 10 + } + ], + "start_time": 1783521552, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 44.253042, + "row_count": 4 + }, + { + "elapsed": 32.382417, + "row_count": 4 + }, + { + "elapsed": 32.492708, + "row_count": 4 + } + ], + "start_time": 1783521557, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 874.6324159999999, + "row_count": 1 + }, + { + "elapsed": 981.603333, + "row_count": 1 + }, + { + "elapsed": 1017.9544579999999, + "row_count": 1 + } + ], + "start_time": 1783521558, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 1183.999708, + "row_count": 10 + }, + { + "elapsed": 1167.995291, + "row_count": 10 + }, + { + "elapsed": 1038.130375, + "row_count": 10 + } + ], + "start_time": 1783521560, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 2049.604833, + "row_count": 10 + }, + { + "elapsed": 2107.563958, + "row_count": 10 + }, + { + "elapsed": 1906.824583, + "row_count": 10 + } + ], + "start_time": 1783521564, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 4998.53525, + "row_count": 10 + }, + { + "elapsed": 4691.800291, + "row_count": 10 + }, + { + "elapsed": 4749.423957999999, + "row_count": 10 + } + ], + "start_time": 1783521570, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 61.212917, + "row_count": 10 + }, + { + "elapsed": 59.338875, + "row_count": 10 + }, + { + "elapsed": 63.560875, + "row_count": 10 + } + ], + "start_time": 1783521584, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 172.10875000000001, + "row_count": 10 + }, + { + "elapsed": 176.716375, + "row_count": 10 + }, + { + "elapsed": 177.591292, + "row_count": 10 + } + ], + "start_time": 1783521585, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 55.916875, + "row_count": 10 + }, + { + "elapsed": 55.573042, + "row_count": 10 + }, + { + "elapsed": 54.534542, + "row_count": 10 + } + ], + "start_time": 1783521585, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 993.148791, + "row_count": 25 + }, + { + "elapsed": 1055.534958, + "row_count": 25 + }, + { + "elapsed": 968.1970829999999, + "row_count": 25 + } + ], + "start_time": 1783521585, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 3575.6857919999998, + "row_count": 25 + }, + { + "elapsed": 3460.662167, + "row_count": 25 + }, + { + "elapsed": 3536.231334, + "row_count": 25 + } + ], + "start_time": 1783521588, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 47.976958, + "row_count": 1 + }, + { + "elapsed": 42.861042000000005, + "row_count": 1 + }, + { + "elapsed": 42.264458, + "row_count": 1 + } + ], + "start_time": 1783521599, + "success": true + }, + { + "query": "Query 30", + "iterations": [ + { + "elapsed": 366.384042, + "row_count": 10 + }, + { + "elapsed": 351.894625, + "row_count": 10 + }, + { + "elapsed": 383.0905, + "row_count": 10 + } + ], + "start_time": 1783521599, + "success": true + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 414.461166, + "row_count": 10 + }, + { + "elapsed": 399.739167, + "row_count": 10 + }, + { + "elapsed": 369.898291, + "row_count": 10 + } + ], + "start_time": 1783521600, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 2395.095042, + "row_count": 10 + }, + { + "elapsed": 1565.577792, + "row_count": 10 + }, + { + "elapsed": 1383.35575, + "row_count": 10 + } + ], + "start_time": 1783521601, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 2285.5898749999997, + "row_count": 10 + }, + { + "elapsed": 2458.74575, + "row_count": 10 + }, + { + "elapsed": 2379.687417, + "row_count": 10 + } + ], + "start_time": 1783521607, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 2026.4257080000002, + "row_count": 10 + }, + { + "elapsed": 1868.836958, + "row_count": 10 + }, + { + "elapsed": 1863.3367079999998, + "row_count": 10 + } + ], + "start_time": 1783521614, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 324.86825000000005, + "row_count": 10 + }, + { + "elapsed": 318.33745899999997, + "row_count": 10 + }, + { + "elapsed": 289.563958, + "row_count": 10 + } + ], + "start_time": 1783521619, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 97.395709, + "row_count": 10 + }, + { + "elapsed": 63.84904099999999, + "row_count": 10 + }, + { + "elapsed": 68.3085, + "row_count": 10 + } + ], + "start_time": 1783521620, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 34.882333, + "row_count": 10 + }, + { + "elapsed": 33.785999999999994, + "row_count": 10 + }, + { + "elapsed": 31.000916, + "row_count": 10 + } + ], + "start_time": 1783521621, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 39.689167, + "row_count": 10 + }, + { + "elapsed": 45.04675, + "row_count": 10 + }, + { + "elapsed": 40.615458, + "row_count": 10 + } + ], + "start_time": 1783521621, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 111.420625, + "row_count": 10 + }, + { + "elapsed": 108.99291699999999, + "row_count": 10 + }, + { + "elapsed": 103.476666, + "row_count": 10 + } + ], + "start_time": 1783521621, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 10.558125, + "row_count": 10 + }, + { + "elapsed": 8.8675, + "row_count": 10 + }, + { + "elapsed": 9.246583, + "row_count": 10 + } + ], + "start_time": 1783521621, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 10.026917, + "row_count": 10 + }, + { + "elapsed": 9.57375, + "row_count": 10 + }, + { + "elapsed": 8.824167000000001, + "row_count": 10 + } + ], + "start_time": 1783521621, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 7.4770840000000005, + "row_count": 10 + }, + { + "elapsed": 6.956792, + "row_count": 10 + }, + { + "elapsed": 6.8532910000000005, + "row_count": 10 + } + ], + "start_time": 1783521621, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/lv-mem2g_off_r1.json b/ab_results/lv-mem2g_off_r1.json new file mode 100644 index 0000000000000..e8146fb448d14 --- /dev/null +++ b/ab_results/lv-mem2g_off_r1.json @@ -0,0 +1,78 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524304, + "arguments": [ + "large-values", + "--iterations", + "2", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "--memory-limit", + "2G", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_off_r1.json" + ] + }, + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 197.6835, + "row_count": 1 + }, + { + "elapsed": 154.469209, + "row_count": 1 + } + ], + "start_time": 1783524304, + "success": true + }, + { + "query": "2", + "iterations": [], + "start_time": 1783524304, + "success": false + }, + { + "query": "3", + "iterations": [], + "start_time": 1783524304, + "success": false + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 164.730625, + "row_count": 1000 + }, + { + "elapsed": 178.782333, + "row_count": 1000 + } + ], + "start_time": 1783524304, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 344.02358300000003, + "row_count": 1 + }, + { + "elapsed": 307.50525, + "row_count": 1 + } + ], + "start_time": 1783524305, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/lv-mem2g_off_r2.json b/ab_results/lv-mem2g_off_r2.json new file mode 100644 index 0000000000000..6aa6cc9b9cf5f --- /dev/null +++ b/ab_results/lv-mem2g_off_r2.json @@ -0,0 +1,78 @@ +{ + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 197.077458, + "row_count": 1 + }, + { + "elapsed": 169.666708, + "row_count": 1 + } + ], + "start_time": 1783524308, + "success": true + }, + { + "query": "2", + "iterations": [], + "start_time": 1783524308, + "success": false + }, + { + "query": "3", + "iterations": [], + "start_time": 1783524309, + "success": false + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 185.57637499999998, + "row_count": 1000 + }, + { + "elapsed": 166.465875, + "row_count": 1000 + } + ], + "start_time": 1783524309, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 313.966125, + "row_count": 1 + }, + { + "elapsed": 315.49224999999996, + "row_count": 1 + } + ], + "start_time": 1783524309, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524308, + "arguments": [ + "large-values", + "--iterations", + "2", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "--memory-limit", + "2G", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_off_r2.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/lv-mem2g_on_r1.json b/ab_results/lv-mem2g_on_r1.json new file mode 100644 index 0000000000000..9c488e8f32e15 --- /dev/null +++ b/ab_results/lv-mem2g_on_r1.json @@ -0,0 +1,78 @@ +{ + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 204.47537499999999, + "row_count": 1 + }, + { + "elapsed": 162.65116700000002, + "row_count": 1 + } + ], + "start_time": 1783524305, + "success": true + }, + { + "query": "2", + "iterations": [], + "start_time": 1783524306, + "success": false + }, + { + "query": "3", + "iterations": [], + "start_time": 1783524306, + "success": false + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 219.99279199999998, + "row_count": 1000 + }, + { + "elapsed": 216.437584, + "row_count": 1000 + } + ], + "start_time": 1783524307, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 348.959166, + "row_count": 1 + }, + { + "elapsed": 422.631667, + "row_count": 1 + } + ], + "start_time": 1783524307, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524305, + "arguments": [ + "large-values", + "--iterations", + "2", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "--memory-limit", + "2G", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_on_r1.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/lv-mem2g_on_r2.json b/ab_results/lv-mem2g_on_r2.json new file mode 100644 index 0000000000000..3b06e8b332fe0 --- /dev/null +++ b/ab_results/lv-mem2g_on_r2.json @@ -0,0 +1,78 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524310, + "arguments": [ + "large-values", + "--iterations", + "2", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "--memory-limit", + "2G", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_on_r2.json" + ] + }, + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 198.926, + "row_count": 1 + }, + { + "elapsed": 160.64475000000002, + "row_count": 1 + } + ], + "start_time": 1783524310, + "success": true + }, + { + "query": "2", + "iterations": [], + "start_time": 1783524310, + "success": false + }, + { + "query": "3", + "iterations": [], + "start_time": 1783524311, + "success": false + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 186.612583, + "row_count": 1000 + }, + { + "elapsed": 190.321584, + "row_count": 1000 + } + ], + "start_time": 1783524312, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 354.584417, + "row_count": 1 + }, + { + "elapsed": 344.833791, + "row_count": 1 + } + ], + "start_time": 1783524312, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/lv-unlimited_off_r1.json b/ab_results/lv-unlimited_off_r1.json new file mode 100644 index 0000000000000..5ad67554bb321 --- /dev/null +++ b/ab_results/lv-unlimited_off_r1.json @@ -0,0 +1,114 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524290, + "arguments": [ + "large-values", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_off_r1.json" + ] + }, + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 336.059208, + "row_count": 1 + }, + { + "elapsed": 214.84883299999998, + "row_count": 1 + }, + { + "elapsed": 196.46845900000002, + "row_count": 1 + } + ], + "start_time": 1783524290, + "success": true + }, + { + "query": "2", + "iterations": [ + { + "elapsed": 177.329917, + "row_count": 65536 + }, + { + "elapsed": 195.192375, + "row_count": 65536 + }, + { + "elapsed": 220.90258300000002, + "row_count": 65536 + } + ], + "start_time": 1783524291, + "success": true + }, + { + "query": "3", + "iterations": [ + { + "elapsed": 257.799042, + "row_count": 65536 + }, + { + "elapsed": 223.499583, + "row_count": 65536 + }, + { + "elapsed": 213.221041, + "row_count": 65536 + } + ], + "start_time": 1783524291, + "success": true + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 193.086125, + "row_count": 1000 + }, + { + "elapsed": 181.814208, + "row_count": 1000 + }, + { + "elapsed": 157.193375, + "row_count": 1000 + } + ], + "start_time": 1783524292, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 319.102958, + "row_count": 1 + }, + { + "elapsed": 300.663708, + "row_count": 1 + }, + { + "elapsed": 313.03641700000003, + "row_count": 1 + } + ], + "start_time": 1783524293, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/lv-unlimited_off_r2.json b/ab_results/lv-unlimited_off_r2.json new file mode 100644 index 0000000000000..e33a629f613f5 --- /dev/null +++ b/ab_results/lv-unlimited_off_r2.json @@ -0,0 +1,114 @@ +{ + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 187.636208, + "row_count": 1 + }, + { + "elapsed": 156.58808299999998, + "row_count": 1 + }, + { + "elapsed": 148.589958, + "row_count": 1 + } + ], + "start_time": 1783524297, + "success": true + }, + { + "query": "2", + "iterations": [ + { + "elapsed": 148.896334, + "row_count": 65536 + }, + { + "elapsed": 147.302166, + "row_count": 65536 + }, + { + "elapsed": 147.625292, + "row_count": 65536 + } + ], + "start_time": 1783524298, + "success": true + }, + { + "query": "3", + "iterations": [ + { + "elapsed": 220.70004200000002, + "row_count": 65536 + }, + { + "elapsed": 209.40620900000002, + "row_count": 65536 + }, + { + "elapsed": 214.033583, + "row_count": 65536 + } + ], + "start_time": 1783524298, + "success": true + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 157.743708, + "row_count": 1000 + }, + { + "elapsed": 155.584333, + "row_count": 1000 + }, + { + "elapsed": 170.668709, + "row_count": 1000 + } + ], + "start_time": 1783524299, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 307.706375, + "row_count": 1 + }, + { + "elapsed": 308.719666, + "row_count": 1 + }, + { + "elapsed": 300.23645799999997, + "row_count": 1 + } + ], + "start_time": 1783524299, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524297, + "arguments": [ + "large-values", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_off_r2.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/lv-unlimited_on_r1.json b/ab_results/lv-unlimited_on_r1.json new file mode 100644 index 0000000000000..fbd025f42ce1f --- /dev/null +++ b/ab_results/lv-unlimited_on_r1.json @@ -0,0 +1,114 @@ +{ + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 190.306583, + "row_count": 1 + }, + { + "elapsed": 167.66412499999998, + "row_count": 1 + }, + { + "elapsed": 165.759125, + "row_count": 1 + } + ], + "start_time": 1783524294, + "success": true + }, + { + "query": "2", + "iterations": [ + { + "elapsed": 172.79541700000001, + "row_count": 65536 + }, + { + "elapsed": 176.481875, + "row_count": 65536 + }, + { + "elapsed": 187.072083, + "row_count": 65536 + } + ], + "start_time": 1783524294, + "success": true + }, + { + "query": "3", + "iterations": [ + { + "elapsed": 330.78745799999996, + "row_count": 65536 + }, + { + "elapsed": 370.869583, + "row_count": 65536 + }, + { + "elapsed": 222.142125, + "row_count": 65536 + } + ], + "start_time": 1783524295, + "success": true + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 184.431041, + "row_count": 1000 + }, + { + "elapsed": 175.750666, + "row_count": 1000 + }, + { + "elapsed": 190.266458, + "row_count": 1000 + } + ], + "start_time": 1783524296, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 331.404709, + "row_count": 1 + }, + { + "elapsed": 328.953125, + "row_count": 1 + }, + { + "elapsed": 324.06679199999996, + "row_count": 1 + } + ], + "start_time": 1783524296, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524294, + "arguments": [ + "large-values", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_on_r1.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/lv-unlimited_on_r2.json b/ab_results/lv-unlimited_on_r2.json new file mode 100644 index 0000000000000..a261be2082119 --- /dev/null +++ b/ab_results/lv-unlimited_on_r2.json @@ -0,0 +1,114 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783524300, + "arguments": [ + "large-values", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_on_r2.json" + ] + }, + "queries": [ + { + "query": "1", + "iterations": [ + { + "elapsed": 194.511833, + "row_count": 1 + }, + { + "elapsed": 162.919083, + "row_count": 1 + }, + { + "elapsed": 164.84795799999998, + "row_count": 1 + } + ], + "start_time": 1783524300, + "success": true + }, + { + "query": "2", + "iterations": [ + { + "elapsed": 163.59825, + "row_count": 65536 + }, + { + "elapsed": 169.151333, + "row_count": 65536 + }, + { + "elapsed": 167.220583, + "row_count": 65536 + } + ], + "start_time": 1783524301, + "success": true + }, + { + "query": "3", + "iterations": [ + { + "elapsed": 250.01658300000003, + "row_count": 65536 + }, + { + "elapsed": 217.55041599999998, + "row_count": 65536 + }, + { + "elapsed": 220.9475, + "row_count": 65536 + } + ], + "start_time": 1783524301, + "success": true + }, + { + "query": "4", + "iterations": [ + { + "elapsed": 179.51741700000002, + "row_count": 1000 + }, + { + "elapsed": 173.85179200000002, + "row_count": 1000 + }, + { + "elapsed": 186.247083, + "row_count": 1000 + } + ], + "start_time": 1783524302, + "success": true + }, + { + "query": "5", + "iterations": [ + { + "elapsed": 341.749, + "row_count": 1 + }, + { + "elapsed": 338.359333, + "row_count": 1 + }, + { + "elapsed": 322.20941600000003, + "row_count": 1 + } + ], + "start_time": 1783524303, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/tpcds_off_r1.json b/ab_results/tpcds_off_r1.json new file mode 100644 index 0000000000000..27d2645b15bd0 --- /dev/null +++ b/ab_results/tpcds_off_r1.json @@ -0,0 +1,1891 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521622, + "arguments": [ + "tpcds", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", + "--query_path", + "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", + "--prefer_hash_join", + "true", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpcds_off_r1.json" + ] + }, + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 5.6685, + "row_count": 0 + }, + { + "elapsed": 3.86675, + "row_count": 0 + }, + { + "elapsed": 3.765959, + "row_count": 0 + } + ], + "start_time": 1783521622, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 124.789209, + "row_count": 2513 + }, + { + "elapsed": 101.340792, + "row_count": 2513 + }, + { + "elapsed": 101.1745, + "row_count": 2513 + } + ], + "start_time": 1783521622, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 87.80262499999999, + "row_count": 38 + }, + { + "elapsed": 85.04379200000001, + "row_count": 38 + }, + { + "elapsed": 84.299291, + "row_count": 38 + } + ], + "start_time": 1783521622, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 908.562041, + "row_count": 8 + }, + { + "elapsed": 875.065875, + "row_count": 8 + }, + { + "elapsed": 884.8748330000001, + "row_count": 8 + } + ], + "start_time": 1783521622, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 127.45124999999999, + "row_count": 100 + }, + { + "elapsed": 123.379416, + "row_count": 100 + }, + { + "elapsed": 122.5365, + "row_count": 100 + } + ], + "start_time": 1783521625, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 88.404833, + "row_count": 41 + }, + { + "elapsed": 85.765083, + "row_count": 41 + }, + { + "elapsed": 86.851625, + "row_count": 41 + } + ], + "start_time": 1783521625, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 229.36124999999998, + "row_count": 100 + }, + { + "elapsed": 220.675917, + "row_count": 100 + }, + { + "elapsed": 223.269292, + "row_count": 100 + } + ], + "start_time": 1783521625, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 80.993416, + "row_count": 0 + }, + { + "elapsed": 80.994125, + "row_count": 0 + }, + { + "elapsed": 80.76445799999999, + "row_count": 0 + } + ], + "start_time": 1783521626, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 89.646667, + "row_count": 1 + }, + { + "elapsed": 82.75637499999999, + "row_count": 1 + }, + { + "elapsed": 85.239083, + "row_count": 1 + } + ], + "start_time": 1783521626, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 86.429083, + "row_count": 2 + }, + { + "elapsed": 85.09004200000001, + "row_count": 2 + }, + { + "elapsed": 85.284292, + "row_count": 2 + } + ], + "start_time": 1783521627, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 592.771375, + "row_count": 88 + }, + { + "elapsed": 580.994833, + "row_count": 88 + }, + { + "elapsed": 605.234375, + "row_count": 88 + } + ], + "start_time": 1783521627, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 32.174542, + "row_count": 100 + }, + { + "elapsed": 30.879417, + "row_count": 100 + }, + { + "elapsed": 30.511, + "row_count": 100 + } + ], + "start_time": 1783521629, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 277.064667, + "row_count": 1 + }, + { + "elapsed": 280.09279100000003, + "row_count": 1 + }, + { + "elapsed": 279.674667, + "row_count": 1 + } + ], + "start_time": 1783521629, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 771.40925, + "row_count": 100 + }, + { + "elapsed": 768.7402089999999, + "row_count": 100 + }, + { + "elapsed": 787.023917, + "row_count": 100 + } + ], + "start_time": 1783521630, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 13.428334, + "row_count": 100 + }, + { + "elapsed": 10.656041, + "row_count": 100 + }, + { + "elapsed": 10.654292, + "row_count": 100 + } + ], + "start_time": 1783521632, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 4.941084, + "row_count": 1 + }, + { + "elapsed": 4.501958, + "row_count": 1 + }, + { + "elapsed": 4.250125000000001, + "row_count": 1 + } + ], + "start_time": 1783521632, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 146.011875, + "row_count": 1 + }, + { + "elapsed": 137.181667, + "row_count": 1 + }, + { + "elapsed": 140.047584, + "row_count": 1 + } + ], + "start_time": 1783521632, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 95.520333, + "row_count": 100 + }, + { + "elapsed": 97.865625, + "row_count": 100 + }, + { + "elapsed": 95.781334, + "row_count": 100 + } + ], + "start_time": 1783521632, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 115.50679199999999, + "row_count": 100 + }, + { + "elapsed": 113.447166, + "row_count": 100 + }, + { + "elapsed": 113.46425, + "row_count": 100 + } + ], + "start_time": 1783521633, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 9.29725, + "row_count": 100 + }, + { + "elapsed": 8.740334, + "row_count": 100 + }, + { + "elapsed": 8.790041, + "row_count": 100 + } + ], + "start_time": 1783521633, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 14.323334000000001, + "row_count": 100 + }, + { + "elapsed": 12.309041, + "row_count": 100 + }, + { + "elapsed": 11.842791, + "row_count": 100 + } + ], + "start_time": 1783521633, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 265.37775000000005, + "row_count": 100 + }, + { + "elapsed": 260.720667, + "row_count": 100 + }, + { + "elapsed": 267.11666699999995, + "row_count": 100 + } + ], + "start_time": 1783521633, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 522.907042, + "row_count": 0 + }, + { + "elapsed": 515.042125, + "row_count": 0 + }, + { + "elapsed": 536.592667, + "row_count": 0 + } + ], + "start_time": 1783521634, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 429.80508299999997, + "row_count": 0 + }, + { + "elapsed": 427.838334, + "row_count": 0 + }, + { + "elapsed": 426.755834, + "row_count": 0 + } + ], + "start_time": 1783521635, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 172.71629099999998, + "row_count": 0 + }, + { + "elapsed": 169.881542, + "row_count": 0 + }, + { + "elapsed": 169.515167, + "row_count": 0 + } + ], + "start_time": 1783521637, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 53.424833, + "row_count": 100 + }, + { + "elapsed": 51.652041000000004, + "row_count": 100 + }, + { + "elapsed": 51.702791, + "row_count": 100 + } + ], + "start_time": 1783521637, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 4.041625, + "row_count": 1 + }, + { + "elapsed": 3.8745, + "row_count": 1 + }, + { + "elapsed": 3.9445419999999998, + "row_count": 1 + } + ], + "start_time": 1783521637, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 103.777834, + "row_count": 1 + }, + { + "elapsed": 103.015042, + "row_count": 1 + }, + { + "elapsed": 102.917042, + "row_count": 1 + } + ], + "start_time": 1783521637, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 167.26637499999998, + "row_count": 0 + }, + { + "elapsed": 162.67516600000002, + "row_count": 0 + }, + { + "elapsed": 164.49525, + "row_count": 0 + } + ], + "start_time": 1783521638, + "success": true + }, + { + "query": "Query 30", + "iterations": [], + "start_time": 1783521638, + "success": false + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 116.10912499999999, + "row_count": 51 + }, + { + "elapsed": 115.56125, + "row_count": 51 + }, + { + "elapsed": 116.014791, + "row_count": 51 + } + ], + "start_time": 1783521638, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 9.402459, + "row_count": 1 + }, + { + "elapsed": 8.707334000000001, + "row_count": 1 + }, + { + "elapsed": 8.429, + "row_count": 1 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 98.9175, + "row_count": 100 + }, + { + "elapsed": 100.517458, + "row_count": 100 + }, + { + "elapsed": 99.80995800000001, + "row_count": 100 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 4.575417, + "row_count": 0 + }, + { + "elapsed": 3.728042, + "row_count": 0 + }, + { + "elapsed": 3.590583, + "row_count": 0 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 99.408208, + "row_count": 100 + }, + { + "elapsed": 96.368333, + "row_count": 100 + }, + { + "elapsed": 95.443208, + "row_count": 100 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 4.7667079999999995, + "row_count": 1 + }, + { + "elapsed": 3.7637080000000003, + "row_count": 1 + }, + { + "elapsed": 3.700791, + "row_count": 1 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 5.617125, + "row_count": 0 + }, + { + "elapsed": 5.234291000000001, + "row_count": 0 + }, + { + "elapsed": 5.481708, + "row_count": 0 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 88.579667, + "row_count": 1 + }, + { + "elapsed": 85.7335, + "row_count": 1 + }, + { + "elapsed": 87.84191700000001, + "row_count": 1 + } + ], + "start_time": 1783521639, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 51.498542, + "row_count": 7 + }, + { + "elapsed": 52.368084, + "row_count": 7 + }, + { + "elapsed": 55.315375, + "row_count": 7 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 72.530916, + "row_count": 100 + }, + { + "elapsed": 65.95979200000001, + "row_count": 100 + }, + { + "elapsed": 64.664875, + "row_count": 100 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 9.051959, + "row_count": 0 + }, + { + "elapsed": 8.516166, + "row_count": 0 + }, + { + "elapsed": 8.3345, + "row_count": 0 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 79.6915, + "row_count": 10 + }, + { + "elapsed": 79.87066700000001, + "row_count": 10 + }, + { + "elapsed": 80.49229199999999, + "row_count": 10 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 43", + "iterations": [ + { + "elapsed": 3.353583, + "row_count": 0 + }, + { + "elapsed": 2.754042, + "row_count": 0 + }, + { + "elapsed": 2.9928749999999997, + "row_count": 0 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 44", + "iterations": [ + { + "elapsed": 4.757584, + "row_count": 0 + }, + { + "elapsed": 4.9139159999999995, + "row_count": 0 + }, + { + "elapsed": 4.83325, + "row_count": 0 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 45", + "iterations": [ + { + "elapsed": 31.174332999999997, + "row_count": 16 + }, + { + "elapsed": 31.23, + "row_count": 16 + }, + { + "elapsed": 31.164708, + "row_count": 16 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 46", + "iterations": [ + { + "elapsed": 4.8115, + "row_count": 0 + }, + { + "elapsed": 4.494625, + "row_count": 0 + }, + { + "elapsed": 4.875584, + "row_count": 0 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 47", + "iterations": [ + { + "elapsed": 431.170458, + "row_count": 100 + }, + { + "elapsed": 433.2035, + "row_count": 100 + }, + { + "elapsed": 436.11641699999996, + "row_count": 100 + } + ], + "start_time": 1783521640, + "success": true + }, + { + "query": "Query 48", + "iterations": [ + { + "elapsed": 199.125583, + "row_count": 1 + }, + { + "elapsed": 195.61575, + "row_count": 1 + }, + { + "elapsed": 196.451667, + "row_count": 1 + } + ], + "start_time": 1783521642, + "success": true + }, + { + "query": "Query 49", + "iterations": [ + { + "elapsed": 169.282792, + "row_count": 31 + }, + { + "elapsed": 167.76025, + "row_count": 31 + }, + { + "elapsed": 168.312209, + "row_count": 31 + } + ], + "start_time": 1783521642, + "success": true + }, + { + "query": "Query 50", + "iterations": [ + { + "elapsed": 125.180708, + "row_count": 6 + }, + { + "elapsed": 119.96225000000001, + "row_count": 6 + }, + { + "elapsed": 119.11820900000001, + "row_count": 6 + } + ], + "start_time": 1783521643, + "success": true + }, + { + "query": "Query 51", + "iterations": [ + { + "elapsed": 116.1545, + "row_count": 100 + }, + { + "elapsed": 114.72995800000001, + "row_count": 100 + }, + { + "elapsed": 115.873334, + "row_count": 100 + } + ], + "start_time": 1783521643, + "success": true + }, + { + "query": "Query 52", + "iterations": [ + { + "elapsed": 80.651875, + "row_count": 100 + }, + { + "elapsed": 79.903875, + "row_count": 100 + }, + { + "elapsed": 80.662583, + "row_count": 100 + } + ], + "start_time": 1783521643, + "success": true + }, + { + "query": "Query 53", + "iterations": [ + { + "elapsed": 77.153375, + "row_count": 14 + }, + { + "elapsed": 74.83120799999999, + "row_count": 14 + }, + { + "elapsed": 75.7425, + "row_count": 14 + } + ], + "start_time": 1783521644, + "success": true + }, + { + "query": "Query 54", + "iterations": [ + { + "elapsed": 104.192042, + "row_count": 0 + }, + { + "elapsed": 102.324083, + "row_count": 0 + }, + { + "elapsed": 102.421125, + "row_count": 0 + } + ], + "start_time": 1783521644, + "success": true + }, + { + "query": "Query 55", + "iterations": [ + { + "elapsed": 79.77220799999999, + "row_count": 69 + }, + { + "elapsed": 80.51283400000001, + "row_count": 69 + }, + { + "elapsed": 80.269333, + "row_count": 69 + } + ], + "start_time": 1783521644, + "success": true + }, + { + "query": "Query 56", + "iterations": [ + { + "elapsed": 99.330584, + "row_count": 78 + }, + { + "elapsed": 99.649, + "row_count": 78 + }, + { + "elapsed": 101.468042, + "row_count": 78 + } + ], + "start_time": 1783521644, + "success": true + }, + { + "query": "Query 57", + "iterations": [ + { + "elapsed": 106.76554200000001, + "row_count": 100 + }, + { + "elapsed": 105.026667, + "row_count": 100 + }, + { + "elapsed": 105.480375, + "row_count": 100 + } + ], + "start_time": 1783521645, + "success": true + }, + { + "query": "Query 58", + "iterations": [ + { + "elapsed": 199.018834, + "row_count": 0 + }, + { + "elapsed": 198.30775, + "row_count": 0 + }, + { + "elapsed": 198.312875, + "row_count": 0 + } + ], + "start_time": 1783521645, + "success": true + }, + { + "query": "Query 59", + "iterations": [ + { + "elapsed": 126.811375, + "row_count": 100 + }, + { + "elapsed": 126.551042, + "row_count": 100 + }, + { + "elapsed": 126.38487500000001, + "row_count": 100 + } + ], + "start_time": 1783521646, + "success": true + }, + { + "query": "Query 60", + "iterations": [ + { + "elapsed": 102.55766700000001, + "row_count": 100 + }, + { + "elapsed": 101.44529200000001, + "row_count": 100 + }, + { + "elapsed": 101.831833, + "row_count": 100 + } + ], + "start_time": 1783521646, + "success": true + }, + { + "query": "Query 61", + "iterations": [ + { + "elapsed": 7.690333, + "row_count": 1 + }, + { + "elapsed": 7.559583, + "row_count": 1 + }, + { + "elapsed": 7.522832999999999, + "row_count": 1 + } + ], + "start_time": 1783521646, + "success": true + }, + { + "query": "Query 62", + "iterations": [ + { + "elapsed": 405.30775, + "row_count": 100 + }, + { + "elapsed": 389.16891599999997, + "row_count": 100 + }, + { + "elapsed": 372.862708, + "row_count": 100 + } + ], + "start_time": 1783521646, + "success": true + }, + { + "query": "Query 63", + "iterations": [ + { + "elapsed": 74.304458, + "row_count": 44 + }, + { + "elapsed": 77.2415, + "row_count": 44 + }, + { + "elapsed": 74.841959, + "row_count": 44 + } + ], + "start_time": 1783521648, + "success": true + }, + { + "query": "Query 64", + "iterations": [ + { + "elapsed": 463.77087500000005, + "row_count": 10 + }, + { + "elapsed": 446.2295, + "row_count": 10 + }, + { + "elapsed": 445.709125, + "row_count": 10 + } + ], + "start_time": 1783521648, + "success": true + }, + { + "query": "Query 65", + "iterations": [ + { + "elapsed": 169.091208, + "row_count": 100 + }, + { + "elapsed": 169.121625, + "row_count": 100 + }, + { + "elapsed": 170.127416, + "row_count": 100 + } + ], + "start_time": 1783521649, + "success": true + }, + { + "query": "Query 66", + "iterations": [ + { + "elapsed": 146.740375, + "row_count": 5 + }, + { + "elapsed": 154.261459, + "row_count": 5 + }, + { + "elapsed": 137.807125, + "row_count": 5 + } + ], + "start_time": 1783521650, + "success": true + }, + { + "query": "Query 67", + "iterations": [ + { + "elapsed": 303.646459, + "row_count": 100 + }, + { + "elapsed": 302.561875, + "row_count": 100 + }, + { + "elapsed": 317.461792, + "row_count": 100 + } + ], + "start_time": 1783521650, + "success": true + }, + { + "query": "Query 68", + "iterations": [ + { + "elapsed": 5.0215, + "row_count": 0 + }, + { + "elapsed": 4.987125, + "row_count": 0 + }, + { + "elapsed": 4.426375, + "row_count": 0 + } + ], + "start_time": 1783521651, + "success": true + }, + { + "query": "Query 69", + "iterations": [ + { + "elapsed": 75.850042, + "row_count": 100 + }, + { + "elapsed": 75.469291, + "row_count": 100 + }, + { + "elapsed": 75.445542, + "row_count": 100 + } + ], + "start_time": 1783521651, + "success": true + }, + { + "query": "Query 70", + "iterations": [ + { + "elapsed": 228.536458, + "row_count": 3 + }, + { + "elapsed": 220.198875, + "row_count": 3 + }, + { + "elapsed": 218.438667, + "row_count": 3 + } + ], + "start_time": 1783521651, + "success": true + }, + { + "query": "Query 71", + "iterations": [ + { + "elapsed": 99.383208, + "row_count": 1102 + }, + { + "elapsed": 96.229875, + "row_count": 1102 + }, + { + "elapsed": 95.664709, + "row_count": 1102 + } + ], + "start_time": 1783521652, + "success": true + }, + { + "query": "Query 72", + "iterations": [ + { + "elapsed": 418.877583, + "row_count": 100 + }, + { + "elapsed": 430.697, + "row_count": 100 + }, + { + "elapsed": 419.774167, + "row_count": 100 + } + ], + "start_time": 1783521652, + "success": true + }, + { + "query": "Query 73", + "iterations": [ + { + "elapsed": 4.309125, + "row_count": 0 + }, + { + "elapsed": 3.839708, + "row_count": 0 + }, + { + "elapsed": 3.677166, + "row_count": 0 + } + ], + "start_time": 1783521653, + "success": true + }, + { + "query": "Query 74", + "iterations": [ + { + "elapsed": 368.984667, + "row_count": 90 + }, + { + "elapsed": 359.462542, + "row_count": 90 + }, + { + "elapsed": 370.330125, + "row_count": 90 + } + ], + "start_time": 1783521653, + "success": true + }, + { + "query": "Query 75", + "iterations": [ + { + "elapsed": 189.657667, + "row_count": 100 + }, + { + "elapsed": 190.38162499999999, + "row_count": 100 + }, + { + "elapsed": 191.179209, + "row_count": 100 + } + ], + "start_time": 1783521655, + "success": true + }, + { + "query": "Query 76", + "iterations": [ + { + "elapsed": 91.035416, + "row_count": 100 + }, + { + "elapsed": 106.09, + "row_count": 100 + }, + { + "elapsed": 92.465292, + "row_count": 100 + } + ], + "start_time": 1783521655, + "success": true + }, + { + "query": "Query 77", + "iterations": [ + { + "elapsed": 141.794792, + "row_count": 44 + }, + { + "elapsed": 135.59420799999998, + "row_count": 44 + }, + { + "elapsed": 137.310708, + "row_count": 44 + } + ], + "start_time": 1783521655, + "success": true + }, + { + "query": "Query 78", + "iterations": [ + { + "elapsed": 228.267208, + "row_count": 100 + }, + { + "elapsed": 225.284666, + "row_count": 100 + }, + { + "elapsed": 225.02229100000002, + "row_count": 100 + } + ], + "start_time": 1783521656, + "success": true + }, + { + "query": "Query 79", + "iterations": [ + { + "elapsed": 180.866208, + "row_count": 100 + }, + { + "elapsed": 162.64241700000002, + "row_count": 100 + }, + { + "elapsed": 156.027042, + "row_count": 100 + } + ], + "start_time": 1783521657, + "success": true + }, + { + "query": "Query 80", + "iterations": [ + { + "elapsed": 213.056042, + "row_count": 100 + }, + { + "elapsed": 211.78941600000002, + "row_count": 100 + }, + { + "elapsed": 212.354667, + "row_count": 100 + } + ], + "start_time": 1783521657, + "success": true + }, + { + "query": "Query 81", + "iterations": [ + { + "elapsed": 18.638875, + "row_count": 96 + }, + { + "elapsed": 16.608749999999997, + "row_count": 96 + }, + { + "elapsed": 16.036375, + "row_count": 96 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 82", + "iterations": [ + { + "elapsed": 36.547792, + "row_count": 1 + }, + { + "elapsed": 30.324542, + "row_count": 1 + }, + { + "elapsed": 28.508292, + "row_count": 1 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 83", + "iterations": [ + { + "elapsed": 24.420583, + "row_count": 4 + }, + { + "elapsed": 24.693958, + "row_count": 4 + }, + { + "elapsed": 23.633333, + "row_count": 4 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 84", + "iterations": [ + { + "elapsed": 29.444083, + "row_count": 22 + }, + { + "elapsed": 29.745792, + "row_count": 22 + }, + { + "elapsed": 29.450083, + "row_count": 22 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 85", + "iterations": [ + { + "elapsed": 105.296042, + "row_count": 3 + }, + { + "elapsed": 106.545541, + "row_count": 3 + }, + { + "elapsed": 104.95966700000001, + "row_count": 3 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 86", + "iterations": [ + { + "elapsed": 29.533584, + "row_count": 100 + }, + { + "elapsed": 28.586291, + "row_count": 100 + }, + { + "elapsed": 29.080125, + "row_count": 100 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 87", + "iterations": [ + { + "elapsed": 88.316667, + "row_count": 1 + }, + { + "elapsed": 87.159792, + "row_count": 1 + }, + { + "elapsed": 90.288, + "row_count": 1 + } + ], + "start_time": 1783521658, + "success": true + }, + { + "query": "Query 88", + "iterations": [ + { + "elapsed": 70.867375, + "row_count": 1 + }, + { + "elapsed": 72.537916, + "row_count": 1 + }, + { + "elapsed": 73.816666, + "row_count": 1 + } + ], + "start_time": 1783521659, + "success": true + }, + { + "query": "Query 89", + "iterations": [ + { + "elapsed": 87.267375, + "row_count": 100 + }, + { + "elapsed": 85.670375, + "row_count": 100 + }, + { + "elapsed": 85.18075, + "row_count": 100 + } + ], + "start_time": 1783521659, + "success": true + }, + { + "query": "Query 90", + "iterations": [ + { + "elapsed": 14.858708, + "row_count": 1 + }, + { + "elapsed": 13.964666000000001, + "row_count": 1 + }, + { + "elapsed": 14.641582999999999, + "row_count": 1 + } + ], + "start_time": 1783521659, + "success": true + }, + { + "query": "Query 91", + "iterations": [ + { + "elapsed": 45.074583000000004, + "row_count": 4 + }, + { + "elapsed": 42.707958999999995, + "row_count": 4 + }, + { + "elapsed": 43.785416, + "row_count": 4 + } + ], + "start_time": 1783521659, + "success": true + }, + { + "query": "Query 92", + "iterations": [ + { + "elapsed": 41.015875, + "row_count": 1 + }, + { + "elapsed": 41.694165999999996, + "row_count": 1 + }, + { + "elapsed": 41.778333, + "row_count": 1 + } + ], + "start_time": 1783521659, + "success": true + }, + { + "query": "Query 93", + "iterations": [ + { + "elapsed": 114.39658299999999, + "row_count": 100 + }, + { + "elapsed": 111.768583, + "row_count": 100 + }, + { + "elapsed": 110.483792, + "row_count": 100 + } + ], + "start_time": 1783521659, + "success": true + }, + { + "query": "Query 94", + "iterations": [ + { + "elapsed": 42.804958, + "row_count": 1 + }, + { + "elapsed": 41.423874999999995, + "row_count": 1 + }, + { + "elapsed": 42.614166000000004, + "row_count": 1 + } + ], + "start_time": 1783521660, + "success": true + }, + { + "query": "Query 95", + "iterations": [ + { + "elapsed": 54.709041, + "row_count": 1 + }, + { + "elapsed": 55.479958, + "row_count": 1 + }, + { + "elapsed": 57.841625, + "row_count": 1 + } + ], + "start_time": 1783521660, + "success": true + }, + { + "query": "Query 96", + "iterations": [ + { + "elapsed": 51.62, + "row_count": 1 + }, + { + "elapsed": 50.765917, + "row_count": 1 + }, + { + "elapsed": 50.701834, + "row_count": 1 + } + ], + "start_time": 1783521660, + "success": true + }, + { + "query": "Query 97", + "iterations": [ + { + "elapsed": 83.814625, + "row_count": 1 + }, + { + "elapsed": 83.93974999999999, + "row_count": 1 + }, + { + "elapsed": 80.627375, + "row_count": 1 + } + ], + "start_time": 1783521660, + "success": true + }, + { + "query": "Query 98", + "iterations": [ + { + "elapsed": 107.287541, + "row_count": 2486 + }, + { + "elapsed": 108.253375, + "row_count": 2486 + }, + { + "elapsed": 107.830875, + "row_count": 2486 + } + ], + "start_time": 1783521660, + "success": true + }, + { + "query": "Query 99", + "iterations": [ + { + "elapsed": 4359.472041, + "row_count": 90 + }, + { + "elapsed": 4312.556208, + "row_count": 90 + }, + { + "elapsed": 4298.860833, + "row_count": 90 + } + ], + "start_time": 1783521661, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/tpcds_off_r2.json b/ab_results/tpcds_off_r2.json new file mode 100644 index 0000000000000..ac39b62dc377d --- /dev/null +++ b/ab_results/tpcds_off_r2.json @@ -0,0 +1,1891 @@ +{ + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 5.114416, + "row_count": 0 + }, + { + "elapsed": 3.529375, + "row_count": 0 + }, + { + "elapsed": 3.457417, + "row_count": 0 + } + ], + "start_time": 1783521725, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 100.854208, + "row_count": 2513 + }, + { + "elapsed": 101.17216699999999, + "row_count": 2513 + }, + { + "elapsed": 108.40254200000001, + "row_count": 2513 + } + ], + "start_time": 1783521725, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 84.77620800000001, + "row_count": 38 + }, + { + "elapsed": 84.1435, + "row_count": 38 + }, + { + "elapsed": 84.37195799999999, + "row_count": 38 + } + ], + "start_time": 1783521726, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 884.514542, + "row_count": 8 + }, + { + "elapsed": 888.085375, + "row_count": 8 + }, + { + "elapsed": 896.045334, + "row_count": 8 + } + ], + "start_time": 1783521726, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 124.61037499999999, + "row_count": 100 + }, + { + "elapsed": 124.344708, + "row_count": 100 + }, + { + "elapsed": 122.315375, + "row_count": 100 + } + ], + "start_time": 1783521729, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 87.57075, + "row_count": 41 + }, + { + "elapsed": 88.997041, + "row_count": 41 + }, + { + "elapsed": 87.635375, + "row_count": 41 + } + ], + "start_time": 1783521729, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 225.391625, + "row_count": 100 + }, + { + "elapsed": 222.582166, + "row_count": 100 + }, + { + "elapsed": 220.736333, + "row_count": 100 + } + ], + "start_time": 1783521729, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 81.228917, + "row_count": 0 + }, + { + "elapsed": 80.523292, + "row_count": 0 + }, + { + "elapsed": 81.186917, + "row_count": 0 + } + ], + "start_time": 1783521730, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 79.077916, + "row_count": 1 + }, + { + "elapsed": 87.355167, + "row_count": 1 + }, + { + "elapsed": 104.325917, + "row_count": 1 + } + ], + "start_time": 1783521730, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 85.08162499999999, + "row_count": 2 + }, + { + "elapsed": 84.821625, + "row_count": 2 + }, + { + "elapsed": 84.517167, + "row_count": 2 + } + ], + "start_time": 1783521731, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 575.892167, + "row_count": 88 + }, + { + "elapsed": 580.845792, + "row_count": 88 + }, + { + "elapsed": 568.143292, + "row_count": 88 + } + ], + "start_time": 1783521731, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 30.264375, + "row_count": 100 + }, + { + "elapsed": 29.739833, + "row_count": 100 + }, + { + "elapsed": 30.391792000000002, + "row_count": 100 + } + ], + "start_time": 1783521732, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 283.282667, + "row_count": 1 + }, + { + "elapsed": 283.63624999999996, + "row_count": 1 + }, + { + "elapsed": 282.888167, + "row_count": 1 + } + ], + "start_time": 1783521733, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 784.752125, + "row_count": 100 + }, + { + "elapsed": 765.496958, + "row_count": 100 + }, + { + "elapsed": 762.572375, + "row_count": 100 + } + ], + "start_time": 1783521733, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 11.181583999999999, + "row_count": 100 + }, + { + "elapsed": 10.965124999999999, + "row_count": 100 + }, + { + "elapsed": 11.08775, + "row_count": 100 + } + ], + "start_time": 1783521736, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 4.734416, + "row_count": 1 + }, + { + "elapsed": 4.365542, + "row_count": 1 + }, + { + "elapsed": 4.202208, + "row_count": 1 + } + ], + "start_time": 1783521736, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 137.068125, + "row_count": 1 + }, + { + "elapsed": 134.577541, + "row_count": 1 + }, + { + "elapsed": 134.869333, + "row_count": 1 + } + ], + "start_time": 1783521736, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 90.172, + "row_count": 100 + }, + { + "elapsed": 90.258375, + "row_count": 100 + }, + { + "elapsed": 90.487125, + "row_count": 100 + } + ], + "start_time": 1783521736, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 111.35050000000001, + "row_count": 100 + }, + { + "elapsed": 110.26258299999999, + "row_count": 100 + }, + { + "elapsed": 111.763292, + "row_count": 100 + } + ], + "start_time": 1783521736, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 9.598832999999999, + "row_count": 100 + }, + { + "elapsed": 8.879125, + "row_count": 100 + }, + { + "elapsed": 8.789584, + "row_count": 100 + } + ], + "start_time": 1783521737, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 11.508542, + "row_count": 100 + }, + { + "elapsed": 11.323666, + "row_count": 100 + }, + { + "elapsed": 11.526167000000001, + "row_count": 100 + } + ], + "start_time": 1783521737, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 260.383333, + "row_count": 100 + }, + { + "elapsed": 260.667541, + "row_count": 100 + }, + { + "elapsed": 259.3995, + "row_count": 100 + } + ], + "start_time": 1783521737, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 523.536458, + "row_count": 0 + }, + { + "elapsed": 519.114458, + "row_count": 0 + }, + { + "elapsed": 522.102583, + "row_count": 0 + } + ], + "start_time": 1783521738, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 427.64020800000003, + "row_count": 0 + }, + { + "elapsed": 426.158584, + "row_count": 0 + }, + { + "elapsed": 436.832084, + "row_count": 0 + } + ], + "start_time": 1783521739, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 170.855458, + "row_count": 0 + }, + { + "elapsed": 173.06425000000002, + "row_count": 0 + }, + { + "elapsed": 167.69091699999998, + "row_count": 0 + } + ], + "start_time": 1783521740, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 51.408875, + "row_count": 100 + }, + { + "elapsed": 51.780125000000005, + "row_count": 100 + }, + { + "elapsed": 51.673417, + "row_count": 100 + } + ], + "start_time": 1783521741, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 3.9595840000000004, + "row_count": 1 + }, + { + "elapsed": 3.682542, + "row_count": 1 + }, + { + "elapsed": 3.391416, + "row_count": 1 + } + ], + "start_time": 1783521741, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 102.63425, + "row_count": 1 + }, + { + "elapsed": 107.004375, + "row_count": 1 + }, + { + "elapsed": 102.649959, + "row_count": 1 + } + ], + "start_time": 1783521741, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 166.092916, + "row_count": 0 + }, + { + "elapsed": 162.8915, + "row_count": 0 + }, + { + "elapsed": 163.579792, + "row_count": 0 + } + ], + "start_time": 1783521741, + "success": true + }, + { + "query": "Query 30", + "iterations": [], + "start_time": 1783521742, + "success": false + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 114.58200000000001, + "row_count": 51 + }, + { + "elapsed": 114.975291, + "row_count": 51 + }, + { + "elapsed": 116.12379200000001, + "row_count": 51 + } + ], + "start_time": 1783521742, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 8.741583, + "row_count": 1 + }, + { + "elapsed": 8.408542, + "row_count": 1 + }, + { + "elapsed": 7.943416999999999, + "row_count": 1 + } + ], + "start_time": 1783521742, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 99.252333, + "row_count": 100 + }, + { + "elapsed": 98.675083, + "row_count": 100 + }, + { + "elapsed": 100.20016700000001, + "row_count": 100 + } + ], + "start_time": 1783521742, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 4.016208000000001, + "row_count": 0 + }, + { + "elapsed": 3.442166, + "row_count": 0 + }, + { + "elapsed": 3.862208, + "row_count": 0 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 96.738375, + "row_count": 100 + }, + { + "elapsed": 95.097, + "row_count": 100 + }, + { + "elapsed": 93.912334, + "row_count": 100 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 3.668917, + "row_count": 1 + }, + { + "elapsed": 3.7550830000000004, + "row_count": 1 + }, + { + "elapsed": 3.95925, + "row_count": 1 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 5.5319590000000005, + "row_count": 0 + }, + { + "elapsed": 5.200541, + "row_count": 0 + }, + { + "elapsed": 5.356541, + "row_count": 0 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 86.113375, + "row_count": 1 + }, + { + "elapsed": 86.02158299999999, + "row_count": 1 + }, + { + "elapsed": 86.584917, + "row_count": 1 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 51.028749999999995, + "row_count": 7 + }, + { + "elapsed": 51.556, + "row_count": 7 + }, + { + "elapsed": 51.367999999999995, + "row_count": 7 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 66.56841700000001, + "row_count": 100 + }, + { + "elapsed": 64.797625, + "row_count": 100 + }, + { + "elapsed": 65.77366699999999, + "row_count": 100 + } + ], + "start_time": 1783521743, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 9.278041, + "row_count": 0 + }, + { + "elapsed": 8.347958, + "row_count": 0 + }, + { + "elapsed": 8.918125, + "row_count": 0 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 81.142417, + "row_count": 10 + }, + { + "elapsed": 79.773583, + "row_count": 10 + }, + { + "elapsed": 79.278833, + "row_count": 10 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 43", + "iterations": [ + { + "elapsed": 3.356292, + "row_count": 0 + }, + { + "elapsed": 2.996, + "row_count": 0 + }, + { + "elapsed": 2.9650420000000004, + "row_count": 0 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 44", + "iterations": [ + { + "elapsed": 4.773916, + "row_count": 0 + }, + { + "elapsed": 4.710666, + "row_count": 0 + }, + { + "elapsed": 4.575959, + "row_count": 0 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 45", + "iterations": [ + { + "elapsed": 31.384750000000004, + "row_count": 16 + }, + { + "elapsed": 31.214, + "row_count": 16 + }, + { + "elapsed": 31.214, + "row_count": 16 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 46", + "iterations": [ + { + "elapsed": 4.799833, + "row_count": 0 + }, + { + "elapsed": 4.461375, + "row_count": 0 + }, + { + "elapsed": 4.638417, + "row_count": 0 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 47", + "iterations": [ + { + "elapsed": 426.58299999999997, + "row_count": 100 + }, + { + "elapsed": 434.414458, + "row_count": 100 + }, + { + "elapsed": 427.514334, + "row_count": 100 + } + ], + "start_time": 1783521744, + "success": true + }, + { + "query": "Query 48", + "iterations": [ + { + "elapsed": 192.446, + "row_count": 1 + }, + { + "elapsed": 191.569334, + "row_count": 1 + }, + { + "elapsed": 195.811709, + "row_count": 1 + } + ], + "start_time": 1783521745, + "success": true + }, + { + "query": "Query 49", + "iterations": [ + { + "elapsed": 166.385625, + "row_count": 31 + }, + { + "elapsed": 166.10312499999998, + "row_count": 31 + }, + { + "elapsed": 167.807125, + "row_count": 31 + } + ], + "start_time": 1783521746, + "success": true + }, + { + "query": "Query 50", + "iterations": [ + { + "elapsed": 122.455833, + "row_count": 6 + }, + { + "elapsed": 119.171375, + "row_count": 6 + }, + { + "elapsed": 120.647, + "row_count": 6 + } + ], + "start_time": 1783521746, + "success": true + }, + { + "query": "Query 51", + "iterations": [ + { + "elapsed": 117.794584, + "row_count": 100 + }, + { + "elapsed": 115.979208, + "row_count": 100 + }, + { + "elapsed": 117.803459, + "row_count": 100 + } + ], + "start_time": 1783521747, + "success": true + }, + { + "query": "Query 52", + "iterations": [ + { + "elapsed": 80.463167, + "row_count": 100 + }, + { + "elapsed": 79.322167, + "row_count": 100 + }, + { + "elapsed": 79.579, + "row_count": 100 + } + ], + "start_time": 1783521747, + "success": true + }, + { + "query": "Query 53", + "iterations": [ + { + "elapsed": 73.169542, + "row_count": 14 + }, + { + "elapsed": 73.675833, + "row_count": 14 + }, + { + "elapsed": 74.810041, + "row_count": 14 + } + ], + "start_time": 1783521747, + "success": true + }, + { + "query": "Query 54", + "iterations": [ + { + "elapsed": 113.810542, + "row_count": 0 + }, + { + "elapsed": 106.802959, + "row_count": 0 + }, + { + "elapsed": 103.5595, + "row_count": 0 + } + ], + "start_time": 1783521748, + "success": true + }, + { + "query": "Query 55", + "iterations": [ + { + "elapsed": 80.1695, + "row_count": 69 + }, + { + "elapsed": 79.234125, + "row_count": 69 + }, + { + "elapsed": 79.57837500000001, + "row_count": 69 + } + ], + "start_time": 1783521748, + "success": true + }, + { + "query": "Query 56", + "iterations": [ + { + "elapsed": 99.967958, + "row_count": 78 + }, + { + "elapsed": 98.86470899999999, + "row_count": 78 + }, + { + "elapsed": 98.629959, + "row_count": 78 + } + ], + "start_time": 1783521748, + "success": true + }, + { + "query": "Query 57", + "iterations": [ + { + "elapsed": 104.046, + "row_count": 100 + }, + { + "elapsed": 104.648292, + "row_count": 100 + }, + { + "elapsed": 106.743625, + "row_count": 100 + } + ], + "start_time": 1783521748, + "success": true + }, + { + "query": "Query 58", + "iterations": [ + { + "elapsed": 198.36225, + "row_count": 0 + }, + { + "elapsed": 197.49075, + "row_count": 0 + }, + { + "elapsed": 198.131167, + "row_count": 0 + } + ], + "start_time": 1783521749, + "success": true + }, + { + "query": "Query 59", + "iterations": [ + { + "elapsed": 125.61104200000001, + "row_count": 100 + }, + { + "elapsed": 134.48208400000001, + "row_count": 100 + }, + { + "elapsed": 136.516958, + "row_count": 100 + } + ], + "start_time": 1783521749, + "success": true + }, + { + "query": "Query 60", + "iterations": [ + { + "elapsed": 103.77112500000001, + "row_count": 100 + }, + { + "elapsed": 101.386791, + "row_count": 100 + }, + { + "elapsed": 100.20725, + "row_count": 100 + } + ], + "start_time": 1783521750, + "success": true + }, + { + "query": "Query 61", + "iterations": [ + { + "elapsed": 7.665291, + "row_count": 1 + }, + { + "elapsed": 7.108625, + "row_count": 1 + }, + { + "elapsed": 7.448416, + "row_count": 1 + } + ], + "start_time": 1783521750, + "success": true + }, + { + "query": "Query 62", + "iterations": [ + { + "elapsed": 373.817917, + "row_count": 100 + }, + { + "elapsed": 367.953792, + "row_count": 100 + }, + { + "elapsed": 372.099958, + "row_count": 100 + } + ], + "start_time": 1783521750, + "success": true + }, + { + "query": "Query 63", + "iterations": [ + { + "elapsed": 74.207458, + "row_count": 44 + }, + { + "elapsed": 73.99870899999999, + "row_count": 44 + }, + { + "elapsed": 74.590583, + "row_count": 44 + } + ], + "start_time": 1783521751, + "success": true + }, + { + "query": "Query 64", + "iterations": [ + { + "elapsed": 447.524791, + "row_count": 10 + }, + { + "elapsed": 451.41274999999996, + "row_count": 10 + }, + { + "elapsed": 448.846, + "row_count": 10 + } + ], + "start_time": 1783521751, + "success": true + }, + { + "query": "Query 65", + "iterations": [ + { + "elapsed": 171.678125, + "row_count": 100 + }, + { + "elapsed": 168.788792, + "row_count": 100 + }, + { + "elapsed": 168.22225, + "row_count": 100 + } + ], + "start_time": 1783521753, + "success": true + }, + { + "query": "Query 66", + "iterations": [ + { + "elapsed": 147.681458, + "row_count": 5 + }, + { + "elapsed": 133.409084, + "row_count": 5 + }, + { + "elapsed": 134.359167, + "row_count": 5 + } + ], + "start_time": 1783521753, + "success": true + }, + { + "query": "Query 67", + "iterations": [ + { + "elapsed": 326.656, + "row_count": 100 + }, + { + "elapsed": 304.123875, + "row_count": 100 + }, + { + "elapsed": 298.208584, + "row_count": 100 + } + ], + "start_time": 1783521754, + "success": true + }, + { + "query": "Query 68", + "iterations": [ + { + "elapsed": 5.443042, + "row_count": 0 + }, + { + "elapsed": 4.636875000000001, + "row_count": 0 + }, + { + "elapsed": 4.9887500000000005, + "row_count": 0 + } + ], + "start_time": 1783521755, + "success": true + }, + { + "query": "Query 69", + "iterations": [ + { + "elapsed": 74.413833, + "row_count": 100 + }, + { + "elapsed": 75.39037499999999, + "row_count": 100 + }, + { + "elapsed": 78.221125, + "row_count": 100 + } + ], + "start_time": 1783521755, + "success": true + }, + { + "query": "Query 70", + "iterations": [ + { + "elapsed": 228.576334, + "row_count": 3 + }, + { + "elapsed": 220.842958, + "row_count": 3 + }, + { + "elapsed": 218.445792, + "row_count": 3 + } + ], + "start_time": 1783521755, + "success": true + }, + { + "query": "Query 71", + "iterations": [ + { + "elapsed": 94.65650000000001, + "row_count": 1102 + }, + { + "elapsed": 95.75908299999999, + "row_count": 1102 + }, + { + "elapsed": 95.425333, + "row_count": 1102 + } + ], + "start_time": 1783521755, + "success": true + }, + { + "query": "Query 72", + "iterations": [ + { + "elapsed": 422.843542, + "row_count": 100 + }, + { + "elapsed": 428.71274999999997, + "row_count": 100 + }, + { + "elapsed": 433.06175, + "row_count": 100 + } + ], + "start_time": 1783521756, + "success": true + }, + { + "query": "Query 73", + "iterations": [ + { + "elapsed": 4.252, + "row_count": 0 + }, + { + "elapsed": 3.753584, + "row_count": 0 + }, + { + "elapsed": 3.872833, + "row_count": 0 + } + ], + "start_time": 1783521757, + "success": true + }, + { + "query": "Query 74", + "iterations": [ + { + "elapsed": 351.43483399999997, + "row_count": 90 + }, + { + "elapsed": 352.56112499999995, + "row_count": 90 + }, + { + "elapsed": 365.99575, + "row_count": 90 + } + ], + "start_time": 1783521757, + "success": true + }, + { + "query": "Query 75", + "iterations": [ + { + "elapsed": 190.606083, + "row_count": 100 + }, + { + "elapsed": 187.621042, + "row_count": 100 + }, + { + "elapsed": 189.028459, + "row_count": 100 + } + ], + "start_time": 1783521758, + "success": true + }, + { + "query": "Query 76", + "iterations": [ + { + "elapsed": 91.72524999999999, + "row_count": 100 + }, + { + "elapsed": 92.17649999999999, + "row_count": 100 + }, + { + "elapsed": 91.439375, + "row_count": 100 + } + ], + "start_time": 1783521759, + "success": true + }, + { + "query": "Query 77", + "iterations": [ + { + "elapsed": 135.94562499999998, + "row_count": 44 + }, + { + "elapsed": 134.74945799999998, + "row_count": 44 + }, + { + "elapsed": 134.17779199999998, + "row_count": 44 + } + ], + "start_time": 1783521759, + "success": true + }, + { + "query": "Query 78", + "iterations": [ + { + "elapsed": 222.948667, + "row_count": 100 + }, + { + "elapsed": 220.78816700000002, + "row_count": 100 + }, + { + "elapsed": 221.213291, + "row_count": 100 + } + ], + "start_time": 1783521759, + "success": true + }, + { + "query": "Query 79", + "iterations": [ + { + "elapsed": 156.279709, + "row_count": 100 + }, + { + "elapsed": 172.568959, + "row_count": 100 + }, + { + "elapsed": 157.27883300000002, + "row_count": 100 + } + ], + "start_time": 1783521760, + "success": true + }, + { + "query": "Query 80", + "iterations": [ + { + "elapsed": 212.78770799999998, + "row_count": 100 + }, + { + "elapsed": 212.683917, + "row_count": 100 + }, + { + "elapsed": 213.039917, + "row_count": 100 + } + ], + "start_time": 1783521761, + "success": true + }, + { + "query": "Query 81", + "iterations": [ + { + "elapsed": 16.357584000000003, + "row_count": 96 + }, + { + "elapsed": 16.271625, + "row_count": 96 + }, + { + "elapsed": 16.410708, + "row_count": 96 + } + ], + "start_time": 1783521761, + "success": true + }, + { + "query": "Query 82", + "iterations": [ + { + "elapsed": 28.058041999999997, + "row_count": 1 + }, + { + "elapsed": 27.595208, + "row_count": 1 + }, + { + "elapsed": 27.737624999999998, + "row_count": 1 + } + ], + "start_time": 1783521761, + "success": true + }, + { + "query": "Query 83", + "iterations": [ + { + "elapsed": 23.655417, + "row_count": 4 + }, + { + "elapsed": 23.666584, + "row_count": 4 + }, + { + "elapsed": 23.868709, + "row_count": 4 + } + ], + "start_time": 1783521761, + "success": true + }, + { + "query": "Query 84", + "iterations": [ + { + "elapsed": 29.304042, + "row_count": 22 + }, + { + "elapsed": 29.384458, + "row_count": 22 + }, + { + "elapsed": 29.512, + "row_count": 22 + } + ], + "start_time": 1783521761, + "success": true + }, + { + "query": "Query 85", + "iterations": [ + { + "elapsed": 129.296542, + "row_count": 3 + }, + { + "elapsed": 104.947, + "row_count": 3 + }, + { + "elapsed": 104.378666, + "row_count": 3 + } + ], + "start_time": 1783521761, + "success": true + }, + { + "query": "Query 86", + "iterations": [ + { + "elapsed": 33.782624999999996, + "row_count": 100 + }, + { + "elapsed": 30.511458, + "row_count": 100 + }, + { + "elapsed": 30.75675, + "row_count": 100 + } + ], + "start_time": 1783521762, + "success": true + }, + { + "query": "Query 87", + "iterations": [ + { + "elapsed": 96.592333, + "row_count": 1 + }, + { + "elapsed": 93.3995, + "row_count": 1 + }, + { + "elapsed": 94.873875, + "row_count": 1 + } + ], + "start_time": 1783521762, + "success": true + }, + { + "query": "Query 88", + "iterations": [ + { + "elapsed": 101.80995800000001, + "row_count": 1 + }, + { + "elapsed": 86.79833400000001, + "row_count": 1 + }, + { + "elapsed": 86.13841699999999, + "row_count": 1 + } + ], + "start_time": 1783521762, + "success": true + }, + { + "query": "Query 89", + "iterations": [ + { + "elapsed": 85.32199999999999, + "row_count": 100 + }, + { + "elapsed": 84.926916, + "row_count": 100 + }, + { + "elapsed": 84.330875, + "row_count": 100 + } + ], + "start_time": 1783521762, + "success": true + }, + { + "query": "Query 90", + "iterations": [ + { + "elapsed": 14.241083, + "row_count": 1 + }, + { + "elapsed": 13.495541999999999, + "row_count": 1 + }, + { + "elapsed": 13.622250000000001, + "row_count": 1 + } + ], + "start_time": 1783521763, + "success": true + }, + { + "query": "Query 91", + "iterations": [ + { + "elapsed": 42.975917, + "row_count": 4 + }, + { + "elapsed": 43.429500000000004, + "row_count": 4 + }, + { + "elapsed": 42.778417, + "row_count": 4 + } + ], + "start_time": 1783521763, + "success": true + }, + { + "query": "Query 92", + "iterations": [ + { + "elapsed": 41.322458, + "row_count": 1 + }, + { + "elapsed": 41.504959, + "row_count": 1 + }, + { + "elapsed": 41.115167, + "row_count": 1 + } + ], + "start_time": 1783521763, + "success": true + }, + { + "query": "Query 93", + "iterations": [ + { + "elapsed": 110.365916, + "row_count": 100 + }, + { + "elapsed": 109.74375, + "row_count": 100 + }, + { + "elapsed": 110.586083, + "row_count": 100 + } + ], + "start_time": 1783521763, + "success": true + }, + { + "query": "Query 94", + "iterations": [ + { + "elapsed": 41.957625, + "row_count": 1 + }, + { + "elapsed": 42.383540999999994, + "row_count": 1 + }, + { + "elapsed": 41.543833, + "row_count": 1 + } + ], + "start_time": 1783521763, + "success": true + }, + { + "query": "Query 95", + "iterations": [ + { + "elapsed": 54.933167, + "row_count": 1 + }, + { + "elapsed": 55.575958, + "row_count": 1 + }, + { + "elapsed": 57.272125, + "row_count": 1 + } + ], + "start_time": 1783521763, + "success": true + }, + { + "query": "Query 96", + "iterations": [ + { + "elapsed": 50.252834, + "row_count": 1 + }, + { + "elapsed": 49.556000000000004, + "row_count": 1 + }, + { + "elapsed": 48.506084, + "row_count": 1 + } + ], + "start_time": 1783521764, + "success": true + }, + { + "query": "Query 97", + "iterations": [ + { + "elapsed": 82.253583, + "row_count": 1 + }, + { + "elapsed": 81.42108300000001, + "row_count": 1 + }, + { + "elapsed": 82.544875, + "row_count": 1 + } + ], + "start_time": 1783521764, + "success": true + }, + { + "query": "Query 98", + "iterations": [ + { + "elapsed": 106.096125, + "row_count": 2486 + }, + { + "elapsed": 107.819667, + "row_count": 2486 + }, + { + "elapsed": 106.01225000000001, + "row_count": 2486 + } + ], + "start_time": 1783521764, + "success": true + }, + { + "query": "Query 99", + "iterations": [ + { + "elapsed": 4239.04025, + "row_count": 90 + }, + { + "elapsed": 4343.546417, + "row_count": 90 + }, + { + "elapsed": 4270.528417, + "row_count": 90 + } + ], + "start_time": 1783521764, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521725, + "arguments": [ + "tpcds", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", + "--query_path", + "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", + "--prefer_hash_join", + "true", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpcds_off_r2.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/tpcds_on_r1.json b/ab_results/tpcds_on_r1.json new file mode 100644 index 0000000000000..5e1b76ae56f52 --- /dev/null +++ b/ab_results/tpcds_on_r1.json @@ -0,0 +1,1891 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521674, + "arguments": [ + "tpcds", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", + "--query_path", + "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", + "--prefer_hash_join", + "true", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpcds_on_r1.json" + ] + }, + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 5.137666, + "row_count": 0 + }, + { + "elapsed": 3.5387079999999997, + "row_count": 0 + }, + { + "elapsed": 3.811, + "row_count": 0 + } + ], + "start_time": 1783521674, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 100.669167, + "row_count": 2513 + }, + { + "elapsed": 101.501125, + "row_count": 2513 + }, + { + "elapsed": 103.34308300000001, + "row_count": 2513 + } + ], + "start_time": 1783521674, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 85.349833, + "row_count": 38 + }, + { + "elapsed": 108.28575, + "row_count": 38 + }, + { + "elapsed": 85.717167, + "row_count": 38 + } + ], + "start_time": 1783521674, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 891.011958, + "row_count": 8 + }, + { + "elapsed": 909.013333, + "row_count": 8 + }, + { + "elapsed": 877.169791, + "row_count": 8 + } + ], + "start_time": 1783521674, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 122.46374999999999, + "row_count": 100 + }, + { + "elapsed": 122.673084, + "row_count": 100 + }, + { + "elapsed": 124.776917, + "row_count": 100 + } + ], + "start_time": 1783521677, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 90.29475, + "row_count": 41 + }, + { + "elapsed": 85.181542, + "row_count": 41 + }, + { + "elapsed": 89.553833, + "row_count": 41 + } + ], + "start_time": 1783521677, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 226.51375000000002, + "row_count": 100 + }, + { + "elapsed": 223.395625, + "row_count": 100 + }, + { + "elapsed": 224.841042, + "row_count": 100 + } + ], + "start_time": 1783521678, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 81.43845800000001, + "row_count": 0 + }, + { + "elapsed": 80.28375, + "row_count": 0 + }, + { + "elapsed": 81.50375, + "row_count": 0 + } + ], + "start_time": 1783521678, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 92.34854200000001, + "row_count": 1 + }, + { + "elapsed": 80.691417, + "row_count": 1 + }, + { + "elapsed": 90.531167, + "row_count": 1 + } + ], + "start_time": 1783521679, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 87.388875, + "row_count": 2 + }, + { + "elapsed": 88.303208, + "row_count": 2 + }, + { + "elapsed": 88.26608399999999, + "row_count": 2 + } + ], + "start_time": 1783521679, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 575.053916, + "row_count": 88 + }, + { + "elapsed": 575.29975, + "row_count": 88 + }, + { + "elapsed": 579.6526250000001, + "row_count": 88 + } + ], + "start_time": 1783521679, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 30.378, + "row_count": 100 + }, + { + "elapsed": 30.268791999999998, + "row_count": 100 + }, + { + "elapsed": 30.801624999999998, + "row_count": 100 + } + ], + "start_time": 1783521681, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 279.397375, + "row_count": 1 + }, + { + "elapsed": 283.49841599999996, + "row_count": 1 + }, + { + "elapsed": 281.188625, + "row_count": 1 + } + ], + "start_time": 1783521681, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 763.604292, + "row_count": 100 + }, + { + "elapsed": 787.8129590000001, + "row_count": 100 + }, + { + "elapsed": 799.7091670000001, + "row_count": 100 + } + ], + "start_time": 1783521682, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 11.050917, + "row_count": 100 + }, + { + "elapsed": 10.530084, + "row_count": 100 + }, + { + "elapsed": 10.23775, + "row_count": 100 + } + ], + "start_time": 1783521684, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 4.503125, + "row_count": 1 + }, + { + "elapsed": 4.607375, + "row_count": 1 + }, + { + "elapsed": 4.514083, + "row_count": 1 + } + ], + "start_time": 1783521684, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 137.710334, + "row_count": 1 + }, + { + "elapsed": 134.649833, + "row_count": 1 + }, + { + "elapsed": 134.745584, + "row_count": 1 + } + ], + "start_time": 1783521684, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 91.263833, + "row_count": 100 + }, + { + "elapsed": 91.005, + "row_count": 100 + }, + { + "elapsed": 95.71829199999999, + "row_count": 100 + } + ], + "start_time": 1783521685, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 111.921459, + "row_count": 100 + }, + { + "elapsed": 111.229375, + "row_count": 100 + }, + { + "elapsed": 111.005167, + "row_count": 100 + } + ], + "start_time": 1783521685, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 9.246625, + "row_count": 100 + }, + { + "elapsed": 8.712582999999999, + "row_count": 100 + }, + { + "elapsed": 8.732875, + "row_count": 100 + } + ], + "start_time": 1783521685, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 11.745958000000002, + "row_count": 100 + }, + { + "elapsed": 11.213042, + "row_count": 100 + }, + { + "elapsed": 11.149, + "row_count": 100 + } + ], + "start_time": 1783521685, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 262.508125, + "row_count": 100 + }, + { + "elapsed": 258.13012499999996, + "row_count": 100 + }, + { + "elapsed": 264.370208, + "row_count": 100 + } + ], + "start_time": 1783521685, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 540.564334, + "row_count": 0 + }, + { + "elapsed": 522.971041, + "row_count": 0 + }, + { + "elapsed": 519.812584, + "row_count": 0 + } + ], + "start_time": 1783521686, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 429.578291, + "row_count": 0 + }, + { + "elapsed": 426.228791, + "row_count": 0 + }, + { + "elapsed": 428.853167, + "row_count": 0 + } + ], + "start_time": 1783521688, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 172.58262499999998, + "row_count": 0 + }, + { + "elapsed": 170.630625, + "row_count": 0 + }, + { + "elapsed": 167.57666600000002, + "row_count": 0 + } + ], + "start_time": 1783521689, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 53.210458, + "row_count": 100 + }, + { + "elapsed": 52.996874999999996, + "row_count": 100 + }, + { + "elapsed": 52.499459, + "row_count": 100 + } + ], + "start_time": 1783521689, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 4.043375, + "row_count": 1 + }, + { + "elapsed": 4.137667, + "row_count": 1 + }, + { + "elapsed": 3.724667, + "row_count": 1 + } + ], + "start_time": 1783521690, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 104.921375, + "row_count": 1 + }, + { + "elapsed": 102.59, + "row_count": 1 + }, + { + "elapsed": 106.534458, + "row_count": 1 + } + ], + "start_time": 1783521690, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 165.464709, + "row_count": 0 + }, + { + "elapsed": 164.312042, + "row_count": 0 + }, + { + "elapsed": 160.865, + "row_count": 0 + } + ], + "start_time": 1783521690, + "success": true + }, + { + "query": "Query 30", + "iterations": [], + "start_time": 1783521690, + "success": false + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 115.15758299999999, + "row_count": 51 + }, + { + "elapsed": 116.46275, + "row_count": 51 + }, + { + "elapsed": 135.086208, + "row_count": 51 + } + ], + "start_time": 1783521690, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 8.6565, + "row_count": 1 + }, + { + "elapsed": 8.376708, + "row_count": 1 + }, + { + "elapsed": 8.769709, + "row_count": 1 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 99.73216599999999, + "row_count": 100 + }, + { + "elapsed": 99.413667, + "row_count": 100 + }, + { + "elapsed": 100.44679199999999, + "row_count": 100 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 4.038125, + "row_count": 0 + }, + { + "elapsed": 4.068041, + "row_count": 0 + }, + { + "elapsed": 3.882458, + "row_count": 0 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 97.23633299999999, + "row_count": 100 + }, + { + "elapsed": 98.402875, + "row_count": 100 + }, + { + "elapsed": 98.09491700000001, + "row_count": 100 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 4.113334, + "row_count": 1 + }, + { + "elapsed": 4.483625, + "row_count": 1 + }, + { + "elapsed": 4.118583, + "row_count": 1 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 6.207666, + "row_count": 0 + }, + { + "elapsed": 5.561958, + "row_count": 0 + }, + { + "elapsed": 5.818458000000001, + "row_count": 0 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 92.89500000000001, + "row_count": 1 + }, + { + "elapsed": 91.060166, + "row_count": 1 + }, + { + "elapsed": 87.815333, + "row_count": 1 + } + ], + "start_time": 1783521691, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 52.913624999999996, + "row_count": 7 + }, + { + "elapsed": 52.045292, + "row_count": 7 + }, + { + "elapsed": 72.333084, + "row_count": 7 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 68.851625, + "row_count": 100 + }, + { + "elapsed": 65.429625, + "row_count": 100 + }, + { + "elapsed": 64.93708400000001, + "row_count": 100 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 8.806332999999999, + "row_count": 0 + }, + { + "elapsed": 8.791625000000002, + "row_count": 0 + }, + { + "elapsed": 8.754417, + "row_count": 0 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 79.657083, + "row_count": 10 + }, + { + "elapsed": 81.293542, + "row_count": 10 + }, + { + "elapsed": 81.066625, + "row_count": 10 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 43", + "iterations": [ + { + "elapsed": 3.2795419999999997, + "row_count": 0 + }, + { + "elapsed": 2.850417, + "row_count": 0 + }, + { + "elapsed": 2.996584, + "row_count": 0 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 44", + "iterations": [ + { + "elapsed": 5.040458999999999, + "row_count": 0 + }, + { + "elapsed": 4.674875, + "row_count": 0 + }, + { + "elapsed": 4.598959, + "row_count": 0 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 45", + "iterations": [ + { + "elapsed": 31.645, + "row_count": 16 + }, + { + "elapsed": 32.583584, + "row_count": 16 + }, + { + "elapsed": 31.502708, + "row_count": 16 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 46", + "iterations": [ + { + "elapsed": 4.776208, + "row_count": 0 + }, + { + "elapsed": 4.858208, + "row_count": 0 + }, + { + "elapsed": 4.695208999999999, + "row_count": 0 + } + ], + "start_time": 1783521692, + "success": true + }, + { + "query": "Query 47", + "iterations": [ + { + "elapsed": 434.6585, + "row_count": 100 + }, + { + "elapsed": 426.74925, + "row_count": 100 + }, + { + "elapsed": 431.065459, + "row_count": 100 + } + ], + "start_time": 1783521693, + "success": true + }, + { + "query": "Query 48", + "iterations": [ + { + "elapsed": 198.646542, + "row_count": 1 + }, + { + "elapsed": 194.130625, + "row_count": 1 + }, + { + "elapsed": 193.394666, + "row_count": 1 + } + ], + "start_time": 1783521694, + "success": true + }, + { + "query": "Query 49", + "iterations": [ + { + "elapsed": 167.93508300000002, + "row_count": 31 + }, + { + "elapsed": 165.550959, + "row_count": 31 + }, + { + "elapsed": 168.64225, + "row_count": 31 + } + ], + "start_time": 1783521694, + "success": true + }, + { + "query": "Query 50", + "iterations": [ + { + "elapsed": 124.276, + "row_count": 6 + }, + { + "elapsed": 119.782334, + "row_count": 6 + }, + { + "elapsed": 119.4825, + "row_count": 6 + } + ], + "start_time": 1783521695, + "success": true + }, + { + "query": "Query 51", + "iterations": [ + { + "elapsed": 120.21612499999999, + "row_count": 100 + }, + { + "elapsed": 118.949583, + "row_count": 100 + }, + { + "elapsed": 118.051, + "row_count": 100 + } + ], + "start_time": 1783521695, + "success": true + }, + { + "query": "Query 52", + "iterations": [ + { + "elapsed": 80.858666, + "row_count": 100 + }, + { + "elapsed": 80.377167, + "row_count": 100 + }, + { + "elapsed": 80.55883299999999, + "row_count": 100 + } + ], + "start_time": 1783521696, + "success": true + }, + { + "query": "Query 53", + "iterations": [ + { + "elapsed": 80.258542, + "row_count": 14 + }, + { + "elapsed": 77.172875, + "row_count": 14 + }, + { + "elapsed": 77.058458, + "row_count": 14 + } + ], + "start_time": 1783521696, + "success": true + }, + { + "query": "Query 54", + "iterations": [ + { + "elapsed": 106.06016699999999, + "row_count": 0 + }, + { + "elapsed": 103.403542, + "row_count": 0 + }, + { + "elapsed": 104.412, + "row_count": 0 + } + ], + "start_time": 1783521696, + "success": true + }, + { + "query": "Query 55", + "iterations": [ + { + "elapsed": 80.635917, + "row_count": 69 + }, + { + "elapsed": 80.731583, + "row_count": 69 + }, + { + "elapsed": 80.38654100000001, + "row_count": 69 + } + ], + "start_time": 1783521696, + "success": true + }, + { + "query": "Query 56", + "iterations": [ + { + "elapsed": 100.674584, + "row_count": 78 + }, + { + "elapsed": 99.990459, + "row_count": 78 + }, + { + "elapsed": 101.95958300000001, + "row_count": 78 + } + ], + "start_time": 1783521697, + "success": true + }, + { + "query": "Query 57", + "iterations": [ + { + "elapsed": 104.906667, + "row_count": 100 + }, + { + "elapsed": 103.818167, + "row_count": 100 + }, + { + "elapsed": 104.153541, + "row_count": 100 + } + ], + "start_time": 1783521697, + "success": true + }, + { + "query": "Query 58", + "iterations": [ + { + "elapsed": 198.862459, + "row_count": 0 + }, + { + "elapsed": 199.094042, + "row_count": 0 + }, + { + "elapsed": 198.233, + "row_count": 0 + } + ], + "start_time": 1783521697, + "success": true + }, + { + "query": "Query 59", + "iterations": [ + { + "elapsed": 125.254833, + "row_count": 100 + }, + { + "elapsed": 125.24737499999999, + "row_count": 100 + }, + { + "elapsed": 126.627958, + "row_count": 100 + } + ], + "start_time": 1783521698, + "success": true + }, + { + "query": "Query 60", + "iterations": [ + { + "elapsed": 100.90670899999999, + "row_count": 100 + }, + { + "elapsed": 103.191, + "row_count": 100 + }, + { + "elapsed": 103.868792, + "row_count": 100 + } + ], + "start_time": 1783521698, + "success": true + }, + { + "query": "Query 61", + "iterations": [ + { + "elapsed": 7.884499999999999, + "row_count": 1 + }, + { + "elapsed": 7.749, + "row_count": 1 + }, + { + "elapsed": 7.4844170000000005, + "row_count": 1 + } + ], + "start_time": 1783521699, + "success": true + }, + { + "query": "Query 62", + "iterations": [ + { + "elapsed": 393.63116599999995, + "row_count": 100 + }, + { + "elapsed": 371.104708, + "row_count": 100 + }, + { + "elapsed": 367.381625, + "row_count": 100 + } + ], + "start_time": 1783521699, + "success": true + }, + { + "query": "Query 63", + "iterations": [ + { + "elapsed": 74.81224999999999, + "row_count": 44 + }, + { + "elapsed": 74.302916, + "row_count": 44 + }, + { + "elapsed": 73.163875, + "row_count": 44 + } + ], + "start_time": 1783521700, + "success": true + }, + { + "query": "Query 64", + "iterations": [ + { + "elapsed": 451.046625, + "row_count": 10 + }, + { + "elapsed": 440.084166, + "row_count": 10 + }, + { + "elapsed": 438.815791, + "row_count": 10 + } + ], + "start_time": 1783521700, + "success": true + }, + { + "query": "Query 65", + "iterations": [ + { + "elapsed": 169.030666, + "row_count": 100 + }, + { + "elapsed": 168.717875, + "row_count": 100 + }, + { + "elapsed": 170.424041, + "row_count": 100 + } + ], + "start_time": 1783521701, + "success": true + }, + { + "query": "Query 66", + "iterations": [ + { + "elapsed": 142.970166, + "row_count": 5 + }, + { + "elapsed": 134.49625, + "row_count": 5 + }, + { + "elapsed": 135.5605, + "row_count": 5 + } + ], + "start_time": 1783521702, + "success": true + }, + { + "query": "Query 67", + "iterations": [ + { + "elapsed": 306.416583, + "row_count": 100 + }, + { + "elapsed": 313.14404099999996, + "row_count": 100 + }, + { + "elapsed": 313.352916, + "row_count": 100 + } + ], + "start_time": 1783521702, + "success": true + }, + { + "query": "Query 68", + "iterations": [ + { + "elapsed": 5.185582999999999, + "row_count": 0 + }, + { + "elapsed": 5.011833, + "row_count": 0 + }, + { + "elapsed": 4.644917, + "row_count": 0 + } + ], + "start_time": 1783521703, + "success": true + }, + { + "query": "Query 69", + "iterations": [ + { + "elapsed": 78.081, + "row_count": 100 + }, + { + "elapsed": 77.149542, + "row_count": 100 + }, + { + "elapsed": 76.93420900000001, + "row_count": 100 + } + ], + "start_time": 1783521703, + "success": true + }, + { + "query": "Query 70", + "iterations": [ + { + "elapsed": 220.682333, + "row_count": 3 + }, + { + "elapsed": 223.17275, + "row_count": 3 + }, + { + "elapsed": 224.474875, + "row_count": 3 + } + ], + "start_time": 1783521703, + "success": true + }, + { + "query": "Query 71", + "iterations": [ + { + "elapsed": 96.363708, + "row_count": 1102 + }, + { + "elapsed": 96.618416, + "row_count": 1102 + }, + { + "elapsed": 96.23825, + "row_count": 1102 + } + ], + "start_time": 1783521704, + "success": true + }, + { + "query": "Query 72", + "iterations": [ + { + "elapsed": 424.67925, + "row_count": 100 + }, + { + "elapsed": 409.80375000000004, + "row_count": 100 + }, + { + "elapsed": 409.832459, + "row_count": 100 + } + ], + "start_time": 1783521704, + "success": true + }, + { + "query": "Query 73", + "iterations": [ + { + "elapsed": 3.9355420000000003, + "row_count": 0 + }, + { + "elapsed": 3.644792, + "row_count": 0 + }, + { + "elapsed": 3.9336670000000002, + "row_count": 0 + } + ], + "start_time": 1783521706, + "success": true + }, + { + "query": "Query 74", + "iterations": [ + { + "elapsed": 346.756958, + "row_count": 90 + }, + { + "elapsed": 355.018625, + "row_count": 90 + }, + { + "elapsed": 369.07041699999996, + "row_count": 90 + } + ], + "start_time": 1783521706, + "success": true + }, + { + "query": "Query 75", + "iterations": [ + { + "elapsed": 211.343584, + "row_count": 100 + }, + { + "elapsed": 188.257, + "row_count": 100 + }, + { + "elapsed": 188.849375, + "row_count": 100 + } + ], + "start_time": 1783521707, + "success": true + }, + { + "query": "Query 76", + "iterations": [ + { + "elapsed": 91.033417, + "row_count": 100 + }, + { + "elapsed": 89.759542, + "row_count": 100 + }, + { + "elapsed": 90.940541, + "row_count": 100 + } + ], + "start_time": 1783521707, + "success": true + }, + { + "query": "Query 77", + "iterations": [ + { + "elapsed": 134.253625, + "row_count": 44 + }, + { + "elapsed": 133.53537500000002, + "row_count": 44 + }, + { + "elapsed": 134.37625, + "row_count": 44 + } + ], + "start_time": 1783521707, + "success": true + }, + { + "query": "Query 78", + "iterations": [ + { + "elapsed": 222.918375, + "row_count": 100 + }, + { + "elapsed": 223.480166, + "row_count": 100 + }, + { + "elapsed": 222.331, + "row_count": 100 + } + ], + "start_time": 1783521708, + "success": true + }, + { + "query": "Query 79", + "iterations": [ + { + "elapsed": 156.448, + "row_count": 100 + }, + { + "elapsed": 155.5225, + "row_count": 100 + }, + { + "elapsed": 159.88666600000002, + "row_count": 100 + } + ], + "start_time": 1783521709, + "success": true + }, + { + "query": "Query 80", + "iterations": [ + { + "elapsed": 212.6855, + "row_count": 100 + }, + { + "elapsed": 210.21816700000002, + "row_count": 100 + }, + { + "elapsed": 210.498834, + "row_count": 100 + } + ], + "start_time": 1783521709, + "success": true + }, + { + "query": "Query 81", + "iterations": [ + { + "elapsed": 16.412083000000003, + "row_count": 96 + }, + { + "elapsed": 16.630125, + "row_count": 96 + }, + { + "elapsed": 16.523166, + "row_count": 96 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 82", + "iterations": [ + { + "elapsed": 28.184041, + "row_count": 1 + }, + { + "elapsed": 28.490624999999998, + "row_count": 1 + }, + { + "elapsed": 28.374416, + "row_count": 1 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 83", + "iterations": [ + { + "elapsed": 23.28875, + "row_count": 4 + }, + { + "elapsed": 23.298083000000002, + "row_count": 4 + }, + { + "elapsed": 23.551041, + "row_count": 4 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 84", + "iterations": [ + { + "elapsed": 29.425542, + "row_count": 22 + }, + { + "elapsed": 29.919833, + "row_count": 22 + }, + { + "elapsed": 31.260958, + "row_count": 22 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 85", + "iterations": [ + { + "elapsed": 107.22125, + "row_count": 3 + }, + { + "elapsed": 105.810291, + "row_count": 3 + }, + { + "elapsed": 105.998958, + "row_count": 3 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 86", + "iterations": [ + { + "elapsed": 28.345, + "row_count": 100 + }, + { + "elapsed": 28.307917, + "row_count": 100 + }, + { + "elapsed": 28.841333, + "row_count": 100 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 87", + "iterations": [ + { + "elapsed": 88.434833, + "row_count": 1 + }, + { + "elapsed": 89.114209, + "row_count": 1 + }, + { + "elapsed": 88.0045, + "row_count": 1 + } + ], + "start_time": 1783521710, + "success": true + }, + { + "query": "Query 88", + "iterations": [ + { + "elapsed": 67.396541, + "row_count": 1 + }, + { + "elapsed": 65.206375, + "row_count": 1 + }, + { + "elapsed": 65.914833, + "row_count": 1 + } + ], + "start_time": 1783521711, + "success": true + }, + { + "query": "Query 89", + "iterations": [ + { + "elapsed": 84.49179199999999, + "row_count": 100 + }, + { + "elapsed": 85.78337499999999, + "row_count": 100 + }, + { + "elapsed": 85.05083300000001, + "row_count": 100 + } + ], + "start_time": 1783521711, + "success": true + }, + { + "query": "Query 90", + "iterations": [ + { + "elapsed": 14.134917, + "row_count": 1 + }, + { + "elapsed": 14.288375, + "row_count": 1 + }, + { + "elapsed": 13.961917000000001, + "row_count": 1 + } + ], + "start_time": 1783521711, + "success": true + }, + { + "query": "Query 91", + "iterations": [ + { + "elapsed": 43.964541000000004, + "row_count": 4 + }, + { + "elapsed": 43.25625, + "row_count": 4 + }, + { + "elapsed": 42.927791, + "row_count": 4 + } + ], + "start_time": 1783521711, + "success": true + }, + { + "query": "Query 92", + "iterations": [ + { + "elapsed": 41.044625, + "row_count": 1 + }, + { + "elapsed": 41.476666, + "row_count": 1 + }, + { + "elapsed": 41.761083, + "row_count": 1 + } + ], + "start_time": 1783521711, + "success": true + }, + { + "query": "Query 93", + "iterations": [ + { + "elapsed": 113.716333, + "row_count": 100 + }, + { + "elapsed": 109.940541, + "row_count": 100 + }, + { + "elapsed": 110.01441700000001, + "row_count": 100 + } + ], + "start_time": 1783521711, + "success": true + }, + { + "query": "Query 94", + "iterations": [ + { + "elapsed": 42.226082999999996, + "row_count": 1 + }, + { + "elapsed": 41.750375, + "row_count": 1 + }, + { + "elapsed": 42.425625000000004, + "row_count": 1 + } + ], + "start_time": 1783521712, + "success": true + }, + { + "query": "Query 95", + "iterations": [ + { + "elapsed": 55.699625000000005, + "row_count": 1 + }, + { + "elapsed": 56.908958000000005, + "row_count": 1 + }, + { + "elapsed": 55.745125, + "row_count": 1 + } + ], + "start_time": 1783521712, + "success": true + }, + { + "query": "Query 96", + "iterations": [ + { + "elapsed": 50.58, + "row_count": 1 + }, + { + "elapsed": 49.690708, + "row_count": 1 + }, + { + "elapsed": 50.009291999999995, + "row_count": 1 + } + ], + "start_time": 1783521712, + "success": true + }, + { + "query": "Query 97", + "iterations": [ + { + "elapsed": 81.737625, + "row_count": 1 + }, + { + "elapsed": 80.69525, + "row_count": 1 + }, + { + "elapsed": 81.893375, + "row_count": 1 + } + ], + "start_time": 1783521712, + "success": true + }, + { + "query": "Query 98", + "iterations": [ + { + "elapsed": 107.472916, + "row_count": 2486 + }, + { + "elapsed": 105.68416599999999, + "row_count": 2486 + }, + { + "elapsed": 107.526667, + "row_count": 2486 + } + ], + "start_time": 1783521712, + "success": true + }, + { + "query": "Query 99", + "iterations": [ + { + "elapsed": 4230.284917, + "row_count": 90 + }, + { + "elapsed": 4192.377209, + "row_count": 90 + }, + { + "elapsed": 4239.053084, + "row_count": 90 + } + ], + "start_time": 1783521713, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/tpcds_on_r2.json b/ab_results/tpcds_on_r2.json new file mode 100644 index 0000000000000..9cf8819159890 --- /dev/null +++ b/ab_results/tpcds_on_r2.json @@ -0,0 +1,1891 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521777, + "arguments": [ + "tpcds", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", + "--query_path", + "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", + "--prefer_hash_join", + "true", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpcds_on_r2.json" + ] + }, + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 5.533583, + "row_count": 0 + }, + { + "elapsed": 3.704292, + "row_count": 0 + }, + { + "elapsed": 3.765209, + "row_count": 0 + } + ], + "start_time": 1783521777, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 101.31195799999999, + "row_count": 2513 + }, + { + "elapsed": 118.858, + "row_count": 2513 + }, + { + "elapsed": 111.984459, + "row_count": 2513 + } + ], + "start_time": 1783521777, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 86.036917, + "row_count": 38 + }, + { + "elapsed": 85.860083, + "row_count": 38 + }, + { + "elapsed": 83.86, + "row_count": 38 + } + ], + "start_time": 1783521778, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 887.956167, + "row_count": 8 + }, + { + "elapsed": 940.129541, + "row_count": 8 + }, + { + "elapsed": 907.008625, + "row_count": 8 + } + ], + "start_time": 1783521778, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 124.11504099999999, + "row_count": 100 + }, + { + "elapsed": 124.627459, + "row_count": 100 + }, + { + "elapsed": 126.77487500000001, + "row_count": 100 + } + ], + "start_time": 1783521781, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 89.33874999999999, + "row_count": 41 + }, + { + "elapsed": 89.73420899999999, + "row_count": 41 + }, + { + "elapsed": 87.981875, + "row_count": 41 + } + ], + "start_time": 1783521781, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 226.276541, + "row_count": 100 + }, + { + "elapsed": 223.550292, + "row_count": 100 + }, + { + "elapsed": 223.221167, + "row_count": 100 + } + ], + "start_time": 1783521781, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 82.048542, + "row_count": 0 + }, + { + "elapsed": 82.210583, + "row_count": 0 + }, + { + "elapsed": 83.03399999999999, + "row_count": 0 + } + ], + "start_time": 1783521782, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 87.391209, + "row_count": 1 + }, + { + "elapsed": 91.518917, + "row_count": 1 + }, + { + "elapsed": 101.34162500000001, + "row_count": 1 + } + ], + "start_time": 1783521782, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 87.382125, + "row_count": 2 + }, + { + "elapsed": 88.217458, + "row_count": 2 + }, + { + "elapsed": 88.37337500000001, + "row_count": 2 + } + ], + "start_time": 1783521782, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 589.3940829999999, + "row_count": 88 + }, + { + "elapsed": 575.1632500000001, + "row_count": 88 + }, + { + "elapsed": 569.699667, + "row_count": 88 + } + ], + "start_time": 1783521783, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 30.790208, + "row_count": 100 + }, + { + "elapsed": 30.01475, + "row_count": 100 + }, + { + "elapsed": 30.047958, + "row_count": 100 + } + ], + "start_time": 1783521784, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 274.31149999999997, + "row_count": 1 + }, + { + "elapsed": 275.582416, + "row_count": 1 + }, + { + "elapsed": 276.92920799999996, + "row_count": 1 + } + ], + "start_time": 1783521785, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 757.513375, + "row_count": 100 + }, + { + "elapsed": 758.030541, + "row_count": 100 + }, + { + "elapsed": 760.844875, + "row_count": 100 + } + ], + "start_time": 1783521785, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 11.329291, + "row_count": 100 + }, + { + "elapsed": 10.549083000000001, + "row_count": 100 + }, + { + "elapsed": 10.311582999999999, + "row_count": 100 + } + ], + "start_time": 1783521788, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 4.630584, + "row_count": 1 + }, + { + "elapsed": 4.030708, + "row_count": 1 + }, + { + "elapsed": 4.07925, + "row_count": 1 + } + ], + "start_time": 1783521788, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 136.115125, + "row_count": 1 + }, + { + "elapsed": 133.737209, + "row_count": 1 + }, + { + "elapsed": 134.402083, + "row_count": 1 + } + ], + "start_time": 1783521788, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 92.613208, + "row_count": 100 + }, + { + "elapsed": 90.72562500000001, + "row_count": 100 + }, + { + "elapsed": 93.281958, + "row_count": 100 + } + ], + "start_time": 1783521788, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 110.482, + "row_count": 100 + }, + { + "elapsed": 112.380708, + "row_count": 100 + }, + { + "elapsed": 111.30862499999999, + "row_count": 100 + } + ], + "start_time": 1783521788, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 8.670541, + "row_count": 100 + }, + { + "elapsed": 8.688833, + "row_count": 100 + }, + { + "elapsed": 8.627875, + "row_count": 100 + } + ], + "start_time": 1783521789, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 11.09425, + "row_count": 100 + }, + { + "elapsed": 11.140583000000001, + "row_count": 100 + }, + { + "elapsed": 11.156083, + "row_count": 100 + } + ], + "start_time": 1783521789, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 259.171208, + "row_count": 100 + }, + { + "elapsed": 257.850125, + "row_count": 100 + }, + { + "elapsed": 260.034042, + "row_count": 100 + } + ], + "start_time": 1783521789, + "success": true + }, + { + "query": "Query 23", + "iterations": [ + { + "elapsed": 519.405708, + "row_count": 0 + }, + { + "elapsed": 517.973625, + "row_count": 0 + }, + { + "elapsed": 521.3017920000001, + "row_count": 0 + } + ], + "start_time": 1783521790, + "success": true + }, + { + "query": "Query 24", + "iterations": [ + { + "elapsed": 427.794667, + "row_count": 0 + }, + { + "elapsed": 421.783167, + "row_count": 0 + }, + { + "elapsed": 425.042458, + "row_count": 0 + } + ], + "start_time": 1783521791, + "success": true + }, + { + "query": "Query 25", + "iterations": [ + { + "elapsed": 170.95125, + "row_count": 0 + }, + { + "elapsed": 167.613125, + "row_count": 0 + }, + { + "elapsed": 167.967708, + "row_count": 0 + } + ], + "start_time": 1783521792, + "success": true + }, + { + "query": "Query 26", + "iterations": [ + { + "elapsed": 52.990041000000005, + "row_count": 100 + }, + { + "elapsed": 52.562292, + "row_count": 100 + }, + { + "elapsed": 52.048166, + "row_count": 100 + } + ], + "start_time": 1783521793, + "success": true + }, + { + "query": "Query 27", + "iterations": [ + { + "elapsed": 3.9410410000000002, + "row_count": 1 + }, + { + "elapsed": 3.689708, + "row_count": 1 + }, + { + "elapsed": 3.388375, + "row_count": 1 + } + ], + "start_time": 1783521793, + "success": true + }, + { + "query": "Query 28", + "iterations": [ + { + "elapsed": 102.61175, + "row_count": 1 + }, + { + "elapsed": 103.745917, + "row_count": 1 + }, + { + "elapsed": 104.06375, + "row_count": 1 + } + ], + "start_time": 1783521793, + "success": true + }, + { + "query": "Query 29", + "iterations": [ + { + "elapsed": 168.71604200000002, + "row_count": 0 + }, + { + "elapsed": 164.501333, + "row_count": 0 + }, + { + "elapsed": 162.86012499999998, + "row_count": 0 + } + ], + "start_time": 1783521793, + "success": true + }, + { + "query": "Query 30", + "iterations": [], + "start_time": 1783521794, + "success": false + }, + { + "query": "Query 31", + "iterations": [ + { + "elapsed": 115.7615, + "row_count": 51 + }, + { + "elapsed": 116.012666, + "row_count": 51 + }, + { + "elapsed": 115.29845800000001, + "row_count": 51 + } + ], + "start_time": 1783521794, + "success": true + }, + { + "query": "Query 32", + "iterations": [ + { + "elapsed": 8.958125, + "row_count": 1 + }, + { + "elapsed": 8.209375, + "row_count": 1 + }, + { + "elapsed": 8.689834000000001, + "row_count": 1 + } + ], + "start_time": 1783521794, + "success": true + }, + { + "query": "Query 33", + "iterations": [ + { + "elapsed": 98.966875, + "row_count": 100 + }, + { + "elapsed": 99.96712500000001, + "row_count": 100 + }, + { + "elapsed": 99.808875, + "row_count": 100 + } + ], + "start_time": 1783521794, + "success": true + }, + { + "query": "Query 34", + "iterations": [ + { + "elapsed": 3.9163749999999995, + "row_count": 0 + }, + { + "elapsed": 4.290417000000001, + "row_count": 0 + }, + { + "elapsed": 3.780833, + "row_count": 0 + } + ], + "start_time": 1783521794, + "success": true + }, + { + "query": "Query 35", + "iterations": [ + { + "elapsed": 95.78629099999999, + "row_count": 100 + }, + { + "elapsed": 96.646167, + "row_count": 100 + }, + { + "elapsed": 97.29425, + "row_count": 100 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 36", + "iterations": [ + { + "elapsed": 3.7439169999999997, + "row_count": 1 + }, + { + "elapsed": 3.751625, + "row_count": 1 + }, + { + "elapsed": 3.652125, + "row_count": 1 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 37", + "iterations": [ + { + "elapsed": 5.497459, + "row_count": 0 + }, + { + "elapsed": 5.13575, + "row_count": 0 + }, + { + "elapsed": 5.134708, + "row_count": 0 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 38", + "iterations": [ + { + "elapsed": 85.63550000000001, + "row_count": 1 + }, + { + "elapsed": 87.071917, + "row_count": 1 + }, + { + "elapsed": 87.628, + "row_count": 1 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 39", + "iterations": [ + { + "elapsed": 51.772459, + "row_count": 7 + }, + { + "elapsed": 53.154333, + "row_count": 7 + }, + { + "elapsed": 52.704125, + "row_count": 7 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 40", + "iterations": [ + { + "elapsed": 69.818125, + "row_count": 100 + }, + { + "elapsed": 83.319291, + "row_count": 100 + }, + { + "elapsed": 65.587959, + "row_count": 100 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 41", + "iterations": [ + { + "elapsed": 9.12875, + "row_count": 0 + }, + { + "elapsed": 8.826, + "row_count": 0 + }, + { + "elapsed": 8.879708, + "row_count": 0 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 42", + "iterations": [ + { + "elapsed": 79.684083, + "row_count": 10 + }, + { + "elapsed": 79.878542, + "row_count": 10 + }, + { + "elapsed": 80.134041, + "row_count": 10 + } + ], + "start_time": 1783521795, + "success": true + }, + { + "query": "Query 43", + "iterations": [ + { + "elapsed": 3.2904169999999997, + "row_count": 0 + }, + { + "elapsed": 2.993, + "row_count": 0 + }, + { + "elapsed": 3.10025, + "row_count": 0 + } + ], + "start_time": 1783521796, + "success": true + }, + { + "query": "Query 44", + "iterations": [ + { + "elapsed": 4.866167, + "row_count": 0 + }, + { + "elapsed": 4.778250000000001, + "row_count": 0 + }, + { + "elapsed": 4.616625, + "row_count": 0 + } + ], + "start_time": 1783521796, + "success": true + }, + { + "query": "Query 45", + "iterations": [ + { + "elapsed": 31.173709000000002, + "row_count": 16 + }, + { + "elapsed": 30.766292, + "row_count": 16 + }, + { + "elapsed": 30.636459000000002, + "row_count": 16 + } + ], + "start_time": 1783521796, + "success": true + }, + { + "query": "Query 46", + "iterations": [ + { + "elapsed": 4.834292, + "row_count": 0 + }, + { + "elapsed": 4.584459, + "row_count": 0 + }, + { + "elapsed": 4.4100839999999994, + "row_count": 0 + } + ], + "start_time": 1783521796, + "success": true + }, + { + "query": "Query 47", + "iterations": [ + { + "elapsed": 428.428084, + "row_count": 100 + }, + { + "elapsed": 435.96212499999996, + "row_count": 100 + }, + { + "elapsed": 428.84299999999996, + "row_count": 100 + } + ], + "start_time": 1783521796, + "success": true + }, + { + "query": "Query 48", + "iterations": [ + { + "elapsed": 196.267167, + "row_count": 1 + }, + { + "elapsed": 195.39379200000002, + "row_count": 1 + }, + { + "elapsed": 194.758625, + "row_count": 1 + } + ], + "start_time": 1783521797, + "success": true + }, + { + "query": "Query 49", + "iterations": [ + { + "elapsed": 167.7655, + "row_count": 31 + }, + { + "elapsed": 166.823292, + "row_count": 31 + }, + { + "elapsed": 166.96291699999998, + "row_count": 31 + } + ], + "start_time": 1783521798, + "success": true + }, + { + "query": "Query 50", + "iterations": [ + { + "elapsed": 125.708458, + "row_count": 6 + }, + { + "elapsed": 120.504333, + "row_count": 6 + }, + { + "elapsed": 118.470334, + "row_count": 6 + } + ], + "start_time": 1783521798, + "success": true + }, + { + "query": "Query 51", + "iterations": [ + { + "elapsed": 117.209792, + "row_count": 100 + }, + { + "elapsed": 116.249875, + "row_count": 100 + }, + { + "elapsed": 118.09308300000001, + "row_count": 100 + } + ], + "start_time": 1783521799, + "success": true + }, + { + "query": "Query 52", + "iterations": [ + { + "elapsed": 80.307959, + "row_count": 100 + }, + { + "elapsed": 80.249166, + "row_count": 100 + }, + { + "elapsed": 79.882708, + "row_count": 100 + } + ], + "start_time": 1783521799, + "success": true + }, + { + "query": "Query 53", + "iterations": [ + { + "elapsed": 73.918667, + "row_count": 14 + }, + { + "elapsed": 73.21775, + "row_count": 14 + }, + { + "elapsed": 76.746375, + "row_count": 14 + } + ], + "start_time": 1783521799, + "success": true + }, + { + "query": "Query 54", + "iterations": [ + { + "elapsed": 102.18325, + "row_count": 0 + }, + { + "elapsed": 103.68508299999999, + "row_count": 0 + }, + { + "elapsed": 102.224583, + "row_count": 0 + } + ], + "start_time": 1783521799, + "success": true + }, + { + "query": "Query 55", + "iterations": [ + { + "elapsed": 79.514667, + "row_count": 69 + }, + { + "elapsed": 79.673125, + "row_count": 69 + }, + { + "elapsed": 79.73912499999999, + "row_count": 69 + } + ], + "start_time": 1783521800, + "success": true + }, + { + "query": "Query 56", + "iterations": [ + { + "elapsed": 99.166084, + "row_count": 78 + }, + { + "elapsed": 99.362541, + "row_count": 78 + }, + { + "elapsed": 99.8615, + "row_count": 78 + } + ], + "start_time": 1783521800, + "success": true + }, + { + "query": "Query 57", + "iterations": [ + { + "elapsed": 105.533792, + "row_count": 100 + }, + { + "elapsed": 104.964583, + "row_count": 100 + }, + { + "elapsed": 104.24591699999999, + "row_count": 100 + } + ], + "start_time": 1783521800, + "success": true + }, + { + "query": "Query 58", + "iterations": [ + { + "elapsed": 197.116, + "row_count": 0 + }, + { + "elapsed": 198.846208, + "row_count": 0 + }, + { + "elapsed": 197.56370900000002, + "row_count": 0 + } + ], + "start_time": 1783521801, + "success": true + }, + { + "query": "Query 59", + "iterations": [ + { + "elapsed": 123.737333, + "row_count": 100 + }, + { + "elapsed": 143.18975, + "row_count": 100 + }, + { + "elapsed": 125.226042, + "row_count": 100 + } + ], + "start_time": 1783521801, + "success": true + }, + { + "query": "Query 60", + "iterations": [ + { + "elapsed": 99.803583, + "row_count": 100 + }, + { + "elapsed": 101.244625, + "row_count": 100 + }, + { + "elapsed": 99.348125, + "row_count": 100 + } + ], + "start_time": 1783521802, + "success": true + }, + { + "query": "Query 61", + "iterations": [ + { + "elapsed": 7.541084, + "row_count": 1 + }, + { + "elapsed": 7.132875, + "row_count": 1 + }, + { + "elapsed": 6.870084, + "row_count": 1 + } + ], + "start_time": 1783521802, + "success": true + }, + { + "query": "Query 62", + "iterations": [ + { + "elapsed": 371.33337500000005, + "row_count": 100 + }, + { + "elapsed": 361.565334, + "row_count": 100 + }, + { + "elapsed": 360.176125, + "row_count": 100 + } + ], + "start_time": 1783521802, + "success": true + }, + { + "query": "Query 63", + "iterations": [ + { + "elapsed": 73.317875, + "row_count": 44 + }, + { + "elapsed": 73.250667, + "row_count": 44 + }, + { + "elapsed": 77.40558300000001, + "row_count": 44 + } + ], + "start_time": 1783521803, + "success": true + }, + { + "query": "Query 64", + "iterations": [ + { + "elapsed": 452.63608300000004, + "row_count": 10 + }, + { + "elapsed": 436.86504199999996, + "row_count": 10 + }, + { + "elapsed": 436.507166, + "row_count": 10 + } + ], + "start_time": 1783521803, + "success": true + }, + { + "query": "Query 65", + "iterations": [ + { + "elapsed": 169.247708, + "row_count": 100 + }, + { + "elapsed": 168.922917, + "row_count": 100 + }, + { + "elapsed": 166.741333, + "row_count": 100 + } + ], + "start_time": 1783521805, + "success": true + }, + { + "query": "Query 66", + "iterations": [ + { + "elapsed": 141.208292, + "row_count": 5 + }, + { + "elapsed": 145.106459, + "row_count": 5 + }, + { + "elapsed": 139.79625000000001, + "row_count": 5 + } + ], + "start_time": 1783521805, + "success": true + }, + { + "query": "Query 67", + "iterations": [ + { + "elapsed": 302.92291700000004, + "row_count": 100 + }, + { + "elapsed": 308.70133300000003, + "row_count": 100 + }, + { + "elapsed": 321.21812500000004, + "row_count": 100 + } + ], + "start_time": 1783521805, + "success": true + }, + { + "query": "Query 68", + "iterations": [ + { + "elapsed": 5.093292, + "row_count": 0 + }, + { + "elapsed": 4.9243749999999995, + "row_count": 0 + }, + { + "elapsed": 4.871, + "row_count": 0 + } + ], + "start_time": 1783521806, + "success": true + }, + { + "query": "Query 69", + "iterations": [ + { + "elapsed": 76.476292, + "row_count": 100 + }, + { + "elapsed": 77.589084, + "row_count": 100 + }, + { + "elapsed": 79.041375, + "row_count": 100 + } + ], + "start_time": 1783521806, + "success": true + }, + { + "query": "Query 70", + "iterations": [ + { + "elapsed": 221.24675, + "row_count": 3 + }, + { + "elapsed": 216.415917, + "row_count": 3 + }, + { + "elapsed": 220.60766700000002, + "row_count": 3 + } + ], + "start_time": 1783521807, + "success": true + }, + { + "query": "Query 71", + "iterations": [ + { + "elapsed": 98.17654200000001, + "row_count": 1102 + }, + { + "elapsed": 96.141791, + "row_count": 1102 + }, + { + "elapsed": 94.747084, + "row_count": 1102 + } + ], + "start_time": 1783521807, + "success": true + }, + { + "query": "Query 72", + "iterations": [ + { + "elapsed": 455.37041700000003, + "row_count": 100 + }, + { + "elapsed": 431.05850000000004, + "row_count": 100 + }, + { + "elapsed": 451.86041700000004, + "row_count": 100 + } + ], + "start_time": 1783521808, + "success": true + }, + { + "query": "Query 73", + "iterations": [ + { + "elapsed": 4.677125, + "row_count": 0 + }, + { + "elapsed": 4.337958, + "row_count": 0 + }, + { + "elapsed": 4.255375, + "row_count": 0 + } + ], + "start_time": 1783521809, + "success": true + }, + { + "query": "Query 74", + "iterations": [ + { + "elapsed": 353.996292, + "row_count": 90 + }, + { + "elapsed": 355.61120800000003, + "row_count": 90 + }, + { + "elapsed": 347.82408300000003, + "row_count": 90 + } + ], + "start_time": 1783521809, + "success": true + }, + { + "query": "Query 75", + "iterations": [ + { + "elapsed": 190.77658399999999, + "row_count": 100 + }, + { + "elapsed": 189.115167, + "row_count": 100 + }, + { + "elapsed": 192.005666, + "row_count": 100 + } + ], + "start_time": 1783521810, + "success": true + }, + { + "query": "Query 76", + "iterations": [ + { + "elapsed": 91.158084, + "row_count": 100 + }, + { + "elapsed": 92.218459, + "row_count": 100 + }, + { + "elapsed": 91.48266600000001, + "row_count": 100 + } + ], + "start_time": 1783521811, + "success": true + }, + { + "query": "Query 77", + "iterations": [ + { + "elapsed": 135.36075, + "row_count": 44 + }, + { + "elapsed": 135.06354100000001, + "row_count": 44 + }, + { + "elapsed": 136.2185, + "row_count": 44 + } + ], + "start_time": 1783521811, + "success": true + }, + { + "query": "Query 78", + "iterations": [ + { + "elapsed": 226.816542, + "row_count": 100 + }, + { + "elapsed": 225.357042, + "row_count": 100 + }, + { + "elapsed": 228.267959, + "row_count": 100 + } + ], + "start_time": 1783521811, + "success": true + }, + { + "query": "Query 79", + "iterations": [ + { + "elapsed": 159.812042, + "row_count": 100 + }, + { + "elapsed": 156.60708400000001, + "row_count": 100 + }, + { + "elapsed": 176.886459, + "row_count": 100 + } + ], + "start_time": 1783521812, + "success": true + }, + { + "query": "Query 80", + "iterations": [ + { + "elapsed": 216.506583, + "row_count": 100 + }, + { + "elapsed": 214.081041, + "row_count": 100 + }, + { + "elapsed": 213.223166, + "row_count": 100 + } + ], + "start_time": 1783521812, + "success": true + }, + { + "query": "Query 81", + "iterations": [ + { + "elapsed": 16.60625, + "row_count": 96 + }, + { + "elapsed": 16.293417, + "row_count": 96 + }, + { + "elapsed": 17.295499999999997, + "row_count": 96 + } + ], + "start_time": 1783521813, + "success": true + }, + { + "query": "Query 82", + "iterations": [ + { + "elapsed": 28.223583, + "row_count": 1 + }, + { + "elapsed": 28.294708, + "row_count": 1 + }, + { + "elapsed": 28.467167, + "row_count": 1 + } + ], + "start_time": 1783521813, + "success": true + }, + { + "query": "Query 83", + "iterations": [ + { + "elapsed": 24.374041, + "row_count": 4 + }, + { + "elapsed": 23.420083, + "row_count": 4 + }, + { + "elapsed": 23.920292, + "row_count": 4 + } + ], + "start_time": 1783521813, + "success": true + }, + { + "query": "Query 84", + "iterations": [ + { + "elapsed": 29.511665999999998, + "row_count": 22 + }, + { + "elapsed": 29.402749999999997, + "row_count": 22 + }, + { + "elapsed": 29.329166999999998, + "row_count": 22 + } + ], + "start_time": 1783521813, + "success": true + }, + { + "query": "Query 85", + "iterations": [ + { + "elapsed": 108.797292, + "row_count": 3 + }, + { + "elapsed": 106.18225000000001, + "row_count": 3 + }, + { + "elapsed": 105.327, + "row_count": 3 + } + ], + "start_time": 1783521813, + "success": true + }, + { + "query": "Query 86", + "iterations": [ + { + "elapsed": 28.772167, + "row_count": 100 + }, + { + "elapsed": 28.352249999999998, + "row_count": 100 + }, + { + "elapsed": 28.785708, + "row_count": 100 + } + ], + "start_time": 1783521814, + "success": true + }, + { + "query": "Query 87", + "iterations": [ + { + "elapsed": 89.42224999999999, + "row_count": 1 + }, + { + "elapsed": 89.93433300000001, + "row_count": 1 + }, + { + "elapsed": 89.489625, + "row_count": 1 + } + ], + "start_time": 1783521814, + "success": true + }, + { + "query": "Query 88", + "iterations": [ + { + "elapsed": 70.73733299999999, + "row_count": 1 + }, + { + "elapsed": 68.876042, + "row_count": 1 + }, + { + "elapsed": 68.81845799999999, + "row_count": 1 + } + ], + "start_time": 1783521814, + "success": true + }, + { + "query": "Query 89", + "iterations": [ + { + "elapsed": 84.655833, + "row_count": 100 + }, + { + "elapsed": 83.75316600000001, + "row_count": 100 + }, + { + "elapsed": 86.591583, + "row_count": 100 + } + ], + "start_time": 1783521814, + "success": true + }, + { + "query": "Query 90", + "iterations": [ + { + "elapsed": 13.7295, + "row_count": 1 + }, + { + "elapsed": 14.272458, + "row_count": 1 + }, + { + "elapsed": 14.617916, + "row_count": 1 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 91", + "iterations": [ + { + "elapsed": 44.3835, + "row_count": 4 + }, + { + "elapsed": 44.994208, + "row_count": 4 + }, + { + "elapsed": 43.934374999999996, + "row_count": 4 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 92", + "iterations": [ + { + "elapsed": 40.94125, + "row_count": 1 + }, + { + "elapsed": 40.576833, + "row_count": 1 + }, + { + "elapsed": 40.4365, + "row_count": 1 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 93", + "iterations": [ + { + "elapsed": 110.903584, + "row_count": 100 + }, + { + "elapsed": 109.453917, + "row_count": 100 + }, + { + "elapsed": 111.966458, + "row_count": 100 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 94", + "iterations": [ + { + "elapsed": 42.078042, + "row_count": 1 + }, + { + "elapsed": 41.579584000000004, + "row_count": 1 + }, + { + "elapsed": 41.694709, + "row_count": 1 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 95", + "iterations": [ + { + "elapsed": 57.626292, + "row_count": 1 + }, + { + "elapsed": 56.596374999999995, + "row_count": 1 + }, + { + "elapsed": 56.497208, + "row_count": 1 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 96", + "iterations": [ + { + "elapsed": 51.429375, + "row_count": 1 + }, + { + "elapsed": 50.987792, + "row_count": 1 + }, + { + "elapsed": 49.728625, + "row_count": 1 + } + ], + "start_time": 1783521815, + "success": true + }, + { + "query": "Query 97", + "iterations": [ + { + "elapsed": 82.394958, + "row_count": 1 + }, + { + "elapsed": 81.08375, + "row_count": 1 + }, + { + "elapsed": 80.45566699999999, + "row_count": 1 + } + ], + "start_time": 1783521816, + "success": true + }, + { + "query": "Query 98", + "iterations": [ + { + "elapsed": 105.294, + "row_count": 2486 + }, + { + "elapsed": 106.360541, + "row_count": 2486 + }, + { + "elapsed": 112.674625, + "row_count": 2486 + } + ], + "start_time": 1783521816, + "success": true + }, + { + "query": "Query 99", + "iterations": [ + { + "elapsed": 4203.855, + "row_count": 90 + }, + { + "elapsed": 4240.967957999999, + "row_count": 90 + }, + { + "elapsed": 4224.1549589999995, + "row_count": 90 + } + ], + "start_time": 1783521816, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/tpch_off_r1.json b/ab_results/tpch_off_r1.json new file mode 100644 index 0000000000000..28aa9a944062c --- /dev/null +++ b/ab_results/tpch_off_r1.json @@ -0,0 +1,439 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521310, + "arguments": [ + "tpch", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", + "--format", + "parquet", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpch_off_r1.json" + ] + }, + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 110.54849999999999, + "row_count": 4 + }, + { + "elapsed": 36.885834, + "row_count": 4 + }, + { + "elapsed": 41.085833, + "row_count": 4 + } + ], + "start_time": 1783521310, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 24.111082999999997, + "row_count": 100 + }, + { + "elapsed": 12.894792, + "row_count": 100 + }, + { + "elapsed": 12.939667, + "row_count": 100 + } + ], + "start_time": 1783521310, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 32.227375, + "row_count": 10 + }, + { + "elapsed": 27.691208, + "row_count": 10 + }, + { + "elapsed": 27.788416, + "row_count": 10 + } + ], + "start_time": 1783521310, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 17.539709000000002, + "row_count": 5 + }, + { + "elapsed": 14.585125000000001, + "row_count": 5 + }, + { + "elapsed": 13.837333000000001, + "row_count": 5 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 37.685334, + "row_count": 5 + }, + { + "elapsed": 36.991875, + "row_count": 5 + }, + { + "elapsed": 33.957542000000004, + "row_count": 5 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 16.361625, + "row_count": 1 + }, + { + "elapsed": 14.569875, + "row_count": 1 + }, + { + "elapsed": 14.420292, + "row_count": 1 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 41.510416, + "row_count": 4 + }, + { + "elapsed": 38.166667000000004, + "row_count": 4 + }, + { + "elapsed": 37.174709, + "row_count": 4 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 35.592292, + "row_count": 2 + }, + { + "elapsed": 34.295583, + "row_count": 2 + }, + { + "elapsed": 36.197708, + "row_count": 2 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 65.762041, + "row_count": 175 + }, + { + "elapsed": 65.088542, + "row_count": 175 + }, + { + "elapsed": 56.015541, + "row_count": 175 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 39.812374999999996, + "row_count": 20 + }, + { + "elapsed": 36.430333000000005, + "row_count": 20 + }, + { + "elapsed": 34.229083, + "row_count": 20 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 12.102583, + "row_count": 1048 + }, + { + "elapsed": 9.070208, + "row_count": 1048 + }, + { + "elapsed": 8.647708, + "row_count": 1048 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 24.071875, + "row_count": 2 + }, + { + "elapsed": 23.031, + "row_count": 2 + }, + { + "elapsed": 20.997999999999998, + "row_count": 2 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 26.464416, + "row_count": 42 + }, + { + "elapsed": 22.484583, + "row_count": 42 + }, + { + "elapsed": 25.499750000000002, + "row_count": 42 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 19.712375, + "row_count": 1 + }, + { + "elapsed": 18.741917, + "row_count": 1 + }, + { + "elapsed": 18.614791, + "row_count": 1 + } + ], + "start_time": 1783521311, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 27.274542, + "row_count": 1 + }, + { + "elapsed": 24.367458000000003, + "row_count": 1 + }, + { + "elapsed": 24.154374999999998, + "row_count": 1 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 10.971292, + "row_count": 18314 + }, + { + "elapsed": 9.821, + "row_count": 18314 + }, + { + "elapsed": 10.016041999999999, + "row_count": 18314 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 70.416791, + "row_count": 1 + }, + { + "elapsed": 67.586708, + "row_count": 1 + }, + { + "elapsed": 74.264167, + "row_count": 1 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 67.777833, + "row_count": 57 + }, + { + "elapsed": 56.593667, + "row_count": 57 + }, + { + "elapsed": 69.01, + "row_count": 57 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 40.387708, + "row_count": 1 + }, + { + "elapsed": 41.666833, + "row_count": 1 + }, + { + "elapsed": 63.5235, + "row_count": 1 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 45.216083, + "row_count": 186 + }, + { + "elapsed": 32.860958000000004, + "row_count": 186 + }, + { + "elapsed": 26.201999999999998, + "row_count": 186 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 51.335542, + "row_count": 100 + }, + { + "elapsed": 48.971959000000005, + "row_count": 100 + }, + { + "elapsed": 49.1815, + "row_count": 100 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 10.092583000000001, + "row_count": 7 + }, + { + "elapsed": 9.038417, + "row_count": 7 + }, + { + "elapsed": 9.489167, + "row_count": 7 + } + ], + "start_time": 1783521312, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/tpch_off_r2.json b/ab_results/tpch_off_r2.json new file mode 100644 index 0000000000000..23ac3cd15f490 --- /dev/null +++ b/ab_results/tpch_off_r2.json @@ -0,0 +1,439 @@ +{ + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 45.665709, + "row_count": 4 + }, + { + "elapsed": 45.714749999999995, + "row_count": 4 + }, + { + "elapsed": 44.746125, + "row_count": 4 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 13.042166, + "row_count": 100 + }, + { + "elapsed": 12.457125, + "row_count": 100 + }, + { + "elapsed": 11.963792, + "row_count": 100 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 27.089875, + "row_count": 10 + }, + { + "elapsed": 27.930042, + "row_count": 10 + }, + { + "elapsed": 30.048, + "row_count": 10 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 17.170875, + "row_count": 5 + }, + { + "elapsed": 15.956042, + "row_count": 5 + }, + { + "elapsed": 17.919166999999998, + "row_count": 5 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 39.251374999999996, + "row_count": 5 + }, + { + "elapsed": 40.0195, + "row_count": 5 + }, + { + "elapsed": 38.990834, + "row_count": 5 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 15.469792, + "row_count": 1 + }, + { + "elapsed": 16.045834, + "row_count": 1 + }, + { + "elapsed": 18.06775, + "row_count": 1 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 46.156667, + "row_count": 4 + }, + { + "elapsed": 42.547583, + "row_count": 4 + }, + { + "elapsed": 43.045583, + "row_count": 4 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 42.312083, + "row_count": 2 + }, + { + "elapsed": 34.721125, + "row_count": 2 + }, + { + "elapsed": 37.059792, + "row_count": 2 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 50.415709, + "row_count": 175 + }, + { + "elapsed": 43.980667000000004, + "row_count": 175 + }, + { + "elapsed": 43.940542, + "row_count": 175 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 33.500875, + "row_count": 20 + }, + { + "elapsed": 33.834625, + "row_count": 20 + }, + { + "elapsed": 33.731457999999996, + "row_count": 20 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 9.224833, + "row_count": 1048 + }, + { + "elapsed": 8.609833, + "row_count": 1048 + }, + { + "elapsed": 8.695958000000001, + "row_count": 1048 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 21.183875, + "row_count": 2 + }, + { + "elapsed": 21.92675, + "row_count": 2 + }, + { + "elapsed": 22.681917, + "row_count": 2 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 27.512083, + "row_count": 42 + }, + { + "elapsed": 58.30175, + "row_count": 42 + }, + { + "elapsed": 30.489458, + "row_count": 42 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 21.81375, + "row_count": 1 + }, + { + "elapsed": 20.650624999999998, + "row_count": 1 + }, + { + "elapsed": 25.382208, + "row_count": 1 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 31.057458999999998, + "row_count": 1 + }, + { + "elapsed": 30.987541, + "row_count": 1 + }, + { + "elapsed": 26.480541, + "row_count": 1 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 10.787625, + "row_count": 18314 + }, + { + "elapsed": 9.677375, + "row_count": 18314 + }, + { + "elapsed": 9.757584, + "row_count": 18314 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 65.53108300000001, + "row_count": 1 + }, + { + "elapsed": 65.263167, + "row_count": 1 + }, + { + "elapsed": 67.612875, + "row_count": 1 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 66.420458, + "row_count": 57 + }, + { + "elapsed": 59.410833000000004, + "row_count": 57 + }, + { + "elapsed": 58.072625, + "row_count": 57 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 30.020875, + "row_count": 1 + }, + { + "elapsed": 27.768583, + "row_count": 1 + }, + { + "elapsed": 26.663542, + "row_count": 1 + } + ], + "start_time": 1783521316, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 27.047, + "row_count": 186 + }, + { + "elapsed": 25.074375, + "row_count": 186 + }, + { + "elapsed": 25.325208, + "row_count": 186 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 52.275, + "row_count": 100 + }, + { + "elapsed": 48.867667, + "row_count": 100 + }, + { + "elapsed": 51.776583, + "row_count": 100 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 10.052041, + "row_count": 7 + }, + { + "elapsed": 9.402458000000001, + "row_count": 7 + }, + { + "elapsed": 9.503582999999999, + "row_count": 7 + } + ], + "start_time": 1783521317, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521315, + "arguments": [ + "tpch", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", + "--format", + "parquet", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpch_off_r2.json" + ] + } +} \ No newline at end of file diff --git a/ab_results/tpch_on_r1.json b/ab_results/tpch_on_r1.json new file mode 100644 index 0000000000000..d1280011ea82a --- /dev/null +++ b/ab_results/tpch_on_r1.json @@ -0,0 +1,439 @@ +{ + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521312, + "arguments": [ + "tpch", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", + "--format", + "parquet", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpch_on_r1.json" + ] + }, + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 42.9765, + "row_count": 4 + }, + { + "elapsed": 40.096, + "row_count": 4 + }, + { + "elapsed": 39.238417, + "row_count": 4 + } + ], + "start_time": 1783521312, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 12.687458000000001, + "row_count": 100 + }, + { + "elapsed": 13.363875, + "row_count": 100 + }, + { + "elapsed": 12.671167, + "row_count": 100 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 28.704917, + "row_count": 10 + }, + { + "elapsed": 28.578083, + "row_count": 10 + }, + { + "elapsed": 26.979208, + "row_count": 10 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 14.917875, + "row_count": 5 + }, + { + "elapsed": 14.827292, + "row_count": 5 + }, + { + "elapsed": 14.050999999999998, + "row_count": 5 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 36.79024999999999, + "row_count": 5 + }, + { + "elapsed": 48.600208, + "row_count": 5 + }, + { + "elapsed": 38.700625, + "row_count": 5 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 17.64725, + "row_count": 1 + }, + { + "elapsed": 17.879208000000002, + "row_count": 1 + }, + { + "elapsed": 14.697166, + "row_count": 1 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 50.899, + "row_count": 4 + }, + { + "elapsed": 50.782374999999995, + "row_count": 4 + }, + { + "elapsed": 46.96975, + "row_count": 4 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 40.016667, + "row_count": 2 + }, + { + "elapsed": 44.013459, + "row_count": 2 + }, + { + "elapsed": 40.014165999999996, + "row_count": 2 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 50.37425, + "row_count": 175 + }, + { + "elapsed": 44.983834, + "row_count": 175 + }, + { + "elapsed": 46.929, + "row_count": 175 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 42.641625000000005, + "row_count": 20 + }, + { + "elapsed": 63.963375000000006, + "row_count": 20 + }, + { + "elapsed": 39.953375, + "row_count": 20 + } + ], + "start_time": 1783521313, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 9.902208, + "row_count": 1048 + }, + { + "elapsed": 12.069666999999999, + "row_count": 1048 + }, + { + "elapsed": 10.495792, + "row_count": 1048 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 29.683666000000002, + "row_count": 2 + }, + { + "elapsed": 30.192542, + "row_count": 2 + }, + { + "elapsed": 30.58, + "row_count": 2 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 28.288708, + "row_count": 42 + }, + { + "elapsed": 28.846875, + "row_count": 42 + }, + { + "elapsed": 34.543917, + "row_count": 42 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 24.067208, + "row_count": 1 + }, + { + "elapsed": 21.468833999999998, + "row_count": 1 + }, + { + "elapsed": 20.752208, + "row_count": 1 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 26.278458, + "row_count": 1 + }, + { + "elapsed": 26.591208, + "row_count": 1 + }, + { + "elapsed": 33.767167, + "row_count": 1 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 10.547374999999999, + "row_count": 18314 + }, + { + "elapsed": 10.867958, + "row_count": 18314 + }, + { + "elapsed": 10.324791999999999, + "row_count": 18314 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 75.053459, + "row_count": 1 + }, + { + "elapsed": 81.439458, + "row_count": 1 + }, + { + "elapsed": 72.507458, + "row_count": 1 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 77.332292, + "row_count": 57 + }, + { + "elapsed": 72.151083, + "row_count": 57 + }, + { + "elapsed": 62.882332999999996, + "row_count": 57 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 32.523458, + "row_count": 1 + }, + { + "elapsed": 32.177749999999996, + "row_count": 1 + }, + { + "elapsed": 30.318624999999997, + "row_count": 1 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 25.952709000000002, + "row_count": 186 + }, + { + "elapsed": 27.209208, + "row_count": 186 + }, + { + "elapsed": 25.721958, + "row_count": 186 + } + ], + "start_time": 1783521314, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 48.596834, + "row_count": 100 + }, + { + "elapsed": 46.218833000000004, + "row_count": 100 + }, + { + "elapsed": 48.855166999999994, + "row_count": 100 + } + ], + "start_time": 1783521315, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 10.040417, + "row_count": 7 + }, + { + "elapsed": 9.946333, + "row_count": 7 + }, + { + "elapsed": 9.694416, + "row_count": 7 + } + ], + "start_time": 1783521315, + "success": true + } + ] +} \ No newline at end of file diff --git a/ab_results/tpch_on_r2.json b/ab_results/tpch_on_r2.json new file mode 100644 index 0000000000000..992b2e3f7ac2d --- /dev/null +++ b/ab_results/tpch_on_r2.json @@ -0,0 +1,439 @@ +{ + "queries": [ + { + "query": "Query 1", + "iterations": [ + { + "elapsed": 45.523584, + "row_count": 4 + }, + { + "elapsed": 37.542832999999995, + "row_count": 4 + }, + { + "elapsed": 38.704416, + "row_count": 4 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 2", + "iterations": [ + { + "elapsed": 13.292583, + "row_count": 100 + }, + { + "elapsed": 13.094875, + "row_count": 100 + }, + { + "elapsed": 12.456208, + "row_count": 100 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 3", + "iterations": [ + { + "elapsed": 28.26575, + "row_count": 10 + }, + { + "elapsed": 29.994833, + "row_count": 10 + }, + { + "elapsed": 30.247, + "row_count": 10 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 4", + "iterations": [ + { + "elapsed": 19.352, + "row_count": 5 + }, + { + "elapsed": 16.396416000000002, + "row_count": 5 + }, + { + "elapsed": 19.144792000000002, + "row_count": 5 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 5", + "iterations": [ + { + "elapsed": 80.001875, + "row_count": 5 + }, + { + "elapsed": 44.889167, + "row_count": 5 + }, + { + "elapsed": 40.862875, + "row_count": 5 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 6", + "iterations": [ + { + "elapsed": 16.637208, + "row_count": 1 + }, + { + "elapsed": 17.534417, + "row_count": 1 + }, + { + "elapsed": 21.551709, + "row_count": 1 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 7", + "iterations": [ + { + "elapsed": 56.581625, + "row_count": 4 + }, + { + "elapsed": 45.848333, + "row_count": 4 + }, + { + "elapsed": 49.040333, + "row_count": 4 + } + ], + "start_time": 1783521317, + "success": true + }, + { + "query": "Query 8", + "iterations": [ + { + "elapsed": 41.24525, + "row_count": 2 + }, + { + "elapsed": 43.712292, + "row_count": 2 + }, + { + "elapsed": 41.177541, + "row_count": 2 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 9", + "iterations": [ + { + "elapsed": 47.659167000000004, + "row_count": 175 + }, + { + "elapsed": 48.496542, + "row_count": 175 + }, + { + "elapsed": 68.08975000000001, + "row_count": 175 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 10", + "iterations": [ + { + "elapsed": 41.386959000000004, + "row_count": 20 + }, + { + "elapsed": 41.043333000000004, + "row_count": 20 + }, + { + "elapsed": 43.026, + "row_count": 20 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 11", + "iterations": [ + { + "elapsed": 13.936542, + "row_count": 1048 + }, + { + "elapsed": 11.915624999999999, + "row_count": 1048 + }, + { + "elapsed": 14.540958, + "row_count": 1048 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 12", + "iterations": [ + { + "elapsed": 32.509459, + "row_count": 2 + }, + { + "elapsed": 26.507333000000003, + "row_count": 2 + }, + { + "elapsed": 27.958167, + "row_count": 2 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 13", + "iterations": [ + { + "elapsed": 32.657041, + "row_count": 42 + }, + { + "elapsed": 27.798375, + "row_count": 42 + }, + { + "elapsed": 28.59, + "row_count": 42 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 14", + "iterations": [ + { + "elapsed": 23.075666000000002, + "row_count": 1 + }, + { + "elapsed": 20.999166, + "row_count": 1 + }, + { + "elapsed": 23.111834, + "row_count": 1 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 15", + "iterations": [ + { + "elapsed": 27.155041, + "row_count": 1 + }, + { + "elapsed": 27.287458, + "row_count": 1 + }, + { + "elapsed": 28.633292, + "row_count": 1 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 16", + "iterations": [ + { + "elapsed": 14.518915999999999, + "row_count": 18314 + }, + { + "elapsed": 11.304124999999999, + "row_count": 18314 + }, + { + "elapsed": 12.738709, + "row_count": 18314 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 17", + "iterations": [ + { + "elapsed": 82.30125000000001, + "row_count": 1 + }, + { + "elapsed": 69.59929199999999, + "row_count": 1 + }, + { + "elapsed": 87.404834, + "row_count": 1 + } + ], + "start_time": 1783521318, + "success": true + }, + { + "query": "Query 18", + "iterations": [ + { + "elapsed": 75.084542, + "row_count": 57 + }, + { + "elapsed": 66.318958, + "row_count": 57 + }, + { + "elapsed": 62.530375, + "row_count": 57 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 19", + "iterations": [ + { + "elapsed": 32.35325, + "row_count": 1 + }, + { + "elapsed": 30.159916, + "row_count": 1 + }, + { + "elapsed": 31.7975, + "row_count": 1 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 20", + "iterations": [ + { + "elapsed": 28.122874999999997, + "row_count": 186 + }, + { + "elapsed": 52.10025, + "row_count": 186 + }, + { + "elapsed": 29.025667000000002, + "row_count": 186 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 21", + "iterations": [ + { + "elapsed": 55.449208, + "row_count": 100 + }, + { + "elapsed": 70.486333, + "row_count": 100 + }, + { + "elapsed": 61.5685, + "row_count": 100 + } + ], + "start_time": 1783521319, + "success": true + }, + { + "query": "Query 22", + "iterations": [ + { + "elapsed": 9.438875, + "row_count": 7 + }, + { + "elapsed": 9.135625, + "row_count": 7 + }, + { + "elapsed": 9.553167, + "row_count": 7 + } + ], + "start_time": 1783521319, + "success": true + } + ], + "context": { + "benchmark_version": "54.0.0", + "datafusion_version": "54.0.0", + "num_cpus": 12, + "start_time": 1783521317, + "arguments": [ + "tpch", + "--iterations", + "3", + "--path", + "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", + "--format", + "parquet", + "-o", + "/tmp/datafusion-batch-normalizer/ab_results/tpch_on_r2.json" + ] + } +} \ No newline at end of file diff --git a/analyze_ab.py b/analyze_ab.py new file mode 100644 index 0000000000000..4438877794c39 --- /dev/null +++ b/analyze_ab.py @@ -0,0 +1,51 @@ +#!/usr/bin/env python3 +"""Compare interleaved A/B dfbench results: per-query min(off rounds) vs min(on rounds).""" +import json +import sys +from pathlib import Path + +OUT = Path("/tmp/datafusion-batch-normalizer/ab_results") + + +def load_mins(suite: str, cfg: str) -> dict[str, float]: + mins: dict[str, float] = {} + for f in sorted(OUT.glob(f"{suite}_{cfg}_r*.json")): + d = json.load(open(f)) + for q in d["queries"]: + if not q.get("success", True): + mins[q["query"]] = float("nan") + continue + m = min(i["elapsed"] for i in q["iterations"]) + k = q["query"] + mins[k] = min(mins.get(k, float("inf")), m) + return mins + + +def main() -> None: + for suite in sys.argv[1:] or ["tpch", "clickbench", "tpcds"]: + off, on = load_mins(suite, "off"), load_mins(suite, "on") + if not off or not on: + print(f"== {suite}: missing results ==") + continue + print(f"\n== {suite} (per-query min across rounds, off vs on) ==") + tot_off = tot_on = 0.0 + worst: list[tuple[float, str, float, float]] = [] + for q in off: + if q not in on: + continue + a, b = off[q], on[q] + tot_off += a + tot_on += b + worst.append((b / a if a > 0 else 1.0, q, a, b)) + worst.sort(reverse=True) + print(f"total: off={tot_off:.0f}ms on={tot_on:.0f}ms ratio={tot_on / tot_off:.3f}") + print("largest regressions (on/off):") + for r, q, a, b in worst[:5]: + print(f" {q}: {a:.1f} -> {b:.1f} ms ({r:.2f}x)") + print("largest improvements (on/off):") + for r, q, a, b in worst[-5:]: + print(f" {q}: {a:.1f} -> {b:.1f} ms ({r:.2f}x)") + + +if __name__ == "__main__": + main() diff --git a/bench_ab.log b/bench_ab.log new file mode 100644 index 0000000000000..ab9f6ac13d3b5 --- /dev/null +++ b/bench_ab.log @@ -0,0 +1,22 @@ +>>> tpch cfg=off round=1 +>>> tpch cfg=on round=1 +>>> tpch cfg=off round=2 +>>> tpch cfg=on round=2 +>>> clickbench cfg=off round=1 +>>> clickbench cfg=on round=1 +>>> clickbench cfg=off round=2 +>>> clickbench cfg=on round=2 +>>> tpcds cfg=off round=1 +Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? +Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. +>>> tpcds cfg=on round=1 +Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? +Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. +>>> tpcds cfg=off round=2 +Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? +Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. +>>> tpcds cfg=on round=2 +Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? +Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. +AB BENCHMARKS DONE +EXIT: 0 diff --git a/bench_run.log b/bench_run.log new file mode 100644 index 0000000000000..938fa56b69c10 --- /dev/null +++ b/bench_run.log @@ -0,0 +1,568 @@ +=== prebuild binaries === + Finished `release` profile [optimized] target(s) in 0.36s + Finished `release` profile [optimized] target(s) in 0.25s +=== tpch: branch, normalizer OFF (save baseline) === +*************************** +DataFusion Benchmark Script +COMMAND: run +BENCHMARK: tpch +QUERY: All +DATAFUSION_DIR: /tmp/datafusion-batch-normalizer/benchmarks/.. +BRANCH_NAME: batch-normalizer +DATA_DIR: /Users/adrian/GitHub/datafusion/benchmarks/data +RESULTS_DIR: /tmp/datafusion-batch-normalizer/benchmarks/results/batch-normalizer +CARGO_COMMAND: cargo run --release +PREFER_HASH_JOIN: true +SIMULATE_LATENCY: false +*************************** +Running tpch benchmark... ++ env BENCH_NAME=tpch BENCH_SIZE=1 DATA_DIR=/Users/adrian/GitHub/datafusion/benchmarks/data PREFER_HASH_JOIN=true TPCH_FILE_TYPE=parquet SIMULATE_LATENCY=false bash -c 'cargo bench --bench sql -- --save-baseline bnoff' + Compiling datafusion-benchmarks v54.0.0 (/private/tmp/datafusion-batch-normalizer/benchmarks) + Finished `bench` profile [optimized] target(s) in 20m 30s + Running benches/sql.rs (/private/tmp/datafusion-batch-normalizer/target/release/deps/sql-4f5152a58555f294) +Gnuplot not found, using plotters backend +Loading benchmarks... +Benchmarking tpch/Q01_sf1 +Benchmarking tpch/Q01_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q01_sf1: Collecting 10 samples in estimated 5.4234 s (50 iterations) +Benchmarking tpch/Q01_sf1: Analyzing +tpch/Q01_sf1 time: [103.79 ms 113.12 ms 123.15 ms] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q02_sf1 +Benchmarking tpch/Q02_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q02_sf1: Collecting 10 samples in estimated 5.0095 s (200 iterations) +Benchmarking tpch/Q02_sf1: Analyzing +tpch/Q02_sf1 time: [25.986 ms 26.217 ms 26.479 ms] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q03_sf1 +Benchmarking tpch/Q03_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q03_sf1: Collecting 10 samples in estimated 5.1353 s (70 iterations) +Benchmarking tpch/Q03_sf1: Analyzing +tpch/Q03_sf1 time: [69.989 ms 72.678 ms 75.598 ms] +Benchmarking tpch/Q04_sf1 +Benchmarking tpch/Q04_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q04_sf1: Collecting 10 samples in estimated 5.0259 s (150 iterations) +Benchmarking tpch/Q04_sf1: Analyzing +tpch/Q04_sf1 time: [34.094 ms 34.614 ms 35.280 ms] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q05_sf1 +Benchmarking tpch/Q05_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q05_sf1: Collecting 10 samples in estimated 5.6980 s (60 iterations) +Benchmarking tpch/Q05_sf1: Analyzing +tpch/Q05_sf1 time: [89.420 ms 97.573 ms 106.87 ms] +Benchmarking tpch/Q06_sf1 +Benchmarking tpch/Q06_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q06_sf1: Collecting 10 samples in estimated 5.1150 s (120 iterations) +Benchmarking tpch/Q06_sf1: Analyzing +tpch/Q06_sf1 time: [41.340 ms 42.976 ms 44.545 ms] +Benchmarking tpch/Q07_sf1 +Benchmarking tpch/Q07_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q07_sf1: Collecting 10 samples in estimated 5.6654 s (50 iterations) +Benchmarking tpch/Q07_sf1: Analyzing +tpch/Q07_sf1 time: [109.67 ms 116.76 ms 124.13 ms] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking tpch/Q08_sf1 +Benchmarking tpch/Q08_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q08_sf1: Collecting 10 samples in estimated 5.2613 s (60 iterations) +Benchmarking tpch/Q08_sf1: Analyzing +tpch/Q08_sf1 time: [87.950 ms 90.582 ms 93.484 ms] +Benchmarking tpch/Q09_sf1 +Benchmarking tpch/Q09_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q09_sf1: Collecting 10 samples in estimated 6.0342 s (50 iterations) +Benchmarking tpch/Q09_sf1: Analyzing +tpch/Q09_sf1 time: [117.87 ms 123.80 ms 130.41 ms] +Benchmarking tpch/Q10_sf1 +Benchmarking tpch/Q10_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q10_sf1: Collecting 10 samples in estimated 5.2531 s (60 iterations) +Benchmarking tpch/Q10_sf1: Analyzing +tpch/Q10_sf1 time: [87.494 ms 88.751 ms 90.128 ms] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q11_sf1 +Benchmarking tpch/Q11_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q11_sf1: Collecting 10 samples in estimated 5.0878 s (270 iterations) +Benchmarking tpch/Q11_sf1: Analyzing +tpch/Q11_sf1 time: [19.381 ms 19.538 ms 19.698 ms] +Benchmarking tpch/Q12_sf1 +Benchmarking tpch/Q12_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q12_sf1: Collecting 10 samples in estimated 5.5419 s (100 iterations) +Benchmarking tpch/Q12_sf1: Analyzing +tpch/Q12_sf1 time: [54.983 ms 55.637 ms 56.365 ms] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q13_sf1 +Benchmarking tpch/Q13_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q13_sf1: Collecting 10 samples in estimated 5.2195 s (80 iterations) +Benchmarking tpch/Q13_sf1: Analyzing +tpch/Q13_sf1 time: [66.519 ms 67.841 ms 69.274 ms] +Benchmarking tpch/Q14_sf1 +Benchmarking tpch/Q14_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q14_sf1: Collecting 10 samples in estimated 5.0776 s (100 iterations) +Benchmarking tpch/Q14_sf1: Analyzing +tpch/Q14_sf1 time: [52.141 ms 53.836 ms 55.710 ms] +Benchmarking tpch/Q15_sf1 +Benchmarking tpch/Q15_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q15_sf1: Collecting 10 samples in estimated 5.2094 s (70 iterations) +Benchmarking tpch/Q15_sf1: Analyzing +tpch/Q15_sf1 time: [75.716 ms 76.229 ms 76.680 ms] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking tpch/Q16_sf1 +Benchmarking tpch/Q16_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q16_sf1: Collecting 10 samples in estimated 5.1376 s (260 iterations) +Benchmarking tpch/Q16_sf1: Analyzing +tpch/Q16_sf1 time: [21.281 ms 21.774 ms 22.278 ms] +Benchmarking tpch/Q17_sf1 +Benchmarking tpch/Q17_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q17_sf1: Collecting 10 samples in estimated 5.0522 s (30 iterations) +Benchmarking tpch/Q17_sf1: Analyzing +tpch/Q17_sf1 time: [166.18 ms 168.53 ms 171.14 ms] +Benchmarking tpch/Q18_sf1 +Benchmarking tpch/Q18_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q18_sf1: Collecting 10 samples in estimated 6.5025 s (40 iterations) +Benchmarking tpch/Q18_sf1: Analyzing +tpch/Q18_sf1 time: [153.94 ms 164.84 ms 176.03 ms] +Benchmarking tpch/Q19_sf1 +Benchmarking tpch/Q19_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q19_sf1: Collecting 10 samples in estimated 5.3931 s (70 iterations) +Benchmarking tpch/Q19_sf1: Analyzing +tpch/Q19_sf1 time: [75.561 ms 76.490 ms 77.421 ms] +Benchmarking tpch/Q20_sf1 +Benchmarking tpch/Q20_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q20_sf1: Collecting 10 samples in estimated 5.6629 s (80 iterations) +Benchmarking tpch/Q20_sf1: Analyzing +tpch/Q20_sf1 time: [68.281 ms 70.390 ms 72.668 ms] +Benchmarking tpch/Q21_sf1 +Benchmarking tpch/Q21_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q21_sf1: Collecting 10 samples in estimated 6.4045 s (40 iterations) +Benchmarking tpch/Q21_sf1: Analyzing +tpch/Q21_sf1 time: [162.25 ms 165.24 ms 168.39 ms] +Benchmarking tpch/Q22_sf1 +Benchmarking tpch/Q22_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q22_sf1: Collecting 10 samples in estimated 5.1335 s (280 iterations) +Benchmarking tpch/Q22_sf1: Analyzing +tpch/Q22_sf1 time: [18.373 ms 18.893 ms 19.514 ms] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe + +Completed benchmarks in 230144 ms ... ++ set +x +Done +=== tpch: branch, normalizer ON vs baseline === +*************************** +DataFusion Benchmark Script +COMMAND: run +BENCHMARK: tpch +QUERY: All +DATAFUSION_DIR: /tmp/datafusion-batch-normalizer/benchmarks/.. +BRANCH_NAME: batch-normalizer +DATA_DIR: /Users/adrian/GitHub/datafusion/benchmarks/data +RESULTS_DIR: /tmp/datafusion-batch-normalizer/benchmarks/results/batch-normalizer +CARGO_COMMAND: cargo run --release +PREFER_HASH_JOIN: true +SIMULATE_LATENCY: false +*************************** +Running tpch benchmark... ++ env BENCH_NAME=tpch BENCH_SIZE=1 DATA_DIR=/Users/adrian/GitHub/datafusion/benchmarks/data PREFER_HASH_JOIN=true TPCH_FILE_TYPE=parquet SIMULATE_LATENCY=false bash -c 'cargo bench --bench sql -- --baseline bnoff' + Finished `bench` profile [optimized] target(s) in 0.43s + Running benches/sql.rs (/private/tmp/datafusion-batch-normalizer/target/release/deps/sql-4f5152a58555f294) +Gnuplot not found, using plotters backend +Loading benchmarks... +Benchmarking tpch/Q01_sf1 +Benchmarking tpch/Q01_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q01_sf1: Collecting 10 samples in estimated 5.9028 s (60 iterations) +Benchmarking tpch/Q01_sf1: Analyzing +tpch/Q01_sf1 time: [118.47 ms 120.79 ms 122.74 ms] + change: [−2.1675% +6.7798% +16.678%] (p = 0.18 > 0.05) + No change in performance detected. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking tpch/Q02_sf1 +Benchmarking tpch/Q02_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q02_sf1: Collecting 10 samples in estimated 6.0207 s (40 iterations) +Benchmarking tpch/Q02_sf1: Analyzing +tpch/Q02_sf1 time: [52.400 ms 69.691 ms 89.699 ms] + change: [+96.347% +165.82% +246.40%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q03_sf1 +Benchmarking tpch/Q03_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q03_sf1: Collecting 10 samples in estimated 5.0493 s (20 iterations) +Benchmarking tpch/Q03_sf1: Analyzing +tpch/Q03_sf1 time: [149.76 ms 173.06 ms 197.54 ms] + change: [+104.60% +138.11% +174.24%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q04_sf1 +Benchmarking tpch/Q04_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q04_sf1: Collecting 10 samples in estimated 5.4039 s (50 iterations) +Benchmarking tpch/Q04_sf1: Analyzing +tpch/Q04_sf1 time: [40.165 ms 43.830 ms 47.654 ms] + change: [+16.334% +26.624% +38.868%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q05_sf1 +Benchmarking tpch/Q05_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q05_sf1: Collecting 10 samples in estimated 5.0501 s (30 iterations) +Benchmarking tpch/Q05_sf1: Analyzing +tpch/Q05_sf1 time: [244.72 ms 345.84 ms 447.32 ms] + change: [+148.09% +254.44% +360.69%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q06_sf1 +Benchmarking tpch/Q06_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q06_sf1: Collecting 10 samples in estimated 5.3992 s (60 iterations) +Benchmarking tpch/Q06_sf1: Analyzing +tpch/Q06_sf1 time: [83.225 ms 85.660 ms 89.018 ms] + change: [+90.105% +99.322% +110.06%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking tpch/Q07_sf1 +Benchmarking tpch/Q07_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q07_sf1: Collecting 10 samples in estimated 5.1659 s (20 iterations) +Benchmarking tpch/Q07_sf1: Analyzing +tpch/Q07_sf1 time: [272.61 ms 286.34 ms 300.95 ms] + change: [+126.18% +145.23% +165.60%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q08_sf1 +Benchmarking tpch/Q08_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q08_sf1: Collecting 10 samples in estimated 5.3812 s (30 iterations) +Benchmarking tpch/Q08_sf1: Analyzing +tpch/Q08_sf1 time: [30.900 ms 41.328 ms 61.370 ms] + change: [−66.259% −54.375% −31.914%] (p = 0.00 < 0.05) + Performance has improved. +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking tpch/Q09_sf1 +Benchmarking tpch/Q09_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q09_sf1: Collecting 10 samples in estimated 5.3032 s (100 iterations) +Benchmarking tpch/Q09_sf1: Analyzing +tpch/Q09_sf1 time: [107.36 ms 217.82 ms 332.92 ms] + change: [−16.143% +75.953% +169.98%] (p = 0.14 > 0.05) + No change in performance detected. +Benchmarking tpch/Q10_sf1 +Benchmarking tpch/Q10_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q10_sf1: Collecting 10 samples in estimated 6.9999 s (30 iterations) +Benchmarking tpch/Q10_sf1: Analyzing +tpch/Q10_sf1 time: [90.880 ms 135.93 ms 183.07 ms] + change: [−3.2470% +53.156% +101.24%] (p = 0.07 > 0.05) + No change in performance detected. +Benchmarking tpch/Q11_sf1 +Benchmarking tpch/Q11_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q11_sf1: Collecting 10 samples in estimated 5.1184 s (350 iterations) +Benchmarking tpch/Q11_sf1: Analyzing +tpch/Q11_sf1 time: [14.107 ms 15.180 ms 16.320 ms] + change: [−27.730% −22.304% −16.473%] (p = 0.00 < 0.05) + Performance has improved. +Benchmarking tpch/Q12_sf1 +Benchmarking tpch/Q12_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q12_sf1: Collecting 10 samples in estimated 5.1059 s (100 iterations) +Benchmarking tpch/Q12_sf1: Analyzing +tpch/Q12_sf1 time: [39.217 ms 44.602 ms 51.759 ms] + change: [−29.798% −19.834% −7.3132%] (p = 0.01 < 0.05) + Performance has improved. +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking tpch/Q13_sf1 +Benchmarking tpch/Q13_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q13_sf1: Collecting 10 samples in estimated 5.8058 s (30 iterations) +Benchmarking tpch/Q13_sf1: Analyzing +tpch/Q13_sf1 time: [117.52 ms 124.67 ms 133.93 ms] + change: [+72.595% +83.761% +98.123%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking tpch/Q14_sf1 +Benchmarking tpch/Q14_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q14_sf1: Collecting 10 samples in estimated 5.1132 s (50 iterations) +Benchmarking tpch/Q14_sf1: Analyzing +tpch/Q14_sf1 time: [103.12 ms 108.13 ms 113.88 ms] + change: [+89.456% +100.86% +113.64%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q15_sf1 +Benchmarking tpch/Q15_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q15_sf1: Collecting 10 samples in estimated 6.2864 s (30 iterations) +Benchmarking tpch/Q15_sf1: Analyzing +tpch/Q15_sf1 time: [148.59 ms 153.52 ms 158.68 ms] + change: [+95.187% +101.39% +108.12%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q16_sf1 +Benchmarking tpch/Q16_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q16_sf1: Collecting 10 samples in estimated 5.2772 s (150 iterations) +Benchmarking tpch/Q16_sf1: Analyzing +tpch/Q16_sf1 time: [33.758 ms 35.260 ms 37.023 ms] + change: [+54.113% +61.933% +70.832%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q17_sf1 +Benchmarking tpch/Q17_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q17_sf1: Collecting 10 samples in estimated 5.2229 s (20 iterations) +Benchmarking tpch/Q17_sf1: Analyzing +tpch/Q17_sf1 time: [95.019 ms 111.82 ms 129.93 ms] + change: [−43.807% −33.654% −22.325%] (p = 0.00 < 0.05) + Performance has improved. +Benchmarking tpch/Q18_sf1 +Benchmarking tpch/Q18_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q18_sf1: Collecting 10 samples in estimated 5.3081 s (20 iterations) +Benchmarking tpch/Q18_sf1: Analyzing +tpch/Q18_sf1 time: [339.03 ms 349.48 ms 357.69 ms] + change: [+97.010% +112.01% +127.97%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low severe +Benchmarking tpch/Q19_sf1 +Benchmarking tpch/Q19_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q19_sf1: Collecting 10 samples in estimated 5.9315 s (40 iterations) +Benchmarking tpch/Q19_sf1: Analyzing +tpch/Q19_sf1 time: [143.42 ms 145.28 ms 147.16 ms] + change: [+86.583% +89.937% +93.498%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q20_sf1 +Benchmarking tpch/Q20_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q20_sf1: Collecting 10 samples in estimated 5.4258 s (40 iterations) +Benchmarking tpch/Q20_sf1: Analyzing +tpch/Q20_sf1 time: [133.60 ms 139.88 ms 148.62 ms] + change: [+87.406% +98.716% +112.82%] (p = 0.00 < 0.05) + Performance has regressed. +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking tpch/Q21_sf1 +Benchmarking tpch/Q21_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q21_sf1: Collecting 10 samples in estimated 6.7043 s (20 iterations) +Benchmarking tpch/Q21_sf1: Analyzing +tpch/Q21_sf1 time: [80.711 ms 116.15 ms 169.12 ms] + change: [−50.988% −29.704% +0.7561%] (p = 0.06 > 0.05) + No change in performance detected. +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking tpch/Q22_sf1 +Benchmarking tpch/Q22_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q22_sf1: Collecting 10 samples in estimated 5.0409 s (360 iterations) +Benchmarking tpch/Q22_sf1: Analyzing +tpch/Q22_sf1 time: [50.963 ms 71.330 ms 94.059 ms] + change: [+170.43% +277.55% +392.39%] (p = 0.00 < 0.05) + Performance has regressed. + +Completed benchmarks in 267771 ms ... ++ set +x +Done +=== tpch_mem: branch, normalizer OFF (save baseline) === +*************************** +DataFusion Benchmark Script +COMMAND: run +BENCHMARK: tpch_mem +QUERY: All +DATAFUSION_DIR: /tmp/datafusion-batch-normalizer/benchmarks/.. +BRANCH_NAME: batch-normalizer +DATA_DIR: /Users/adrian/GitHub/datafusion/benchmarks/data +RESULTS_DIR: /tmp/datafusion-batch-normalizer/benchmarks/results/batch-normalizer +CARGO_COMMAND: cargo run --release +PREFER_HASH_JOIN: true +SIMULATE_LATENCY: false +*************************** +Running tpch_mem benchmark... ++ env BENCH_NAME=tpch BENCH_SIZE=1 DATA_DIR=/Users/adrian/GitHub/datafusion/benchmarks/data TPCH_FILE_TYPE=mem PREFER_HASH_JOIN=true SIMULATE_LATENCY=false bash -c 'cargo bench --bench sql -- --save-baseline bnoff' + Finished `bench` profile [optimized] target(s) in 0.48s + Running benches/sql.rs (/private/tmp/datafusion-batch-normalizer/target/release/deps/sql-4f5152a58555f294) +Gnuplot not found, using plotters backend +Loading benchmarks... +Benchmarking tpch/Q01_sf1 +Benchmarking tpch/Q01_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q01_sf1: Collecting 10 samples in estimated 5.1100 s (30 iterations) +Benchmarking tpch/Q01_sf1: Analyzing +tpch/Q01_sf1 time: [170.74 ms 181.18 ms 193.91 ms] + change: [+43.714% +60.164% +77.805%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q02_sf1 +Benchmarking tpch/Q02_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q02_sf1: Collecting 10 samples in estimated 5.0871 s (380 iterations) +Benchmarking tpch/Q02_sf1: Analyzing +tpch/Q02_sf1 time: [17.064 ms 26.694 ms 37.767 ms] + change: [−38.290% +1.8163% +44.416%] (p = 0.93 > 0.05) + No change in performance detected. +Benchmarking tpch/Q03_sf1 +Benchmarking tpch/Q03_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q03_sf1: Collecting 10 samples in estimated 5.3451 s (130 iterations) +Benchmarking tpch/Q03_sf1: Analyzing +tpch/Q03_sf1 time: [37.187 ms 37.920 ms 38.775 ms] + change: [−50.046% −47.825% −45.405%] (p = 0.00 < 0.05) + Performance has improved. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q04_sf1 +Benchmarking tpch/Q04_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q04_sf1: Collecting 10 samples in estimated 5.1886 s (170 iterations) +Benchmarking tpch/Q04_sf1: Analyzing +tpch/Q04_sf1 time: [30.450 ms 31.776 ms 33.554 ms] + change: [−12.427% −8.2000% −2.6242%] (p = 0.01 < 0.05) + Performance has improved. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q05_sf1 +Benchmarking tpch/Q05_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q05_sf1: Collecting 10 samples in estimated 5.7035 s (30 iterations) +Benchmarking tpch/Q05_sf1: Analyzing +tpch/Q05_sf1 time: [77.916 ms 121.59 ms 164.13 ms] + change: [−20.620% +24.617% +72.311%] (p = 0.33 > 0.05) + No change in performance detected. +Benchmarking tpch/Q06_sf1 +Benchmarking tpch/Q06_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q06_sf1: Collecting 10 samples in estimated 5.1609 s (220 iterations) +Benchmarking tpch/Q06_sf1: Analyzing +tpch/Q06_sf1 time: [38.190 ms 41.205 ms 45.027 ms] + change: [−12.009% −4.1207% +5.8721%] (p = 0.41 > 0.05) + No change in performance detected. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q07_sf1 +Benchmarking tpch/Q07_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q07_sf1: Collecting 10 samples in estimated 6.1318 s (30 iterations) +Benchmarking tpch/Q07_sf1: Analyzing +tpch/Q07_sf1 time: [160.52 ms 172.48 ms 185.17 ms] + change: [+33.480% +47.717% +62.869%] (p = 0.00 < 0.05) + Performance has regressed. +Benchmarking tpch/Q08_sf1 +Benchmarking tpch/Q08_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q08_sf1: Collecting 10 samples in estimated 5.1276 s (150 iterations) +Benchmarking tpch/Q08_sf1: Analyzing +tpch/Q08_sf1 time: [30.601 ms 31.094 ms 31.671 ms] + change: [−66.886% −65.673% −64.447%] (p = 0.00 < 0.05) + Performance has improved. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q09_sf1 +Benchmarking tpch/Q09_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q09_sf1: Collecting 10 samples in estimated 5.0922 s (160 iterations) +./benchmarks/bench.sh: line 32: 44400 Terminated: 15 "$@" +Benchmarking tpch/Q09_sf1: Analyzing +tpch/Q09_sf1 time: [74.004 ms 106.76 ms 145.94 ms] + change: [−42.368% −13.761% +17.894%] (p = 0.43 > 0.05) + No change in performance detected. +Found 4 outliers among 10 measurements (40.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking tpch/Q10_sf1 +Benchmarking tpch/Q10_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q10_sf1: Collecting 10 samples in estimated 5.5189 s (50 iterations) +Benchmarking tpch/Q10_sf1: Analyzing +tpch/Q10_sf1 time: [109.27 ms 119.14 ms 131.99 ms] + change: [+22.793% +34.237% +48.433%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q11_sf1 +Benchmarking tpch/Q11_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q11_sf1: Collecting 10 samples in estimated 5.0668 s (400 iterations) +Benchmarking tpch/Q11_sf1: Analyzing +tpch/Q11_sf1 time: [12.692 ms 12.949 ms 13.252 ms] + change: [−35.117% −33.723% −32.314%] (p = 0.00 < 0.05) + Performance has improved. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q12_sf1 +Benchmarking tpch/Q12_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q12_sf1: Collecting 10 samples in estimated 5.1147 s (100 iterations) +Benchmarking tpch/Q12_sf1: Analyzing +tpch/Q12_sf1 time: [24.127 ms 26.667 ms 29.526 ms] + change: [−56.704% −52.069% −47.066%] (p = 0.00 < 0.05) + Performance has improved. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q13_sf1 +Benchmarking tpch/Q13_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q13_sf1: Collecting 10 samples in estimated 5.5777 s (90 iterations) +Benchmarking tpch/Q13_sf1: Analyzing +tpch/Q13_sf1 time: [62.530 ms 64.588 ms 67.344 ms] + change: [−8.5002% −4.7961% −0.7475%] (p = 0.05 < 0.05) + Change within noise threshold. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking tpch/Q14_sf1 +Benchmarking tpch/Q14_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q14_sf1: Collecting 10 samples in estimated 5.0686 s (310 iterations) +Benchmarking tpch/Q14_sf1: Analyzing +tpch/Q14_sf1 time: [15.081 ms 15.984 ms 16.994 ms] + change: [−72.155% −70.310% −68.034%] (p = 0.00 < 0.05) + Performance has improved. +Benchmarking tpch/Q15_sf1 +Benchmarking tpch/Q15_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q15_sf1: Collecting 10 samples in estimated 5.1889 s (100 iterations) +Benchmarking tpch/Q15_sf1: Analyzing +tpch/Q15_sf1 time: [30.152 ms 37.983 ms 50.611 ms] + change: [−60.536% −50.173% −34.312%] (p = 0.00 < 0.05) + Performance has improved. +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking tpch/Q16_sf1 +Benchmarking tpch/Q16_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q16_sf1: Collecting 10 samples in estimated 5.0705 s (160 iterations) +Benchmarking tpch/Q16_sf1: Analyzing +tpch/Q16_sf1 time: [27.551 ms 31.864 ms 35.473 ms] + change: [+25.259% +46.337% +63.140%] (p = 0.00 < 0.05) + Performance has regressed. +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low severe + 1 (10.00%) high mild +Benchmarking tpch/Q17_sf1 +Benchmarking tpch/Q17_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q17_sf1: Collecting 10 samples in estimated 5.1396 s (90 iterations) +Benchmarking tpch/Q17_sf1: Analyzing +tpch/Q17_sf1 time: [153.92 ms 207.86 ms 277.06 ms] + change: [−7.9318% +23.335% +57.501%] (p = 0.28 > 0.05) + No change in performance detected. +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking tpch/Q18_sf1 +Benchmarking tpch/Q18_sf1: Warming up for 3.0000 s + +Warning: Unable to complete 10 samples in 5.0s. You may wish to increase target time to 10.3s. +Benchmarking tpch/Q18_sf1: Collecting 10 samples in estimated 10.333 s (10 iterations) +Benchmarking tpch/Q18_sf1: Analyzing +tpch/Q18_sf1 time: [379.61 ms 390.88 ms 399.95 ms] + change: [+120.49% +137.13% +154.93%] (p = 0.00 < 0.05) + Performance has regressed. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking tpch/Q19_sf1 +Benchmarking tpch/Q19_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q19_sf1: Collecting 10 samples in estimated 5.0393 s (70 iterations) +Benchmarking tpch/Q19_sf1: Analyzing +tpch/Q19_sf1 time: [65.670 ms 67.574 ms 69.629 ms] + change: [−14.421% −11.657% −8.8163%] (p = 0.00 < 0.05) + Performance has improved. +Benchmarking tpch/Q20_sf1 +Benchmarking tpch/Q20_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q20_sf1: Collecting 10 samples in estimated 5.0035 s (100 iterations) +Benchmarking tpch/Q20_sf1: Analyzing +tpch/Q20_sf1 time: [16.113 ms 18.749 ms 22.214 ms] + change: [−77.255% −73.364% −67.621%] (p = 0.00 < 0.05) + Performance has improved. +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking tpch/Q21_sf1 +Benchmarking tpch/Q21_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q21_sf1: Collecting 10 samples in estimated 5.8139 s (50 iterations) +Benchmarking tpch/Q21_sf1: Analyzing +tpch/Q21_sf1 time: [170.71 ms 183.22 ms 195.25 ms] + change: [+2.7213% +10.883% +19.070%] (p = 0.02 < 0.05) + Performance has regressed. +Benchmarking tpch/Q22_sf1 +Benchmarking tpch/Q22_sf1: Warming up for 3.0000 s +Benchmarking tpch/Q22_sf1: Collecting 10 samples in estimated 5.0292 s (260 iterations) +Benchmarking tpch/Q22_sf1: Analyzing +tpch/Q22_sf1 time: [17.036 ms 17.598 ms 18.148 ms] + change: [−10.980% −6.8549% −2.8204%] (p = 0.01 < 0.05) + Performance has improved. + +Completed benchmarks in 275797 ms ... diff --git a/datafusion/common/src/config.rs b/datafusion/common/src/config.rs index 3ea6b88513071..b8657aeef19a1 100644 --- a/datafusion/common/src/config.rs +++ b/datafusion/common/src/config.rs @@ -732,15 +732,18 @@ config_namespace! { /// metadata memory consumption pub batch_size: ConfigNonZeroUsize, default = non_zero_usize_default(8192) - /// Soft target, in bytes, for the in-memory size of batches produced by data - /// sources, in addition to the row-based `batch_size` target. When set, data - /// source output batches are re-chunked towards both targets: batches much - /// larger than this (by in-memory size) are split into compact copies of - /// roughly this size even when within `batch_size` rows -- protecting - /// downstream operators from very large batches (e.g. wide rows with large - /// string values) -- and small batches are coalesced until they reach either - /// target. Batches near the targets are passed through without copying. - /// When `None` (the default), batches are only split by row count. + /// Soft target, in bytes, for the in-memory size of batches, in addition to + /// the row-based `batch_size` target. When set, data source output batches + /// are re-chunked towards both targets: batches much larger than this (by + /// in-memory size) are split into compact copies of roughly this size even + /// when within `batch_size` rows -- protecting downstream operators from + /// very large batches (e.g. wide rows with large string values) -- and + /// small batches are coalesced until they reach either target. Batches near + /// the targets are passed through without copying. Sorts, sort-preserving + /// merges and aggregation spills also bound their output and spill batches + /// to roughly this size instead of emitting `batch_size`-row batches of + /// unbounded byte size. When `None` (the default), batches are only + /// chunked by row count. pub target_batch_size_bytes: Option, default = None /// A perfect hash join (see `HashJoinExec` for more details) will be considered diff --git a/datafusion/sqllogictest/test_files/information_schema.slt b/datafusion/sqllogictest/test_files/information_schema.slt index 144e7e4ffe37b..3de332651eeda 100644 --- a/datafusion/sqllogictest/test_files/information_schema.slt +++ b/datafusion/sqllogictest/test_files/information_schema.slt @@ -441,7 +441,7 @@ datafusion.execution.sort_pushdown_buffer_capacity 1073741824 Maximum buffer cap datafusion.execution.sort_spill_reservation_bytes 10485760 Specifies the reserved memory for each spillable sort operation to facilitate an in-memory merge. When a sort operation spills to disk, the in-memory data must be sorted and merged before being written to a file. This setting reserves a specific amount of memory for that in-memory sort/merge process. Note: This setting is irrelevant if the sort operation cannot spill (i.e., if there's no `DiskManager` configured). datafusion.execution.spill_compression uncompressed Sets the compression codec used when spilling data to disk. Since datafusion writes spill files using the Arrow IPC Stream format, only codecs supported by the Arrow IPC Stream Writer are allowed. Valid values are: uncompressed, lz4_frame, zstd. Note: lz4_frame offers faster (de)compression, but typically results in larger spill files. In contrast, zstd achieves higher compression ratios at the cost of slower (de)compression speed. datafusion.execution.split_file_groups_by_statistics false Attempt to eliminate sorts by packing & sorting files with non-overlapping statistics into the same file groups. Currently experimental -datafusion.execution.target_batch_size_bytes NULL Soft target, in bytes, for the in-memory size of batches produced by data sources, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. When `None` (the default), batches are only split by row count. +datafusion.execution.target_batch_size_bytes NULL Soft target, in bytes, for the in-memory size of batches, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. Sorts, sort-preserving merges and aggregation spills also bound their output and spill batches to roughly this size instead of emitting `batch_size`-row batches of unbounded byte size. When `None` (the default), batches are only chunked by row count. datafusion.execution.target_partitions 7 Number of partitions for query execution. Increasing partitions can increase concurrency. Defaults to the number of CPU cores on the system datafusion.execution.time_zone NULL The default time zone Some functions, e.g. `now` return timestamps in this time zone datafusion.execution.use_row_number_estimates_to_optimize_partitioning false Should DataFusion use row number estimates at the input to decide whether increasing parallelism is beneficial or not. By default, only exact row numbers (not estimates) are used for this decision. Setting this flag to `true` will likely produce better plans. if the source of statistics is accurate. We plan to make this the default in the future. diff --git a/docs/source/user-guide/configs.md b/docs/source/user-guide/configs.md index e0d9154741ea4..7ba0c7b8b114a 100644 --- a/docs/source/user-guide/configs.md +++ b/docs/source/user-guide/configs.md @@ -74,7 +74,7 @@ The following configuration settings are available: | datafusion.catalog.has_header | true | Default value for `format.has_header` for `CREATE EXTERNAL TABLE` if not specified explicitly in the statement. | | datafusion.catalog.newlines_in_values | false | Specifies whether newlines in (quoted) CSV values are supported. This is the default value for `format.newlines_in_values` for `CREATE EXTERNAL TABLE` if not specified explicitly in the statement. Parsing newlines in quoted values may be affected by execution behaviour such as parallel file scanning. Setting this to `true` ensures that newlines in values are parsed successfully, which may reduce performance. | | datafusion.execution.batch_size | 8192 | Default batch size while creating new batches, it's especially useful for buffer-in-memory batches since creating tiny batches would result in too much metadata memory consumption | -| datafusion.execution.target_batch_size_bytes | NULL | Soft target, in bytes, for the in-memory size of batches produced by data sources, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. When `None` (the default), batches are only split by row count. | +| datafusion.execution.target_batch_size_bytes | NULL | Soft target, in bytes, for the in-memory size of batches, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. Sorts, sort-preserving merges and aggregation spills also bound their output and spill batches to roughly this size instead of emitting `batch_size`-row batches of unbounded byte size. When `None` (the default), batches are only chunked by row count. | | datafusion.execution.perfect_hash_join_small_build_threshold | 1024 | A perfect hash join (see `HashJoinExec` for more details) will be considered if the range of keys (max - min) on the build side is < this threshold. This provides a fast path for joins with very small key ranges, bypassing the density check. Currently only supports cases where build_side.num_rows() < u32::MAX. Support for build_side.num_rows() >= u32::MAX will be added in the future. | | datafusion.execution.perfect_hash_join_min_key_density | 0.15 | The minimum required density of join keys on the build side to consider a perfect hash join (see `HashJoinExec` for more details). Density is calculated as: `(number of rows) / (max_key - min_key + 1)`. A perfect hash join may be used if the actual key density > this value. Currently only supports cases where build_side.num_rows() < u32::MAX. Support for build_side.num_rows() >= u32::MAX will be added in the future. | | datafusion.execution.coalesce_batches | true | When set to true, record batches will be examined between each operator and small batches will be coalesced into larger batches. This is helpful when there are highly selective filters or joins that could produce tiny output batches. The target batch size is determined by the configuration setting | diff --git a/lv_ab.log b/lv_ab.log new file mode 100644 index 0000000000000..aa2678d51857b --- /dev/null +++ b/lv_ab.log @@ -0,0 +1,55 @@ +>>> large_values mode=unlimited cfg=off round=1 +Query 1 avg time: 249.13 ms +Query 2 avg time: 197.81 ms +Query 3 avg time: 231.51 ms +Query 4 avg time: 177.36 ms +Query 5 avg time: 310.93 ms +>>> large_values mode=unlimited cfg=on round=1 +Query 1 avg time: 174.58 ms +Query 2 avg time: 178.78 ms +Query 3 avg time: 307.93 ms +Query 4 avg time: 183.48 ms +Query 5 avg time: 328.14 ms +>>> large_values mode=unlimited cfg=off round=2 +Query 1 avg time: 164.27 ms +Query 2 avg time: 147.94 ms +Query 3 avg time: 214.71 ms +Query 4 avg time: 161.33 ms +Query 5 avg time: 305.55 ms +>>> large_values mode=unlimited cfg=on round=2 +Query 1 avg time: 174.09 ms +Query 2 avg time: 166.66 ms +Query 3 avg time: 229.50 ms +Query 4 avg time: 179.87 ms +Query 5 avg time: 334.11 ms +>>> large_values mode=mem2g cfg=off round=1 +Query 1 avg time: 176.08 ms +Query 2 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. +Resources exhausted: Additional allocation failed for ExternalSorter[0] with top memory consumers (across reservations) as: +Query 3 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. +Resources exhausted: Additional allocation failed for ExternalSorter[0] with top memory consumers (across reservations) as: +Query 4 avg time: 171.76 ms +Query 5 avg time: 325.76 ms +>>> large_values mode=mem2g cfg=on round=1 +Query 1 avg time: 183.56 ms +Query 2 failed: Resources exhausted: Additional allocation failed for SortPreservingMergeExec[0] with top memory consumers (across reservations) as: +Query 3 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. +Resources exhausted: Additional allocation failed for ExternalSorter[6] with top memory consumers (across reservations) as: +Query 4 avg time: 218.22 ms +Query 5 avg time: 385.80 ms +>>> large_values mode=mem2g cfg=off round=2 +Query 1 avg time: 183.37 ms +Query 2 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. +Resources exhausted: Additional allocation failed for ExternalSorter[2] with top memory consumers (across reservations) as: +Query 3 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. +Resources exhausted: Additional allocation failed for ExternalSorter[3] with top memory consumers (across reservations) as: +Query 4 avg time: 176.02 ms +Query 5 avg time: 314.73 ms +>>> large_values mode=mem2g cfg=on round=2 +Query 1 avg time: 179.79 ms +Query 2 failed: Resources exhausted: Additional allocation failed for SortPreservingMergeExec[0] with top memory consumers (across reservations) as: +Query 3 failed: Resources exhausted: Additional allocation failed for SortPreservingMergeExec[0] with top memory consumers (across reservations) as: +Query 4 avg time: 188.47 ms +Query 5 avg time: 349.71 ms +LV AB DONE +EXIT: 0 diff --git a/pr_body.md b/pr_body.md new file mode 100644 index 0000000000000..924fb87cb124e --- /dev/null +++ b/pr_body.md @@ -0,0 +1,48 @@ +## Which issue does this PR close? + +- N/A (design discussed offline; can file a tracking issue if preferred) + +## Rationale for this change + +Operators bound their output batches by row count (`datafusion.execution.batch_size`) only. With wide rows (large string values, wide schemas) a batch within the row limit can still be arbitrarily large in bytes — multi-GB batches break memory accounting assumptions and cause OOMs. Conversely, streams of many tiny batches waste per-batch overhead. + +The existing `BatchSplitStream` on `DataSourceExec` splits by rows only, and splitting by zero-copy `slice` cannot release memory anyway: a slice of a 4GB batch still pins all 4GB of buffers (arrow's `concat` also short-circuits single inputs to a zero-copy slice). + +This PR adds a **batch normalizer**: a stream wrapper that re-chunks data source output towards a target row count *and* byte size, opt-in via a new config option. + +## What changes are included in this PR? + +1. `BatchNormalizer` / `BatchNormalizerStream` (`datafusion/physical-plan/src/batch_normalizer.rs`). Per input batch, one of four actions: + - **Pass through** (zero copy): rows ≥ `batch_size / 2` or logical bytes ≥ `target / 2`, up to `2x` the byte target. The wide acceptance band means near-target batches are never copied. + - **Coalesce**: small batches are buffered (via arrow `BatchCoalescer`) and flushed when the buffer reaches the row target **or** the byte target, whichever first. + - **Split**: oversized batches (by rows or bytes) are re-emitted as compact ~target-sized copies (`take_record_batch` + view-array GC), produced incrementally (one chunk per poll) so peak memory is the parent plus ~one chunk. Copying is load-bearing: zero-copy slices would keep the oversized parent alive. + - **Compact**: batches that retain far more memory than they logically use (> 2x and > 1MiB waste, e.g. a small slice pinning a huge parent, or sparse StringView data buffers) are copied so the backing buffers can be freed. +2. New config `datafusion.execution.target_batch_size_bytes` (default `None` = unchanged behavior). When set, `DataSourceExec` wraps its output in `BatchNormalizerStream` instead of the row-only `BatchSplitStream`. +3. Operator metrics: `batches_passed_through`, `batches_coalesced`, `batches_split`, `batches_compacted`. + +Planned follow-ups (intentionally not in this PR): memory-pool reservation for the normalizer's buffer with a spill fallback (following the `RepartitionExec` `OutputChannel`/`SpillPool` pattern), and byte-aware bounding for operator emit paths (join/aggregate output amplification is not addressable at the scan). + +## Local benchmark observations (laptop, noisy — GKE runs requested) + +Interleaved off/on A/B (2 rounds, per-query minimums, same binary, 16MiB target via `DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES`): + +- TPC-H SF1: total off 623ms vs on 678ms. Operator metrics confirm the normalizer is pure zero-copy pass-through on these scans (e.g. Q1/Q6: 742/742 `batches_passed_through`, 0 copies), so the residual delta is per-batch size measurement overhead and/or laptop noise (off-vs-off noise floor spans 0.66-1.22x per query). +- ClickBench partitioned: total off 21.9s vs on 22.4s (+2.6%; noise floor p90 1.13x). String-heavy group-by queries (Q13/Q17/Q21) show 1.19-1.25x, slightly above the noise band — likely the StringView waste-compaction path; being investigated with operator metrics. Improvements to 0.81x on Q32/Q33. + +Laptop numbers are close to the noise floor; treating the dedicated benchmark runner as the source of truth. + +## Are these changes tested? + +Yes — written test-first (TDD): + +- 18 unit tests covering pass-through zero-copy guarantees (pointer equality), coalesce flush on rows/bytes, incremental split with compaction guarantees (chunks must not retain the parent's buffers, including the StringView GC case), waste compaction and its thresholds, ordering across buffered/pass-through boundaries, single-giant-row and zero-column edge cases, metrics, and the stream adapter. +- 3 end-to-end tests exercising the config through `SessionContext` scans. +- Extended workspace test suite passes; config docs and `information_schema.slt` regenerated. + +## Are there any user-facing changes? + +New opt-in config option `datafusion.execution.target_batch_size_bytes` (documented in `configs.md`). Default behavior is unchanged. No breaking API changes. + +🤖 Generated with [Claude Code](https://claude.com/claude-code) + +https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm diff --git a/rerun_tpch.sh b/rerun_tpch.sh new file mode 100755 index 0000000000000..b4cdf466dbc03 --- /dev/null +++ b/rerun_tpch.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +# tpch-only rerun (rounds 3,4) after the polluted rounds 1,2; overwrites nothing. +set -e +BRANCH_DIR="/tmp/datafusion-batch-normalizer" +DATA="$HOME/GitHub/datafusion/benchmarks/data" +BIN="$BRANCH_DIR/target/release/dfbench" +OUT="$BRANCH_DIR/ab_results" +rm -f "$OUT"/tpch_*_r1.json "$OUT"/tpch_*_r2.json +for round in 3 4; do + for cfg in off on; do + envargs=() + [ "$cfg" = on ] && envargs=(DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=16777216) + echo ">>> tpch cfg=$cfg round=$round" + env "${envargs[@]}" "$BIN" tpch --iterations 3 \ + --path "$DATA/tpch_sf1" --format parquet -o "$OUT/tpch_${cfg}_r${round}.json" > /dev/null + done +done +echo "TPCH RERUN DONE" diff --git a/run_benchmarks.sh b/run_benchmarks.sh new file mode 100755 index 0000000000000..3eaaa775dd229 --- /dev/null +++ b/run_benchmarks.sh @@ -0,0 +1,49 @@ +#!/usr/bin/env bash +# Benchmark driver for the batch-normalizer branch. +# +# tpch / tpch_mem use the criterion "sql" bench harness: run config-off as a +# saved baseline, then config-on compared against it (same binary, env flip). +# clickbench_partitioned / tpcds use dfbench JSON results: bn-off vs bn-on +# from the branch binary, plus a main-binary baseline for clickbench. +set -e + +export DATA_DIR="$HOME/GitHub/datafusion/benchmarks/data" +MAIN_DIR="$HOME/GitHub/datafusion" +BRANCH_DIR="/tmp/datafusion-batch-normalizer" +TARGET_BYTES=16777216 # 16MiB soft target +ON_ENV="DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=$TARGET_BYTES" + +echo "=== prebuild binaries ===" +(cd "$BRANCH_DIR" && cargo build --release -p datafusion-benchmarks --bin dfbench 2>&1 | tail -1) +(cd "$MAIN_DIR" && cargo build --release -p datafusion-benchmarks --bin dfbench 2>&1 | tail -1) + +# --- criterion suites: tpch, tpch_mem (branch binary, off-baseline vs on) --- +criterion_suite() { + local suite=$1 + echo "=== $suite: branch, normalizer OFF (save baseline) ===" + (cd "$BRANCH_DIR" && SQL_CARGO_COMMAND="cargo bench --bench sql -- --save-baseline bnoff" \ + ./benchmarks/bench.sh run "$suite") + echo "=== $suite: branch, normalizer ON vs baseline ===" + (cd "$BRANCH_DIR" && env $ON_ENV \ + SQL_CARGO_COMMAND="cargo bench --bench sql -- --baseline bnoff" \ + ./benchmarks/bench.sh run "$suite") +} + +# --- dfbench suites (JSON results) --- +dfbench_branch() { + local suite=$1 + echo "=== $suite: branch, normalizer OFF ===" + (cd "$BRANCH_DIR" && RESULTS_NAME=bn-off ./benchmarks/bench.sh run "$suite") + echo "=== $suite: branch, normalizer ON ===" + (cd "$BRANCH_DIR" && env $ON_ENV RESULTS_NAME=bn-on ./benchmarks/bench.sh run "$suite") +} + +criterion_suite tpch +criterion_suite tpch_mem + +echo "=== clickbench_partitioned: main baseline ===" +(cd "$MAIN_DIR" && RESULTS_NAME=bn-main ./benchmarks/bench.sh run clickbench_partitioned) +dfbench_branch clickbench_partitioned +dfbench_branch tpcds + +echo "=== ALL BENCHMARKS DONE ===" diff --git a/run_benchmarks2.sh b/run_benchmarks2.sh new file mode 100755 index 0000000000000..a7feb92972b78 --- /dev/null +++ b/run_benchmarks2.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +# Interleaved A/B benchmark: normalizer off vs on, same branch binary. +# Two rounds of off->on per suite; compare per-query minimums across rounds +# to be robust against environment drift (the failure mode of run 1). +set -e + +BRANCH_DIR="/tmp/datafusion-batch-normalizer" +DATA="$HOME/GitHub/datafusion/benchmarks/data" +QUERIES="$HOME/GitHub/datafusion/benchmarks/queries" +TPCDS_QUERIES="$HOME/GitHub/datafusion/datafusion/core/tests/tpc-ds" +BIN="$BRANCH_DIR/target/release/dfbench" +OUT="$BRANCH_DIR/ab_results" +TARGET_BYTES=16777216 + +mkdir -p "$OUT" +cd "$BRANCH_DIR" + +run_one() { + local suite=$1 cfg=$2 round=$3 + local envargs=() + if [ "$cfg" = on ]; then + envargs=(DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=$TARGET_BYTES) + fi + local out="$OUT/${suite}_${cfg}_r${round}.json" + echo ">>> $suite cfg=$cfg round=$round" + case $suite in + tpch) + env "${envargs[@]}" "$BIN" tpch --iterations 3 \ + --path "$DATA/tpch_sf1" --format parquet -o "$out" > /dev/null + ;; + clickbench) + env "${envargs[@]}" "$BIN" clickbench --iterations 3 \ + --path "$DATA/hits_partitioned" \ + --queries-path "$QUERIES/clickbench/queries" -o "$out" > /dev/null + ;; + tpcds) + env "${envargs[@]}" "$BIN" tpcds --iterations 3 \ + --path "$DATA/tpcds_sf1" --query_path "$TPCDS_QUERIES" \ + --prefer_hash_join true -o "$out" > /dev/null + ;; + esac +} + +for suite in tpch clickbench tpcds; do + for round in 1 2; do + for cfg in off on; do + run_one "$suite" "$cfg" "$round" + done + done +done + +echo "AB BENCHMARKS DONE" diff --git a/run_lv_ab.sh b/run_lv_ab.sh new file mode 100755 index 0000000000000..683951c3838ad --- /dev/null +++ b/run_lv_ab.sh @@ -0,0 +1,36 @@ +#!/usr/bin/env bash +# Interleaved A/B for the large_values benchmark: normalizer off vs on, +# unlimited memory and 2GB memory limit (fair pool + disk spill). +set -e + +BRANCH_DIR="/tmp/datafusion-batch-normalizer" +BIN="$BRANCH_DIR/target/release/dfbench" +DATA="$HOME/GitHub/datafusion/benchmarks/data/large_values" +OUT="$BRANCH_DIR/ab_results" +TARGET_BYTES=16777216 + +mkdir -p "$OUT" + +run_one() { + local mode=$1 cfg=$2 round=$3 + local envargs=() limitargs=() iters=3 + [ "$cfg" = on ] && envargs=(DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=$TARGET_BYTES) + if [ "$mode" = mem2g ]; then + limitargs=(--memory-limit 2G) + iters=2 + fi + echo ">>> large_values mode=$mode cfg=$cfg round=$round" + env "${envargs[@]}" "$BIN" large-values --iterations $iters \ + --path "$DATA" "${limitargs[@]}" \ + -o "$OUT/lv-${mode}_${cfg}_r${round}.json" 2>&1 | grep -E 'failed|avg' +} + +for mode in unlimited mem2g; do + for round in 1 2; do + for cfg in off on; do + run_one "$mode" "$cfg" "$round" + done + done +done + +echo "LV AB DONE" diff --git a/test_suite2.log b/test_suite2.log new file mode 100644 index 0000000000000..58f0cf0ebe4e6 --- /dev/null +++ b/test_suite2.log @@ -0,0 +1 @@ +EXIT: 0 diff --git a/test_suite_output.log b/test_suite_output.log new file mode 100644 index 0000000000000..022d688b9cef2 --- /dev/null +++ b/test_suite_output.log @@ -0,0 +1,81 @@ +test cases::roundtrip_physical_plan::wildcard_select ... ok +test cases::serialize::tests::include_remaps_for_projects ... ok +test cases::serialize::tests::include_remaps_for_windows ... ok +test cases::roundtrip_logical_plan::try_cast_decimal_to_string ... ok +test cases::serialize::tests::serialize_simple_select ... ok +test cases::serialize::tests::table_scan_without_projection ... ok +test cases::serialize::tests::serialize_to_file ... ok +test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_exact ... ok +test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_not_subset ... ok +test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_subset ... ok +test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_subset_with_mask ... ok +test cases::roundtrip_logical_plan::all_type_literal ... ok +test cases::substrait_validations::tests::schema_compatibility::reject_plans_with_incompatible_field_nullability ... ok +test cases::substrait_validations::tests::schema_compatibility::reject_plans_with_incompatible_field_types ... ok +test cases::roundtrip_logical_plan::simple_aggregate ... ok +test cases::roundtrip_logical_plan::simple_window_function ... ok +test cases::roundtrip_logical_plan::simple_intersect_table_reuse ... ok +test cases::roundtrip_logical_plan::simple_intersect ... ok +test cases::consumer_integration::tests::tpch_test_19 ... ok +test cases::serialize::tests::higher_order_function ... ok +test cases::consumer_integration::tests::tpch_test_22 ... ok +test cases::roundtrip_logical_plan::window_with_rows ... ok +test cases::roundtrip_logical_plan::roundtrip_array_transform_higher_order_function ... ok + +test result: ok. 200 passed; 0 failed; 6 ignored; 0 measured; 0 filtered out; finished in 1.26s + + Running tests/utils.rs (target/ci/deps/utils-70afe979898e7729) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/ci/deps/datafusion_wasmtest-7e361b1316a80476) + +running 6 tests +test test::test_parquet_write ... ok +test test::basic_execute ... ok +test test::test_parquet_read_and_write ... ok +test test::test_csv_read_xz_compressed ... ok +test test::basic_df_function_execute ... ok +test test::test_basic_aggregate ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.11s + + Running unittests src/lib.rs (target/ci/deps/ffi_example_table_provider-893f4913c8ab6c61) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/ci/deps/ffi_module_interface-9a41e100f9d90255) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/ci/deps/ffi_module_loader-150f75c332fc06ba) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/ci/deps/gen-93e8d1206f8c17bf) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/ci/deps/gen_common-155a74322ca91bb8) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/ci/deps/test_utils-2cc61db516d825b4) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + +EXIT: 0 From 047ea98678c2b3c30736b254c085a6660a2eb464 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 12:01:28 -0500 Subject: [PATCH 06/11] feat: wire large_values benchmark into bench.sh Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- benchmarks/bench.sh | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/benchmarks/bench.sh b/benchmarks/bench.sh index 52b78c844a73a..6d24eef0de04a 100755 --- a/benchmarks/bench.sh +++ b/benchmarks/bench.sh @@ -102,6 +102,7 @@ topk_tpch: Benchmark of top-k (sorting with limit) queries on TPC-H topk_sorted_tpch: Benchmark of top-k queries on TPC-H lineitem ordered by l_orderkey (SF=1) push_down_topk: Benchmark of ORDER BY ... LIMIT over outer joins on TPC-H dataset (SF=1) — exercises pushing TopK through a join external_aggr: External aggregation benchmark on TPC-H dataset (SF=1) +large_values: Queries over very large row values (multi-KiB strings; batches within batch_size rows but 100MB+ in memory); data is generated on first run wide_schema: Small-projection queries on a wide synthetic dataset (1024 cols × 256 files) — measures per-file metadata overhead (runs both 'wide' and 'narrow' subgroups: narrow is an internal baseline; the wide-vs-narrow ratio is the signal) predicate_eval: Conjunctive (AND) filter-evaluation micro-benchmarks; each subgroup is a different predicate pattern, to test how an @@ -554,6 +555,9 @@ main() { external_aggr) run_external_aggr ;; + large_values) + run_large_values + ;; sort_pushdown) run_sort_pushdown ;; @@ -1235,6 +1239,16 @@ run_h2o_window() { } # Runs the external aggregation benchmark +# Runs the large_values benchmark: queries over multi-KiB string values whose +# batches stay within batch_size rows but are 100MB+ in memory. The dfbench +# subcommand generates its dataset on first use. +run_large_values() { + RESULTS_FILE="${RESULTS_DIR}/large_values.json" + echo "RESULTS_FILE: ${RESULTS_FILE}" + echo "Running large_values benchmark..." + debug_run $CARGO_COMMAND --bin dfbench -- large-values --iterations 5 --path "${DATA_DIR}/large_values" -o "${RESULTS_FILE}" ${QUERY_ARG} +} + run_external_aggr() { # Use TPC-H SF1 dataset TPCH_DIR="${DATA_DIR}/tpch_sf1" From 3a03ec5b7308b9c2e670be4dd05b539abab05b35 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 14:28:21 -0500 Subject: [PATCH 07/11] fix: scale the compaction waste floor to target_batch_size_bytes The GKE on/off A/B showed clickbench_partitioned +5% with the flag on (17 queries slower, up to 1.2x on string-heavy scans). EXPLAIN ANALYZE attribution: 7.96K of 12.3K scan batches hit the waste-compaction path, because parquet-decoded string batches routinely retain 2-4x their logical size via decode buffers shared across consecutive batches -- tripping the flat 1MB absolute-waste floor on nearly every batch and paying a full copy each time for no benefit. Require the absolute waste to also reach target_batch_size_bytes: that is the scale at which pinned memory matters, and shared-decode-buffer false positives sit well below it. After the fix Q22 shows 0 compacted / 12.2K passed through, and the Q21/Q22 regressions drop from 1.19-1.20x to ~1.01x locally. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- .../physical-plan/src/batch_normalizer.rs | 43 +++++++++++++++++-- 1 file changed, 40 insertions(+), 3 deletions(-) diff --git a/datafusion/physical-plan/src/batch_normalizer.rs b/datafusion/physical-plan/src/batch_normalizer.rs index afd9a43d58515..c9181c430771b 100644 --- a/datafusion/physical-plan/src/batch_normalizer.rs +++ b/datafusion/physical-plan/src/batch_normalizer.rs @@ -76,8 +76,13 @@ const SPLIT_SLOP_FACTOR: usize = 2; /// more than this multiple of its logical size... const WASTE_RATIO: usize = 2; -/// ...and the absolute waste exceeds this many bytes. Compaction copies data, -/// which is only worth it if it frees a meaningful amount of memory. +/// ...and the absolute waste exceeds `max(MIN_WASTE_BYTES, target_bytes)`. +/// Compaction copies data, which only pays off when it frees memory that is +/// large on the scale the byte target cares about. In particular, +/// parquet-decoded string/view batches routinely retain 2-4x their logical +/// size because decode buffers are shared across consecutive batches; +/// compacting every such batch costs a copy per batch for no benefit (the +/// batches die immediately in streaming pipelines). const MIN_WASTE_BYTES: usize = 1024 * 1024; /// Metrics for [`BatchNormalizer`] @@ -306,8 +311,9 @@ impl BatchNormalizer { // (e.g. a small slice of a huge batch): copy it so the backing // buffers can be freed. let retained = get_record_batch_memory_size(&batch); + let min_waste = MIN_WASTE_BYTES.max(self.target_bytes); let wasteful = retained > WASTE_RATIO * logical - && retained.saturating_sub(logical) >= MIN_WASTE_BYTES; + && retained.saturating_sub(logical) >= min_waste; let batch = if wasteful { self.metrics.batches_compacted.add(1); compact_slice(&batch, 0, rows)? @@ -757,6 +763,37 @@ mod tests { assert!(Arc::ptr_eq(slice.column(1), out[0].column(1))); } + #[test] + fn moderately_wasteful_batch_below_target_passes_through() { + // ClickBench regression shape: parquet-decoded view/string batches + // routinely retain 2-4x their logical size because decode buffers are + // shared across consecutive batches. Waste that is large in ratio but + // small relative to target_bytes must NOT trigger a per-batch copy -- + // in a streaming pipeline these batches die immediately and + // compacting them is pure overhead. + let target_bytes = 16 * 1024 * 1024; + let parent = string_batch(16 * 1024, 1024); // ~17MB retained + let slice = parent.slice(0, 5000); // ~5MB logical, ~12MB waste, ratio >2 + let logical = logical_size(&slice); + let retained = get_record_batch_memory_size(&slice); + assert!(retained > WASTE_RATIO * logical); + assert!(retained - logical > MIN_WASTE_BYTES); + assert!(retained - logical < target_bytes); + + let mut n = BatchNormalizer::new( + test_schema(), + 8192, + target_bytes, + BatchNormalizerMetrics::default(), + ); + let out = run(&mut n, [slice.clone()]); + assert_eq!(out.len(), 1); + assert!( + Arc::ptr_eq(slice.column(1), out[0].column(1)), + "moderately wasteful batch should pass through zero-copy" + ); + } + // === ordering / flush === #[test] From 2cf5402b589b530bf3b5a867031e5bfd5905bd5f Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 14:29:11 -0500 Subject: [PATCH 08/11] chore: allow too_many_arguments on SortPreservingMergeStream::new Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- datafusion/physical-plan/src/sorts/merge.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/datafusion/physical-plan/src/sorts/merge.rs b/datafusion/physical-plan/src/sorts/merge.rs index ab8d246a47294..241e864a0dcda 100644 --- a/datafusion/physical-plan/src/sorts/merge.rs +++ b/datafusion/physical-plan/src/sorts/merge.rs @@ -156,6 +156,7 @@ pub(crate) struct SortPreservingMergeStream { } impl SortPreservingMergeStream { + #[expect(clippy::too_many_arguments)] pub(crate) fn new( streams: CursorStream, schema: SchemaRef, From cefa8d169a3184a794afa64704048478d6ca1b18 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 17:30:29 -0500 Subject: [PATCH 09/11] chore: remove accidentally committed local benchmark results and scripts Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- ab_results/clickbench_off_r1.json | 838 ------------ ab_results/clickbench_off_r2.json | 838 ------------ ab_results/clickbench_on_r1.json | 838 ------------ ab_results/clickbench_on_r2.json | 838 ------------ ab_results/lv-mem2g_off_r1.json | 78 -- ab_results/lv-mem2g_off_r2.json | 78 -- ab_results/lv-mem2g_on_r1.json | 78 -- ab_results/lv-mem2g_on_r2.json | 78 -- ab_results/lv-unlimited_off_r1.json | 114 -- ab_results/lv-unlimited_off_r2.json | 114 -- ab_results/lv-unlimited_on_r1.json | 114 -- ab_results/lv-unlimited_on_r2.json | 114 -- ab_results/tpcds_off_r1.json | 1891 --------------------------- ab_results/tpcds_off_r2.json | 1891 --------------------------- ab_results/tpcds_on_r1.json | 1891 --------------------------- ab_results/tpcds_on_r2.json | 1891 --------------------------- ab_results/tpch_off_r1.json | 439 ------- ab_results/tpch_off_r2.json | 439 ------- ab_results/tpch_on_r1.json | 439 ------- ab_results/tpch_on_r2.json | 439 ------- analyze_ab.py | 51 - bench_ab.log | 22 - bench_run.log | 568 -------- lv_ab.log | 55 - pr_body.md | 48 - rerun_tpch.sh | 18 - run_benchmarks.sh | 49 - run_benchmarks2.sh | 52 - run_lv_ab.sh | 36 - test_suite2.log | 1 - test_suite_output.log | 81 -- 31 files changed, 14421 deletions(-) delete mode 100644 ab_results/clickbench_off_r1.json delete mode 100644 ab_results/clickbench_off_r2.json delete mode 100644 ab_results/clickbench_on_r1.json delete mode 100644 ab_results/clickbench_on_r2.json delete mode 100644 ab_results/lv-mem2g_off_r1.json delete mode 100644 ab_results/lv-mem2g_off_r2.json delete mode 100644 ab_results/lv-mem2g_on_r1.json delete mode 100644 ab_results/lv-mem2g_on_r2.json delete mode 100644 ab_results/lv-unlimited_off_r1.json delete mode 100644 ab_results/lv-unlimited_off_r2.json delete mode 100644 ab_results/lv-unlimited_on_r1.json delete mode 100644 ab_results/lv-unlimited_on_r2.json delete mode 100644 ab_results/tpcds_off_r1.json delete mode 100644 ab_results/tpcds_off_r2.json delete mode 100644 ab_results/tpcds_on_r1.json delete mode 100644 ab_results/tpcds_on_r2.json delete mode 100644 ab_results/tpch_off_r1.json delete mode 100644 ab_results/tpch_off_r2.json delete mode 100644 ab_results/tpch_on_r1.json delete mode 100644 ab_results/tpch_on_r2.json delete mode 100644 analyze_ab.py delete mode 100644 bench_ab.log delete mode 100644 bench_run.log delete mode 100644 lv_ab.log delete mode 100644 pr_body.md delete mode 100755 rerun_tpch.sh delete mode 100755 run_benchmarks.sh delete mode 100755 run_benchmarks2.sh delete mode 100755 run_lv_ab.sh delete mode 100644 test_suite2.log delete mode 100644 test_suite_output.log diff --git a/ab_results/clickbench_off_r1.json b/ab_results/clickbench_off_r1.json deleted file mode 100644 index c4d3c192f09ea..0000000000000 --- a/ab_results/clickbench_off_r1.json +++ /dev/null @@ -1,838 +0,0 @@ -{ - "queries": [ - { - "query": "Query 0", - "iterations": [ - { - "elapsed": 10.636792000000002, - "row_count": 1 - }, - { - "elapsed": 0.996291, - "row_count": 1 - }, - { - "elapsed": 0.752083, - "row_count": 1 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 13.110958, - "row_count": 1 - }, - { - "elapsed": 9.677332999999999, - "row_count": 1 - }, - { - "elapsed": 9.441583, - "row_count": 1 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 40.527750000000005, - "row_count": 1 - }, - { - "elapsed": 35.489875, - "row_count": 1 - }, - { - "elapsed": 35.82, - "row_count": 1 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 50.697167, - "row_count": 1 - }, - { - "elapsed": 35.816375, - "row_count": 1 - }, - { - "elapsed": 33.748124999999995, - "row_count": 1 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 284.429958, - "row_count": 1 - }, - { - "elapsed": 246.957125, - "row_count": 1 - }, - { - "elapsed": 238.5355, - "row_count": 1 - } - ], - "start_time": 1783521320, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 408.82012499999996, - "row_count": 1 - }, - { - "elapsed": 308.69625, - "row_count": 1 - }, - { - "elapsed": 297.91925000000003, - "row_count": 1 - } - ], - "start_time": 1783521320, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 2.029875, - "row_count": 1 - }, - { - "elapsed": 1.01, - "row_count": 1 - }, - { - "elapsed": 0.733583, - "row_count": 1 - } - ], - "start_time": 1783521321, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 10.715916, - "row_count": 18 - }, - { - "elapsed": 10.89125, - "row_count": 18 - }, - { - "elapsed": 13.660709, - "row_count": 18 - } - ], - "start_time": 1783521321, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 369.200042, - "row_count": 10 - }, - { - "elapsed": 390.686875, - "row_count": 10 - }, - { - "elapsed": 356.26858300000004, - "row_count": 10 - } - ], - "start_time": 1783521321, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 441.60949999999997, - "row_count": 10 - }, - { - "elapsed": 437.158708, - "row_count": 10 - }, - { - "elapsed": 469.328792, - "row_count": 10 - } - ], - "start_time": 1783521323, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 68.55791699999999, - "row_count": 10 - }, - { - "elapsed": 70.536709, - "row_count": 10 - }, - { - "elapsed": 67.517125, - "row_count": 10 - } - ], - "start_time": 1783521324, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 87.96908400000001, - "row_count": 10 - }, - { - "elapsed": 102.623542, - "row_count": 10 - }, - { - "elapsed": 95.89625000000001, - "row_count": 10 - } - ], - "start_time": 1783521324, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 358.362917, - "row_count": 10 - }, - { - "elapsed": 311.256958, - "row_count": 10 - }, - { - "elapsed": 323.571458, - "row_count": 10 - } - ], - "start_time": 1783521324, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 462.247959, - "row_count": 10 - }, - { - "elapsed": 455.317542, - "row_count": 10 - }, - { - "elapsed": 411.10049999999995, - "row_count": 10 - } - ], - "start_time": 1783521325, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 313.504917, - "row_count": 10 - }, - { - "elapsed": 291.132167, - "row_count": 10 - }, - { - "elapsed": 308.518958, - "row_count": 10 - } - ], - "start_time": 1783521327, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 268.445084, - "row_count": 10 - }, - { - "elapsed": 287.097209, - "row_count": 10 - }, - { - "elapsed": 297.423125, - "row_count": 10 - } - ], - "start_time": 1783521328, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 875.591709, - "row_count": 10 - }, - { - "elapsed": 709.986667, - "row_count": 10 - }, - { - "elapsed": 671.4042919999999, - "row_count": 10 - } - ], - "start_time": 1783521328, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 680.3142909999999, - "row_count": 10 - }, - { - "elapsed": 681.31575, - "row_count": 10 - }, - { - "elapsed": 650.4926250000001, - "row_count": 10 - } - ], - "start_time": 1783521331, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 1926.9366670000002, - "row_count": 10 - }, - { - "elapsed": 1731.15825, - "row_count": 10 - }, - { - "elapsed": 1484.126375, - "row_count": 10 - } - ], - "start_time": 1783521333, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 23.231667, - "row_count": 4 - }, - { - "elapsed": 22.635375, - "row_count": 4 - }, - { - "elapsed": 23.23025, - "row_count": 4 - } - ], - "start_time": 1783521338, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 741.956625, - "row_count": 1 - }, - { - "elapsed": 587.169709, - "row_count": 1 - }, - { - "elapsed": 578.187959, - "row_count": 1 - } - ], - "start_time": 1783521338, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 666.699625, - "row_count": 10 - }, - { - "elapsed": 676.720125, - "row_count": 10 - }, - { - "elapsed": 603.946042, - "row_count": 10 - } - ], - "start_time": 1783521340, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 1305.983, - "row_count": 10 - }, - { - "elapsed": 1215.559292, - "row_count": 10 - }, - { - "elapsed": 1496.914458, - "row_count": 10 - } - ], - "start_time": 1783521342, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 4005.849459, - "row_count": 10 - }, - { - "elapsed": 3692.944416, - "row_count": 10 - }, - { - "elapsed": 3646.3434169999996, - "row_count": 10 - } - ], - "start_time": 1783521346, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 41.810125, - "row_count": 10 - }, - { - "elapsed": 38.102083, - "row_count": 10 - }, - { - "elapsed": 42.853625, - "row_count": 10 - } - ], - "start_time": 1783521357, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 130.636833, - "row_count": 10 - }, - { - "elapsed": 133.10312499999998, - "row_count": 10 - }, - { - "elapsed": 133.94508299999998, - "row_count": 10 - } - ], - "start_time": 1783521357, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 43.594750000000005, - "row_count": 10 - }, - { - "elapsed": 40.873667000000005, - "row_count": 10 - }, - { - "elapsed": 40.230792, - "row_count": 10 - } - ], - "start_time": 1783521358, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 854.735958, - "row_count": 25 - }, - { - "elapsed": 797.480375, - "row_count": 25 - }, - { - "elapsed": 779.8305, - "row_count": 25 - } - ], - "start_time": 1783521358, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 2999.923208, - "row_count": 25 - }, - { - "elapsed": 2904.0651669999997, - "row_count": 25 - }, - { - "elapsed": 2907.92525, - "row_count": 25 - } - ], - "start_time": 1783521360, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 36.826417, - "row_count": 1 - }, - { - "elapsed": 40.079334, - "row_count": 1 - }, - { - "elapsed": 36.367458, - "row_count": 1 - } - ], - "start_time": 1783521369, - "success": true - }, - { - "query": "Query 30", - "iterations": [ - { - "elapsed": 346.85958300000004, - "row_count": 10 - }, - { - "elapsed": 354.263459, - "row_count": 10 - }, - { - "elapsed": 504.59545800000006, - "row_count": 10 - } - ], - "start_time": 1783521369, - "success": true - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 439.88624999999996, - "row_count": 10 - }, - { - "elapsed": 378.638417, - "row_count": 10 - }, - { - "elapsed": 392.276, - "row_count": 10 - } - ], - "start_time": 1783521370, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 2563.318584, - "row_count": 10 - }, - { - "elapsed": 1827.5330840000001, - "row_count": 10 - }, - { - "elapsed": 1593.9350829999998, - "row_count": 10 - } - ], - "start_time": 1783521372, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 2299.922375, - "row_count": 10 - }, - { - "elapsed": 2168.455084, - "row_count": 10 - }, - { - "elapsed": 1983.3596249999998, - "row_count": 10 - } - ], - "start_time": 1783521378, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 2131.8048329999997, - "row_count": 10 - }, - { - "elapsed": 2047.6145419999998, - "row_count": 10 - }, - { - "elapsed": 2311.581875, - "row_count": 10 - } - ], - "start_time": 1783521384, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 434.33500000000004, - "row_count": 10 - }, - { - "elapsed": 340.65979200000004, - "row_count": 10 - }, - { - "elapsed": 359.275083, - "row_count": 10 - } - ], - "start_time": 1783521391, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 52.865959, - "row_count": 10 - }, - { - "elapsed": 55.3895, - "row_count": 10 - }, - { - "elapsed": 52.296625, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 26.106333999999997, - "row_count": 10 - }, - { - "elapsed": 25.077458, - "row_count": 10 - }, - { - "elapsed": 28.070208, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 37.545584, - "row_count": 10 - }, - { - "elapsed": 52.066250000000004, - "row_count": 10 - }, - { - "elapsed": 52.099667000000004, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 151.66299999999998, - "row_count": 10 - }, - { - "elapsed": 113.709292, - "row_count": 10 - }, - { - "elapsed": 103.79125, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 10.194666999999999, - "row_count": 10 - }, - { - "elapsed": 9.335958, - "row_count": 10 - }, - { - "elapsed": 8.99325, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 9.718417, - "row_count": 10 - }, - { - "elapsed": 10.039375, - "row_count": 10 - }, - { - "elapsed": 9.251083, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 12.940125, - "row_count": 10 - }, - { - "elapsed": 7.3825, - "row_count": 10 - }, - { - "elapsed": 6.9745, - "row_count": 10 - } - ], - "start_time": 1783521392, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521319, - "arguments": [ - "clickbench", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", - "--queries-path", - "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/clickbench_off_r1.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/clickbench_off_r2.json b/ab_results/clickbench_off_r2.json deleted file mode 100644 index cb11c7a3cc3f0..0000000000000 --- a/ab_results/clickbench_off_r2.json +++ /dev/null @@ -1,838 +0,0 @@ -{ - "queries": [ - { - "query": "Query 0", - "iterations": [ - { - "elapsed": 7.757499999999999, - "row_count": 1 - }, - { - "elapsed": 0.887792, - "row_count": 1 - }, - { - "elapsed": 0.668875, - "row_count": 1 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 9.309125, - "row_count": 1 - }, - { - "elapsed": 8.767083, - "row_count": 1 - }, - { - "elapsed": 8.602625, - "row_count": 1 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 32.477125, - "row_count": 1 - }, - { - "elapsed": 31.701167, - "row_count": 1 - }, - { - "elapsed": 32.687917, - "row_count": 1 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 45.721083, - "row_count": 1 - }, - { - "elapsed": 31.109667, - "row_count": 1 - }, - { - "elapsed": 34.001125, - "row_count": 1 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 242.219625, - "row_count": 1 - }, - { - "elapsed": 227.345459, - "row_count": 1 - }, - { - "elapsed": 217.208167, - "row_count": 1 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 372.05287500000003, - "row_count": 1 - }, - { - "elapsed": 295.10479200000003, - "row_count": 1 - }, - { - "elapsed": 294.87575, - "row_count": 1 - } - ], - "start_time": 1783521466, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 1.2689590000000002, - "row_count": 1 - }, - { - "elapsed": 0.964833, - "row_count": 1 - }, - { - "elapsed": 0.855792, - "row_count": 1 - } - ], - "start_time": 1783521467, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 10.750417, - "row_count": 18 - }, - { - "elapsed": 10.834709, - "row_count": 18 - }, - { - "elapsed": 10.31625, - "row_count": 18 - } - ], - "start_time": 1783521467, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 337.553625, - "row_count": 10 - }, - { - "elapsed": 339.906, - "row_count": 10 - }, - { - "elapsed": 328.210084, - "row_count": 10 - } - ], - "start_time": 1783521467, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 446.8135, - "row_count": 10 - }, - { - "elapsed": 463.572083, - "row_count": 10 - }, - { - "elapsed": 428.645875, - "row_count": 10 - } - ], - "start_time": 1783521468, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 73.835167, - "row_count": 10 - }, - { - "elapsed": 76.976958, - "row_count": 10 - }, - { - "elapsed": 64.38408299999999, - "row_count": 10 - } - ], - "start_time": 1783521469, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 83.928, - "row_count": 10 - }, - { - "elapsed": 81.287375, - "row_count": 10 - }, - { - "elapsed": 91.643625, - "row_count": 10 - } - ], - "start_time": 1783521469, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 308.034208, - "row_count": 10 - }, - { - "elapsed": 290.759083, - "row_count": 10 - }, - { - "elapsed": 306.794959, - "row_count": 10 - } - ], - "start_time": 1783521470, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 415.42675, - "row_count": 10 - }, - { - "elapsed": 441.33691699999997, - "row_count": 10 - }, - { - "elapsed": 423.31125, - "row_count": 10 - } - ], - "start_time": 1783521471, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 332.197917, - "row_count": 10 - }, - { - "elapsed": 328.54358299999996, - "row_count": 10 - }, - { - "elapsed": 336.309625, - "row_count": 10 - } - ], - "start_time": 1783521472, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 311.306125, - "row_count": 10 - }, - { - "elapsed": 311.491875, - "row_count": 10 - }, - { - "elapsed": 284.06395899999995, - "row_count": 10 - } - ], - "start_time": 1783521473, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 771.392083, - "row_count": 10 - }, - { - "elapsed": 768.158416, - "row_count": 10 - }, - { - "elapsed": 834.558625, - "row_count": 10 - } - ], - "start_time": 1783521474, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 745.640292, - "row_count": 10 - }, - { - "elapsed": 756.891125, - "row_count": 10 - }, - { - "elapsed": 735.1555, - "row_count": 10 - } - ], - "start_time": 1783521476, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 1530.485292, - "row_count": 10 - }, - { - "elapsed": 1602.7038340000001, - "row_count": 10 - }, - { - "elapsed": 1597.295125, - "row_count": 10 - } - ], - "start_time": 1783521478, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 30.804917, - "row_count": 4 - }, - { - "elapsed": 43.208917, - "row_count": 4 - }, - { - "elapsed": 24.928333000000002, - "row_count": 4 - } - ], - "start_time": 1783521483, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 674.840833, - "row_count": 1 - }, - { - "elapsed": 629.004125, - "row_count": 1 - }, - { - "elapsed": 668.372417, - "row_count": 1 - } - ], - "start_time": 1783521483, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 688.529, - "row_count": 10 - }, - { - "elapsed": 687.582541, - "row_count": 10 - }, - { - "elapsed": 661.881375, - "row_count": 10 - } - ], - "start_time": 1783521485, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 1327.140708, - "row_count": 10 - }, - { - "elapsed": 1204.883666, - "row_count": 10 - }, - { - "elapsed": 1248.022709, - "row_count": 10 - } - ], - "start_time": 1783521487, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 4146.086334, - "row_count": 10 - }, - { - "elapsed": 4009.261917, - "row_count": 10 - }, - { - "elapsed": 3679.446584, - "row_count": 10 - } - ], - "start_time": 1783521491, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 45.77425, - "row_count": 10 - }, - { - "elapsed": 43.795666, - "row_count": 10 - }, - { - "elapsed": 46.308875, - "row_count": 10 - } - ], - "start_time": 1783521503, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 126.654875, - "row_count": 10 - }, - { - "elapsed": 127.692917, - "row_count": 10 - }, - { - "elapsed": 129.76, - "row_count": 10 - } - ], - "start_time": 1783521503, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 44.640083, - "row_count": 10 - }, - { - "elapsed": 49.238791, - "row_count": 10 - }, - { - "elapsed": 42.876042000000005, - "row_count": 10 - } - ], - "start_time": 1783521503, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 804.443375, - "row_count": 25 - }, - { - "elapsed": 864.3981670000001, - "row_count": 25 - }, - { - "elapsed": 861.303333, - "row_count": 25 - } - ], - "start_time": 1783521504, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 2986.4698750000002, - "row_count": 25 - }, - { - "elapsed": 2969.160083, - "row_count": 25 - }, - { - "elapsed": 2944.488125, - "row_count": 25 - } - ], - "start_time": 1783521506, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 41.269292, - "row_count": 1 - }, - { - "elapsed": 38.260417, - "row_count": 1 - }, - { - "elapsed": 36.20375, - "row_count": 1 - } - ], - "start_time": 1783521515, - "success": true - }, - { - "query": "Query 30", - "iterations": [ - { - "elapsed": 322.893583, - "row_count": 10 - }, - { - "elapsed": 315.17212500000005, - "row_count": 10 - }, - { - "elapsed": 326.89708299999995, - "row_count": 10 - } - ], - "start_time": 1783521515, - "success": true - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 348.918333, - "row_count": 10 - }, - { - "elapsed": 350.475375, - "row_count": 10 - }, - { - "elapsed": 332.85362499999997, - "row_count": 10 - } - ], - "start_time": 1783521516, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 2308.651792, - "row_count": 10 - }, - { - "elapsed": 1625.227333, - "row_count": 10 - }, - { - "elapsed": 1441.425709, - "row_count": 10 - } - ], - "start_time": 1783521517, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 2037.6407909999998, - "row_count": 10 - }, - { - "elapsed": 1997.130834, - "row_count": 10 - }, - { - "elapsed": 1937.249667, - "row_count": 10 - } - ], - "start_time": 1783521522, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 1836.23325, - "row_count": 10 - }, - { - "elapsed": 1765.4417919999999, - "row_count": 10 - }, - { - "elapsed": 2076.349208, - "row_count": 10 - } - ], - "start_time": 1783521528, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 309.540292, - "row_count": 10 - }, - { - "elapsed": 305.360125, - "row_count": 10 - }, - { - "elapsed": 345.27058300000004, - "row_count": 10 - } - ], - "start_time": 1783521534, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 59.661667, - "row_count": 10 - }, - { - "elapsed": 52.024375, - "row_count": 10 - }, - { - "elapsed": 52.012375, - "row_count": 10 - } - ], - "start_time": 1783521535, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 31.444209, - "row_count": 10 - }, - { - "elapsed": 30.575917, - "row_count": 10 - }, - { - "elapsed": 31.308999999999997, - "row_count": 10 - } - ], - "start_time": 1783521535, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 37.526583, - "row_count": 10 - }, - { - "elapsed": 36.711208, - "row_count": 10 - }, - { - "elapsed": 36.387, - "row_count": 10 - } - ], - "start_time": 1783521535, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 100.166417, - "row_count": 10 - }, - { - "elapsed": 96.452792, - "row_count": 10 - }, - { - "elapsed": 93.71625, - "row_count": 10 - } - ], - "start_time": 1783521535, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 9.978834, - "row_count": 10 - }, - { - "elapsed": 8.435625, - "row_count": 10 - }, - { - "elapsed": 8.873334, - "row_count": 10 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 12.264958, - "row_count": 10 - }, - { - "elapsed": 8.6085, - "row_count": 10 - }, - { - "elapsed": 8.641542000000001, - "row_count": 10 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 8.010417, - "row_count": 10 - }, - { - "elapsed": 6.773000000000001, - "row_count": 10 - }, - { - "elapsed": 6.683583, - "row_count": 10 - } - ], - "start_time": 1783521536, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521465, - "arguments": [ - "clickbench", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", - "--queries-path", - "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/clickbench_off_r2.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/clickbench_on_r1.json b/ab_results/clickbench_on_r1.json deleted file mode 100644 index 13f0f2afc0506..0000000000000 --- a/ab_results/clickbench_on_r1.json +++ /dev/null @@ -1,838 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521393, - "arguments": [ - "clickbench", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", - "--queries-path", - "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/clickbench_on_r1.json" - ] - }, - "queries": [ - { - "query": "Query 0", - "iterations": [ - { - "elapsed": 8.096375, - "row_count": 1 - }, - { - "elapsed": 0.94425, - "row_count": 1 - }, - { - "elapsed": 0.692833, - "row_count": 1 - } - ], - "start_time": 1783521393, - "success": true - }, - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 14.858125, - "row_count": 1 - }, - { - "elapsed": 13.381625, - "row_count": 1 - }, - { - "elapsed": 11.821750000000002, - "row_count": 1 - } - ], - "start_time": 1783521393, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 45.389832999999996, - "row_count": 1 - }, - { - "elapsed": 42.562542, - "row_count": 1 - }, - { - "elapsed": 44.568916, - "row_count": 1 - } - ], - "start_time": 1783521393, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 62.50304199999999, - "row_count": 1 - }, - { - "elapsed": 42.210417, - "row_count": 1 - }, - { - "elapsed": 59.671833, - "row_count": 1 - } - ], - "start_time": 1783521393, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 352.002625, - "row_count": 1 - }, - { - "elapsed": 310.031292, - "row_count": 1 - }, - { - "elapsed": 303.825625, - "row_count": 1 - } - ], - "start_time": 1783521393, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 349.74158300000005, - "row_count": 1 - }, - { - "elapsed": 355.444791, - "row_count": 1 - }, - { - "elapsed": 363.875583, - "row_count": 1 - } - ], - "start_time": 1783521394, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 1.1741659999999998, - "row_count": 1 - }, - { - "elapsed": 0.827292, - "row_count": 1 - }, - { - "elapsed": 0.7476670000000001, - "row_count": 1 - } - ], - "start_time": 1783521395, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 17.519833, - "row_count": 18 - }, - { - "elapsed": 11.557375, - "row_count": 18 - }, - { - "elapsed": 12.088375000000001, - "row_count": 18 - } - ], - "start_time": 1783521395, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 388.138083, - "row_count": 10 - }, - { - "elapsed": 366.532709, - "row_count": 10 - }, - { - "elapsed": 383.436, - "row_count": 10 - } - ], - "start_time": 1783521395, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 477.423792, - "row_count": 10 - }, - { - "elapsed": 483.522834, - "row_count": 10 - }, - { - "elapsed": 467.36516700000004, - "row_count": 10 - } - ], - "start_time": 1783521396, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 69.372875, - "row_count": 10 - }, - { - "elapsed": 81.57725, - "row_count": 10 - }, - { - "elapsed": 77.326917, - "row_count": 10 - } - ], - "start_time": 1783521398, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 92.93254200000001, - "row_count": 10 - }, - { - "elapsed": 99.365958, - "row_count": 10 - }, - { - "elapsed": 88.337792, - "row_count": 10 - } - ], - "start_time": 1783521398, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 337.515375, - "row_count": 10 - }, - { - "elapsed": 362.82595899999995, - "row_count": 10 - }, - { - "elapsed": 337.64437499999997, - "row_count": 10 - } - ], - "start_time": 1783521398, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 621.530417, - "row_count": 10 - }, - { - "elapsed": 528.0484170000001, - "row_count": 10 - }, - { - "elapsed": 612.0186659999999, - "row_count": 10 - } - ], - "start_time": 1783521399, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 454.731542, - "row_count": 10 - }, - { - "elapsed": 361.203916, - "row_count": 10 - }, - { - "elapsed": 341.617375, - "row_count": 10 - } - ], - "start_time": 1783521401, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 332.865291, - "row_count": 10 - }, - { - "elapsed": 297.699541, - "row_count": 10 - }, - { - "elapsed": 288.36454200000003, - "row_count": 10 - } - ], - "start_time": 1783521402, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 759.308416, - "row_count": 10 - }, - { - "elapsed": 744.088166, - "row_count": 10 - }, - { - "elapsed": 758.176375, - "row_count": 10 - } - ], - "start_time": 1783521403, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 790.697833, - "row_count": 10 - }, - { - "elapsed": 814.461875, - "row_count": 10 - }, - { - "elapsed": 849.444792, - "row_count": 10 - } - ], - "start_time": 1783521405, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 2203.440209, - "row_count": 10 - }, - { - "elapsed": 1858.3045419999999, - "row_count": 10 - }, - { - "elapsed": 1456.971292, - "row_count": 10 - } - ], - "start_time": 1783521408, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 27.467583, - "row_count": 4 - }, - { - "elapsed": 28.034582999999998, - "row_count": 4 - }, - { - "elapsed": 26.727083, - "row_count": 4 - } - ], - "start_time": 1783521413, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 641.5, - "row_count": 1 - }, - { - "elapsed": 677.097042, - "row_count": 1 - }, - { - "elapsed": 693.2620000000001, - "row_count": 1 - } - ], - "start_time": 1783521413, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 845.369792, - "row_count": 10 - }, - { - "elapsed": 784.214666, - "row_count": 10 - }, - { - "elapsed": 757.29225, - "row_count": 10 - } - ], - "start_time": 1783521415, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 1522.309625, - "row_count": 10 - }, - { - "elapsed": 1412.0735, - "row_count": 10 - }, - { - "elapsed": 1426.077375, - "row_count": 10 - } - ], - "start_time": 1783521418, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 4141.845832999999, - "row_count": 10 - }, - { - "elapsed": 4124.703084, - "row_count": 10 - }, - { - "elapsed": 4048.6242920000004, - "row_count": 10 - } - ], - "start_time": 1783521422, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 47.3905, - "row_count": 10 - }, - { - "elapsed": 46.100541, - "row_count": 10 - }, - { - "elapsed": 47.743708000000005, - "row_count": 10 - } - ], - "start_time": 1783521435, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 140.448042, - "row_count": 10 - }, - { - "elapsed": 140.06004099999998, - "row_count": 10 - }, - { - "elapsed": 137.859792, - "row_count": 10 - } - ], - "start_time": 1783521435, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 43.605084000000005, - "row_count": 10 - }, - { - "elapsed": 54.127542, - "row_count": 10 - }, - { - "elapsed": 42.751459, - "row_count": 10 - } - ], - "start_time": 1783521435, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 917.45275, - "row_count": 25 - }, - { - "elapsed": 869.396791, - "row_count": 25 - }, - { - "elapsed": 856.466166, - "row_count": 25 - } - ], - "start_time": 1783521435, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 2903.5979159999997, - "row_count": 25 - }, - { - "elapsed": 2721.127458, - "row_count": 25 - }, - { - "elapsed": 2707.90175, - "row_count": 25 - } - ], - "start_time": 1783521438, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 38.071166, - "row_count": 1 - }, - { - "elapsed": 37.105542, - "row_count": 1 - }, - { - "elapsed": 46.108834, - "row_count": 1 - } - ], - "start_time": 1783521446, - "success": true - }, - { - "query": "Query 30", - "iterations": [ - { - "elapsed": 301.48225, - "row_count": 10 - }, - { - "elapsed": 299.395083, - "row_count": 10 - }, - { - "elapsed": 328.64887500000003, - "row_count": 10 - } - ], - "start_time": 1783521446, - "success": true - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 316.49725, - "row_count": 10 - }, - { - "elapsed": 307.586334, - "row_count": 10 - }, - { - "elapsed": 317.047041, - "row_count": 10 - } - ], - "start_time": 1783521447, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 2088.244, - "row_count": 10 - }, - { - "elapsed": 1202.19525, - "row_count": 10 - }, - { - "elapsed": 1169.632459, - "row_count": 10 - } - ], - "start_time": 1783521448, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 1887.4482079999998, - "row_count": 10 - }, - { - "elapsed": 1680.2657920000001, - "row_count": 10 - }, - { - "elapsed": 1611.361, - "row_count": 10 - } - ], - "start_time": 1783521453, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 1791.6960419999998, - "row_count": 10 - }, - { - "elapsed": 1692.4321249999998, - "row_count": 10 - }, - { - "elapsed": 1700.8285, - "row_count": 10 - } - ], - "start_time": 1783521458, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 310.654417, - "row_count": 10 - }, - { - "elapsed": 315.000084, - "row_count": 10 - }, - { - "elapsed": 266.73658300000005, - "row_count": 10 - } - ], - "start_time": 1783521463, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 82.258459, - "row_count": 10 - }, - { - "elapsed": 56.130291, - "row_count": 10 - }, - { - "elapsed": 55.778957999999996, - "row_count": 10 - } - ], - "start_time": 1783521464, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 27.695541000000002, - "row_count": 10 - }, - { - "elapsed": 26.696, - "row_count": 10 - }, - { - "elapsed": 29.5845, - "row_count": 10 - } - ], - "start_time": 1783521464, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 32.694624999999995, - "row_count": 10 - }, - { - "elapsed": 32.609375, - "row_count": 10 - }, - { - "elapsed": 32.107125, - "row_count": 10 - } - ], - "start_time": 1783521464, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 99.275042, - "row_count": 10 - }, - { - "elapsed": 96.879916, - "row_count": 10 - }, - { - "elapsed": 95.24354100000001, - "row_count": 10 - } - ], - "start_time": 1783521464, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 9.93125, - "row_count": 10 - }, - { - "elapsed": 8.338999999999999, - "row_count": 10 - }, - { - "elapsed": 8.761083, - "row_count": 10 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 9.358917, - "row_count": 10 - }, - { - "elapsed": 8.283541999999999, - "row_count": 10 - }, - { - "elapsed": 8.797374999999999, - "row_count": 10 - } - ], - "start_time": 1783521465, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 7.46475, - "row_count": 10 - }, - { - "elapsed": 6.543292, - "row_count": 10 - }, - { - "elapsed": 6.658583, - "row_count": 10 - } - ], - "start_time": 1783521465, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/clickbench_on_r2.json b/ab_results/clickbench_on_r2.json deleted file mode 100644 index c27668b9823af..0000000000000 --- a/ab_results/clickbench_on_r2.json +++ /dev/null @@ -1,838 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521536, - "arguments": [ - "clickbench", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/hits_partitioned", - "--queries-path", - "/Users/adrian/GitHub/datafusion/benchmarks/queries/clickbench/queries", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/clickbench_on_r2.json" - ] - }, - "queries": [ - { - "query": "Query 0", - "iterations": [ - { - "elapsed": 7.7271659999999995, - "row_count": 1 - }, - { - "elapsed": 0.890208, - "row_count": 1 - }, - { - "elapsed": 0.682708, - "row_count": 1 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 10.941374999999999, - "row_count": 1 - }, - { - "elapsed": 9.917709, - "row_count": 1 - }, - { - "elapsed": 9.989916999999998, - "row_count": 1 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 37.082042, - "row_count": 1 - }, - { - "elapsed": 40.037125, - "row_count": 1 - }, - { - "elapsed": 37.955000000000005, - "row_count": 1 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 47.134333, - "row_count": 1 - }, - { - "elapsed": 37.871125, - "row_count": 1 - }, - { - "elapsed": 33.410834, - "row_count": 1 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 245.83775, - "row_count": 1 - }, - { - "elapsed": 243.700667, - "row_count": 1 - }, - { - "elapsed": 255.754, - "row_count": 1 - } - ], - "start_time": 1783521536, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 370.58970899999997, - "row_count": 1 - }, - { - "elapsed": 397.89420800000005, - "row_count": 1 - }, - { - "elapsed": 422.11825, - "row_count": 1 - } - ], - "start_time": 1783521537, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 1.5801669999999999, - "row_count": 1 - }, - { - "elapsed": 1.452334, - "row_count": 1 - }, - { - "elapsed": 1.276583, - "row_count": 1 - } - ], - "start_time": 1783521538, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 17.379915999999998, - "row_count": 18 - }, - { - "elapsed": 15.438542, - "row_count": 18 - }, - { - "elapsed": 16.311166, - "row_count": 18 - } - ], - "start_time": 1783521538, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 490.116292, - "row_count": 10 - }, - { - "elapsed": 400.770167, - "row_count": 10 - }, - { - "elapsed": 403.71525, - "row_count": 10 - } - ], - "start_time": 1783521538, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 590.7842079999999, - "row_count": 10 - }, - { - "elapsed": 520.600958, - "row_count": 10 - }, - { - "elapsed": 507.06370899999996, - "row_count": 10 - } - ], - "start_time": 1783521540, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 76.241791, - "row_count": 10 - }, - { - "elapsed": 80.495833, - "row_count": 10 - }, - { - "elapsed": 72.38787500000001, - "row_count": 10 - } - ], - "start_time": 1783521541, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 92.851583, - "row_count": 10 - }, - { - "elapsed": 87.317375, - "row_count": 10 - }, - { - "elapsed": 88.511042, - "row_count": 10 - } - ], - "start_time": 1783521542, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 356.400125, - "row_count": 10 - }, - { - "elapsed": 345.653667, - "row_count": 10 - }, - { - "elapsed": 423.479041, - "row_count": 10 - } - ], - "start_time": 1783521542, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 572.4365, - "row_count": 10 - }, - { - "elapsed": 518.094167, - "row_count": 10 - }, - { - "elapsed": 512.337375, - "row_count": 10 - } - ], - "start_time": 1783521543, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 378.043666, - "row_count": 10 - }, - { - "elapsed": 393.452625, - "row_count": 10 - }, - { - "elapsed": 392.532375, - "row_count": 10 - } - ], - "start_time": 1783521545, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 324.45691700000003, - "row_count": 10 - }, - { - "elapsed": 328.474458, - "row_count": 10 - }, - { - "elapsed": 332.248042, - "row_count": 10 - } - ], - "start_time": 1783521546, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 814.551, - "row_count": 10 - }, - { - "elapsed": 828.122833, - "row_count": 10 - }, - { - "elapsed": 859.751709, - "row_count": 10 - } - ], - "start_time": 1783521547, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 841.892291, - "row_count": 10 - }, - { - "elapsed": 811.304542, - "row_count": 10 - }, - { - "elapsed": 899.85575, - "row_count": 10 - } - ], - "start_time": 1783521549, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 1890.0516249999998, - "row_count": 10 - }, - { - "elapsed": 1911.086542, - "row_count": 10 - }, - { - "elapsed": 1922.562041, - "row_count": 10 - } - ], - "start_time": 1783521552, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 44.253042, - "row_count": 4 - }, - { - "elapsed": 32.382417, - "row_count": 4 - }, - { - "elapsed": 32.492708, - "row_count": 4 - } - ], - "start_time": 1783521557, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 874.6324159999999, - "row_count": 1 - }, - { - "elapsed": 981.603333, - "row_count": 1 - }, - { - "elapsed": 1017.9544579999999, - "row_count": 1 - } - ], - "start_time": 1783521558, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 1183.999708, - "row_count": 10 - }, - { - "elapsed": 1167.995291, - "row_count": 10 - }, - { - "elapsed": 1038.130375, - "row_count": 10 - } - ], - "start_time": 1783521560, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 2049.604833, - "row_count": 10 - }, - { - "elapsed": 2107.563958, - "row_count": 10 - }, - { - "elapsed": 1906.824583, - "row_count": 10 - } - ], - "start_time": 1783521564, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 4998.53525, - "row_count": 10 - }, - { - "elapsed": 4691.800291, - "row_count": 10 - }, - { - "elapsed": 4749.423957999999, - "row_count": 10 - } - ], - "start_time": 1783521570, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 61.212917, - "row_count": 10 - }, - { - "elapsed": 59.338875, - "row_count": 10 - }, - { - "elapsed": 63.560875, - "row_count": 10 - } - ], - "start_time": 1783521584, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 172.10875000000001, - "row_count": 10 - }, - { - "elapsed": 176.716375, - "row_count": 10 - }, - { - "elapsed": 177.591292, - "row_count": 10 - } - ], - "start_time": 1783521585, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 55.916875, - "row_count": 10 - }, - { - "elapsed": 55.573042, - "row_count": 10 - }, - { - "elapsed": 54.534542, - "row_count": 10 - } - ], - "start_time": 1783521585, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 993.148791, - "row_count": 25 - }, - { - "elapsed": 1055.534958, - "row_count": 25 - }, - { - "elapsed": 968.1970829999999, - "row_count": 25 - } - ], - "start_time": 1783521585, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 3575.6857919999998, - "row_count": 25 - }, - { - "elapsed": 3460.662167, - "row_count": 25 - }, - { - "elapsed": 3536.231334, - "row_count": 25 - } - ], - "start_time": 1783521588, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 47.976958, - "row_count": 1 - }, - { - "elapsed": 42.861042000000005, - "row_count": 1 - }, - { - "elapsed": 42.264458, - "row_count": 1 - } - ], - "start_time": 1783521599, - "success": true - }, - { - "query": "Query 30", - "iterations": [ - { - "elapsed": 366.384042, - "row_count": 10 - }, - { - "elapsed": 351.894625, - "row_count": 10 - }, - { - "elapsed": 383.0905, - "row_count": 10 - } - ], - "start_time": 1783521599, - "success": true - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 414.461166, - "row_count": 10 - }, - { - "elapsed": 399.739167, - "row_count": 10 - }, - { - "elapsed": 369.898291, - "row_count": 10 - } - ], - "start_time": 1783521600, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 2395.095042, - "row_count": 10 - }, - { - "elapsed": 1565.577792, - "row_count": 10 - }, - { - "elapsed": 1383.35575, - "row_count": 10 - } - ], - "start_time": 1783521601, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 2285.5898749999997, - "row_count": 10 - }, - { - "elapsed": 2458.74575, - "row_count": 10 - }, - { - "elapsed": 2379.687417, - "row_count": 10 - } - ], - "start_time": 1783521607, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 2026.4257080000002, - "row_count": 10 - }, - { - "elapsed": 1868.836958, - "row_count": 10 - }, - { - "elapsed": 1863.3367079999998, - "row_count": 10 - } - ], - "start_time": 1783521614, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 324.86825000000005, - "row_count": 10 - }, - { - "elapsed": 318.33745899999997, - "row_count": 10 - }, - { - "elapsed": 289.563958, - "row_count": 10 - } - ], - "start_time": 1783521619, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 97.395709, - "row_count": 10 - }, - { - "elapsed": 63.84904099999999, - "row_count": 10 - }, - { - "elapsed": 68.3085, - "row_count": 10 - } - ], - "start_time": 1783521620, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 34.882333, - "row_count": 10 - }, - { - "elapsed": 33.785999999999994, - "row_count": 10 - }, - { - "elapsed": 31.000916, - "row_count": 10 - } - ], - "start_time": 1783521621, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 39.689167, - "row_count": 10 - }, - { - "elapsed": 45.04675, - "row_count": 10 - }, - { - "elapsed": 40.615458, - "row_count": 10 - } - ], - "start_time": 1783521621, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 111.420625, - "row_count": 10 - }, - { - "elapsed": 108.99291699999999, - "row_count": 10 - }, - { - "elapsed": 103.476666, - "row_count": 10 - } - ], - "start_time": 1783521621, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 10.558125, - "row_count": 10 - }, - { - "elapsed": 8.8675, - "row_count": 10 - }, - { - "elapsed": 9.246583, - "row_count": 10 - } - ], - "start_time": 1783521621, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 10.026917, - "row_count": 10 - }, - { - "elapsed": 9.57375, - "row_count": 10 - }, - { - "elapsed": 8.824167000000001, - "row_count": 10 - } - ], - "start_time": 1783521621, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 7.4770840000000005, - "row_count": 10 - }, - { - "elapsed": 6.956792, - "row_count": 10 - }, - { - "elapsed": 6.8532910000000005, - "row_count": 10 - } - ], - "start_time": 1783521621, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/lv-mem2g_off_r1.json b/ab_results/lv-mem2g_off_r1.json deleted file mode 100644 index e8146fb448d14..0000000000000 --- a/ab_results/lv-mem2g_off_r1.json +++ /dev/null @@ -1,78 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524304, - "arguments": [ - "large-values", - "--iterations", - "2", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "--memory-limit", - "2G", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_off_r1.json" - ] - }, - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 197.6835, - "row_count": 1 - }, - { - "elapsed": 154.469209, - "row_count": 1 - } - ], - "start_time": 1783524304, - "success": true - }, - { - "query": "2", - "iterations": [], - "start_time": 1783524304, - "success": false - }, - { - "query": "3", - "iterations": [], - "start_time": 1783524304, - "success": false - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 164.730625, - "row_count": 1000 - }, - { - "elapsed": 178.782333, - "row_count": 1000 - } - ], - "start_time": 1783524304, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 344.02358300000003, - "row_count": 1 - }, - { - "elapsed": 307.50525, - "row_count": 1 - } - ], - "start_time": 1783524305, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/lv-mem2g_off_r2.json b/ab_results/lv-mem2g_off_r2.json deleted file mode 100644 index 6aa6cc9b9cf5f..0000000000000 --- a/ab_results/lv-mem2g_off_r2.json +++ /dev/null @@ -1,78 +0,0 @@ -{ - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 197.077458, - "row_count": 1 - }, - { - "elapsed": 169.666708, - "row_count": 1 - } - ], - "start_time": 1783524308, - "success": true - }, - { - "query": "2", - "iterations": [], - "start_time": 1783524308, - "success": false - }, - { - "query": "3", - "iterations": [], - "start_time": 1783524309, - "success": false - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 185.57637499999998, - "row_count": 1000 - }, - { - "elapsed": 166.465875, - "row_count": 1000 - } - ], - "start_time": 1783524309, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 313.966125, - "row_count": 1 - }, - { - "elapsed": 315.49224999999996, - "row_count": 1 - } - ], - "start_time": 1783524309, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524308, - "arguments": [ - "large-values", - "--iterations", - "2", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "--memory-limit", - "2G", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_off_r2.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/lv-mem2g_on_r1.json b/ab_results/lv-mem2g_on_r1.json deleted file mode 100644 index 9c488e8f32e15..0000000000000 --- a/ab_results/lv-mem2g_on_r1.json +++ /dev/null @@ -1,78 +0,0 @@ -{ - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 204.47537499999999, - "row_count": 1 - }, - { - "elapsed": 162.65116700000002, - "row_count": 1 - } - ], - "start_time": 1783524305, - "success": true - }, - { - "query": "2", - "iterations": [], - "start_time": 1783524306, - "success": false - }, - { - "query": "3", - "iterations": [], - "start_time": 1783524306, - "success": false - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 219.99279199999998, - "row_count": 1000 - }, - { - "elapsed": 216.437584, - "row_count": 1000 - } - ], - "start_time": 1783524307, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 348.959166, - "row_count": 1 - }, - { - "elapsed": 422.631667, - "row_count": 1 - } - ], - "start_time": 1783524307, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524305, - "arguments": [ - "large-values", - "--iterations", - "2", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "--memory-limit", - "2G", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_on_r1.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/lv-mem2g_on_r2.json b/ab_results/lv-mem2g_on_r2.json deleted file mode 100644 index 3b06e8b332fe0..0000000000000 --- a/ab_results/lv-mem2g_on_r2.json +++ /dev/null @@ -1,78 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524310, - "arguments": [ - "large-values", - "--iterations", - "2", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "--memory-limit", - "2G", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-mem2g_on_r2.json" - ] - }, - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 198.926, - "row_count": 1 - }, - { - "elapsed": 160.64475000000002, - "row_count": 1 - } - ], - "start_time": 1783524310, - "success": true - }, - { - "query": "2", - "iterations": [], - "start_time": 1783524310, - "success": false - }, - { - "query": "3", - "iterations": [], - "start_time": 1783524311, - "success": false - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 186.612583, - "row_count": 1000 - }, - { - "elapsed": 190.321584, - "row_count": 1000 - } - ], - "start_time": 1783524312, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 354.584417, - "row_count": 1 - }, - { - "elapsed": 344.833791, - "row_count": 1 - } - ], - "start_time": 1783524312, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/lv-unlimited_off_r1.json b/ab_results/lv-unlimited_off_r1.json deleted file mode 100644 index 5ad67554bb321..0000000000000 --- a/ab_results/lv-unlimited_off_r1.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524290, - "arguments": [ - "large-values", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_off_r1.json" - ] - }, - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 336.059208, - "row_count": 1 - }, - { - "elapsed": 214.84883299999998, - "row_count": 1 - }, - { - "elapsed": 196.46845900000002, - "row_count": 1 - } - ], - "start_time": 1783524290, - "success": true - }, - { - "query": "2", - "iterations": [ - { - "elapsed": 177.329917, - "row_count": 65536 - }, - { - "elapsed": 195.192375, - "row_count": 65536 - }, - { - "elapsed": 220.90258300000002, - "row_count": 65536 - } - ], - "start_time": 1783524291, - "success": true - }, - { - "query": "3", - "iterations": [ - { - "elapsed": 257.799042, - "row_count": 65536 - }, - { - "elapsed": 223.499583, - "row_count": 65536 - }, - { - "elapsed": 213.221041, - "row_count": 65536 - } - ], - "start_time": 1783524291, - "success": true - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 193.086125, - "row_count": 1000 - }, - { - "elapsed": 181.814208, - "row_count": 1000 - }, - { - "elapsed": 157.193375, - "row_count": 1000 - } - ], - "start_time": 1783524292, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 319.102958, - "row_count": 1 - }, - { - "elapsed": 300.663708, - "row_count": 1 - }, - { - "elapsed": 313.03641700000003, - "row_count": 1 - } - ], - "start_time": 1783524293, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/lv-unlimited_off_r2.json b/ab_results/lv-unlimited_off_r2.json deleted file mode 100644 index e33a629f613f5..0000000000000 --- a/ab_results/lv-unlimited_off_r2.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 187.636208, - "row_count": 1 - }, - { - "elapsed": 156.58808299999998, - "row_count": 1 - }, - { - "elapsed": 148.589958, - "row_count": 1 - } - ], - "start_time": 1783524297, - "success": true - }, - { - "query": "2", - "iterations": [ - { - "elapsed": 148.896334, - "row_count": 65536 - }, - { - "elapsed": 147.302166, - "row_count": 65536 - }, - { - "elapsed": 147.625292, - "row_count": 65536 - } - ], - "start_time": 1783524298, - "success": true - }, - { - "query": "3", - "iterations": [ - { - "elapsed": 220.70004200000002, - "row_count": 65536 - }, - { - "elapsed": 209.40620900000002, - "row_count": 65536 - }, - { - "elapsed": 214.033583, - "row_count": 65536 - } - ], - "start_time": 1783524298, - "success": true - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 157.743708, - "row_count": 1000 - }, - { - "elapsed": 155.584333, - "row_count": 1000 - }, - { - "elapsed": 170.668709, - "row_count": 1000 - } - ], - "start_time": 1783524299, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 307.706375, - "row_count": 1 - }, - { - "elapsed": 308.719666, - "row_count": 1 - }, - { - "elapsed": 300.23645799999997, - "row_count": 1 - } - ], - "start_time": 1783524299, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524297, - "arguments": [ - "large-values", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_off_r2.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/lv-unlimited_on_r1.json b/ab_results/lv-unlimited_on_r1.json deleted file mode 100644 index fbd025f42ce1f..0000000000000 --- a/ab_results/lv-unlimited_on_r1.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 190.306583, - "row_count": 1 - }, - { - "elapsed": 167.66412499999998, - "row_count": 1 - }, - { - "elapsed": 165.759125, - "row_count": 1 - } - ], - "start_time": 1783524294, - "success": true - }, - { - "query": "2", - "iterations": [ - { - "elapsed": 172.79541700000001, - "row_count": 65536 - }, - { - "elapsed": 176.481875, - "row_count": 65536 - }, - { - "elapsed": 187.072083, - "row_count": 65536 - } - ], - "start_time": 1783524294, - "success": true - }, - { - "query": "3", - "iterations": [ - { - "elapsed": 330.78745799999996, - "row_count": 65536 - }, - { - "elapsed": 370.869583, - "row_count": 65536 - }, - { - "elapsed": 222.142125, - "row_count": 65536 - } - ], - "start_time": 1783524295, - "success": true - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 184.431041, - "row_count": 1000 - }, - { - "elapsed": 175.750666, - "row_count": 1000 - }, - { - "elapsed": 190.266458, - "row_count": 1000 - } - ], - "start_time": 1783524296, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 331.404709, - "row_count": 1 - }, - { - "elapsed": 328.953125, - "row_count": 1 - }, - { - "elapsed": 324.06679199999996, - "row_count": 1 - } - ], - "start_time": 1783524296, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524294, - "arguments": [ - "large-values", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_on_r1.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/lv-unlimited_on_r2.json b/ab_results/lv-unlimited_on_r2.json deleted file mode 100644 index a261be2082119..0000000000000 --- a/ab_results/lv-unlimited_on_r2.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783524300, - "arguments": [ - "large-values", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/large_values", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/lv-unlimited_on_r2.json" - ] - }, - "queries": [ - { - "query": "1", - "iterations": [ - { - "elapsed": 194.511833, - "row_count": 1 - }, - { - "elapsed": 162.919083, - "row_count": 1 - }, - { - "elapsed": 164.84795799999998, - "row_count": 1 - } - ], - "start_time": 1783524300, - "success": true - }, - { - "query": "2", - "iterations": [ - { - "elapsed": 163.59825, - "row_count": 65536 - }, - { - "elapsed": 169.151333, - "row_count": 65536 - }, - { - "elapsed": 167.220583, - "row_count": 65536 - } - ], - "start_time": 1783524301, - "success": true - }, - { - "query": "3", - "iterations": [ - { - "elapsed": 250.01658300000003, - "row_count": 65536 - }, - { - "elapsed": 217.55041599999998, - "row_count": 65536 - }, - { - "elapsed": 220.9475, - "row_count": 65536 - } - ], - "start_time": 1783524301, - "success": true - }, - { - "query": "4", - "iterations": [ - { - "elapsed": 179.51741700000002, - "row_count": 1000 - }, - { - "elapsed": 173.85179200000002, - "row_count": 1000 - }, - { - "elapsed": 186.247083, - "row_count": 1000 - } - ], - "start_time": 1783524302, - "success": true - }, - { - "query": "5", - "iterations": [ - { - "elapsed": 341.749, - "row_count": 1 - }, - { - "elapsed": 338.359333, - "row_count": 1 - }, - { - "elapsed": 322.20941600000003, - "row_count": 1 - } - ], - "start_time": 1783524303, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/tpcds_off_r1.json b/ab_results/tpcds_off_r1.json deleted file mode 100644 index 27d2645b15bd0..0000000000000 --- a/ab_results/tpcds_off_r1.json +++ /dev/null @@ -1,1891 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521622, - "arguments": [ - "tpcds", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", - "--query_path", - "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", - "--prefer_hash_join", - "true", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpcds_off_r1.json" - ] - }, - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 5.6685, - "row_count": 0 - }, - { - "elapsed": 3.86675, - "row_count": 0 - }, - { - "elapsed": 3.765959, - "row_count": 0 - } - ], - "start_time": 1783521622, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 124.789209, - "row_count": 2513 - }, - { - "elapsed": 101.340792, - "row_count": 2513 - }, - { - "elapsed": 101.1745, - "row_count": 2513 - } - ], - "start_time": 1783521622, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 87.80262499999999, - "row_count": 38 - }, - { - "elapsed": 85.04379200000001, - "row_count": 38 - }, - { - "elapsed": 84.299291, - "row_count": 38 - } - ], - "start_time": 1783521622, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 908.562041, - "row_count": 8 - }, - { - "elapsed": 875.065875, - "row_count": 8 - }, - { - "elapsed": 884.8748330000001, - "row_count": 8 - } - ], - "start_time": 1783521622, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 127.45124999999999, - "row_count": 100 - }, - { - "elapsed": 123.379416, - "row_count": 100 - }, - { - "elapsed": 122.5365, - "row_count": 100 - } - ], - "start_time": 1783521625, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 88.404833, - "row_count": 41 - }, - { - "elapsed": 85.765083, - "row_count": 41 - }, - { - "elapsed": 86.851625, - "row_count": 41 - } - ], - "start_time": 1783521625, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 229.36124999999998, - "row_count": 100 - }, - { - "elapsed": 220.675917, - "row_count": 100 - }, - { - "elapsed": 223.269292, - "row_count": 100 - } - ], - "start_time": 1783521625, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 80.993416, - "row_count": 0 - }, - { - "elapsed": 80.994125, - "row_count": 0 - }, - { - "elapsed": 80.76445799999999, - "row_count": 0 - } - ], - "start_time": 1783521626, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 89.646667, - "row_count": 1 - }, - { - "elapsed": 82.75637499999999, - "row_count": 1 - }, - { - "elapsed": 85.239083, - "row_count": 1 - } - ], - "start_time": 1783521626, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 86.429083, - "row_count": 2 - }, - { - "elapsed": 85.09004200000001, - "row_count": 2 - }, - { - "elapsed": 85.284292, - "row_count": 2 - } - ], - "start_time": 1783521627, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 592.771375, - "row_count": 88 - }, - { - "elapsed": 580.994833, - "row_count": 88 - }, - { - "elapsed": 605.234375, - "row_count": 88 - } - ], - "start_time": 1783521627, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 32.174542, - "row_count": 100 - }, - { - "elapsed": 30.879417, - "row_count": 100 - }, - { - "elapsed": 30.511, - "row_count": 100 - } - ], - "start_time": 1783521629, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 277.064667, - "row_count": 1 - }, - { - "elapsed": 280.09279100000003, - "row_count": 1 - }, - { - "elapsed": 279.674667, - "row_count": 1 - } - ], - "start_time": 1783521629, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 771.40925, - "row_count": 100 - }, - { - "elapsed": 768.7402089999999, - "row_count": 100 - }, - { - "elapsed": 787.023917, - "row_count": 100 - } - ], - "start_time": 1783521630, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 13.428334, - "row_count": 100 - }, - { - "elapsed": 10.656041, - "row_count": 100 - }, - { - "elapsed": 10.654292, - "row_count": 100 - } - ], - "start_time": 1783521632, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 4.941084, - "row_count": 1 - }, - { - "elapsed": 4.501958, - "row_count": 1 - }, - { - "elapsed": 4.250125000000001, - "row_count": 1 - } - ], - "start_time": 1783521632, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 146.011875, - "row_count": 1 - }, - { - "elapsed": 137.181667, - "row_count": 1 - }, - { - "elapsed": 140.047584, - "row_count": 1 - } - ], - "start_time": 1783521632, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 95.520333, - "row_count": 100 - }, - { - "elapsed": 97.865625, - "row_count": 100 - }, - { - "elapsed": 95.781334, - "row_count": 100 - } - ], - "start_time": 1783521632, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 115.50679199999999, - "row_count": 100 - }, - { - "elapsed": 113.447166, - "row_count": 100 - }, - { - "elapsed": 113.46425, - "row_count": 100 - } - ], - "start_time": 1783521633, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 9.29725, - "row_count": 100 - }, - { - "elapsed": 8.740334, - "row_count": 100 - }, - { - "elapsed": 8.790041, - "row_count": 100 - } - ], - "start_time": 1783521633, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 14.323334000000001, - "row_count": 100 - }, - { - "elapsed": 12.309041, - "row_count": 100 - }, - { - "elapsed": 11.842791, - "row_count": 100 - } - ], - "start_time": 1783521633, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 265.37775000000005, - "row_count": 100 - }, - { - "elapsed": 260.720667, - "row_count": 100 - }, - { - "elapsed": 267.11666699999995, - "row_count": 100 - } - ], - "start_time": 1783521633, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 522.907042, - "row_count": 0 - }, - { - "elapsed": 515.042125, - "row_count": 0 - }, - { - "elapsed": 536.592667, - "row_count": 0 - } - ], - "start_time": 1783521634, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 429.80508299999997, - "row_count": 0 - }, - { - "elapsed": 427.838334, - "row_count": 0 - }, - { - "elapsed": 426.755834, - "row_count": 0 - } - ], - "start_time": 1783521635, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 172.71629099999998, - "row_count": 0 - }, - { - "elapsed": 169.881542, - "row_count": 0 - }, - { - "elapsed": 169.515167, - "row_count": 0 - } - ], - "start_time": 1783521637, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 53.424833, - "row_count": 100 - }, - { - "elapsed": 51.652041000000004, - "row_count": 100 - }, - { - "elapsed": 51.702791, - "row_count": 100 - } - ], - "start_time": 1783521637, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 4.041625, - "row_count": 1 - }, - { - "elapsed": 3.8745, - "row_count": 1 - }, - { - "elapsed": 3.9445419999999998, - "row_count": 1 - } - ], - "start_time": 1783521637, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 103.777834, - "row_count": 1 - }, - { - "elapsed": 103.015042, - "row_count": 1 - }, - { - "elapsed": 102.917042, - "row_count": 1 - } - ], - "start_time": 1783521637, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 167.26637499999998, - "row_count": 0 - }, - { - "elapsed": 162.67516600000002, - "row_count": 0 - }, - { - "elapsed": 164.49525, - "row_count": 0 - } - ], - "start_time": 1783521638, - "success": true - }, - { - "query": "Query 30", - "iterations": [], - "start_time": 1783521638, - "success": false - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 116.10912499999999, - "row_count": 51 - }, - { - "elapsed": 115.56125, - "row_count": 51 - }, - { - "elapsed": 116.014791, - "row_count": 51 - } - ], - "start_time": 1783521638, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 9.402459, - "row_count": 1 - }, - { - "elapsed": 8.707334000000001, - "row_count": 1 - }, - { - "elapsed": 8.429, - "row_count": 1 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 98.9175, - "row_count": 100 - }, - { - "elapsed": 100.517458, - "row_count": 100 - }, - { - "elapsed": 99.80995800000001, - "row_count": 100 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 4.575417, - "row_count": 0 - }, - { - "elapsed": 3.728042, - "row_count": 0 - }, - { - "elapsed": 3.590583, - "row_count": 0 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 99.408208, - "row_count": 100 - }, - { - "elapsed": 96.368333, - "row_count": 100 - }, - { - "elapsed": 95.443208, - "row_count": 100 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 4.7667079999999995, - "row_count": 1 - }, - { - "elapsed": 3.7637080000000003, - "row_count": 1 - }, - { - "elapsed": 3.700791, - "row_count": 1 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 5.617125, - "row_count": 0 - }, - { - "elapsed": 5.234291000000001, - "row_count": 0 - }, - { - "elapsed": 5.481708, - "row_count": 0 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 88.579667, - "row_count": 1 - }, - { - "elapsed": 85.7335, - "row_count": 1 - }, - { - "elapsed": 87.84191700000001, - "row_count": 1 - } - ], - "start_time": 1783521639, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 51.498542, - "row_count": 7 - }, - { - "elapsed": 52.368084, - "row_count": 7 - }, - { - "elapsed": 55.315375, - "row_count": 7 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 72.530916, - "row_count": 100 - }, - { - "elapsed": 65.95979200000001, - "row_count": 100 - }, - { - "elapsed": 64.664875, - "row_count": 100 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 9.051959, - "row_count": 0 - }, - { - "elapsed": 8.516166, - "row_count": 0 - }, - { - "elapsed": 8.3345, - "row_count": 0 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 79.6915, - "row_count": 10 - }, - { - "elapsed": 79.87066700000001, - "row_count": 10 - }, - { - "elapsed": 80.49229199999999, - "row_count": 10 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 43", - "iterations": [ - { - "elapsed": 3.353583, - "row_count": 0 - }, - { - "elapsed": 2.754042, - "row_count": 0 - }, - { - "elapsed": 2.9928749999999997, - "row_count": 0 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 44", - "iterations": [ - { - "elapsed": 4.757584, - "row_count": 0 - }, - { - "elapsed": 4.9139159999999995, - "row_count": 0 - }, - { - "elapsed": 4.83325, - "row_count": 0 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 45", - "iterations": [ - { - "elapsed": 31.174332999999997, - "row_count": 16 - }, - { - "elapsed": 31.23, - "row_count": 16 - }, - { - "elapsed": 31.164708, - "row_count": 16 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 46", - "iterations": [ - { - "elapsed": 4.8115, - "row_count": 0 - }, - { - "elapsed": 4.494625, - "row_count": 0 - }, - { - "elapsed": 4.875584, - "row_count": 0 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 47", - "iterations": [ - { - "elapsed": 431.170458, - "row_count": 100 - }, - { - "elapsed": 433.2035, - "row_count": 100 - }, - { - "elapsed": 436.11641699999996, - "row_count": 100 - } - ], - "start_time": 1783521640, - "success": true - }, - { - "query": "Query 48", - "iterations": [ - { - "elapsed": 199.125583, - "row_count": 1 - }, - { - "elapsed": 195.61575, - "row_count": 1 - }, - { - "elapsed": 196.451667, - "row_count": 1 - } - ], - "start_time": 1783521642, - "success": true - }, - { - "query": "Query 49", - "iterations": [ - { - "elapsed": 169.282792, - "row_count": 31 - }, - { - "elapsed": 167.76025, - "row_count": 31 - }, - { - "elapsed": 168.312209, - "row_count": 31 - } - ], - "start_time": 1783521642, - "success": true - }, - { - "query": "Query 50", - "iterations": [ - { - "elapsed": 125.180708, - "row_count": 6 - }, - { - "elapsed": 119.96225000000001, - "row_count": 6 - }, - { - "elapsed": 119.11820900000001, - "row_count": 6 - } - ], - "start_time": 1783521643, - "success": true - }, - { - "query": "Query 51", - "iterations": [ - { - "elapsed": 116.1545, - "row_count": 100 - }, - { - "elapsed": 114.72995800000001, - "row_count": 100 - }, - { - "elapsed": 115.873334, - "row_count": 100 - } - ], - "start_time": 1783521643, - "success": true - }, - { - "query": "Query 52", - "iterations": [ - { - "elapsed": 80.651875, - "row_count": 100 - }, - { - "elapsed": 79.903875, - "row_count": 100 - }, - { - "elapsed": 80.662583, - "row_count": 100 - } - ], - "start_time": 1783521643, - "success": true - }, - { - "query": "Query 53", - "iterations": [ - { - "elapsed": 77.153375, - "row_count": 14 - }, - { - "elapsed": 74.83120799999999, - "row_count": 14 - }, - { - "elapsed": 75.7425, - "row_count": 14 - } - ], - "start_time": 1783521644, - "success": true - }, - { - "query": "Query 54", - "iterations": [ - { - "elapsed": 104.192042, - "row_count": 0 - }, - { - "elapsed": 102.324083, - "row_count": 0 - }, - { - "elapsed": 102.421125, - "row_count": 0 - } - ], - "start_time": 1783521644, - "success": true - }, - { - "query": "Query 55", - "iterations": [ - { - "elapsed": 79.77220799999999, - "row_count": 69 - }, - { - "elapsed": 80.51283400000001, - "row_count": 69 - }, - { - "elapsed": 80.269333, - "row_count": 69 - } - ], - "start_time": 1783521644, - "success": true - }, - { - "query": "Query 56", - "iterations": [ - { - "elapsed": 99.330584, - "row_count": 78 - }, - { - "elapsed": 99.649, - "row_count": 78 - }, - { - "elapsed": 101.468042, - "row_count": 78 - } - ], - "start_time": 1783521644, - "success": true - }, - { - "query": "Query 57", - "iterations": [ - { - "elapsed": 106.76554200000001, - "row_count": 100 - }, - { - "elapsed": 105.026667, - "row_count": 100 - }, - { - "elapsed": 105.480375, - "row_count": 100 - } - ], - "start_time": 1783521645, - "success": true - }, - { - "query": "Query 58", - "iterations": [ - { - "elapsed": 199.018834, - "row_count": 0 - }, - { - "elapsed": 198.30775, - "row_count": 0 - }, - { - "elapsed": 198.312875, - "row_count": 0 - } - ], - "start_time": 1783521645, - "success": true - }, - { - "query": "Query 59", - "iterations": [ - { - "elapsed": 126.811375, - "row_count": 100 - }, - { - "elapsed": 126.551042, - "row_count": 100 - }, - { - "elapsed": 126.38487500000001, - "row_count": 100 - } - ], - "start_time": 1783521646, - "success": true - }, - { - "query": "Query 60", - "iterations": [ - { - "elapsed": 102.55766700000001, - "row_count": 100 - }, - { - "elapsed": 101.44529200000001, - "row_count": 100 - }, - { - "elapsed": 101.831833, - "row_count": 100 - } - ], - "start_time": 1783521646, - "success": true - }, - { - "query": "Query 61", - "iterations": [ - { - "elapsed": 7.690333, - "row_count": 1 - }, - { - "elapsed": 7.559583, - "row_count": 1 - }, - { - "elapsed": 7.522832999999999, - "row_count": 1 - } - ], - "start_time": 1783521646, - "success": true - }, - { - "query": "Query 62", - "iterations": [ - { - "elapsed": 405.30775, - "row_count": 100 - }, - { - "elapsed": 389.16891599999997, - "row_count": 100 - }, - { - "elapsed": 372.862708, - "row_count": 100 - } - ], - "start_time": 1783521646, - "success": true - }, - { - "query": "Query 63", - "iterations": [ - { - "elapsed": 74.304458, - "row_count": 44 - }, - { - "elapsed": 77.2415, - "row_count": 44 - }, - { - "elapsed": 74.841959, - "row_count": 44 - } - ], - "start_time": 1783521648, - "success": true - }, - { - "query": "Query 64", - "iterations": [ - { - "elapsed": 463.77087500000005, - "row_count": 10 - }, - { - "elapsed": 446.2295, - "row_count": 10 - }, - { - "elapsed": 445.709125, - "row_count": 10 - } - ], - "start_time": 1783521648, - "success": true - }, - { - "query": "Query 65", - "iterations": [ - { - "elapsed": 169.091208, - "row_count": 100 - }, - { - "elapsed": 169.121625, - "row_count": 100 - }, - { - "elapsed": 170.127416, - "row_count": 100 - } - ], - "start_time": 1783521649, - "success": true - }, - { - "query": "Query 66", - "iterations": [ - { - "elapsed": 146.740375, - "row_count": 5 - }, - { - "elapsed": 154.261459, - "row_count": 5 - }, - { - "elapsed": 137.807125, - "row_count": 5 - } - ], - "start_time": 1783521650, - "success": true - }, - { - "query": "Query 67", - "iterations": [ - { - "elapsed": 303.646459, - "row_count": 100 - }, - { - "elapsed": 302.561875, - "row_count": 100 - }, - { - "elapsed": 317.461792, - "row_count": 100 - } - ], - "start_time": 1783521650, - "success": true - }, - { - "query": "Query 68", - "iterations": [ - { - "elapsed": 5.0215, - "row_count": 0 - }, - { - "elapsed": 4.987125, - "row_count": 0 - }, - { - "elapsed": 4.426375, - "row_count": 0 - } - ], - "start_time": 1783521651, - "success": true - }, - { - "query": "Query 69", - "iterations": [ - { - "elapsed": 75.850042, - "row_count": 100 - }, - { - "elapsed": 75.469291, - "row_count": 100 - }, - { - "elapsed": 75.445542, - "row_count": 100 - } - ], - "start_time": 1783521651, - "success": true - }, - { - "query": "Query 70", - "iterations": [ - { - "elapsed": 228.536458, - "row_count": 3 - }, - { - "elapsed": 220.198875, - "row_count": 3 - }, - { - "elapsed": 218.438667, - "row_count": 3 - } - ], - "start_time": 1783521651, - "success": true - }, - { - "query": "Query 71", - "iterations": [ - { - "elapsed": 99.383208, - "row_count": 1102 - }, - { - "elapsed": 96.229875, - "row_count": 1102 - }, - { - "elapsed": 95.664709, - "row_count": 1102 - } - ], - "start_time": 1783521652, - "success": true - }, - { - "query": "Query 72", - "iterations": [ - { - "elapsed": 418.877583, - "row_count": 100 - }, - { - "elapsed": 430.697, - "row_count": 100 - }, - { - "elapsed": 419.774167, - "row_count": 100 - } - ], - "start_time": 1783521652, - "success": true - }, - { - "query": "Query 73", - "iterations": [ - { - "elapsed": 4.309125, - "row_count": 0 - }, - { - "elapsed": 3.839708, - "row_count": 0 - }, - { - "elapsed": 3.677166, - "row_count": 0 - } - ], - "start_time": 1783521653, - "success": true - }, - { - "query": "Query 74", - "iterations": [ - { - "elapsed": 368.984667, - "row_count": 90 - }, - { - "elapsed": 359.462542, - "row_count": 90 - }, - { - "elapsed": 370.330125, - "row_count": 90 - } - ], - "start_time": 1783521653, - "success": true - }, - { - "query": "Query 75", - "iterations": [ - { - "elapsed": 189.657667, - "row_count": 100 - }, - { - "elapsed": 190.38162499999999, - "row_count": 100 - }, - { - "elapsed": 191.179209, - "row_count": 100 - } - ], - "start_time": 1783521655, - "success": true - }, - { - "query": "Query 76", - "iterations": [ - { - "elapsed": 91.035416, - "row_count": 100 - }, - { - "elapsed": 106.09, - "row_count": 100 - }, - { - "elapsed": 92.465292, - "row_count": 100 - } - ], - "start_time": 1783521655, - "success": true - }, - { - "query": "Query 77", - "iterations": [ - { - "elapsed": 141.794792, - "row_count": 44 - }, - { - "elapsed": 135.59420799999998, - "row_count": 44 - }, - { - "elapsed": 137.310708, - "row_count": 44 - } - ], - "start_time": 1783521655, - "success": true - }, - { - "query": "Query 78", - "iterations": [ - { - "elapsed": 228.267208, - "row_count": 100 - }, - { - "elapsed": 225.284666, - "row_count": 100 - }, - { - "elapsed": 225.02229100000002, - "row_count": 100 - } - ], - "start_time": 1783521656, - "success": true - }, - { - "query": "Query 79", - "iterations": [ - { - "elapsed": 180.866208, - "row_count": 100 - }, - { - "elapsed": 162.64241700000002, - "row_count": 100 - }, - { - "elapsed": 156.027042, - "row_count": 100 - } - ], - "start_time": 1783521657, - "success": true - }, - { - "query": "Query 80", - "iterations": [ - { - "elapsed": 213.056042, - "row_count": 100 - }, - { - "elapsed": 211.78941600000002, - "row_count": 100 - }, - { - "elapsed": 212.354667, - "row_count": 100 - } - ], - "start_time": 1783521657, - "success": true - }, - { - "query": "Query 81", - "iterations": [ - { - "elapsed": 18.638875, - "row_count": 96 - }, - { - "elapsed": 16.608749999999997, - "row_count": 96 - }, - { - "elapsed": 16.036375, - "row_count": 96 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 82", - "iterations": [ - { - "elapsed": 36.547792, - "row_count": 1 - }, - { - "elapsed": 30.324542, - "row_count": 1 - }, - { - "elapsed": 28.508292, - "row_count": 1 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 83", - "iterations": [ - { - "elapsed": 24.420583, - "row_count": 4 - }, - { - "elapsed": 24.693958, - "row_count": 4 - }, - { - "elapsed": 23.633333, - "row_count": 4 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 84", - "iterations": [ - { - "elapsed": 29.444083, - "row_count": 22 - }, - { - "elapsed": 29.745792, - "row_count": 22 - }, - { - "elapsed": 29.450083, - "row_count": 22 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 85", - "iterations": [ - { - "elapsed": 105.296042, - "row_count": 3 - }, - { - "elapsed": 106.545541, - "row_count": 3 - }, - { - "elapsed": 104.95966700000001, - "row_count": 3 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 86", - "iterations": [ - { - "elapsed": 29.533584, - "row_count": 100 - }, - { - "elapsed": 28.586291, - "row_count": 100 - }, - { - "elapsed": 29.080125, - "row_count": 100 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 87", - "iterations": [ - { - "elapsed": 88.316667, - "row_count": 1 - }, - { - "elapsed": 87.159792, - "row_count": 1 - }, - { - "elapsed": 90.288, - "row_count": 1 - } - ], - "start_time": 1783521658, - "success": true - }, - { - "query": "Query 88", - "iterations": [ - { - "elapsed": 70.867375, - "row_count": 1 - }, - { - "elapsed": 72.537916, - "row_count": 1 - }, - { - "elapsed": 73.816666, - "row_count": 1 - } - ], - "start_time": 1783521659, - "success": true - }, - { - "query": "Query 89", - "iterations": [ - { - "elapsed": 87.267375, - "row_count": 100 - }, - { - "elapsed": 85.670375, - "row_count": 100 - }, - { - "elapsed": 85.18075, - "row_count": 100 - } - ], - "start_time": 1783521659, - "success": true - }, - { - "query": "Query 90", - "iterations": [ - { - "elapsed": 14.858708, - "row_count": 1 - }, - { - "elapsed": 13.964666000000001, - "row_count": 1 - }, - { - "elapsed": 14.641582999999999, - "row_count": 1 - } - ], - "start_time": 1783521659, - "success": true - }, - { - "query": "Query 91", - "iterations": [ - { - "elapsed": 45.074583000000004, - "row_count": 4 - }, - { - "elapsed": 42.707958999999995, - "row_count": 4 - }, - { - "elapsed": 43.785416, - "row_count": 4 - } - ], - "start_time": 1783521659, - "success": true - }, - { - "query": "Query 92", - "iterations": [ - { - "elapsed": 41.015875, - "row_count": 1 - }, - { - "elapsed": 41.694165999999996, - "row_count": 1 - }, - { - "elapsed": 41.778333, - "row_count": 1 - } - ], - "start_time": 1783521659, - "success": true - }, - { - "query": "Query 93", - "iterations": [ - { - "elapsed": 114.39658299999999, - "row_count": 100 - }, - { - "elapsed": 111.768583, - "row_count": 100 - }, - { - "elapsed": 110.483792, - "row_count": 100 - } - ], - "start_time": 1783521659, - "success": true - }, - { - "query": "Query 94", - "iterations": [ - { - "elapsed": 42.804958, - "row_count": 1 - }, - { - "elapsed": 41.423874999999995, - "row_count": 1 - }, - { - "elapsed": 42.614166000000004, - "row_count": 1 - } - ], - "start_time": 1783521660, - "success": true - }, - { - "query": "Query 95", - "iterations": [ - { - "elapsed": 54.709041, - "row_count": 1 - }, - { - "elapsed": 55.479958, - "row_count": 1 - }, - { - "elapsed": 57.841625, - "row_count": 1 - } - ], - "start_time": 1783521660, - "success": true - }, - { - "query": "Query 96", - "iterations": [ - { - "elapsed": 51.62, - "row_count": 1 - }, - { - "elapsed": 50.765917, - "row_count": 1 - }, - { - "elapsed": 50.701834, - "row_count": 1 - } - ], - "start_time": 1783521660, - "success": true - }, - { - "query": "Query 97", - "iterations": [ - { - "elapsed": 83.814625, - "row_count": 1 - }, - { - "elapsed": 83.93974999999999, - "row_count": 1 - }, - { - "elapsed": 80.627375, - "row_count": 1 - } - ], - "start_time": 1783521660, - "success": true - }, - { - "query": "Query 98", - "iterations": [ - { - "elapsed": 107.287541, - "row_count": 2486 - }, - { - "elapsed": 108.253375, - "row_count": 2486 - }, - { - "elapsed": 107.830875, - "row_count": 2486 - } - ], - "start_time": 1783521660, - "success": true - }, - { - "query": "Query 99", - "iterations": [ - { - "elapsed": 4359.472041, - "row_count": 90 - }, - { - "elapsed": 4312.556208, - "row_count": 90 - }, - { - "elapsed": 4298.860833, - "row_count": 90 - } - ], - "start_time": 1783521661, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/tpcds_off_r2.json b/ab_results/tpcds_off_r2.json deleted file mode 100644 index ac39b62dc377d..0000000000000 --- a/ab_results/tpcds_off_r2.json +++ /dev/null @@ -1,1891 +0,0 @@ -{ - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 5.114416, - "row_count": 0 - }, - { - "elapsed": 3.529375, - "row_count": 0 - }, - { - "elapsed": 3.457417, - "row_count": 0 - } - ], - "start_time": 1783521725, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 100.854208, - "row_count": 2513 - }, - { - "elapsed": 101.17216699999999, - "row_count": 2513 - }, - { - "elapsed": 108.40254200000001, - "row_count": 2513 - } - ], - "start_time": 1783521725, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 84.77620800000001, - "row_count": 38 - }, - { - "elapsed": 84.1435, - "row_count": 38 - }, - { - "elapsed": 84.37195799999999, - "row_count": 38 - } - ], - "start_time": 1783521726, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 884.514542, - "row_count": 8 - }, - { - "elapsed": 888.085375, - "row_count": 8 - }, - { - "elapsed": 896.045334, - "row_count": 8 - } - ], - "start_time": 1783521726, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 124.61037499999999, - "row_count": 100 - }, - { - "elapsed": 124.344708, - "row_count": 100 - }, - { - "elapsed": 122.315375, - "row_count": 100 - } - ], - "start_time": 1783521729, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 87.57075, - "row_count": 41 - }, - { - "elapsed": 88.997041, - "row_count": 41 - }, - { - "elapsed": 87.635375, - "row_count": 41 - } - ], - "start_time": 1783521729, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 225.391625, - "row_count": 100 - }, - { - "elapsed": 222.582166, - "row_count": 100 - }, - { - "elapsed": 220.736333, - "row_count": 100 - } - ], - "start_time": 1783521729, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 81.228917, - "row_count": 0 - }, - { - "elapsed": 80.523292, - "row_count": 0 - }, - { - "elapsed": 81.186917, - "row_count": 0 - } - ], - "start_time": 1783521730, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 79.077916, - "row_count": 1 - }, - { - "elapsed": 87.355167, - "row_count": 1 - }, - { - "elapsed": 104.325917, - "row_count": 1 - } - ], - "start_time": 1783521730, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 85.08162499999999, - "row_count": 2 - }, - { - "elapsed": 84.821625, - "row_count": 2 - }, - { - "elapsed": 84.517167, - "row_count": 2 - } - ], - "start_time": 1783521731, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 575.892167, - "row_count": 88 - }, - { - "elapsed": 580.845792, - "row_count": 88 - }, - { - "elapsed": 568.143292, - "row_count": 88 - } - ], - "start_time": 1783521731, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 30.264375, - "row_count": 100 - }, - { - "elapsed": 29.739833, - "row_count": 100 - }, - { - "elapsed": 30.391792000000002, - "row_count": 100 - } - ], - "start_time": 1783521732, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 283.282667, - "row_count": 1 - }, - { - "elapsed": 283.63624999999996, - "row_count": 1 - }, - { - "elapsed": 282.888167, - "row_count": 1 - } - ], - "start_time": 1783521733, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 784.752125, - "row_count": 100 - }, - { - "elapsed": 765.496958, - "row_count": 100 - }, - { - "elapsed": 762.572375, - "row_count": 100 - } - ], - "start_time": 1783521733, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 11.181583999999999, - "row_count": 100 - }, - { - "elapsed": 10.965124999999999, - "row_count": 100 - }, - { - "elapsed": 11.08775, - "row_count": 100 - } - ], - "start_time": 1783521736, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 4.734416, - "row_count": 1 - }, - { - "elapsed": 4.365542, - "row_count": 1 - }, - { - "elapsed": 4.202208, - "row_count": 1 - } - ], - "start_time": 1783521736, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 137.068125, - "row_count": 1 - }, - { - "elapsed": 134.577541, - "row_count": 1 - }, - { - "elapsed": 134.869333, - "row_count": 1 - } - ], - "start_time": 1783521736, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 90.172, - "row_count": 100 - }, - { - "elapsed": 90.258375, - "row_count": 100 - }, - { - "elapsed": 90.487125, - "row_count": 100 - } - ], - "start_time": 1783521736, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 111.35050000000001, - "row_count": 100 - }, - { - "elapsed": 110.26258299999999, - "row_count": 100 - }, - { - "elapsed": 111.763292, - "row_count": 100 - } - ], - "start_time": 1783521736, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 9.598832999999999, - "row_count": 100 - }, - { - "elapsed": 8.879125, - "row_count": 100 - }, - { - "elapsed": 8.789584, - "row_count": 100 - } - ], - "start_time": 1783521737, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 11.508542, - "row_count": 100 - }, - { - "elapsed": 11.323666, - "row_count": 100 - }, - { - "elapsed": 11.526167000000001, - "row_count": 100 - } - ], - "start_time": 1783521737, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 260.383333, - "row_count": 100 - }, - { - "elapsed": 260.667541, - "row_count": 100 - }, - { - "elapsed": 259.3995, - "row_count": 100 - } - ], - "start_time": 1783521737, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 523.536458, - "row_count": 0 - }, - { - "elapsed": 519.114458, - "row_count": 0 - }, - { - "elapsed": 522.102583, - "row_count": 0 - } - ], - "start_time": 1783521738, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 427.64020800000003, - "row_count": 0 - }, - { - "elapsed": 426.158584, - "row_count": 0 - }, - { - "elapsed": 436.832084, - "row_count": 0 - } - ], - "start_time": 1783521739, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 170.855458, - "row_count": 0 - }, - { - "elapsed": 173.06425000000002, - "row_count": 0 - }, - { - "elapsed": 167.69091699999998, - "row_count": 0 - } - ], - "start_time": 1783521740, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 51.408875, - "row_count": 100 - }, - { - "elapsed": 51.780125000000005, - "row_count": 100 - }, - { - "elapsed": 51.673417, - "row_count": 100 - } - ], - "start_time": 1783521741, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 3.9595840000000004, - "row_count": 1 - }, - { - "elapsed": 3.682542, - "row_count": 1 - }, - { - "elapsed": 3.391416, - "row_count": 1 - } - ], - "start_time": 1783521741, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 102.63425, - "row_count": 1 - }, - { - "elapsed": 107.004375, - "row_count": 1 - }, - { - "elapsed": 102.649959, - "row_count": 1 - } - ], - "start_time": 1783521741, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 166.092916, - "row_count": 0 - }, - { - "elapsed": 162.8915, - "row_count": 0 - }, - { - "elapsed": 163.579792, - "row_count": 0 - } - ], - "start_time": 1783521741, - "success": true - }, - { - "query": "Query 30", - "iterations": [], - "start_time": 1783521742, - "success": false - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 114.58200000000001, - "row_count": 51 - }, - { - "elapsed": 114.975291, - "row_count": 51 - }, - { - "elapsed": 116.12379200000001, - "row_count": 51 - } - ], - "start_time": 1783521742, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 8.741583, - "row_count": 1 - }, - { - "elapsed": 8.408542, - "row_count": 1 - }, - { - "elapsed": 7.943416999999999, - "row_count": 1 - } - ], - "start_time": 1783521742, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 99.252333, - "row_count": 100 - }, - { - "elapsed": 98.675083, - "row_count": 100 - }, - { - "elapsed": 100.20016700000001, - "row_count": 100 - } - ], - "start_time": 1783521742, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 4.016208000000001, - "row_count": 0 - }, - { - "elapsed": 3.442166, - "row_count": 0 - }, - { - "elapsed": 3.862208, - "row_count": 0 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 96.738375, - "row_count": 100 - }, - { - "elapsed": 95.097, - "row_count": 100 - }, - { - "elapsed": 93.912334, - "row_count": 100 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 3.668917, - "row_count": 1 - }, - { - "elapsed": 3.7550830000000004, - "row_count": 1 - }, - { - "elapsed": 3.95925, - "row_count": 1 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 5.5319590000000005, - "row_count": 0 - }, - { - "elapsed": 5.200541, - "row_count": 0 - }, - { - "elapsed": 5.356541, - "row_count": 0 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 86.113375, - "row_count": 1 - }, - { - "elapsed": 86.02158299999999, - "row_count": 1 - }, - { - "elapsed": 86.584917, - "row_count": 1 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 51.028749999999995, - "row_count": 7 - }, - { - "elapsed": 51.556, - "row_count": 7 - }, - { - "elapsed": 51.367999999999995, - "row_count": 7 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 66.56841700000001, - "row_count": 100 - }, - { - "elapsed": 64.797625, - "row_count": 100 - }, - { - "elapsed": 65.77366699999999, - "row_count": 100 - } - ], - "start_time": 1783521743, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 9.278041, - "row_count": 0 - }, - { - "elapsed": 8.347958, - "row_count": 0 - }, - { - "elapsed": 8.918125, - "row_count": 0 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 81.142417, - "row_count": 10 - }, - { - "elapsed": 79.773583, - "row_count": 10 - }, - { - "elapsed": 79.278833, - "row_count": 10 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 43", - "iterations": [ - { - "elapsed": 3.356292, - "row_count": 0 - }, - { - "elapsed": 2.996, - "row_count": 0 - }, - { - "elapsed": 2.9650420000000004, - "row_count": 0 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 44", - "iterations": [ - { - "elapsed": 4.773916, - "row_count": 0 - }, - { - "elapsed": 4.710666, - "row_count": 0 - }, - { - "elapsed": 4.575959, - "row_count": 0 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 45", - "iterations": [ - { - "elapsed": 31.384750000000004, - "row_count": 16 - }, - { - "elapsed": 31.214, - "row_count": 16 - }, - { - "elapsed": 31.214, - "row_count": 16 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 46", - "iterations": [ - { - "elapsed": 4.799833, - "row_count": 0 - }, - { - "elapsed": 4.461375, - "row_count": 0 - }, - { - "elapsed": 4.638417, - "row_count": 0 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 47", - "iterations": [ - { - "elapsed": 426.58299999999997, - "row_count": 100 - }, - { - "elapsed": 434.414458, - "row_count": 100 - }, - { - "elapsed": 427.514334, - "row_count": 100 - } - ], - "start_time": 1783521744, - "success": true - }, - { - "query": "Query 48", - "iterations": [ - { - "elapsed": 192.446, - "row_count": 1 - }, - { - "elapsed": 191.569334, - "row_count": 1 - }, - { - "elapsed": 195.811709, - "row_count": 1 - } - ], - "start_time": 1783521745, - "success": true - }, - { - "query": "Query 49", - "iterations": [ - { - "elapsed": 166.385625, - "row_count": 31 - }, - { - "elapsed": 166.10312499999998, - "row_count": 31 - }, - { - "elapsed": 167.807125, - "row_count": 31 - } - ], - "start_time": 1783521746, - "success": true - }, - { - "query": "Query 50", - "iterations": [ - { - "elapsed": 122.455833, - "row_count": 6 - }, - { - "elapsed": 119.171375, - "row_count": 6 - }, - { - "elapsed": 120.647, - "row_count": 6 - } - ], - "start_time": 1783521746, - "success": true - }, - { - "query": "Query 51", - "iterations": [ - { - "elapsed": 117.794584, - "row_count": 100 - }, - { - "elapsed": 115.979208, - "row_count": 100 - }, - { - "elapsed": 117.803459, - "row_count": 100 - } - ], - "start_time": 1783521747, - "success": true - }, - { - "query": "Query 52", - "iterations": [ - { - "elapsed": 80.463167, - "row_count": 100 - }, - { - "elapsed": 79.322167, - "row_count": 100 - }, - { - "elapsed": 79.579, - "row_count": 100 - } - ], - "start_time": 1783521747, - "success": true - }, - { - "query": "Query 53", - "iterations": [ - { - "elapsed": 73.169542, - "row_count": 14 - }, - { - "elapsed": 73.675833, - "row_count": 14 - }, - { - "elapsed": 74.810041, - "row_count": 14 - } - ], - "start_time": 1783521747, - "success": true - }, - { - "query": "Query 54", - "iterations": [ - { - "elapsed": 113.810542, - "row_count": 0 - }, - { - "elapsed": 106.802959, - "row_count": 0 - }, - { - "elapsed": 103.5595, - "row_count": 0 - } - ], - "start_time": 1783521748, - "success": true - }, - { - "query": "Query 55", - "iterations": [ - { - "elapsed": 80.1695, - "row_count": 69 - }, - { - "elapsed": 79.234125, - "row_count": 69 - }, - { - "elapsed": 79.57837500000001, - "row_count": 69 - } - ], - "start_time": 1783521748, - "success": true - }, - { - "query": "Query 56", - "iterations": [ - { - "elapsed": 99.967958, - "row_count": 78 - }, - { - "elapsed": 98.86470899999999, - "row_count": 78 - }, - { - "elapsed": 98.629959, - "row_count": 78 - } - ], - "start_time": 1783521748, - "success": true - }, - { - "query": "Query 57", - "iterations": [ - { - "elapsed": 104.046, - "row_count": 100 - }, - { - "elapsed": 104.648292, - "row_count": 100 - }, - { - "elapsed": 106.743625, - "row_count": 100 - } - ], - "start_time": 1783521748, - "success": true - }, - { - "query": "Query 58", - "iterations": [ - { - "elapsed": 198.36225, - "row_count": 0 - }, - { - "elapsed": 197.49075, - "row_count": 0 - }, - { - "elapsed": 198.131167, - "row_count": 0 - } - ], - "start_time": 1783521749, - "success": true - }, - { - "query": "Query 59", - "iterations": [ - { - "elapsed": 125.61104200000001, - "row_count": 100 - }, - { - "elapsed": 134.48208400000001, - "row_count": 100 - }, - { - "elapsed": 136.516958, - "row_count": 100 - } - ], - "start_time": 1783521749, - "success": true - }, - { - "query": "Query 60", - "iterations": [ - { - "elapsed": 103.77112500000001, - "row_count": 100 - }, - { - "elapsed": 101.386791, - "row_count": 100 - }, - { - "elapsed": 100.20725, - "row_count": 100 - } - ], - "start_time": 1783521750, - "success": true - }, - { - "query": "Query 61", - "iterations": [ - { - "elapsed": 7.665291, - "row_count": 1 - }, - { - "elapsed": 7.108625, - "row_count": 1 - }, - { - "elapsed": 7.448416, - "row_count": 1 - } - ], - "start_time": 1783521750, - "success": true - }, - { - "query": "Query 62", - "iterations": [ - { - "elapsed": 373.817917, - "row_count": 100 - }, - { - "elapsed": 367.953792, - "row_count": 100 - }, - { - "elapsed": 372.099958, - "row_count": 100 - } - ], - "start_time": 1783521750, - "success": true - }, - { - "query": "Query 63", - "iterations": [ - { - "elapsed": 74.207458, - "row_count": 44 - }, - { - "elapsed": 73.99870899999999, - "row_count": 44 - }, - { - "elapsed": 74.590583, - "row_count": 44 - } - ], - "start_time": 1783521751, - "success": true - }, - { - "query": "Query 64", - "iterations": [ - { - "elapsed": 447.524791, - "row_count": 10 - }, - { - "elapsed": 451.41274999999996, - "row_count": 10 - }, - { - "elapsed": 448.846, - "row_count": 10 - } - ], - "start_time": 1783521751, - "success": true - }, - { - "query": "Query 65", - "iterations": [ - { - "elapsed": 171.678125, - "row_count": 100 - }, - { - "elapsed": 168.788792, - "row_count": 100 - }, - { - "elapsed": 168.22225, - "row_count": 100 - } - ], - "start_time": 1783521753, - "success": true - }, - { - "query": "Query 66", - "iterations": [ - { - "elapsed": 147.681458, - "row_count": 5 - }, - { - "elapsed": 133.409084, - "row_count": 5 - }, - { - "elapsed": 134.359167, - "row_count": 5 - } - ], - "start_time": 1783521753, - "success": true - }, - { - "query": "Query 67", - "iterations": [ - { - "elapsed": 326.656, - "row_count": 100 - }, - { - "elapsed": 304.123875, - "row_count": 100 - }, - { - "elapsed": 298.208584, - "row_count": 100 - } - ], - "start_time": 1783521754, - "success": true - }, - { - "query": "Query 68", - "iterations": [ - { - "elapsed": 5.443042, - "row_count": 0 - }, - { - "elapsed": 4.636875000000001, - "row_count": 0 - }, - { - "elapsed": 4.9887500000000005, - "row_count": 0 - } - ], - "start_time": 1783521755, - "success": true - }, - { - "query": "Query 69", - "iterations": [ - { - "elapsed": 74.413833, - "row_count": 100 - }, - { - "elapsed": 75.39037499999999, - "row_count": 100 - }, - { - "elapsed": 78.221125, - "row_count": 100 - } - ], - "start_time": 1783521755, - "success": true - }, - { - "query": "Query 70", - "iterations": [ - { - "elapsed": 228.576334, - "row_count": 3 - }, - { - "elapsed": 220.842958, - "row_count": 3 - }, - { - "elapsed": 218.445792, - "row_count": 3 - } - ], - "start_time": 1783521755, - "success": true - }, - { - "query": "Query 71", - "iterations": [ - { - "elapsed": 94.65650000000001, - "row_count": 1102 - }, - { - "elapsed": 95.75908299999999, - "row_count": 1102 - }, - { - "elapsed": 95.425333, - "row_count": 1102 - } - ], - "start_time": 1783521755, - "success": true - }, - { - "query": "Query 72", - "iterations": [ - { - "elapsed": 422.843542, - "row_count": 100 - }, - { - "elapsed": 428.71274999999997, - "row_count": 100 - }, - { - "elapsed": 433.06175, - "row_count": 100 - } - ], - "start_time": 1783521756, - "success": true - }, - { - "query": "Query 73", - "iterations": [ - { - "elapsed": 4.252, - "row_count": 0 - }, - { - "elapsed": 3.753584, - "row_count": 0 - }, - { - "elapsed": 3.872833, - "row_count": 0 - } - ], - "start_time": 1783521757, - "success": true - }, - { - "query": "Query 74", - "iterations": [ - { - "elapsed": 351.43483399999997, - "row_count": 90 - }, - { - "elapsed": 352.56112499999995, - "row_count": 90 - }, - { - "elapsed": 365.99575, - "row_count": 90 - } - ], - "start_time": 1783521757, - "success": true - }, - { - "query": "Query 75", - "iterations": [ - { - "elapsed": 190.606083, - "row_count": 100 - }, - { - "elapsed": 187.621042, - "row_count": 100 - }, - { - "elapsed": 189.028459, - "row_count": 100 - } - ], - "start_time": 1783521758, - "success": true - }, - { - "query": "Query 76", - "iterations": [ - { - "elapsed": 91.72524999999999, - "row_count": 100 - }, - { - "elapsed": 92.17649999999999, - "row_count": 100 - }, - { - "elapsed": 91.439375, - "row_count": 100 - } - ], - "start_time": 1783521759, - "success": true - }, - { - "query": "Query 77", - "iterations": [ - { - "elapsed": 135.94562499999998, - "row_count": 44 - }, - { - "elapsed": 134.74945799999998, - "row_count": 44 - }, - { - "elapsed": 134.17779199999998, - "row_count": 44 - } - ], - "start_time": 1783521759, - "success": true - }, - { - "query": "Query 78", - "iterations": [ - { - "elapsed": 222.948667, - "row_count": 100 - }, - { - "elapsed": 220.78816700000002, - "row_count": 100 - }, - { - "elapsed": 221.213291, - "row_count": 100 - } - ], - "start_time": 1783521759, - "success": true - }, - { - "query": "Query 79", - "iterations": [ - { - "elapsed": 156.279709, - "row_count": 100 - }, - { - "elapsed": 172.568959, - "row_count": 100 - }, - { - "elapsed": 157.27883300000002, - "row_count": 100 - } - ], - "start_time": 1783521760, - "success": true - }, - { - "query": "Query 80", - "iterations": [ - { - "elapsed": 212.78770799999998, - "row_count": 100 - }, - { - "elapsed": 212.683917, - "row_count": 100 - }, - { - "elapsed": 213.039917, - "row_count": 100 - } - ], - "start_time": 1783521761, - "success": true - }, - { - "query": "Query 81", - "iterations": [ - { - "elapsed": 16.357584000000003, - "row_count": 96 - }, - { - "elapsed": 16.271625, - "row_count": 96 - }, - { - "elapsed": 16.410708, - "row_count": 96 - } - ], - "start_time": 1783521761, - "success": true - }, - { - "query": "Query 82", - "iterations": [ - { - "elapsed": 28.058041999999997, - "row_count": 1 - }, - { - "elapsed": 27.595208, - "row_count": 1 - }, - { - "elapsed": 27.737624999999998, - "row_count": 1 - } - ], - "start_time": 1783521761, - "success": true - }, - { - "query": "Query 83", - "iterations": [ - { - "elapsed": 23.655417, - "row_count": 4 - }, - { - "elapsed": 23.666584, - "row_count": 4 - }, - { - "elapsed": 23.868709, - "row_count": 4 - } - ], - "start_time": 1783521761, - "success": true - }, - { - "query": "Query 84", - "iterations": [ - { - "elapsed": 29.304042, - "row_count": 22 - }, - { - "elapsed": 29.384458, - "row_count": 22 - }, - { - "elapsed": 29.512, - "row_count": 22 - } - ], - "start_time": 1783521761, - "success": true - }, - { - "query": "Query 85", - "iterations": [ - { - "elapsed": 129.296542, - "row_count": 3 - }, - { - "elapsed": 104.947, - "row_count": 3 - }, - { - "elapsed": 104.378666, - "row_count": 3 - } - ], - "start_time": 1783521761, - "success": true - }, - { - "query": "Query 86", - "iterations": [ - { - "elapsed": 33.782624999999996, - "row_count": 100 - }, - { - "elapsed": 30.511458, - "row_count": 100 - }, - { - "elapsed": 30.75675, - "row_count": 100 - } - ], - "start_time": 1783521762, - "success": true - }, - { - "query": "Query 87", - "iterations": [ - { - "elapsed": 96.592333, - "row_count": 1 - }, - { - "elapsed": 93.3995, - "row_count": 1 - }, - { - "elapsed": 94.873875, - "row_count": 1 - } - ], - "start_time": 1783521762, - "success": true - }, - { - "query": "Query 88", - "iterations": [ - { - "elapsed": 101.80995800000001, - "row_count": 1 - }, - { - "elapsed": 86.79833400000001, - "row_count": 1 - }, - { - "elapsed": 86.13841699999999, - "row_count": 1 - } - ], - "start_time": 1783521762, - "success": true - }, - { - "query": "Query 89", - "iterations": [ - { - "elapsed": 85.32199999999999, - "row_count": 100 - }, - { - "elapsed": 84.926916, - "row_count": 100 - }, - { - "elapsed": 84.330875, - "row_count": 100 - } - ], - "start_time": 1783521762, - "success": true - }, - { - "query": "Query 90", - "iterations": [ - { - "elapsed": 14.241083, - "row_count": 1 - }, - { - "elapsed": 13.495541999999999, - "row_count": 1 - }, - { - "elapsed": 13.622250000000001, - "row_count": 1 - } - ], - "start_time": 1783521763, - "success": true - }, - { - "query": "Query 91", - "iterations": [ - { - "elapsed": 42.975917, - "row_count": 4 - }, - { - "elapsed": 43.429500000000004, - "row_count": 4 - }, - { - "elapsed": 42.778417, - "row_count": 4 - } - ], - "start_time": 1783521763, - "success": true - }, - { - "query": "Query 92", - "iterations": [ - { - "elapsed": 41.322458, - "row_count": 1 - }, - { - "elapsed": 41.504959, - "row_count": 1 - }, - { - "elapsed": 41.115167, - "row_count": 1 - } - ], - "start_time": 1783521763, - "success": true - }, - { - "query": "Query 93", - "iterations": [ - { - "elapsed": 110.365916, - "row_count": 100 - }, - { - "elapsed": 109.74375, - "row_count": 100 - }, - { - "elapsed": 110.586083, - "row_count": 100 - } - ], - "start_time": 1783521763, - "success": true - }, - { - "query": "Query 94", - "iterations": [ - { - "elapsed": 41.957625, - "row_count": 1 - }, - { - "elapsed": 42.383540999999994, - "row_count": 1 - }, - { - "elapsed": 41.543833, - "row_count": 1 - } - ], - "start_time": 1783521763, - "success": true - }, - { - "query": "Query 95", - "iterations": [ - { - "elapsed": 54.933167, - "row_count": 1 - }, - { - "elapsed": 55.575958, - "row_count": 1 - }, - { - "elapsed": 57.272125, - "row_count": 1 - } - ], - "start_time": 1783521763, - "success": true - }, - { - "query": "Query 96", - "iterations": [ - { - "elapsed": 50.252834, - "row_count": 1 - }, - { - "elapsed": 49.556000000000004, - "row_count": 1 - }, - { - "elapsed": 48.506084, - "row_count": 1 - } - ], - "start_time": 1783521764, - "success": true - }, - { - "query": "Query 97", - "iterations": [ - { - "elapsed": 82.253583, - "row_count": 1 - }, - { - "elapsed": 81.42108300000001, - "row_count": 1 - }, - { - "elapsed": 82.544875, - "row_count": 1 - } - ], - "start_time": 1783521764, - "success": true - }, - { - "query": "Query 98", - "iterations": [ - { - "elapsed": 106.096125, - "row_count": 2486 - }, - { - "elapsed": 107.819667, - "row_count": 2486 - }, - { - "elapsed": 106.01225000000001, - "row_count": 2486 - } - ], - "start_time": 1783521764, - "success": true - }, - { - "query": "Query 99", - "iterations": [ - { - "elapsed": 4239.04025, - "row_count": 90 - }, - { - "elapsed": 4343.546417, - "row_count": 90 - }, - { - "elapsed": 4270.528417, - "row_count": 90 - } - ], - "start_time": 1783521764, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521725, - "arguments": [ - "tpcds", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", - "--query_path", - "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", - "--prefer_hash_join", - "true", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpcds_off_r2.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/tpcds_on_r1.json b/ab_results/tpcds_on_r1.json deleted file mode 100644 index 5e1b76ae56f52..0000000000000 --- a/ab_results/tpcds_on_r1.json +++ /dev/null @@ -1,1891 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521674, - "arguments": [ - "tpcds", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", - "--query_path", - "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", - "--prefer_hash_join", - "true", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpcds_on_r1.json" - ] - }, - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 5.137666, - "row_count": 0 - }, - { - "elapsed": 3.5387079999999997, - "row_count": 0 - }, - { - "elapsed": 3.811, - "row_count": 0 - } - ], - "start_time": 1783521674, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 100.669167, - "row_count": 2513 - }, - { - "elapsed": 101.501125, - "row_count": 2513 - }, - { - "elapsed": 103.34308300000001, - "row_count": 2513 - } - ], - "start_time": 1783521674, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 85.349833, - "row_count": 38 - }, - { - "elapsed": 108.28575, - "row_count": 38 - }, - { - "elapsed": 85.717167, - "row_count": 38 - } - ], - "start_time": 1783521674, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 891.011958, - "row_count": 8 - }, - { - "elapsed": 909.013333, - "row_count": 8 - }, - { - "elapsed": 877.169791, - "row_count": 8 - } - ], - "start_time": 1783521674, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 122.46374999999999, - "row_count": 100 - }, - { - "elapsed": 122.673084, - "row_count": 100 - }, - { - "elapsed": 124.776917, - "row_count": 100 - } - ], - "start_time": 1783521677, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 90.29475, - "row_count": 41 - }, - { - "elapsed": 85.181542, - "row_count": 41 - }, - { - "elapsed": 89.553833, - "row_count": 41 - } - ], - "start_time": 1783521677, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 226.51375000000002, - "row_count": 100 - }, - { - "elapsed": 223.395625, - "row_count": 100 - }, - { - "elapsed": 224.841042, - "row_count": 100 - } - ], - "start_time": 1783521678, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 81.43845800000001, - "row_count": 0 - }, - { - "elapsed": 80.28375, - "row_count": 0 - }, - { - "elapsed": 81.50375, - "row_count": 0 - } - ], - "start_time": 1783521678, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 92.34854200000001, - "row_count": 1 - }, - { - "elapsed": 80.691417, - "row_count": 1 - }, - { - "elapsed": 90.531167, - "row_count": 1 - } - ], - "start_time": 1783521679, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 87.388875, - "row_count": 2 - }, - { - "elapsed": 88.303208, - "row_count": 2 - }, - { - "elapsed": 88.26608399999999, - "row_count": 2 - } - ], - "start_time": 1783521679, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 575.053916, - "row_count": 88 - }, - { - "elapsed": 575.29975, - "row_count": 88 - }, - { - "elapsed": 579.6526250000001, - "row_count": 88 - } - ], - "start_time": 1783521679, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 30.378, - "row_count": 100 - }, - { - "elapsed": 30.268791999999998, - "row_count": 100 - }, - { - "elapsed": 30.801624999999998, - "row_count": 100 - } - ], - "start_time": 1783521681, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 279.397375, - "row_count": 1 - }, - { - "elapsed": 283.49841599999996, - "row_count": 1 - }, - { - "elapsed": 281.188625, - "row_count": 1 - } - ], - "start_time": 1783521681, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 763.604292, - "row_count": 100 - }, - { - "elapsed": 787.8129590000001, - "row_count": 100 - }, - { - "elapsed": 799.7091670000001, - "row_count": 100 - } - ], - "start_time": 1783521682, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 11.050917, - "row_count": 100 - }, - { - "elapsed": 10.530084, - "row_count": 100 - }, - { - "elapsed": 10.23775, - "row_count": 100 - } - ], - "start_time": 1783521684, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 4.503125, - "row_count": 1 - }, - { - "elapsed": 4.607375, - "row_count": 1 - }, - { - "elapsed": 4.514083, - "row_count": 1 - } - ], - "start_time": 1783521684, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 137.710334, - "row_count": 1 - }, - { - "elapsed": 134.649833, - "row_count": 1 - }, - { - "elapsed": 134.745584, - "row_count": 1 - } - ], - "start_time": 1783521684, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 91.263833, - "row_count": 100 - }, - { - "elapsed": 91.005, - "row_count": 100 - }, - { - "elapsed": 95.71829199999999, - "row_count": 100 - } - ], - "start_time": 1783521685, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 111.921459, - "row_count": 100 - }, - { - "elapsed": 111.229375, - "row_count": 100 - }, - { - "elapsed": 111.005167, - "row_count": 100 - } - ], - "start_time": 1783521685, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 9.246625, - "row_count": 100 - }, - { - "elapsed": 8.712582999999999, - "row_count": 100 - }, - { - "elapsed": 8.732875, - "row_count": 100 - } - ], - "start_time": 1783521685, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 11.745958000000002, - "row_count": 100 - }, - { - "elapsed": 11.213042, - "row_count": 100 - }, - { - "elapsed": 11.149, - "row_count": 100 - } - ], - "start_time": 1783521685, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 262.508125, - "row_count": 100 - }, - { - "elapsed": 258.13012499999996, - "row_count": 100 - }, - { - "elapsed": 264.370208, - "row_count": 100 - } - ], - "start_time": 1783521685, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 540.564334, - "row_count": 0 - }, - { - "elapsed": 522.971041, - "row_count": 0 - }, - { - "elapsed": 519.812584, - "row_count": 0 - } - ], - "start_time": 1783521686, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 429.578291, - "row_count": 0 - }, - { - "elapsed": 426.228791, - "row_count": 0 - }, - { - "elapsed": 428.853167, - "row_count": 0 - } - ], - "start_time": 1783521688, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 172.58262499999998, - "row_count": 0 - }, - { - "elapsed": 170.630625, - "row_count": 0 - }, - { - "elapsed": 167.57666600000002, - "row_count": 0 - } - ], - "start_time": 1783521689, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 53.210458, - "row_count": 100 - }, - { - "elapsed": 52.996874999999996, - "row_count": 100 - }, - { - "elapsed": 52.499459, - "row_count": 100 - } - ], - "start_time": 1783521689, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 4.043375, - "row_count": 1 - }, - { - "elapsed": 4.137667, - "row_count": 1 - }, - { - "elapsed": 3.724667, - "row_count": 1 - } - ], - "start_time": 1783521690, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 104.921375, - "row_count": 1 - }, - { - "elapsed": 102.59, - "row_count": 1 - }, - { - "elapsed": 106.534458, - "row_count": 1 - } - ], - "start_time": 1783521690, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 165.464709, - "row_count": 0 - }, - { - "elapsed": 164.312042, - "row_count": 0 - }, - { - "elapsed": 160.865, - "row_count": 0 - } - ], - "start_time": 1783521690, - "success": true - }, - { - "query": "Query 30", - "iterations": [], - "start_time": 1783521690, - "success": false - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 115.15758299999999, - "row_count": 51 - }, - { - "elapsed": 116.46275, - "row_count": 51 - }, - { - "elapsed": 135.086208, - "row_count": 51 - } - ], - "start_time": 1783521690, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 8.6565, - "row_count": 1 - }, - { - "elapsed": 8.376708, - "row_count": 1 - }, - { - "elapsed": 8.769709, - "row_count": 1 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 99.73216599999999, - "row_count": 100 - }, - { - "elapsed": 99.413667, - "row_count": 100 - }, - { - "elapsed": 100.44679199999999, - "row_count": 100 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 4.038125, - "row_count": 0 - }, - { - "elapsed": 4.068041, - "row_count": 0 - }, - { - "elapsed": 3.882458, - "row_count": 0 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 97.23633299999999, - "row_count": 100 - }, - { - "elapsed": 98.402875, - "row_count": 100 - }, - { - "elapsed": 98.09491700000001, - "row_count": 100 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 4.113334, - "row_count": 1 - }, - { - "elapsed": 4.483625, - "row_count": 1 - }, - { - "elapsed": 4.118583, - "row_count": 1 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 6.207666, - "row_count": 0 - }, - { - "elapsed": 5.561958, - "row_count": 0 - }, - { - "elapsed": 5.818458000000001, - "row_count": 0 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 92.89500000000001, - "row_count": 1 - }, - { - "elapsed": 91.060166, - "row_count": 1 - }, - { - "elapsed": 87.815333, - "row_count": 1 - } - ], - "start_time": 1783521691, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 52.913624999999996, - "row_count": 7 - }, - { - "elapsed": 52.045292, - "row_count": 7 - }, - { - "elapsed": 72.333084, - "row_count": 7 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 68.851625, - "row_count": 100 - }, - { - "elapsed": 65.429625, - "row_count": 100 - }, - { - "elapsed": 64.93708400000001, - "row_count": 100 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 8.806332999999999, - "row_count": 0 - }, - { - "elapsed": 8.791625000000002, - "row_count": 0 - }, - { - "elapsed": 8.754417, - "row_count": 0 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 79.657083, - "row_count": 10 - }, - { - "elapsed": 81.293542, - "row_count": 10 - }, - { - "elapsed": 81.066625, - "row_count": 10 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 43", - "iterations": [ - { - "elapsed": 3.2795419999999997, - "row_count": 0 - }, - { - "elapsed": 2.850417, - "row_count": 0 - }, - { - "elapsed": 2.996584, - "row_count": 0 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 44", - "iterations": [ - { - "elapsed": 5.040458999999999, - "row_count": 0 - }, - { - "elapsed": 4.674875, - "row_count": 0 - }, - { - "elapsed": 4.598959, - "row_count": 0 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 45", - "iterations": [ - { - "elapsed": 31.645, - "row_count": 16 - }, - { - "elapsed": 32.583584, - "row_count": 16 - }, - { - "elapsed": 31.502708, - "row_count": 16 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 46", - "iterations": [ - { - "elapsed": 4.776208, - "row_count": 0 - }, - { - "elapsed": 4.858208, - "row_count": 0 - }, - { - "elapsed": 4.695208999999999, - "row_count": 0 - } - ], - "start_time": 1783521692, - "success": true - }, - { - "query": "Query 47", - "iterations": [ - { - "elapsed": 434.6585, - "row_count": 100 - }, - { - "elapsed": 426.74925, - "row_count": 100 - }, - { - "elapsed": 431.065459, - "row_count": 100 - } - ], - "start_time": 1783521693, - "success": true - }, - { - "query": "Query 48", - "iterations": [ - { - "elapsed": 198.646542, - "row_count": 1 - }, - { - "elapsed": 194.130625, - "row_count": 1 - }, - { - "elapsed": 193.394666, - "row_count": 1 - } - ], - "start_time": 1783521694, - "success": true - }, - { - "query": "Query 49", - "iterations": [ - { - "elapsed": 167.93508300000002, - "row_count": 31 - }, - { - "elapsed": 165.550959, - "row_count": 31 - }, - { - "elapsed": 168.64225, - "row_count": 31 - } - ], - "start_time": 1783521694, - "success": true - }, - { - "query": "Query 50", - "iterations": [ - { - "elapsed": 124.276, - "row_count": 6 - }, - { - "elapsed": 119.782334, - "row_count": 6 - }, - { - "elapsed": 119.4825, - "row_count": 6 - } - ], - "start_time": 1783521695, - "success": true - }, - { - "query": "Query 51", - "iterations": [ - { - "elapsed": 120.21612499999999, - "row_count": 100 - }, - { - "elapsed": 118.949583, - "row_count": 100 - }, - { - "elapsed": 118.051, - "row_count": 100 - } - ], - "start_time": 1783521695, - "success": true - }, - { - "query": "Query 52", - "iterations": [ - { - "elapsed": 80.858666, - "row_count": 100 - }, - { - "elapsed": 80.377167, - "row_count": 100 - }, - { - "elapsed": 80.55883299999999, - "row_count": 100 - } - ], - "start_time": 1783521696, - "success": true - }, - { - "query": "Query 53", - "iterations": [ - { - "elapsed": 80.258542, - "row_count": 14 - }, - { - "elapsed": 77.172875, - "row_count": 14 - }, - { - "elapsed": 77.058458, - "row_count": 14 - } - ], - "start_time": 1783521696, - "success": true - }, - { - "query": "Query 54", - "iterations": [ - { - "elapsed": 106.06016699999999, - "row_count": 0 - }, - { - "elapsed": 103.403542, - "row_count": 0 - }, - { - "elapsed": 104.412, - "row_count": 0 - } - ], - "start_time": 1783521696, - "success": true - }, - { - "query": "Query 55", - "iterations": [ - { - "elapsed": 80.635917, - "row_count": 69 - }, - { - "elapsed": 80.731583, - "row_count": 69 - }, - { - "elapsed": 80.38654100000001, - "row_count": 69 - } - ], - "start_time": 1783521696, - "success": true - }, - { - "query": "Query 56", - "iterations": [ - { - "elapsed": 100.674584, - "row_count": 78 - }, - { - "elapsed": 99.990459, - "row_count": 78 - }, - { - "elapsed": 101.95958300000001, - "row_count": 78 - } - ], - "start_time": 1783521697, - "success": true - }, - { - "query": "Query 57", - "iterations": [ - { - "elapsed": 104.906667, - "row_count": 100 - }, - { - "elapsed": 103.818167, - "row_count": 100 - }, - { - "elapsed": 104.153541, - "row_count": 100 - } - ], - "start_time": 1783521697, - "success": true - }, - { - "query": "Query 58", - "iterations": [ - { - "elapsed": 198.862459, - "row_count": 0 - }, - { - "elapsed": 199.094042, - "row_count": 0 - }, - { - "elapsed": 198.233, - "row_count": 0 - } - ], - "start_time": 1783521697, - "success": true - }, - { - "query": "Query 59", - "iterations": [ - { - "elapsed": 125.254833, - "row_count": 100 - }, - { - "elapsed": 125.24737499999999, - "row_count": 100 - }, - { - "elapsed": 126.627958, - "row_count": 100 - } - ], - "start_time": 1783521698, - "success": true - }, - { - "query": "Query 60", - "iterations": [ - { - "elapsed": 100.90670899999999, - "row_count": 100 - }, - { - "elapsed": 103.191, - "row_count": 100 - }, - { - "elapsed": 103.868792, - "row_count": 100 - } - ], - "start_time": 1783521698, - "success": true - }, - { - "query": "Query 61", - "iterations": [ - { - "elapsed": 7.884499999999999, - "row_count": 1 - }, - { - "elapsed": 7.749, - "row_count": 1 - }, - { - "elapsed": 7.4844170000000005, - "row_count": 1 - } - ], - "start_time": 1783521699, - "success": true - }, - { - "query": "Query 62", - "iterations": [ - { - "elapsed": 393.63116599999995, - "row_count": 100 - }, - { - "elapsed": 371.104708, - "row_count": 100 - }, - { - "elapsed": 367.381625, - "row_count": 100 - } - ], - "start_time": 1783521699, - "success": true - }, - { - "query": "Query 63", - "iterations": [ - { - "elapsed": 74.81224999999999, - "row_count": 44 - }, - { - "elapsed": 74.302916, - "row_count": 44 - }, - { - "elapsed": 73.163875, - "row_count": 44 - } - ], - "start_time": 1783521700, - "success": true - }, - { - "query": "Query 64", - "iterations": [ - { - "elapsed": 451.046625, - "row_count": 10 - }, - { - "elapsed": 440.084166, - "row_count": 10 - }, - { - "elapsed": 438.815791, - "row_count": 10 - } - ], - "start_time": 1783521700, - "success": true - }, - { - "query": "Query 65", - "iterations": [ - { - "elapsed": 169.030666, - "row_count": 100 - }, - { - "elapsed": 168.717875, - "row_count": 100 - }, - { - "elapsed": 170.424041, - "row_count": 100 - } - ], - "start_time": 1783521701, - "success": true - }, - { - "query": "Query 66", - "iterations": [ - { - "elapsed": 142.970166, - "row_count": 5 - }, - { - "elapsed": 134.49625, - "row_count": 5 - }, - { - "elapsed": 135.5605, - "row_count": 5 - } - ], - "start_time": 1783521702, - "success": true - }, - { - "query": "Query 67", - "iterations": [ - { - "elapsed": 306.416583, - "row_count": 100 - }, - { - "elapsed": 313.14404099999996, - "row_count": 100 - }, - { - "elapsed": 313.352916, - "row_count": 100 - } - ], - "start_time": 1783521702, - "success": true - }, - { - "query": "Query 68", - "iterations": [ - { - "elapsed": 5.185582999999999, - "row_count": 0 - }, - { - "elapsed": 5.011833, - "row_count": 0 - }, - { - "elapsed": 4.644917, - "row_count": 0 - } - ], - "start_time": 1783521703, - "success": true - }, - { - "query": "Query 69", - "iterations": [ - { - "elapsed": 78.081, - "row_count": 100 - }, - { - "elapsed": 77.149542, - "row_count": 100 - }, - { - "elapsed": 76.93420900000001, - "row_count": 100 - } - ], - "start_time": 1783521703, - "success": true - }, - { - "query": "Query 70", - "iterations": [ - { - "elapsed": 220.682333, - "row_count": 3 - }, - { - "elapsed": 223.17275, - "row_count": 3 - }, - { - "elapsed": 224.474875, - "row_count": 3 - } - ], - "start_time": 1783521703, - "success": true - }, - { - "query": "Query 71", - "iterations": [ - { - "elapsed": 96.363708, - "row_count": 1102 - }, - { - "elapsed": 96.618416, - "row_count": 1102 - }, - { - "elapsed": 96.23825, - "row_count": 1102 - } - ], - "start_time": 1783521704, - "success": true - }, - { - "query": "Query 72", - "iterations": [ - { - "elapsed": 424.67925, - "row_count": 100 - }, - { - "elapsed": 409.80375000000004, - "row_count": 100 - }, - { - "elapsed": 409.832459, - "row_count": 100 - } - ], - "start_time": 1783521704, - "success": true - }, - { - "query": "Query 73", - "iterations": [ - { - "elapsed": 3.9355420000000003, - "row_count": 0 - }, - { - "elapsed": 3.644792, - "row_count": 0 - }, - { - "elapsed": 3.9336670000000002, - "row_count": 0 - } - ], - "start_time": 1783521706, - "success": true - }, - { - "query": "Query 74", - "iterations": [ - { - "elapsed": 346.756958, - "row_count": 90 - }, - { - "elapsed": 355.018625, - "row_count": 90 - }, - { - "elapsed": 369.07041699999996, - "row_count": 90 - } - ], - "start_time": 1783521706, - "success": true - }, - { - "query": "Query 75", - "iterations": [ - { - "elapsed": 211.343584, - "row_count": 100 - }, - { - "elapsed": 188.257, - "row_count": 100 - }, - { - "elapsed": 188.849375, - "row_count": 100 - } - ], - "start_time": 1783521707, - "success": true - }, - { - "query": "Query 76", - "iterations": [ - { - "elapsed": 91.033417, - "row_count": 100 - }, - { - "elapsed": 89.759542, - "row_count": 100 - }, - { - "elapsed": 90.940541, - "row_count": 100 - } - ], - "start_time": 1783521707, - "success": true - }, - { - "query": "Query 77", - "iterations": [ - { - "elapsed": 134.253625, - "row_count": 44 - }, - { - "elapsed": 133.53537500000002, - "row_count": 44 - }, - { - "elapsed": 134.37625, - "row_count": 44 - } - ], - "start_time": 1783521707, - "success": true - }, - { - "query": "Query 78", - "iterations": [ - { - "elapsed": 222.918375, - "row_count": 100 - }, - { - "elapsed": 223.480166, - "row_count": 100 - }, - { - "elapsed": 222.331, - "row_count": 100 - } - ], - "start_time": 1783521708, - "success": true - }, - { - "query": "Query 79", - "iterations": [ - { - "elapsed": 156.448, - "row_count": 100 - }, - { - "elapsed": 155.5225, - "row_count": 100 - }, - { - "elapsed": 159.88666600000002, - "row_count": 100 - } - ], - "start_time": 1783521709, - "success": true - }, - { - "query": "Query 80", - "iterations": [ - { - "elapsed": 212.6855, - "row_count": 100 - }, - { - "elapsed": 210.21816700000002, - "row_count": 100 - }, - { - "elapsed": 210.498834, - "row_count": 100 - } - ], - "start_time": 1783521709, - "success": true - }, - { - "query": "Query 81", - "iterations": [ - { - "elapsed": 16.412083000000003, - "row_count": 96 - }, - { - "elapsed": 16.630125, - "row_count": 96 - }, - { - "elapsed": 16.523166, - "row_count": 96 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 82", - "iterations": [ - { - "elapsed": 28.184041, - "row_count": 1 - }, - { - "elapsed": 28.490624999999998, - "row_count": 1 - }, - { - "elapsed": 28.374416, - "row_count": 1 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 83", - "iterations": [ - { - "elapsed": 23.28875, - "row_count": 4 - }, - { - "elapsed": 23.298083000000002, - "row_count": 4 - }, - { - "elapsed": 23.551041, - "row_count": 4 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 84", - "iterations": [ - { - "elapsed": 29.425542, - "row_count": 22 - }, - { - "elapsed": 29.919833, - "row_count": 22 - }, - { - "elapsed": 31.260958, - "row_count": 22 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 85", - "iterations": [ - { - "elapsed": 107.22125, - "row_count": 3 - }, - { - "elapsed": 105.810291, - "row_count": 3 - }, - { - "elapsed": 105.998958, - "row_count": 3 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 86", - "iterations": [ - { - "elapsed": 28.345, - "row_count": 100 - }, - { - "elapsed": 28.307917, - "row_count": 100 - }, - { - "elapsed": 28.841333, - "row_count": 100 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 87", - "iterations": [ - { - "elapsed": 88.434833, - "row_count": 1 - }, - { - "elapsed": 89.114209, - "row_count": 1 - }, - { - "elapsed": 88.0045, - "row_count": 1 - } - ], - "start_time": 1783521710, - "success": true - }, - { - "query": "Query 88", - "iterations": [ - { - "elapsed": 67.396541, - "row_count": 1 - }, - { - "elapsed": 65.206375, - "row_count": 1 - }, - { - "elapsed": 65.914833, - "row_count": 1 - } - ], - "start_time": 1783521711, - "success": true - }, - { - "query": "Query 89", - "iterations": [ - { - "elapsed": 84.49179199999999, - "row_count": 100 - }, - { - "elapsed": 85.78337499999999, - "row_count": 100 - }, - { - "elapsed": 85.05083300000001, - "row_count": 100 - } - ], - "start_time": 1783521711, - "success": true - }, - { - "query": "Query 90", - "iterations": [ - { - "elapsed": 14.134917, - "row_count": 1 - }, - { - "elapsed": 14.288375, - "row_count": 1 - }, - { - "elapsed": 13.961917000000001, - "row_count": 1 - } - ], - "start_time": 1783521711, - "success": true - }, - { - "query": "Query 91", - "iterations": [ - { - "elapsed": 43.964541000000004, - "row_count": 4 - }, - { - "elapsed": 43.25625, - "row_count": 4 - }, - { - "elapsed": 42.927791, - "row_count": 4 - } - ], - "start_time": 1783521711, - "success": true - }, - { - "query": "Query 92", - "iterations": [ - { - "elapsed": 41.044625, - "row_count": 1 - }, - { - "elapsed": 41.476666, - "row_count": 1 - }, - { - "elapsed": 41.761083, - "row_count": 1 - } - ], - "start_time": 1783521711, - "success": true - }, - { - "query": "Query 93", - "iterations": [ - { - "elapsed": 113.716333, - "row_count": 100 - }, - { - "elapsed": 109.940541, - "row_count": 100 - }, - { - "elapsed": 110.01441700000001, - "row_count": 100 - } - ], - "start_time": 1783521711, - "success": true - }, - { - "query": "Query 94", - "iterations": [ - { - "elapsed": 42.226082999999996, - "row_count": 1 - }, - { - "elapsed": 41.750375, - "row_count": 1 - }, - { - "elapsed": 42.425625000000004, - "row_count": 1 - } - ], - "start_time": 1783521712, - "success": true - }, - { - "query": "Query 95", - "iterations": [ - { - "elapsed": 55.699625000000005, - "row_count": 1 - }, - { - "elapsed": 56.908958000000005, - "row_count": 1 - }, - { - "elapsed": 55.745125, - "row_count": 1 - } - ], - "start_time": 1783521712, - "success": true - }, - { - "query": "Query 96", - "iterations": [ - { - "elapsed": 50.58, - "row_count": 1 - }, - { - "elapsed": 49.690708, - "row_count": 1 - }, - { - "elapsed": 50.009291999999995, - "row_count": 1 - } - ], - "start_time": 1783521712, - "success": true - }, - { - "query": "Query 97", - "iterations": [ - { - "elapsed": 81.737625, - "row_count": 1 - }, - { - "elapsed": 80.69525, - "row_count": 1 - }, - { - "elapsed": 81.893375, - "row_count": 1 - } - ], - "start_time": 1783521712, - "success": true - }, - { - "query": "Query 98", - "iterations": [ - { - "elapsed": 107.472916, - "row_count": 2486 - }, - { - "elapsed": 105.68416599999999, - "row_count": 2486 - }, - { - "elapsed": 107.526667, - "row_count": 2486 - } - ], - "start_time": 1783521712, - "success": true - }, - { - "query": "Query 99", - "iterations": [ - { - "elapsed": 4230.284917, - "row_count": 90 - }, - { - "elapsed": 4192.377209, - "row_count": 90 - }, - { - "elapsed": 4239.053084, - "row_count": 90 - } - ], - "start_time": 1783521713, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/tpcds_on_r2.json b/ab_results/tpcds_on_r2.json deleted file mode 100644 index 9cf8819159890..0000000000000 --- a/ab_results/tpcds_on_r2.json +++ /dev/null @@ -1,1891 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521777, - "arguments": [ - "tpcds", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpcds_sf1", - "--query_path", - "/Users/adrian/GitHub/datafusion/datafusion/core/tests/tpc-ds", - "--prefer_hash_join", - "true", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpcds_on_r2.json" - ] - }, - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 5.533583, - "row_count": 0 - }, - { - "elapsed": 3.704292, - "row_count": 0 - }, - { - "elapsed": 3.765209, - "row_count": 0 - } - ], - "start_time": 1783521777, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 101.31195799999999, - "row_count": 2513 - }, - { - "elapsed": 118.858, - "row_count": 2513 - }, - { - "elapsed": 111.984459, - "row_count": 2513 - } - ], - "start_time": 1783521777, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 86.036917, - "row_count": 38 - }, - { - "elapsed": 85.860083, - "row_count": 38 - }, - { - "elapsed": 83.86, - "row_count": 38 - } - ], - "start_time": 1783521778, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 887.956167, - "row_count": 8 - }, - { - "elapsed": 940.129541, - "row_count": 8 - }, - { - "elapsed": 907.008625, - "row_count": 8 - } - ], - "start_time": 1783521778, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 124.11504099999999, - "row_count": 100 - }, - { - "elapsed": 124.627459, - "row_count": 100 - }, - { - "elapsed": 126.77487500000001, - "row_count": 100 - } - ], - "start_time": 1783521781, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 89.33874999999999, - "row_count": 41 - }, - { - "elapsed": 89.73420899999999, - "row_count": 41 - }, - { - "elapsed": 87.981875, - "row_count": 41 - } - ], - "start_time": 1783521781, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 226.276541, - "row_count": 100 - }, - { - "elapsed": 223.550292, - "row_count": 100 - }, - { - "elapsed": 223.221167, - "row_count": 100 - } - ], - "start_time": 1783521781, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 82.048542, - "row_count": 0 - }, - { - "elapsed": 82.210583, - "row_count": 0 - }, - { - "elapsed": 83.03399999999999, - "row_count": 0 - } - ], - "start_time": 1783521782, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 87.391209, - "row_count": 1 - }, - { - "elapsed": 91.518917, - "row_count": 1 - }, - { - "elapsed": 101.34162500000001, - "row_count": 1 - } - ], - "start_time": 1783521782, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 87.382125, - "row_count": 2 - }, - { - "elapsed": 88.217458, - "row_count": 2 - }, - { - "elapsed": 88.37337500000001, - "row_count": 2 - } - ], - "start_time": 1783521782, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 589.3940829999999, - "row_count": 88 - }, - { - "elapsed": 575.1632500000001, - "row_count": 88 - }, - { - "elapsed": 569.699667, - "row_count": 88 - } - ], - "start_time": 1783521783, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 30.790208, - "row_count": 100 - }, - { - "elapsed": 30.01475, - "row_count": 100 - }, - { - "elapsed": 30.047958, - "row_count": 100 - } - ], - "start_time": 1783521784, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 274.31149999999997, - "row_count": 1 - }, - { - "elapsed": 275.582416, - "row_count": 1 - }, - { - "elapsed": 276.92920799999996, - "row_count": 1 - } - ], - "start_time": 1783521785, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 757.513375, - "row_count": 100 - }, - { - "elapsed": 758.030541, - "row_count": 100 - }, - { - "elapsed": 760.844875, - "row_count": 100 - } - ], - "start_time": 1783521785, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 11.329291, - "row_count": 100 - }, - { - "elapsed": 10.549083000000001, - "row_count": 100 - }, - { - "elapsed": 10.311582999999999, - "row_count": 100 - } - ], - "start_time": 1783521788, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 4.630584, - "row_count": 1 - }, - { - "elapsed": 4.030708, - "row_count": 1 - }, - { - "elapsed": 4.07925, - "row_count": 1 - } - ], - "start_time": 1783521788, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 136.115125, - "row_count": 1 - }, - { - "elapsed": 133.737209, - "row_count": 1 - }, - { - "elapsed": 134.402083, - "row_count": 1 - } - ], - "start_time": 1783521788, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 92.613208, - "row_count": 100 - }, - { - "elapsed": 90.72562500000001, - "row_count": 100 - }, - { - "elapsed": 93.281958, - "row_count": 100 - } - ], - "start_time": 1783521788, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 110.482, - "row_count": 100 - }, - { - "elapsed": 112.380708, - "row_count": 100 - }, - { - "elapsed": 111.30862499999999, - "row_count": 100 - } - ], - "start_time": 1783521788, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 8.670541, - "row_count": 100 - }, - { - "elapsed": 8.688833, - "row_count": 100 - }, - { - "elapsed": 8.627875, - "row_count": 100 - } - ], - "start_time": 1783521789, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 11.09425, - "row_count": 100 - }, - { - "elapsed": 11.140583000000001, - "row_count": 100 - }, - { - "elapsed": 11.156083, - "row_count": 100 - } - ], - "start_time": 1783521789, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 259.171208, - "row_count": 100 - }, - { - "elapsed": 257.850125, - "row_count": 100 - }, - { - "elapsed": 260.034042, - "row_count": 100 - } - ], - "start_time": 1783521789, - "success": true - }, - { - "query": "Query 23", - "iterations": [ - { - "elapsed": 519.405708, - "row_count": 0 - }, - { - "elapsed": 517.973625, - "row_count": 0 - }, - { - "elapsed": 521.3017920000001, - "row_count": 0 - } - ], - "start_time": 1783521790, - "success": true - }, - { - "query": "Query 24", - "iterations": [ - { - "elapsed": 427.794667, - "row_count": 0 - }, - { - "elapsed": 421.783167, - "row_count": 0 - }, - { - "elapsed": 425.042458, - "row_count": 0 - } - ], - "start_time": 1783521791, - "success": true - }, - { - "query": "Query 25", - "iterations": [ - { - "elapsed": 170.95125, - "row_count": 0 - }, - { - "elapsed": 167.613125, - "row_count": 0 - }, - { - "elapsed": 167.967708, - "row_count": 0 - } - ], - "start_time": 1783521792, - "success": true - }, - { - "query": "Query 26", - "iterations": [ - { - "elapsed": 52.990041000000005, - "row_count": 100 - }, - { - "elapsed": 52.562292, - "row_count": 100 - }, - { - "elapsed": 52.048166, - "row_count": 100 - } - ], - "start_time": 1783521793, - "success": true - }, - { - "query": "Query 27", - "iterations": [ - { - "elapsed": 3.9410410000000002, - "row_count": 1 - }, - { - "elapsed": 3.689708, - "row_count": 1 - }, - { - "elapsed": 3.388375, - "row_count": 1 - } - ], - "start_time": 1783521793, - "success": true - }, - { - "query": "Query 28", - "iterations": [ - { - "elapsed": 102.61175, - "row_count": 1 - }, - { - "elapsed": 103.745917, - "row_count": 1 - }, - { - "elapsed": 104.06375, - "row_count": 1 - } - ], - "start_time": 1783521793, - "success": true - }, - { - "query": "Query 29", - "iterations": [ - { - "elapsed": 168.71604200000002, - "row_count": 0 - }, - { - "elapsed": 164.501333, - "row_count": 0 - }, - { - "elapsed": 162.86012499999998, - "row_count": 0 - } - ], - "start_time": 1783521793, - "success": true - }, - { - "query": "Query 30", - "iterations": [], - "start_time": 1783521794, - "success": false - }, - { - "query": "Query 31", - "iterations": [ - { - "elapsed": 115.7615, - "row_count": 51 - }, - { - "elapsed": 116.012666, - "row_count": 51 - }, - { - "elapsed": 115.29845800000001, - "row_count": 51 - } - ], - "start_time": 1783521794, - "success": true - }, - { - "query": "Query 32", - "iterations": [ - { - "elapsed": 8.958125, - "row_count": 1 - }, - { - "elapsed": 8.209375, - "row_count": 1 - }, - { - "elapsed": 8.689834000000001, - "row_count": 1 - } - ], - "start_time": 1783521794, - "success": true - }, - { - "query": "Query 33", - "iterations": [ - { - "elapsed": 98.966875, - "row_count": 100 - }, - { - "elapsed": 99.96712500000001, - "row_count": 100 - }, - { - "elapsed": 99.808875, - "row_count": 100 - } - ], - "start_time": 1783521794, - "success": true - }, - { - "query": "Query 34", - "iterations": [ - { - "elapsed": 3.9163749999999995, - "row_count": 0 - }, - { - "elapsed": 4.290417000000001, - "row_count": 0 - }, - { - "elapsed": 3.780833, - "row_count": 0 - } - ], - "start_time": 1783521794, - "success": true - }, - { - "query": "Query 35", - "iterations": [ - { - "elapsed": 95.78629099999999, - "row_count": 100 - }, - { - "elapsed": 96.646167, - "row_count": 100 - }, - { - "elapsed": 97.29425, - "row_count": 100 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 36", - "iterations": [ - { - "elapsed": 3.7439169999999997, - "row_count": 1 - }, - { - "elapsed": 3.751625, - "row_count": 1 - }, - { - "elapsed": 3.652125, - "row_count": 1 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 37", - "iterations": [ - { - "elapsed": 5.497459, - "row_count": 0 - }, - { - "elapsed": 5.13575, - "row_count": 0 - }, - { - "elapsed": 5.134708, - "row_count": 0 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 38", - "iterations": [ - { - "elapsed": 85.63550000000001, - "row_count": 1 - }, - { - "elapsed": 87.071917, - "row_count": 1 - }, - { - "elapsed": 87.628, - "row_count": 1 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 39", - "iterations": [ - { - "elapsed": 51.772459, - "row_count": 7 - }, - { - "elapsed": 53.154333, - "row_count": 7 - }, - { - "elapsed": 52.704125, - "row_count": 7 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 40", - "iterations": [ - { - "elapsed": 69.818125, - "row_count": 100 - }, - { - "elapsed": 83.319291, - "row_count": 100 - }, - { - "elapsed": 65.587959, - "row_count": 100 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 41", - "iterations": [ - { - "elapsed": 9.12875, - "row_count": 0 - }, - { - "elapsed": 8.826, - "row_count": 0 - }, - { - "elapsed": 8.879708, - "row_count": 0 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 42", - "iterations": [ - { - "elapsed": 79.684083, - "row_count": 10 - }, - { - "elapsed": 79.878542, - "row_count": 10 - }, - { - "elapsed": 80.134041, - "row_count": 10 - } - ], - "start_time": 1783521795, - "success": true - }, - { - "query": "Query 43", - "iterations": [ - { - "elapsed": 3.2904169999999997, - "row_count": 0 - }, - { - "elapsed": 2.993, - "row_count": 0 - }, - { - "elapsed": 3.10025, - "row_count": 0 - } - ], - "start_time": 1783521796, - "success": true - }, - { - "query": "Query 44", - "iterations": [ - { - "elapsed": 4.866167, - "row_count": 0 - }, - { - "elapsed": 4.778250000000001, - "row_count": 0 - }, - { - "elapsed": 4.616625, - "row_count": 0 - } - ], - "start_time": 1783521796, - "success": true - }, - { - "query": "Query 45", - "iterations": [ - { - "elapsed": 31.173709000000002, - "row_count": 16 - }, - { - "elapsed": 30.766292, - "row_count": 16 - }, - { - "elapsed": 30.636459000000002, - "row_count": 16 - } - ], - "start_time": 1783521796, - "success": true - }, - { - "query": "Query 46", - "iterations": [ - { - "elapsed": 4.834292, - "row_count": 0 - }, - { - "elapsed": 4.584459, - "row_count": 0 - }, - { - "elapsed": 4.4100839999999994, - "row_count": 0 - } - ], - "start_time": 1783521796, - "success": true - }, - { - "query": "Query 47", - "iterations": [ - { - "elapsed": 428.428084, - "row_count": 100 - }, - { - "elapsed": 435.96212499999996, - "row_count": 100 - }, - { - "elapsed": 428.84299999999996, - "row_count": 100 - } - ], - "start_time": 1783521796, - "success": true - }, - { - "query": "Query 48", - "iterations": [ - { - "elapsed": 196.267167, - "row_count": 1 - }, - { - "elapsed": 195.39379200000002, - "row_count": 1 - }, - { - "elapsed": 194.758625, - "row_count": 1 - } - ], - "start_time": 1783521797, - "success": true - }, - { - "query": "Query 49", - "iterations": [ - { - "elapsed": 167.7655, - "row_count": 31 - }, - { - "elapsed": 166.823292, - "row_count": 31 - }, - { - "elapsed": 166.96291699999998, - "row_count": 31 - } - ], - "start_time": 1783521798, - "success": true - }, - { - "query": "Query 50", - "iterations": [ - { - "elapsed": 125.708458, - "row_count": 6 - }, - { - "elapsed": 120.504333, - "row_count": 6 - }, - { - "elapsed": 118.470334, - "row_count": 6 - } - ], - "start_time": 1783521798, - "success": true - }, - { - "query": "Query 51", - "iterations": [ - { - "elapsed": 117.209792, - "row_count": 100 - }, - { - "elapsed": 116.249875, - "row_count": 100 - }, - { - "elapsed": 118.09308300000001, - "row_count": 100 - } - ], - "start_time": 1783521799, - "success": true - }, - { - "query": "Query 52", - "iterations": [ - { - "elapsed": 80.307959, - "row_count": 100 - }, - { - "elapsed": 80.249166, - "row_count": 100 - }, - { - "elapsed": 79.882708, - "row_count": 100 - } - ], - "start_time": 1783521799, - "success": true - }, - { - "query": "Query 53", - "iterations": [ - { - "elapsed": 73.918667, - "row_count": 14 - }, - { - "elapsed": 73.21775, - "row_count": 14 - }, - { - "elapsed": 76.746375, - "row_count": 14 - } - ], - "start_time": 1783521799, - "success": true - }, - { - "query": "Query 54", - "iterations": [ - { - "elapsed": 102.18325, - "row_count": 0 - }, - { - "elapsed": 103.68508299999999, - "row_count": 0 - }, - { - "elapsed": 102.224583, - "row_count": 0 - } - ], - "start_time": 1783521799, - "success": true - }, - { - "query": "Query 55", - "iterations": [ - { - "elapsed": 79.514667, - "row_count": 69 - }, - { - "elapsed": 79.673125, - "row_count": 69 - }, - { - "elapsed": 79.73912499999999, - "row_count": 69 - } - ], - "start_time": 1783521800, - "success": true - }, - { - "query": "Query 56", - "iterations": [ - { - "elapsed": 99.166084, - "row_count": 78 - }, - { - "elapsed": 99.362541, - "row_count": 78 - }, - { - "elapsed": 99.8615, - "row_count": 78 - } - ], - "start_time": 1783521800, - "success": true - }, - { - "query": "Query 57", - "iterations": [ - { - "elapsed": 105.533792, - "row_count": 100 - }, - { - "elapsed": 104.964583, - "row_count": 100 - }, - { - "elapsed": 104.24591699999999, - "row_count": 100 - } - ], - "start_time": 1783521800, - "success": true - }, - { - "query": "Query 58", - "iterations": [ - { - "elapsed": 197.116, - "row_count": 0 - }, - { - "elapsed": 198.846208, - "row_count": 0 - }, - { - "elapsed": 197.56370900000002, - "row_count": 0 - } - ], - "start_time": 1783521801, - "success": true - }, - { - "query": "Query 59", - "iterations": [ - { - "elapsed": 123.737333, - "row_count": 100 - }, - { - "elapsed": 143.18975, - "row_count": 100 - }, - { - "elapsed": 125.226042, - "row_count": 100 - } - ], - "start_time": 1783521801, - "success": true - }, - { - "query": "Query 60", - "iterations": [ - { - "elapsed": 99.803583, - "row_count": 100 - }, - { - "elapsed": 101.244625, - "row_count": 100 - }, - { - "elapsed": 99.348125, - "row_count": 100 - } - ], - "start_time": 1783521802, - "success": true - }, - { - "query": "Query 61", - "iterations": [ - { - "elapsed": 7.541084, - "row_count": 1 - }, - { - "elapsed": 7.132875, - "row_count": 1 - }, - { - "elapsed": 6.870084, - "row_count": 1 - } - ], - "start_time": 1783521802, - "success": true - }, - { - "query": "Query 62", - "iterations": [ - { - "elapsed": 371.33337500000005, - "row_count": 100 - }, - { - "elapsed": 361.565334, - "row_count": 100 - }, - { - "elapsed": 360.176125, - "row_count": 100 - } - ], - "start_time": 1783521802, - "success": true - }, - { - "query": "Query 63", - "iterations": [ - { - "elapsed": 73.317875, - "row_count": 44 - }, - { - "elapsed": 73.250667, - "row_count": 44 - }, - { - "elapsed": 77.40558300000001, - "row_count": 44 - } - ], - "start_time": 1783521803, - "success": true - }, - { - "query": "Query 64", - "iterations": [ - { - "elapsed": 452.63608300000004, - "row_count": 10 - }, - { - "elapsed": 436.86504199999996, - "row_count": 10 - }, - { - "elapsed": 436.507166, - "row_count": 10 - } - ], - "start_time": 1783521803, - "success": true - }, - { - "query": "Query 65", - "iterations": [ - { - "elapsed": 169.247708, - "row_count": 100 - }, - { - "elapsed": 168.922917, - "row_count": 100 - }, - { - "elapsed": 166.741333, - "row_count": 100 - } - ], - "start_time": 1783521805, - "success": true - }, - { - "query": "Query 66", - "iterations": [ - { - "elapsed": 141.208292, - "row_count": 5 - }, - { - "elapsed": 145.106459, - "row_count": 5 - }, - { - "elapsed": 139.79625000000001, - "row_count": 5 - } - ], - "start_time": 1783521805, - "success": true - }, - { - "query": "Query 67", - "iterations": [ - { - "elapsed": 302.92291700000004, - "row_count": 100 - }, - { - "elapsed": 308.70133300000003, - "row_count": 100 - }, - { - "elapsed": 321.21812500000004, - "row_count": 100 - } - ], - "start_time": 1783521805, - "success": true - }, - { - "query": "Query 68", - "iterations": [ - { - "elapsed": 5.093292, - "row_count": 0 - }, - { - "elapsed": 4.9243749999999995, - "row_count": 0 - }, - { - "elapsed": 4.871, - "row_count": 0 - } - ], - "start_time": 1783521806, - "success": true - }, - { - "query": "Query 69", - "iterations": [ - { - "elapsed": 76.476292, - "row_count": 100 - }, - { - "elapsed": 77.589084, - "row_count": 100 - }, - { - "elapsed": 79.041375, - "row_count": 100 - } - ], - "start_time": 1783521806, - "success": true - }, - { - "query": "Query 70", - "iterations": [ - { - "elapsed": 221.24675, - "row_count": 3 - }, - { - "elapsed": 216.415917, - "row_count": 3 - }, - { - "elapsed": 220.60766700000002, - "row_count": 3 - } - ], - "start_time": 1783521807, - "success": true - }, - { - "query": "Query 71", - "iterations": [ - { - "elapsed": 98.17654200000001, - "row_count": 1102 - }, - { - "elapsed": 96.141791, - "row_count": 1102 - }, - { - "elapsed": 94.747084, - "row_count": 1102 - } - ], - "start_time": 1783521807, - "success": true - }, - { - "query": "Query 72", - "iterations": [ - { - "elapsed": 455.37041700000003, - "row_count": 100 - }, - { - "elapsed": 431.05850000000004, - "row_count": 100 - }, - { - "elapsed": 451.86041700000004, - "row_count": 100 - } - ], - "start_time": 1783521808, - "success": true - }, - { - "query": "Query 73", - "iterations": [ - { - "elapsed": 4.677125, - "row_count": 0 - }, - { - "elapsed": 4.337958, - "row_count": 0 - }, - { - "elapsed": 4.255375, - "row_count": 0 - } - ], - "start_time": 1783521809, - "success": true - }, - { - "query": "Query 74", - "iterations": [ - { - "elapsed": 353.996292, - "row_count": 90 - }, - { - "elapsed": 355.61120800000003, - "row_count": 90 - }, - { - "elapsed": 347.82408300000003, - "row_count": 90 - } - ], - "start_time": 1783521809, - "success": true - }, - { - "query": "Query 75", - "iterations": [ - { - "elapsed": 190.77658399999999, - "row_count": 100 - }, - { - "elapsed": 189.115167, - "row_count": 100 - }, - { - "elapsed": 192.005666, - "row_count": 100 - } - ], - "start_time": 1783521810, - "success": true - }, - { - "query": "Query 76", - "iterations": [ - { - "elapsed": 91.158084, - "row_count": 100 - }, - { - "elapsed": 92.218459, - "row_count": 100 - }, - { - "elapsed": 91.48266600000001, - "row_count": 100 - } - ], - "start_time": 1783521811, - "success": true - }, - { - "query": "Query 77", - "iterations": [ - { - "elapsed": 135.36075, - "row_count": 44 - }, - { - "elapsed": 135.06354100000001, - "row_count": 44 - }, - { - "elapsed": 136.2185, - "row_count": 44 - } - ], - "start_time": 1783521811, - "success": true - }, - { - "query": "Query 78", - "iterations": [ - { - "elapsed": 226.816542, - "row_count": 100 - }, - { - "elapsed": 225.357042, - "row_count": 100 - }, - { - "elapsed": 228.267959, - "row_count": 100 - } - ], - "start_time": 1783521811, - "success": true - }, - { - "query": "Query 79", - "iterations": [ - { - "elapsed": 159.812042, - "row_count": 100 - }, - { - "elapsed": 156.60708400000001, - "row_count": 100 - }, - { - "elapsed": 176.886459, - "row_count": 100 - } - ], - "start_time": 1783521812, - "success": true - }, - { - "query": "Query 80", - "iterations": [ - { - "elapsed": 216.506583, - "row_count": 100 - }, - { - "elapsed": 214.081041, - "row_count": 100 - }, - { - "elapsed": 213.223166, - "row_count": 100 - } - ], - "start_time": 1783521812, - "success": true - }, - { - "query": "Query 81", - "iterations": [ - { - "elapsed": 16.60625, - "row_count": 96 - }, - { - "elapsed": 16.293417, - "row_count": 96 - }, - { - "elapsed": 17.295499999999997, - "row_count": 96 - } - ], - "start_time": 1783521813, - "success": true - }, - { - "query": "Query 82", - "iterations": [ - { - "elapsed": 28.223583, - "row_count": 1 - }, - { - "elapsed": 28.294708, - "row_count": 1 - }, - { - "elapsed": 28.467167, - "row_count": 1 - } - ], - "start_time": 1783521813, - "success": true - }, - { - "query": "Query 83", - "iterations": [ - { - "elapsed": 24.374041, - "row_count": 4 - }, - { - "elapsed": 23.420083, - "row_count": 4 - }, - { - "elapsed": 23.920292, - "row_count": 4 - } - ], - "start_time": 1783521813, - "success": true - }, - { - "query": "Query 84", - "iterations": [ - { - "elapsed": 29.511665999999998, - "row_count": 22 - }, - { - "elapsed": 29.402749999999997, - "row_count": 22 - }, - { - "elapsed": 29.329166999999998, - "row_count": 22 - } - ], - "start_time": 1783521813, - "success": true - }, - { - "query": "Query 85", - "iterations": [ - { - "elapsed": 108.797292, - "row_count": 3 - }, - { - "elapsed": 106.18225000000001, - "row_count": 3 - }, - { - "elapsed": 105.327, - "row_count": 3 - } - ], - "start_time": 1783521813, - "success": true - }, - { - "query": "Query 86", - "iterations": [ - { - "elapsed": 28.772167, - "row_count": 100 - }, - { - "elapsed": 28.352249999999998, - "row_count": 100 - }, - { - "elapsed": 28.785708, - "row_count": 100 - } - ], - "start_time": 1783521814, - "success": true - }, - { - "query": "Query 87", - "iterations": [ - { - "elapsed": 89.42224999999999, - "row_count": 1 - }, - { - "elapsed": 89.93433300000001, - "row_count": 1 - }, - { - "elapsed": 89.489625, - "row_count": 1 - } - ], - "start_time": 1783521814, - "success": true - }, - { - "query": "Query 88", - "iterations": [ - { - "elapsed": 70.73733299999999, - "row_count": 1 - }, - { - "elapsed": 68.876042, - "row_count": 1 - }, - { - "elapsed": 68.81845799999999, - "row_count": 1 - } - ], - "start_time": 1783521814, - "success": true - }, - { - "query": "Query 89", - "iterations": [ - { - "elapsed": 84.655833, - "row_count": 100 - }, - { - "elapsed": 83.75316600000001, - "row_count": 100 - }, - { - "elapsed": 86.591583, - "row_count": 100 - } - ], - "start_time": 1783521814, - "success": true - }, - { - "query": "Query 90", - "iterations": [ - { - "elapsed": 13.7295, - "row_count": 1 - }, - { - "elapsed": 14.272458, - "row_count": 1 - }, - { - "elapsed": 14.617916, - "row_count": 1 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 91", - "iterations": [ - { - "elapsed": 44.3835, - "row_count": 4 - }, - { - "elapsed": 44.994208, - "row_count": 4 - }, - { - "elapsed": 43.934374999999996, - "row_count": 4 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 92", - "iterations": [ - { - "elapsed": 40.94125, - "row_count": 1 - }, - { - "elapsed": 40.576833, - "row_count": 1 - }, - { - "elapsed": 40.4365, - "row_count": 1 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 93", - "iterations": [ - { - "elapsed": 110.903584, - "row_count": 100 - }, - { - "elapsed": 109.453917, - "row_count": 100 - }, - { - "elapsed": 111.966458, - "row_count": 100 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 94", - "iterations": [ - { - "elapsed": 42.078042, - "row_count": 1 - }, - { - "elapsed": 41.579584000000004, - "row_count": 1 - }, - { - "elapsed": 41.694709, - "row_count": 1 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 95", - "iterations": [ - { - "elapsed": 57.626292, - "row_count": 1 - }, - { - "elapsed": 56.596374999999995, - "row_count": 1 - }, - { - "elapsed": 56.497208, - "row_count": 1 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 96", - "iterations": [ - { - "elapsed": 51.429375, - "row_count": 1 - }, - { - "elapsed": 50.987792, - "row_count": 1 - }, - { - "elapsed": 49.728625, - "row_count": 1 - } - ], - "start_time": 1783521815, - "success": true - }, - { - "query": "Query 97", - "iterations": [ - { - "elapsed": 82.394958, - "row_count": 1 - }, - { - "elapsed": 81.08375, - "row_count": 1 - }, - { - "elapsed": 80.45566699999999, - "row_count": 1 - } - ], - "start_time": 1783521816, - "success": true - }, - { - "query": "Query 98", - "iterations": [ - { - "elapsed": 105.294, - "row_count": 2486 - }, - { - "elapsed": 106.360541, - "row_count": 2486 - }, - { - "elapsed": 112.674625, - "row_count": 2486 - } - ], - "start_time": 1783521816, - "success": true - }, - { - "query": "Query 99", - "iterations": [ - { - "elapsed": 4203.855, - "row_count": 90 - }, - { - "elapsed": 4240.967957999999, - "row_count": 90 - }, - { - "elapsed": 4224.1549589999995, - "row_count": 90 - } - ], - "start_time": 1783521816, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/tpch_off_r1.json b/ab_results/tpch_off_r1.json deleted file mode 100644 index 28aa9a944062c..0000000000000 --- a/ab_results/tpch_off_r1.json +++ /dev/null @@ -1,439 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521310, - "arguments": [ - "tpch", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", - "--format", - "parquet", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpch_off_r1.json" - ] - }, - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 110.54849999999999, - "row_count": 4 - }, - { - "elapsed": 36.885834, - "row_count": 4 - }, - { - "elapsed": 41.085833, - "row_count": 4 - } - ], - "start_time": 1783521310, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 24.111082999999997, - "row_count": 100 - }, - { - "elapsed": 12.894792, - "row_count": 100 - }, - { - "elapsed": 12.939667, - "row_count": 100 - } - ], - "start_time": 1783521310, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 32.227375, - "row_count": 10 - }, - { - "elapsed": 27.691208, - "row_count": 10 - }, - { - "elapsed": 27.788416, - "row_count": 10 - } - ], - "start_time": 1783521310, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 17.539709000000002, - "row_count": 5 - }, - { - "elapsed": 14.585125000000001, - "row_count": 5 - }, - { - "elapsed": 13.837333000000001, - "row_count": 5 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 37.685334, - "row_count": 5 - }, - { - "elapsed": 36.991875, - "row_count": 5 - }, - { - "elapsed": 33.957542000000004, - "row_count": 5 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 16.361625, - "row_count": 1 - }, - { - "elapsed": 14.569875, - "row_count": 1 - }, - { - "elapsed": 14.420292, - "row_count": 1 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 41.510416, - "row_count": 4 - }, - { - "elapsed": 38.166667000000004, - "row_count": 4 - }, - { - "elapsed": 37.174709, - "row_count": 4 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 35.592292, - "row_count": 2 - }, - { - "elapsed": 34.295583, - "row_count": 2 - }, - { - "elapsed": 36.197708, - "row_count": 2 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 65.762041, - "row_count": 175 - }, - { - "elapsed": 65.088542, - "row_count": 175 - }, - { - "elapsed": 56.015541, - "row_count": 175 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 39.812374999999996, - "row_count": 20 - }, - { - "elapsed": 36.430333000000005, - "row_count": 20 - }, - { - "elapsed": 34.229083, - "row_count": 20 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 12.102583, - "row_count": 1048 - }, - { - "elapsed": 9.070208, - "row_count": 1048 - }, - { - "elapsed": 8.647708, - "row_count": 1048 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 24.071875, - "row_count": 2 - }, - { - "elapsed": 23.031, - "row_count": 2 - }, - { - "elapsed": 20.997999999999998, - "row_count": 2 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 26.464416, - "row_count": 42 - }, - { - "elapsed": 22.484583, - "row_count": 42 - }, - { - "elapsed": 25.499750000000002, - "row_count": 42 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 19.712375, - "row_count": 1 - }, - { - "elapsed": 18.741917, - "row_count": 1 - }, - { - "elapsed": 18.614791, - "row_count": 1 - } - ], - "start_time": 1783521311, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 27.274542, - "row_count": 1 - }, - { - "elapsed": 24.367458000000003, - "row_count": 1 - }, - { - "elapsed": 24.154374999999998, - "row_count": 1 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 10.971292, - "row_count": 18314 - }, - { - "elapsed": 9.821, - "row_count": 18314 - }, - { - "elapsed": 10.016041999999999, - "row_count": 18314 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 70.416791, - "row_count": 1 - }, - { - "elapsed": 67.586708, - "row_count": 1 - }, - { - "elapsed": 74.264167, - "row_count": 1 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 67.777833, - "row_count": 57 - }, - { - "elapsed": 56.593667, - "row_count": 57 - }, - { - "elapsed": 69.01, - "row_count": 57 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 40.387708, - "row_count": 1 - }, - { - "elapsed": 41.666833, - "row_count": 1 - }, - { - "elapsed": 63.5235, - "row_count": 1 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 45.216083, - "row_count": 186 - }, - { - "elapsed": 32.860958000000004, - "row_count": 186 - }, - { - "elapsed": 26.201999999999998, - "row_count": 186 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 51.335542, - "row_count": 100 - }, - { - "elapsed": 48.971959000000005, - "row_count": 100 - }, - { - "elapsed": 49.1815, - "row_count": 100 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 10.092583000000001, - "row_count": 7 - }, - { - "elapsed": 9.038417, - "row_count": 7 - }, - { - "elapsed": 9.489167, - "row_count": 7 - } - ], - "start_time": 1783521312, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/tpch_off_r2.json b/ab_results/tpch_off_r2.json deleted file mode 100644 index 23ac3cd15f490..0000000000000 --- a/ab_results/tpch_off_r2.json +++ /dev/null @@ -1,439 +0,0 @@ -{ - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 45.665709, - "row_count": 4 - }, - { - "elapsed": 45.714749999999995, - "row_count": 4 - }, - { - "elapsed": 44.746125, - "row_count": 4 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 13.042166, - "row_count": 100 - }, - { - "elapsed": 12.457125, - "row_count": 100 - }, - { - "elapsed": 11.963792, - "row_count": 100 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 27.089875, - "row_count": 10 - }, - { - "elapsed": 27.930042, - "row_count": 10 - }, - { - "elapsed": 30.048, - "row_count": 10 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 17.170875, - "row_count": 5 - }, - { - "elapsed": 15.956042, - "row_count": 5 - }, - { - "elapsed": 17.919166999999998, - "row_count": 5 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 39.251374999999996, - "row_count": 5 - }, - { - "elapsed": 40.0195, - "row_count": 5 - }, - { - "elapsed": 38.990834, - "row_count": 5 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 15.469792, - "row_count": 1 - }, - { - "elapsed": 16.045834, - "row_count": 1 - }, - { - "elapsed": 18.06775, - "row_count": 1 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 46.156667, - "row_count": 4 - }, - { - "elapsed": 42.547583, - "row_count": 4 - }, - { - "elapsed": 43.045583, - "row_count": 4 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 42.312083, - "row_count": 2 - }, - { - "elapsed": 34.721125, - "row_count": 2 - }, - { - "elapsed": 37.059792, - "row_count": 2 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 50.415709, - "row_count": 175 - }, - { - "elapsed": 43.980667000000004, - "row_count": 175 - }, - { - "elapsed": 43.940542, - "row_count": 175 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 33.500875, - "row_count": 20 - }, - { - "elapsed": 33.834625, - "row_count": 20 - }, - { - "elapsed": 33.731457999999996, - "row_count": 20 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 9.224833, - "row_count": 1048 - }, - { - "elapsed": 8.609833, - "row_count": 1048 - }, - { - "elapsed": 8.695958000000001, - "row_count": 1048 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 21.183875, - "row_count": 2 - }, - { - "elapsed": 21.92675, - "row_count": 2 - }, - { - "elapsed": 22.681917, - "row_count": 2 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 27.512083, - "row_count": 42 - }, - { - "elapsed": 58.30175, - "row_count": 42 - }, - { - "elapsed": 30.489458, - "row_count": 42 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 21.81375, - "row_count": 1 - }, - { - "elapsed": 20.650624999999998, - "row_count": 1 - }, - { - "elapsed": 25.382208, - "row_count": 1 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 31.057458999999998, - "row_count": 1 - }, - { - "elapsed": 30.987541, - "row_count": 1 - }, - { - "elapsed": 26.480541, - "row_count": 1 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 10.787625, - "row_count": 18314 - }, - { - "elapsed": 9.677375, - "row_count": 18314 - }, - { - "elapsed": 9.757584, - "row_count": 18314 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 65.53108300000001, - "row_count": 1 - }, - { - "elapsed": 65.263167, - "row_count": 1 - }, - { - "elapsed": 67.612875, - "row_count": 1 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 66.420458, - "row_count": 57 - }, - { - "elapsed": 59.410833000000004, - "row_count": 57 - }, - { - "elapsed": 58.072625, - "row_count": 57 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 30.020875, - "row_count": 1 - }, - { - "elapsed": 27.768583, - "row_count": 1 - }, - { - "elapsed": 26.663542, - "row_count": 1 - } - ], - "start_time": 1783521316, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 27.047, - "row_count": 186 - }, - { - "elapsed": 25.074375, - "row_count": 186 - }, - { - "elapsed": 25.325208, - "row_count": 186 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 52.275, - "row_count": 100 - }, - { - "elapsed": 48.867667, - "row_count": 100 - }, - { - "elapsed": 51.776583, - "row_count": 100 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 10.052041, - "row_count": 7 - }, - { - "elapsed": 9.402458000000001, - "row_count": 7 - }, - { - "elapsed": 9.503582999999999, - "row_count": 7 - } - ], - "start_time": 1783521317, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521315, - "arguments": [ - "tpch", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", - "--format", - "parquet", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpch_off_r2.json" - ] - } -} \ No newline at end of file diff --git a/ab_results/tpch_on_r1.json b/ab_results/tpch_on_r1.json deleted file mode 100644 index d1280011ea82a..0000000000000 --- a/ab_results/tpch_on_r1.json +++ /dev/null @@ -1,439 +0,0 @@ -{ - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521312, - "arguments": [ - "tpch", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", - "--format", - "parquet", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpch_on_r1.json" - ] - }, - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 42.9765, - "row_count": 4 - }, - { - "elapsed": 40.096, - "row_count": 4 - }, - { - "elapsed": 39.238417, - "row_count": 4 - } - ], - "start_time": 1783521312, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 12.687458000000001, - "row_count": 100 - }, - { - "elapsed": 13.363875, - "row_count": 100 - }, - { - "elapsed": 12.671167, - "row_count": 100 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 28.704917, - "row_count": 10 - }, - { - "elapsed": 28.578083, - "row_count": 10 - }, - { - "elapsed": 26.979208, - "row_count": 10 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 14.917875, - "row_count": 5 - }, - { - "elapsed": 14.827292, - "row_count": 5 - }, - { - "elapsed": 14.050999999999998, - "row_count": 5 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 36.79024999999999, - "row_count": 5 - }, - { - "elapsed": 48.600208, - "row_count": 5 - }, - { - "elapsed": 38.700625, - "row_count": 5 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 17.64725, - "row_count": 1 - }, - { - "elapsed": 17.879208000000002, - "row_count": 1 - }, - { - "elapsed": 14.697166, - "row_count": 1 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 50.899, - "row_count": 4 - }, - { - "elapsed": 50.782374999999995, - "row_count": 4 - }, - { - "elapsed": 46.96975, - "row_count": 4 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 40.016667, - "row_count": 2 - }, - { - "elapsed": 44.013459, - "row_count": 2 - }, - { - "elapsed": 40.014165999999996, - "row_count": 2 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 50.37425, - "row_count": 175 - }, - { - "elapsed": 44.983834, - "row_count": 175 - }, - { - "elapsed": 46.929, - "row_count": 175 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 42.641625000000005, - "row_count": 20 - }, - { - "elapsed": 63.963375000000006, - "row_count": 20 - }, - { - "elapsed": 39.953375, - "row_count": 20 - } - ], - "start_time": 1783521313, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 9.902208, - "row_count": 1048 - }, - { - "elapsed": 12.069666999999999, - "row_count": 1048 - }, - { - "elapsed": 10.495792, - "row_count": 1048 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 29.683666000000002, - "row_count": 2 - }, - { - "elapsed": 30.192542, - "row_count": 2 - }, - { - "elapsed": 30.58, - "row_count": 2 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 28.288708, - "row_count": 42 - }, - { - "elapsed": 28.846875, - "row_count": 42 - }, - { - "elapsed": 34.543917, - "row_count": 42 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 24.067208, - "row_count": 1 - }, - { - "elapsed": 21.468833999999998, - "row_count": 1 - }, - { - "elapsed": 20.752208, - "row_count": 1 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 26.278458, - "row_count": 1 - }, - { - "elapsed": 26.591208, - "row_count": 1 - }, - { - "elapsed": 33.767167, - "row_count": 1 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 10.547374999999999, - "row_count": 18314 - }, - { - "elapsed": 10.867958, - "row_count": 18314 - }, - { - "elapsed": 10.324791999999999, - "row_count": 18314 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 75.053459, - "row_count": 1 - }, - { - "elapsed": 81.439458, - "row_count": 1 - }, - { - "elapsed": 72.507458, - "row_count": 1 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 77.332292, - "row_count": 57 - }, - { - "elapsed": 72.151083, - "row_count": 57 - }, - { - "elapsed": 62.882332999999996, - "row_count": 57 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 32.523458, - "row_count": 1 - }, - { - "elapsed": 32.177749999999996, - "row_count": 1 - }, - { - "elapsed": 30.318624999999997, - "row_count": 1 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 25.952709000000002, - "row_count": 186 - }, - { - "elapsed": 27.209208, - "row_count": 186 - }, - { - "elapsed": 25.721958, - "row_count": 186 - } - ], - "start_time": 1783521314, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 48.596834, - "row_count": 100 - }, - { - "elapsed": 46.218833000000004, - "row_count": 100 - }, - { - "elapsed": 48.855166999999994, - "row_count": 100 - } - ], - "start_time": 1783521315, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 10.040417, - "row_count": 7 - }, - { - "elapsed": 9.946333, - "row_count": 7 - }, - { - "elapsed": 9.694416, - "row_count": 7 - } - ], - "start_time": 1783521315, - "success": true - } - ] -} \ No newline at end of file diff --git a/ab_results/tpch_on_r2.json b/ab_results/tpch_on_r2.json deleted file mode 100644 index 992b2e3f7ac2d..0000000000000 --- a/ab_results/tpch_on_r2.json +++ /dev/null @@ -1,439 +0,0 @@ -{ - "queries": [ - { - "query": "Query 1", - "iterations": [ - { - "elapsed": 45.523584, - "row_count": 4 - }, - { - "elapsed": 37.542832999999995, - "row_count": 4 - }, - { - "elapsed": 38.704416, - "row_count": 4 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 2", - "iterations": [ - { - "elapsed": 13.292583, - "row_count": 100 - }, - { - "elapsed": 13.094875, - "row_count": 100 - }, - { - "elapsed": 12.456208, - "row_count": 100 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 3", - "iterations": [ - { - "elapsed": 28.26575, - "row_count": 10 - }, - { - "elapsed": 29.994833, - "row_count": 10 - }, - { - "elapsed": 30.247, - "row_count": 10 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 4", - "iterations": [ - { - "elapsed": 19.352, - "row_count": 5 - }, - { - "elapsed": 16.396416000000002, - "row_count": 5 - }, - { - "elapsed": 19.144792000000002, - "row_count": 5 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 5", - "iterations": [ - { - "elapsed": 80.001875, - "row_count": 5 - }, - { - "elapsed": 44.889167, - "row_count": 5 - }, - { - "elapsed": 40.862875, - "row_count": 5 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 6", - "iterations": [ - { - "elapsed": 16.637208, - "row_count": 1 - }, - { - "elapsed": 17.534417, - "row_count": 1 - }, - { - "elapsed": 21.551709, - "row_count": 1 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 7", - "iterations": [ - { - "elapsed": 56.581625, - "row_count": 4 - }, - { - "elapsed": 45.848333, - "row_count": 4 - }, - { - "elapsed": 49.040333, - "row_count": 4 - } - ], - "start_time": 1783521317, - "success": true - }, - { - "query": "Query 8", - "iterations": [ - { - "elapsed": 41.24525, - "row_count": 2 - }, - { - "elapsed": 43.712292, - "row_count": 2 - }, - { - "elapsed": 41.177541, - "row_count": 2 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 9", - "iterations": [ - { - "elapsed": 47.659167000000004, - "row_count": 175 - }, - { - "elapsed": 48.496542, - "row_count": 175 - }, - { - "elapsed": 68.08975000000001, - "row_count": 175 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 10", - "iterations": [ - { - "elapsed": 41.386959000000004, - "row_count": 20 - }, - { - "elapsed": 41.043333000000004, - "row_count": 20 - }, - { - "elapsed": 43.026, - "row_count": 20 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 11", - "iterations": [ - { - "elapsed": 13.936542, - "row_count": 1048 - }, - { - "elapsed": 11.915624999999999, - "row_count": 1048 - }, - { - "elapsed": 14.540958, - "row_count": 1048 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 12", - "iterations": [ - { - "elapsed": 32.509459, - "row_count": 2 - }, - { - "elapsed": 26.507333000000003, - "row_count": 2 - }, - { - "elapsed": 27.958167, - "row_count": 2 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 13", - "iterations": [ - { - "elapsed": 32.657041, - "row_count": 42 - }, - { - "elapsed": 27.798375, - "row_count": 42 - }, - { - "elapsed": 28.59, - "row_count": 42 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 14", - "iterations": [ - { - "elapsed": 23.075666000000002, - "row_count": 1 - }, - { - "elapsed": 20.999166, - "row_count": 1 - }, - { - "elapsed": 23.111834, - "row_count": 1 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 15", - "iterations": [ - { - "elapsed": 27.155041, - "row_count": 1 - }, - { - "elapsed": 27.287458, - "row_count": 1 - }, - { - "elapsed": 28.633292, - "row_count": 1 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 16", - "iterations": [ - { - "elapsed": 14.518915999999999, - "row_count": 18314 - }, - { - "elapsed": 11.304124999999999, - "row_count": 18314 - }, - { - "elapsed": 12.738709, - "row_count": 18314 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 17", - "iterations": [ - { - "elapsed": 82.30125000000001, - "row_count": 1 - }, - { - "elapsed": 69.59929199999999, - "row_count": 1 - }, - { - "elapsed": 87.404834, - "row_count": 1 - } - ], - "start_time": 1783521318, - "success": true - }, - { - "query": "Query 18", - "iterations": [ - { - "elapsed": 75.084542, - "row_count": 57 - }, - { - "elapsed": 66.318958, - "row_count": 57 - }, - { - "elapsed": 62.530375, - "row_count": 57 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 19", - "iterations": [ - { - "elapsed": 32.35325, - "row_count": 1 - }, - { - "elapsed": 30.159916, - "row_count": 1 - }, - { - "elapsed": 31.7975, - "row_count": 1 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 20", - "iterations": [ - { - "elapsed": 28.122874999999997, - "row_count": 186 - }, - { - "elapsed": 52.10025, - "row_count": 186 - }, - { - "elapsed": 29.025667000000002, - "row_count": 186 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 21", - "iterations": [ - { - "elapsed": 55.449208, - "row_count": 100 - }, - { - "elapsed": 70.486333, - "row_count": 100 - }, - { - "elapsed": 61.5685, - "row_count": 100 - } - ], - "start_time": 1783521319, - "success": true - }, - { - "query": "Query 22", - "iterations": [ - { - "elapsed": 9.438875, - "row_count": 7 - }, - { - "elapsed": 9.135625, - "row_count": 7 - }, - { - "elapsed": 9.553167, - "row_count": 7 - } - ], - "start_time": 1783521319, - "success": true - } - ], - "context": { - "benchmark_version": "54.0.0", - "datafusion_version": "54.0.0", - "num_cpus": 12, - "start_time": 1783521317, - "arguments": [ - "tpch", - "--iterations", - "3", - "--path", - "/Users/adrian/GitHub/datafusion/benchmarks/data/tpch_sf1", - "--format", - "parquet", - "-o", - "/tmp/datafusion-batch-normalizer/ab_results/tpch_on_r2.json" - ] - } -} \ No newline at end of file diff --git a/analyze_ab.py b/analyze_ab.py deleted file mode 100644 index 4438877794c39..0000000000000 --- a/analyze_ab.py +++ /dev/null @@ -1,51 +0,0 @@ -#!/usr/bin/env python3 -"""Compare interleaved A/B dfbench results: per-query min(off rounds) vs min(on rounds).""" -import json -import sys -from pathlib import Path - -OUT = Path("/tmp/datafusion-batch-normalizer/ab_results") - - -def load_mins(suite: str, cfg: str) -> dict[str, float]: - mins: dict[str, float] = {} - for f in sorted(OUT.glob(f"{suite}_{cfg}_r*.json")): - d = json.load(open(f)) - for q in d["queries"]: - if not q.get("success", True): - mins[q["query"]] = float("nan") - continue - m = min(i["elapsed"] for i in q["iterations"]) - k = q["query"] - mins[k] = min(mins.get(k, float("inf")), m) - return mins - - -def main() -> None: - for suite in sys.argv[1:] or ["tpch", "clickbench", "tpcds"]: - off, on = load_mins(suite, "off"), load_mins(suite, "on") - if not off or not on: - print(f"== {suite}: missing results ==") - continue - print(f"\n== {suite} (per-query min across rounds, off vs on) ==") - tot_off = tot_on = 0.0 - worst: list[tuple[float, str, float, float]] = [] - for q in off: - if q not in on: - continue - a, b = off[q], on[q] - tot_off += a - tot_on += b - worst.append((b / a if a > 0 else 1.0, q, a, b)) - worst.sort(reverse=True) - print(f"total: off={tot_off:.0f}ms on={tot_on:.0f}ms ratio={tot_on / tot_off:.3f}") - print("largest regressions (on/off):") - for r, q, a, b in worst[:5]: - print(f" {q}: {a:.1f} -> {b:.1f} ms ({r:.2f}x)") - print("largest improvements (on/off):") - for r, q, a, b in worst[-5:]: - print(f" {q}: {a:.1f} -> {b:.1f} ms ({r:.2f}x)") - - -if __name__ == "__main__": - main() diff --git a/bench_ab.log b/bench_ab.log deleted file mode 100644 index ab9f6ac13d3b5..0000000000000 --- a/bench_ab.log +++ /dev/null @@ -1,22 +0,0 @@ ->>> tpch cfg=off round=1 ->>> tpch cfg=on round=1 ->>> tpch cfg=off round=2 ->>> tpch cfg=on round=2 ->>> clickbench cfg=off round=1 ->>> clickbench cfg=on round=1 ->>> clickbench cfg=off round=2 ->>> clickbench cfg=on round=2 ->>> tpcds cfg=off round=1 -Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? -Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. ->>> tpcds cfg=on round=1 -Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? -Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. ->>> tpcds cfg=off round=2 -Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? -Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. ->>> tpcds cfg=on round=2 -Query 30 failed: Schema error: No field named c_last_review_date_sk. Did you mean 'customer.c_last_review_date'? -Valid fields are ctr1.ctr_customer_sk, ctr1.ctr_state, ctr1.ctr_total_return, customer_address.ca_address_sk, customer_address.ca_address_id, customer_address.ca_street_number, customer_address.ca_street_name, customer_address.ca_street_type, customer_address.ca_suite_number, customer_address.ca_city, customer_address.ca_county, customer_address.ca_state, customer_address.ca_zip, customer_address.ca_country, customer_address.ca_gmt_offset, customer_address.ca_location_type, customer.c_customer_sk, customer.c_customer_id, customer.c_current_cdemo_sk, customer.c_current_hdemo_sk, customer.c_current_addr_sk, customer.c_first_shipto_date_sk, customer.c_first_sales_date_sk, customer.c_salutation, customer.c_first_name, customer.c_last_name, customer.c_preferred_cust_flag, customer.c_birth_day, customer.c_birth_month, customer.c_birth_year, customer.c_birth_country, customer.c_login, customer.c_email_address, customer.c_last_review_date. -AB BENCHMARKS DONE -EXIT: 0 diff --git a/bench_run.log b/bench_run.log deleted file mode 100644 index 938fa56b69c10..0000000000000 --- a/bench_run.log +++ /dev/null @@ -1,568 +0,0 @@ -=== prebuild binaries === - Finished `release` profile [optimized] target(s) in 0.36s - Finished `release` profile [optimized] target(s) in 0.25s -=== tpch: branch, normalizer OFF (save baseline) === -*************************** -DataFusion Benchmark Script -COMMAND: run -BENCHMARK: tpch -QUERY: All -DATAFUSION_DIR: /tmp/datafusion-batch-normalizer/benchmarks/.. -BRANCH_NAME: batch-normalizer -DATA_DIR: /Users/adrian/GitHub/datafusion/benchmarks/data -RESULTS_DIR: /tmp/datafusion-batch-normalizer/benchmarks/results/batch-normalizer -CARGO_COMMAND: cargo run --release -PREFER_HASH_JOIN: true -SIMULATE_LATENCY: false -*************************** -Running tpch benchmark... -+ env BENCH_NAME=tpch BENCH_SIZE=1 DATA_DIR=/Users/adrian/GitHub/datafusion/benchmarks/data PREFER_HASH_JOIN=true TPCH_FILE_TYPE=parquet SIMULATE_LATENCY=false bash -c 'cargo bench --bench sql -- --save-baseline bnoff' - Compiling datafusion-benchmarks v54.0.0 (/private/tmp/datafusion-batch-normalizer/benchmarks) - Finished `bench` profile [optimized] target(s) in 20m 30s - Running benches/sql.rs (/private/tmp/datafusion-batch-normalizer/target/release/deps/sql-4f5152a58555f294) -Gnuplot not found, using plotters backend -Loading benchmarks... -Benchmarking tpch/Q01_sf1 -Benchmarking tpch/Q01_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q01_sf1: Collecting 10 samples in estimated 5.4234 s (50 iterations) -Benchmarking tpch/Q01_sf1: Analyzing -tpch/Q01_sf1 time: [103.79 ms 113.12 ms 123.15 ms] -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q02_sf1 -Benchmarking tpch/Q02_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q02_sf1: Collecting 10 samples in estimated 5.0095 s (200 iterations) -Benchmarking tpch/Q02_sf1: Analyzing -tpch/Q02_sf1 time: [25.986 ms 26.217 ms 26.479 ms] -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q03_sf1 -Benchmarking tpch/Q03_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q03_sf1: Collecting 10 samples in estimated 5.1353 s (70 iterations) -Benchmarking tpch/Q03_sf1: Analyzing -tpch/Q03_sf1 time: [69.989 ms 72.678 ms 75.598 ms] -Benchmarking tpch/Q04_sf1 -Benchmarking tpch/Q04_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q04_sf1: Collecting 10 samples in estimated 5.0259 s (150 iterations) -Benchmarking tpch/Q04_sf1: Analyzing -tpch/Q04_sf1 time: [34.094 ms 34.614 ms 35.280 ms] -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q05_sf1 -Benchmarking tpch/Q05_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q05_sf1: Collecting 10 samples in estimated 5.6980 s (60 iterations) -Benchmarking tpch/Q05_sf1: Analyzing -tpch/Q05_sf1 time: [89.420 ms 97.573 ms 106.87 ms] -Benchmarking tpch/Q06_sf1 -Benchmarking tpch/Q06_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q06_sf1: Collecting 10 samples in estimated 5.1150 s (120 iterations) -Benchmarking tpch/Q06_sf1: Analyzing -tpch/Q06_sf1 time: [41.340 ms 42.976 ms 44.545 ms] -Benchmarking tpch/Q07_sf1 -Benchmarking tpch/Q07_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q07_sf1: Collecting 10 samples in estimated 5.6654 s (50 iterations) -Benchmarking tpch/Q07_sf1: Analyzing -tpch/Q07_sf1 time: [109.67 ms 116.76 ms 124.13 ms] -Found 2 outliers among 10 measurements (20.00%) - 2 (20.00%) high mild -Benchmarking tpch/Q08_sf1 -Benchmarking tpch/Q08_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q08_sf1: Collecting 10 samples in estimated 5.2613 s (60 iterations) -Benchmarking tpch/Q08_sf1: Analyzing -tpch/Q08_sf1 time: [87.950 ms 90.582 ms 93.484 ms] -Benchmarking tpch/Q09_sf1 -Benchmarking tpch/Q09_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q09_sf1: Collecting 10 samples in estimated 6.0342 s (50 iterations) -Benchmarking tpch/Q09_sf1: Analyzing -tpch/Q09_sf1 time: [117.87 ms 123.80 ms 130.41 ms] -Benchmarking tpch/Q10_sf1 -Benchmarking tpch/Q10_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q10_sf1: Collecting 10 samples in estimated 5.2531 s (60 iterations) -Benchmarking tpch/Q10_sf1: Analyzing -tpch/Q10_sf1 time: [87.494 ms 88.751 ms 90.128 ms] -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q11_sf1 -Benchmarking tpch/Q11_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q11_sf1: Collecting 10 samples in estimated 5.0878 s (270 iterations) -Benchmarking tpch/Q11_sf1: Analyzing -tpch/Q11_sf1 time: [19.381 ms 19.538 ms 19.698 ms] -Benchmarking tpch/Q12_sf1 -Benchmarking tpch/Q12_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q12_sf1: Collecting 10 samples in estimated 5.5419 s (100 iterations) -Benchmarking tpch/Q12_sf1: Analyzing -tpch/Q12_sf1 time: [54.983 ms 55.637 ms 56.365 ms] -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q13_sf1 -Benchmarking tpch/Q13_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q13_sf1: Collecting 10 samples in estimated 5.2195 s (80 iterations) -Benchmarking tpch/Q13_sf1: Analyzing -tpch/Q13_sf1 time: [66.519 ms 67.841 ms 69.274 ms] -Benchmarking tpch/Q14_sf1 -Benchmarking tpch/Q14_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q14_sf1: Collecting 10 samples in estimated 5.0776 s (100 iterations) -Benchmarking tpch/Q14_sf1: Analyzing -tpch/Q14_sf1 time: [52.141 ms 53.836 ms 55.710 ms] -Benchmarking tpch/Q15_sf1 -Benchmarking tpch/Q15_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q15_sf1: Collecting 10 samples in estimated 5.2094 s (70 iterations) -Benchmarking tpch/Q15_sf1: Analyzing -tpch/Q15_sf1 time: [75.716 ms 76.229 ms 76.680 ms] -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) low mild -Benchmarking tpch/Q16_sf1 -Benchmarking tpch/Q16_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q16_sf1: Collecting 10 samples in estimated 5.1376 s (260 iterations) -Benchmarking tpch/Q16_sf1: Analyzing -tpch/Q16_sf1 time: [21.281 ms 21.774 ms 22.278 ms] -Benchmarking tpch/Q17_sf1 -Benchmarking tpch/Q17_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q17_sf1: Collecting 10 samples in estimated 5.0522 s (30 iterations) -Benchmarking tpch/Q17_sf1: Analyzing -tpch/Q17_sf1 time: [166.18 ms 168.53 ms 171.14 ms] -Benchmarking tpch/Q18_sf1 -Benchmarking tpch/Q18_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q18_sf1: Collecting 10 samples in estimated 6.5025 s (40 iterations) -Benchmarking tpch/Q18_sf1: Analyzing -tpch/Q18_sf1 time: [153.94 ms 164.84 ms 176.03 ms] -Benchmarking tpch/Q19_sf1 -Benchmarking tpch/Q19_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q19_sf1: Collecting 10 samples in estimated 5.3931 s (70 iterations) -Benchmarking tpch/Q19_sf1: Analyzing -tpch/Q19_sf1 time: [75.561 ms 76.490 ms 77.421 ms] -Benchmarking tpch/Q20_sf1 -Benchmarking tpch/Q20_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q20_sf1: Collecting 10 samples in estimated 5.6629 s (80 iterations) -Benchmarking tpch/Q20_sf1: Analyzing -tpch/Q20_sf1 time: [68.281 ms 70.390 ms 72.668 ms] -Benchmarking tpch/Q21_sf1 -Benchmarking tpch/Q21_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q21_sf1: Collecting 10 samples in estimated 6.4045 s (40 iterations) -Benchmarking tpch/Q21_sf1: Analyzing -tpch/Q21_sf1 time: [162.25 ms 165.24 ms 168.39 ms] -Benchmarking tpch/Q22_sf1 -Benchmarking tpch/Q22_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q22_sf1: Collecting 10 samples in estimated 5.1335 s (280 iterations) -Benchmarking tpch/Q22_sf1: Analyzing -tpch/Q22_sf1 time: [18.373 ms 18.893 ms 19.514 ms] -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) low mild - 1 (10.00%) high severe - -Completed benchmarks in 230144 ms ... -+ set +x -Done -=== tpch: branch, normalizer ON vs baseline === -*************************** -DataFusion Benchmark Script -COMMAND: run -BENCHMARK: tpch -QUERY: All -DATAFUSION_DIR: /tmp/datafusion-batch-normalizer/benchmarks/.. -BRANCH_NAME: batch-normalizer -DATA_DIR: /Users/adrian/GitHub/datafusion/benchmarks/data -RESULTS_DIR: /tmp/datafusion-batch-normalizer/benchmarks/results/batch-normalizer -CARGO_COMMAND: cargo run --release -PREFER_HASH_JOIN: true -SIMULATE_LATENCY: false -*************************** -Running tpch benchmark... -+ env BENCH_NAME=tpch BENCH_SIZE=1 DATA_DIR=/Users/adrian/GitHub/datafusion/benchmarks/data PREFER_HASH_JOIN=true TPCH_FILE_TYPE=parquet SIMULATE_LATENCY=false bash -c 'cargo bench --bench sql -- --baseline bnoff' - Finished `bench` profile [optimized] target(s) in 0.43s - Running benches/sql.rs (/private/tmp/datafusion-batch-normalizer/target/release/deps/sql-4f5152a58555f294) -Gnuplot not found, using plotters backend -Loading benchmarks... -Benchmarking tpch/Q01_sf1 -Benchmarking tpch/Q01_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q01_sf1: Collecting 10 samples in estimated 5.9028 s (60 iterations) -Benchmarking tpch/Q01_sf1: Analyzing -tpch/Q01_sf1 time: [118.47 ms 120.79 ms 122.74 ms] - change: [−2.1675% +6.7798% +16.678%] (p = 0.18 > 0.05) - No change in performance detected. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) low mild -Benchmarking tpch/Q02_sf1 -Benchmarking tpch/Q02_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q02_sf1: Collecting 10 samples in estimated 6.0207 s (40 iterations) -Benchmarking tpch/Q02_sf1: Analyzing -tpch/Q02_sf1 time: [52.400 ms 69.691 ms 89.699 ms] - change: [+96.347% +165.82% +246.40%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q03_sf1 -Benchmarking tpch/Q03_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q03_sf1: Collecting 10 samples in estimated 5.0493 s (20 iterations) -Benchmarking tpch/Q03_sf1: Analyzing -tpch/Q03_sf1 time: [149.76 ms 173.06 ms 197.54 ms] - change: [+104.60% +138.11% +174.24%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q04_sf1 -Benchmarking tpch/Q04_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q04_sf1: Collecting 10 samples in estimated 5.4039 s (50 iterations) -Benchmarking tpch/Q04_sf1: Analyzing -tpch/Q04_sf1 time: [40.165 ms 43.830 ms 47.654 ms] - change: [+16.334% +26.624% +38.868%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q05_sf1 -Benchmarking tpch/Q05_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q05_sf1: Collecting 10 samples in estimated 5.0501 s (30 iterations) -Benchmarking tpch/Q05_sf1: Analyzing -tpch/Q05_sf1 time: [244.72 ms 345.84 ms 447.32 ms] - change: [+148.09% +254.44% +360.69%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q06_sf1 -Benchmarking tpch/Q06_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q06_sf1: Collecting 10 samples in estimated 5.3992 s (60 iterations) -Benchmarking tpch/Q06_sf1: Analyzing -tpch/Q06_sf1 time: [83.225 ms 85.660 ms 89.018 ms] - change: [+90.105% +99.322% +110.06%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high severe -Benchmarking tpch/Q07_sf1 -Benchmarking tpch/Q07_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q07_sf1: Collecting 10 samples in estimated 5.1659 s (20 iterations) -Benchmarking tpch/Q07_sf1: Analyzing -tpch/Q07_sf1 time: [272.61 ms 286.34 ms 300.95 ms] - change: [+126.18% +145.23% +165.60%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q08_sf1 -Benchmarking tpch/Q08_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q08_sf1: Collecting 10 samples in estimated 5.3812 s (30 iterations) -Benchmarking tpch/Q08_sf1: Analyzing -tpch/Q08_sf1 time: [30.900 ms 41.328 ms 61.370 ms] - change: [−66.259% −54.375% −31.914%] (p = 0.00 < 0.05) - Performance has improved. -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) high mild - 1 (10.00%) high severe -Benchmarking tpch/Q09_sf1 -Benchmarking tpch/Q09_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q09_sf1: Collecting 10 samples in estimated 5.3032 s (100 iterations) -Benchmarking tpch/Q09_sf1: Analyzing -tpch/Q09_sf1 time: [107.36 ms 217.82 ms 332.92 ms] - change: [−16.143% +75.953% +169.98%] (p = 0.14 > 0.05) - No change in performance detected. -Benchmarking tpch/Q10_sf1 -Benchmarking tpch/Q10_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q10_sf1: Collecting 10 samples in estimated 6.9999 s (30 iterations) -Benchmarking tpch/Q10_sf1: Analyzing -tpch/Q10_sf1 time: [90.880 ms 135.93 ms 183.07 ms] - change: [−3.2470% +53.156% +101.24%] (p = 0.07 > 0.05) - No change in performance detected. -Benchmarking tpch/Q11_sf1 -Benchmarking tpch/Q11_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q11_sf1: Collecting 10 samples in estimated 5.1184 s (350 iterations) -Benchmarking tpch/Q11_sf1: Analyzing -tpch/Q11_sf1 time: [14.107 ms 15.180 ms 16.320 ms] - change: [−27.730% −22.304% −16.473%] (p = 0.00 < 0.05) - Performance has improved. -Benchmarking tpch/Q12_sf1 -Benchmarking tpch/Q12_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q12_sf1: Collecting 10 samples in estimated 5.1059 s (100 iterations) -Benchmarking tpch/Q12_sf1: Analyzing -tpch/Q12_sf1 time: [39.217 ms 44.602 ms 51.759 ms] - change: [−29.798% −19.834% −7.3132%] (p = 0.01 < 0.05) - Performance has improved. -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) high mild - 1 (10.00%) high severe -Benchmarking tpch/Q13_sf1 -Benchmarking tpch/Q13_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q13_sf1: Collecting 10 samples in estimated 5.8058 s (30 iterations) -Benchmarking tpch/Q13_sf1: Analyzing -tpch/Q13_sf1 time: [117.52 ms 124.67 ms 133.93 ms] - change: [+72.595% +83.761% +98.123%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high severe -Benchmarking tpch/Q14_sf1 -Benchmarking tpch/Q14_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q14_sf1: Collecting 10 samples in estimated 5.1132 s (50 iterations) -Benchmarking tpch/Q14_sf1: Analyzing -tpch/Q14_sf1 time: [103.12 ms 108.13 ms 113.88 ms] - change: [+89.456% +100.86% +113.64%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q15_sf1 -Benchmarking tpch/Q15_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q15_sf1: Collecting 10 samples in estimated 6.2864 s (30 iterations) -Benchmarking tpch/Q15_sf1: Analyzing -tpch/Q15_sf1 time: [148.59 ms 153.52 ms 158.68 ms] - change: [+95.187% +101.39% +108.12%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q16_sf1 -Benchmarking tpch/Q16_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q16_sf1: Collecting 10 samples in estimated 5.2772 s (150 iterations) -Benchmarking tpch/Q16_sf1: Analyzing -tpch/Q16_sf1 time: [33.758 ms 35.260 ms 37.023 ms] - change: [+54.113% +61.933% +70.832%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q17_sf1 -Benchmarking tpch/Q17_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q17_sf1: Collecting 10 samples in estimated 5.2229 s (20 iterations) -Benchmarking tpch/Q17_sf1: Analyzing -tpch/Q17_sf1 time: [95.019 ms 111.82 ms 129.93 ms] - change: [−43.807% −33.654% −22.325%] (p = 0.00 < 0.05) - Performance has improved. -Benchmarking tpch/Q18_sf1 -Benchmarking tpch/Q18_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q18_sf1: Collecting 10 samples in estimated 5.3081 s (20 iterations) -Benchmarking tpch/Q18_sf1: Analyzing -tpch/Q18_sf1 time: [339.03 ms 349.48 ms 357.69 ms] - change: [+97.010% +112.01% +127.97%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) low severe -Benchmarking tpch/Q19_sf1 -Benchmarking tpch/Q19_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q19_sf1: Collecting 10 samples in estimated 5.9315 s (40 iterations) -Benchmarking tpch/Q19_sf1: Analyzing -tpch/Q19_sf1 time: [143.42 ms 145.28 ms 147.16 ms] - change: [+86.583% +89.937% +93.498%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q20_sf1 -Benchmarking tpch/Q20_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q20_sf1: Collecting 10 samples in estimated 5.4258 s (40 iterations) -Benchmarking tpch/Q20_sf1: Analyzing -tpch/Q20_sf1 time: [133.60 ms 139.88 ms 148.62 ms] - change: [+87.406% +98.716% +112.82%] (p = 0.00 < 0.05) - Performance has regressed. -Found 2 outliers among 10 measurements (20.00%) - 2 (20.00%) high severe -Benchmarking tpch/Q21_sf1 -Benchmarking tpch/Q21_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q21_sf1: Collecting 10 samples in estimated 6.7043 s (20 iterations) -Benchmarking tpch/Q21_sf1: Analyzing -tpch/Q21_sf1 time: [80.711 ms 116.15 ms 169.12 ms] - change: [−50.988% −29.704% +0.7561%] (p = 0.06 > 0.05) - No change in performance detected. -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) high mild - 1 (10.00%) high severe -Benchmarking tpch/Q22_sf1 -Benchmarking tpch/Q22_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q22_sf1: Collecting 10 samples in estimated 5.0409 s (360 iterations) -Benchmarking tpch/Q22_sf1: Analyzing -tpch/Q22_sf1 time: [50.963 ms 71.330 ms 94.059 ms] - change: [+170.43% +277.55% +392.39%] (p = 0.00 < 0.05) - Performance has regressed. - -Completed benchmarks in 267771 ms ... -+ set +x -Done -=== tpch_mem: branch, normalizer OFF (save baseline) === -*************************** -DataFusion Benchmark Script -COMMAND: run -BENCHMARK: tpch_mem -QUERY: All -DATAFUSION_DIR: /tmp/datafusion-batch-normalizer/benchmarks/.. -BRANCH_NAME: batch-normalizer -DATA_DIR: /Users/adrian/GitHub/datafusion/benchmarks/data -RESULTS_DIR: /tmp/datafusion-batch-normalizer/benchmarks/results/batch-normalizer -CARGO_COMMAND: cargo run --release -PREFER_HASH_JOIN: true -SIMULATE_LATENCY: false -*************************** -Running tpch_mem benchmark... -+ env BENCH_NAME=tpch BENCH_SIZE=1 DATA_DIR=/Users/adrian/GitHub/datafusion/benchmarks/data TPCH_FILE_TYPE=mem PREFER_HASH_JOIN=true SIMULATE_LATENCY=false bash -c 'cargo bench --bench sql -- --save-baseline bnoff' - Finished `bench` profile [optimized] target(s) in 0.48s - Running benches/sql.rs (/private/tmp/datafusion-batch-normalizer/target/release/deps/sql-4f5152a58555f294) -Gnuplot not found, using plotters backend -Loading benchmarks... -Benchmarking tpch/Q01_sf1 -Benchmarking tpch/Q01_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q01_sf1: Collecting 10 samples in estimated 5.1100 s (30 iterations) -Benchmarking tpch/Q01_sf1: Analyzing -tpch/Q01_sf1 time: [170.74 ms 181.18 ms 193.91 ms] - change: [+43.714% +60.164% +77.805%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q02_sf1 -Benchmarking tpch/Q02_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q02_sf1: Collecting 10 samples in estimated 5.0871 s (380 iterations) -Benchmarking tpch/Q02_sf1: Analyzing -tpch/Q02_sf1 time: [17.064 ms 26.694 ms 37.767 ms] - change: [−38.290% +1.8163% +44.416%] (p = 0.93 > 0.05) - No change in performance detected. -Benchmarking tpch/Q03_sf1 -Benchmarking tpch/Q03_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q03_sf1: Collecting 10 samples in estimated 5.3451 s (130 iterations) -Benchmarking tpch/Q03_sf1: Analyzing -tpch/Q03_sf1 time: [37.187 ms 37.920 ms 38.775 ms] - change: [−50.046% −47.825% −45.405%] (p = 0.00 < 0.05) - Performance has improved. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q04_sf1 -Benchmarking tpch/Q04_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q04_sf1: Collecting 10 samples in estimated 5.1886 s (170 iterations) -Benchmarking tpch/Q04_sf1: Analyzing -tpch/Q04_sf1 time: [30.450 ms 31.776 ms 33.554 ms] - change: [−12.427% −8.2000% −2.6242%] (p = 0.01 < 0.05) - Performance has improved. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q05_sf1 -Benchmarking tpch/Q05_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q05_sf1: Collecting 10 samples in estimated 5.7035 s (30 iterations) -Benchmarking tpch/Q05_sf1: Analyzing -tpch/Q05_sf1 time: [77.916 ms 121.59 ms 164.13 ms] - change: [−20.620% +24.617% +72.311%] (p = 0.33 > 0.05) - No change in performance detected. -Benchmarking tpch/Q06_sf1 -Benchmarking tpch/Q06_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q06_sf1: Collecting 10 samples in estimated 5.1609 s (220 iterations) -Benchmarking tpch/Q06_sf1: Analyzing -tpch/Q06_sf1 time: [38.190 ms 41.205 ms 45.027 ms] - change: [−12.009% −4.1207% +5.8721%] (p = 0.41 > 0.05) - No change in performance detected. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q07_sf1 -Benchmarking tpch/Q07_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q07_sf1: Collecting 10 samples in estimated 6.1318 s (30 iterations) -Benchmarking tpch/Q07_sf1: Analyzing -tpch/Q07_sf1 time: [160.52 ms 172.48 ms 185.17 ms] - change: [+33.480% +47.717% +62.869%] (p = 0.00 < 0.05) - Performance has regressed. -Benchmarking tpch/Q08_sf1 -Benchmarking tpch/Q08_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q08_sf1: Collecting 10 samples in estimated 5.1276 s (150 iterations) -Benchmarking tpch/Q08_sf1: Analyzing -tpch/Q08_sf1 time: [30.601 ms 31.094 ms 31.671 ms] - change: [−66.886% −65.673% −64.447%] (p = 0.00 < 0.05) - Performance has improved. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q09_sf1 -Benchmarking tpch/Q09_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q09_sf1: Collecting 10 samples in estimated 5.0922 s (160 iterations) -./benchmarks/bench.sh: line 32: 44400 Terminated: 15 "$@" -Benchmarking tpch/Q09_sf1: Analyzing -tpch/Q09_sf1 time: [74.004 ms 106.76 ms 145.94 ms] - change: [−42.368% −13.761% +17.894%] (p = 0.43 > 0.05) - No change in performance detected. -Found 4 outliers among 10 measurements (40.00%) - 2 (20.00%) low mild - 1 (10.00%) high mild - 1 (10.00%) high severe -Benchmarking tpch/Q10_sf1 -Benchmarking tpch/Q10_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q10_sf1: Collecting 10 samples in estimated 5.5189 s (50 iterations) -Benchmarking tpch/Q10_sf1: Analyzing -tpch/Q10_sf1 time: [109.27 ms 119.14 ms 131.99 ms] - change: [+22.793% +34.237% +48.433%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q11_sf1 -Benchmarking tpch/Q11_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q11_sf1: Collecting 10 samples in estimated 5.0668 s (400 iterations) -Benchmarking tpch/Q11_sf1: Analyzing -tpch/Q11_sf1 time: [12.692 ms 12.949 ms 13.252 ms] - change: [−35.117% −33.723% −32.314%] (p = 0.00 < 0.05) - Performance has improved. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q12_sf1 -Benchmarking tpch/Q12_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q12_sf1: Collecting 10 samples in estimated 5.1147 s (100 iterations) -Benchmarking tpch/Q12_sf1: Analyzing -tpch/Q12_sf1 time: [24.127 ms 26.667 ms 29.526 ms] - change: [−56.704% −52.069% −47.066%] (p = 0.00 < 0.05) - Performance has improved. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q13_sf1 -Benchmarking tpch/Q13_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q13_sf1: Collecting 10 samples in estimated 5.5777 s (90 iterations) -Benchmarking tpch/Q13_sf1: Analyzing -tpch/Q13_sf1 time: [62.530 ms 64.588 ms 67.344 ms] - change: [−8.5002% −4.7961% −0.7475%] (p = 0.05 < 0.05) - Change within noise threshold. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high severe -Benchmarking tpch/Q14_sf1 -Benchmarking tpch/Q14_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q14_sf1: Collecting 10 samples in estimated 5.0686 s (310 iterations) -Benchmarking tpch/Q14_sf1: Analyzing -tpch/Q14_sf1 time: [15.081 ms 15.984 ms 16.994 ms] - change: [−72.155% −70.310% −68.034%] (p = 0.00 < 0.05) - Performance has improved. -Benchmarking tpch/Q15_sf1 -Benchmarking tpch/Q15_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q15_sf1: Collecting 10 samples in estimated 5.1889 s (100 iterations) -Benchmarking tpch/Q15_sf1: Analyzing -tpch/Q15_sf1 time: [30.152 ms 37.983 ms 50.611 ms] - change: [−60.536% −50.173% −34.312%] (p = 0.00 < 0.05) - Performance has improved. -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) high mild - 1 (10.00%) high severe -Benchmarking tpch/Q16_sf1 -Benchmarking tpch/Q16_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q16_sf1: Collecting 10 samples in estimated 5.0705 s (160 iterations) -Benchmarking tpch/Q16_sf1: Analyzing -tpch/Q16_sf1 time: [27.551 ms 31.864 ms 35.473 ms] - change: [+25.259% +46.337% +63.140%] (p = 0.00 < 0.05) - Performance has regressed. -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) low severe - 1 (10.00%) high mild -Benchmarking tpch/Q17_sf1 -Benchmarking tpch/Q17_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q17_sf1: Collecting 10 samples in estimated 5.1396 s (90 iterations) -Benchmarking tpch/Q17_sf1: Analyzing -tpch/Q17_sf1 time: [153.92 ms 207.86 ms 277.06 ms] - change: [−7.9318% +23.335% +57.501%] (p = 0.28 > 0.05) - No change in performance detected. -Found 2 outliers among 10 measurements (20.00%) - 1 (10.00%) low mild - 1 (10.00%) high severe -Benchmarking tpch/Q18_sf1 -Benchmarking tpch/Q18_sf1: Warming up for 3.0000 s - -Warning: Unable to complete 10 samples in 5.0s. You may wish to increase target time to 10.3s. -Benchmarking tpch/Q18_sf1: Collecting 10 samples in estimated 10.333 s (10 iterations) -Benchmarking tpch/Q18_sf1: Analyzing -tpch/Q18_sf1 time: [379.61 ms 390.88 ms 399.95 ms] - change: [+120.49% +137.13% +154.93%] (p = 0.00 < 0.05) - Performance has regressed. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) low mild -Benchmarking tpch/Q19_sf1 -Benchmarking tpch/Q19_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q19_sf1: Collecting 10 samples in estimated 5.0393 s (70 iterations) -Benchmarking tpch/Q19_sf1: Analyzing -tpch/Q19_sf1 time: [65.670 ms 67.574 ms 69.629 ms] - change: [−14.421% −11.657% −8.8163%] (p = 0.00 < 0.05) - Performance has improved. -Benchmarking tpch/Q20_sf1 -Benchmarking tpch/Q20_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q20_sf1: Collecting 10 samples in estimated 5.0035 s (100 iterations) -Benchmarking tpch/Q20_sf1: Analyzing -tpch/Q20_sf1 time: [16.113 ms 18.749 ms 22.214 ms] - change: [−77.255% −73.364% −67.621%] (p = 0.00 < 0.05) - Performance has improved. -Found 1 outliers among 10 measurements (10.00%) - 1 (10.00%) high mild -Benchmarking tpch/Q21_sf1 -Benchmarking tpch/Q21_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q21_sf1: Collecting 10 samples in estimated 5.8139 s (50 iterations) -Benchmarking tpch/Q21_sf1: Analyzing -tpch/Q21_sf1 time: [170.71 ms 183.22 ms 195.25 ms] - change: [+2.7213% +10.883% +19.070%] (p = 0.02 < 0.05) - Performance has regressed. -Benchmarking tpch/Q22_sf1 -Benchmarking tpch/Q22_sf1: Warming up for 3.0000 s -Benchmarking tpch/Q22_sf1: Collecting 10 samples in estimated 5.0292 s (260 iterations) -Benchmarking tpch/Q22_sf1: Analyzing -tpch/Q22_sf1 time: [17.036 ms 17.598 ms 18.148 ms] - change: [−10.980% −6.8549% −2.8204%] (p = 0.01 < 0.05) - Performance has improved. - -Completed benchmarks in 275797 ms ... diff --git a/lv_ab.log b/lv_ab.log deleted file mode 100644 index aa2678d51857b..0000000000000 --- a/lv_ab.log +++ /dev/null @@ -1,55 +0,0 @@ ->>> large_values mode=unlimited cfg=off round=1 -Query 1 avg time: 249.13 ms -Query 2 avg time: 197.81 ms -Query 3 avg time: 231.51 ms -Query 4 avg time: 177.36 ms -Query 5 avg time: 310.93 ms ->>> large_values mode=unlimited cfg=on round=1 -Query 1 avg time: 174.58 ms -Query 2 avg time: 178.78 ms -Query 3 avg time: 307.93 ms -Query 4 avg time: 183.48 ms -Query 5 avg time: 328.14 ms ->>> large_values mode=unlimited cfg=off round=2 -Query 1 avg time: 164.27 ms -Query 2 avg time: 147.94 ms -Query 3 avg time: 214.71 ms -Query 4 avg time: 161.33 ms -Query 5 avg time: 305.55 ms ->>> large_values mode=unlimited cfg=on round=2 -Query 1 avg time: 174.09 ms -Query 2 avg time: 166.66 ms -Query 3 avg time: 229.50 ms -Query 4 avg time: 179.87 ms -Query 5 avg time: 334.11 ms ->>> large_values mode=mem2g cfg=off round=1 -Query 1 avg time: 176.08 ms -Query 2 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. -Resources exhausted: Additional allocation failed for ExternalSorter[0] with top memory consumers (across reservations) as: -Query 3 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. -Resources exhausted: Additional allocation failed for ExternalSorter[0] with top memory consumers (across reservations) as: -Query 4 avg time: 171.76 ms -Query 5 avg time: 325.76 ms ->>> large_values mode=mem2g cfg=on round=1 -Query 1 avg time: 183.56 ms -Query 2 failed: Resources exhausted: Additional allocation failed for SortPreservingMergeExec[0] with top memory consumers (across reservations) as: -Query 3 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. -Resources exhausted: Additional allocation failed for ExternalSorter[6] with top memory consumers (across reservations) as: -Query 4 avg time: 218.22 ms -Query 5 avg time: 385.80 ms ->>> large_values mode=mem2g cfg=off round=2 -Query 1 avg time: 183.37 ms -Query 2 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. -Resources exhausted: Additional allocation failed for ExternalSorter[2] with top memory consumers (across reservations) as: -Query 3 failed: Not enough memory to continue external sort. Consider increasing the memory limit config: 'datafusion.runtime.memory_limit', or decreasing the config: 'datafusion.execution.sort_spill_reservation_bytes'. -Resources exhausted: Additional allocation failed for ExternalSorter[3] with top memory consumers (across reservations) as: -Query 4 avg time: 176.02 ms -Query 5 avg time: 314.73 ms ->>> large_values mode=mem2g cfg=on round=2 -Query 1 avg time: 179.79 ms -Query 2 failed: Resources exhausted: Additional allocation failed for SortPreservingMergeExec[0] with top memory consumers (across reservations) as: -Query 3 failed: Resources exhausted: Additional allocation failed for SortPreservingMergeExec[0] with top memory consumers (across reservations) as: -Query 4 avg time: 188.47 ms -Query 5 avg time: 349.71 ms -LV AB DONE -EXIT: 0 diff --git a/pr_body.md b/pr_body.md deleted file mode 100644 index 924fb87cb124e..0000000000000 --- a/pr_body.md +++ /dev/null @@ -1,48 +0,0 @@ -## Which issue does this PR close? - -- N/A (design discussed offline; can file a tracking issue if preferred) - -## Rationale for this change - -Operators bound their output batches by row count (`datafusion.execution.batch_size`) only. With wide rows (large string values, wide schemas) a batch within the row limit can still be arbitrarily large in bytes — multi-GB batches break memory accounting assumptions and cause OOMs. Conversely, streams of many tiny batches waste per-batch overhead. - -The existing `BatchSplitStream` on `DataSourceExec` splits by rows only, and splitting by zero-copy `slice` cannot release memory anyway: a slice of a 4GB batch still pins all 4GB of buffers (arrow's `concat` also short-circuits single inputs to a zero-copy slice). - -This PR adds a **batch normalizer**: a stream wrapper that re-chunks data source output towards a target row count *and* byte size, opt-in via a new config option. - -## What changes are included in this PR? - -1. `BatchNormalizer` / `BatchNormalizerStream` (`datafusion/physical-plan/src/batch_normalizer.rs`). Per input batch, one of four actions: - - **Pass through** (zero copy): rows ≥ `batch_size / 2` or logical bytes ≥ `target / 2`, up to `2x` the byte target. The wide acceptance band means near-target batches are never copied. - - **Coalesce**: small batches are buffered (via arrow `BatchCoalescer`) and flushed when the buffer reaches the row target **or** the byte target, whichever first. - - **Split**: oversized batches (by rows or bytes) are re-emitted as compact ~target-sized copies (`take_record_batch` + view-array GC), produced incrementally (one chunk per poll) so peak memory is the parent plus ~one chunk. Copying is load-bearing: zero-copy slices would keep the oversized parent alive. - - **Compact**: batches that retain far more memory than they logically use (> 2x and > 1MiB waste, e.g. a small slice pinning a huge parent, or sparse StringView data buffers) are copied so the backing buffers can be freed. -2. New config `datafusion.execution.target_batch_size_bytes` (default `None` = unchanged behavior). When set, `DataSourceExec` wraps its output in `BatchNormalizerStream` instead of the row-only `BatchSplitStream`. -3. Operator metrics: `batches_passed_through`, `batches_coalesced`, `batches_split`, `batches_compacted`. - -Planned follow-ups (intentionally not in this PR): memory-pool reservation for the normalizer's buffer with a spill fallback (following the `RepartitionExec` `OutputChannel`/`SpillPool` pattern), and byte-aware bounding for operator emit paths (join/aggregate output amplification is not addressable at the scan). - -## Local benchmark observations (laptop, noisy — GKE runs requested) - -Interleaved off/on A/B (2 rounds, per-query minimums, same binary, 16MiB target via `DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES`): - -- TPC-H SF1: total off 623ms vs on 678ms. Operator metrics confirm the normalizer is pure zero-copy pass-through on these scans (e.g. Q1/Q6: 742/742 `batches_passed_through`, 0 copies), so the residual delta is per-batch size measurement overhead and/or laptop noise (off-vs-off noise floor spans 0.66-1.22x per query). -- ClickBench partitioned: total off 21.9s vs on 22.4s (+2.6%; noise floor p90 1.13x). String-heavy group-by queries (Q13/Q17/Q21) show 1.19-1.25x, slightly above the noise band — likely the StringView waste-compaction path; being investigated with operator metrics. Improvements to 0.81x on Q32/Q33. - -Laptop numbers are close to the noise floor; treating the dedicated benchmark runner as the source of truth. - -## Are these changes tested? - -Yes — written test-first (TDD): - -- 18 unit tests covering pass-through zero-copy guarantees (pointer equality), coalesce flush on rows/bytes, incremental split with compaction guarantees (chunks must not retain the parent's buffers, including the StringView GC case), waste compaction and its thresholds, ordering across buffered/pass-through boundaries, single-giant-row and zero-column edge cases, metrics, and the stream adapter. -- 3 end-to-end tests exercising the config through `SessionContext` scans. -- Extended workspace test suite passes; config docs and `information_schema.slt` regenerated. - -## Are there any user-facing changes? - -New opt-in config option `datafusion.execution.target_batch_size_bytes` (documented in `configs.md`). Default behavior is unchanged. No breaking API changes. - -🤖 Generated with [Claude Code](https://claude.com/claude-code) - -https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm diff --git a/rerun_tpch.sh b/rerun_tpch.sh deleted file mode 100755 index b4cdf466dbc03..0000000000000 --- a/rerun_tpch.sh +++ /dev/null @@ -1,18 +0,0 @@ -#!/usr/bin/env bash -# tpch-only rerun (rounds 3,4) after the polluted rounds 1,2; overwrites nothing. -set -e -BRANCH_DIR="/tmp/datafusion-batch-normalizer" -DATA="$HOME/GitHub/datafusion/benchmarks/data" -BIN="$BRANCH_DIR/target/release/dfbench" -OUT="$BRANCH_DIR/ab_results" -rm -f "$OUT"/tpch_*_r1.json "$OUT"/tpch_*_r2.json -for round in 3 4; do - for cfg in off on; do - envargs=() - [ "$cfg" = on ] && envargs=(DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=16777216) - echo ">>> tpch cfg=$cfg round=$round" - env "${envargs[@]}" "$BIN" tpch --iterations 3 \ - --path "$DATA/tpch_sf1" --format parquet -o "$OUT/tpch_${cfg}_r${round}.json" > /dev/null - done -done -echo "TPCH RERUN DONE" diff --git a/run_benchmarks.sh b/run_benchmarks.sh deleted file mode 100755 index 3eaaa775dd229..0000000000000 --- a/run_benchmarks.sh +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env bash -# Benchmark driver for the batch-normalizer branch. -# -# tpch / tpch_mem use the criterion "sql" bench harness: run config-off as a -# saved baseline, then config-on compared against it (same binary, env flip). -# clickbench_partitioned / tpcds use dfbench JSON results: bn-off vs bn-on -# from the branch binary, plus a main-binary baseline for clickbench. -set -e - -export DATA_DIR="$HOME/GitHub/datafusion/benchmarks/data" -MAIN_DIR="$HOME/GitHub/datafusion" -BRANCH_DIR="/tmp/datafusion-batch-normalizer" -TARGET_BYTES=16777216 # 16MiB soft target -ON_ENV="DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=$TARGET_BYTES" - -echo "=== prebuild binaries ===" -(cd "$BRANCH_DIR" && cargo build --release -p datafusion-benchmarks --bin dfbench 2>&1 | tail -1) -(cd "$MAIN_DIR" && cargo build --release -p datafusion-benchmarks --bin dfbench 2>&1 | tail -1) - -# --- criterion suites: tpch, tpch_mem (branch binary, off-baseline vs on) --- -criterion_suite() { - local suite=$1 - echo "=== $suite: branch, normalizer OFF (save baseline) ===" - (cd "$BRANCH_DIR" && SQL_CARGO_COMMAND="cargo bench --bench sql -- --save-baseline bnoff" \ - ./benchmarks/bench.sh run "$suite") - echo "=== $suite: branch, normalizer ON vs baseline ===" - (cd "$BRANCH_DIR" && env $ON_ENV \ - SQL_CARGO_COMMAND="cargo bench --bench sql -- --baseline bnoff" \ - ./benchmarks/bench.sh run "$suite") -} - -# --- dfbench suites (JSON results) --- -dfbench_branch() { - local suite=$1 - echo "=== $suite: branch, normalizer OFF ===" - (cd "$BRANCH_DIR" && RESULTS_NAME=bn-off ./benchmarks/bench.sh run "$suite") - echo "=== $suite: branch, normalizer ON ===" - (cd "$BRANCH_DIR" && env $ON_ENV RESULTS_NAME=bn-on ./benchmarks/bench.sh run "$suite") -} - -criterion_suite tpch -criterion_suite tpch_mem - -echo "=== clickbench_partitioned: main baseline ===" -(cd "$MAIN_DIR" && RESULTS_NAME=bn-main ./benchmarks/bench.sh run clickbench_partitioned) -dfbench_branch clickbench_partitioned -dfbench_branch tpcds - -echo "=== ALL BENCHMARKS DONE ===" diff --git a/run_benchmarks2.sh b/run_benchmarks2.sh deleted file mode 100755 index a7feb92972b78..0000000000000 --- a/run_benchmarks2.sh +++ /dev/null @@ -1,52 +0,0 @@ -#!/usr/bin/env bash -# Interleaved A/B benchmark: normalizer off vs on, same branch binary. -# Two rounds of off->on per suite; compare per-query minimums across rounds -# to be robust against environment drift (the failure mode of run 1). -set -e - -BRANCH_DIR="/tmp/datafusion-batch-normalizer" -DATA="$HOME/GitHub/datafusion/benchmarks/data" -QUERIES="$HOME/GitHub/datafusion/benchmarks/queries" -TPCDS_QUERIES="$HOME/GitHub/datafusion/datafusion/core/tests/tpc-ds" -BIN="$BRANCH_DIR/target/release/dfbench" -OUT="$BRANCH_DIR/ab_results" -TARGET_BYTES=16777216 - -mkdir -p "$OUT" -cd "$BRANCH_DIR" - -run_one() { - local suite=$1 cfg=$2 round=$3 - local envargs=() - if [ "$cfg" = on ]; then - envargs=(DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=$TARGET_BYTES) - fi - local out="$OUT/${suite}_${cfg}_r${round}.json" - echo ">>> $suite cfg=$cfg round=$round" - case $suite in - tpch) - env "${envargs[@]}" "$BIN" tpch --iterations 3 \ - --path "$DATA/tpch_sf1" --format parquet -o "$out" > /dev/null - ;; - clickbench) - env "${envargs[@]}" "$BIN" clickbench --iterations 3 \ - --path "$DATA/hits_partitioned" \ - --queries-path "$QUERIES/clickbench/queries" -o "$out" > /dev/null - ;; - tpcds) - env "${envargs[@]}" "$BIN" tpcds --iterations 3 \ - --path "$DATA/tpcds_sf1" --query_path "$TPCDS_QUERIES" \ - --prefer_hash_join true -o "$out" > /dev/null - ;; - esac -} - -for suite in tpch clickbench tpcds; do - for round in 1 2; do - for cfg in off on; do - run_one "$suite" "$cfg" "$round" - done - done -done - -echo "AB BENCHMARKS DONE" diff --git a/run_lv_ab.sh b/run_lv_ab.sh deleted file mode 100755 index 683951c3838ad..0000000000000 --- a/run_lv_ab.sh +++ /dev/null @@ -1,36 +0,0 @@ -#!/usr/bin/env bash -# Interleaved A/B for the large_values benchmark: normalizer off vs on, -# unlimited memory and 2GB memory limit (fair pool + disk spill). -set -e - -BRANCH_DIR="/tmp/datafusion-batch-normalizer" -BIN="$BRANCH_DIR/target/release/dfbench" -DATA="$HOME/GitHub/datafusion/benchmarks/data/large_values" -OUT="$BRANCH_DIR/ab_results" -TARGET_BYTES=16777216 - -mkdir -p "$OUT" - -run_one() { - local mode=$1 cfg=$2 round=$3 - local envargs=() limitargs=() iters=3 - [ "$cfg" = on ] && envargs=(DATAFUSION_EXECUTION_TARGET_BATCH_SIZE_BYTES=$TARGET_BYTES) - if [ "$mode" = mem2g ]; then - limitargs=(--memory-limit 2G) - iters=2 - fi - echo ">>> large_values mode=$mode cfg=$cfg round=$round" - env "${envargs[@]}" "$BIN" large-values --iterations $iters \ - --path "$DATA" "${limitargs[@]}" \ - -o "$OUT/lv-${mode}_${cfg}_r${round}.json" 2>&1 | grep -E 'failed|avg' -} - -for mode in unlimited mem2g; do - for round in 1 2; do - for cfg in off on; do - run_one "$mode" "$cfg" "$round" - done - done -done - -echo "LV AB DONE" diff --git a/test_suite2.log b/test_suite2.log deleted file mode 100644 index 58f0cf0ebe4e6..0000000000000 --- a/test_suite2.log +++ /dev/null @@ -1 +0,0 @@ -EXIT: 0 diff --git a/test_suite_output.log b/test_suite_output.log deleted file mode 100644 index 022d688b9cef2..0000000000000 --- a/test_suite_output.log +++ /dev/null @@ -1,81 +0,0 @@ -test cases::roundtrip_physical_plan::wildcard_select ... ok -test cases::serialize::tests::include_remaps_for_projects ... ok -test cases::serialize::tests::include_remaps_for_windows ... ok -test cases::roundtrip_logical_plan::try_cast_decimal_to_string ... ok -test cases::serialize::tests::serialize_simple_select ... ok -test cases::serialize::tests::table_scan_without_projection ... ok -test cases::serialize::tests::serialize_to_file ... ok -test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_exact ... ok -test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_not_subset ... ok -test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_subset ... ok -test cases::substrait_validations::tests::schema_compatibility::ensure_schema_match_subset_with_mask ... ok -test cases::roundtrip_logical_plan::all_type_literal ... ok -test cases::substrait_validations::tests::schema_compatibility::reject_plans_with_incompatible_field_nullability ... ok -test cases::substrait_validations::tests::schema_compatibility::reject_plans_with_incompatible_field_types ... ok -test cases::roundtrip_logical_plan::simple_aggregate ... ok -test cases::roundtrip_logical_plan::simple_window_function ... ok -test cases::roundtrip_logical_plan::simple_intersect_table_reuse ... ok -test cases::roundtrip_logical_plan::simple_intersect ... ok -test cases::consumer_integration::tests::tpch_test_19 ... ok -test cases::serialize::tests::higher_order_function ... ok -test cases::consumer_integration::tests::tpch_test_22 ... ok -test cases::roundtrip_logical_plan::window_with_rows ... ok -test cases::roundtrip_logical_plan::roundtrip_array_transform_higher_order_function ... ok - -test result: ok. 200 passed; 0 failed; 6 ignored; 0 measured; 0 filtered out; finished in 1.26s - - Running tests/utils.rs (target/ci/deps/utils-70afe979898e7729) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running unittests src/lib.rs (target/ci/deps/datafusion_wasmtest-7e361b1316a80476) - -running 6 tests -test test::test_parquet_write ... ok -test test::basic_execute ... ok -test test::test_parquet_read_and_write ... ok -test test::test_csv_read_xz_compressed ... ok -test test::basic_df_function_execute ... ok -test test::test_basic_aggregate ... ok - -test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.11s - - Running unittests src/lib.rs (target/ci/deps/ffi_example_table_provider-893f4913c8ab6c61) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running unittests src/lib.rs (target/ci/deps/ffi_module_interface-9a41e100f9d90255) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running unittests src/main.rs (target/ci/deps/ffi_module_loader-150f75c332fc06ba) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running unittests src/main.rs (target/ci/deps/gen-93e8d1206f8c17bf) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running unittests src/main.rs (target/ci/deps/gen_common-155a74322ca91bb8) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running unittests src/lib.rs (target/ci/deps/test_utils-2cc61db516d825b4) - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - -EXIT: 0 From 775c059d88180c4b6169dd3047c5f39508d07e18 Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Wed, 8 Jul 2026 19:06:03 -0500 Subject: [PATCH 10/11] feat: derive the batch byte target adaptively from the memory limit Adds datafusion.execution.adaptive_target_batch_size (default true): when target_batch_size_bytes is unset and the memory pool reports a finite limit, the byte target is derived as pool_size / target_partitions / 16, capped at 16MiB. The /16 margin covers per-batch multipliers in the sort/merge machinery (2x sort buffering, ~4x spill-merge reservation per stream, SPM buffering all streams); the ceiling is where tight-pool merges stay reliably stable while larger batches add nothing. Adaptive targeting deliberately stays off when there is no memory limit (nothing to protect: identical code path to today) and when the derived target falls below 1MiB (a pool that small cannot be saved by re-chunking, and carefully crafted small-pool OOM scenarios keep their exact behavior). An explicit target_batch_size_bytes always wins. With no configuration at all, the large_values benchmark under a 2GB limit goes from failing its sort queries to completing them at both 4 and 12 partitions, including the 2GiB-dataset variant. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- datafusion/common/src/config.rs | 9 ++ datafusion/datasource/src/source.rs | 8 +- .../src/aggregates/grouped_hash_stream.rs | 7 +- .../physical-plan/src/batch_normalizer.rs | 124 +++++++++++++++++- datafusion/physical-plan/src/sorts/sort.rs | 3 +- .../src/sorts/sort_preserving_merge.rs | 9 +- .../test_files/information_schema.slt | 2 + docs/source/user-guide/configs.md | 1 + 8 files changed, 143 insertions(+), 20 deletions(-) diff --git a/datafusion/common/src/config.rs b/datafusion/common/src/config.rs index b8657aeef19a1..89b27c4094536 100644 --- a/datafusion/common/src/config.rs +++ b/datafusion/common/src/config.rs @@ -746,6 +746,15 @@ config_namespace! { /// chunked by row count. pub target_batch_size_bytes: Option, default = None + /// When `target_batch_size_bytes` is unset and the memory pool has a finite + /// limit, derive a byte-size target for batches automatically from the pool's + /// per-partition share, so queries whose batches are large relative to the + /// memory budget re-chunk them (and can complete) instead of failing with + /// ResourcesExhausted. Has no effect when there is no memory limit (nothing + /// to protect: batches pass through untouched) or when + /// `target_batch_size_bytes` is set explicitly. + pub adaptive_target_batch_size: bool, default = true + /// A perfect hash join (see `HashJoinExec` for more details) will be considered /// if the range of keys (max - min) on the build side is < this threshold. /// This provides a fast path for joins with very small key ranges, diff --git a/datafusion/datasource/src/source.rs b/datafusion/datasource/src/source.rs index cb7ee71f09b7c..fcaa5adcec497 100644 --- a/datafusion/datasource/src/source.rs +++ b/datafusion/datasource/src/source.rs @@ -24,7 +24,7 @@ use std::sync::{Arc, OnceLock}; use datafusion_physical_expr::projection::ProjectionExprs; use datafusion_physical_plan::batch_normalizer::{ - BatchNormalizerMetrics, BatchNormalizerStream, + BatchNormalizerMetrics, BatchNormalizerStream, effective_target_batch_size_bytes, }; use datafusion_physical_plan::execution_plan::{ Boundedness, EmissionType, SchedulingType, @@ -416,11 +416,7 @@ impl ExecutionPlan for DataSourceExec { // With a byte target configured, normalize output batches by both // row count and in-memory size (splitting oversized batches and // coalescing small ones); otherwise only split by row count. - let target_batch_size_bytes = context - .session_config() - .options() - .execution - .target_batch_size_bytes; + let target_batch_size_bytes = effective_target_batch_size_bytes(&context); if let Some(target_bytes) = target_batch_size_bytes { log::debug!( "Batch normalization enabled for partition {partition}: \ diff --git a/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs b/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs index 87cf9beb28f5d..2be6870fa6d3d 100644 --- a/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs +++ b/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs @@ -395,11 +395,8 @@ impl GroupedHashAggregateStream { let agg_filter_expr = Arc::clone(&agg.filter_expr); let batch_size = context.session_config().batch_size(); - let target_batch_size_bytes = context - .session_config() - .options() - .execution - .target_batch_size_bytes; + let target_batch_size_bytes = + crate::batch_normalizer::effective_target_batch_size_bytes(context); let input = agg.input.execute(partition, Arc::clone(context))?; let baseline_metrics = BaselineMetrics::new(&agg.metrics, partition); let group_by_metrics = GroupByMetrics::new(&agg.metrics, partition); diff --git a/datafusion/physical-plan/src/batch_normalizer.rs b/datafusion/physical-plan/src/batch_normalizer.rs index c9181c430771b..0b64300ce9428 100644 --- a/datafusion/physical-plan/src/batch_normalizer.rs +++ b/datafusion/physical-plan/src/batch_normalizer.rs @@ -59,7 +59,8 @@ use arrow::compute::{BatchCoalescer, take_record_batch}; use arrow::datatypes::{ByteViewType, SchemaRef}; use datafusion_common::utils::memory::get_record_batch_memory_size; use datafusion_common::{Result, assert_or_internal_err}; -use datafusion_execution::{RecordBatchStream, SendableRecordBatchStream}; +use datafusion_execution::memory_pool::MemoryLimit; +use datafusion_execution::{RecordBatchStream, SendableRecordBatchStream, TaskContext}; use futures::{Stream, StreamExt}; use crate::metrics::{Count, ExecutionPlanMetricsSet, MetricBuilder}; @@ -85,6 +86,63 @@ const WASTE_RATIO: usize = 2; /// batches die immediately in streaming pipelines). const MIN_WASTE_BYTES: usize = 1024 * 1024; +/// Divisor applied to the per-partition share of a finite memory pool to +/// derive an adaptive byte target: `pool_size / target_partitions / +/// ADAPTIVE_TARGET_DIVISOR`. +/// +/// The margin covers what each partition's operators need per batch beyond +/// the batch itself: an external sort reserves ~2x a batch's size to buffer +/// it, its spill merge reserves ~4x the largest spilled batch per stream +/// (with a read-ahead of 2), and the final sort-preserving merge buffers +/// batches from every stream concurrently. /16 keeps several such batches +/// per partition comfortably inside the partition's fair share, empirically +/// turning "ResourcesExhausted on oversized batches" into completed queries +/// without shrinking batches so far that per-batch overhead dominates. +pub const ADAPTIVE_TARGET_DIVISOR: usize = 16; + +/// Adaptive targeting only activates when the derived target reaches this +/// minimum (i.e. the pool holds at least 16MiB per partition). Below it the +/// pool is too small for re-chunking to change the outcome, so behavior is +/// left exactly as with no target -- this also keeps carefully-constructed +/// small-pool OOM scenarios (e.g. in tests) unchanged. +pub const MIN_ADAPTIVE_TARGET_BYTES: usize = 1024 * 1024; + +/// Ceiling for the adaptive byte target. Batches beyond ~16MiB buy no +/// per-batch-overhead amortization, and empirically the sort/merge machinery +/// under a tight memory limit is only reliably stable when spilled batches +/// stay at or below this size; a larger pool share is headroom, not an +/// invitation for bigger batches. +pub const MAX_ADAPTIVE_TARGET_BYTES: usize = 16 * 1024 * 1024; + +/// Resolve the effective byte-size target for batches under this task +/// context: +/// +/// 1. An explicit `datafusion.execution.target_batch_size_bytes` always wins. +/// 2. Otherwise, if `datafusion.execution.adaptive_target_batch_size` is on +/// and the memory pool reports a finite limit, the target is derived from +/// the per-partition share of the pool (see [`ADAPTIVE_TARGET_DIVISOR`]). +/// With no memory limit there is nothing to protect, so no target is set +/// and batches are never split or copied. +/// 3. `None` otherwise: batches are chunked by row count only. +pub fn effective_target_batch_size_bytes(context: &TaskContext) -> Option { + let options = context.session_config().options(); + if let Some(target) = options.execution.target_batch_size_bytes { + return Some(target); + } + if !options.execution.adaptive_target_batch_size { + return None; + } + match context.memory_pool().memory_limit() { + MemoryLimit::Finite(pool_size) => { + let partitions = options.execution.target_partitions.max(1); + let target = pool_size / partitions / ADAPTIVE_TARGET_DIVISOR; + (target >= MIN_ADAPTIVE_TARGET_BYTES) + .then(|| target.min(MAX_ADAPTIVE_TARGET_BYTES)) + } + _ => None, + } +} + /// Metrics for [`BatchNormalizer`] #[derive(Debug, Clone, Default)] pub struct BatchNormalizerMetrics { @@ -563,6 +621,70 @@ mod tests { logical_batch_size(batch).unwrap() } + // === adaptive target === + + #[test] + fn adaptive_target_from_memory_limit() { + use datafusion_execution::TaskContext; + use datafusion_execution::config::SessionConfig; + use datafusion_execution::memory_pool::{FairSpillPool, GreedyMemoryPool}; + use datafusion_execution::runtime_env::RuntimeEnvBuilder; + + let ctx_with = + |pool: Option>, + target: Option, + adaptive: bool, + partitions: usize| { + let mut config = SessionConfig::new().with_target_partitions(partitions); + config.options_mut().execution.target_batch_size_bytes = target; + config.options_mut().execution.adaptive_target_batch_size = adaptive; + let mut rt = RuntimeEnvBuilder::new(); + if let Some(pool) = pool { + rt = rt.with_memory_pool(pool); + } + TaskContext::default() + .with_session_config(config) + .with_runtime(Arc::new(rt.build().unwrap())) + }; + + // no limit, no explicit target -> disabled + let ctx = ctx_with(None, None, true, 8); + assert_eq!(effective_target_batch_size_bytes(&ctx), None); + + // finite pool -> pool_size / partitions / ADAPTIVE_TARGET_DIVISOR + let pool: Arc = + Arc::new(FairSpillPool::new(2 * 1024 * 1024 * 1024)); + let ctx = ctx_with(Some(Arc::clone(&pool)), None, true, 8); + assert_eq!( + effective_target_batch_size_bytes(&ctx), + Some(2 * 1024 * 1024 * 1024 / 8 / ADAPTIVE_TARGET_DIVISOR) + ); + + // explicit target always wins + let ctx = ctx_with(Some(Arc::clone(&pool)), Some(123456), true, 8); + assert_eq!(effective_target_batch_size_bytes(&ctx), Some(123456)); + + // adaptive disabled -> None even with a finite pool + let ctx = ctx_with(Some(Arc::clone(&pool)), None, false, 8); + assert_eq!(effective_target_batch_size_bytes(&ctx), None); + + // huge pool / few partitions -> clamped to the 16MiB ceiling + let pool: Arc = + Arc::new(GreedyMemoryPool::new(64 * 1024 * 1024 * 1024)); + let ctx = ctx_with(Some(pool), None, true, 4); + assert_eq!( + effective_target_batch_size_bytes(&ctx), + Some(MAX_ADAPTIVE_TARGET_BYTES) + ); + + // pool too small for the minimum target -> adaptive stays off so + // small-pool behavior (and crafted OOM scenarios) is unchanged + let pool: Arc = + Arc::new(GreedyMemoryPool::new(64 * 1024 * 1024)); + let ctx = ctx_with(Some(pool), None, true, 512); + assert_eq!(effective_target_batch_size_bytes(&ctx), None); + } + // === pass through === #[test] diff --git a/datafusion/physical-plan/src/sorts/sort.rs b/datafusion/physical-plan/src/sorts/sort.rs index e796633ab374e..60066091e8b12 100644 --- a/datafusion/physical-plan/src/sorts/sort.rs +++ b/datafusion/physical-plan/src/sorts/sort.rs @@ -25,6 +25,7 @@ use std::sync::Arc; use parking_lot::RwLock; +use crate::batch_normalizer::effective_target_batch_size_bytes; use crate::common::spawn_buffered; use crate::execution_plan::{ Boundedness, CardinalityEffect, EmissionType, has_same_children_properties, @@ -1403,7 +1404,7 @@ impl ExecutionPlan for SortExec { input.schema(), self.expr.clone(), context.session_config().batch_size(), - execution_options.target_batch_size_bytes, + effective_target_batch_size_bytes(&context), execution_options.sort_spill_reservation_bytes, execution_options.sort_in_place_threshold_bytes, context.session_config().spill_compression(), diff --git a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs index 9fbdefab43d6c..c3597249cfb98 100644 --- a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs +++ b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs @@ -19,6 +19,7 @@ use std::sync::Arc; +use crate::batch_normalizer::effective_target_batch_size_bytes; use crate::common::spawn_buffered; use crate::limit::LimitStream; use crate::metrics::{BaselineMetrics, ExecutionPlanMetricsSet, MetricsSet}; @@ -363,13 +364,7 @@ impl ExecutionPlan for SortPreservingMergeExec { .with_expressions(&self.expr) .with_metrics(BaselineMetrics::new(&self.metrics, partition)) .with_batch_size(context.session_config().batch_size()) - .with_batch_size_bytes( - context - .session_config() - .options() - .execution - .target_batch_size_bytes, - ) + .with_batch_size_bytes(effective_target_batch_size_bytes(&context)) .with_fetch(self.fetch) .with_reservation(reservation) .with_round_robin_tie_breaker(self.enable_round_robin_repartition) diff --git a/datafusion/sqllogictest/test_files/information_schema.slt b/datafusion/sqllogictest/test_files/information_schema.slt index 3de332651eeda..32fde1a76e214 100644 --- a/datafusion/sqllogictest/test_files/information_schema.slt +++ b/datafusion/sqllogictest/test_files/information_schema.slt @@ -214,6 +214,7 @@ datafusion.catalog.has_header true datafusion.catalog.information_schema true datafusion.catalog.location NULL datafusion.catalog.newlines_in_values false +datafusion.execution.adaptive_target_batch_size true datafusion.execution.batch_size 8192 datafusion.execution.coalesce_batches true datafusion.execution.collect_statistics true @@ -374,6 +375,7 @@ datafusion.catalog.has_header true Default value for `format.has_header` for `CR datafusion.catalog.information_schema true Should DataFusion provide access to `information_schema` virtual tables for displaying schema information datafusion.catalog.location NULL Location scanned to load tables for `default` schema datafusion.catalog.newlines_in_values false Specifies whether newlines in (quoted) CSV values are supported. This is the default value for `format.newlines_in_values` for `CREATE EXTERNAL TABLE` if not specified explicitly in the statement. Parsing newlines in quoted values may be affected by execution behaviour such as parallel file scanning. Setting this to `true` ensures that newlines in values are parsed successfully, which may reduce performance. +datafusion.execution.adaptive_target_batch_size true When `target_batch_size_bytes` is unset and the memory pool has a finite limit, derive a byte-size target for batches automatically from the pool's per-partition share, so queries whose batches are large relative to the memory budget re-chunk them (and can complete) instead of failing with ResourcesExhausted. Has no effect when there is no memory limit (nothing to protect: batches pass through untouched) or when `target_batch_size_bytes` is set explicitly. datafusion.execution.batch_size 8192 Default batch size while creating new batches, it's especially useful for buffer-in-memory batches since creating tiny batches would result in too much metadata memory consumption datafusion.execution.coalesce_batches true When set to true, record batches will be examined between each operator and small batches will be coalesced into larger batches. This is helpful when there are highly selective filters or joins that could produce tiny output batches. The target batch size is determined by the configuration setting datafusion.execution.collect_statistics true Should DataFusion collect statistics when first creating a table. Has no effect after the table is created. Defaults to true. diff --git a/docs/source/user-guide/configs.md b/docs/source/user-guide/configs.md index 7ba0c7b8b114a..aa4cf0268ef1f 100644 --- a/docs/source/user-guide/configs.md +++ b/docs/source/user-guide/configs.md @@ -75,6 +75,7 @@ The following configuration settings are available: | datafusion.catalog.newlines_in_values | false | Specifies whether newlines in (quoted) CSV values are supported. This is the default value for `format.newlines_in_values` for `CREATE EXTERNAL TABLE` if not specified explicitly in the statement. Parsing newlines in quoted values may be affected by execution behaviour such as parallel file scanning. Setting this to `true` ensures that newlines in values are parsed successfully, which may reduce performance. | | datafusion.execution.batch_size | 8192 | Default batch size while creating new batches, it's especially useful for buffer-in-memory batches since creating tiny batches would result in too much metadata memory consumption | | datafusion.execution.target_batch_size_bytes | NULL | Soft target, in bytes, for the in-memory size of batches, in addition to the row-based `batch_size` target. When set, data source output batches are re-chunked towards both targets: batches much larger than this (by in-memory size) are split into compact copies of roughly this size even when within `batch_size` rows -- protecting downstream operators from very large batches (e.g. wide rows with large string values) -- and small batches are coalesced until they reach either target. Batches near the targets are passed through without copying. Sorts, sort-preserving merges and aggregation spills also bound their output and spill batches to roughly this size instead of emitting `batch_size`-row batches of unbounded byte size. When `None` (the default), batches are only chunked by row count. | +| datafusion.execution.adaptive_target_batch_size | true | When `target_batch_size_bytes` is unset and the memory pool has a finite limit, derive a byte-size target for batches automatically from the pool's per-partition share, so queries whose batches are large relative to the memory budget re-chunk them (and can complete) instead of failing with ResourcesExhausted. Has no effect when there is no memory limit (nothing to protect: batches pass through untouched) or when `target_batch_size_bytes` is set explicitly. | | datafusion.execution.perfect_hash_join_small_build_threshold | 1024 | A perfect hash join (see `HashJoinExec` for more details) will be considered if the range of keys (max - min) on the build side is < this threshold. This provides a fast path for joins with very small key ranges, bypassing the density check. Currently only supports cases where build_side.num_rows() < u32::MAX. Support for build_side.num_rows() >= u32::MAX will be added in the future. | | datafusion.execution.perfect_hash_join_min_key_density | 0.15 | The minimum required density of join keys on the build side to consider a perfect hash join (see `HashJoinExec` for more details). Density is calculated as: `(number of rows) / (max_key - min_key + 1)`. A perfect hash join may be used if the actual key density > this value. Currently only supports cases where build_side.num_rows() < u32::MAX. Support for build_side.num_rows() >= u32::MAX will be added in the future. | | datafusion.execution.coalesce_batches | true | When set to true, record batches will be examined between each operator and small batches will be coalesced into larger batches. This is helpful when there are highly selective filters or joins that could produce tiny output batches. The target batch size is determined by the configuration setting | From 16a8de0a167fab73514e37f9d077f36b00b2ed1c Mon Sep 17 00:00:00 2001 From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com> Date: Thu, 9 Jul 2026 01:31:10 -0500 Subject: [PATCH 11/11] fix: GC view arrays in byte-targeted sort chunks and merge output Arrow's take and interleave copy view-array views but share the underlying data buffers, so byte-targeted sorted chunks and merged output batches pinned every source batch they drew from: sorting 1GB of 16KiB Utf8View values produced 4MB-logical batches retaining 128MB each (SortExec output_bytes=31.9GB), and downstream reservations (BatchBuilder, SortPreservingMergeExec) count retained size -- so the byte target made memory accounting worse, failing ORDER BY at a 4GB limit where row-only chunking passed. Run gc_view_arrays on IncrementalSortIterator chunks and BatchBuilder output when a byte target is set (the GC is heuristic-gated and no-ops on non-view or non-wasteful batches; row-only mode is untouched). large_values Q3 (ORDER BY val) at 4G: fails -> completes, and adaptive is now on par with row-only where both pass; the 64KiB spill sorts at 2G drop from ~2.3s to ~1.1s. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01UcPTREZVLXsSZDRCae33gm --- datafusion/physical-plan/src/sorts/builder.rs | 14 ++++- datafusion/physical-plan/src/sorts/sort.rs | 31 ++++++++++ .../src/sorts/sort_preserving_merge.rs | 60 +++++++++++++++++++ datafusion/physical-plan/src/sorts/stream.rs | 14 ++++- 4 files changed, 116 insertions(+), 3 deletions(-) diff --git a/datafusion/physical-plan/src/sorts/builder.rs b/datafusion/physical-plan/src/sorts/builder.rs index e163ae39f1247..7f2885be9b8af 100644 --- a/datafusion/physical-plan/src/sorts/builder.rs +++ b/datafusion/physical-plan/src/sorts/builder.rs @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -use crate::spill::get_record_batch_memory_size; +use crate::spill::{gc_view_arrays, get_record_batch_memory_size}; use arrow::array::ArrayRef; use arrow::compute::interleave; use arrow::datatypes::SchemaRef; @@ -232,7 +232,17 @@ impl BatchBuilder { self.reservation.shrink(self.reservation.size() - target); } - RecordBatch::try_new(Arc::clone(&self.schema), columns).map_err(Into::into) + let batch = RecordBatch::try_new(Arc::clone(&self.schema), columns)?; + if self.target_bytes.is_some() { + // `interleave` copies view-array views but shares their data + // buffers, so a byte-targeted output batch would otherwise pin + // every source batch it draws from -- inflating its retained + // size (and downstream memory reservations) far past the + // target. GC when the waste is real; no-op otherwise. Row-only + // mode (target unset) keeps today's behavior byte-for-byte. + return gc_view_arrays(&batch); + } + Ok(batch) } /// Drains the in_progress row indexes, and builds a new RecordBatch from them diff --git a/datafusion/physical-plan/src/sorts/sort.rs b/datafusion/physical-plan/src/sorts/sort.rs index 60066091e8b12..7f74bac289e2e 100644 --- a/datafusion/physical-plan/src/sorts/sort.rs +++ b/datafusion/physical-plan/src/sorts/sort.rs @@ -2952,6 +2952,37 @@ mod tests { Ok(()) } + #[tokio::test] + async fn test_sort_batch_chunked_byte_target_releases_view_buffers() -> Result<()> { + use arrow::array::StringViewArray; + // take() on view arrays shares data buffers; chunked sort output + // must GC them or each chunk pins the whole parent batch + let schema = Arc::new(Schema::new(vec![Field::new( + "s", + DataType::Utf8View, + false, + )])); + let s = StringViewArray::from_iter_values( + (0..100).rev().map(|i| format!("{i:0>1024}")), + ); + let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s)])?; + let parent_size = get_record_batch_memory_size(&batch); + + let expressions: LexOrdering = + [PhysicalSortExpr::new_default(Arc::new(Column::new("s", 0)))].into(); + let result_batches = + sort_batch_chunked(&batch, &expressions, 1000, Some(8 * 1024))?; + assert!(result_batches.len() > 1); + for chunk in &result_batches { + assert!( + get_record_batch_memory_size(chunk) < parent_size / 2, + "chunk retains {} bytes of the parent's view data buffers", + get_record_batch_memory_size(chunk) + ); + } + Ok(()) + } + #[tokio::test] async fn test_sort_exec_byte_bounded_output() -> Result<()> { use arrow::array::StringArray; diff --git a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs index c3597249cfb98..ef9d16941cf3f 100644 --- a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs +++ b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs @@ -898,6 +898,66 @@ mod tests { } } + #[tokio::test] + async fn test_merge_byte_bounded_output_releases_view_buffers() { + use crate::spill::get_record_batch_memory_size; + use crate::stream::RecordBatchStreamAdapter; + use arrow::array::StringViewArray; + use datafusion_execution::memory_pool::{MemoryPool, UnboundedMemoryPool}; + + // Utf8View inputs: arrow's interleave copies views but shares the + // underlying data buffers, so without a GC pass every merged output + // batch would pin all source batches -- inflating retained size (and + // therefore downstream memory reservations) by orders of magnitude. + let schema = Arc::new(Schema::new(vec![Field::new( + "s", + DataType::Utf8View, + false, + )])); + let source_size = 200 * 1024; // ~200KiB per source batch + let make_stream = |offset: usize| -> SendableRecordBatchStream { + let s = StringViewArray::from_iter_values( + (0..200).map(|i| format!("{:0>1024}", 2 * i + offset)), + ); + let batch = + RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(s)]).unwrap(); + Box::pin(RecordBatchStreamAdapter::new( + Arc::clone(&schema), + futures::stream::iter(vec![Ok(batch)]), + )) + }; + + let exprs: LexOrdering = + [PhysicalSortExpr::new_default(col("s", &schema).unwrap())].into(); + let target_bytes = 32 * 1024; + + let merged = StreamingMergeBuilder::new() + .with_streams(vec![make_stream(0), make_stream(1)]) + .with_schema(Arc::clone(&schema)) + .with_expressions(&exprs) + .with_metrics(BaselineMetrics::new(&ExecutionPlanMetricsSet::new(), 0)) + .with_batch_size(8192) + .with_batch_size_bytes(Some(target_bytes)) + .with_reservation({ + let pool: Arc = Arc::new(UnboundedMemoryPool::default()); + MemoryConsumer::new("test").register(&pool) + }) + .build() + .unwrap(); + + let batches = common::collect(merged).await.unwrap(); + assert!(batches.len() > 1); + assert_eq!(batches.iter().map(|b| b.num_rows()).sum::(), 400); + for batch in &batches { + assert!( + get_record_batch_memory_size(batch) < source_size, + "merged batch retains {} bytes -- it is pinning the source \ + batches' view data buffers", + get_record_batch_memory_size(batch) + ); + } + } + // Split the provided record batch into multiple batch_size record batches fn split_batch(sorted: &RecordBatch, batch_size: usize) -> Vec { let batches = sorted.num_rows().div_ceil(batch_size); diff --git a/datafusion/physical-plan/src/sorts/stream.rs b/datafusion/physical-plan/src/sorts/stream.rs index 31da91523a606..b3be7fe492454 100644 --- a/datafusion/physical-plan/src/sorts/stream.rs +++ b/datafusion/physical-plan/src/sorts/stream.rs @@ -16,7 +16,7 @@ // under the License. use crate::sorts::cursor::{ArrayValues, CursorArray, RowValues}; -use crate::spill::get_record_batch_memory_size; +use crate::spill::{gc_view_arrays, get_record_batch_memory_size}; use crate::{EmptyRecordBatchStream, SendableRecordBatchStream}; use crate::{PhysicalExpr, PhysicalSortExpr}; use arrow::array::{Array, UInt32Array}; @@ -312,6 +312,9 @@ pub(crate) struct IncrementalSortIterator { batch: RecordBatch, expressions: LexOrdering, batch_size: usize, + /// When byte-targeted, GC view arrays in each chunk: `take` shares view + /// data buffers, so an un-GC'd chunk would pin the whole parent batch + gc_views: bool, indices: Option, cursor: usize, } @@ -340,6 +343,7 @@ impl IncrementalSortIterator { batch, expressions, batch_size, + gc_views: target_bytes.is_some(), cursor: 0, indices: None, } @@ -384,6 +388,14 @@ impl Iterator for IncrementalSortIterator { Ok(batch) => batch, Err(e) => return Some(Err(e.into())), }; + let new_batch = if self.gc_views { + match gc_view_arrays(&new_batch) { + Ok(batch) => batch, + Err(e) => return Some(Err(e)), + } + } else { + new_batch + }; self.cursor += batch_size;