Only cache limits as u8

To avoid possible cache issues, Chris [asked] to store a smaller size
for the cached limit. This change drops the `Option<usize>` to a
`Option<u8>` adding conversions between `usize` and `u8` as needed. The
`usize` is retained for consistency in the public API
(`OperandConstraint::Limit`) and for ease of use in comparing with HW
encodings and slice indexes (all `usize`).

[asked]: #239 (comment)

Author: abrown

src/ion/data_structures.rs

@@ -203,7 +203,7 @@ pub struct LiveBundle {
     pub allocation: Allocation,
     pub prio: u32, // recomputed after every bulk update
     pub spill_weight_and_props: u32,
-    pub limit: Option<usize>,
+    pub limit: Option<u8>,
 }
 
 pub const BUNDLE_MAX_SPILL_WEIGHT: u32 = (1 << 28) - 1;

src/ion/merge.rs

@@ -18,6 +18,7 @@ use crate::ion::data_structures::{
 };
 use crate::{Function, Inst, OperandConstraint, OperandKind, PReg, ProgPoint};
 use alloc::format;
+use core::convert::TryFrom;
 
 impl<'a, F: Function> Env<'a, F> {
     fn merge_bundle_properties(&mut self, from: LiveBundleIndex, to: LiveBundleIndex) {
@@ -282,7 +283,7 @@ impl<'a, F: Function> Env<'a, F> {
             let mut fixed = false;
             let mut fixed_def = false;
             let mut stack = false;
-            let mut limit: Option<usize> = None;
+            let mut limit: Option<u8> = None;
             for entry in &self.bundles[bundle].ranges {
                 for u in &self.ranges[entry.index].uses {
                     use OperandConstraint::*;
@@ -294,10 +295,14 @@ impl<'a, F: Function> Env<'a, F> {
                             }
                         }
                         Stack => stack = true,
-                        Limit(current) => match limit {
-                            Some(prev) => limit = Some(prev.min(current)),
-                            None => limit = Some(current),
-                        },
+                        Limit(current) => {
+                            let current = u8::try_from(current)
+                                .expect("the current limit is too large to fit in a u8");
+                            match limit {
+                                Some(prev) => limit = Some(prev.min(current)),
+                                None => limit = Some(current),
+                            }
+                        }
                         Any | Reg | Reuse(_) => {
                             continue;
                         }
@@ -392,16 +397,20 @@ impl<'a, F: Function> Env<'a, F> {
         total
     }
 
-    pub fn compute_bundle_limit(&self, bundle: LiveBundleIndex) -> Option<usize> {
-        let mut limit: Option<usize> = None;
+    pub fn compute_bundle_limit(&self, bundle: LiveBundleIndex) -> Option<u8> {
+        let mut limit: Option<u8> = None;
         for entry in &self.bundles[bundle].ranges {
             for u in &self.ranges[entry.index].uses {
                 use OperandConstraint::*;
                 match u.operand.constraint() {
-                    Limit(current) => match limit {
-                        Some(prev) => limit = Some(prev.min(current)),
-                        None => limit = Some(current),
-                    },
+                    Limit(current) => {
+                        let current = u8::try_from(current)
+                            .expect("the current limit is too large to fit in a u8");
+                        match limit {
+                            Some(prev) => limit = Some(prev.min(current)),
+                            None => limit = Some(current),
+                        }
+                    }
                     FixedReg(_) | Stack => {
                         break;
                     }

src/ion/process.rs

@@ -1073,7 +1073,7 @@ impl<'a, F: Function> Env<'a, F> {
                 + bundle.index();
 
             self.ctx.output.stats.process_bundle_reg_probe_start_any += 1;
-            let limit = self.bundles[bundle].limit;
+            let limit = self.bundles[bundle].limit.map(|l| l as usize);
             for preg in RegTraversalIter::new(
                 self.env,
                 class,

src/ion/spill.rs

@@ -42,7 +42,7 @@ impl<'a, F: Function> Env<'a, F> {
 
             let mut success = false;
             self.ctx.output.stats.spill_bundle_reg_probes += 1;
-            let limit = self.bundles[bundle].limit;
+            let limit = self.bundles[bundle].limit.map(|l| l as usize);
             for preg in RegTraversalIter::new(self.env, class, None, hint, bundle.index(), limit) {
                 trace!("trying bundle {:?} to preg {:?}", bundle, preg);
                 let preg_idx = PRegIndex::new(preg.index());