Commit 2c12cab4 authored by Lopez Ortiz, Omar's avatar Lopez Ortiz, Omar
Browse files

Combine leaf_node cache and backend_cache into a single thread_local struct

parent bc946b02

graph_framework/arithmetic.hpp

+25 −25
Original line number Diff line number Diff line
@@ -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__)

graph_framework/math.hpp

+25 −25
Original line number Diff line number Diff line
@@ -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__)

graph_framework/node.hpp

+13 −11
Original line number Diff line number Diff line
@@ -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__)

graph_framework/piecewise.hpp

+53 −53

File changed.

Preview size limit exceeded, changes collapsed.

graph_framework/trigonometry.hpp

+15 −15
Original line number Diff line number Diff line
@@ -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__)