Skip to content

Commit 5fcf712

Browse files
fontanffontanf
authored
Bugfix/parallel exceptions (#190)
* Update exceptions in irregular optimize * Fix other optimize files
1 parent 737de9d commit 5fcf712

File tree

5 files changed

+241
-133
lines changed

5 files changed

+241
-133
lines changed

‎src/boxstacks/optimize.cpp

+8-4
Original file line numberDiff line numberDiff line change
@@ -187,17 +187,21 @@ packingsolver::boxstacks::Output packingsolver::boxstacks::optimize(
187187
<< " " << tssibs_output.maximum_size_of_the_queue;
188188
algorithm_formatter.update_solution(solution, ss.str());
189189
};
190+
exception_ptr_list.push_front(std::exception_ptr());
190191
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential) {
191-
exception_ptr_list.push_front(std::exception_ptr());
192192
threads.push_back(std::thread(
193193
wrapper<decltype(&treesearchsolver::iterative_beam_search_2<BranchingScheme>), treesearchsolver::iterative_beam_search_2<BranchingScheme>>,
194194
std::ref(exception_ptr_list.front()),
195195
std::ref(branching_schemes[i]),
196196
ibs_parameters_list[i]));
197197
} else {
198-
treesearchsolver::iterative_beam_search_2<BranchingScheme>(
199-
branching_schemes[i],
200-
ibs_parameters_list[i]);
198+
try {
199+
treesearchsolver::iterative_beam_search_2<BranchingScheme>(
200+
branching_schemes[i],
201+
ibs_parameters_list[i]);
202+
} catch (...) {
203+
exception_ptr_list.front() = std::current_exception();
204+
}
201205
}
202206
}
203207
for (Counter i = 0; i < (Counter)threads.size(); ++i)

‎src/irregular/optimize.cpp

