From 2c12cab4f3b8ec0912a06b621cfcebb6cb147d18 Mon Sep 17 00:00:00 2001
From: omlopez <lopezortizoe@ornl.gov>
Date: Mon, 27 Jan 2025 12:09:41 -0500
Subject: [PATCH 1/2] Combine leaf_node cache and backend_cache into a single
 thread_local struct

---
 graph_framework/arithmetic.hpp   |  50 +++++++--------
 graph_framework/math.hpp         |  50 +++++++--------
 graph_framework/node.hpp         |  24 +++----
 graph_framework/piecewise.hpp    | 106 +++++++++++++++----------------
 graph_framework/trigonometry.hpp |  30 ++++-----
 5 files changed, 131 insertions(+), 129 deletions(-)

diff --git a/graph_framework/arithmetic.hpp b/graph_framework/arithmetic.hpp
index 589d4de..ea06a6c 100644
--- a/graph_framework/arithmetic.hpp
+++ b/graph_framework/arithmetic.hpp
@@ -741,12 +741,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1563,12 +1563,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -2455,12 +2455,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -3406,12 +3406,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -4837,12 +4837,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/math.hpp b/graph_framework/math.hpp
index f7fdfc0..16429da 100644
--- a/graph_framework/math.hpp
+++ b/graph_framework/math.hpp
@@ -279,12 +279,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -546,12 +546,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -786,12 +786,12 @@ namespace graph {
         auto temp = std::make_shared<log_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1289,12 +1289,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1554,12 +1554,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/node.hpp b/graph_framework/node.hpp
index f9eb2c3..93afc20 100644
--- a/graph_framework/node.hpp
+++ b/graph_framework/node.hpp
@@ -311,12 +311,14 @@ namespace graph {
                    << std::endl;
         }
 
-///  Cache for constructed nodes.
-        inline thread_local static std::map<size_t,
-                                            std::shared_ptr<leaf_node<T, SAFE_MATH>>> cache;
-///  Cache for the backend buffers.
-        inline thread_local static std::map<size_t,
-                                            backend::buffer<T>> backend_cache;
+// Create one struct that holds both caches: for constructed nodes and for the backend buffers
+    struct caches_t {
+        std::map<size_t, std::shared_ptr<leaf_node<T, SAFE_MATH>>> main_cache;
+        std::map<size_t, backend::buffer<T>> backend_cache;
+    };
+
+// We define only one inline static thread_local variable
+    inline static thread_local caches_t caches;
 
 ///  Type def to retrieve the backend type.
         typedef T base;
@@ -593,12 +595,12 @@ namespace graph {
         auto temp = std::make_shared<constant_node<T, SAFE_MATH>> (d);
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/piecewise.hpp b/graph_framework/piecewise.hpp
index c1faaa4..0178171 100644
--- a/graph_framework/piecewise.hpp
+++ b/graph_framework/piecewise.hpp
@@ -116,11 +116,11 @@ void compile_index(std::ostringstream &stream,
         static size_t hash_data(const backend::buffer<T> &d) {
             const size_t h = std::hash<std::string>{} (piecewise_1D_node::to_string(d));
             for (size_t i = h; i < std::numeric_limits<size_t>::max(); i++) {
-                if (leaf_node<T, SAFE_MATH>::backend_cache.find(i) ==
-                    leaf_node<T, SAFE_MATH>::backend_cache.end()) {
-                    leaf_node<T, SAFE_MATH>::backend_cache[i] = d;
+                if (leaf_node<T, SAFE_MATH>::caches.backend_cache.find(i) ==
+                    leaf_node<T, SAFE_MATH>::caches.backend_cache.end()) {
+                    leaf_node<T, SAFE_MATH>::caches.backend_cache[i] = d;
                     return i;
-                } else if (d == leaf_node<T, SAFE_MATH>::backend_cache[i]) {
+                } else if (d == leaf_node<T, SAFE_MATH>::caches.backend_cache[i]) {
                     return i;
                 }
             }
@@ -156,7 +156,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The evaluated value of the node.
 //------------------------------------------------------------------------------
         virtual backend::buffer<T> evaluate() {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash];
+            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash];
         }
 
 //------------------------------------------------------------------------------
@@ -207,16 +207,16 @@ void compile_index(std::ostringstream &stream,
                                             visited, usage,
                                             textures1d, textures2d,
                                             avail_const_mem);
-                if (registers.find(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()) == registers.end()) {
-                    registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] =
-                        jit::to_string('a', leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data());
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()) == registers.end()) {
+                    registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] =
+                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data());
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                length);
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                length);
 #endif
                     } else {
@@ -229,30 +229,30 @@ void compile_index(std::ostringstream &stream,
                         }
                         stream << "const ";
                         jit::add_type<T> (stream);
-                        stream << " " << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] << "[] = {";
+                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] << "[] = {";
                         if constexpr (jit::is_complex<T> ()) {
                             jit::add_type<T> (stream);
                         }
