Make the traversal cache lazy (no need to create an empty Dict every time)

Author: VEZY

src/compute_MTG/caching.jl

@@ -57,16 +57,19 @@ function cache_nodes!(node; scale=nothing, symbol=nothing, link=nothing, filter_
     symbol = normalize_symbol_filter(symbol)
     link = normalize_link_filter(link)
     # The cache is already present:
-    if length(node_traversal_cache(node)) != 0 && haskey(node_traversal_cache(node), cache_name(scale, symbol, link, all, filter_fun))
+    cache_key = cache_name(scale, symbol, link, all, filter_fun)
+    cache = _maybe_traversal_cache(node)
+    if cache !== nothing && !isempty(cache) && haskey(cache, cache_key)
         if !overwrite
             error("The node already has a cache for this combination of filters. Hint: use `overwrite=true` if needed.")
         else
             # We have to delete the cache first because else it would be used in the traversal below:
-            delete!(node_traversal_cache(node), cache_name(scale, symbol, link, all, filter_fun))
+            delete!(cache, cache_key)
         end
     end
 
-    node_traversal_cache(node)[cache_name(scale, symbol, link, all, filter_fun)] = traverse(
+    cache = node_traversal_cache(node)
+    cache[cache_key] = traverse(
         node,
         node -> node,
         scale=scale, symbol=symbol, link=link, filter_fun=filter_fun, all=all

src/compute_MTG/traverse.jl

@@ -113,8 +113,8 @@ function traverse!(node::Node, f::Function, args...; scale=nothing, symbol=nothi
     link = normalize_link_filter(link)
 
     # If the node has already a cache of the traversal, we use it instead of traversing the mtg:
-    cache = node_traversal_cache(node)
-    if !isempty(cache)
+    cache = _maybe_traversal_cache(node)
+    if cache !== nothing && !isempty(cache)
         cache_key = cache_name(scale, symbol, link, all, filter_fun)
         cached_nodes = get(cache, cache_key, nothing)
         if cached_nodes !== nothing
@@ -172,8 +172,8 @@ function traverse(node::Node, f::Function, args...; scale=nothing, symbol=nothin
     # NB: f has to return someting here, if its a mutating function, use traverse!
 
     # If the node has already a cache of the traversal, we use it instead of traversing the mtg:
-    cache = node_traversal_cache(node)
-    if !isempty(cache)
+    cache = _maybe_traversal_cache(node)
+    if cache !== nothing && !isempty(cache)
         cache_key = cache_name(scale, symbol, link, all, filter_fun)
         cached_nodes = get(cache, cache_key, nothing)
 

src/types/Node.jl

@@ -55,7 +55,7 @@ mutable struct Node{N<:AbstractNodeMTG,A}
     "Node attributes. Can be anything really"
     attributes::A
     "Cache for mtg nodes traversal"
-    traversal_cache::Dict{String,Vector{Node{N,A}}}
+    traversal_cache::Union{Nothing,Dict{String,Vector{Node{N,A}}}}
 end
 
 # All deprecated methods (the ones with a node name) :
@@ -68,7 +68,7 @@ end
 
 function Node(id::Int, MTG::T, attributes::ColumnarAttrs) where {T<:AbstractNodeMTG}
     node = Node{T,ColumnarAttrs}(
-        id, nothing, Vector{Node{T,ColumnarAttrs}}(), MTG, attributes, Dict{String,Vector{Node{T,ColumnarAttrs}}}()
+        id, nothing, Vector{Node{T,ColumnarAttrs}}(), MTG, attributes, nothing
     )
     init_columnar_root!(attributes, id, getfield(MTG, :symbol))
     return node
@@ -101,7 +101,7 @@ end
 
 function Node(id::Int, parent::Node{M,ColumnarAttrs}, MTG::M, attributes::ColumnarAttrs) where {M<:AbstractNodeMTG}
     node = Node{M,ColumnarAttrs}(
-        id, parent, Vector{Node{M,ColumnarAttrs}}(), MTG, attributes, Dict{String,Vector{Node{M,ColumnarAttrs}}}()
+        id, parent, Vector{Node{M,ColumnarAttrs}}(), MTG, attributes, nothing
     )
     addchild!(parent, node)
     bind_columnar_child!(node_attributes(parent), attributes, id, getfield(MTG, :symbol))
@@ -517,7 +517,16 @@ Base.names(mtg::T) where {T<:MultiScaleTreeGraph.Node} = get_attributes(mtg)
 
 Get the traversal cache of the node if any.
 """
-node_traversal_cache(node::Node) = getfield(node, :traversal_cache)
+@inline _maybe_traversal_cache(node::Node) = getfield(node, :traversal_cache)
+
+function node_traversal_cache(node::Node{T,A}) where {T,A}
+    cache = getfield(node, :traversal_cache)
+    if cache === nothing
+        cache = Dict{String,Vector{Node{T,A}}}()
+        setfield!(node, :traversal_cache, cache)
+    end
+    return cache
+end
 
 Base.getproperty(node::Node, key::Symbol) = unsafe_getindex(node, key)
 Base.hasproperty(node::Node, key::Symbol) = haskey(node_attributes(node), key)