blob: ebc95459aa7f627d5b4865f077592c364795a9e5 [file] [edit]
#include "internal.hpp"
#include <cstring>
namespace CaDiCaL {
#ifndef QUIET
/*------------------------------------------------------------------------*/
// Provide nicely formatted progress report messages while running through
// the 'report' function below. The code is so complex, because it should
// be easy to add and remove reporting of certain statistics, while still
// providing a nicely looking format with automatically aligned headers.
/*------------------------------------------------------------------------*\
The 'reports' are shown as 'c <char> ...' with '<char>' as follows:
i propagated learned unit clause
O backtracked after phases reset to original phase
F backtracked after flipping phases
# backtracked after randomly setting phases
B backtracked after resetting to best phases
W backtracked after local search improved phases
b blocked clause elimination
G before garbage collection
C after garbage collection
K covered clause elimination ('Kovered Klause')
c clausal congruence closure
d decomposed binary implication graph and substituted equivalent literals
2 removed duplicated binary clauses
e bounded variable elimination round
^ variable elimination bound increased
I variable instantiation
[ start of stable search phase
] end of stable search phase
{ start of unstable search phase
} end of unstable search phase
P preprocessing round (capital 'P')
L local search round
* start of solving without the need to restore clauses
+ start of solving before restoring clauses
r start of solving after restoring clauses
1 end of solving returns satisfiable
0 end of solving returns unsatisfiable
? end of solving due to interrupt
k binary backbone extraction ('kernel')
l lucky phase solving
p failed literal probing round (lower case 'p')
. before reducing redundant clauses
f flushed redundant clauses
- reduced redundant clauses
~ start of resetting phases
R restart
s subsumed clause removal round
3 ternary resolution round
t transition reduction of binary implication graph
u vivified tier1 clauses
v vivified tier2 clauses
w vivified tier3 clauses
x vivified irredundant clauses
= sweeping to find equivalences using Citten
f factor (BVA)
The order of the list follows the occurrences of 'report' in the source
files, i.e., obtained from "grep 'report (' *.cpp". Note that some of the
reports are only printed for higher verbosity level (for instance 'R').
\*------------------------------------------------------------------------*/
struct Report {
const char *header;
char buffer[32];
int pos;
Report (const char *h, int precision, int min, double value);
Report () {}
void print_header (char *line);
};
/*------------------------------------------------------------------------*/
void Report::print_header (char *line) {
int len = strlen (header);
for (int i = -1, j = pos - (len + 1) / 2 - 3; i < len; i++, j++)
line[j] = i < 0 ? ' ' : header[i];
}
Report::Report (const char *h, int precision, int min, double value)
: header (h) {
char fmt[32];
if (precision < 0)
snprintf (fmt, sizeof fmt, "%%.%df", -precision - 1);
else
snprintf (fmt, sizeof fmt, "%%.%df", precision);
snprintf (buffer, sizeof buffer, fmt, value);
const int width = strlen (buffer);
assert (width < 32);
if (precision < 0)
strcat (buffer, "%");
if (width >= min)
return;
if (precision < 0)
snprintf (fmt, sizeof fmt, "%%%d.%df%%%%", min, -precision - 1);
else
snprintf (fmt, sizeof fmt, "%%%d.%df", min, precision);
snprintf (buffer, sizeof buffer, fmt, value);
}
/*------------------------------------------------------------------------*/
// The following statistics are printed in columns, whenever 'report' is
// called. For instance 'reduce' with prefix '-' will call it. The other
// more interesting report is due to learning a unit, called iteration, with
// prefix 'i'. To add another statistics column, add a corresponding line
// here. If you want to report something else add 'report (..)' functions.
#define TIME \
(opts.reportsystem ? (opts.reportsolve ? solve_time () : time ()) : 0)
#define MB \
(opts.reportsystem \
? (current_resident_set_size () / (double) (1l << 20)) \
: 0)
#define REMAINING (percent (active (), stats.variables_original))
#define TRAIL (percent (averages.current.trail.slow, max_var))
#define TARGET (percent (target_assigned, max_var))
#define BEST (percent (best_assigned, max_var))
#define REPORTS \
/* HEADER, PRECISION, MIN, VALUE */ \
REPORT ("seconds", 2, 5, TIME) \
REPORT ("MB", 0, 2, MB) \
REPORT ("level", 0, 2, averages.current.level) \
REPORT ("reductions", 0, 1, stats.reductions) \
REPORT ("restarts", 0, 3, stats.restart) \
REPORT ("rate", 0, 2, averages.current.decisions) \
REPORT ("conflicts", 0, 4, stats.conflicts) \
REPORT ("redundant", 0, 4, stats.clauses_now_red) \
REPORT ("size/glue", 1, 2, \
relative (averages.current.size, averages.current.glue.slow)) \
REPORT ("size", 0, 1, averages.current.size) \
REPORT ("glue", 0, 1, averages.current.glue.slow) \
REPORT ("tier1", 0, 1, tier1[stable]) \
REPORT ("tier2", 0, 1, tier2[stable]) \
REPORT ("trail", -1, 2, TRAIL) \
REPORT ("irredundant", 0, 4, stats.clauses_now_irr) \
REPORT ("variables", 0, 3, active ()) \
REPORT ("remaining", -1, 2, REMAINING)
// Note, keep an empty line before this line (because of '\')!
#if 0 // ADDITIONAL STATISTICS TO REPORT
REPORT("best", -1, 2, BEST) \
REPORT("target", -1, 2, TARGET) \
REPORT("maxvar", 0, 2, external->max_var)
#endif
static const int num_reports = // as compile time constant
#define REPORT(HEAD, PREC, MIN, EXPR) 1 +
REPORTS
#undef REPORT
0;
/*------------------------------------------------------------------------*/
// Here is the idea behind the colors:
//
// - red: rephasing
//
// - green: problem transformation (or scheduled with it like subsume). In
// bold: change of the number of variables.
//
// - blue: other inprocessing. Bold blue: finding equivalences
//
// - cyan: binary clauses reducing (deduplication, transitive reduction)
//
void Internal::report (char type, int verbose) {
if (!opts.report)
return;
#ifdef LOGGING
if (!opts.log)
#endif
if (opts.quiet || (verbose > opts.verbose))
return;
if (!reported) {
assert (!lim.report);
reported = true;
MSG ("%stime measured in %s time %s%s", tout.magenta_code (),
internal->opts.realtime ? "real" : "process",
internal->opts.reportsolve ? "in solving" : "since initialization",
tout.normal_code ());
}
Report reports[num_reports];
int n = 0;
#define REPORT(HEAD, PREC, MIN, EXPR) \
assert (n < num_reports); \
reports[n++] = Report (HEAD, PREC, MIN, (double) (EXPR));
REPORTS
#undef REPORT
if (!lim.report) {
print_prefix ();
fputc ('\n', stdout);
int pos = 4;
for (int i = 0; i < n; i++) {
assert (strlen (reports[i].buffer) <= 32);
int len = strlen (reports[i].buffer);
reports[i].pos = pos + (len + 1) / 2;
pos += len + 1;
}
const int max_line = pos + 20, nrows = 3;
char *line = new char[max_line];
for (int start = 0; start < nrows; start++) {
int i;
for (i = 0; i < max_line; i++)
line[i] = ' ';
for (i = start; i < n; i += nrows)
reports[i].print_header (line);
for (i = max_line - 1; line[i - 1] == ' '; i--)
;
line[i] = 0;
print_prefix ();
tout.yellow ();
fputs (line, stdout);
tout.normal ();
fputc ('\n', stdout);
}
print_prefix ();
fputc ('\n', stdout);
delete[] line;
lim.report = opts.reportheader;
} else
lim.report--;
print_prefix ();
switch (type) {
case '[':
case ']':
tout.magenta (true);
break;
case 's':
case 'b':
case 'k':
case 'K':
tout.green (false);
break;
case 'f':
case 'e':
tout.green (true);
break;
case 'p':
case '2':
case '3':
case 'u':
case 'v':
case 'w':
case 'x':
tout.blue (false);
break;
case 'd':
case 't':
tout.cyan (false);
break;
case '=':
case 'c':
tout.blue (true);
break;
case 'z':
case '!':
tout.cyan (true);
break;
case '-':
tout.normal ();
break;
case '0':
case '1':
case '?':
case 'i':
tout.bold ();
break;
case 'L':
case 'P':
tout.bold ();
tout.underline ();
break;
case '(':
case ')':
break;
case '{':
case '}':
tout.normal ();
break;
case 'B':
case 'W':
case 'O':
case '#':
case 'I':
case 'F':
tout.red ();
break;
default:
break;
}
fputc (type, stdout);
if (stable || type == ']')
tout.magenta ();
else if (preprocessing || type == ')')
tout.bold (), tout.yellow ();
else if (type != 'L' && type != 'P')
tout.normal ();
for (int i = 0; i < n; i++) {
fputc (' ', stdout);
fputs (reports[i].buffer, stdout);
}
if (stable || type == 'L' || type == 'P' || type == ']' || type == ')' ||
preprocessing)
tout.normal ();
fputc ('\n', stdout);
fflush (stdout);
}
#else // ifndef QUIET
void Internal::report (char, int) {}
#endif
} // namespace CaDiCaL