Move per type data to a meta struct

Author: polytypic

provides/include/trade_v1/private/meta.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "trade_v1/private/access.hpp"
+
+struct trade_v1::Private::meta_t {
+  size_t m_access_align_m1;
+  size_t m_access_size;
+  destroy_t m_destroy;
+};
+
+template <class Value> struct trade_v1::Private::meta {
+  static const meta_t s_instance;
+};
+
+template <class Value>
+const trade_v1::Private::meta_t trade_v1::Private::meta<Value>::s_instance = {
+    alignof(access_t<Value>) - 1,
+    sizeof(access_t<Value>),
+    Private::destroy<Value>};

provides/include/trade_v1/private/private-methods.hpp

@@ -3,6 +3,7 @@
 #include "trade_v1/config.hpp"
 #include "trade_v1/private/access-methods.hpp"
 #include "trade_v1/private/lock.hpp"
+#include "trade_v1/private/meta.hpp"
 #include "trade_v1/private/transaction-methods.hpp"
 
 #include "molecular_v1/backoff.hpp"
@@ -36,10 +37,8 @@ template <class Value>
 trade_v1::Private::access_t<Value> *
 trade_v1::Private::insert(transaction_base_t *transaction,
                           atom_t<Value> *atom) {
-  return static_cast<access_t<Value> *>(insert(transaction,
-                                               atom,
-                                               alignof(access_t<Value>) - 1,
-                                               sizeof(access_t<Value>)));
+  return static_cast<access_t<Value> *>(
+      insert(transaction, atom, meta<Value>::s_instance));
 }
 
 template <class Value>
