This fixes the problems when using containers in global variables

Because of initialization order issues, before this change, it could
happen that a global container using a free_list as part of its memory
policy would be initialized before the state of the free list.  This
fixes the problem, thus addressing issue #37

Author: arximboldi

immer/heap/free_list_heap.hpp

@@ -49,13 +49,13 @@ struct free_list_heap : Base
 
         free_list_node* n;
         do {
-            n = head_.data;
+            n = head().data;
             if (!n) {
                 auto p = base_t::allocate(Size + sizeof(free_list_node));
                 return static_cast<free_list_node*>(p);
             }
-        } while (!head_.data.compare_exchange_weak(n, n->next));
-        head_.count.fetch_sub(1u, std::memory_order_relaxed);
+        } while (!head().data.compare_exchange_weak(n, n->next));
+        head().count.fetch_sub(1u, std::memory_order_relaxed);
         return n;
     }
 
@@ -67,14 +67,14 @@ struct free_list_heap : Base
 
         // we use relaxed, because we are fine with temporarily having
         // a few more/less buffers in free list
-        if (head_.count.load(std::memory_order_relaxed) >= Limit) {
+        if (head().count.load(std::memory_order_relaxed) >= Limit) {
             base_t::deallocate(Size + sizeof(free_list_node), data);
         } else {
             auto n = static_cast<free_list_node*>(data);
             do {
-                n->next = head_.data;
-            } while (!head_.data.compare_exchange_weak(n->next, n));
-            head_.count.fetch_add(1u, std::memory_order_relaxed);
+                n->next = head().data;
+            } while (!head().data.compare_exchange_weak(n->next, n));
+            head().count.fetch_add(1u, std::memory_order_relaxed);
         }
     }
 
@@ -85,10 +85,11 @@ struct free_list_heap : Base
         std::atomic<std::size_t> count;
     };
 
-    static head_t head_;
+    static head_t& head()
+    {
+        static head_t head_{{nullptr}, {0}};
+        return head_;
+    }
 };
 
-template <std::size_t S, std::size_t L, typename B>
-typename free_list_heap<S,L,B>::head_t  free_list_heap<S,L,B>::head_ {{nullptr}, {0}};
-
 } // namespace immer

immer/heap/thread_local_free_list_heap.hpp

@@ -36,13 +36,13 @@ struct thread_local_free_list_storage
         ~head_t() { Heap::clear(); }
     };
 
-    thread_local static head_t head;
+    static head_t& head()
+    {
+        thread_local static head_t head_{nullptr, 0};
+        return head_;
+    }
 };
 
-template <typename Heap>
-thread_local typename thread_local_free_list_storage<Heap>::head_t
-thread_local_free_list_storage<Heap>::head {nullptr, 0};
-
 } // namespace detail
 
 /*!

immer/heap/unsafe_free_list_heap.hpp

@@ -36,14 +36,13 @@ struct unsafe_free_list_storage
         std::size_t count;
     };
 
-    static head_t head;
+    static head_t& head()
+    {
+        static head_t head_ {nullptr, 0};
+        return head_;
+    }
 };
 
-template <typename Heap>
-typename unsafe_free_list_storage<Heap>::head_t
-unsafe_free_list_storage<Heap>::head {nullptr, 0};
-
-
 template <template<class>class Storage,
           std::size_t Size,
           std::size_t Limit,
@@ -61,13 +60,13 @@ class unsafe_free_list_heap_impl : Base
         assert(size <= sizeof(free_list_node) + Size);
         assert(size >= sizeof(free_list_node));
 
-        auto n = storage::head.data;
+        auto n = storage::head().data;
         if (!n) {
             auto p = base_t::allocate(Size + sizeof(free_list_node));
             return static_cast<free_list_node*>(p);
         }
-        --storage::head.count;
-        storage::head.data = n->next;
+        --storage::head().count;
+        storage::head().data = n->next;
         return n;
     }
 
@@ -77,23 +76,23 @@ class unsafe_free_list_heap_impl : Base
         assert(size <= sizeof(free_list_node) + Size);
         assert(size >= sizeof(free_list_node));
 
-        if (storage::head.count >= Limit)
+        if (storage::head().count >= Limit)
             base_t::deallocate(Size + sizeof(free_list_node), data);
         else {
             auto n = static_cast<free_list_node*>(data);
-            n->next = storage::head.data;
-            storage::head.data = n;
-            ++storage::head.count;
+            n->next = storage::head().data;
+            storage::head().data = n;
+            ++storage::head().count;
         }
     }
 
     static void clear()
     {
-        while (storage::head.data) {
-            auto n = storage::head.data->next;
-            base_t::deallocate(Size + sizeof(free_list_node), storage::head.data);
-            storage::head.data = n;
-            --storage::head.count;
+        while (storage::head().data) {
+            auto n = storage::head().data->next;
+            base_t::deallocate(Size + sizeof(free_list_node), storage::head().data);
+            storage::head().data = n;
+            --storage::head().count;
         }
     }
 };