Google OR-Tools v9.14
a fast and portable software suite for combinatorial optimization
Loading...
Searching...
No Matches
fz.cc
Go to the documentation of this file.
1// Copyright 2010-2025 Google LLC
2// Licensed under the Apache License, Version 2.0 (the "License");
3// you may not use this file except in compliance with the License.
4// You may obtain a copy of the License at
5//
6// http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13
14// This is the skeleton for the official flatzinc interpreter. Much
15// of the functionalities are fixed (name of parameters, format of the
16// input): see http://www.minizinc.org/downloads/doc-1.6/flatzinc-spec.pdf
17
18#include <cstdlib>
19#include <cstring>
20#if defined(__GNUC__) // Linux or Mac OS X.
21#include <signal.h>
22#endif // __GNUC__
23
24#include <iostream>
25#include <ostream>
26#include <string>
27#include <vector>
28
29#include "absl/flags/flag.h"
30#include "absl/flags/parse.h"
31#include "absl/flags/usage.h"
32#include "absl/log/check.h"
33#include "absl/log/flags.h"
34#include "absl/log/initialize.h"
35#include "absl/log/log.h"
36#include "absl/strings/match.h"
37#include "absl/strings/str_split.h"
38#include "absl/strings/string_view.h"
39#include "absl/time/time.h"
41#include "ortools/base/path.h"
42#include "ortools/base/timer.h"
47
48constexpr bool kOrToolsMode = true;
49
50ABSL_FLAG(double, time_limit, 0, "time limit in seconds.");
51ABSL_FLAG(bool, search_all_solutions, false, "Search for all solutions.");
52ABSL_FLAG(bool, display_all_solutions, false,
53 "Display all improving solutions.");
54ABSL_FLAG(bool, free_search, !kOrToolsMode,
55 "If false, the solver must follow the defined search."
56 "If true, other search are allowed.");
57ABSL_FLAG(int, threads, 0, "Number of threads the solver will use.");
58ABSL_FLAG(bool, statistics, false, "Print solver statistics after search.");
59ABSL_FLAG(bool, read_from_stdin, false,
60 "Read the FlatZinc from stdin, not from a file.");
61ABSL_FLAG(int, fz_seed, 0, "Random seed");
62ABSL_FLAG(std::string, fz_model_name, "stdin",
63 "Define problem name when reading from stdin.");
64ABSL_FLAG(std::string, params, "", "SatParameters as a text proto.");
65ABSL_FLAG(bool, fz_logging, false,
66 "Print logging information from the flatzinc interpreter.");
67ABSL_FLAG(bool, ortools_mode, kOrToolsMode,
68 "Display solutions in the flatzinc format");
69
70namespace operations_research {
71namespace fz {
72
73std::vector<char*> FixAndParseParameters(int* argc, char*** argv) {
74 char all_param[] = "--search_all_solutions";
75 char print_solutions[] = "--display_all_solutions";
76 char free_param[] = "--free_search";
77 char threads_param[] = "--threads";
78 char logging_param[] = "--fz_logging";
79 char statistics_param[] = "--statistics";
80 char seed_param[] = "--fz_seed";
81 char time_param[] = "--time_limit";
82 bool use_time_param = false;
83 bool set_free_search = false;
84 for (int i = 1; i < *argc; ++i) {
85 if (strcmp((*argv)[i], "-a") == 0) {
86 (*argv)[i] = all_param;
87 }
88 if (strcmp((*argv)[i], "-i") == 0) {
89 (*argv)[i] = print_solutions;
90 }
91 if (strcmp((*argv)[i], "-f") == 0) {
92 (*argv)[i] = free_param;
93 set_free_search = true;
94 }
95 if (strcmp((*argv)[i], "-p") == 0) {
96 (*argv)[i] = threads_param;
97 }
98 if (strcmp((*argv)[i], "-l") == 0) {
99 (*argv)[i] = logging_param;
100 }
101 if (strcmp((*argv)[i], "-s") == 0) {
102 (*argv)[i] = statistics_param;
103 }
104 if (strcmp((*argv)[i], "-r") == 0) {
105 (*argv)[i] = seed_param;
106 }
107 if (strcmp((*argv)[i], "-t") == 0) {
108 (*argv)[i] = time_param;
109 use_time_param = true;
110 }
111 if (kOrToolsMode) {
112 if (strcmp((*argv)[i], "-v") == 0) {
113 (*argv)[i] = logging_param;
114 }
115 }
116 }
117 const char kUsage[] =
118 "Usage: see flags.\nThis program parses and solve a flatzinc problem.";
119
120 absl::SetProgramUsageMessage(kUsage);
121 const std::vector<char*> residual_flags =
122 absl::ParseCommandLine(*argc, *argv);
123 absl::InitializeLog();
124
125 // Fix time limit if -t was used.
126 if (use_time_param) {
127 absl::SetFlag(&FLAGS_time_limit, absl::GetFlag(FLAGS_time_limit) / 1000.0);
128 }
129
130 // Define the default number of workers to 1 if -f was used.
131 if (set_free_search && absl::GetFlag(FLAGS_threads) == 0) {
132 absl::SetFlag(&FLAGS_threads, 1);
133 }
134
135 return residual_flags;
136}
137
138Model ParseFlatzincModel(const std::string& input, bool input_is_filename,
139 SolverLogger* logger, absl::Duration* parse_duration) {
140 WallTimer timer;
141 timer.Start();
142
143 // Check the extension.
144 if (input_is_filename && !absl::EndsWith(input, ".fzn")) {
145 LOG(FATAL) << "Unrecognized flatzinc file: `" << input << "'";
146 }
147
148 // Read model.
149 const std::string problem_name = input_is_filename
150 ? std::string(file::Stem(input))
151 : absl::GetFlag(FLAGS_fz_model_name);
152 Model model(problem_name);
153 if (input_is_filename) {
154 CHECK(ParseFlatzincFile(input, &model));
155 } else {
156 CHECK(ParseFlatzincString(input, &model));
157 }
158
159 *parse_duration = timer.GetDuration();
160 SOLVER_LOG(logger, "File ", (input_is_filename ? input : "stdin"),
161 " parsed in ", absl::ToInt64Milliseconds(*parse_duration), " ms");
162 SOLVER_LOG(logger, "");
163
164 // Print statistics.
165 ModelStatistics stats(model, logger);
166 stats.BuildStatistics();
167 stats.PrintStatistics();
168 return model;
169}
170
171void LogInFlatzincFormat(const std::string& multi_line_input) {
172 if (multi_line_input.empty()) {
173 std::cout << std::endl;
174 return;
175 }
176 const absl::string_view flatzinc_prefix =
177 absl::GetFlag(FLAGS_ortools_mode) ? "%% " : "";
178 const std::vector<absl::string_view> lines =
179 absl::StrSplit(multi_line_input, '\n');
180 for (const absl::string_view& line : lines) {
181 std::cout << flatzinc_prefix << line << std::endl;
182 }
183}
184
185} // namespace fz
186} // namespace operations_research
187
188int main(int argc, char** argv) {
189 // Flatzinc specifications require single dash parameters (-a, -f, -p).
190 // We need to fix parameters before parsing them.
191 const std::vector<char*> residual_flags =
193 // We allow piping model through stdin.
194 std::string input;
195 if (absl::GetFlag(FLAGS_read_from_stdin)) {
196 std::string currentLine;
197 while (std::getline(std::cin, currentLine)) {
198 input.append(currentLine);
199 input.append("\n");
200 }
201 } else {
202 if (residual_flags.empty()) {
203 LOG(ERROR) << "Usage: " << argv[0] << " <file>";
204 return EXIT_FAILURE;
205 }
206 input = residual_flags.back();
207 }
208
210 if (absl::GetFlag(FLAGS_ortools_mode)) {
211 logger.EnableLogging(absl::GetFlag(FLAGS_fz_logging));
212 // log_to_stdout is disabled later.
214 } else {
215 logger.EnableLogging(true);
216 logger.SetLogToStdOut(true);
217 }
218
219 absl::Duration parse_duration;
222 input, !absl::GetFlag(FLAGS_read_from_stdin), &logger,
223 &parse_duration);
225
227 parameters.display_all_solutions = absl::GetFlag(FLAGS_display_all_solutions);
228 parameters.search_all_solutions = absl::GetFlag(FLAGS_search_all_solutions);
229 parameters.use_free_search = absl::GetFlag(FLAGS_free_search);
230 parameters.log_search_progress =
231 absl::GetFlag(FLAGS_fz_logging) || !absl::GetFlag(FLAGS_ortools_mode);
232 parameters.random_seed = absl::GetFlag(FLAGS_fz_seed);
233 parameters.display_statistics = absl::GetFlag(FLAGS_statistics);
234 parameters.number_of_threads = absl::GetFlag(FLAGS_threads);
235 parameters.max_time_in_seconds =
236 absl::GetFlag(FLAGS_time_limit) - absl::ToInt64Seconds(parse_duration);
237 parameters.ortools_mode = absl::GetFlag(FLAGS_ortools_mode);
238
239 operations_research::SolverLogger solution_logger;
240 solution_logger.SetLogToStdOut(true);
241 solution_logger.EnableLogging(parameters.ortools_mode);
242
243 if (absl::GetFlag(FLAGS_time_limit) > 0 &&
244 parse_duration > absl::Seconds(absl::GetFlag(FLAGS_time_limit))) {
245 if (parameters.ortools_mode) {
246 SOLVER_LOG(&solution_logger, "%% TIMEOUT");
247 }
248 if (parameters.log_search_progress) {
249 SOLVER_LOG(&logger, "CpSolverResponse summary:");
250 SOLVER_LOG(&logger, "status: UNKNOWN");
251 }
252 return EXIT_SUCCESS;
253 }
254
256 absl::GetFlag(FLAGS_params),
257 &logger, &solution_logger);
258 return EXIT_SUCCESS;
259}
absl::Duration GetDuration() const
Definition timer.h:47
void Start()
When Start() is called multiple times, only the most recent is used.
Definition timer.h:30
void EnableLogging(bool enable)
Definition logging.h:47
void SetLogToStdOut(bool enable)
Should all messages be displayed on stdout ?
Definition logging.h:53
void AddInfoLoggingCallback(std::function< void(const std::string &message)> callback)
Definition logging.cc:29
void PrintStatistics() const
--— Model statistics --—
Definition model.cc:1134
ABSL_FLAG(double, time_limit, 0, "time limit in seconds.")
int main(int argc, char **argv)
Definition fz.cc:188
constexpr bool kOrToolsMode
Definition fz.cc:48
time_limit
Definition solve.cc:22
absl::string_view Stem(absl::string_view path)
Definition path.cc:129
void LogInFlatzincFormat(const std::string &multi_line_input)
Definition fz.cc:171
Model ParseFlatzincModel(const std::string &input, bool input_is_filename, SolverLogger *logger, absl::Duration *parse_duration)
Definition fz.cc:138
bool ParseFlatzincString(const std::string &input, Model *model)
Definition parser.cc:67
bool ParseFlatzincFile(const std::string &filename, Model *model)
--— public parsing API --—
Definition parser.cc:42
std::vector< char * > FixAndParseParameters(int *argc, char ***argv)
Definition fz.cc:73
void SolveFzWithCpModelProto(const fz::Model &fz_model, const fz::FlatzincSatParameters &p, const std::string &sat_params, SolverLogger *logger, SolverLogger *solution_logger)
Solves the given flatzinc model using the CP-SAT solver.
void ProcessFloatingPointOVariablesAndObjective(fz::Model *fz_model)
In SWIG mode, we don't want anything besides these top-level includes.
static int input(yyscan_t yyscanner)
static const char kUsage[]
#define SOLVER_LOG(logger,...)
Definition logging.h:110