@@ -48,7 +47,6 @@ Value trade_v1::Private::load(const atom_t<Value> &atom) {
   if (transaction->m_alloc) {
     auto access = insert(transaction, const_cast<atom_t<Value> *>(&atom));
     if (access->m_state == INITIAL) {
-      access->m_destroy = destroy<Value>;
       auto &lock = s_locks[access->m_lock_ix];
       auto s = lock.m_clock.load();
       if (transaction->m_start < s)
@@ -96,7 +94,6 @@ Value &trade_v1::Private::store(atom_t<Value> &atom, Forwardable &&value) {
   switch (access->m_state) {
   case INITIAL:
     new (&access->m_current) Value(std::forward<Forwardable>(value));
-    access->m_destroy = destroy<Value>;
     access->m_state = WRITTEN;
     break;
   case READ:
@@ -114,7 +111,6 @@ template <class Value> Value &trade_v1::Private::ref(atom_t<Value> &atom) {
   auto access = insert(transaction, &atom);
   switch (access->m_state) {
   case INITIAL: {
-    access->m_destroy = destroy<Value>;
     auto &lock = s_locks[access->m_lock_ix];
     auto s = lock.m_clock.load();
     if (transaction->m_start < s)

provides/include/trade_v1/private/private.hpp

@@ -54,6 +54,11 @@ class Private {
 
   //
 
+  struct meta_t;
+  template <class Value> struct meta;
+
+  //
+
   using state_t = uint8_t;
   static constexpr state_t INITIAL = 0, READ = 1, WRITTEN = 2;
 
@@ -86,8 +91,7 @@ class Private {
 
   static access_base_t *insert(transaction_base_t *transaction,
                                atom_mono_t *atom,
-                               size_t align_m1,
-                               size_t size);
+                               const meta_t &meta);
 
   template <class Value>
   static access_t<Value> *insert(transaction_base_t *transaction,

provides/library/trade.cpp

@@ -1,4 +1,5 @@
 #include "trade_v1/trade.hpp"
+#include "trade_v1/private/meta.hpp"
 
 #include <condition_variable>
 #include <cstdio>
@@ -153,20 +154,20 @@ struct trade_v1::Private::Static {
 trade_v1::Private::access_base_t *
 trade_v1::Private::insert(transaction_base_t *transaction,
                           atom_mono_t *access_atom,
-                          size_t align_m1,
-                          size_t size) {
+                          const meta_t &meta) {
   auto root = transaction->m_accesses;
 
   auto access_ix = lock_ix_of(access_atom);
 
   if (!root) {
-    auto access = Static::alloc_align(transaction, align_m1);
-    if (Static::alloc_limit(transaction, access, size)) {
+    auto access = Static::alloc_align(transaction, meta.m_access_align_m1);
+    if (Static::alloc_limit(transaction, access, meta.m_access_size)) {
       access->m_children[0] = nullptr;
       access->m_children[1] = nullptr;
       access->m_atom = access_atom;
       access->m_state = INITIAL;
       access->m_lock_ix = access_ix;
+      access->m_destroy = meta.m_destroy;
       return transaction->m_accesses = access;
     } else {
       throw transaction;
@@ -188,13 +189,14 @@ trade_v1::Private::insert(transaction_base_t *transaction,
         *side_near[0] = nullptr;
         *side_near[1] = root->m_children[1];
         root->m_children[1] = side_root[1];
-        auto access = Static::alloc_align(transaction, align_m1);
-        if (Static::alloc_limit(transaction, access, size)) {
+        auto access = Static::alloc_align(transaction, meta.m_access_align_m1);
+        if (Static::alloc_limit(transaction, access, meta.m_access_size)) {
           access->m_children[0] = side_root[0];
           access->m_children[1] = root;
           access->m_atom = access_atom;
           access->m_state = INITIAL;
           access->m_lock_ix = access_ix;
+          access->m_destroy = meta.m_destroy;
           return transaction->m_accesses = access;
         } else {
           root->m_children[0] = side_root[0];
@@ -213,13 +215,15 @@ trade_v1::Private::insert(transaction_base_t *transaction,
         if (!next) {
           *side_near[0] = nullptr;
           *side_near[1] = root;
-          auto access = Static::alloc_align(transaction, align_m1);
-          if (Static::alloc_limit(transaction, access, size)) {
+          auto access =
+              Static::alloc_align(transaction, meta.m_access_align_m1);
+          if (Static::alloc_limit(transaction, access, meta.m_access_size)) {
             access->m_children[0] = side_root[0];
             access->m_children[1] = side_root[1];
             access->m_atom = access_atom;
             access->m_state = INITIAL;
             access->m_lock_ix = access_ix;
+            access->m_destroy = meta.m_destroy;
             return transaction->m_accesses = access;
           } else {
             root->m_children[0] = side_root[0];
@@ -239,13 +243,14 @@ trade_v1::Private::insert(transaction_base_t *transaction,
         *side_near[0] = root->m_children[0];
         *side_near[1] = nullptr;
         root->m_children[0] = side_root[0];
-        auto access = Static::alloc_align(transaction, align_m1);
-        if (Static::alloc_limit(transaction, access, size)) {
+        auto access = Static::alloc_align(transaction, meta.m_access_align_m1);
+        if (Static::alloc_limit(transaction, access, meta.m_access_size)) {
           access->m_children[0] = root;
           access->m_children[1] = side_root[1];
           access->m_atom = access_atom;
           access->m_state = INITIAL;
           access->m_lock_ix = access_ix;
+          access->m_destroy = meta.m_destroy;
           return transaction->m_accesses = access;
         } else {
           root->m_children[1] = side_root[1];
@@ -264,13 +269,15 @@ trade_v1::Private::insert(transaction_base_t *transaction,
         if (!next) {
           *side_near[0] = root;
           *side_near[1] = nullptr;
-          auto access = Static::alloc_align(transaction, align_m1);
-          if (Static::alloc_limit(transaction, access, size)) {
+          auto access =
+              Static::alloc_align(transaction, meta.m_access_align_m1);
+          if (Static::alloc_limit(transaction, access, meta.m_access_size)) {
             access->m_children[0] = side_root[0];
             access->m_children[1] = side_root[1];
             access->m_atom = access_atom;
             access->m_state = INITIAL;
             access->m_lock_ix = access_ix;
+            access->m_destroy = meta.m_destroy;
             return transaction->m_accesses = access;
           } else {
             root->m_children[1] = side_root[1];