57 active_constraint_(nullptr),

58 active_demon_(nullptr),

59 start_time_ns_(absl::GetCurrentTimeNanos()) {}

63 constraint_map_.end());

64 }

69 return (absl::GetCurrentTimeNanos() - start_time_ns_) / 1000;

70 }

73 Constraint* const constraint) override {

75 return;

76 }

77

78 CHECK(active_constraint_ == nullptr);

79 CHECK(active_demon_ == nullptr);

80 CHECK(constraint != nullptr);

84 active_constraint_ = constraint;

85 constraint_map_[constraint] = ct_run;

86 }

89 CHECK(active_constraint_ != nullptr);

90 CHECK(active_demon_ == nullptr);

91 CHECK(constraint != nullptr);

92 CHECK_EQ(constraint, active_constraint_);

93 ConstraintRuns* const ct_run = constraint_map_[constraint];

94 if (ct_run != nullptr) {

97 }

98 active_constraint_ = nullptr;

99 }

104 return;

105 }

106

107 CHECK(active_constraint_ == nullptr);

108 CHECK(active_demon_ == nullptr);

109 CHECK(constraint != nullptr);

110 CHECK(delayed != nullptr);

111 ConstraintRuns* const ct_run = constraint_map_[constraint];

113 active_constraint_ = constraint;

114 }

118 CHECK(active_constraint_ != nullptr);

119 CHECK(active_demon_ == nullptr);

120 CHECK(constraint != nullptr);

121 CHECK(delayed != nullptr);

122 CHECK_EQ(constraint, active_constraint_);

123 ConstraintRuns* const ct_run = constraint_map_[constraint];

124 if (ct_run != nullptr) {

127 }

128 active_constraint_ = nullptr;

129 }

133 return;

134 }

135

136 if (demon_map_.find(demon) == demon_map_.end()) {

137 CHECK(active_constraint_ != nullptr);

138 CHECK(active_demon_ == nullptr);

139 CHECK(demon != nullptr);

140 ConstraintRuns* const ct_run = constraint_map_[active_constraint_];

144 demon_map_[demon] = demon_run;

145 demons_per_constraint_[active_constraint_].push_back(demon_run);

146 }

147 }

150 CHECK(demon != nullptr);

152 return;

153 }

154 CHECK(active_demon_ == nullptr);

155 active_demon_ = demon;

156 DemonRuns* const demon_run = demon_map_[active_demon_];

157 if (demon_run != nullptr) {

159 }

160 }

163 CHECK(demon != nullptr);

165 return;

166 }

167 CHECK_EQ(active_demon_, demon);

168 DemonRuns* const demon_run = demon_map_[active_demon_];

169 if (demon_run != nullptr) {

171 }

172 active_demon_ = nullptr;

173 }

181 if (active_demon_ != nullptr) {

182 DemonRuns* const demon_run = demon_map_[active_demon_];

183 if (demon_run != nullptr) {

186 }

187 active_demon_ = nullptr;

188

189 active_constraint_ = nullptr;

190 } else if (active_constraint_ != nullptr) {

191 ConstraintRuns* const ct_run = constraint_map_[active_constraint_];

192 if (ct_run != nullptr) {

195 }

196 active_constraint_ = nullptr;

197 }

198 }

203 constraint_map_.end());

204 constraint_map_.clear();

205 demon_map_.clear();

206 demons_per_constraint_.clear();

207 }

213 int64_t new_max) override {}

222 const std::vector<int64_t>& values) override {}

224 const std::vector<int64_t>& values) override {}

229 int64_t new_max) override {}

233 int64_t new_max) override {}

237 int64_t new_max) override {}

244 const std::vector<int>& rank_last,

245 const std::vector<int>& unperformed) override {}

248 void AddFakeRun(Demon* const demon, int64_t start_time, int64_t end_time,

249 bool is_fail) {

250 CHECK(demon != nullptr);

251 DemonRuns* const demon_run = demon_map_[demon];

252 CHECK(demon_run != nullptr);

255 if (is_fail) {

257 }

258 }

262 const char* const kConstraintFormat =

263 " - Constraint: %s\n failures=%d, initial propagation "

264 "runtime=%d us, demons=%d, demon invocations=%d, total demon "

265 "runtime=%d us\n";

266 const char* const kDemonFormat =

267 " --- Demon: %s\n invocations=%d, failures=%d, total "

268 "runtime=%d us, [average=%.2lf, median=%.2lf, stddev=%.2lf]\n";

270 const std::string model =

271 absl::StrFormat("Model %s:\n", solver->model_name());

274 std::vector<Container> to_sort;