+56-32
Original file line numberDiff line numberDiff line change
@@ -185,8 +185,8 @@ void optimize_tree_search(
185185
outputs[i].solution_pool.add(solution);
186186
};
187187
}
188+
exception_ptr_list.push_front(std::exception_ptr());
188189
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential) {
189-
exception_ptr_list.push_front(std::exception_ptr());
190190
threads.push_back(std::thread(
191191
wrapper<decltype(&optimize_tree_search_worker), optimize_tree_search_worker>,
192192
std::ref(exception_ptr_list.front()),
@@ -196,12 +196,16 @@ void optimize_tree_search(
196196
branching_scheme_parameters_list[i],
197197
ibs_parameters_list[i]));
198198
} else {
199-
optimize_tree_search_worker(
200-
instance,
201-
parameters,
202-
algorithm_formatter,
203-
branching_scheme_parameters_list[i],
204-
ibs_parameters_list[i]);
199+
try {
200+
optimize_tree_search_worker(
201+
instance,
202+
parameters,
203+
algorithm_formatter,
204+
branching_scheme_parameters_list[i],
205+
ibs_parameters_list[i]);
206+
} catch (...) {
207+
exception_ptr_list.front() = std::current_exception();
208+
}
205209
}
206210
}
207211
for (Counter i = 0; i < (Counter)threads.size(); ++i)
@@ -580,92 +584,112 @@ packingsolver::irregular::Output packingsolver::irregular::optimize(
580584
std::forward_list<std::exception_ptr> exception_ptr_list;
581585
// Tree search.
582586
if (use_tree_search) {
587+
exception_ptr_list.push_front(std::exception_ptr());
583588
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
584589
&& last_algorithm != 0) {
585-
exception_ptr_list.push_front(std::exception_ptr());
586590
threads.push_back(std::thread(
587591
wrapper<decltype(&optimize_tree_search), optimize_tree_search>,
588592
std::ref(exception_ptr_list.front()),
589593
std::ref(instance),
590594
std::ref(parameters),
591595
std::ref(algorithm_formatter)));
592596
} else {
593-
optimize_tree_search(
594-
instance,
595-
parameters,
596-
algorithm_formatter);
597+
try {
598+
optimize_tree_search(
599+
instance,
600+
parameters,
601+
algorithm_formatter);
602+
} catch (...) {
603+
exception_ptr_list.front() = std::current_exception();
604+
}
597605
}
598606
}
599607
// Sequential single knapsack.
600608
if (use_sequential_single_knapsack) {
609+
exception_ptr_list.push_front(std::exception_ptr());
601610
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
602611
&& last_algorithm != 1) {
603-
exception_ptr_list.push_front(std::exception_ptr());
604612
threads.push_back(std::thread(
605613
wrapper<decltype(&optimize_sequential_single_knapsack), optimize_sequential_single_knapsack>,
606614
std::ref(exception_ptr_list.front()),
607615
std::ref(instance),
608616
std::ref(parameters),
609617
std::ref(algorithm_formatter)));
610618
} else {
611-
optimize_sequential_single_knapsack(
612-
instance,
613-
parameters,
614-
algorithm_formatter);
619+
try {
620+
optimize_sequential_single_knapsack(
621+
instance,
622+
parameters,
623+
algorithm_formatter);
624+
} catch (...) {
625+
exception_ptr_list.front() = std::current_exception();
626+
}
615627
}
616628
}
617629
// Sequential value correction.
618630
if (use_sequential_value_correction) {
631+
exception_ptr_list.push_front(std::exception_ptr());
619632
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
620633
&& last_algorithm != 2) {
621-
exception_ptr_list.push_front(std::exception_ptr());
622634
threads.push_back(std::thread(
623635
wrapper<decltype(&optimize_sequential_value_correction), optimize_sequential_value_correction>,
624636
std::ref(exception_ptr_list.front()),
625637
std::ref(instance),
626638
std::ref(parameters),
627639
std::ref(algorithm_formatter)));
628640
} else {
629-
optimize_sequential_value_correction(
630-
instance,
631-
parameters,
632-
algorithm_formatter);
641+
try {
642+
optimize_sequential_value_correction(
643+
instance,
644+
parameters,
645+
algorithm_formatter);
646+
} catch (...) {
647+
exception_ptr_list.front() = std::current_exception();
648+
}
633649
}
634650
}
635651
// Dichotomic search.
636652
if (use_dichotomic_search) {
653+
exception_ptr_list.push_front(std::exception_ptr());
637654
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
638655
&& last_algorithm != 3) {
639-
exception_ptr_list.push_front(std::exception_ptr());
640656
threads.push_back(std::thread(
641657
wrapper<decltype(&optimize_dichotomic_search), optimize_dichotomic_search>,
642658
std::ref(exception_ptr_list.front()),
643659
std::ref(instance),
644660
std::ref(parameters),
645661
std::ref(algorithm_formatter)));
646662
} else {
647-
optimize_dichotomic_search(
648-
instance,
649-
parameters,
650-
algorithm_formatter);
663+
try {
664+
optimize_dichotomic_search(
665+
instance,
666+
parameters,
667+
algorithm_formatter);
668+
} catch (...) {
669+
exception_ptr_list.front() = std::current_exception();
670+
}
651671
}
652672
}
653673
// Column generation.
654674
if (use_column_generation) {
675+
exception_ptr_list.push_front(std::exception_ptr());
655676
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
656677
&& last_algorithm != 4) {
657-
exception_ptr_list.push_front(std::exception_ptr());
658678
threads.push_back(std::thread(
659679
wrapper<decltype(&optimize_column_generation), optimize_column_generation>,
660680
std::ref(exception_ptr_list.front()),
661681
std::ref(instance),
662682
std::ref(parameters),
663683
std::ref(algorithm_formatter)));
664684
} else {
665-
optimize_column_generation(
666-
instance,
667-
parameters,
668-
algorithm_formatter);
685+
try {
686+
optimize_column_generation(
687+
instance,
688+
parameters,
689+
algorithm_formatter);
690+
} catch (...) {
691+
exception_ptr_list.front() = std::current_exception();
692+
}
669693
}
670694
}
671695
for (Counter i = 0; i < (Counter)threads.size(); ++i)

‎src/onedimensional/optimize.cpp

