Merge PMDK to Master

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "files.associations": {
+        "mutex": "c",
+        "shared_mutex": "c",
+        "condition_variable": "c",
+        "chrono": "cpp"
+    }
+}

P-CLHT/CMakeLists.txt

@@ -38,9 +38,17 @@ find_library(JemallocLib jemalloc)
 find_library(TbbLib tbb)
 find_package (Threads)
 
+if(PKG_CONFIG_FOUND)
+	pkg_check_modules(LIBPMEMOBJ++ REQUIRED libpmemobj++)
+else()
+	find_package(LIBPMEMOBJ++ REQUIRED)
+endif()
+
+link_directories(${LIBPMEMOBJ++_LIBRARY_DIRS})
+
 set(P_CLHT_TEST example.cpp src/clht_lb_res.c src/clht_gc.c
     external/sspfd/sspfd.c external/ssmem/src/ssmem.c)
 add_executable(example ${P_CLHT_TEST})
 
-target_link_libraries(example ${TbbLib} ${JemallocLib} boost_system
+target_link_libraries(example ${TbbLib} ${JemallocLib} ${LIBPMEMOBJ++_LIBRARIES} boost_system
     boost_thread pthread)

P-CLHT/Makefile

@@ -151,7 +151,7 @@ CFLAGS += $(PLATFORM)
 CFLAGS += $(OPTIMIZE)
 CFLAGS += $(DEBUG_FLAGS)
 
-INCLUDES := -I$(MAININCLUDE) -I$(TOP)/external/include
+INCLUDES := -I$(MAININCLUDE) -I$(TOP)/external/include 
 OBJ_FILES := clht_gc.o
 
 SRC := src

P-CLHT/example.cpp

@@ -6,9 +6,9 @@
 #include <atomic>
 #include "tbb/tbb.h"
 
-using namespace std;
+#include <libpmemobj.h>
 
-#include "clht.h"
+#include "clht_lb_res.h"
 #include "ssmem.h"
 
 typedef struct thread_data {
@@ -117,11 +117,13 @@ void run(char **argv) {
             barrier_cross(&barrier);
 
             for (uint64_t i = start_key; i < end_key; i++) {
-                    uintptr_t val = clht_get(tds[thread_id].ht->ht, keys[i]);
-                    if (val != keys[i]) {
-                        std::cout << "[CLHT] wrong key read: " << val << "expected: " << keys[i] << std::endl;
-                        exit(1);
-                    }
+                PMEMoid pmem_ht = (PMEMoid)((tds[thread_id].ht)->ht);
+                clht_hashtable_t *ht = (clht_hashtable_t*)pmemobj_direct(pmem_ht);
+                uintptr_t val = clht_get(ht, keys[i]);
+                if (val != keys[i]) {
+                    std::cout << "[CLHT] wrong key read: " << val << "expected: " << keys[i] << std::endl;
+                    exit(1);
+                }
             }
         };
 

P-CLHT/include/clht_lb_res.h

@@ -36,6 +36,7 @@
 #include <inttypes.h>
 #include "atomic_ops.h"
 #include "utils.h"
+#include <libpmemobj.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -160,7 +161,8 @@ typedef struct ALIGNED(CACHE_LINE_SIZE) bucket_s
   volatile uint32_t hops;
   clht_addr_t key[ENTRIES_PER_BUCKET];
   clht_val_t val[ENTRIES_PER_BUCKET];
-  volatile struct bucket_s* next;
+  // volatile struct bucket_s* next;
+  PMEMoid next;
 } bucket_t;
 
 //#if __GNUC__ > 4 && __GNUC_MINOR__ > 4
@@ -173,8 +175,10 @@ typedef struct ALIGNED(CACHE_LINE_SIZE) clht
   {
     struct
     {
-      struct clht_hashtable_s* ht;
+      PMEMoid ht;
+      // struct clht_hashtable_s* ht;
       uint8_t next_cache_line[CACHE_LINE_SIZE - (sizeof(void*))];
+      // Prob need to add TOID to this as well
       struct clht_hashtable_s* ht_oldest;
       struct ht_ts* version_list;
       size_t version_min;
@@ -193,7 +197,8 @@ typedef struct ALIGNED(CACHE_LINE_SIZE) clht_hashtable_s
     struct
     {
       size_t num_buckets;
-      bucket_t* table;
+      PMEMoid table;
+      //bucket_t* table;
       size_t hash;
       size_t version;
       uint8_t next_cache_line[CACHE_LINE_SIZE - (3 * sizeof(size_t)) - (sizeof(void*))];
@@ -405,6 +410,7 @@ lock_acq_rtm_chk_resize(clht_lock_t* lock, clht_hashtable_t* h)
 /* Create a new hashtable. */
 clht_hashtable_t* clht_hashtable_create(uint64_t num_buckets);
 clht_t* clht_create(uint64_t num_buckets);
+clht_t* clht_open();
 
 /* Insert a key-value pair into a hashtable. */
 int clht_put(clht_t* hashtable, clht_addr_t key, clht_val_t val);
@@ -441,6 +447,14 @@ int ht_resize_pes(clht_t* hashtable, int is_increase, int by);
 const char* clht_type_desc();
 
 void clht_lock_initialization(clht_t *h);
+
+// Initialize the persistent memory pool
+POBJ_LAYOUT_BEGIN(clht);
+POBJ_LAYOUT_ROOT(clht, clht_t);
+POBJ_LAYOUT_TOID(clht, clht_hashtable_t);
+POBJ_LAYOUT_TOID(clht, bucket_t);
+POBJ_LAYOUT_END(clht);
+
 #ifdef __cplusplus
 }
 #endif

P-CLHT/src/clht_gc.c

@@ -47,7 +47,8 @@ clht_gc_thread_init(clht_t* h, int id)
   ht_ts_t* ts = (ht_ts_t*) memalign(CACHE_LINE_SIZE, sizeof(ht_ts_t));
   assert(ts != NULL);
 
-  ts->version = h->ht->version;
+  clht_hashtable_t* ht_ptr = pmemobj_direct(h->ht);
+  ts->version = ht_ptr->version;
   ts->id = id;
 
   do
@@ -128,7 +129,8 @@ clht_gc_min_version_used(clht_t* h)
 {
   volatile ht_ts_t* cur = h->version_list;
 
-  size_t min = h->ht->version;
+  clht_hashtable_t* ht_ptr = pmemobj_direct(h->ht);
+  size_t min = ht_ptr->version;
   while (cur != NULL)
     {
       if (cur->version < min)
@@ -149,8 +151,9 @@ clht_gc_min_version_used(clht_t* h)
 static int
 clht_gc_collect_cond(clht_t* hashtable, int collect_not_referenced_only)
 {
+  clht_hashtable_t* ht_ptr = pmemobj_direct(hashtable->ht);
   /* if version_min >= current version there is nothing to collect! */
-  if ((hashtable->version_min >= hashtable->ht->version) || TRYLOCK_ACQ(&hashtable->gc_lock))
+  if ((hashtable->version_min >= ht_ptr->version) || TRYLOCK_ACQ(&hashtable->gc_lock))
     {
       /* printf("** someone else is performing gc\n"); */
       return 0;
@@ -160,7 +163,7 @@ clht_gc_collect_cond(clht_t* hashtable, int collect_not_referenced_only)
 
   /* printf("[GCOLLE-%02d] LOCK  : %zu\n", GET_ID(collect_not_referenced_only), hashtable->version); */
 
-  size_t version_min = hashtable->ht->version; 
+  size_t version_min = ht_ptr->version; 
   if (collect_not_referenced_only)
     {
       version_min = clht_gc_min_version_used(hashtable);
@@ -221,20 +224,23 @@ clht_gc_free(clht_hashtable_t* hashtable)
   uint64_t bin;
   for (bin = 0; bin < num_buckets; bin++)
     {
-      bucket = hashtable->table + bin;
-      bucket = bucket->next;
+      bucket = ((bucket_t*)pmemobj_direct(hashtable->table)) + bin;
+      bucket = pmemobj_direct(bucket->next);
+
       while (bucket != NULL)
-	{
-	  volatile bucket_t* cur = bucket;
-	  bucket = bucket->next;
-	  free((void*) cur);
-	}
+      {
+        volatile bucket_t* cur = bucket;
+        bucket = pmemobj_direct(bucket->next);
+        PMEMoid cur_oid = pmemobj_oid((void*) cur);
+        pmemobj_free(&cur_oid);
+      }
     }
 #endif
 
-  free(hashtable->table);
-  free(hashtable);
-
+  pmemobj_free(&(hashtable->table));
+  PMEMoid ht_oid = pmemobj_oid((void*) hashtable);
+  pmemobj_free(&ht_oid);
+
   return 1;
 }
 
@@ -246,12 +252,13 @@ clht_gc_destroy(clht_t* hashtable)
 {
 #if !defined(CLHT_LINKED)
   clht_gc_collect_all(hashtable);
-  clht_gc_free(hashtable->ht);
-  free(hashtable);
+  clht_gc_free(pmemobj_direct(hashtable->ht));
+  // PMEMoid ht_oid = pmemobj_oid((void*) hashtable);
+  // pmemobj_free(&ht_oid);
 #endif
 
-  //  ssmem_alloc_term(clht_alloc);
-  free(clht_alloc);
+  // ssmem_alloc_term(clht_alloc);
+  //free(clht_alloc);
 }
 
 /* 
@@ -269,20 +276,26 @@ clht_gc_release(clht_hashtable_t* hashtable)
 
   uint64_t bin;
   for (bin = 0; bin < num_buckets; bin++)
-    {
-      bucket = hashtable->table + bin;
-      bucket = bucket->next;
+  {
+      bucket = ((bucket_t*)pmemobj_direct(hashtable->table)) + bin;
+      bucket = pmemobj_direct(bucket->next);
+
       while (bucket != NULL)
   	{
   	  volatile bucket_t* cur = bucket;
-  	  bucket = bucket->next;
+  	  bucket = pmemobj_direct(bucket->next);
   	  ssmem_release(clht_alloc, (void*) cur);
+      // PMEMoid cur_oid = pmemobj_oid((void*) cur);
+      // pmemobj_free(&cur_oid);
   	}
-    }
+  }
 #endif
 
-  ssmem_release(clht_alloc, hashtable->table);
+  ssmem_release(clht_alloc, pmemobj_direct(hashtable->table));
   ssmem_release(clht_alloc, hashtable);
+  // pmemobj_free(&(hashtable->table));
+  // PMEMoid ht_oid = pmemobj_oid((void*) hashtable);
+  // pmemobj_free(&ht_oid);
   return 1;
 }