Update

HW2

Author: ChanJoon

HW2/HTtest

@@ -0,0 +1,27 @@
+USER_ID := $(shell whoami)
+
+.PHONY: run HTtest clean remote report format
+# HT Test
+run: HTtest
+	./HTtest 0 | tee result/base.txt
+	./HTtest 1 | tee result/better.txt
+
+HTtest: main.cc 
+	g++ -std=c++11 -g -fopenmp -pthread  $< -o $@ -lboost_system  -lboost_thread
+
+clean:
+	rm -f HTtest result/*.txt
+
+remote: 
+	scp better_locked_hash_table.h mgp-run:/home/${USER_ID}/HW2
+	scp locked_hash_table.h mgp-run:/home/${USER_ID}/HW2
+	scp hash_table.h mgp-run:/home/${USER_ID}/HW2
+	ssh mgp-run "cd HW2 && make" | tee result/eval_output.txt
+
+report:
+	cat result/base.txt
+	cat result/better.txt
+
+# Development
+format:
+	clang-format -i -style=Google *.cc *.h

HW2/Makefile

@@ -0,0 +1,39 @@
+# Homework 2
+
+## Summary
+
+You should improve a performance of locked open addressing hash table.
+
+Go to `better_locked_hash_table.h` and implement `TODO`
+
+```
+$ make remote
+$ cat result/better.txt
+TABLE_SIZE 10000000 init: 4000000 new: 4000000 NT: 16 additional_reads: 9 use_custom: 1
+user-defined HT1 1
+start filling
+init hash table took 0.118376 sec
+start test
+test 36000000 ops took @@@@@@@ sec
+sanity check PASSED: 
+```
+
+## Functions
+
+```
+# Run locally
+make
+make run
+# Compile
+make HTtest
+# Clean
+make clean
+# Evaluate performance
+make remote
+# Remove
+make remove
+```
+
+## References
+
+- [std::thread - cplusplus.com](http://www.cplusplus.com/reference/thread/thread/)

HW2/README.md

@@ -0,0 +1,164 @@
+#ifndef _BETTER_LOCKED_HASH_TABLE_H_
+#define _BETTER_LOCKED_HASH_TABLE_H_
+
+
+#include <iostream>
+#include <mutex>
+#include <thread>
+//
+#include <vector>
+#include <atomic>
+#include <shared_mutex>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/locks.hpp>
+//
+#include "hash_table.h"
+#include "bucket.h"
+
+class better_locked_probing_hash_table : public hash_table {
+
+  private:
+    Bucket* table;
+    const int TABLE_SIZE; //we do not consider resizing. Thus the table has to be larger than the max num items.
+    std::mutex global_mutex; 
+
+    static constexpr int NUM_STRIPES = 256;
+    std::vector<std::mutex> stripe_mutexes;
+    std::vector<boost::shared_mutex> shared_stripe_mutexes;
+
+    int get_stripe_index(uint64_t table_index)
+    {
+      return table_index % NUM_STRIPES;
+    }
+
+    public:
+
+    better_locked_probing_hash_table(int table_size):TABLE_SIZE(table_size), stripe_mutexes(NUM_STRIPES), shared_stripe_mutexes(NUM_STRIPES) {
+      this->table = new Bucket[TABLE_SIZE]();
+      for(int i=0;i<TABLE_SIZE;i++) {
+        this->table[i].valid=0; //means empty
+      }
+    }
+
+    virtual uint32_t hash(uint32_t x) override 
+    {
+      //https://stackoverflow.com/questions/664014/what-integer-hash-function-are-good-that-accepts-an-integer-hash-key
+      x = ((x >> 16) ^ x) * 0x45d9f3b;
+      x = ((x >> 16) ^ x) * 0x45d9f3b;
+      x = (x >> 16) ^ x;
+      return (x % TABLE_SIZE); 
+    }
+
+    // uint32_t hash(uint32_t x, std::mutex* m)  
+    // {
+    //   m->lock();
+    //   //https://stackoverflow.com/questions/664014/what-integer-hash-function-are-good-that-accepts-an-integer-hash-key
+    //   x = ((x >> 16) ^ x) * 0x45d9f3b;
+    //   x = ((x >> 16) ^ x) * 0x45d9f3b;
+    //   x = (x >> 16) ^ x;
+    //   m->unlock();
+    //   return (x % TABLE_SIZE); 
+    // }
+
+    // uint32_t hash(std::atomic<uint32_t> *x)  
+    // {
+    //   uint32_t val = x->load();
+    //   //https://stackoverflow.com/questions/664014/what-integer-hash-function-are-good-that-accepts-an-integer-hash-key
+    //   val = ((val >> 16) ^ val) * 0x45d9f3b;
+    //   val = ((val >> 16) ^ val) * 0x45d9f3b;
+    //   val = (val >> 16) ^ val;
+
+    //   x->store(val);
+    //   return (val % TABLE_SIZE); 
+    // }
+
+    uint32_t hash2(uint32_t x)
+    {
+      // Which one is more effective?
+      //https://stackoverflow.com/a/41537995
+      const int p = 23;
+      const uint32_t knuth = 2654435769;
+      const uint32_t y = x;
+
+      x =  (y * knuth) >> (32 - p);
+      return (x % TABLE_SIZE);
+    }
+
+    virtual uint32_t hash_next(uint32_t key, uint32_t prev_index) override
+    {
+      //linear probing. no special secondary hashfunction
+      return ((prev_index + 1)% TABLE_SIZE); 
+    }
+
+    uint32_t hash_next(uint32_t key, uint32_t prev_index, int probe_count)
+    {
+      //quadratic probing. no special secondary hashfunction
+      // std::cout << "We got probe_count: " << probe_count << std::endl;
+      return ((prev_index + probe_count * probe_count + probe_count)% TABLE_SIZE);
+    }
+
+    //the buffer has to be allocated by the caller
+    bool read(uint32_t key, uint64_t* value_buffer){
+      uint64_t index = this->hash(key);
+      // boost::shared_lock<boost::shared_mutex> lock(shared_stripe_mutexes[get_stripe_index(index)]);
+      int probe_count=0;
+
+      while(table[index].valid == true) {
+        if(table[index].key == key) {
+          *value_buffer = table[index].value;
+          return true;
+        } else {
+          probe_count++;
+          index = this->hash_next(key, index, probe_count);
+          if(probe_count >= TABLE_SIZE) break;
+        }
+      }//end while
+
+      //If you reached here, you either encountered an empty slot or the table is full. In any case, the item you're looking for is not here 
+      return false;
+
+    }
+
+
+    bool insert(uint32_t key, uint64_t value) {
+      // std::lock_guard<std::mutex> lock(global_mutex);
+      uint64_t index = this->hash(key);
+
+      int probe_count=0;
+
+      while (true) {
+        std::lock_guard<std::mutex> lock(stripe_mutexes[get_stripe_index(index)]);
+        // boost::unique_lock<boost::shared_mutex> lock(shared_stripe_mutexes[get_stripe_index(index)]);
+        if (table[index].valid == false) {
+          // Found an empty bucket
+          table[index].valid = true;
+          table[index].key = key;
+          table[index].value = value;
+          return true;
+        } else if (table[index].key == key) {
+          // Found a bucket with the same key, modify its value
+          table[index].value = value;
+          return true;
+        } else {
+          // Bucket is occupied by a different key, continue probing
+          probe_count++;
+          index = this->hash_next(key, index, probe_count);
+          if (probe_count >= TABLE_SIZE) {
+            // Could not add because the table is full
+            return false;
+          }
+        }
+      }
+
+    }
+
+    int num_items() {
+      int count=0;
+      for(int i=0;i<TABLE_SIZE;i++) {
+        if(table[i].valid==true) count++;
+      }
+      return count;
+    }
+};
+
+#endif

HW2/better_locked_hash_table.h

@@ -0,0 +1,12 @@
+#ifndef _BUCKET_H_
+#define _BUCKET_H_
+#include <unistd.h>
+
+struct Bucket { //16B in its size
+  uint32_t key;  // 2B key
+  uint16_t valid; // 0=empty 1=occupied
+  uint16_t meta; // Currently Unused. Reserved for 1B misc metadata (timestamp, contained lock, memo, tag, or anything)
+  uint64_t value;
+};
+
+#endif

HW2/bucket.h

@@ -0,0 +1,136 @@
+#ifndef _ERROR_H_
+#define _ERROR_H_
+
+
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/prctl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <assert.h>
+
+
+
+#define ASSERT(left,operator,right) { if(!((left) operator (right))){ std::cerr << "ASSERT FAILED: " << #left << #operator << #right << " @ " << __FILE__ << " (" << __LINE__ << "). " << #left << "=" << (left) << "; " << #right << "=" << (right) << std::endl; assert((left) operator (right));}}
+
+ void format_backtrace(std::string &output) {
+  // Trim the right side of the output.
+  size_t index = output.find_last_not_of(" \t\r\n");
+  output.erase((index != std::string::npos) ? index + 1 : 0);
+
+  // Find an entry for the signal handler and trim all entries deeper than it.
+  index = output.find("<signal handler called>");
+  if (index != std::string::npos) {
+    index = output.find('\n', index);
+    if (index != std::string::npos) {
+      output.erase(0, index + 1);
+    }
+  }
+
+  // Insert indentation.
+  if (!output.empty()) {
+    const std::string indent = "  ";
+    output.insert(0, indent);
+
+    for (size_t offset = output.find('\n'); offset != std::string::npos; ) {
+      output.insert(offset + 1, indent);
+      offset = output.find('\n', offset + 1);
+    }
+  }
+}
+void print_backtrace() {
+  int pipefd[2];
+  int use_pipe = (pipe(pipefd) == 0);
+
+  pid_t child = fork();
+  if (child == -1) {
+    return;
+  }
+
+  if (child == 0) {
+    if (use_pipe) {
+      close(pipefd[0]);
+    }
+
+    // Create a dummy process so that GDB can attach to it. This is to provide a
+    // workaround for the case when ptrace_scope is enabled, in which processes
+    // are not allowed to attach to non-child processes.
+    pid_t dummy = fork();
+    if (dummy == -1) {
+      _Exit(1);
+    }
+
+    if (dummy == 0) {
+      if (use_pipe) {
+        close(pipefd[1]);
+      }
+
+      // Wait until the parent process sends SIGTERM on its termination.
+      int result = prctl(PR_SET_PDEATHSIG, SIGTERM, 0, 0, 0);
+      if (result == 0) {
+        pause();
+      }
+    } else {
+      // Ignore stderr and redirect stdout to pipe (or stderr).
+      dup2(use_pipe ? pipefd[1] : fileno(stderr), fileno(stdout));
+      //FILE* tmp = freopen("/dev/null", "w", stderr);
+
+      // Run GDB to print the current stack trace.
+      std::string pid = std::to_string(dummy);
+      execlp("gdb", "gdb", "--pid", pid.c_str(), "--batch",
+             "-ex", "set print frame-arguments none", "-ex", "bt", NULL);
+    }
+
+    _Exit(0);
+  } else {
+    if (use_pipe) {
+      close(pipefd[1]);
+
+      // Read backtrace from GDB.
+      std::string output;
+      for (char c; read(pipefd[0], &c, 1) > 0; ) {
+        output.push_back(c);
+      }
+
+      close(pipefd[0]);
+
+      // Format the output.
+      format_backtrace(output);
+
+      // Print the backtrace.
+      if (!output.empty()) {
+        fprintf(stderr, "Backtrace:\n%s\n", output.c_str());
+      }
+    }
+
+    waitpid(child, NULL, 0);
+  }
+}
+
+
+extern "C" void backtrace_handler(int sig) {
+  // Print the current stack trace.
+  print_backtrace();
+
+  // Call the original signal handler.
+  signal(sig, SIG_DFL);
+  int result = raise(sig);
+
+  if (result != 0) {
+    _Exit(sig);
+  }
+}
+
+void install_backtrace_handler() {
+  signal(SIGABRT, backtrace_handler);
+  signal(SIGFPE, backtrace_handler);
+  signal(SIGSEGV, backtrace_handler);
+}
+#endif