Merge remote-tracking branch 'private/master' into gpl-filler-gcell-removal

Author: gudeh

Jenkinsfile

@@ -264,7 +264,13 @@ def bazelTest = {
                             if (env.BRANCH_NAME != 'master') {
                                 cmd += ' --remote_upload_local_results=false';
                             }
-                            sh label: 'Bazel Build', script: cmd + ' --google_credentials=$GCS_SA_KEY ...';
+                            cmd += ' --google_credentials=$GCS_SA_KEY';
+                            try {
+                                sh label: 'Bazel Build', script: cmd + ' ...';
+                            } catch (e) {
+                                currentBuild.result = 'FAILURE';
+                                sh label: 'Bazel Build (keep_going)', script: cmd + ' --keep_going ...';
+                            }
                         }
                     }
                 }

docs/user/Bazel-caching.md

@@ -51,6 +51,28 @@ bazel build --config=openroad-dev //...
 
 This configuration is **read-only** to prevent local, unverified builds from populating the shared cache.
 
+### Using a `user.bazelrc` file instead of `--config=openroad-dev`
+
+You may prefer `user.bazelrc` file instead of using the `--config=openroad-dev` option.
+
+    # user: username@openroad.tools
+    build --remote_cache=https://storage.googleapis.com/openroad-bazel-cache
+    build --credential_helper=*.googleapis.com=%workspace%/etc/cred_helper.py
+    build --remote_cache_compression=true
+    build --remote_upload_local_results=false
+
+To test the setup:
+
+    $ etc/cred_helper.py test
+    Running: gcloud auth print-access-token username@openroad.tools
+    {
+    "kind": "storage#testIamPermissionsResponse",
+    "permissions": [
+        "storage.buckets.get",
+        "storage.objects.create"
+    ]
+    }
+
 ---
 
 ### 3. CI Access (Jenkins Pipeline)

src/par/src/Coarsener.cpp

