diff --git a/node-graph/graph-craft/src/document/value.rs b/node-graph/graph-craft/src/document/value.rs index 5a7ed4936e..80b087becc 100644 --- a/node-graph/graph-craft/src/document/value.rs +++ b/node-graph/graph-craft/src/document/value.rs @@ -357,6 +357,30 @@ macro_rules! tagged_value { if ty == edge_type::() { return Ok(handle.downcast::().map_err(|e| format!("{e:?}"))?.eval(ctx).map(TaggedValue::RenderOutput)); } + // ======================= + // RECORD WIRES, WHICH LAND AS THEIR ELEMENT + // ======================= + if ty == core_types::registry::record_edge_type::<()>() { + return Ok(handle.downcast_record::<()>().map_err(|e| format!("{e:?}"))?.eval(ctx).map(|_| TaggedValue::None)); + } + $( + if ty == core_types::registry::record_edge_type::<$ty>() { + let layout = handle.layout().ok_or_else(|| "a record edge must carry its layout".to_string())?.clone(); + return Ok(handle + .downcast_record::<$ty>() + .map_err(|e| format!("{e:?}"))? + .eval(ctx) + .map(|value| TaggedValue::$identifier(unsafe { core_types::record::read_element::<$ty>(layout.rec(&value)) }))); + } + )* + if ty == core_types::registry::record_edge_type::() { + let layout = handle.layout().ok_or_else(|| "a record edge must carry its layout".to_string())?.clone(); + return Ok(handle + .downcast_record::() + .map_err(|e| format!("{e:?}"))? + .eval(ctx) + .map(|value| TaggedValue::RenderOutput(unsafe { core_types::record::read_element::(layout.rec(&value)) }))); + } Err(format!("Cannot convert edge of type {ty} to TaggedValue")) } diff --git a/node-graph/libraries/core-types/src/record.rs b/node-graph/libraries/core-types/src/record.rs index b5d7de9720..a762a8a09a 100644 --- a/node-graph/libraries/core-types/src/record.rs +++ b/node-graph/libraries/core-types/src/record.rs @@ -289,6 +289,65 @@ pub trait RecordEdge<'e, C>: Node> {} impl<'e, C, N: Node>> RecordEdge<'e, C> for N {} +/// Builds an element-only record from a kernel's poll: inline layouts land +/// in the value, larger ones spill to the record stack, arena exhaustion of +/// a parked element reports as an error poll. +pub fn lift_poll<'e, T: Send + Sync + 'static>(poll: GPoll, layout: &Layout, arena: &'e crate::arena::Arena) -> GPoll> { + let build = |element: T| { + if layout.is_inline() { + let mut value = RecordValue::zeroed(); + unsafe { write_element(value.as_mut_ptr(), element, arena)? }; + Some(value) + } else { + let dst = stack::push(layout.frame_bytes()); + let written = unsafe { write_element(dst, element, arena) }; + stack::pop(dst); + written.map(|()| RecordValue::spilled(unsafe { Rec::new(dst.cast_const()) })) + } + }; + let exhausted = || { + GPoll::Error(Box::new(crate::gpoll::GraphError { + kind: crate::gpoll::ErrorKind::ArenaExhausted, + trace: Vec::new(), + })) + }; + match poll { + GPoll::Final(element) => build(element).map_or_else(exhausted, GPoll::Final), + GPoll::Partial(element) => build(element).map_or_else(exhausted, GPoll::Partial), + GPoll::Fallback(boxed) => { + let (element, error) = *boxed; + build(element).map_or_else(exhausted, |value| GPoll::Fallback(Box::new((value, error)))) + } + GPoll::Pending => GPoll::Pending, + GPoll::Error(error) => GPoll::Error(error), + } +} + +/// The raw lazy edge handed to a poll kernel whose wire rides records while +/// the kernel consumes the plain element. +pub struct ElementEdge<'a, El, N> { + node: &'a N, + layout: &'a Layout, + _marker: std::marker::PhantomData El>, +} + +impl<'a, El: Clone, N> ElementEdge<'a, El, N> { + pub fn new(node: &'a N, layout: &'a Layout) -> Self { + Self { + node, + layout, + _marker: std::marker::PhantomData, + } + } + + pub fn eval<'d, C>(&self, ctx: &C) -> GPoll + where + N: Node>, + { + self.node.eval(ctx).map(|value| unsafe { read_element::(self.layout.rec(&value)) }) + } +} + /// The lazy input handed to a kernel whose edge rides a record wire while /// the kernel consumes the plain element. #[derive(Clone, Copy)] @@ -696,34 +755,7 @@ where type Output = RecordValue<'e>; fn eval(&self, input: &C) -> GPoll> { - let build = |element: El| { - if self.layout.is_inline() { - let mut value = RecordValue::zeroed(); - unsafe { write_element(value.as_mut_ptr(), element, input.arena())? }; - Some(value) - } else { - let dst = stack::push(self.layout.frame_bytes()); - let written = unsafe { write_element(dst, element, input.arena()) }; - stack::pop(dst); - written.map(|()| RecordValue::spilled(unsafe { Rec::new(dst.cast_const()) })) - } - }; - let exhausted = || { - GPoll::Error(Box::new(crate::gpoll::GraphError { - kind: crate::gpoll::ErrorKind::ArenaExhausted, - trace: Vec::new(), - })) - }; - match self.edge.eval(input) { - GPoll::Final(element) => build(element).map_or_else(exhausted, GPoll::Final), - GPoll::Partial(element) => build(element).map_or_else(exhausted, GPoll::Partial), - GPoll::Fallback(boxed) => { - let (element, error) = *boxed; - build(element).map_or_else(exhausted, |value| GPoll::Fallback(Box::new((value, error)))) - } - GPoll::Pending => GPoll::Pending, - GPoll::Error(error) => GPoll::Error(error), - } + lift_poll(self.edge.eval(input), &self.layout, input.arena()) } fn layout(&self) -> Option<&Layout> { diff --git a/node-graph/node-macro/src/codegen.rs b/node-graph/node-macro/src/codegen.rs index dbcdcce3a8..e4c1e87224 100644 --- a/node-graph/node-macro/src/codegen.rs +++ b/node-graph/node-macro/src/codegen.rs @@ -816,7 +816,16 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn GenericParam::Type(type_param) => !derive_routing || Some(&type_param.ident) != routing.as_ref().map(|routing| &routing.generic), _ => true, }) - .map(&generic_tokens) + .map(|param| match param { + // Flipped kernels clone lazy elements out of their records, so + // every element generic carries the bound wire values satisfy. + GenericParam::Type(type_param) if flip && Some(&type_param.ident) != ctx_param.map(|ctx_param| &ctx_param.ident) => { + let mut bounded = type_param.clone(); + bounded.bounds.push(syn::parse_quote!(::core::clone::Clone)); + quote!(#bounded) + } + param => generic_tokens(param), + }) .collect(); let mut impl_generics: Vec = parsed .fn_generics @@ -874,6 +883,24 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn } } } + if flip { + let mut kernel_lazy = false; + for (index, field) in regular_fields.iter().enumerate() { + if matches!(&field.ty, ParsedFieldType::Node(_)) { + kernel_lazy = true; + let source_generic = format_ident!("__Source{index}"); + let derived_extra = derives + .then(|| quote!(+ for<'__derived> #core_types::record::RecordEdge<'__derived, #core_types::context::Derived<'__derived, #ctx_ident>>)) + .into_iter(); + generics.push(quote! { + #source_generic: #core_types::node::Node<#ctx_ident, Output = #core_types::record::RecordValue<'__record>> #(#derived_extra)* + }); + } + } + if kernel_lazy { + generics.insert(0, quote!('__record)); + } + } let data_field_generic_idents: Vec = parsed .fn_generics @@ -947,8 +974,13 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn let source_generic = format_ident!("__Source{index}"); quote!(#pat: #core_types::record::RecordLazyInput<'_, '__record, #source_generic>) } + ParsedFieldType::Node(NodeParsedField { output_type, .. }) if flip && raw_lazy => { + let source_generic = format_ident!("__Source{index}"); + quote!(#pat: &#core_types::record::ElementEdge<'_, #output_type, #source_generic>) + } ParsedFieldType::Node(NodeParsedField { output_type, .. }) if flip => { - quote!(#pat: #core_types::record::ElementLazyInput<'_, #output_type, impl for<'__el> #core_types::record::RecordEdge<'__el, #ctx_ident>>) + let source_generic = format_ident!("__Source{index}"); + quote!(#pat: #core_types::record::ElementLazyInput<'_, #output_type, #source_generic>) } ParsedFieldType::Node(NodeParsedField { output_type, .. }) if raw_lazy => { let bound = lazy_bound(output_type); @@ -965,7 +997,13 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn let record_value_ty: Type = syn::parse_quote!(#core_types::record::RecordValue<'__record>); let node_bounds = regular_fields.iter().enumerate().zip(&node_generics).map(|((index, field), node_generic)| match &field.ty { ParsedFieldType::Regular(_) if flip => quote!(#node_generic: #core_types::node::Node<#ctx_ident, Output = #record_value_ty>), - ParsedFieldType::Node(_) if flip => quote!(#node_generic: for<'__el> #core_types::record::RecordEdge<'__el, #ctx_ident>), + ParsedFieldType::Node(_) if flip => match derives { + true => quote! { + #node_generic: #core_types::node::Node<#ctx_ident, Output = #record_value_ty>, + #node_generic: for<'__derived> #core_types::record::RecordEdge<'__derived, #core_types::context::Derived<'__derived, #ctx_ident>> + }, + false => quote!(#node_generic: #core_types::node::Node<#ctx_ident, Output = #record_value_ty>), + }, ParsedFieldType::Regular(RegularParsedField { ty, lend: Some(_), .. }) => { let lifetime = lend_lifetime.as_ref().expect("lend fields imply the lend lifetime"); quote!(#node_generic: #core_types::node::Node<#ctx_ident, Output = &#lifetime #ty>) @@ -1071,10 +1109,16 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn ParsedFieldType::Node(NodeParsedField { output_type, .. }) if derive_routing && routing_source(output_type) => quote! { let #name = #core_types::record::RecordLazyInput::new(&self.#name, &__cell, #index); }, - ParsedFieldType::Node(_) if flip => { + ParsedFieldType::Node(NodeParsedField { output_type, .. }) if flip && raw_lazy => { let slot = format_ident!("__in_{index}"); quote! { - let #name = #core_types::record::ElementLazyInput::new(&self.#name, &__cell, #index, &self.#slot); + let #name = #core_types::record::ElementEdge::<#output_type, _>::new(&self.#name, &self.#slot); + } + } + ParsedFieldType::Node(NodeParsedField { output_type, .. }) if flip => { + let slot = format_ident!("__in_{index}"); + quote! { + let #name = #core_types::record::ElementLazyInput::<#output_type, _>::new(&self.#name, &__cell, #index, &self.#slot); } } ParsedFieldType::Node(_) if raw_lazy => quote!(), @@ -1102,6 +1146,7 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn let call_args = regular_fields.iter().filter(|field| !injected_name(&field.pat_ident.ident)).map(|field| { let name = &field.pat_ident.ident; match &field.ty { + ParsedFieldType::Node(_) if flip && raw_lazy => quote!(&#name), ParsedFieldType::Node(_) if raw_lazy => quote!(&self.#name), _ => quote!(#name), } @@ -1359,6 +1404,11 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn } }); let flip_tail = flip.then(|| { + if matches!(kernel_kind(&parsed.output_type), KernelKind::Poll(_)) { + return quote! { + __cell.merge(#core_types::record::lift_poll(#kernel_call, &self.__layout, #core_types::context::ExtractArena::arena(__input))) + }; + } let kernel_value = match kernel_kind(&parsed.output_type) { KernelKind::Interrupt(_) => quote! { match #kernel_call { @@ -1838,9 +1888,6 @@ pub(crate) fn record_flip(parsed: &ParsedNodeFn) -> bool { if parsed.attributes.batch.is_some() || parsed.attributes.shader_node.is_some() || parsed.attributes.plain { return false; } - if matches!(kernel_kind(&parsed.output_type), KernelKind::Poll(_)) { - return false; - } if type_disqualifies(&slot_value_type(&parsed.output_type)) { return false; } @@ -1851,11 +1898,12 @@ pub(crate) fn record_flip(parsed: &ParsedNodeFn) -> bool { // Registry rows assign a generic from a field it names bare, so a // generic without such a position keeps the plain lowering. GenericParam::Type(type_param) => { - let bare = parsed.fields.iter().any(|field| match &field.ty { - ParsedFieldType::Regular(RegularParsedField { ty, .. }) => { - matches!(ty, Type::Path(path) if path.qself.is_none() && path.path.get_ident() == Some(&type_param.ident)) - } - _ => false, + let bare = parsed.fields.iter().any(|field| { + let ty = match &field.ty { + ParsedFieldType::Regular(RegularParsedField { ty, .. }) => ty, + ParsedFieldType::Node(NodeParsedField { output_type, .. }) => output_type, + }; + matches!(ty, Type::Path(path) if path.qself.is_none() && path.path.get_ident() == Some(&type_param.ident)) }); if !bare { return false; @@ -1864,16 +1912,7 @@ pub(crate) fn record_flip(parsed: &ParsedNodeFn) -> bool { GenericParam::Lifetime(_) | GenericParam::Const(_) => return false, } } - let has_lazy = parsed.fields.iter().any(|field| matches!(&field.ty, ParsedFieldType::Node(_))); - let derives = context_param(parsed).is_some_and(|ctx_param| { - ctx_param.bounds.iter().any(|bound| match bound { - TypeParamBound::Trait(trait_bound) => trait_bound.path.segments.last().is_some_and(|segment| segment.ident == "DeriveCtx"), - _ => false, - }) - }); - // A derived-context kernel evaluates lazy edges at contexts the element - // wrapper cannot prove, so those keep the plain lowering for now. - !(has_lazy && derives) + true } pub(crate) fn routing_io(parsed: &ParsedNodeFn) -> Option { @@ -2191,11 +2230,12 @@ fn flip_entries_tokens(parsed: &ParsedNodeFn, struct_name: &Ident, regular_field .map(|generic| { regular_fields .iter() - .position(|field| match &field.ty { - ParsedFieldType::Regular(RegularParsedField { ty, .. }) => { - matches!(ty, Type::Path(path) if path.qself.is_none() && path.path.get_ident() == Some(generic)) - } - _ => false, + .position(|field| { + let ty = match &field.ty { + ParsedFieldType::Regular(RegularParsedField { ty, .. }) => ty, + ParsedFieldType::Node(NodeParsedField { output_type, .. }) => output_type, + }; + matches!(ty, Type::Path(path) if path.qself.is_none() && path.path.get_ident() == Some(generic)) }) .map(|index| (generic.clone(), index)) }) diff --git a/node-graph/nodes/gcore/src/memo.rs b/node-graph/nodes/gcore/src/memo.rs index 3b382aaf40..b470f6dbdb 100644 --- a/node-graph/nodes/gcore/src/memo.rs +++ b/node-graph/nodes/gcore/src/memo.rs @@ -12,7 +12,7 @@ use std::sync::Mutex; /// Helps speed up repeated renders in a computationally-heavy part of the node graph. /// /// Stores the last evaluated data that flowed through this node and immediately returns that data on subsequent renders if the context has not changed. -#[node_macro::node(category("General"), path(graphene_core::memo), skip_impl, extent(memoize_extent))] +#[node_macro::node(category("General"), path(graphene_core::memo), skip_impl, plain, extent(memoize_extent))] fn memoize(input: I, #[data] cache: Arc>>, content: impl Node) -> GPoll { let key = cache_key(&input); if let Some((hash, value, finality)) = cache.lock().unwrap().as_ref() @@ -111,7 +111,7 @@ fn lend<'e, T: Send + Sync>(ctx: impl Ctx + ExtractArena<'e>, value: T) -> GPoll type MonitorValue = Arc>>>>; /// The Monitor node is used by the editor to access the data flowing through it. -#[node_macro::node(category(""), path(graphene_core::memo), serialize(serialize_monitor), properties("monitor_properties"), skip_impl)] +#[node_macro::node(category(""), path(graphene_core::memo), serialize(serialize_monitor), properties("monitor_properties"), skip_impl, plain)] fn monitor( ctx: impl Ctx + DeriveCtx + ExtractAll, #[allow(clippy::type_complexity)]