275 for (absl::flat_hash_map<const Constraint*,

277 constraint_map_.begin();

278 it != constraint_map_.end(); ++it) {

279 const Constraint* const ct = it->first;

280 int64_t fails = 0;

281 int64_t demon_invocations = 0;

282 int64_t initial_propagation_runtime = 0;

283 int64_t total_demon_runtime = 0;

284 int demon_count = 0;

286 &demon_invocations, &total_demon_runtime,

287 &demon_count);

288 to_sort.push_back(

289 Container(ct, total_demon_runtime + initial_propagation_runtime));

290 }

291 std::sort(to_sort.begin(), to_sort.end());

292

293 for (int i = 0; i < to_sort.size(); ++i) {

294 const Constraint* const ct = to_sort[i].ct;

295 int64_t fails = 0;

296 int64_t demon_invocations = 0;

297 int64_t initial_propagation_runtime = 0;

298 int64_t total_demon_runtime = 0;

299 int demon_count = 0;

301 &demon_invocations, &total_demon_runtime,

302 &demon_count);

303 const std::string constraint_message =

304 absl::StrFormat(kConstraintFormat, ct->DebugString(), fails,

305 initial_propagation_runtime, demon_count,

306 demon_invocations, total_demon_runtime);

308 .IgnoreError();

309 const std::vector<DemonRuns*>& demons = demons_per_constraint_[ct];

310 const int demon_size = demons.size();

311 for (int demon_index = 0; demon_index < demon_size; ++demon_index) {

312 DemonRuns* const demon_runs = demons[demon_index];

313 int64_t invocations = 0;

314 int64_t fails = 0;

315 int64_t runtime = 0;

316 double mean_runtime = 0;

317 double median_runtime = 0;

318 double standard_deviation = 0.0;

320 &mean_runtime, &median_runtime,

321 &standard_deviation);

322 const std::string runs = absl::StrFormat(

323 kDemonFormat, demon_runs->demon_id(), invocations, fails, runtime,

324 mean_runtime, median_runtime, standard_deviation);

326 }

327 }

328 }

330 }

334 int64_t* const fails,

335 int64_t* const initial_propagation_runtime,

336 int64_t* const demon_invocations,

337 int64_t* const total_demon_runtime, int* demons) {

338 CHECK(constraint != nullptr);

339 ConstraintRuns* const ct_run = constraint_map_[constraint];

340 CHECK(ct_run != nullptr);

341 *demon_invocations = 0;

343 *initial_propagation_runtime = 0;

347 }

348 *total_demon_runtime = 0;

349

350

352 CHECK_EQ(*demons, demons_per_constraint_[constraint].size());

353 for (int demon_index = 0; demon_index < *demons; ++demon_index) {

354 const DemonRuns& demon_runs = ct_run->demons(demon_index);

355 *fails += demon_runs.failures();

358 *demon_invocations += runs;

359 for (int run_index = 0; run_index < runs; ++run_index) {

360 const int64_t demon_time =

362 *total_demon_runtime += demon_time;

363 }

364 }

365 }

368 int64_t* const demon_invocations, int64_t* const fails,

369 int64_t* const total_demon_runtime,

370 double* const mean_demon_runtime,

371 double* const median_demon_runtime,

372 double* const stddev_demon_runtime) {

373 CHECK(demon_runs != nullptr);

375

377 *demon_invocations = runs;

378 *fails = demon_runs->failures();

379 *total_demon_runtime = 0;

380 *mean_demon_runtime = 0.0;

381 *median_demon_runtime = 0.0;

382 *stddev_demon_runtime = 0.0;

383 std::vector<double> runtimes;

384 for (int run_index = 0; run_index < runs; ++run_index) {

385 const int64_t demon_time =

387 *total_demon_runtime += demon_time;

388 runtimes.push_back(demon_time);

389 }

390

391 if (!runtimes.empty()) {

392 *mean_demon_runtime = (1.0L * *total_demon_runtime) / runtimes.size();

393

394

395 std::sort(runtimes.begin(), runtimes.end());

396 const int pivot = runtimes.size() / 2;

397

398 if (runtimes.size() == 1) {

399 *median_demon_runtime = runtimes[0];

400 } else {

401 *median_demon_runtime =

402 runtimes.size() % 2 == 1

403 ? runtimes[pivot]

404 : (runtimes[pivot - 1] + runtimes[pivot]) / 2.0;

405 }

406

407

408 double total_deviation = 0.0f;

409

410 for (int i = 0; i < runtimes.size(); ++i) {

411 total_deviation += pow(runtimes[i] - *mean_demon_runtime, 2);

412 }

413

414 *stddev_demon_runtime = sqrt(total_deviation / runtimes.size());

415 }

416 }