perf: optimize iterative exe

encodings/alp/src/alp/rules.rs

@@ -4,26 +4,41 @@
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::arrays::filter::FilterExecuteAdaptor;
 use vortex_array::arrays::slice::SliceExecuteAdaptor;
+use vortex_array::kernel::ParentKernelDense;
+use vortex_array::kernel::ParentKernelEntry;
 use vortex_array::kernel::ParentKernelSet;
+use vortex_array::optimizer::rules::ParentRuleDense;
+use vortex_array::optimizer::rules::ParentRuleEntry;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
+use vortex_session::registry::CachedId;
 
 use crate::ALP;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<ALP> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(ALP)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ALP)),
-    ParentKernelSet::lift(&MaskExecuteAdaptor(ALP)),
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ALP)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ALP)),
-]);
-
-pub(super) const RULES: ParentRuleSet<ALP> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&BetweenReduceAdaptor(ALP)),
-    ParentRuleSet::lift(&CastReduceAdaptor(ALP)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ALP)),
-]);
+static KEYED_PARENT_KERNELS: [ParentKernelEntry<ALP>; 5] = [
+    ParentKernelSet::lift_id(CachedId::new("vortex.binary"), &CompareExecuteAdaptor(ALP)),
+    ParentKernelSet::lift_id(CachedId::new("vortex.filter"), &FilterExecuteAdaptor(ALP)),
+    ParentKernelSet::lift_id(CachedId::new("vortex.mask"), &MaskExecuteAdaptor(ALP)),
+    ParentKernelSet::lift_id(CachedId::new("vortex.slice"), &SliceExecuteAdaptor(ALP)),
+    ParentKernelSet::lift_id(CachedId::new("vortex.dict"), &TakeExecuteAdaptor(ALP)),
+];
+
+static KEYED_PARENT_KERNELS_DENSE: ParentKernelDense<ALP> = ParentKernelDense::new();
+
+pub(super) static PARENT_KERNELS: ParentKernelSet<ALP> =
+    ParentKernelSet::new_indexed(&KEYED_PARENT_KERNELS, &KEYED_PARENT_KERNELS_DENSE, &[]);
+
+static KEYED_PARENT_RULES: [ParentRuleEntry<ALP>; 3] = [
+    ParentRuleSet::lift_id(CachedId::new("vortex.between"), &BetweenReduceAdaptor(ALP)),
+    ParentRuleSet::lift_id(CachedId::new("vortex.cast"), &CastReduceAdaptor(ALP)),
+    ParentRuleSet::lift_id(CachedId::new("vortex.mask"), &MaskReduceAdaptor(ALP)),
+];
+
+static KEYED_PARENT_RULES_DENSE: ParentRuleDense<ALP> = ParentRuleDense::new();
+
+pub(super) static RULES: ParentRuleSet<ALP> =
+    ParentRuleSet::new_indexed(&KEYED_PARENT_RULES, &KEYED_PARENT_RULES_DENSE, &[]);

encodings/alp/src/alp_rd/kernel.rs

@@ -4,12 +4,20 @@
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::arrays::filter::FilterExecuteAdaptor;
 use vortex_array::arrays::slice::SliceExecuteAdaptor;
+use vortex_array::kernel::ParentKernelDense;
+use vortex_array::kernel::ParentKernelEntry;
 use vortex_array::kernel::ParentKernelSet;
+use vortex_session::registry::CachedId;
 
 use crate::alp_rd::ALPRD;
 
-pub(crate) static PARENT_KERNELS: ParentKernelSet<ALPRD> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPRD)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPRD)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPRD)),
-]);
+static KEYED_PARENT_KERNELS: [ParentKernelEntry<ALPRD>; 3] = [
+    ParentKernelSet::lift_id(CachedId::new("vortex.slice"), &SliceExecuteAdaptor(ALPRD)),
+    ParentKernelSet::lift_id(CachedId::new("vortex.filter"), &FilterExecuteAdaptor(ALPRD)),
+    ParentKernelSet::lift_id(CachedId::new("vortex.dict"), &TakeExecuteAdaptor(ALPRD)),
+];
+
+static KEYED_PARENT_KERNELS_DENSE: ParentKernelDense<ALPRD> = ParentKernelDense::new();
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<ALPRD> =
+    ParentKernelSet::new_indexed(&KEYED_PARENT_KERNELS, &KEYED_PARENT_KERNELS_DENSE, &[]);

