58#include "absl/flags/declare.h"
59#include "absl/flags/flag.h"
60#include "absl/status/status.h"
61#include "absl/status/statusor.h"
62#include "absl/strings/match.h"
63#include "absl/strings/str_cat.h"
64#include "absl/strings/str_format.h"
65#include "absl/time/time.h"
72#include "ortools/linear_solver/linear_solver.pb.h"
77#include "ortools/sat/cp_model.pb.h"
84 "Input file name with solution in .sol format.");
85ABSL_FLAG(std::optional<std::string>, solver, std::nullopt,
86 "The solver to use: bop, cbc, clp, glop, glpk_lp, glpk_mip, "
87 "gurobi_lp, gurobi_mip, pdlp, scip, knapsack, sat. If unspecified "
88 "either use MPModelRequest.solver_type if the --input is an "
89 "MPModelRequest and the field is set or use glop.");
91 "Number of threads to use by the underlying solver.");
93 "Solver specific parameters file. "
94 "If this flag is set, the --params flag is ignored.");
95ABSL_FLAG(std::string, params,
"",
"Solver specific parameters");
97 "It specifies a limit on the solving time. The duration must be must "
98 "be positive. It default to an infinite duration meaning that no "
99 "time limit will be imposed.");
101 "If non-empty, write the returned solution in csv format with "
102 "each line formed by a variable name and its value.");
105 "Format in which to dump protos (if flags --dump_model, "
106 "--dump_request, or --dump_response are used). Possible values: "
107 "'text', 'binary', 'json' which correspond to text proto format "
108 "binary proto format, and json. If 'binary' or 'json' are used, "
109 "we append '.bin' and '.json' to file names.");
111 "Whether to gzip dumped protos. Appends .gz to their name.");
113 "If non-empty, dumps MPModelProto there.");
115 "If non-empty, dumps MPModelRequest there.");
117 "If non-empty, dumps MPSolutionResponse there.");
119 "If non-empty, output the best solution in Miplib .sol format.");
121 "If non-empty, dumps the model in mps format there.");
124 "Run MPSolver on the given input file. Many formats are supported: \n"
125 " - a .mps or .mps.gz file,\n"
126 " - an MPModelProto (binary or text, possibly gzipped),\n"
127 " - an MPModelRequest (binary or text, possibly gzipped).";
132MPModelRequest ReadMipModel(
const std::string&
input) {
133 MPModelRequest request_proto;
134 MPModelProto model_proto;
135 if (absl::EndsWith(
input,
".lp")) {
140 model_proto = std::move(result).value();
141 }
else if (absl::EndsWith(
input,
".mps") ||
142 absl::EndsWith(
input,
".mps.gz")) {
143 QCHECK_OK(glop::MPSReader().ParseFile(
input, &model_proto))
144 <<
"Error while parsing the mps file '" <<
input <<
"'.";
152 const bool is_model_proto = model_proto.variable_size() > 0;
153 const bool is_request_proto =
154 request_proto.model().variable_size() > 0 ||
155 !request_proto.model_delta().baseline_model_file_path().empty();
156 if (!is_model_proto && !is_request_proto) {
157 LOG(FATAL) <<
"Failed to parse '" <<
input
158 <<
"' as an MPModelProto or an MPModelRequest.";
160 CHECK(!(is_model_proto && is_request_proto));
162 if (is_request_proto) {
163 LOG(INFO) <<
"Read input proto as an MPModelRequest.";
165 LOG(INFO) <<
"Read input proto as an MPModelProto.";
166 model_proto.Swap(request_proto.mutable_model());
168 return request_proto;
171MPSolutionResponse LocalSolve(
const MPModelRequest& request_proto) {
175 MPSolver solver(request_proto.model().name(),
177 request_proto.solver_type()));
178 const absl::Status set_num_threads_status =
179 solver.SetNumThreads(absl::GetFlag(FLAGS_num_threads));
180 if (set_num_threads_status.ok()) {
181 LOG(INFO) <<
"Set number of threads to " << absl::GetFlag(FLAGS_num_threads)
183 }
else if (absl::GetFlag(FLAGS_num_threads) != 1) {
184 LOG(ERROR) <<
"Failed to set number of threads due to: "
185 << set_num_threads_status.message() <<
". Using 1 as default.";
187 solver.EnableOutput();
189 if (request_proto.has_solver_specific_parameters()) {
190 CHECK(solver.SetSolverSpecificParametersAsString(
191 request_proto.solver_specific_parameters()))
192 <<
"Wrong solver_specific_parameters (bad --params or --params_file ?)";
195 MPSolutionResponse response;
199 std::string error_message;
200 const MPSolverResponseStatus status =
201 solver.LoadModelFromProtoWithUniqueNamesOrDie(request_proto.model(),
204 if (status != MPSOLVER_MODEL_IS_VALID) {
207 if (request_proto.solver_type() ==
208 MPModelRequest::SAT_INTEGER_PROGRAMMING) {
209 sat::CpSolverResponse sat_response;
210 sat_response.set_status(sat::CpSolverStatus::MODEL_INVALID);
214 response.set_status(status);
215 response.set_status_str(error_message);
219 if (request_proto.has_solver_time_limit_seconds()) {
221 absl::Seconds(request_proto.solver_time_limit_seconds()));
228 SigintHandler handler;
229 handler.Register([&solver] { solver.InterruptSolve(); });
237 !absl::GetFlag(FLAGS_verify_solution)) {
238 const bool verified =
239 solver.VerifySolution(MPSolverParameters().GetDoubleParam(
241 absl::GetFlag(FLAGS_log_verification_errors));
242 LOG(INFO) <<
"The solution "
243 << (verified ?
"was verified." :
"didn't pass verification.");
250 absl::PrintF(
"%-12s: %d\n",
"Nodes", solver.nodes());
254 solver.FillSolutionResponseProto(&response);
259 QCHECK(!absl::GetFlag(FLAGS_input).empty()) <<
"--input is required";
260 QCHECK_GE(absl::GetFlag(FLAGS_time_limit), absl::ZeroDuration())
261 <<
"--time_limit must be given a positive duration";
264 std::optional<MPSolver::OptimizationProblemType> type;
265 if (
const std::optional<std::string> type_flag = absl::GetFlag(FLAGS_solver);
266 type_flag.has_value()) {
269 <<
"Unsupported --solver: " << type_flag.value();
273 MPModelRequest request_proto = ReadMipModel(absl::GetFlag(FLAGS_input));
275 if (!absl::GetFlag(FLAGS_sol_hint).empty()) {
276 const auto read_sol =
277 ParseSolFile(absl::GetFlag(FLAGS_sol_hint), request_proto.model());
278 CHECK_OK(read_sol.status());
279 const MPSolutionResponse& sol = read_sol.value();
280 if (request_proto.model().has_solution_hint()) {
281 LOG(WARNING) <<
"Overwriting solution hint found in the request with "
282 <<
"solution from " << absl::GetFlag(FLAGS_sol_hint);
284 request_proto.mutable_model()->clear_solution_hint();
285 for (
int i = 0; i < sol.variable_value_size(); ++i) {
286 request_proto.mutable_model()->mutable_solution_hint()->add_var_index(i);
287 request_proto.mutable_model()->mutable_solution_hint()->add_var_value(
288 sol.variable_value(i));
292 printf(
"%-12s: '%s'\n",
"File", absl::GetFlag(FLAGS_input).c_str());
296 if (absl::GetFlag(FLAGS_dump_format) ==
"text") {
298 }
else if (absl::GetFlag(FLAGS_dump_format) ==
"binary") {
300 }
else if (absl::GetFlag(FLAGS_dump_format) ==
"json") {
303 LOG(FATAL) <<
"Unsupported --dump_format: "
304 << absl::GetFlag(FLAGS_dump_format);
307 if (!absl::GetFlag(FLAGS_dump_mps).empty()) {
309 request_proto.model()));
313 if (type.has_value() || !request_proto.has_solver_type()) {
314 request_proto.set_solver_type(
static_cast<MPModelRequest::SolverType
>(
317 if (absl::GetFlag(FLAGS_time_limit) != absl::InfiniteDuration()) {
318 LOG(INFO) <<
"Setting a time limit of " << absl::GetFlag(FLAGS_time_limit);
319 request_proto.set_solver_time_limit_seconds(
320 absl::ToDoubleSeconds(absl::GetFlag(FLAGS_time_limit)));
322 if (absl::GetFlag(FLAGS_linear_solver_enable_verbose_output)) {
323 request_proto.set_enable_internal_solver_output(
true);
325 if (!absl::GetFlag(FLAGS_params_file).empty()) {
326 CHECK(absl::GetFlag(FLAGS_params).empty())
327 <<
"--params and --params_file are incompatible";
328 std::string file_contents;
331 <<
"Could not read parameters file.";
332 request_proto.set_solver_specific_parameters(file_contents);
334 if (!absl::GetFlag(FLAGS_params).empty()) {
335 request_proto.set_solver_specific_parameters(absl::GetFlag(FLAGS_params));
339 if (!absl::GetFlag(FLAGS_dump_model).empty()) {
341 request_proto.model(), write_format,
342 absl::GetFlag(FLAGS_dump_gzip)));
344 if (!absl::GetFlag(FLAGS_dump_request).empty()) {
346 write_format, absl::GetFlag(FLAGS_dump_gzip)));
350 "%-12s: %s\n",
"Solver",
351 MPModelRequest::SolverType_Name(request_proto.solver_type()).c_str());
352 absl::PrintF(
"%-12s: %s\n",
"Parameters", absl::GetFlag(FLAGS_params));
353 absl::PrintF(
"%-12s: %d x %d\n",
"Dimension",
354 request_proto.model().constraint_size(),
355 request_proto.model().variable_size());
357 const absl::Time solve_start_time = absl::Now();
359 const MPSolutionResponse response = LocalSolve(request_proto);
361 const absl::Duration solving_time = absl::Now() - solve_start_time;
362 const bool has_solution = response.status() == MPSOLVER_OPTIMAL ||
363 response.status() == MPSOLVER_FEASIBLE;
364 absl::PrintF(
"%-12s: %s\n",
"Status",
365 MPSolverResponseStatus_Name(
366 static_cast<MPSolverResponseStatus
>(response.status()))
368 absl::PrintF(
"%-12s: %15.15e\n",
"Objective",
369 has_solution ? response.objective_value() : 0.0);
370 absl::PrintF(
"%-12s: %15.15e\n",
"BestBound",
371 has_solution ? response.best_objective_bound() : 0.0);
372 absl::PrintF(
"%-12s: %s\n",
"StatusString", response.status_str());
373 absl::PrintF(
"%-12s: %-6.4g s\n",
"Time",
374 absl::ToDoubleSeconds(solving_time));
378 if (!absl::GetFlag(FLAGS_sol_file).empty() && has_solution) {
379 std::string sol_string;
380 absl::StrAppend(&sol_string,
"=obj= ", response.objective_value(),
"\n");
381 for (
int i = 0; i < response.variable_value().size(); ++i) {
382 absl::StrAppend(&sol_string, request_proto.model().variable(i).name(),
383 " ", response.variable_value(i),
"\n");
385 LOG(INFO) <<
"Writing .sol solution to '" << absl::GetFlag(FLAGS_sol_file)
390 if (!absl::GetFlag(FLAGS_dump_response).empty() && has_solution) {
392 write_format, absl::GetFlag(FLAGS_dump_gzip)));
394 if (!absl::GetFlag(FLAGS_output_csv).empty() && has_solution) {
395 std::string csv_file;
396 for (
int i = 0; i < response.variable_value_size(); ++i) {
398 absl::StrFormat(
"%s,%e\n", request_proto.model().variable(i).name(),
399 response.variable_value(i));
409int main(
int argc,
char** argv) {
@ FEASIBLE
feasible, or stopped by limit.
@ GLOP_LINEAR_PROGRAMMING
static bool ParseSolverType(absl::string_view solver_id, OptimizationProblemType *type)
static
void InitGoogle(absl::string_view usage, int *argc, char ***argv, bool deprecated)
ABSL_FLAG(std::string, sol_hint, "", "Input file name with solution in .sol format.")
int main(int argc, char **argv)
static const char kUsageStr[]
absl::StatusOr< std::string > GetContents(absl::string_view path, Options options)
-— Content API -—
absl::Status SetContents(absl::string_view file_name, absl::string_view contents, Options options)
std::string CpSolverResponseStats(const CpSolverResponse &response, bool has_objective)
In SWIG mode, we don't want anything besides these top-level includes.
absl::Status WriteModelToMpsFile(absl::string_view filename, const MPModelProto &model, const MPModelExportOptions &options)
absl::StatusOr< glop::DenseRow > ParseSolFile(absl::string_view file_name, const glop::LinearProgram &model)
Parse a solution to model from a file.
bool SolverTypeIsMip(MPModelRequest::SolverType solver_type)
There is a homonymous version taking a MPSolver::OptimizationProblemType.
absl::Status WriteProtoToFile(absl::string_view filename, const google::protobuf::Message &proto, ProtoWriteFormat proto_write_format, bool gzipped, bool append_extension_to_file_name)
absl::Status ReadFileToProto(absl::string_view filename, google::protobuf::Message *proto, bool allow_partial)
absl::StatusOr< MPModelProto > ModelProtoFromLpFormat(absl::string_view model)
This calls ParseLp() under the hood. See below.
static int input(yyscan_t yyscanner)