refactor: shrinks Value from 96 to 24 bytes

While investigating Sprocket's baseline memory usage, certain
workloads—particularly those involving deeply nested compound types like
`Map[String, Map[String, ...]]`—scaled poorly. The root cause was the
`Value` enum in `wdl-engine`, which occupied 96 bytes per element due to
large inline types (`Type` at 56 bytes, `TaskPostEvaluationValue` at 96
bytes) inflating the enum even though the common case (`PrimitiveValue`)
is only 16 bytes.

This refactor pushes `Arc` wrapping down into the types that inflate
`Value`. Each compound value type (`Array`, `Map`, `Pair`, `Struct`,
`EnumVariant`) and each large hidden value type (`TaskPreEvaluation`,
`TaskPostEvaluation`) becomes a thin wrapper around `Arc<Inner>`, where
the inner struct owns all fields directly—eliminating nested `Arc`
layering. Two new wrapper types (`NoneValue` and `TypeNameRefValue`)
handle variants that previously stored a bare `Type`. `CallValue` wraps
its `CallType` field behind `Arc` as well.

The tradeoff is an additional pointer indirection when accessing fields
of compound and hidden values, since their data now lives behind `Arc`
on the heap rather than inline in the enum. In practice, this cost is
negligible: these types were already heap-allocated internally (e.g.,
`Array` stored an `Arc<Vec<Value>>`), so the refactor consolidates
rather than adds indirection. Clone remains cheap—a refcount bump on
one `Arc` rather than multiple.

A const assertion prevents `Value` from exceeding 24 bytes in the
future. The `as_map` standard library function was also updated to use
the `IndexMap` entry API, eliminating a redundant key clone.

See PR for benchmark results.

Relates to #541.

Author: claymcleod

crates/wdl-engine/src/cache/hash.rs

@@ -23,6 +23,7 @@ use crate::OutputValue;
 use crate::Pair;
 use crate::PrimitiveValue;
 use crate::Struct;
+use crate::NoneValue;
 use crate::Value;
 use crate::digest::Digest;
 
@@ -209,7 +210,7 @@ impl Hashable for Option<PrimitiveValue> {
             None => {
                 // A `None` for an optional primitive value (used in map keys) represents a WDL
                 // `None` value, so hash it as one
-                Value::None(Type::None).hash(hasher)
+                Value::None(NoneValue::new(Type::None)).hash(hasher)
             }
         }
     }

crates/wdl-engine/src/eval/v1/expr.rs

@@ -3,7 +3,6 @@
 use std::cmp::Ordering;
 use std::fmt::Write;
 use std::iter::once;
-use std::sync::Arc;
 
 use futures::FutureExt;
 use futures::future::BoxFuture;
@@ -768,8 +767,8 @@ impl<C: EvaluationContext> ExprEvaluator<C> {
             }
         }
 
-        let name = struct_ty.name().clone();
-        Ok(Struct::new_unchecked(ty, name, Arc::new(members)).into())
+        let name = struct_ty.name().as_str().to_string();
+        Ok(Struct::new_unchecked(ty, name, members).into())
     }
 
     /// Evaluates a literal hints expression.
