Optimización de un Compilador Scheme JIT Basado en CPS: Recuperando el Rendimiento Perdido

impl Cps {
    pub(super) fn reduce(self) -> Self {
        // Perform beta reduction twice. This seems like the sweet spot for now
        self.beta_reduction(&mut HashMap::default())
            .beta_reduction(&mut HashMap::default())
    }

    /// Beta-reduction optimization step. This function replaces applications to
    /// functions with the body of the function with arguments substituted.
    ///
    /// Our initial heuristic is rather simple: if a function is non-recursive and
    /// is applied to exactly once in its continuation expression, its body is
    /// substituted for the application.
    ///
    /// The uses analysis cache is absolutely demolished and dangerous to use by
    /// the end of this function.
    fn beta_reduction(self, uses_cache: &mut HashMap<Local, HashMap<Local, usize>>) -> Self {
        match self {
            Cps::PrimOp(prim_op, values, result, cexp) => Cps::PrimOp(
                prim_op, values, result, Box::new(cexp.beta_reduction(uses_cache)),
            ),
            Cps::If(cond, success, failure) => Cps::If(
                cond,
                Box::new(success.beta_reduction(uses_cache)),
                Box::new(failure.beta_reduction(uses_cache)),
            ),
            Cps::Closure {
                args, body, val, cexp, debug,
            } => {
                let body = body.beta_reduction(uses_cache);
                let mut cexp = cexp.beta_reduction(uses_cache);
                let is_recursive = body.uses(uses_cache).contains_key(&val);
                let uses = cexp.uses(uses_cache).get(&val).copied().unwrap_or(0);

                // TODO: When we get more list primops, allow for variadic substitutions
                if !args.variadic && !is_recursive && uses == 1 {
                    let reduced = cexp.reduce_function(val, &args, &body, uses_cache);
                    if reduced {
                        uses_cache.remove(&val);
                        return cexp;
                    }
                }

                Cps::Closure {
                    args,
                    body: Box::new(body),
                    val,
                    cexp: Box::new(cexp),
                    debug,
                }
            }
            cexp => cexp,
        }
    }

    fn reduce_function(
        &mut self,
        func: Local,
        args: &ClosureArgs,
        func_body: &Cps,
        uses_cache: &mut HashMap<Local, HashMap<Local, usize>>,
    ) -> bool {
        let new = match self {
            Cps::PrimOp(_, _, _, cexp) => {
                return cexp.reduce_function(func, args, func_body, uses_cache)
            }
            Cps::If(_, succ, fail) => {
                return succ.reduce_function(func, args, func_body, uses_cache)
                    || fail.reduce_function(func, args, func_body, uses_cache)
            }
            Cps::Closure { val, body, cexp, .. } => {
                let reduced = body.reduce_function(func, args, func_body, uses_cache)
                    || cexp.reduce_function(func, args, func_body, uses_cache);
                if reduced {
                    uses_cache.remove(val);
                }
                return reduced;
            }
            Cps::App(Value::Var(Var::Local(operator)), applied, _) if *operator == func => {
                let substitutions: HashMap<_, _> = args
                    .to_vec()
                    .into_iter()
                    .zip(applied.iter().cloned())
                    .collect();
                let mut body = func_body.clone();
                body.substitute(&substitutions);
                body
            }
            Cps::App(_, _, _) | Cps::Forward(_, _) | Cps::Halt(_) => return false,
        };
        *self = new;
        true
    }
}

impl Expression {
    pub fn to_primop(&self) -> Option<PrimOp> {
        use crate::{
            num::{
                add_builtin_wrapper,
                div_builtin_wrapper,
                equal_builtin_wrapper,
                greater_builtin_wrapper,
                greater_equal_builtin_wrapper,
                lesser_builtin_wrapper,
                lesser_equal_builtin_wrapper,
                mul_builtin_wrapper,
                sub_builtin_wrapper,
            },
            proc::{Closure, FuncPtr::Bridge},
        };

        if let Expression::Var(Var::Global(global)) = self {
            let val = global.value_ref().read().clone();
            let val: Gc<Closure> = val.try_into().ok()?;
            let val_read = val.read();
            match val_read.func {
                Bridge(ptr) if ptr == add_builtin_wrapper => Some(PrimOp::Add),
                Bridge(ptr) if ptr == sub_builtin_wrapper => Some(PrimOp::Sub),
                Bridge(ptr) if ptr == mul_builtin_wrapper => Some(PrimOp::Mul),
                Bridge(ptr) if ptr == div_builtin_wrapper => Some(PrimOp::Div),
                Bridge(ptr) if ptr == equal_builtin_wrapper => Some(PrimOp::Equal),
                Bridge(ptr) if ptr == greater_builtin_wrapper => Some(PrimOp::Greater),
                Bridge(ptr) if ptr == greater_equal_builtin_wrapper => Some(PrimOp::GreaterEqual),
                Bridge(ptr) if ptr == lesser_builtin_wrapper => Some(PrimOp::Lesser),
                Bridge(ptr) if ptr == lesser_equal_builtin_wrapper => Some(PrimOp::LesserEqual),
                _ => None,
            }
        } else {
            None
        }
    }
}

#[repr(u64)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum ValueType {
    Undefined = 0,
    Null = 1,
    Boolean = 2,
    Character = 3,
    Number = 4,
    String = 5,
    Symbol = 6,
    Vector = 7,
    ByteVector = 8,
    Syntax = 9,
    Closure = 10,
    Record = 11,
    Condition = 12,
    Pair = 13,
    HashTable = 14,
    Other = 15,
}

#[derive(Clone, Trace)]
#[repr(align(16))]
pub enum OtherData {
    CapturedEnv(CapturedEnv),
    Transformer(Transformer),
    Future(Future),
    RecordType(RecordType),
    UserData(Arc<dyn std::any::Any>),
}