encodings/alp/src/alp_rd/rules.rs

@@ -1,13 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::optimizer::rules::ParentRuleDense;
+use vortex_array::optimizer::rules::ParentRuleEntry;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
+use vortex_session::registry::CachedId;
 
 use crate::alp_rd::ALPRD;
 
-pub(crate) static RULES: ParentRuleSet<ALPRD> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ALPRD)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ALPRD)),
-]);
+static KEYED_PARENT_RULES: [ParentRuleEntry<ALPRD>; 2] = [
+    ParentRuleSet::lift_id(CachedId::new("vortex.cast"), &CastReduceAdaptor(ALPRD)),
+    ParentRuleSet::lift_id(CachedId::new("vortex.mask"), &MaskReduceAdaptor(ALPRD)),
+];
+
+static KEYED_PARENT_RULES_DENSE: ParentRuleDense<ALPRD> = ParentRuleDense::new();
+
+pub(crate) static RULES: ParentRuleSet<ALPRD> =
+    ParentRuleSet::new_indexed(&KEYED_PARENT_RULES, &KEYED_PARENT_RULES_DENSE, &[]);

encodings/bytebool/src/kernel.rs

@@ -2,9 +2,19 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::kernel::ParentKernelDense;
+use vortex_array::kernel::ParentKernelEntry;
 use vortex_array::kernel::ParentKernelSet;
+use vortex_session::registry::CachedId;
 
 use crate::ByteBool;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<ByteBool> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(ByteBool))]);
+static KEYED_PARENT_KERNELS: [ParentKernelEntry<ByteBool>; 1] = [ParentKernelSet::lift_id(
+    CachedId::new("vortex.dict"),
+    &TakeExecuteAdaptor(ByteBool),
+)];
+
+static KEYED_PARENT_KERNELS_DENSE: ParentKernelDense<ByteBool> = ParentKernelDense::new();
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<ByteBool> =
+    ParentKernelSet::new_indexed(&KEYED_PARENT_KERNELS, &KEYED_PARENT_KERNELS_DENSE, &[]);

encodings/bytebool/src/rules.rs

@@ -2,14 +2,22 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::arrays::slice::SliceReduceAdaptor;
+use vortex_array::optimizer::rules::ParentRuleDense;
+use vortex_array::optimizer::rules::ParentRuleEntry;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
+use vortex_session::registry::CachedId;
 
 use crate::ByteBool;
 
-pub(crate) static RULES: ParentRuleSet<ByteBool> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ByteBool)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ByteBool)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ByteBool)),
-]);
+static KEYED_PARENT_RULES: [ParentRuleEntry<ByteBool>; 3] = [
+    ParentRuleSet::lift_id(CachedId::new("vortex.cast"), &CastReduceAdaptor(ByteBool)),
+    ParentRuleSet::lift_id(CachedId::new("vortex.mask"), &MaskReduceAdaptor(ByteBool)),
+    ParentRuleSet::lift_id(CachedId::new("vortex.slice"), &SliceReduceAdaptor(ByteBool)),
+];
+
+static KEYED_PARENT_RULES_DENSE: ParentRuleDense<ByteBool> = ParentRuleDense::new();
+
+pub(crate) static RULES: ParentRuleSet<ByteBool> =
+    ParentRuleSet::new_indexed(&KEYED_PARENT_RULES, &KEYED_PARENT_RULES_DENSE, &[]);

encodings/datetime-parts/src/compute/kernel.rs

@@ -2,12 +2,26 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::kernel::ParentKernelDense;
+use vortex_array::kernel::ParentKernelEntry;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
+use vortex_session::registry::CachedId;
 
 use crate::DateTimeParts;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<DateTimeParts> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(DateTimeParts)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(DateTimeParts)),
