simplified code: removed external/fastmod.h; removed additive_search; removed SDC and D-EF encoders

Author: jermp

CMakeLists.txt

@@ -9,7 +9,6 @@ MESSAGE(STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE})
 if (NOT TARGET PTHASH)
   add_library(PTHASH INTERFACE)
   target_include_directories(PTHASH INTERFACE include)
-  target_include_directories(PTHASH SYSTEM INTERFACE external/fastmod)
   target_include_directories(PTHASH SYSTEM INTERFACE external/mm_file/include)
   target_include_directories(PTHASH SYSTEM INTERFACE external/xxHash)
 

external/fastmod/fastmod.h

@@ -21,6 +21,7 @@ struct external_memory_builder_partitioned_phf {
         util::check_hash_collision_probability<Hasher>(num_keys);
 
         const uint64_t avg_partition_size = compute_avg_partition_size(num_keys, config);
+        m_avg_partition_size = avg_partition_size;
         const uint64_t num_partitions = compute_num_partitions(num_keys, avg_partition_size);
         if (num_partitions == 0) throw std::invalid_argument("number of partitions must be > 0");
 
@@ -200,6 +201,10 @@ struct external_memory_builder_partitioned_phf {
         return m_num_partitions;
     }
 
+    uint64_t avg_partition_size() const {
+        return m_avg_partition_size;
+    }
+
     range_bucketer bucketer() const {
         return m_bucketer;
     }
@@ -268,6 +273,8 @@ struct external_memory_builder_partitioned_phf {
     uint64_t m_num_keys;
     uint64_t m_table_size;
     uint64_t m_num_partitions;
+    uint64_t m_avg_partition_size;
+
     range_bucketer m_bucketer;
     std::vector<uint64_t> m_offsets;
     builders_files_manager<internal_memory_builder_single_phf<hasher_type, Bucketer>> m_builders;

include/builders/external_memory_builder_partitioned_phf.hpp

@@ -142,8 +142,8 @@ struct external_memory_builder_single_phf {
                 auto pilots =
                     tfm.get_multifile_pairs_writer(num_non_empty_buckets, ram_for_pilots, 1, 0);
 
-                search(m_num_keys, m_num_buckets, num_non_empty_buckets, m_seed, config,
-                       buckets_iterator, taken_bvb, pilots);
+                search(m_num_keys, m_num_buckets, num_non_empty_buckets,  //
+                       config, buckets_iterator, taken_bvb, pilots);
 
                 pilots.flush();
                 buckets_iterator.close();
@@ -199,6 +199,14 @@ struct external_memory_builder_single_phf {
         return m_table_size;
     }
 
+    uint64_t num_partitions() const {
+        return 0;
+    }
+
+    uint64_t avg_partition_size() const {
+        return 0;
+    }
+
     Bucketer bucketer() const {
         return m_bucketer;
     }
@@ -216,7 +224,9 @@ struct external_memory_builder_single_phf {
     uint64_t m_num_keys;
     uint64_t m_table_size;
     uint64_t m_num_buckets;
+
     Bucketer m_bucketer;
+
     std::string m_pilots_filename;
     std::string m_free_slots_filename;
 

include/builders/external_memory_builder_single_phf.hpp

@@ -20,6 +20,7 @@ struct internal_memory_builder_partitioned_phf {
         const uint64_t avg_partition_size = config.dense_partitioning
                                                 ? find_avg_partition_size(num_keys)
                                                 : compute_avg_partition_size(num_keys, config);
+        m_avg_partition_size = avg_partition_size;
         const uint64_t num_partitions = compute_num_partitions(num_keys, avg_partition_size);
         assert(num_partitions > 0);
 
@@ -255,6 +256,10 @@ struct internal_memory_builder_partitioned_phf {
         return m_num_partitions;
     }
 
+    uint64_t avg_partition_size() const {
+        return m_avg_partition_size;
+    }
+
     uint64_t num_buckets_per_partition() const {
         return m_num_buckets_per_partition;
     }
@@ -405,8 +410,11 @@ struct internal_memory_builder_partitioned_phf {
     uint64_t m_num_keys;
     uint64_t m_table_size;
     uint64_t m_num_partitions;
+    uint64_t m_avg_partition_size;
     uint64_t m_num_buckets_per_partition;
+
     range_bucketer m_bucketer;
+
     std::vector<uint64_t> m_offsets;
     std::vector<uint64_t> m_free_slots;  // for dense partitioning
     std::vector<internal_memory_builder_single_phf<hasher_type, bucketer_type>> m_builders;

include/builders/internal_memory_builder_partitioned_phf.hpp

@@ -117,8 +117,8 @@ struct internal_memory_builder_single_phf {
             bits::bit_vector::builder taken_bvb(m_table_size);
             uint64_t num_non_empty_buckets = buckets.num_buckets();
             pilots_wrapper_t pilots_wrapper(m_pilots);
-            search(m_num_keys, m_num_buckets, num_non_empty_buckets, m_seed, config,
-                   buckets_iterator, taken_bvb, pilots_wrapper);
+            search(m_num_keys, m_num_buckets, num_non_empty_buckets,  //
+                   config, buckets_iterator, taken_bvb, pilots_wrapper);
             taken_bvb.build(m_taken);
             if (config.minimal) {
                 m_free_slots.clear();
@@ -152,6 +152,14 @@ struct internal_memory_builder_single_phf {
         return m_table_size;
     }
 
+    uint64_t num_partitions() const {
+        return 0;
+    }
+
+    uint64_t avg_partition_size() const {
+        return 0;
+    }
+
     Bucketer bucketer() const {
         return m_bucketer;
     }
@@ -224,7 +232,9 @@ struct internal_memory_builder_single_phf {
     uint64_t m_num_keys;
     uint64_t m_num_buckets;
     uint64_t m_table_size;
+
     Bucketer m_bucketer;
+
     bits::bit_vector m_taken;
     std::vector<uint64_t> m_pilots;
     std::vector<uint64_t> m_free_slots;