refactor: rename ip code, split into more files, remove ip namespace …

…in favor of more Initial* prefixes

kaminpar-shm/initial_partitioning/bfs_bipartitioner.cc → kaminpar-shm/initial_partitioning/initial_bfs_bipartitioner.cc

@@ -5,7 +5,7 @@
  * @author: Daniel Seemaier
  * @date:   21.09.2021
  ******************************************************************************/
-#include "kaminpar-shm/initial_partitioning/bfs_bipartitioner.h"
+#include "kaminpar-shm/initial_partitioning/initial_bfs_bipartitioner.h"
 
 #include "kaminpar-shm/datastructures/csr_graph.h"
 #include "kaminpar-shm/initial_partitioning/seed_node_utils.h"
@@ -14,7 +14,7 @@
 #include "kaminpar-common/datastructures/marker.h"
 #include "kaminpar-common/datastructures/queue.h"
 
-namespace kaminpar::shm::ip {
+namespace kaminpar::shm {
 using Queues = std::array<Queue<NodeID>, 2>;
 
 namespace bfs {
@@ -68,17 +68,17 @@ struct shorter_queue {
 } // namespace bfs
 
 template <typename BlockSelectionStrategy>
-BfsBipartitioner<BlockSelectionStrategy>::BfsBipartitioner(
+InitialBFSBipartitioner<BlockSelectionStrategy>::InitialBFSBipartitioner(
     const InitialPoolPartitionerContext &pool_ctx
 )
-    : Bipartitioner(pool_ctx),
+    : InitialFlatBipartitioner(pool_ctx),
       _num_seed_iterations(pool_ctx.num_seed_iterations) {}
 
 template <typename BlockSelectionStrategy>
-void BfsBipartitioner<BlockSelectionStrategy>::init(
+void InitialBFSBipartitioner<BlockSelectionStrategy>::init(
     const CSRGraph &graph, const PartitionContext &p_ctx
 ) {
-  Bipartitioner::init(graph, p_ctx);
+  InitialFlatBipartitioner::init(graph, p_ctx);
 
   if (_marker.capacity() < _graph->n()) {
     _marker.resize(_graph->n());
@@ -95,9 +95,9 @@ void BfsBipartitioner<BlockSelectionStrategy>::init(
 }
 
 template <typename BlockSelectionStrategy>
-void BfsBipartitioner<BlockSelectionStrategy>::fill_bipartition() {
+void InitialBFSBipartitioner<BlockSelectionStrategy>::fill_bipartition() {
   const auto [start_a, start_b] =
-      ip::find_far_away_nodes(*_graph, _num_seed_iterations, _queues[0], _bfs_init_marker);
+      find_far_away_nodes(*_graph, _num_seed_iterations, _queues[0], _bfs_init_marker);
 
   _marker.reset();
   for (const auto i : {0, 1}) {
@@ -165,9 +165,9 @@ void BfsBipartitioner<BlockSelectionStrategy>::fill_bipartition() {
   }
 }
 
-template class BfsBipartitioner<bfs::alternating>;
-template class BfsBipartitioner<bfs::lighter>;
-template class BfsBipartitioner<bfs::sequential>;
-template class BfsBipartitioner<bfs::longer_queue>;
-template class BfsBipartitioner<bfs::shorter_queue>;
-} // namespace kaminpar::shm::ip
+template class InitialBFSBipartitioner<bfs::alternating>;
+template class InitialBFSBipartitioner<bfs::lighter>;
+template class InitialBFSBipartitioner<bfs::sequential>;
+template class InitialBFSBipartitioner<bfs::longer_queue>;
+template class InitialBFSBipartitioner<bfs::shorter_queue>;
+} // namespace kaminpar::shm

kaminpar-shm/initial_partitioning/bfs_bipartitioner.h → kaminpar-shm/initial_partitioning/initial_bfs_bipartitioner.h

@@ -10,13 +10,13 @@
 #include <array>
 
 #include "kaminpar-shm/datastructures/csr_graph.h"
-#include "kaminpar-shm/initial_partitioning/bipartitioner.h"
+#include "kaminpar-shm/initial_partitioning/initial_flat_bipartitioner.h"
 #include "kaminpar-shm/kaminpar.h"
 
 #include "kaminpar-common/datastructures/marker.h"
 #include "kaminpar-common/datastructures/queue.h"
 
-namespace kaminpar::shm::ip {
+namespace kaminpar::shm {
 namespace bfs {
 struct alternating;   // Switch between queues after each node
 struct lighter;       // Use lighter queue next
@@ -34,11 +34,12 @@ struct shorter_queue; // Use shorter queue next
  *
  * @tparam BlockSelectionStrategy Invoked after each step to choose the active block.
  */
-template <typename BlockSelectionStrategy> class BfsBipartitioner : public Bipartitioner {
+template <typename BlockSelectionStrategy>
+class InitialBFSBipartitioner : public InitialFlatBipartitioner {
   static constexpr std::size_t kMarkAssigned = 2;
 
 public:
-  BfsBipartitioner(const InitialPoolPartitionerContext &pool_ctx);
+  InitialBFSBipartitioner(const InitialPoolPartitionerContext &pool_ctx);
 
   void init(const CSRGraph &graph, const PartitionContext &p_ctx) final;
 
@@ -53,9 +54,9 @@ template <typename BlockSelectionStrategy> class BfsBipartitioner : public Bipar
   Marker<3> _marker{};
 };
 
-using AlternatingBfsBipartitioner = BfsBipartitioner<bfs::alternating>;
-using LighterBlockBfsBipartitioner = BfsBipartitioner<bfs::lighter>;
-using SequentialBfsBipartitioner = BfsBipartitioner<bfs::sequential>;
-using LongerQueueBfsBipartitioner = BfsBipartitioner<bfs::longer_queue>;
-using ShorterQueueBfsBipartitioner = BfsBipartitioner<bfs::shorter_queue>;
-} // namespace kaminpar::shm::ip
+using AlternatingBfsBipartitioner = InitialBFSBipartitioner<bfs::alternating>;
+using LighterBlockBfsBipartitioner = InitialBFSBipartitioner<bfs::lighter>;
+using SequentialBfsBipartitioner = InitialBFSBipartitioner<bfs::sequential>;
+using LongerQueueBfsBipartitioner = InitialBFSBipartitioner<bfs::longer_queue>;
+using ShorterQueueBfsBipartitioner = InitialBFSBipartitioner<bfs::shorter_queue>;
+} // namespace kaminpar::shm

kaminpar-shm/initial_partitioning/initial_coarsener.cc

@@ -11,7 +11,7 @@
 #include "kaminpar-common/logger.h"
 #include "kaminpar-common/timer.h"
 
-namespace kaminpar::shm::ip {
+namespace kaminpar::shm {
 namespace {
 constexpr static bool kRandomizeNodeOrder = true;
 }
@@ -403,4 +403,4 @@ void InitialCoarsener::interleaved_visit_neighbor(
     _rating_map[_clustering[c_v].leader] += weight;
   }
 }
-} // namespace kaminpar::shm::ip
+} // namespace kaminpar::shm

kaminpar-shm/initial_partitioning/initial_coarsener.h

@@ -19,7 +19,7 @@
 #include "kaminpar-common/datastructures/scalable_vector.h"
 #include "kaminpar-common/random.h"
 
-namespace kaminpar::shm::ip {
+namespace kaminpar::shm {
 struct InitialCoarsenerTimings {
   std::uint64_t contract_ms = 0;
   std::uint64_t alloc_ms = 0;
@@ -40,8 +40,8 @@ struct InitialCoarsenerTimings {
 };
 
 class InitialCoarsener {
-  static constexpr auto kChunkSize = 256;
-  static constexpr auto kNumberOfNodePermutations = 16;
+  static constexpr std::size_t kChunkSize = 256;
+  static constexpr std::size_t kNumberOfNodePermutations = 16;
 
   using ContractionResult = std::pair<CSRGraph, ScalableVector<NodeID>>;
 
@@ -142,4 +142,4 @@ class InitialCoarsener {
 
   InitialCoarsenerTimings _timings{};
 };
-} // namespace kaminpar::shm::ip
+} // namespace kaminpar::shm

kaminpar-shm/initial_partitioning/bipartitioner.cc → kaminpar-shm/initial_partitioning/initial_flat_bipartitioner.cc

@@ -5,7 +5,7 @@
  * @author: Daniel Seemaier
  * @date:   21.09.2021
  ******************************************************************************/
-#include "kaminpar-shm/initial_partitioning/bipartitioner.h"
+#include "kaminpar-shm/initial_partitioning/initial_flat_bipartitioner.h"
 
 #include "kaminpar-shm/datastructures/csr_graph.h"
 #include "kaminpar-shm/datastructures/partitioned_graph.h"
@@ -14,16 +14,17 @@
 #include "kaminpar-common/assert.h"
 #include "kaminpar-common/datastructures/static_array.h"
 
-namespace kaminpar::shm::ip {
-void Bipartitioner::init(const CSRGraph &graph, const PartitionContext &p_ctx) {
+namespace kaminpar::shm {
+void InitialFlatBipartitioner::init(const CSRGraph &graph, const PartitionContext &p_ctx) {
   KASSERT(p_ctx.k == 2u, "must be initialized with a 2-way partition context");
 
   _graph = &graph;
   _p_ctx = &p_ctx;
 }
 
-PartitionedCSRGraph
-Bipartitioner::bipartition(StaticArray<BlockID> partition, StaticArray<BlockWeight> block_weights) {
+PartitionedCSRGraph InitialFlatBipartitioner::bipartition(
+    StaticArray<BlockID> partition, StaticArray<BlockWeight> block_weights
+) {
   if (_graph->n() == 0) {
     block_weights[0] = 0;
     block_weights[1] = 0;
@@ -54,4 +55,4 @@ Bipartitioner::bipartition(StaticArray<BlockID> partition, StaticArray<BlockWeig
 
   return {*_graph, 2, std::move(_partition), std::move(_final_block_weights)};
 }
-} // namespace kaminpar::shm::ip
+} // namespace kaminpar::shm

kaminpar-shm/initial_partitioning/bipartitioner.h → kaminpar-shm/initial_partitioning/initial_flat_bipartitioner.h

@@ -16,16 +16,16 @@
 #include "kaminpar-common/assert.h"
 #include "kaminpar-common/datastructures/static_array.h"
 
-namespace kaminpar::shm::ip {
-class Bipartitioner {
+namespace kaminpar::shm {
+class InitialFlatBipartitioner {
 public:
-  Bipartitioner(const Bipartitioner &) = delete;
-  Bipartitioner &operator=(Bipartitioner &&) = delete;
+  InitialFlatBipartitioner(const InitialFlatBipartitioner &) = delete;
+  InitialFlatBipartitioner &operator=(InitialFlatBipartitioner &&) = delete;
 
-  Bipartitioner(Bipartitioner &&) noexcept = default;
-  Bipartitioner &operator=(const Bipartitioner &) = delete;
+  InitialFlatBipartitioner(InitialFlatBipartitioner &&) noexcept = default;
+  InitialFlatBipartitioner &operator=(const InitialFlatBipartitioner &) = delete;
 
-  virtual ~Bipartitioner() = default;
+  virtual ~InitialFlatBipartitioner() = default;
 
   virtual void init(const CSRGraph &graph, const PartitionContext &p_ctx);
 
@@ -36,7 +36,7 @@ class Bipartitioner {
   static constexpr BlockID V1 = 0;
   static constexpr BlockID V2 = 1;
 
-  Bipartitioner(const InitialPoolPartitionerContext &pool_ctx) : _pool_ctx(pool_ctx) {}
+  InitialFlatBipartitioner(const InitialPoolPartitionerContext &pool_ctx) : _pool_ctx(pool_ctx) {}
 
   virtual void fill_bipartition() = 0;
 
@@ -81,4 +81,4 @@ class Bipartitioner {
   StaticArray<BlockID> _partition;
   StaticArray<BlockWeight> _final_block_weights;
 };
-} // namespace kaminpar::shm::ip
+} // namespace kaminpar::shm