-]);
+static KEYED_PARENT_KERNELS: [ParentKernelEntry<DateTimeParts>; 2] = [
+    ParentKernelSet::lift_id(
+        CachedId::new("vortex.binary"),
+        &CompareExecuteAdaptor(DateTimeParts),
+    ),
+    ParentKernelSet::lift_id(
+        CachedId::new("vortex.dict"),
+        &TakeExecuteAdaptor(DateTimeParts),
+    ),
+];
+
+static KEYED_PARENT_KERNELS_DENSE: ParentKernelDense<DateTimeParts> = ParentKernelDense::new();
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<DateTimeParts> =
+    ParentKernelSet::new_indexed(&KEYED_PARENT_KERNELS, &KEYED_PARENT_KERNELS_DENSE, &[]);

encodings/datetime-parts/src/compute/rules.rs

@@ -18,25 +18,50 @@ use vortex_array::dtype::DType;
 use vortex_array::extension::datetime::Timestamp;
 use vortex_array::optimizer::ArrayOptimizer;
 use vortex_array::optimizer::rules::ArrayParentReduceRule;
+use vortex_array::optimizer::rules::ParentRuleDense;
+use vortex_array::optimizer::rules::ParentRuleEntry;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::between::Between;
 use vortex_array::scalar_fn::fns::binary::Binary;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_session::registry::CachedId;
 
 use crate::DateTimeParts;
 use crate::array::DateTimePartsArrayExt;
 use crate::timestamp;
-pub(crate) const PARENT_RULES: ParentRuleSet<DateTimeParts> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&DTPFilterPushDownRule),
-    ParentRuleSet::lift(&DTPComparisonPushDownRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(DateTimeParts)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(DateTimeParts)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(DateTimeParts)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(DateTimeParts)),
-]);
+
+static KEYED_PARENT_RULES: [ParentRuleEntry<DateTimeParts>; 4] = [
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.cast"),
+        &CastReduceAdaptor(DateTimeParts),
+    ),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.filter"),
+        &FilterReduceAdaptor(DateTimeParts),
+    ),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.mask"),
+        &MaskReduceAdaptor(DateTimeParts),
+    ),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.slice"),
+        &SliceReduceAdaptor(DateTimeParts),
+    ),
+];
+
+static KEYED_PARENT_RULES_DENSE: ParentRuleDense<DateTimeParts> = ParentRuleDense::new();
+
+pub(crate) static PARENT_RULES: ParentRuleSet<DateTimeParts> = ParentRuleSet::new_indexed(
+    &KEYED_PARENT_RULES,
+    &KEYED_PARENT_RULES_DENSE,
+    &[
+        ParentRuleSet::lift(&DTPFilterPushDownRule),
+        ParentRuleSet::lift(&DTPComparisonPushDownRule),
+    ],
+);
 
 /// Push the filter into the days column of a date time parts, we could extend this to other fields
 /// but its less clear if that is beneficial.

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/kernel.rs

@@ -2,12 +2,26 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::kernel::ParentKernelDense;
+use vortex_array::kernel::ParentKernelEntry;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
+use vortex_session::registry::CachedId;
 
 use crate::DecimalByteParts;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<DecimalByteParts> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(DecimalByteParts)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(DecimalByteParts)),
-]);
+static KEYED_PARENT_KERNELS: [ParentKernelEntry<DecimalByteParts>; 2] = [
+    ParentKernelSet::lift_id(
+        CachedId::new("vortex.binary"),
+        &CompareExecuteAdaptor(DecimalByteParts),
+    ),
+    ParentKernelSet::lift_id(
+        CachedId::new("vortex.dict"),
+        &TakeExecuteAdaptor(DecimalByteParts),
+    ),
+];
+
+static KEYED_PARENT_KERNELS_DENSE: ParentKernelDense<DecimalByteParts> = ParentKernelDense::new();
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<DecimalByteParts> =
+    ParentKernelSet::new_indexed(&KEYED_PARENT_KERNELS, &KEYED_PARENT_KERNELS_DENSE, &[]);

encodings/decimal-byte-parts/src/decimal_byte_parts/rules.rs