-                        stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][0];
+                        stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][0];
                         for (size_t i = 1; i < length; i++) {
                             stream << ", ";
                             if constexpr (jit::is_complex<T> ()) {
                                 jit::add_type<T> (stream);
                             }
-                            stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][i];
+                            stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][i];
                         }
                         stream << "};" << std::endl;
                     }
                 } else {
 //  When using textures, the register can be defined in a previous kernel. We
 //  need to add the textures again.
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                length);
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                length);
 #endif
                     }
@@ -296,7 +296,7 @@ void compile_index(std::ostringstream &stream,
 #ifdef USE_INDEX_CACHE
                 if (indices.find(this->arg.get()) == indices.end()) {
 #endif
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                     shared_leaf<T, SAFE_MATH> a = this->arg->compile(stream,
                                                                      registers,
                                                                      indices,
@@ -328,7 +328,7 @@ void compile_index(std::ostringstream &stream,
                     }
                 }
 #endif
-                stream << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()];
+                stream << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()];
                 if constexpr (jit::use_metal<T> ()) {
 #ifdef USE_INDEX_CACHE
                     stream << ".read("
@@ -435,7 +435,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns True the node has a zero constant value.
 //------------------------------------------------------------------------------
         virtual bool has_constant_zero() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].has_zero();
+            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].has_zero();
         }
 
 //------------------------------------------------------------------------------
@@ -493,7 +493,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The size of the buffer.
 //------------------------------------------------------------------------------
         size_t get_size() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
         }
     };
 
@@ -513,12 +513,12 @@ void compile_index(std::ostringstream &stream,
         auto temp = std::make_shared<piecewise_1D_node<T, SAFE_MATH>> (d, x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -633,11 +633,11 @@ void compile_index(std::ostringstream &stream,
         static size_t hash_data(const backend::buffer<T> &d) {
             const size_t h = std::hash<std::string>{} (piecewise_2D_node::to_string(d));
             for (size_t i = h; i < std::numeric_limits<size_t>::max(); i++) {
-                if (leaf_node<T, SAFE_MATH>::backend_cache.find(i) ==
-                    leaf_node<T, SAFE_MATH>::backend_cache.end()) {
-                    leaf_node<T, SAFE_MATH>::backend_cache[i] = d;
+                if (leaf_node<T, SAFE_MATH>::caches.backend_cache.find(i) ==
+                    leaf_node<T, SAFE_MATH>::caches.backend_cache.end()) {
+                    leaf_node<T, SAFE_MATH>::caches.backend_cache[i] = d;
                     return i;
-                } else if (d == leaf_node<T, SAFE_MATH>::backend_cache[i]) {
+                } else if (d == leaf_node<T, SAFE_MATH>::caches.backend_cache[i]) {
                     return i;
                 }
             }
@@ -688,7 +688,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The number of columns in the constant.
 //------------------------------------------------------------------------------
         size_t get_num_rows() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size() /
+            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size() /
                    num_columns;
         }
 
@@ -702,7 +702,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The evaluated value of the node.
 //------------------------------------------------------------------------------
         virtual backend::buffer<T> evaluate() {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash];
+            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash];
         }
 
 //------------------------------------------------------------------------------
@@ -758,16 +758,16 @@ void compile_index(std::ostringstream &stream,
                                               visited, usage,
                                               textures1d, textures2d,
                                               avail_const_mem);
-                if (registers.find(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()) == registers.end()) {
-                    registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] =
-                        jit::to_string('a', leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data());
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()) == registers.end()) {
+                    registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] =
+                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data());
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #endif
                     } else {
@@ -780,30 +780,30 @@ void compile_index(std::ostringstream &stream,
                         }
                         stream << "const ";
                         jit::add_type<T> (stream);
-                        stream << " " << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] << "[] = {";
+                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] << "[] = {";
                         if constexpr (jit::is_complex<T> ()) {
                             jit::add_type<T> (stream);
                         }
