feat: ScanPerf objective in sampling compressor

vortex-sampling-compressor/src/compressors/alp.rs

@@ -25,6 +25,10 @@ impl EncodingCompressor for ALPCompressor {
         constants::ALP_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::ALP_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support primitive arrays
         let parray = PrimitiveArray::try_from(array).ok()?;

vortex-sampling-compressor/src/compressors/alp_rd.rs

@@ -32,6 +32,10 @@ impl EncodingCompressor for ALPRDCompressor {
         constants::ALP_RD_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::ALP_RD_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support primitive arrays
         let parray = PrimitiveArray::try_from(array).ok()?;

vortex-sampling-compressor/src/compressors/bitpacked.rs

@@ -52,6 +52,14 @@ impl EncodingCompressor for BitPackedCompressor {
         }
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        if self.allow_patches {
+            constants::BITPACKED_WITH_PATCHES_GIB_PER_S
+        } else {
+            constants::BITPACKED_NO_PATCHES_GIB_PER_S
+        }
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support primitive arrays
         let parray = PrimitiveArray::try_from(array).ok()?;

vortex-sampling-compressor/src/compressors/chunked.rs

@@ -10,7 +10,7 @@ use vortex_error::{vortex_bail, VortexResult};
 
 use super::EncoderMetadata;
 use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor};
-use crate::SamplingCompressor;
+use crate::{constants, SamplingCompressor};
 
 #[derive(Debug)]
 pub struct ChunkedCompressor {
@@ -35,7 +35,11 @@ impl EncodingCompressor for ChunkedCompressor {
     }
 
     fn cost(&self) -> u8 {
-        0
+        constants::CHUNKED_COST
+    }
+
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::CHUNKED_GIB_PER_S
     }
 
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {

vortex-sampling-compressor/src/compressors/constant.rs

@@ -21,6 +21,10 @@ impl EncodingCompressor for ConstantCompressor {
         constants::CONSTANT_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::CONSTANT_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         (!array.is_empty() && array.statistics().compute_is_constant().unwrap_or(false))
             .then_some(self as &dyn EncodingCompressor)

vortex-sampling-compressor/src/compressors/date_time_parts.rs

@@ -23,6 +23,10 @@ impl EncodingCompressor for DateTimePartsCompressor {
         constants::DATE_TIME_PARTS_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::DATE_TIME_PARTS_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         if let Ok(temporal_array) = TemporalArray::try_from(array) {
             match temporal_array.temporal_metadata() {

vortex-sampling-compressor/src/compressors/delta.rs

@@ -21,6 +21,10 @@ impl EncodingCompressor for DeltaCompressor {
         constants::DELTA_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::DELTA_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support primitive arrays
         let parray = PrimitiveArray::try_from(array).ok()?;

vortex-sampling-compressor/src/compressors/dict.rs

@@ -26,6 +26,10 @@ impl EncodingCompressor for DictCompressor {
         constants::DICT_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::DICT_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         if array.encoding().id() != Primitive::ID
             && array.encoding().id() != VarBin::ID

vortex-sampling-compressor/src/compressors/for.rs

@@ -24,6 +24,10 @@ impl EncodingCompressor for FoRCompressor {
         constants::FOR_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::FOR_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support primitive arrays
         let parray = PrimitiveArray::try_from(array).ok()?;

vortex-sampling-compressor/src/compressors/fsst.rs

@@ -36,6 +36,10 @@ impl EncodingCompressor for FSSTCompressor {
         constants::FSST_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::FSST_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &vortex_array::Array) -> Option<&dyn EncodingCompressor> {
         // FSST arrays must have DType::Utf8.
         //

vortex-sampling-compressor/src/compressors/mod.rs

@@ -32,6 +32,8 @@ pub trait EncodingCompressor: Sync + Send + Debug {
 
     fn cost(&self) -> u8;
 
+    fn decompression_gib_per_second(&self) -> f64;
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor>;
 
     fn compress<'a>(
@@ -222,6 +224,36 @@ impl<'a> CompressedArray<'a> {
     pub fn nbytes(&self) -> usize {
         self.array.nbytes()
     }
+
+    pub fn decompression_time_ms(&self, assumed_compression_ratio: f64) -> f64 {
+        const MS_PER_SEC: f64 = 1000.0;
+        const BYTES_PER_GB: f64 = 1_073_741_824.0;
+        let children_time = self
+            .path()
+            .iter()
+            .map(|c| {
+                c.children
+                    .iter()
+                    .zip(self.array.children().iter())
+                    .map(|(c, a)| {
+                        CompressedArray::new(a.clone(), c.clone())
+                            .decompression_time_ms(assumed_compression_ratio)
+                    })
+                    .sum::<f64>()
+            })
+            .sum::<f64>();
+        children_time
+            + self
+                .path()
+                .as_ref()
+                .map(|c| {
+                    (MS_PER_SEC / c.compressor().decompression_gib_per_second())
+                        * assumed_compression_ratio
+                        * self.nbytes() as f64
+                        / BYTES_PER_GB
+                })
+                .unwrap_or(0.0)
+    }
 }
 
 impl AsRef<Array> for CompressedArray<'_> {

vortex-sampling-compressor/src/compressors/roaring_bool.rs

@@ -22,6 +22,10 @@ impl EncodingCompressor for RoaringBoolCompressor {
         constants::ROARING_BOOL_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::ROARING_BOOL_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support bool arrays
         if array.encoding().id() != Bool::ID {

vortex-sampling-compressor/src/compressors/roaring_int.rs

@@ -20,6 +20,10 @@ impl EncodingCompressor for RoaringIntCompressor {
         constants::ROARING_INT_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::ROARING_INT_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support non-nullable uint arrays
         if !array.dtype().is_unsigned_int() || array.dtype().is_nullable() {

vortex-sampling-compressor/src/compressors/runend.rs

@@ -26,6 +26,10 @@ impl EncodingCompressor for RunEndCompressor {
         constants::RUN_END_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::RUN_END_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         if array.encoding().id() != Primitive::ID {
             return None;

vortex-sampling-compressor/src/compressors/sparse.rs

@@ -19,6 +19,10 @@ impl EncodingCompressor for SparseCompressor {
         constants::SPARSE_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::SPARSE_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         array.is_encoding(Sparse::ID).then_some(self)
     }

vortex-sampling-compressor/src/compressors/struct_.rs

@@ -7,7 +7,7 @@ use vortex_array::{Array, ArrayDef, IntoArray};
 use vortex_error::VortexResult;
 
 use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor};
-use crate::SamplingCompressor;
+use crate::{constants, SamplingCompressor};
 
 #[derive(Debug)]
 pub struct StructCompressor;
@@ -18,7 +18,11 @@ impl EncodingCompressor for StructCompressor {
     }
 
     fn cost(&self) -> u8 {
-        0
+        constants::STRUCT_COST
+    }
+
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::STRUCT_GIB_PER_S
     }
 
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {

vortex-sampling-compressor/src/compressors/zigzag.rs

@@ -22,6 +22,10 @@ impl EncodingCompressor for ZigZagCompressor {
         constants::ZIGZAG_COST
     }
 
+    fn decompression_gib_per_second(&self) -> f64 {
+        constants::ZIGZAG_GIB_PER_S
+    }
+
     fn can_compress(&self, array: &Array) -> Option<&dyn EncodingCompressor> {
         // Only support primitive arrays
         let parray = PrimitiveArray::try_from(array).ok()?;

vortex-sampling-compressor/src/constants.rs

@@ -1,26 +1,53 @@
 #![allow(dead_code)]
+#![allow(unused_imports)]
 
-// structural pass-throughs have no cost
-pub const SPARSE_COST: u8 = 0;
-// TODO: struct
-// TODO: chunked
+pub use cost::*;
+pub use decompression::*;
 
-// so fast that we can ignore the cost
-pub const BITPACKED_NO_PATCHES_COST: u8 = 0;
-pub const BITPACKED_WITH_PATCHES_COST: u8 = 0;
-pub const CONSTANT_COST: u8 = 0;
-pub const ZIGZAG_COST: u8 = 0;
+mod cost {
+    // structural pass-throughs have no cost
+    pub const SPARSE_COST: u8 = 0;
+    pub const STRUCT_COST: u8 = 0;
+    pub const CHUNKED_COST: u8 = 0;
 
-// "normal" encodings
-pub const ALP_COST: u8 = 1;
-pub const ALP_RD_COST: u8 = 1;
-pub const DATE_TIME_PARTS_COST: u8 = 1;
-pub const DICT_COST: u8 = 1;
-pub const FOR_COST: u8 = 1;
-pub const FSST_COST: u8 = 1;
-pub const ROARING_BOOL_COST: u8 = 1;
-pub const ROARING_INT_COST: u8 = 1;
-pub const RUN_END_COST: u8 = 1;
+    // so fast that we can ignore the cost
+    pub const BITPACKED_NO_PATCHES_COST: u8 = 0;
+    pub const BITPACKED_WITH_PATCHES_COST: u8 = 0;
+    pub const CONSTANT_COST: u8 = 0;
+    pub const ZIGZAG_COST: u8 = 0;
 
-// "expensive" encodings
-pub const DELTA_COST: u8 = 2;
+    // "normal" encodings
+    pub const ALP_COST: u8 = 1;
+    pub const ALP_RD_COST: u8 = 1;
+    pub const DATE_TIME_PARTS_COST: u8 = 1;
+    pub const DICT_COST: u8 = 1;
+    pub const FOR_COST: u8 = 1;
+    pub const FSST_COST: u8 = 1;
+    pub const ROARING_BOOL_COST: u8 = 1;
+    pub const ROARING_INT_COST: u8 = 1;
+    pub const RUN_END_COST: u8 = 1;
+    pub const DELTA_COST: u8 = 1;
+}
+
+mod decompression {
+    // structural pass-throughs
+    pub const SPARSE_GIB_PER_S: f64 = f64::INFINITY;
+    pub const STRUCT_GIB_PER_S: f64 = f64::INFINITY;
+    pub const CHUNKED_GIB_PER_S: f64 = f64::INFINITY;
+
+    // benchmarked decompression throughput
+    pub const ALP_GIB_PER_S: f64 = 4.9;
+    pub const ALP_RD_GIB_PER_S: f64 = 3.3;
+    pub const BITPACKED_NO_PATCHES_GIB_PER_S: f64 = 36.0;
+    pub const BITPACKED_WITH_PATCHES_GIB_PER_S: f64 = 33.2;
+    pub const CONSTANT_GIB_PER_S: f64 = 200.0;
+    pub const DATE_TIME_PARTS_GIB_PER_S: f64 = 20.0; // this is a guess
+    pub const DELTA_GIB_PER_S: f64 = 4.7;
+    pub const DICT_GIB_PER_S: f64 = 10.0;
+    pub const FOR_GIB_PER_S: f64 = 8.7;
+    pub const FSST_GIB_PER_S: f64 = 2.0;
+    pub const ROARING_BOOL_GIB_PER_S: f64 = 5.0;
+    pub const ROARING_INT_GIB_PER_S: f64 = 5.0;
+    pub const RUN_END_GIB_PER_S: f64 = 10.0;
+    pub const ZIGZAG_GIB_PER_S: f64 = 25.5;
+}