+53-29
Original file line numberDiff line numberDiff line change
@@ -166,17 +166,21 @@ void optimize_tree_search(
166166
outputs[i].solution_pool.add(solution);
167167
};
168168
}
169+
exception_ptr_list.push_front(std::exception_ptr());
169170
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential) {
170-
exception_ptr_list.push_front(std::exception_ptr());
171171
threads.push_back(std::thread(
172172
wrapper<decltype(&treesearchsolver::iterative_beam_search_2<BranchingScheme>), treesearchsolver::iterative_beam_search_2<BranchingScheme>>,
173173
std::ref(exception_ptr_list.front()),
174174
std::ref(branching_schemes[i]),
175175
ibs_parameters_list[i]));
176176
} else {
177-
treesearchsolver::iterative_beam_search_2<BranchingScheme>(
178-
branching_schemes[i],
179-
ibs_parameters_list[i]);
177+
try {
178+
treesearchsolver::iterative_beam_search_2<BranchingScheme>(
179+
branching_schemes[i],
180+
ibs_parameters_list[i]);
181+
} catch (...) {
182+
exception_ptr_list.front() = std::current_exception();
183+
}
180184
}
181185
}
182186
for (Counter i = 0; i < (Counter)threads.size(); ++i)
@@ -561,92 +565,112 @@ packingsolver::onedimensional::Output packingsolver::onedimensional::optimize(
561565
std::forward_list<std::exception_ptr> exception_ptr_list;
562566
// Tree search.
563567
if (use_tree_search) {
568+
exception_ptr_list.push_front(std::exception_ptr());
564569
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
565570
&& last_algorithm != 0) {
566-
exception_ptr_list.push_front(std::exception_ptr());
567571
threads.push_back(std::thread(
568572
wrapper<decltype(&optimize_tree_search), optimize_tree_search>,
569573
std::ref(exception_ptr_list.front()),
570574
std::ref(instance),
571575
std::ref(parameters),
572576
std::ref(algorithm_formatter)));
573577
} else {
574-
optimize_tree_search(
575-
instance,
576-
parameters,
577-
algorithm_formatter);
578+
try {
579+
optimize_tree_search(
580+
instance,
581+
parameters,
582+
algorithm_formatter);
583+
} catch (...) {
584+
exception_ptr_list.front() = std::current_exception();
585+
}
578586
}
579587
}
580588
// Sequential single knapsack.
581589
if (use_sequential_single_knapsack) {
590+
exception_ptr_list.push_front(std::exception_ptr());
582591
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
583592
&& last_algorithm != 1) {
584-
exception_ptr_list.push_front(std::exception_ptr());
585593
threads.push_back(std::thread(
586594
wrapper<decltype(&optimize_sequential_single_knapsack), optimize_sequential_single_knapsack>,
587595
std::ref(exception_ptr_list.front()),
588596
std::ref(instance),
589597
std::ref(parameters),
590598
std::ref(algorithm_formatter)));
591599
} else {
592-
optimize_sequential_single_knapsack(
593-
instance,
594-
parameters,
595-
algorithm_formatter);
600+
try {
601+
optimize_sequential_single_knapsack(
602+
instance,
603+
parameters,
604+
algorithm_formatter);
605+
} catch (...) {
606+
exception_ptr_list.front() = std::current_exception();
607+
}
596608
}
597609
}
598610
// Sequential value correction.
599611
if (use_sequential_value_correction) {
612+
exception_ptr_list.push_front(std::exception_ptr());
600613
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
601614
&& last_algorithm != 2) {
602-
exception_ptr_list.push_front(std::exception_ptr());
603615
threads.push_back(std::thread(
604616
wrapper<decltype(&optimize_sequential_value_correction), optimize_sequential_value_correction>,
605617
std::ref(exception_ptr_list.front()),
606618
std::ref(instance),
607619
std::ref(parameters),
608620
std::ref(algorithm_formatter)));
609621
} else {
610-
optimize_sequential_value_correction(
611-
instance,
612-
parameters,
613-
algorithm_formatter);
622+
try {
623+
optimize_sequential_value_correction(
624+
instance,
625+
parameters,
626+
algorithm_formatter);
627+
} catch (...) {
628+
exception_ptr_list.front() = std::current_exception();
629+
}
614630
}
615631
}
616632
// Dichotomic search.
617633
if (use_dichotomic_search) {
634+
exception_ptr_list.push_front(std::exception_ptr());
618635
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
619636
&& last_algorithm != 3) {
620-
exception_ptr_list.push_front(std::exception_ptr());
621637
threads.push_back(std::thread(
622638
wrapper<decltype(&optimize_dichotomic_search), optimize_dichotomic_search>,
623639
std::ref(exception_ptr_list.front()),
624640
std::ref(instance),
625641
std::ref(parameters),
626642
std::ref(algorithm_formatter)));
627643
} else {
628-
optimize_dichotomic_search(
629-
instance,
630-
parameters,
631-
algorithm_formatter);
644+
try {
645+
optimize_dichotomic_search(
646+
instance,
647+
parameters,
648+
algorithm_formatter);
649+
} catch (...) {
650+
exception_ptr_list.front() = std::current_exception();
651+
}
632652
}
633653
}
634654
// Column generation.
635655
if (use_column_generation) {
656+
exception_ptr_list.push_front(std::exception_ptr());
636657
if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential
637658
&& last_algorithm != 4) {
638-
exception_ptr_list.push_front(std::exception_ptr());
639659
threads.push_back(std::thread(
640660
wrapper<decltype(&optimize_column_generation), optimize_column_generation>,
641661
std::ref(exception_ptr_list.front()),
642662
std::ref(instance),
643663
std::ref(parameters),
644664
std::ref(algorithm_formatter)));
645665
} else {
646-
optimize_column_generation(
647-
instance,
648-
parameters,
649-
algorithm_formatter);
666+
try {
667+
optimize_column_generation(
668+
instance,
669+
parameters,
670+
algorithm_formatter);
671+
} catch (...) {
672+
exception_ptr_list.front() = std::current_exception();
673+
}
650674
}
651675
}
652676
for (Counter i = 0; i < (Counter)threads.size(); ++i)

0 commit comments

Comments
 (0)