-                        stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][0];
+                        stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][0];
                         for (size_t i = 1; i < length; i++) {
                             stream << ", ";
                             if constexpr (jit::is_complex<T> ()) {
                                 jit::add_type<T> (stream);
                             }
-                            stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][i];
+                            stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][i];
                         }
                         stream << "};" << std::endl;
                     }
                 } else {
 //  When using textures, the register can be defined in a previous kernel. We
 //  need to add the textures again.
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #endif
                     }
@@ -857,7 +857,7 @@ void compile_index(std::ostringstream &stream,
                 jit::register_map &indices,
                 const jit::register_usage &usage) {
             if (registers.find(this) == registers.end()) {
-                const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                 const size_t num_rows = length/num_columns;
 
 #ifdef USE_INDEX_CACHE
@@ -898,7 +898,7 @@ void compile_index(std::ostringstream &stream,
                              ) {
                     if (indices.find(temp.get()) == indices.end()) {
                         indices[temp.get()] = jit::to_string('i', temp.get());
-                        const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                        const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
                         stream << "        const "
                                << jit::smallest_int_type<T> (length) << " "
                                << indices[temp.get()] << " = "
@@ -927,7 +927,7 @@ void compile_index(std::ostringstream &stream,
                     }
                 }
 #endif
-                stream << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()];
+                stream << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()];
                 if constexpr (jit::use_metal<T> ()) {
 #ifdef USE_INDEX_CACHE
                     stream << ".read("
@@ -1051,7 +1051,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns True the node has a zero constant value.
 //------------------------------------------------------------------------------
         virtual bool has_constant_zero() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].has_zero();
+            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].has_zero();
         }
 
 //------------------------------------------------------------------------------
