Cleaned up util::Sorter::SortParallel(...) by adding clarity comments to describe algorithm. Added comments to util::HashTable w.r.t. lazy vs. normal mode.

Author: pmenon

src/catalog/layout_catalog.cpp

@@ -18,6 +18,7 @@
 #include "executor/logical_tile.h"
 #include "storage/data_table.h"
 #include "storage/layout.h"
+#include "type/value_factory.h"
 
 namespace peloton {
 namespace catalog {

src/codegen/query.cpp

@@ -51,7 +51,7 @@ void Query::Execute(executor::ExecutorContext &executor_context,
   func_args->consumer_arg = consumer.GetConsumerState();
 
   // Timer
-  Timer<std::ratio<1, 1000>> timer;
+  Timer<std::milli> timer;
   timer.Start();
 
   // Call init

src/codegen/runtime_functions.cpp

@@ -147,10 +147,10 @@ void RuntimeFunctions::GetTileGroupLayout(const storage::TileGroup *tile_group,
 
 void RuntimeFunctions::ExecuteTableScan(
     void *query_state, executor::ExecutorContext::ThreadStates &thread_states,
-    uint32_t db_oid, uint32_t table_oid, void *f) {
+    uint32_t db_oid, uint32_t table_oid, void *func) {
   //    void (*scanner)(void *, void *, uint64_t, uint64_t)) {
   using ScanFunc = void (*)(void *, void *, uint64_t, uint64_t);
-  auto *scanner = reinterpret_cast<ScanFunc>(f);
+  auto *scanner = reinterpret_cast<ScanFunc>(func);
 
   // The worker pool
   auto &worker_pool = threadpool::MonoQueuePool::GetExecutionInstance();
@@ -179,11 +179,11 @@ void RuntimeFunctions::ExecuteTableScan(
         last_task ? num_tilegroups : tilegroup_start + num_tilegroups_per_task;
     auto work = [&query_state, &thread_states, &scanner, &latch, task_id,
                  tilegroup_start, tilegroup_stop]() {
-      LOG_INFO("Task-%u scanning tile groups [%u-%u)", task_id, tilegroup_start,
-               tilegroup_stop);
+      LOG_DEBUG("Task-%u scanning tile groups [%u-%u)", task_id,
+                tilegroup_start, tilegroup_stop);
 
       // Time this
-      Timer<std::ratio<1, 1000>> timer;
+      Timer<std::milli> timer;
       timer.Start();
 
       // Pull out this task's thread state
@@ -197,8 +197,8 @@ void RuntimeFunctions::ExecuteTableScan(
 
       // Log stuff
       timer.Stop();
-      LOG_INFO("Task-%u done scanning (%.2lf ms) ...", task_id,
-               timer.GetDuration());
+      LOG_DEBUG("Task-%u done scanning (%.2lf ms) ...", task_id,
+                timer.GetDuration());
     };
     worker_pool.SubmitTask(work);
   }
@@ -222,10 +222,10 @@ void RuntimeFunctions::ExecutePerState(
   for (uint32_t tid = 0; tid < num_tasks; tid++) {
     worker_pool.SubmitTask(
         [&query_state, &work_func, &thread_states, &latch, tid]() {
-          LOG_INFO("Processing thread state %u ...", tid);
+          LOG_DEBUG("Processing thread state %u ...", tid);
 
           // Time this
-          Timer<std::ratio<1, 1000>> timer;
+          Timer<std::milli> timer;
           timer.Start();
 
           // Pull out the thread state
@@ -238,8 +238,8 @@ void RuntimeFunctions::ExecutePerState(
           latch.CountDown();
 
           timer.Stop();
-          LOG_INFO("Finished processing thread state %u (%.2lf ms) ...", tid,
-                   timer.GetDuration());
+          LOG_DEBUG("Finished processing thread state %u (%.2lf ms) ...", tid,
+                    timer.GetDuration());
         });
   }
 

src/codegen/util/hash_table.cpp

@@ -106,11 +106,6 @@ void HashTable::EntryBuffer::TransferMemoryBlocks(
 ///
 ////////////////////////////////////////////////////////////////////////////////
 
-/**
- * This hash-table uses an open-addressing probing scheme
- *
- */
-
 HashTable::HashTable(::peloton::type::AbstractPool &memory, uint32_t key_size,
                      uint32_t value_size)
     : memory_(memory),
@@ -157,8 +152,11 @@ char *HashTable::InsertLazy(uint64_t hash) {
 
   // Insert the entry into the linked list in the first directory slot
   if (directory_[0] == nullptr) {
-    // This is the first entry
-    directory_[0] = directory_[1] = entry;
+    // This is the first entry. The first slot in the directory is the head of
+    // the linked list of entries. All other's link their tail to the second
+    // element in the directory.
+    directory_[0] = entry;
+    directory_[1] = entry;
   } else {
     PELOTON_ASSERT(directory_[1] != nullptr);
     directory_[1]->next = entry;
@@ -251,7 +249,6 @@ void HashTable::ReserveLazy(
 void HashTable::MergeLazyUnfinished(HashTable &other) {
   // Begin with the head of the linked list of entries, stored in the first
   // directory entry
-  PELOTON_ASSERT(other.directory_[0] != nullptr);
   auto *head = other.directory_[0];
 
   while (head != nullptr) {
@@ -274,6 +271,7 @@ void HashTable::MergeLazyUnfinished(HashTable &other) {
   ::peloton::atomic_add(&num_elems_, other.NumElements());
 
   // Transfer all allocated memory blocks in the other table into this one
+  PELOTON_ASSERT(&memory_ == &other.memory_);
   other.num_elems_ = other.capacity_ = 0;
   other.entry_buffer_.TransferMemoryBlocks(entry_buffer_);
 }