@@ -1320,7 +1319,7 @@ impl<C: EvaluationContext> ExprEvaluator<C> {
                 // Evaluate the argument expressions
                 let mut count = 0;
                 let mut types = [const { Type::Union }; MAX_PARAMETERS];
-                let mut arguments = [const { CallArgument::none() }; MAX_PARAMETERS];
+                let mut arguments: [CallArgument; MAX_PARAMETERS] = std::array::from_fn(|_| CallArgument::none());
                 for arg in expr.arguments() {
                     if count < MAX_PARAMETERS {
                         let v = self.evaluate_expr(&arg).await?;
@@ -1506,16 +1505,17 @@ impl<C: EvaluationContext> ExprEvaluator<C> {
                 Some(value) => Ok(value.clone()),
                 None => Err(unknown_call_io(call.ty(), &name, Io::Output)),
             },
-            Value::TypeNameRef(ty) => {
-                if let Some(ty) = ty.as_enum() {
+            Value::TypeNameRef(v) => {
+                let ty = v.ty();
+                if let Some(enum_ty) = ty.as_enum() {
                     let value = self
                         .context()
-                        .enum_variant_value(ty.name(), name.text())
-                        .map_err(|_| unknown_enum_variant_access(ty.name(), &name))?;
-                    let variant = EnumVariant::new(ty.clone(), name.text(), value);
+                        .enum_variant_value(enum_ty.name(), name.text())
+                        .map_err(|_| unknown_enum_variant_access(enum_ty.name(), &name))?;
+                    let variant = EnumVariant::new(enum_ty.clone(), name.text(), value);
                     Ok(Value::Compound(CompoundValue::EnumVariant(variant)))
                 } else {
-                    Err(cannot_access(&ty, target.span()))
+                    Err(cannot_access(ty, target.span()))
                 }
             }
             value => Err(cannot_access(&value.ty(), target.span())),
@@ -1701,6 +1701,7 @@ pub(crate) mod test {
     use std::collections::HashMap;
     use std::fs;
     use std::path::Path;
+    use std::sync::Arc;
 
     use anyhow::Result;
     use pretty_assertions::assert_eq;
@@ -1716,6 +1717,7 @@ pub(crate) mod test {
 
     use super::*;
     use crate::EvaluationPath;
+    use crate::TypeNameRefValue;
     use crate::eval::Scope;
     use crate::eval::ScopeRef;
     use crate::http::Location;
@@ -1871,12 +1873,12 @@ pub(crate) mod test {
 
             // If the name is a reference to a struct, return it as a [`Type::TypeNameRef`].
             if let Some(ty) = self.env.structs.get(name) {
-                return Ok(Value::TypeNameRef(ty.clone()));
+                return Ok(Value::TypeNameRef(TypeNameRefValue::new(ty.clone())));
             }
 
             // If the name is a reference to an enum, return it as a [`Type::TypeNameRef`].
             if let Some(ty) = self.env.enums.get(name) {
-                return Ok(Value::TypeNameRef(ty.clone()));
+                return Ok(Value::TypeNameRef(TypeNameRefValue::new(ty.clone())));
             }
 
             Err(unknown_name(name, span))

crates/wdl-engine/src/eval/v1/task.rs

@@ -80,6 +80,7 @@ use crate::TaskInputs;
 use crate::TaskPostEvaluationData;
 use crate::TaskPostEvaluationValue;
 use crate::TaskPreEvaluationValue;
+use crate::TypeNameRefValue;
 use crate::Value;
 use crate::backend::ExecuteTaskRequest;
 use crate::backend::TaskExecutionConstraints;
@@ -257,7 +258,7 @@ impl EvaluationContext for TaskEvaluationContext<'_, '_> {
         }
 
         if let Some(ty) = self.state.document.get_custom_type(name) {
-            return Ok(Value::TypeNameRef(ty));
+            return Ok(Value::TypeNameRef(TypeNameRefValue::new(ty)));
         }
 
         Err(unknown_name(name, span))

crates/wdl-engine/src/eval/v1/workflow.rs

@@ -68,6 +68,7 @@ use crate::EvaluationPath;
 use crate::EvaluationResult;
 use crate::Inputs;
 use crate::Outputs;
+use crate::TypeNameRefValue;
 use crate::Value;
 use crate::WorkflowInputs;
 use crate::diagnostics::decl_evaluation_failed;
@@ -164,7 +165,7 @@ impl EvaluationContext for WorkflowEvaluationContext<'_, '_> {
         }
 
         if let Some(ty) = self.state.document.get_custom_type(name) {
-            return Ok(Value::TypeNameRef(ty));
+            return Ok(Value::TypeNameRef(TypeNameRefValue::new(ty)));
         }
 
         Err(unknown_name(name, span))

crates/wdl-engine/src/stdlib.rs

@@ -20,6 +20,7 @@ use crate::EvaluationContext;
 use crate::EvaluationPath;
 use crate::HostPath;
 use crate::PrimitiveValue;
+use crate::NoneValue;
 use crate::Value;
 use crate::diagnostics::function_call_failed;
 use crate::http::Location;
@@ -178,9 +179,9 @@ impl CallArgument {
     }
 
     /// Constructs a `None` call argument.
-    pub const fn none() -> Self {
+    pub fn none() -> Self {
         Self {
-            value: Value::None(Type::None),
+            value: Value::None(NoneValue::new(Type::None)),
             span: Span::new(0, 0),
         }
     }

crates/wdl-engine/src/stdlib/as_map.rs

@@ -59,12 +59,17 @@ fn as_map(context: CallContext<'_>) -> Result<Value, Diagnostic> {
             _ => unreachable!("expected a primitive type for the left value"),
         };
 
-        if elements.insert(key.clone(), pair.right().clone()).is_some() {
-            return Err(function_call_failed(
-                FUNCTION_NAME,
-                DuplicateKeyError(key),
-                context.arguments[0].span,
-            ));
+        match elements.entry(key) {
+            indexmap::map::Entry::Occupied(e) => {
+                return Err(function_call_failed(
+                    FUNCTION_NAME,
+                    DuplicateKeyError(e.key().clone()),
+                    context.arguments[0].span,
+                ));
+            }
+            indexmap::map::Entry::Vacant(e) => {
+                e.insert(pair.right().clone());
+            }
         }
     }
 

crates/wdl-engine/src/stdlib/contains_key.rs

@@ -13,7 +13,6 @@ use super::Function;
 use super::Signature;
 use crate::CompoundValue;
 use crate::PrimitiveValue;
-use crate::Struct;
 use crate::Value;
 
 /// Given a Map and a key, tests whether the collection contains an entry with
@@ -82,9 +81,7 @@ fn contains_key_recursive(context: CallContext<'_>) -> Result<Value, Diagnostic>
                 map.get(&PrimitiveValue::String(key.clone())).cloned()
             }
             Value::Compound(CompoundValue::Object(object)) => object.get(key.as_str()).cloned(),
-            Value::Compound(CompoundValue::Struct(Struct { members, .. })) => {
-                members.get(key.as_str()).cloned()
-            }
+            Value::Compound(CompoundValue::Struct(s)) => s.get(key.as_str()).cloned(),
             _ => None,
         }
     }

crates/wdl-engine/src/stdlib/find.rs

@@ -38,7 +38,7 @@ fn find(context: CallContext<'_>) -> Result<Value, Diagnostic> {
 
     match regex.find(input.as_str()) {
         Some(m) => Ok(PrimitiveValue::new_string(m.as_str()).into()),
-        None => Ok(Value::None(Type::from(PrimitiveType::String).optional())),
+        None => Ok(Value::new_none(Type::from(PrimitiveType::String).optional())),
     }
 }
 

crates/wdl-engine/src/stdlib/keys.rs

@@ -9,7 +9,6 @@ use super::Signature;
 use crate::Array;
 use crate::CompoundValue;
 use crate::PrimitiveValue;
-use crate::Struct;
 use crate::Value;
 
 /// Given a key-value type collection (Map, Struct, or Object), returns an Array
@@ -37,10 +36,9 @@ fn keys(context: CallContext<'_>) -> Result<Value, Diagnostic> {
             .keys()
             .map(|k| PrimitiveValue::new_string(k).into())
             .collect(),
-        Value::Compound(CompoundValue::Struct(Struct { members, .. })) => members
-            .keys()
-            .map(|k| PrimitiveValue::new_string(k).into())
-            .collect(),
+        Value::Compound(CompoundValue::Struct(s)) => {
+            s.keys().map(|k| PrimitiveValue::new_string(k).into()).collect()
+        }
         _ => unreachable!("expected a map, object, or struct"),
     };