@@ -1154,12 +1154,12 @@ void compile_index(std::ostringstream &stream,
         auto temp = std::make_shared<piecewise_2D_node<T, SAFE_MATH>> (d, n, x, y)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/trigonometry.hpp b/graph_framework/trigonometry.hpp
index 19ef146..f69cd90 100644
--- a/graph_framework/trigonometry.hpp
+++ b/graph_framework/trigonometry.hpp
@@ -228,12 +228,12 @@ namespace graph {
         auto temp = std::make_shared<sine_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -478,12 +478,12 @@ namespace graph {
         auto temp = std::make_shared<cosine_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -798,12 +798,12 @@ namespace graph {
         auto temp = std::make_shared<arctan_node<T, SAFE_MATH>> (l, r)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
+                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
-- 
GitLab


From 67d3625e88c08ddc2dbac8f0aa8851180adf741f Mon Sep 17 00:00:00 2001
From: cianciosa <cianciosamr@ornl.gov>
Date: Mon, 27 Jan 2025 13:30:50 -0500
Subject: [PATCH 2/2] Minor changes changes to naming, code formatting, and add
 doxygen comments. This also removes unneeded namespace qualifiers and fixes a
 missing header file in the precompilered header list.

---
 graph_framework/CMakeLists.txt   |   1 +
 graph_framework/absorption.hpp   |   5 +-
 graph_framework/arithmetic.hpp   |  56 ++++++++--------
 graph_framework/math.hpp         |  50 +++++++--------
 graph_framework/node.hpp         |  32 ++++++----
 graph_framework/piecewise.hpp    | 106 +++++++++++++++----------------
 graph_framework/trigonometry.hpp |  30 ++++-----
 graph_tests/efit_test.cpp        |   1 -
 8 files changed, 145 insertions(+), 136 deletions(-)

diff --git a/graph_framework/CMakeLists.txt b/graph_framework/CMakeLists.txt
index 270bde1..24a9b7d 100644
--- a/graph_framework/CMakeLists.txt
+++ b/graph_framework/CMakeLists.txt
@@ -45,6 +45,7 @@ target_precompile_headers (rays
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/arithmetic.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/backend.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/dispersion.hpp>>
+                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/absorption.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/math.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/node.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/solver.hpp>>
diff --git a/graph_framework/absorption.hpp b/graph_framework/absorption.hpp
index 9706dbd..939099e 100644
--- a/graph_framework/absorption.hpp
+++ b/graph_framework/absorption.hpp
@@ -1,6 +1,6 @@
 //------------------------------------------------------------------------------
-///  @file absoprtion.hpp
-///  @brief Base class for a dispersion relation.
+///  @file absorption.hpp
+///  @brief Base class for an absorption model.
 ///
 ///  Defines functions for computing power absorbtion.
 //------------------------------------------------------------------------------
@@ -11,6 +11,7 @@
 #include <thread>
 
 #include "newton.hpp"
+#include "output.hpp"
 
 namespace absorption {
 //******************************************************************************
diff --git a/graph_framework/arithmetic.hpp b/graph_framework/arithmetic.hpp
index ea06a6c..3d93efa 100644
--- a/graph_framework/arithmetic.hpp
+++ b/graph_framework/arithmetic.hpp
@@ -8,7 +8,7 @@
 #ifndef arithmetic_h
 #define arithmetic_h
 
-#include "trigonometry.hpp"
+#include "node.hpp"
 
 namespace graph {
 //------------------------------------------------------------------------------
@@ -741,12 +741,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1563,12 +1563,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1822,8 +1822,8 @@ namespace graph {
             }
 
 //  Move trig to the right.
-            auto cl = graph::cos_cast(this->left);
-            auto sl = graph::sin_cast(this->left);
+            auto cl = cos_cast(this->left);
+            auto sl = sin_cast(this->left);
             if ((cl.get() && !this->right->is_power_like() &&
                  !this->right->is_all_variables() &&
                  !sin_cast(this->right).get()) ||
@@ -2455,12 +2455,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -3406,12 +3406,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -4837,12 +4837,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/math.hpp b/graph_framework/math.hpp
index 16429da..7e58fa1 100644
--- a/graph_framework/math.hpp
+++ b/graph_framework/math.hpp
@@ -279,12 +279,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -546,12 +546,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -786,12 +786,12 @@ namespace graph {
         auto temp = std::make_shared<log_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1289,12 +1289,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1554,12 +1554,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/node.hpp b/graph_framework/node.hpp
index 93afc20..ad1bd7c 100644
--- a/graph_framework/node.hpp
+++ b/graph_framework/node.hpp
@@ -312,13 +312,21 @@ namespace graph {
         }
 
 // Create one struct that holds both caches: for constructed nodes and for the backend buffers
-    struct caches_t {
-        std::map<size_t, std::shared_ptr<leaf_node<T, SAFE_MATH>>> main_cache;
-        std::map<size_t, backend::buffer<T>> backend_cache;
-    };
+//------------------------------------------------------------------------------
+///  @brief Data structure to contain the two caches.
+///
+///  This a avoids an issue on gnu compilers where it would try to redefine the
+///  __tls_guard twice depending on the include order.
+//------------------------------------------------------------------------------
+        struct caches_t {
+///  Cache of node.
+            std::map<size_t, std::shared_ptr<leaf_node<T, SAFE_MATH>>> nodes;
+///  Cache of backend buffers.
+            std::map<size_t, backend::buffer<T>> backends;
+        };
 
-// We define only one inline static thread_local variable
-    inline static thread_local caches_t caches;
+///  A per thread instance of the cache structure.
+        inline static thread_local caches_t caches;
 
 ///  Type def to retrieve the backend type.
         typedef T base;
@@ -595,12 +603,12 @@ namespace graph {
         auto temp = std::make_shared<constant_node<T, SAFE_MATH>> (d);
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1370,7 +1378,7 @@ namespace graph {
     using input_nodes = std::vector<shared_variable<T, SAFE_MATH>>;
 ///  Convenience type alias for maping end codes back to inputs.
     template<jit::float_scalar T, bool SAFE_MATH=false>
-    using map_nodes = std::vector<std::pair<graph::shared_leaf<T, SAFE_MATH>,
+    using map_nodes = std::vector<std::pair<shared_leaf<T, SAFE_MATH>,
                                             shared_variable<T, SAFE_MATH>>>;
 
 //------------------------------------------------------------------------------
diff --git a/graph_framework/piecewise.hpp b/graph_framework/piecewise.hpp
index 0178171..d956f6f 100644
--- a/graph_framework/piecewise.hpp
+++ b/graph_framework/piecewise.hpp
@@ -116,11 +116,11 @@ void compile_index(std::ostringstream &stream,
         static size_t hash_data(const backend::buffer<T> &d) {
             const size_t h = std::hash<std::string>{} (piecewise_1D_node::to_string(d));
             for (size_t i = h; i < std::numeric_limits<size_t>::max(); i++) {
-                if (leaf_node<T, SAFE_MATH>::caches.backend_cache.find(i) ==
-                    leaf_node<T, SAFE_MATH>::caches.backend_cache.end()) {
-                    leaf_node<T, SAFE_MATH>::caches.backend_cache[i] = d;
+                if (leaf_node<T, SAFE_MATH>::caches.backends.find(i) ==
+                    leaf_node<T, SAFE_MATH>::caches.backends.end()) {
+                    leaf_node<T, SAFE_MATH>::caches.backends[i] = d;
                     return i;
-                } else if (d == leaf_node<T, SAFE_MATH>::caches.backend_cache[i]) {
+                } else if (d == leaf_node<T, SAFE_MATH>::caches.backends[i]) {
                     return i;
                 }
             }
@@ -156,7 +156,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The evaluated value of the node.
 //------------------------------------------------------------------------------
         virtual backend::buffer<T> evaluate() {
-            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash];
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash];
         }
 
 //------------------------------------------------------------------------------
@@ -207,16 +207,16 @@ void compile_index(std::ostringstream &stream,
                                             visited, usage,
                                             textures1d, textures2d,
                                             avail_const_mem);
-                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()) == registers.end()) {
-                    registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] =
-                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data());
-                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()) == registers.end()) {
+                    registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] =
+                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data());
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #endif
                     } else {
@@ -229,30 +229,30 @@ void compile_index(std::ostringstream &stream,
                         }
                         stream << "const ";
                         jit::add_type<T> (stream);
-                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] << "[] = {";
+                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] << "[] = {";
                         if constexpr (jit::is_complex<T> ()) {
                             jit::add_type<T> (stream);
                         }
-                        stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][0];
+                        stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][0];
                         for (size_t i = 1; i < length; i++) {
                             stream << ", ";
                             if constexpr (jit::is_complex<T> ()) {
                                 jit::add_type<T> (stream);
                             }
-                            stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][i];
+                            stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][i];
                         }
                         stream << "};" << std::endl;
                     }
                 } else {
 //  When using textures, the register can be defined in a previous kernel. We
 //  need to add the textures again.
-                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #endif
                     }
