minor optims

Author: lperron

ortools/flatzinc/fz.cc

@@ -194,6 +194,7 @@ int main(int argc, char** argv) {
     std::string currentLine;
     while (std::getline(std::cin, currentLine)) {
       input.append(currentLine);
+      input.append("\n");
     }
   } else {
     if (residual_flags.empty()) {

ortools/graph/minimum_spanning_tree.h

@@ -134,16 +134,21 @@ std::vector<typename Graph::ArcIndex> BuildPrimMinimumSpanningTree(
     int GetHeapIndex() const { return heap_index; }
     bool operator<(const Entry& other) const { return value > other.value; }
 
-    NodeIndex node;
+    // In the typical case, `NodeIndex` is 4 bytes, so having fields in this
+    // order is optimal in terms of memory usage and cache locality across all
+    // values of `sizeof(ArcValueType)`.
     ArcValueType value;
+    NodeIndex node;
     int heap_index;
   };
 
   AdjustablePriorityQueue<Entry> pq;
   std::vector<Entry> entries;
   std::vector<bool> touched_entry(graph.num_nodes(), false);
   for (NodeIndex node : graph.AllNodes()) {
-    entries.push_back({node, std::numeric_limits<ArcValueType>::max(), -1});
+    entries.push_back({.value = std::numeric_limits<ArcValueType>::max(),
+                       .node = node,
+                       .heap_index = -1});
   }
   entries[0].value = 0;
   pq.Add(&entries[0]);

ortools/sat/BUILD.bazel

@@ -3509,11 +3509,13 @@ cc_library(
         ":synchronization",
         ":timetable",
         ":util",
+        "//ortools/base:stl_util",
         "//ortools/util:bitset",
         "//ortools/util:saturated_arithmetic",
         "//ortools/util:strong_integers",
         "//ortools/util:time_limit",
         "@abseil-cpp//absl/container:flat_hash_set",
+        "@abseil-cpp//absl/container:inlined_vector",
         "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/log:vlog_is_on",

ortools/sat/cp_model.cc

@@ -610,6 +610,9 @@ LinearExpr IntervalVar::EndExpr() const {
 BoolVar IntervalVar::PresenceBoolVar() const {
   DCHECK(builder_ != nullptr);
   if (builder_ == nullptr) return BoolVar();
+  if (builder_->Proto().constraints(index_).enforcement_literal_size() == 0) {
+    return builder_->TrueVar();
+  }
   return BoolVar(builder_->Proto().constraints(index_).enforcement_literal(0),
                  builder_);
 }
@@ -712,12 +715,25 @@ BoolVar CpModelBuilder::FalseVar() {
 IntervalVar CpModelBuilder::NewIntervalVar(const LinearExpr& start,
                                            const LinearExpr& size,
                                            const LinearExpr& end) {
-  return NewOptionalIntervalVar(start, size, end, TrueVar());
+  const int index = cp_model_.constraints_size();
+  ConstraintProto* const ct = cp_model_.add_constraints();
+  IntervalConstraintProto* const interval = ct->mutable_interval();
+  *interval->mutable_start() = LinearExprToProto(start);
+  *interval->mutable_size() = LinearExprToProto(size);
+  *interval->mutable_end() = LinearExprToProto(end);
+  return IntervalVar(index, this);
 }
 
 IntervalVar CpModelBuilder::NewFixedSizeIntervalVar(const LinearExpr& start,
                                                     int64_t size) {
-  return NewOptionalFixedSizeIntervalVar(start, size, TrueVar());
+  const int index = cp_model_.constraints_size();
+  ConstraintProto* const ct = cp_model_.add_constraints();
+  IntervalConstraintProto* const interval = ct->mutable_interval();
+  *interval->mutable_start() = LinearExprToProto(start);
+  interval->mutable_size()->set_offset(size);
+  *interval->mutable_end() = LinearExprToProto(start);
+  interval->mutable_end()->set_offset(interval->end().offset() + size);
+  return IntervalVar(index, this);
 }
 
 IntervalVar CpModelBuilder::NewOptionalIntervalVar(const LinearExpr& start,

ortools/sat/cp_model_solver.cc

@@ -2407,7 +2407,8 @@ CpSolverResponse SolveCpModel(const CpModelProto& model_proto, Model* model) {
   // Always add the timing information to a response. Note that it is important
   // to add this after the log/dump postprocessor since we execute them in
   // reverse order.
-  auto* shared_time_limit = model->GetOrCreate<ModelSharedTimeLimit>();
+  ModelSharedTimeLimit* shared_time_limit =
+      model->GetOrCreate<ModelSharedTimeLimit>();
   shared_response_manager->AddResponsePostprocessor(
       [&wall_timer, &user_timer,
        &shared_time_limit](CpSolverResponse* response) {
@@ -2446,7 +2447,7 @@ CpSolverResponse SolveCpModel(const CpModelProto& model_proto, Model* model) {
   // Register SIGINT handler if requested by the parameters.
   if (params.catch_sigint_signal()) {
     model->GetOrCreate<SigintHandler>()->Register(
-        [&shared_time_limit]() { shared_time_limit->Stop(); });
+        [shared_time_limit]() { shared_time_limit->Stop(); });
   }
 #endif  // __PORTABLE_PLATFORM__
 

ortools/sat/cp_model_test.cc

@@ -1196,37 +1196,32 @@ TEST(CpModelTest, TestNoOverlap) {
   const CpModelProto expected_model = ParseTestProto(R"pb(
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
-    variables { domain: 1 domain: 1 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     constraints {
-      enforcement_literal: 2
       interval {
         start { vars: 0 coeffs: 1 }
         end { vars: 1 coeffs: 1 }
         size { offset: 5 }
       }
     }
     constraints {
-      enforcement_literal: 2
       interval {
-        start { vars: 3 coeffs: 1 }
-        end { vars: 4 coeffs: 1 }
+        start { vars: 2 coeffs: 1 }
+        end { vars: 3 coeffs: 1 }
         size { offset: 5 }
       }
     }
     constraints {
-      enforcement_literal: 2
       interval {
-        start { vars: 5 coeffs: 1 }
-        end { vars: 6 coeffs: 1 }
+        start { vars: 4 coeffs: 1 }
+        end { vars: 5 coeffs: 1 }
         size { offset: 5 }
       }
     }
-    constraints { no_overlap { intervals: 0 intervals: 1 intervals: 2 } }
-  )pb");
+    constraints { no_overlap { intervals: 0 intervals: 1 intervals: 2 } })pb");
   EXPECT_THAT(cp_model.Proto(), EqualsProto(expected_model));
 }
 
@@ -1257,42 +1252,37 @@ TEST(CpModelTest, TestNoOverlap2D) {
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 5 domain: 5 }
-    variables { domain: 1 domain: 1 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     constraints {
-      enforcement_literal: 3
       interval {
         start { vars: 0 coeffs: 1 }
         end { vars: 1 coeffs: 1 }
         size { vars: 2 coeffs: 1 }
       }
     }
     constraints {
-      enforcement_literal: 3
       interval {
-        start { vars: 4 coeffs: 1 }
-        end { vars: 5 coeffs: 1 }
+        start { vars: 3 coeffs: 1 }
+        end { vars: 4 coeffs: 1 }
         size { vars: 2 coeffs: 1 }
       }
     }
     constraints {
-      enforcement_literal: 3
       interval {
-        start { vars: 6 coeffs: 1 }
-        end { vars: 7 coeffs: 1 }
+        start { vars: 5 coeffs: 1 }
+        end { vars: 6 coeffs: 1 }
         size { vars: 2 coeffs: 1 }
       }
     }
     constraints {
-      enforcement_literal: 3
       interval {
-        start { vars: 8 coeffs: 1 }
-        end { vars: 9 coeffs: 1 }
+        start { vars: 7 coeffs: 1 }
+        end { vars: 8 coeffs: 1 }
         size { vars: 2 coeffs: 1 }
       }
     }
@@ -1325,37 +1315,33 @@ TEST(CpModelTest, TestCumulative) {
   const CpModelProto expected_model = ParseTestProto(R"pb(
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
-    variables { domain: 1 domain: 1 }
     variables { domain: 0 domain: 20 }
     variables { domain: 0 domain: 20 }
     variables { domain: 5 domain: 10 }
     variables { domain: 5 domain: 10 }
     constraints {
-      enforcement_literal: 2
       interval {
         start { vars: 0 coeffs: 1 }
         end { vars: 1 coeffs: 1 }
         size { offset: 5 }
       }
     }
     constraints {
-      enforcement_literal: 2
       interval {
-        start { vars: 3 coeffs: 1 }
-        end { vars: 4 coeffs: 1 }
+        start { vars: 2 coeffs: 1 }
+        end { vars: 3 coeffs: 1 }
         size { offset: 5 }
       }
     }
     constraints {
       cumulative {
-        capacity: { vars: 5 coeffs: 1 }
+        capacity { vars: 4 coeffs: 1 }
         intervals: 0
         intervals: 1
-        demands { vars: 6 coeffs: 1 }
+        demands { vars: 5 coeffs: 1 }
         demands { offset: 8 }
       }
-    }
-  )pb");
+    })pb");
   EXPECT_THAT(cp_model.Proto(), EqualsProto(expected_model));
 }
 

ortools/sat/cuts.cc

@@ -2063,9 +2063,10 @@ ImpliedBoundsProcessor::ComputeBestImpliedBound(
     // and slack in [0, ub - lb].
     const IntegerValue diff = entry.lower_bound - lb;
     CHECK_GE(diff, 0);
-    const double bool_lp_value = entry.is_positive
-                                     ? lp_values[entry.literal_view]
-                                     : 1.0 - lp_values[entry.literal_view];
+    const double bool_lp_value =
+        VariableIsPositive(entry.literal_view)
+            ? lp_values[entry.literal_view]
+            : 1.0 - lp_values[PositiveVariable(entry.literal_view)];
     const double slack_lp_value =
         lp_values[var] - ToDouble(lb) - bool_lp_value * ToDouble(diff);
 
@@ -2075,14 +2076,14 @@ ImpliedBoundsProcessor::ComputeBestImpliedBound(
       LinearConstraint ib_cut;
       ib_cut.lb = kMinIntegerValue;
       std::vector<std::pair<IntegerVariable, IntegerValue>> terms;
-      if (entry.is_positive) {
+      if (VariableIsPositive(entry.literal_view)) {
         // X >= Indicator * (bound - lb) + lb
         terms.push_back({entry.literal_view, diff});
         terms.push_back({var, IntegerValue(-1)});
         ib_cut.ub = -lb;
       } else {
         // X >= -Indicator * (bound - lb) + bound
-        terms.push_back({entry.literal_view, -diff});
+        terms.push_back({PositiveVariable(entry.literal_view), -diff});
         terms.push_back({var, IntegerValue(-1)});
         ib_cut.ub = -entry.lower_bound;
       }
@@ -2100,7 +2101,6 @@ ImpliedBoundsProcessor::ComputeBestImpliedBound(
       result.var_lp_value = lp_values[var];
       result.bool_lp_value = bool_lp_value;
       result.implied_bound = entry.lower_bound;
-      result.is_positive = entry.is_positive;
       result.bool_var = entry.literal_view;
     }
   }
@@ -2153,11 +2153,11 @@ bool ImpliedBoundsProcessor::DecomposeWithImpliedLowerBound(
 
   // We have X/-X = info.diff * Boolean + slack.
   bool_term.coeff = term.coeff * bound_diff;
-  bool_term.expr_vars[0] = info.bool_var;
+  bool_term.expr_vars[0] = PositiveVariable(info.bool_var);
   bool_term.expr_coeffs[1] = 0;
   bool_term.bound_diff = IntegerValue(1);
   bool_term.lp_value = info.bool_lp_value;
-  if (info.is_positive) {
+  if (VariableIsPositive(info.bool_var)) {
     bool_term.expr_coeffs[0] = IntegerValue(1);
     bool_term.expr_offset = IntegerValue(0);
   } else {

ortools/sat/cuts.h

@@ -263,8 +263,10 @@ class ImpliedBoundsProcessor {
   struct BestImpliedBoundInfo {
     double var_lp_value = 0.0;
     double bool_lp_value = 0.0;
-    bool is_positive;
     IntegerValue implied_bound;
+
+    // When VariableIsPositive(bool_var) then it is when this is one that the
+    // bound is implied. Otherwise it is when this is zero.
     IntegerVariable bool_var = kNoIntegerVariable;
 
     double SlackLpValue(IntegerValue lb) const {

ortools/sat/diffn.cc

@@ -26,11 +26,13 @@
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/log/vlog_is_on.h"
 #include "absl/numeric/bits.h"
 #include "absl/types/span.h"
+#include "ortools/base/stl_util.h"
 #include "ortools/sat/2d_mandatory_overlap_propagator.h"
 #include "ortools/sat/2d_orthogonal_packing.h"
 #include "ortools/sat/2d_try_edge_propagator.h"
@@ -287,11 +289,11 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
     };
 
     for (int i = 0; i < num_boxes; ++i) {
-      if (repository->IsOptional(x[i])) continue;
-      if (repository->IsOptional(y[i])) continue;
+      if (repository->IsAbsent(x[i])) continue;
+      if (repository->IsAbsent(y[i])) continue;
       for (int j = i + 1; j < num_boxes; ++j) {
-        if (repository->IsOptional(x[j])) continue;
-        if (repository->IsOptional(y[j])) continue;
+        if (repository->IsAbsent(x[j])) continue;
+        if (repository->IsAbsent(y[j])) continue;
 
         // At most one of these two x options is true.
         const Literal x_ij = f(repository->End(x[i]), repository->Start(x[j]));
@@ -314,7 +316,21 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
         }
 
         // At least one of the 4 options is true.
-        if (!sat_solver->AddProblemClause({x_ij, x_ji, y_ij, y_ji})) {
+        std::vector<Literal> clause = {x_ij, x_ji, y_ij, y_ji};
+        if (repository->IsOptional(x[i])) {
+          clause.push_back(repository->PresenceLiteral(x[i]).Negated());
+        }
+        if (repository->IsOptional(y[i])) {
+          clause.push_back(repository->PresenceLiteral(y[i]).Negated());
+        }
+        if (repository->IsOptional(x[j])) {
+          clause.push_back(repository->PresenceLiteral(x[j]).Negated());
+        }
+        if (repository->IsOptional(y[j])) {
+          clause.push_back(repository->PresenceLiteral(y[j]).Negated());
+        }
+        gtl::STLSortAndRemoveDuplicates(&clause);
+        if (!sat_solver->AddProblemClause(clause)) {
           return;
         }
       }

ortools/sat/fuzz_testdata/EnumerateAllSolutions

@@ -20,8 +20,20 @@ variables {
 constraints {
   all_diff {
     exprs {
-      vars: [0, 1, 2, 3]
-      coeffs: [1, 1, 1, 1]
+      vars: [0]
+      coeffs: [1]
+    }
+    exprs {
+      vars: [1]
+      coeffs: [1]
+    }
+    exprs {
+      vars: [2]
+      coeffs: [1]
+    }
+    exprs {
+      vars: [3]
+      coeffs: [1]
     }
   }
 }