Apache DataFusion SQL Query Engine
fix(physical-plan): replace approximate `map_size` accounting with exact `HashTable::allocation_size()` in `GroupValuesRows` (#25750)
Mohit Gurav4d167a167228
diff --git a/datafusion/physical-plan/src/aggregates/group_values/row.rs b/datafusion/physical-plan/src/aggregates/group_values/row.rsindex 01e9f3eaa7..1bbd3e2297 100644--- a/datafusion/physical-plan/src/aggregates/group_values/row.rs+++ b/datafusion/physical-plan/src/aggregates/group_values/row.rs@@ -28,11 +28,10 @@ use datafusion_common::Result;use datafusion_common::hash_utils::RandomState;use datafusion_common::hash_utils::create_hashes;use datafusion_common::utils::normalize_float_zero;-use datafusion_execution::memory_pool::proxy::{HashTableAllocExt, VecAllocExt};+use datafusion_execution::memory_pool::proxy::VecAllocExt;use datafusion_expr::{EmitTo, GroupSelection};use hashbrown::hash_table::HashTable;use log::debug;-use std::mem::size_of;use std::sync::Arc;/// A [`GroupValues`] making use of [`Rows`]@@ -60,9 +59,6 @@ pub struct GroupValuesRows {/// values: (hash, group_index)map: HashTable<(u64, usize)>,- /// The size of `map` in bytes- map_size: usize,-/// The actual group by values, stored in arrow [`Row`] format./// `group_values[i]` holds the group value for group_index `i`.///@@ -107,7 +103,6 @@ impl GroupValuesRows {schema,row_converter,map,- map_size: 0,group_values: None,hashes_buffer: Default::default(),rows_buffer,@@ -168,10 +163,10 @@ impl GroupValues for GroupValuesRows {group_values.push(group_rows.row(row));// for hasher function, use precomputed hash value- self.map.insert_accounted(+ self.map.insert_unique(+ target_hash,(target_hash, group_idx),|(hash, _group_index)| *hash,- &mut self.map_size,);group_idx}@@ -186,9 +181,11 @@ impl GroupValues for GroupValuesRows {fn size(&self) -> usize {let group_values_size = self.group_values.as_ref().map(|v| v.size()).unwrap_or(0);+ // `HashTable::allocation_size` reports the complete hashbrown allocation,+ // which includes the entry array, control bytes, and trailing group layout.self.row_converter.size()+ group_values_size- + self.map_size+ + self.map.allocation_size()+ self.rows_buffer.size()+ self.hashes_buffer.allocated_size()}@@ -289,7 +286,6 @@ impl GroupValues for GroupValuesRows {});self.map.clear();self.map.shrink_to(num_rows, |_| 0); // hasher does not matter since the map is cleared- self.map_size = self.map.capacity() * size_of::<(u64, usize)>();self.hashes_buffer.clear();self.hashes_buffer.shrink_to(num_rows);}@@ -443,8 +439,9 @@ pub(crate) fn encode_array_if_necessary(#[cfg(test)]mod tests {use super::*;- use arrow::array::{AsArray, ListArray};+ use arrow::array::{AsArray, Int32Array, ListArray, StringArray};use arrow::datatypes::{Field, Int32Type, Schema};+ use std::mem::size_of;#[test]fn preserving_nested_row_values() -> Result<()> {@@ -484,4 +481,176 @@ mod tests {assert_eq!(groups, vec![3]);Ok(())}++ #[test]+ fn test_exact_hash_table_allocation_accounting_multi_column() -> Result<()> {+ let schema = Arc::new(Schema::new(vec![+ Field::new("a", DataType::Int32, true),+ Field::new("b", DataType::Utf8, true),+ ]));+ let mut group_values = GroupValuesRows::try_new(schema)?;++ // 1. Initial state: map is unallocated+ assert_eq!(group_values.map.capacity(), 0);+ assert_eq!(group_values.map.allocation_size(), 0);+ assert_eq!(+ group_values.size(),+ group_values.row_converter.size()+ + group_values.rows_buffer.size()+ + group_values.hashes_buffer.allocated_size()+ );++ // 2. Insert multi-column keys and observe table allocation growth+ let num_distinct = 500;+ let col_a = Arc::new(Int32Array::from_iter_values(0..num_distinct)) as ArrayRef;+ let col_b = Arc::new(StringArray::from_iter_values(+ (0..num_distinct).map(|i| format!("key_string_{i}")),+ )) as ArrayRef;++ let mut groups = vec![];+ group_values.intern(&[col_a, col_b], &mut groups)?;+ assert_eq!(groups.len(), num_distinct as usize);++ let table_bytes = group_values.map.allocation_size();+ assert!(group_values.map.capacity() >= num_distinct as usize);+ assert!(table_bytes > 0);++ // Hashbrown's layout contains entry slots, control bytes, and trailing group bytes.+ // It must strictly exceed the naive entry-only size: capacity * size_of::<(u64, usize)>().+ let entry_only_bytes = group_values.map.capacity() * size_of::<(u64, usize)>();+ assert!(+ table_bytes > entry_only_bytes,+ "allocation_size ({table_bytes}) must exceed entry-only capacity ({entry_only_bytes})"+ );++ // GroupValuesRows::size() should accurately account for the map's allocation_size+ let expected_size = group_values.row_converter.size()+ + group_values+ .group_values+ .as_ref()+ .map(|v| v.size())+ .unwrap_or(0)+ + table_bytes+ + group_values.rows_buffer.size()+ + group_values.hashes_buffer.allocated_size();+ assert_eq!(group_values.size(), expected_size);++ // 3. Partial emit (EmitTo::First) - table retains entries and capacity+ let emit_count = 200;+ let emitted = group_values.emit(EmitTo::First(emit_count))?;+ assert_eq!(emitted[0].len(), emit_count);+ assert_eq!(group_values.len(), (num_distinct as usize) - emit_count);++ // Retained capacity is still charged until the table releases it+ assert_eq!(group_values.map.allocation_size(), table_bytes);+ assert_eq!(+ group_values.size(),+ group_values.row_converter.size()+ + group_values+ .group_values+ .as_ref()+ .map(|v| v.size())+ .unwrap_or(0)+ + table_bytes+ + group_values.rows_buffer.size()+ + group_values.hashes_buffer.allocated_size()+ );++ // 4. Emit all (EmitTo::All) - map is cleared but capacity remains allocated for reuse+ let remaining_count = group_values.len();+ let emitted_all = group_values.emit(EmitTo::All)?;+ assert_eq!(emitted_all[0].len(), remaining_count);+ assert_eq!(group_values.len(), 0);++ // Clear preserves table capacity+ assert_eq!(group_values.map.allocation_size(), table_bytes);++ // 5. clear_shrink: releases/shrinks map capacity+ group_values.clear_shrink(16);+ let shrunken_table_bytes = group_values.map.allocation_size();+ assert!(+ shrunken_table_bytes < table_bytes,+ "clear_shrink should shrink table from {table_bytes} to {shrunken_table_bytes}"+ );+ assert_eq!(+ group_values.size(),+ group_values.row_converter.size()+ + group_values+ .group_values+ .as_ref()+ .map(|v| v.size())+ .unwrap_or(0)+ + shrunken_table_bytes+ + group_values.rows_buffer.size()+ + group_values.hashes_buffer.allocated_size()+ );++ // 6. Reinsert new distinct values into the shrunken table+ let new_col_a =+ Arc::new(Int32Array::from_iter_values(num_distinct..num_distinct * 2))+ as ArrayRef;+ let new_col_b = Arc::new(StringArray::from_iter_values(+ (num_distinct..num_distinct * 2).map(|i| format!("key_string_{i}")),+ )) as ArrayRef;+ group_values.intern(&[new_col_a, new_col_b], &mut groups)?;+ assert_eq!(groups.len(), num_distinct as usize);+ assert!(group_values.map.allocation_size() > shrunken_table_bytes);+ assert_eq!(+ group_values.size(),+ group_values.row_converter.size()+ + group_values+ .group_values+ .as_ref()+ .map(|v| v.size())+ .unwrap_or(0)+ + group_values.map.allocation_size()+ + group_values.rows_buffer.size()+ + group_values.hashes_buffer.allocated_size()+ );++ Ok(())+ }++ #[test]+ fn test_exact_hash_table_allocation_accounting_nested_keys() -> Result<()> {+ let field = Arc::new(Field::new_list_field(DataType::Int32, true));+ let schema = Arc::new(Schema::new(vec![Field::new(+ "nested",+ DataType::List(field),+ true,+ )]));+ let mut group_values = GroupValuesRows::try_new(schema)?;++ assert_eq!(group_values.map.capacity(), 0);+ assert_eq!(group_values.map.allocation_size(), 0);++ let input = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(+ (0..256).map(|i| Some(vec![Some(i), Some(i * 2)])),+ )) as ArrayRef;+ let mut groups = vec![];+ group_values.intern(&[input], &mut groups)?;+ assert_eq!(groups.len(), 256);++ let table_bytes = group_values.map.allocation_size();+ assert!(table_bytes > 0);+ assert_eq!(+ group_values.size(),+ group_values.row_converter.size()+ + group_values+ .group_values+ .as_ref()+ .map(|v| v.size())+ .unwrap_or(0)+ + table_bytes+ + group_values.rows_buffer.size()+ + group_values.hashes_buffer.allocated_size()+ );++ // Shrink to 0: table should completely deallocate+ group_values.clear_shrink(0);+ assert_eq!(group_values.map.capacity(), 0);+ assert_eq!(group_values.map.allocation_size(), 0);++ Ok(())+ }}