@@ -296,7 +296,7 @@ void compile_index(std::ostringstream &stream,
 #ifdef USE_INDEX_CACHE
                 if (indices.find(this->arg.get()) == indices.end()) {
 #endif
-                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     shared_leaf<T, SAFE_MATH> a = this->arg->compile(stream,
                                                                      registers,
                                                                      indices,
@@ -328,7 +328,7 @@ void compile_index(std::ostringstream &stream,
                     }
                 }
 #endif
-                stream << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()];
+                stream << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()];
                 if constexpr (jit::use_metal<T> ()) {
 #ifdef USE_INDEX_CACHE
                     stream << ".read("
@@ -435,7 +435,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns True the node has a zero constant value.
 //------------------------------------------------------------------------------
         virtual bool has_constant_zero() const {
-            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].has_zero();
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].has_zero();
         }
 
 //------------------------------------------------------------------------------
@@ -493,7 +493,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The size of the buffer.
 //------------------------------------------------------------------------------
         size_t get_size() const {
-            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
         }
     };
 
@@ -513,12 +513,12 @@ void compile_index(std::ostringstream &stream,
         auto temp = std::make_shared<piecewise_1D_node<T, SAFE_MATH>> (d, x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -633,11 +633,11 @@ void compile_index(std::ostringstream &stream,
         static size_t hash_data(const backend::buffer<T> &d) {
             const size_t h = std::hash<std::string>{} (piecewise_2D_node::to_string(d));
             for (size_t i = h; i < std::numeric_limits<size_t>::max(); i++) {
-                if (leaf_node<T, SAFE_MATH>::caches.backend_cache.find(i) ==
-                    leaf_node<T, SAFE_MATH>::caches.backend_cache.end()) {
-                    leaf_node<T, SAFE_MATH>::caches.backend_cache[i] = d;
+                if (leaf_node<T, SAFE_MATH>::caches.backends.find(i) ==
+                    leaf_node<T, SAFE_MATH>::caches.backends.end()) {
+                    leaf_node<T, SAFE_MATH>::caches.backends[i] = d;
                     return i;
-                } else if (d == leaf_node<T, SAFE_MATH>::caches.backend_cache[i]) {
+                } else if (d == leaf_node<T, SAFE_MATH>::caches.backends[i]) {
                     return i;
                 }
             }
@@ -688,7 +688,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The number of columns in the constant.
 //------------------------------------------------------------------------------
         size_t get_num_rows() const {
-            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size() /
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size() /
                    num_columns;
         }
 
@@ -702,7 +702,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The evaluated value of the node.
 //------------------------------------------------------------------------------
         virtual backend::buffer<T> evaluate() {
-            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash];
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash];
         }
 
 //------------------------------------------------------------------------------
@@ -758,16 +758,16 @@ void compile_index(std::ostringstream &stream,
                                               visited, usage,
                                               textures1d, textures2d,
                                               avail_const_mem);
-                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()) == registers.end()) {
-                    registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] =
-                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data());
-                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()) == registers.end()) {
+                    registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] =
+                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data());
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #endif
                     } else {
@@ -780,30 +780,30 @@ void compile_index(std::ostringstream &stream,
                         }
                         stream << "const ";
                         jit::add_type<T> (stream);
-                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()] << "[] = {";
+                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] << "[] = {";
                         if constexpr (jit::is_complex<T> ()) {
                             jit::add_type<T> (stream);
                         }
