optimizations, still debugging

Author: etwest

include/sketch_types.h

@@ -1,4 +1,9 @@
 #pragma once
+
+#include <exception>
+#include <vector>
+
+#include "types.h"
 // enum SerialType {
 //   FULL,
 //   RANGE,
@@ -17,19 +22,18 @@ struct SketchSample {
 };
 
 struct ExhaustiveSketchSample {
-  std::unordered_set<vec_t> idxs;
+  std::vector<vec_t> idxs;
   SampleResult result;
 };
 
 class OutOfSamplesException : public std::exception {
  private:
   std::string err_msg;
+
  public:
   OutOfSamplesException(size_t seed, size_t num_samples, size_t sample_idx)
       : err_msg("This sketch (seed=" + std::to_string(seed) +
                 ", max samples=" + std::to_string(num_samples) +
                 ") cannot be sampled more times (cur idx=" + std::to_string(sample_idx) + ")!") {}
-  virtual const char* what() const throw() {
-    return err_msg.c_str();
-  }
+  virtual const char* what() const throw() { return err_msg.c_str(); }
 };

include/sparse_sketch.h

@@ -56,7 +56,7 @@ class SparseSketch {
   // Allocated buckets
   Bucket* buckets;
 
-  static constexpr size_t min_num_dense_rows = 4;
+  static constexpr size_t min_num_dense_rows = 5;
   size_t num_dense_rows = min_num_dense_rows;
 
   // Variables for sparse representation of lower levels of bucket Matrix
@@ -81,6 +81,47 @@ class SparseSketch {
   void update_sparse(uint8_t col, SparseBucket to_add, bool realloc_if_needed = true);
   SketchSample sample_sparse(size_t first_col, size_t end_col);
 
+  inline uint8_t remove_ll_head(size_t col) {
+    uint8_t temp = ll_metadata[col];
+    ll_metadata[col] = sparse_buckets[ll_metadata[col]].next;
+    return temp;
+  }
+  inline uint8_t claim_free_bucket() {
+    assert(ll_metadata[num_columns] != uint8_t(-1));
+    return remove_ll_head(num_columns);
+  }
+  inline void insert_to_ll_head(size_t col, uint8_t add_idx) {
+    sparse_buckets[add_idx].next = ll_metadata[col];
+    ll_metadata[col] = add_idx;
+  }
+  inline void free_bucket(uint8_t bkt_idx) {
+    sparse_buckets[bkt_idx].row = 0;
+    sparse_buckets[bkt_idx].bkt = {0, 0};
+    insert_to_ll_head(num_columns, bkt_idx);
+  }
+  inline void insert_to_ll(uint8_t add_idx, SparseBucket &prev) {
+    sparse_buckets[add_idx].next = prev.next;
+    prev.next = add_idx;
+  }
+  inline void remove_from_ll(SparseBucket& bkt_to_remove, SparseBucket &prev) {
+    prev.next = bkt_to_remove.next;
+  }
+  inline bool merge_sparse_bkt(uint8_t our_idx, SparseBucket& oth, uint8_t prev_idx, size_t col) {
+    SparseBucket &ours = sparse_buckets[our_idx];
+    ours.bkt.alpha ^= oth.bkt.alpha;
+    ours.bkt.gamma ^= oth.bkt.gamma;
+    if (Bucket_Boruvka::is_empty(ours.bkt)) {
+      if (prev_idx == uint8_t(-1)) 
+        remove_ll_head(col);
+      else 
+        remove_from_ll(ours, sparse_buckets[prev_idx]);
+      
+      free_bucket(our_idx);
+      return true;
+    }
+    return false;
+  }
+
   inline Bucket& deterministic_bucket() {
     return buckets[0];
   }
@@ -119,6 +160,11 @@ class SparseSketch {
     ll_metadata = (uint8_t *) &buckets[calc_metadata_index(num_dense_rows)];
   }
 
+  // given another SparseSketch column, merge it into ours
+  void merge_sparse_column(SparseBucket *oth_sparse_buckets, uint8_t *oth_ll_metadata, size_t col);
+
+  void validate();
+
  public:
   /**
    * The below constructors use vector length as their input. However, in graph sketching our input

src/cc_sketch_alg.cpp

@@ -466,7 +466,7 @@ inline void CCSketchAlg::create_merge_instructions(std::vector<MergeInstr> &merg
 }
 
 void CCSketchAlg::boruvka_emulation() {
-  // auto start = std::chrono::steady_clock::now();
+  auto start = std::chrono::steady_clock::now();
   update_locked = true;
 
   cc_alg_start = std::chrono::steady_clock::now();
@@ -486,27 +486,27 @@ void CCSketchAlg::boruvka_emulation() {
   }
   size_t round_num = 0;
   bool modified = true;
-  // std::cout << std::endl;
-  // std::cout << "  pre boruvka processing = "
-  //             << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
-  //             << std::endl;
+  std::cout << std::endl;
+  std::cout << "  pre boruvka processing = "
+              << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
+              << std::endl;
 
   while (true) {
-    // std::cout << "   Round: " << round_num << std::endl;
-    // start = std::chrono::steady_clock::now();
+    std::cout << "   Round: " << round_num << std::endl;
+    start = std::chrono::steady_clock::now();
     modified = perform_boruvka_round(round_num, merge_instr, global_merges);
-    // std::cout << "     perform_boruvka_round = "
-    //           << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
-    //           << std::endl;
+    std::cout << "     perform_boruvka_round = "
+              << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
+              << std::endl;
 
     if (!modified) break;
 
     // calculate updated merge instructions for next round
-    // start = std::chrono::steady_clock::now();
+    start = std::chrono::steady_clock::now();
     create_merge_instructions(merge_instr);
-    // std::cout << "     create_merge_instructions = "
-    //           << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
-    //           << std::endl;
+    std::cout << "     create_merge_instructions = "
+              << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
+              << std::endl;
     ++round_num;
   }
   last_query_rounds = round_num;
@@ -534,11 +534,11 @@ ConnectedComponents CCSketchAlg::connected_components() {
     bool except = false;
     std::exception_ptr err;
     try {
-      // auto start = std::chrono::steady_clock::now();
+      auto start = std::chrono::steady_clock::now();
       boruvka_emulation();
-      // std::cout << " boruvka's algorithm = "
-      //         << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
-      //         << std::endl;
+      std::cout << " boruvka's algorithm = "
+              << std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count()
+              << std::endl;
     } catch (...) {
       except = true;
       err = std::current_exception();

src/dense_sketch.cpp

@@ -124,7 +124,7 @@ ExhaustiveSketchSample DenseSketch::exhaustive_sample() {
   if (sample_idx >= num_samples) {
     throw OutOfSamplesException(seed, num_samples, sample_idx);
   }
-  std::unordered_set<vec_t> ret;
+  std::vector<vec_t> ret;
 
   size_t idx = sample_idx++;
   size_t first_column = idx * cols_per_sample;
@@ -133,14 +133,14 @@ ExhaustiveSketchSample DenseSketch::exhaustive_sample() {
     return {ret, ZERO}; // the "first" bucket is deterministic so if zero then no edges to return
 
   unlikely_if (Bucket_Boruvka::is_good(deterministic_bucket(), checksum_seed())) {
-    ret.insert(deterministic_bucket().alpha);
+    ret.push_back(deterministic_bucket().alpha);
     return {ret, GOOD};
   }
 
   for (size_t i = 0; i < cols_per_sample; ++i) {
     for (size_t j = 0; j < bkt_per_col; ++j) {
       unlikely_if (Bucket_Boruvka::is_good(bucket(i + first_column, j), checksum_seed())) {
-        ret.insert(bucket(i + first_column, j).alpha);
+        ret.push_back(bucket(i + first_column, j).alpha);
       }
     }
   }