Remove generic rle (#7350)

## Summary

Tracking issue: #7216

We have this generic RLE code from the old compressor that doesn't make
as much sense anymore.
This change hardcodes the 2 schemes (int and float) instead of using
generics that make things harder to trace.

This is a purely cosmetic change.

## API Changes

Removes olds constants and just has `FloatRLEScheme` and `IntRLEScheme`.

## Testing

<!--
Please describe how this change was tested. Here are some common
categories for
testing in Vortex:

1. Verifying existing behavior is maintained.
2. Verifying new behavior and functionality works correctly.
3. Serialization compatibility (backwards and forwards) should be
maintained or
   explicitly broken.
-->

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-btrblocks/public-api.lock

@@ -138,6 +138,42 @@ pub fn vortex_btrblocks::schemes::float::ALPScheme::num_children(&self) -> usize
 
 pub fn vortex_btrblocks::schemes::float::ALPScheme::scheme_name(&self) -> &'static str
 
+pub struct vortex_btrblocks::schemes::float::FloatRLEScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::clone(&self) -> vortex_btrblocks::schemes::float::FloatRLEScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::eq(&self, other: &vortex_btrblocks::schemes::float::FloatRLEScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::float::FloatRLEScheme
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::scheme_name(&self) -> &'static str
+
 pub struct vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
 impl core::clone::Clone for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
@@ -202,8 +238,6 @@ pub fn vortex_btrblocks::schemes::float::PcoScheme::matches(&self, canonical: &v
 
 pub fn vortex_btrblocks::schemes::float::PcoScheme::scheme_name(&self) -> &'static str
 
-pub const vortex_btrblocks::schemes::float::RLE_FLOAT_SCHEME: vortex_btrblocks::schemes::rle::RLEScheme<vortex_btrblocks::schemes::rle::FloatRLEConfig>
-
 pub mod vortex_btrblocks::schemes::integer
 
 pub use vortex_btrblocks::schemes::integer::IntConstantScheme
@@ -276,6 +310,42 @@ pub fn vortex_btrblocks::schemes::integer::FoRScheme::matches(&self, canonical:
 
 pub fn vortex_btrblocks::schemes::integer::FoRScheme::scheme_name(&self) -> &'static str
 
+pub struct vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::clone(&self) -> vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::IntRLEScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::scheme_name(&self) -> &'static str
+
 pub struct vortex_btrblocks::schemes::integer::PcoScheme
 
 impl core::clone::Clone for vortex_btrblocks::schemes::integer::PcoScheme
@@ -446,8 +516,6 @@ pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::num_children(&self) ->
 
 pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::scheme_name(&self) -> &'static str
 
-pub const vortex_btrblocks::schemes::integer::RLE_INTEGER_SCHEME: vortex_btrblocks::schemes::rle::RLEScheme<vortex_btrblocks::schemes::rle::IntRLEConfig>
-
 pub mod vortex_btrblocks::schemes::string
 
 pub use vortex_btrblocks::schemes::string::StringConstantScheme

vortex-btrblocks/src/builder.rs

@@ -14,7 +14,6 @@ use crate::schemes::bool;
 use crate::schemes::decimal;
 use crate::schemes::float;
 use crate::schemes::integer;
-use crate::schemes::rle;
 use crate::schemes::string;
 use crate::schemes::temporal;
 
@@ -40,7 +39,7 @@ pub const ALL_SCHEMES: &[&dyn Scheme] = &[
     &integer::IntDictScheme,
     &integer::RunEndScheme,
     &integer::SequenceScheme,
-    &rle::RLE_INTEGER_SCHEME,
+    &integer::IntRLEScheme,
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Float schemes.
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -49,7 +48,7 @@ pub const ALL_SCHEMES: &[&dyn Scheme] = &[
     &float::ALPRDScheme,
     &float::FloatDictScheme,
     &float::NullDominatedSparseScheme,
-    &rle::RLE_FLOAT_SCHEME,
+    &float::FloatRLEScheme,
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // String schemes.
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -162,8 +161,8 @@ impl BtrBlocksCompressorBuilder {
     pub fn only_cuda_compatible(self) -> Self {
         let builder = self.exclude_schemes([
             integer::SparseScheme.id(),
-            rle::RLE_INTEGER_SCHEME.id(),
-            rle::RLE_FLOAT_SCHEME.id(),
+            integer::IntRLEScheme.id(),
+            float::FloatRLEScheme.id(),
             float::NullDominatedSparseScheme.id(),
             string::StringDictScheme.id(),
             string::FSSTScheme.id(),

vortex-btrblocks/src/schemes/float.rs

@@ -29,6 +29,8 @@ use crate::CompressorContext;
 use crate::Scheme;
 use crate::SchemeExt;
 use crate::compress_patches;
+use crate::schemes::rle_ancestor_exclusions;
+use crate::schemes::rle_descendant_exclusions;
 
 /// ALP (Adaptive Lossless floating-Point) encoding.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -55,7 +57,9 @@ pub use vortex_compressor::builtins::FloatDictScheme;
 pub use vortex_compressor::builtins::is_float_primitive;
 pub use vortex_compressor::stats::FloatStats;
 
-pub use crate::schemes::rle::RLE_FLOAT_SCHEME;
+/// RLE scheme for float arrays.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct FloatRLEScheme;
 
 impl Scheme for ALPScheme {
     fn scheme_name(&self) -> &'static str {
@@ -269,6 +273,55 @@ impl Scheme for PcoScheme {
     }
 }
 
+impl Scheme for FloatRLEScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.rle"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    /// Children: values=0, indices=1, offsets=2.
+    fn num_children(&self) -> usize {
+        3
+    }
+
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        rle_descendant_exclusions()
+    }
+
+    fn ancestor_exclusions(&self) -> Vec<vortex_compressor::scheme::AncestorExclusion> {
+        rle_ancestor_exclusions()
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // RLE is only useful when we cascade it with another encoding.
+        if ctx.finished_cascading() {
+            return CompressionEstimate::Skip;
+        }
+
+        if data.float_stats().average_run_length() < super::integer::RUN_LENGTH_THRESHOLD {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        super::integer::rle_compress(self, compressor, data, ctx)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::iter;
@@ -288,7 +341,7 @@ mod tests {
     use vortex_fastlanes::RLE;
 
     use crate::BtrBlocksCompressor;
-    use crate::schemes::rle::RLE_FLOAT_SCHEME;
+    use crate::schemes::float::FloatRLEScheme;
 
     #[test]
     fn test_empty() -> VortexResult<()> {
@@ -330,7 +383,7 @@ mod tests {
 
         let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
 
-        let compressor = CascadingCompressor::new(vec![&RLE_FLOAT_SCHEME]);
+        let compressor = CascadingCompressor::new(vec![&FloatRLEScheme]);
         let compressed = compressor.compress(&array.into_array())?;
         assert!(compressed.is::<RLE>());