@@ -8,22 +8,44 @@ use vortex_array::arrays::Filter;
 use vortex_array::arrays::filter::FilterReduceAdaptor;
 use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ArrayParentReduceRule;
+use vortex_array::optimizer::rules::ParentRuleDense;
+use vortex_array::optimizer::rules::ParentRuleEntry;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_session::registry::CachedId;
 
 use crate::DecimalByteParts;
 use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 
-pub(super) const PARENT_RULES: ParentRuleSet<DecimalByteParts> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&DecimalBytePartsFilterPushDownRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(DecimalByteParts)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(DecimalByteParts)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(DecimalByteParts)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(DecimalByteParts)),
-]);
+static KEYED_PARENT_RULES: [ParentRuleEntry<DecimalByteParts>; 4] = [
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.cast"),
+        &CastReduceAdaptor(DecimalByteParts),
+    ),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.filter"),
+        &FilterReduceAdaptor(DecimalByteParts),
+    ),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.mask"),
+        &MaskReduceAdaptor(DecimalByteParts),
+    ),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.slice"),
+        &SliceReduceAdaptor(DecimalByteParts),
+    ),
+];
+
+static KEYED_PARENT_RULES_DENSE: ParentRuleDense<DecimalByteParts> = ParentRuleDense::new();
+
+pub(super) static PARENT_RULES: ParentRuleSet<DecimalByteParts> = ParentRuleSet::new_indexed(
+    &KEYED_PARENT_RULES,
+    &KEYED_PARENT_RULES_DENSE,
+    &[ParentRuleSet::lift(&DecimalBytePartsFilterPushDownRule)],
+);
 
 #[derive(Debug)]
 struct DecimalBytePartsFilterPushDownRule;

encodings/fastlanes/src/bitpacking/vtable/kernels.rs

@@ -3,11 +3,22 @@
 
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::arrays::filter::FilterExecuteAdaptor;
+use vortex_array::kernel::ParentKernelDense;
+use vortex_array::kernel::ParentKernelEntry;
 use vortex_array::kernel::ParentKernelSet;
+use vortex_session::registry::CachedId;
 
 use crate::BitPacked;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<BitPacked> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&FilterExecuteAdaptor(BitPacked)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(BitPacked)),
-]);
+static KEYED_PARENT_KERNELS: [ParentKernelEntry<BitPacked>; 2] = [
+    ParentKernelSet::lift_id(
+        CachedId::new("vortex.filter"),
+        &FilterExecuteAdaptor(BitPacked),
+    ),
+    ParentKernelSet::lift_id(CachedId::new("vortex.dict"), &TakeExecuteAdaptor(BitPacked)),
+];
+
+static KEYED_PARENT_KERNELS_DENSE: ParentKernelDense<BitPacked> = ParentKernelDense::new();
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<BitPacked> =
+    ParentKernelSet::new_indexed(&KEYED_PARENT_KERNELS, &KEYED_PARENT_KERNELS_DENSE, &[]);

encodings/fastlanes/src/bitpacking/vtable/rules.rs

@@ -2,12 +2,23 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::arrays::slice::SliceReduceAdaptor;
+use vortex_array::optimizer::rules::ParentRuleDense;
+use vortex_array::optimizer::rules::ParentRuleEntry;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
+use vortex_session::registry::CachedId;
 
 use crate::BitPacked;
 
-pub(crate) const RULES: ParentRuleSet<BitPacked> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(BitPacked)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(BitPacked)),
-]);
+static KEYED_RULES: [ParentRuleEntry<BitPacked>; 2] = [
+    ParentRuleSet::lift_id(CachedId::new("vortex.cast"), &CastReduceAdaptor(BitPacked)),
+    ParentRuleSet::lift_id(
+        CachedId::new("vortex.slice"),
+        &SliceReduceAdaptor(BitPacked),
+    ),
+];
+
+static KEYED_RULES_DENSE: ParentRuleDense<BitPacked> = ParentRuleDense::new();
+
+pub(crate) static RULES: ParentRuleSet<BitPacked> =
+    ParentRuleSet::new_indexed(&KEYED_RULES, &KEYED_RULES_DENSE, &[]);