-                        stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][0];
+                        stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][0];
                         for (size_t i = 1; i < length; i++) {
                             stream << ", ";
                             if constexpr (jit::is_complex<T> ()) {
                                 jit::add_type<T> (stream);
                             }
-                            stream << leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash][i];
+                            stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][i];
                         }
                         stream << "};" << std::endl;
                     }
                 } else {
 //  When using textures, the register can be defined in a previous kernel. We
 //  need to add the textures again.
-                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #endif
                     }
@@ -857,7 +857,7 @@ void compile_index(std::ostringstream &stream,
                 jit::register_map &indices,
                 const jit::register_usage &usage) {
             if (registers.find(this) == registers.end()) {
-                const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                 const size_t num_rows = length/num_columns;
 
 #ifdef USE_INDEX_CACHE
@@ -898,7 +898,7 @@ void compile_index(std::ostringstream &stream,
                              ) {
                     if (indices.find(temp.get()) == indices.end()) {
                         indices[temp.get()] = jit::to_string('i', temp.get());
-                        const size_t length = leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].size();
+                        const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                         stream << "        const "
                                << jit::smallest_int_type<T> (length) << " "
                                << indices[temp.get()] << " = "
@@ -927,7 +927,7 @@ void compile_index(std::ostringstream &stream,
                     }
                 }
 #endif
-                stream << registers[leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].data()];
+                stream << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()];
                 if constexpr (jit::use_metal<T> ()) {
 #ifdef USE_INDEX_CACHE
                     stream << ".read("
@@ -1051,7 +1051,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns True the node has a zero constant value.
 //------------------------------------------------------------------------------
         virtual bool has_constant_zero() const {
-            return leaf_node<T, SAFE_MATH>::caches.backend_cache[data_hash].has_zero();
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].has_zero();
         }
 
 //------------------------------------------------------------------------------
@@ -1154,12 +1154,12 @@ void compile_index(std::ostringstream &stream,
         auto temp = std::make_shared<piecewise_2D_node<T, SAFE_MATH>> (d, n, x, y)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/trigonometry.hpp b/graph_framework/trigonometry.hpp
index f69cd90..d5fd80e 100644
--- a/graph_framework/trigonometry.hpp
+++ b/graph_framework/trigonometry.hpp
@@ -228,12 +228,12 @@ namespace graph {
         auto temp = std::make_shared<sine_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -478,12 +478,12 @@ namespace graph {
         auto temp = std::make_shared<cosine_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -798,12 +798,12 @@ namespace graph {
         auto temp = std::make_shared<arctan_node<T, SAFE_MATH>> (l, r)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::caches.main_cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::caches.main_cache.end()) {
-                leaf_node<T, SAFE_MATH>::caches.main_cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.main_cache[i])) {
-                return leaf_node<T, SAFE_MATH>::caches.main_cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_tests/efit_test.cpp b/graph_tests/efit_test.cpp
index 13c1a14..c8d749c 100644
--- a/graph_tests/efit_test.cpp
+++ b/graph_tests/efit_test.cpp
@@ -14,7 +14,6 @@
 #include <netcdf.h>
 
 #include "equilibrium.hpp"
-#include "workflow.hpp"
 
 //------------------------------------------------------------------------------
 ///  @brief Class interface for gold data.
-- 
GitLab