@@ -653,16 +653,16 @@ void Coarsener::OrderVertices(const HGraphPtr& hgraph,
                               std::vector<int>& vertices) const
 {
   switch (vertex_order_choice_) {
-    case CoarsenOrder::RANDOM:
+    case CoarsenOrder::kRandom:
       shuffle(vertices.begin(),
               vertices.end(),
               std::default_random_engine(random_seed_));
       return;
 
-    case CoarsenOrder::DEFAULT:
+    case CoarsenOrder::kDefault:
       return;
 
-    case CoarsenOrder::SIZE: {
+    case CoarsenOrder::kSize: {
       // sort the vertices based on vertex weight
       // calculate the weight for all the vertices
       std::vector<float> average_sizes(hgraph->GetNumVertices(), 0.0);
@@ -677,7 +677,7 @@ void Coarsener::OrderVertices(const HGraphPtr& hgraph,
     }
       return;
 
-    case CoarsenOrder::DEGREE: {
+    case CoarsenOrder::kDegree: {
       // sort the vertices based on degree of each vertex in non-decreasing
       // order i.e., number of neighboring vertices
       std::vector<int> degrees(hgraph->GetNumVertices(), 0);
@@ -944,16 +944,16 @@ HGraphPtr Coarsener::Contraction(
 std::string ToString(const CoarsenOrder order)
 {
   switch (order) {
-    case CoarsenOrder::RANDOM:
+    case CoarsenOrder::kRandom:
       return std::string("RANDOM");
 
-    case CoarsenOrder::DEGREE:
+    case CoarsenOrder::kDegree:
       return std::string("DEGREE");
 
-    case CoarsenOrder::SIZE:
+    case CoarsenOrder::kSize:
       return std::string("SIZE");
 
-    case CoarsenOrder::DEFAULT:
+    case CoarsenOrder::kDefault:
       return std::string("DEFAULT");
 
     default:

src/par/src/Coarsener.h

@@ -30,10 +30,10 @@ using CoarseningPtr = std::shared_ptr<Coarsener>;
 // the type for vertex ordering
 enum class CoarsenOrder
 {
-  RANDOM,
-  DEGREE,
-  SIZE,
-  DEFAULT
+  kRandom,
+  kDegree,
+  kSize,
+  kDefault
 };
 
 // function : convert CoarsenOrder to string
@@ -183,7 +183,7 @@ class Coarsener
 
   std::vector<float> thr_cluster_weight_;  // the maximum weight of a cluster
   int random_seed_ = 0;
-  CoarsenOrder vertex_order_choice_ = CoarsenOrder::RANDOM;
+  CoarsenOrder vertex_order_choice_ = CoarsenOrder::kRandom;
   EvaluatorPtr evaluator_ = nullptr;
   utl::Logger* logger_ = nullptr;
 };

src/par/src/Evaluator.cpp

@@ -719,7 +719,7 @@ void GoldenEvaluator::UpdateTiming(const HGraphPtr& hgraph,
     // the remaining vertices are all sinks
     // It will stop if the sink vertex is a FF or IO
     for (const int v : timing_graph_->Vertices(e)) {
-      if (timing_graph_->GetVertexType(v) != COMB_STD_CELL) {
+      if (timing_graph_->GetVertexType(v) != kCombStdCell) {
         continue;  // the current vertex is port or seq_std_cell or macro
       }
       // find all the hyperedges connected to this hyperedge
@@ -749,7 +749,7 @@ void GoldenEvaluator::UpdateTiming(const HGraphPtr& hgraph,
     const int src_id = *range.begin();
     // Stop backward traversing if the current vertex is port or seq_std_cell or
     // macro
-    if (timing_graph_->GetVertexType(src_id) != COMB_STD_CELL) {
+    if (timing_graph_->GetVertexType(src_id) != kCombStdCell) {
       return;  // the current vertex is port or seq_std_cell or macro
     }
     // find all the hyperedges driving this vertex

src/par/src/GreedyRefine.cpp

@@ -54,7 +54,7 @@ float GreedyRefine::Pass(
     // find the best candidate block
     // the initialization of best_gain is 0.0
     // define a lambda function to compare two HyperedgeGainPtr (>=)
-    auto CompareHyperedgeGain
+    auto compare_hyperedge_gain
         = [&](const HyperedgeGainPtr& a, const HyperedgeGainPtr& b) {
             if (a->GetGain() > b->GetGain()) {
               return true;
@@ -81,7 +81,7 @@ float GreedyRefine::Pass(
         HyperedgeGainPtr gain_hyperedge = CalculateHyperedgeGain(
             hyperedge_id, to_pid, hgraph, solution, cur_paths_cost, net_degs);
         if (!best_gain_hyperedge
-            || CompareHyperedgeGain(gain_hyperedge, best_gain_hyperedge)) {
+            || compare_hyperedge_gain(gain_hyperedge, best_gain_hyperedge)) {
           best_gain_hyperedge = gain_hyperedge;
         }
       }

src/par/src/Multilevel.cpp

@@ -244,7 +244,7 @@ std::vector<int> MultilevelPartitioner::SingleCycleRefinement(
                             upper_block_balance,
                             lower_block_balance,
                             top_solutions[best_solution_id],
-                            PartitionType::INIT_DIRECT_ILP);
+                            PartitionType::kInitDirectIlp);
   }
   // Here we need to do rebugetting on the best solution
   RefinePartition(hierarchy,
@@ -297,7 +297,7 @@ void MultilevelPartitioner::InitialPartition(
                             upper_block_balance,
                             lower_block_balance,
                             solution,
-                            PartitionType::INIT_RANDOM);
+                            PartitionType::kInitRandom);
     // call FM refiner to improve the solution
     k_way_fm_refiner_->Refine(
         hgraph, upper_block_balance, lower_block_balance, solution);
@@ -325,7 +325,7 @@ void MultilevelPartitioner::InitialPartition(
                             upper_block_balance,
                             lower_block_balance,
                             solution,
-                            PartitionType::INIT_RANDOM_VILE);
+                            PartitionType::kInitRandomVile);
     // call FM refiner to improve the solution
     k_way_fm_refiner_->Refine(
         hgraph, upper_block_balance, lower_block_balance, solution);
@@ -351,7 +351,7 @@ void MultilevelPartitioner::InitialPartition(
                           upper_block_balance,
                           lower_block_balance,
                           vile_solution,
-                          PartitionType::INIT_VILE);
+                          PartitionType::kInitVile);
   // We need k_way_fm_refiner to generate a balanced partitioning
   k_way_fm_refiner_->Refine(
       hgraph, upper_block_balance, lower_block_balance, vile_solution);
@@ -386,7 +386,7 @@ void MultilevelPartitioner::InitialPartition(
                             upper_block_balance,
                             lower_block_balance,
                             ilp_solution,
-                            PartitionType::INIT_DIRECT_ILP);
+                            PartitionType::kInitDirectIlp);
     const auto ilp_token
         = evaluator_->CutEvaluator(hgraph, ilp_solution, false);
     initial_solutions_cost.push_back(ilp_token.cost);
@@ -651,7 +651,7 @@ std::vector<int> MultilevelPartitioner::CutOverlayILPPart(
                             upper_block_balance,
                             lower_block_balance,
                             init_solution,
-                            PartitionType::INIT_DIRECT_ILP);
+                            PartitionType::kInitDirectIlp);
   } else {
     clustered_hgraph->SetCommunity(init_solution);
     init_solution = SingleCycleRefinement(

src/par/src/Partitioner.cpp

@@ -65,20 +65,20 @@ void Partitioner::Partition(const HGraphPtr& hgraph,
     std::fill(solution.begin(), solution.end(), -1);
   }
   switch (partitioner_choice) {
-    case PartitionType::INIT_RANDOM:
+    case PartitionType::kInitRandom:
       RandomPart(hgraph, upper_block_balance, lower_block_balance, solution);
       break;
 
-    case PartitionType::INIT_RANDOM_VILE:
+    case PartitionType::kInitRandomVile:
       RandomPart(
           hgraph, upper_block_balance, lower_block_balance, solution, true);
       break;
 
-    case PartitionType::INIT_VILE:
+    case PartitionType::kInitVile:
       VilePart(hgraph, solution);
       break;
 
-    case PartitionType::INIT_DIRECT_ILP:
+    case PartitionType::kInitDirectIlp:
       ILPPart(hgraph, upper_block_balance, lower_block_balance, solution);
       break;
 
@@ -224,7 +224,7 @@ void Partitioner::ILPPart(const HGraphPtr& hgraph,
     std::iota(edge_mask.begin(), edge_mask.end(), 0);
   } else if (ilp_accelerator_factor_ > 0.0) {
     // define comp structure to compare hyperedge ( function: >)
-    struct comp
+    struct Comp
     {
       // comparator function
       bool operator()(const std::pair<int, float>& l,
@@ -237,7 +237,7 @@ void Partitioner::ILPPart(const HGraphPtr& hgraph,
       }
     };
     // use set data structure to sort hyperedges
-    std::set<std::pair<int, float>, comp> unvisited_hyperedges;
+    std::set<std::pair<int, float>, Comp> unvisited_hyperedges;
     float tot_cost = 0.0;  // total hyperedge cut
     for (auto e = 0; e < hgraph->GetNumHyperedges(); ++e) {
       const float score = evaluator_->CalculateHyperedgeCost(e, hgraph);

src/par/src/Partitioner.h

@@ -25,10 +25,10 @@ namespace par {
 // Define the partitioning algorithm
 enum class PartitionType
 {
-  INIT_RANDOM,
-  INIT_RANDOM_VILE,
-  INIT_VILE,
-  INIT_DIRECT_ILP
+  kInitRandom,
+  kInitRandomVile,
+  kInitVile,
+  kInitDirectIlp
 };
 
 class Partitioner;

src/par/src/PriorityQueue.cpp

@@ -72,7 +72,7 @@ std::shared_ptr<VertexGain> PriorityQueue::GetBestCandidate(
   int index = 0;             // starting from the first index
 
   // define the lambda function to check the balance constraint
-  auto CheckBalance = [&](int index) {
+  auto check_balance = [&](int index) {
     const int vertex_id = vertices_[index]->GetVertex();
     const int to_pid = vertices_[index]->GetDestinationPart();
     const int from_pid = vertices_[index]->GetSourcePart();
@@ -86,7 +86,7 @@ std::shared_ptr<VertexGain> PriorityQueue::GetBestCandidate(
   };
 
   // check the first index
-  if (CheckBalance(index) == true) {
+  if (check_balance(index) == true) {
     return vertices_[index];
   }
 
@@ -95,13 +95,13 @@ std::shared_ptr<VertexGain> PriorityQueue::GetBestCandidate(
     pass++;
     // Step 1: check the left child first
     const int left_child = LeftChild(index);
-    if (left_child < total_elements_ && CheckBalance(left_child) == true) {
+    if (left_child < total_elements_ && check_balance(left_child) == true) {
       candidate_index = left_child;
     }
 
     // Step 2: check the right child second
     const int right_child = RightChild(index);
-    if (right_child < total_elements_ && CheckBalance(right_child) == true
+    if (right_child < total_elements_ && check_balance(right_child) == true
         && (candidate_index == -1
             || CompareElementLargeThan(right_child, candidate_index))) {
       candidate_index = right_child;  // use the right index