Generated on for Gecode by doxygen 1.17.0
fault.cpp
Go to the documentation of this file.
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
5 *
6 * Copyright:
7 * Mikael Zayenz Lagerkvist, 2026
8 *
9 * This file is part of Gecode, the generic constraint
10 * development environment:
11 * http://www.gecode.dev
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining
14 * a copy of this software and associated documentation files (the
15 * "Software"), to deal in the Software without restriction, including
16 * without limitation the rights to use, copy, modify, merge, publish,
17 * distribute, sublicense, and/or sell copies of the Software, and to
18 * permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be
22 * included in all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 *
32 */
33
34#include <gecode/minimodel.hh>
35#include <gecode/search.hh>
36
37#include "test/test.hh"
38
39namespace Test { namespace Fault {
40
41 using namespace Gecode;
43
45
46 class FaultScope {
47 private:
48 Support::Lock lock;
49 public:
56 };
57
59 protected:
62 : Propagator(home,p) {
63 Support::FailPoint::check(Phase::PropagatorCopy);
64 }
65 public:
66 static void post(Home home) {
67 (void) new (home) ThrowingPropagator(home);
68 }
69 virtual Actor* copy(Space& home) {
70 return new (home) ThrowingPropagator(home,*this);
71 }
72 virtual PropCost cost(const Space&, const ModEventDelta&) const {
74 }
75 virtual void reschedule(Space&) {}
76 virtual ExecStatus propagate(Space& home, const ModEventDelta&) {
77 return home.ES_SUBSUMED(*this);
78 }
79 virtual size_t dispose(Space& home) {
80 (void) Propagator::dispose(home);
81 return sizeof(*this);
82 }
83 };
84
85 class AdvisorCopyPropagator;
86
87 class ThrowingAdvisor : public Advisor {
88 protected:
89 int id;
90 public:
92 Council<ThrowingAdvisor>& c, int id0)
93 : Advisor(home,p,c), id(id0) {}
95 : Advisor(home,a), id(a.id) {
96 Support::FailPoint::check(Phase::AdvisorCopy);
97 }
98 Propagator* owner(void) const {
99 return &propagator();
100 }
102 Advisor::dispose(home,c);
103 }
104 };
105
107 protected:
109 AdvisorCopyPropagator(Home home) : Propagator(home), c(home) {
110 (void) new (home) ThrowingAdvisor(home,*this,c,0);
111 (void) new (home) ThrowingAdvisor(home,*this,c,1);
112 }
114 : Propagator(home,p) {
115 c.update(home,p.c);
116 }
117 public:
119 return new (home) AdvisorCopyPropagator(home);
120 }
121 bool advisors_point_to_self(void) const {
123 int n = 0;
124 while (as()) {
125 if (as.advisor().owner() != this)
126 return false;
127 ++n; ++as;
128 }
129 return n == 2;
130 }
131 virtual Actor* copy(Space& home) {
132 return new (home) AdvisorCopyPropagator(home,*this);
133 }
134 virtual PropCost cost(const Space&, const ModEventDelta&) const {
136 }
137 virtual void reschedule(Space&) {}
139 return ES_FIX;
140 }
141 virtual size_t dispose(Space& home) {
142 c.dispose(home);
143 (void) Propagator::dispose(home);
144 return sizeof(*this);
145 }
146 };
147
148 class ThrowingChoice : public Choice {
149 public:
150 ThrowingChoice(const Brancher& b) : Choice(b,1) {}
151 virtual void archive(Archive& e) const {
153 }
154 };
155
156 class ThrowingBrancher : public Brancher {
157 protected:
158 bool done;
159 ThrowingBrancher(Home home) : Brancher(home), done(false) {}
161 : Brancher(home,b), done(b.done) {
162 Support::FailPoint::check(Phase::BrancherCopy);
163 }
164 public:
165 static void post(Home home) {
166 (void) new (home) ThrowingBrancher(home);
167 }
168 virtual bool status(const Space&) const {
169 return !done;
170 }
171 virtual const Choice* choice(Space&) {
172 return new ThrowingChoice(*this);
173 }
174 virtual const Choice* choice(const Space&, Archive&) {
175 return new ThrowingChoice(*this);
176 }
177 virtual ExecStatus commit(Space&, const Choice&, unsigned int) {
178 done = true;
179 return ES_OK;
180 }
181 virtual void print(const Space&, const Choice&,
182 unsigned int, std::ostream&) const {}
183 virtual Actor* copy(Space& home) {
184 return new (home) ThrowingBrancher(home,*this);
185 }
186 virtual size_t dispose(Space&) {
187 return sizeof(*this);
188 }
189 };
190
191 class CloneCopySpace : public Space {
192 public:
200 virtual Space* copy(void) {
201 return new CloneCopySpace(*this);
202 }
203 };
204
205 class DisposeSpace : public Space {
206 public:
208 DisposeSpace(void) : x(*this,3,0,2) {
210 }
212 x.update(*this,s.x);
213 }
214 virtual Space* copy(void) {
215 return new DisposeSpace(*this);
216 }
217 };
218
219 class NoticeDisposeActor : public Actor {
220 public:
221 static int disposed;
222
224 home.notice(*this,AP_DISPOSE);
225 }
226 static void post(Home home) {
227 (void) new (home) NoticeDisposeActor(home);
228 }
229 virtual Actor* copy(Space& home) {
230 return new (home) NoticeDisposeActor(home);
231 }
232 virtual size_t dispose(Space& home) {
233 home.ignore(*this,AP_DISPOSE);
234 disposed++;
235 return sizeof(*this);
236 }
237 };
238
240
241 class NoticeDisposeSpace : public Space {
242 public:
243 NoticeDisposeSpace(int registered = 0, bool fail_next = false) {
244 for (int i=0; i<registered; i++)
246 if (fail_next) {
247 Support::FailPoint::fail_after(Phase::SpaceDisposeNoticeArray,0);
249 } else if (registered == 0) {
251 }
252 }
254 virtual Space* copy(void) {
255 return new NoticeDisposeSpace(*this);
256 }
257 };
258
259 class MiniModelSpace : public Space {
260 public:
263 virtual Space* copy(void) {
264 return new MiniModelSpace(*this);
265 }
266 };
267
268 class DerivedCopySpace : public Space {
269 public:
271 DerivedCopySpace(void) : x(*this,2,0,1) {
274 }
276 Support::FailPoint::check(Phase::DerivedSpaceCopy);
277 x.update(*this,s.x);
278 }
279 virtual Space* copy(void) {
280 return new DerivedCopySpace(*this);
281 }
282 };
283
284 class DerivedUpdateSpace : public Space {
285 public:
287 DerivedUpdateSpace(void) : x(*this,2,0,1) {
288 rel(*this,x[0] != x[1]);
290 }
292 x.update(*this,s.x);
293 Support::FailPoint::check(Phase::DerivedSpaceCopy);
294 }
295 virtual Space* copy(void) {
296 return new DerivedUpdateSpace(*this);
297 }
298 };
299
301 public:
302 int value;
303 FaultLocalObject(Home home, int v) : LocalObject(home), value(v) {}
305 : LocalObject(home,o), value(o.value) {
306 Support::FailPoint::check(Phase::LocalObjectCopy);
307 }
308 virtual Actor* copy(Space& home) {
309 return new (home) FaultLocalObject(home,*this);
310 }
311 virtual size_t dispose(Space&) {
312 return sizeof(*this);
313 }
314 };
315
317 public:
320 void update(Space& home, FaultLocalHandle& h) {
321 LocalHandle::update(home,h);
322 }
323 int value(void) const {
324 return static_cast<FaultLocalObject*>(object())->value;
325 }
326 };
327
328 class LocalCopySpace : public Space {
329 public:
332 : h(new (*this) FaultLocalObject(*this,42)) {}
334 h.update(*this,s.h);
335 }
336 virtual Space* copy(void) {
337 return new LocalCopySpace(*this);
338 }
339 };
340
341 class AdvisorCopySpace : public Space {
342 public:
345 : p(AdvisorCopyPropagator::post(*this)) {}
347 virtual Space* copy(void) {
348 return new AdvisorCopySpace(*this);
349 }
350 bool advisors_point_to_source(void) const {
351 return (p != nullptr) && p->advisors_point_to_self();
352 }
353 };
354
355 class BranchPostSpace : public Space {
356 public:
358 BranchPostSpace(void) : x(*this,4,0,3) {
359 rel(*this,x[0] != x[1]);
360 }
362 x.update(*this,s.x);
363 }
364 virtual Space* copy(void) {
365 return new BranchPostSpace(*this);
366 }
370 void post_chb_branch(void) {
372 }
373 void post_plain_branch(void) {
375 }
376 };
377
378 bool clone_after_failed_copy(Phase p, unsigned long long n) {
379 FaultScope scope;
381 if (s.status() == SS_FAILED)
382 return false;
385 try {
386 Space* c = s.clone();
387 delete c;
389 return false;
390 } catch (const MemoryExhausted&) {
392 } catch (...) {
394 return false;
395 }
396 Space* c = s.clone();
397 delete c;
398 const Choice* ch = s.choice();
399 bool ok = ch != nullptr;
400 if (ch != nullptr) {
401 s.commit(*ch,0);
402 delete ch;
403 }
404 return ok && (s.status() != SS_FAILED);
405 }
406
407 bool expect_memory_exhausted(Phase p, unsigned long long n) {
408 FaultScope scope;
410 if (s.status() == SS_FAILED)
411 return false;
414 try {
415 Space* c = s.clone();
416 delete c;
417 } catch (const MemoryExhausted&) {
419 Space* c = s.clone();
420 delete c;
421 const Choice* ch = s.choice();
422 bool ok = ch != nullptr;
423 if (ch != nullptr) {
424 s.commit(*ch,0);
425 delete ch;
426 }
427 return ok && (s.status() != SS_FAILED);
428 } catch (...) {
430 return false;
431 }
433 return false;
434 }
435
437 FaultScope scope;
440 Support::FailPoint::fail_after(Phase::LocalObjectCopy,0);
441 try {
442 Space* c = s.clone();
443 delete c;
444 } catch (const MemoryExhausted&) {
446 if (s.h.value() != 42)
447 return false;
448 LocalCopySpace* c = static_cast<LocalCopySpace*>(s.clone());
449 bool ok = (c != nullptr) && (c->h.value() == 42);
450 delete c;
451 return ok;
452 } catch (...) {
454 return false;
455 }
457 return false;
458 }
459
461 FaultScope scope;
464 return false;
466 Support::FailPoint::fail_after(Phase::AdvisorCopy,1);
467 try {
468 Space* c = s.clone();
469 delete c;
471 return false;
472 } catch (const MemoryExhausted&) {
475 return false;
476 AdvisorCopySpace* c = static_cast<AdvisorCopySpace*>(s.clone());
477 bool ok = (c != nullptr);
478 delete c;
479 return ok && s.advisors_point_to_source();
480 } catch (...) {
482 return false;
483 }
484 }
485
487 FaultScope scope;
488 DisposeSpace s;
489 if (s.status() == SS_FAILED)
490 return false;
492 Support::FailPoint::fail_after(Phase::SpaceDisposalArray,0);
493 try {
494 Space* c = s.clone();
495 delete c;
497 return false;
498 } catch (const MemoryExhausted&) {
500 } catch (...) {
502 return false;
503 }
504 Space* c = s.clone();
505 delete c;
506 DFS<DisposeSpace> e(&s);
507 Space* sol = e.next();
508 bool ok = (sol != nullptr);
509 delete sol;
510 return ok;
511 }
512
514 Space* c = s.clone();
515 delete c;
517 Space* sol = e.next();
518 bool ok = (sol != nullptr);
519 delete sol;
520 return ok;
521 }
522
524 FaultScope scope;
526 if (s.status() == SS_FAILED)
527 return false;
529 Support::FailPoint::fail_after(Phase::DerivedSpaceCopy,0);
530 try {
531 Space* c = s.clone();
532 delete c;
534 return false;
535 } catch (const MemoryExhausted&) {
537 } catch (...) {
539 return false;
540 }
542 }
543
545 FaultScope scope;
547 Support::FailPoint::fail_after(Phase::Heap,0);
548 try {
549 int* x = heap.alloc<int>(1);
550 heap.free<int>(x,1);
552 return false;
553 } catch (const MemoryExhausted&) {
555 return true;
556 } catch (...) {
558 return false;
559 }
560 }
561
563 FaultScope scope;
564 int* x = heap.alloc<int>(1);
566 Support::FailPoint::fail_after(Phase::Heap,0);
567 try {
568 int* y = heap.realloc<int>(x,1,2);
570 heap.free<int>(y,2);
571 return false;
572 } catch (const MemoryExhausted&) {
574 heap.free<int>(x,1);
575 return true;
576 } catch (...) {
578 heap.free<int>(x,1);
579 return false;
580 }
581 }
582
584 FaultScope scope;
586 if (s.status() == SS_FAILED)
587 return false;
588 bool saw_failure = false;
589 for (unsigned long long budget = 0; budget < 32; budget++) {
591 Support::FailPoint::fail_after(Phase::Heap,budget);
592 try {
593 Space* c = s.clone();
594 unsigned long long checks = Support::FailPoint::count();
596 delete c;
597 return saw_failure && (checks > 0) && derived_update_space_is_usable(s);
598 } catch (const MemoryExhausted&) {
600 saw_failure = true;
602 return false;
603 } catch (...) {
605 return false;
606 }
607 }
608 return false;
609 }
610
612 FaultScope scope;
613 bool saw_failure = false;
614 for (unsigned long long budget = 0; budget < 32; budget++) {
616 if (s.status() == SS_FAILED)
617 return false;
619 Support::FailPoint::fail_after(Phase::Heap,budget);
620 try {
621 if (chb)
622 s.post_chb_branch();
623 else
625 unsigned long long checks = Support::FailPoint::count();
628 Space* sol = e.next();
629 bool ok = (sol != nullptr);
630 delete sol;
631 return saw_failure && (checks > 0) && ok;
632 } catch (const MemoryExhausted&) {
634 saw_failure = true;
637 Space* sol = e.next();
638 bool ok = (sol != nullptr);
639 delete sol;
640 if (!ok)
641 return false;
642 } catch (...) {
644 return false;
645 }
646 }
647 return false;
648 }
649
651 FaultScope scope;
652 int ranges[3][2] = {{0, 0}, {2, 2}, {4, 4}};
653 bool saw_failure = false;
654 for (unsigned long long budget = 0; budget < 8; budget++) {
655 IntSet::fault_reset_allocations();
657 Support::FailPoint::fail_after(Phase::Heap,budget);
658 try {
659 unsigned long long checks;
660 {
661 IntSet s(ranges,3);
662 checks = Support::FailPoint::count();
663 }
665 return saw_failure && (checks > 0) &&
666 (IntSet::fault_live_allocations() == 0);
667 } catch (const MemoryExhausted&) {
669 saw_failure = true;
670 if (IntSet::fault_live_allocations() != 0)
671 return false;
672 } catch (...) {
674 return false;
675 }
676 }
677 return false;
678 }
679
681 FaultScope scope;
682 bool saw_failure = false;
683 for (unsigned long long budget = 0; budget < 32; budget++) {
684 LinIntExpr::fault_reset_allocations();
686 try {
687 MiniModelSpace home;
688 IntVarArgs x(home,4,0,3);
689 Support::FailPoint::fail_after(Phase::Heap,budget);
690 {
691 LinIntExpr e = min(x);
692 (void) e;
693 }
694 unsigned long long checks = Support::FailPoint::count();
696 return saw_failure && (checks > 0) &&
697 (LinIntExpr::fault_live_allocations() == 0);
698 } catch (const MemoryExhausted&) {
700 saw_failure = true;
701 if (LinIntExpr::fault_live_allocations() != 0)
702 return false;
703 } catch (...) {
705 return false;
706 }
707 }
708 return false;
709 }
710
712 FaultScope scope;
713 bool saw_failure = false;
714 for (unsigned long long budget = 0; budget < 8; budget++) {
715 LinIntExpr::fault_reset_allocations();
717 try {
718 MiniModelSpace home;
719 IntVarArgs x(home,4,0,3);
720 BoolVarArgs b(home,4,0,1);
721 IntArgs a({1,2,3,4});
722 Support::FailPoint::fail_after(Phase::Heap,budget);
723 switch (kind) {
724 case 0:
725 {
726 LinIntExpr e(x);
727 (void) e;
728 }
729 break;
730 case 1:
731 {
732 LinIntExpr e(a,x);
733 (void) e;
734 }
735 break;
736 case 2:
737 {
738 LinIntExpr e(b);
739 (void) e;
740 }
741 break;
742 case 3:
743 {
744 LinIntExpr e(a,b);
745 (void) e;
746 }
747 break;
748 default:
749 return false;
750 }
751 unsigned long long checks = Support::FailPoint::count();
753 return saw_failure && (checks > 0) &&
754 (LinIntExpr::fault_live_allocations() == 0);
755 } catch (const MemoryExhausted&) {
757 saw_failure = true;
758 if (LinIntExpr::fault_live_allocations() != 0)
759 return false;
760 } catch (...) {
762 return false;
763 }
764 }
765 return false;
766 }
767
769 for (int kind = 0; kind < 4; kind++)
771 return false;
772 return true;
773 }
774
775#ifdef GECODE_HAS_FLOAT_VARS
777 FaultScope scope;
778 bool saw_failure = false;
779 for (unsigned long long budget = 0; budget < 32; budget++) {
781 try {
782 MiniModelSpace home;
783 FloatVarArgs x(home,4,0.0,3.0);
784 Support::FailPoint::fail_after(Phase::Heap,budget);
785 {
786 LinFloatExpr e = min(x);
787 (void) e;
788 }
789 unsigned long long checks = Support::FailPoint::count();
791 return saw_failure && (checks > 0);
792 } catch (const MemoryExhausted&) {
794 saw_failure = true;
795 } catch (...) {
797 return false;
798 }
799 }
800 return false;
801 }
802#endif
803
804#ifdef GECODE_HAS_SET_VARS
806 FaultScope scope;
807 bool saw_failure = false;
808 for (unsigned long long budget = 0; budget < 32; budget++) {
810 try {
811 MiniModelSpace home;
812 SetVarArgs x(home,4,IntSet::empty,1,1);
813 Support::FailPoint::fail_after(Phase::Heap,budget);
814 {
815 SetExpr e = setunion(x);
816 (void) e;
817 }
818 unsigned long long checks = Support::FailPoint::count();
820 return saw_failure && (checks > 0);
821 } catch (const MemoryExhausted&) {
823 saw_failure = true;
824 } catch (...) {
826 return false;
827 }
828 }
829 return false;
830 }
831#endif
832
834 FaultScope scope;
837 Support::FailPoint::fail_after(Phase::SpaceDisposeNoticeArray,0);
838 try {
841 return false;
842 } catch (const MemoryExhausted&) {
845 } catch (...) {
847 return false;
848 }
849 }
850
852 FaultScope scope;
855 try {
856 NoticeDisposeSpace s(4,true);
858 return false;
859 } catch (const MemoryExhausted&) {
862 } catch (...) {
864 return false;
865 }
866 }
867
869 FaultScope scope;
870 LinIntExpr::fault_reset_allocations();
872 try {
873 MiniModelSpace home;
874 IntVarArgs x(home,2,0,1);
875 Support::FailPoint::fail_after(Phase::MiniModel,1);
876 LinIntExpr e = min(x);
877 (void) e;
879 return false;
880 } catch (const MemoryExhausted&) {
882 return LinIntExpr::fault_live_allocations() == 0;
883 } catch (...) {
885 return false;
886 }
887 }
888
890 public:
891 static int disposed;
892
894 virtual ~FaultBoolMisc(void) {
895 disposed++;
896 }
897 virtual void post(Home, BoolVar, bool, const IntPropLevels&) {}
898 };
899
901
903 FaultScope scope;
907 Support::FailPoint::fail_after(Phase::Heap,0);
908 try {
909 BoolExpr b(m);
910 (void) b;
912 return false;
913 } catch (const MemoryExhausted&) {
915 return FaultBoolMisc::disposed == 1;
916 } catch (...) {
918 return false;
919 }
920 }
921
923 public:
925 : Base("Fault::MiniModel::DefaultNodes") {}
926 virtual bool run(void) {
928 }
929 };
930
931 class DisposeNoticeArray : public Base {
932 public:
934 : Base("Fault::Dispose::NoticeArray") {}
935 virtual bool run(void) {
937 }
938 };
939
941 public:
943 : Base("Fault::Dispose::NoticeArrayResize") {}
947 };
948
949 class CloneDisposalArray : public Base {
950 public:
952 : Base("Fault::Clone::DisposalArray") {}
953 virtual bool run(void) {
955 }
956 };
957
959 public:
961 : Base("Fault::Clone::DerivedSpaceUpdate") {}
962 virtual bool run(void) {
964 }
965 };
966
967 class HeapAllocation : public Base {
968 public:
970 : Base("Fault::Heap::Allocation") {}
971 virtual bool run(void) {
973 }
974 };
975
976 class HeapReallocation : public Base {
977 public:
979 : Base("Fault::Heap::Reallocation") {}
980 virtual bool run(void) {
982 }
983 };
984
985 class CloneHeapFailures : public Base {
986 public:
988 : Base("Fault::Clone::HeapFailures") {}
989 virtual bool run(void) {
991 }
992 };
993
995 public:
997 : Base("Fault::Branch::ActionHeapFailures") {}
998 virtual bool run(void) {
1000 }
1001 };
1002
1004 public:
1006 : Base("Fault::Branch::ChbHeapFailures") {}
1007 virtual bool run(void) {
1009 }
1010 };
1011
1012 class IntSetHeapFailures : public Base {
1013 public:
1015 : Base("Fault::IntSet::HeapFailures") {}
1016 virtual bool run(void) {
1018 }
1019 };
1020
1022 public:
1024 : Base("Fault::MiniModel::HeapFailures") {}
1025 virtual bool run(void) {
1027 }
1028 };
1029
1031 public:
1033 : Base("Fault::MiniModel::LinearSumHeapFailures") {}
1034 virtual bool run(void) {
1036 }
1037 };
1038
1040 public:
1042 : Base("Fault::MiniModel::BoolMiscHeapFailure") {}
1043 virtual bool run(void) {
1045 }
1046 };
1047
1048#ifdef GECODE_HAS_FLOAT_VARS
1050 public:
1052 : Base("Fault::MiniModel::FloatHeapFailures") {}
1053 virtual bool run(void) {
1055 }
1056 };
1057#endif
1058
1059#ifdef GECODE_HAS_SET_VARS
1061 public:
1063 : Base("Fault::MiniModel::SetHeapFailures") {}
1064 virtual bool run(void) {
1066 }
1067 };
1068#endif
1069
1070 class ClonePropagatorCopy : public Base {
1071 public:
1073 : Base("Fault::Clone::PropagatorCopy") {}
1074 virtual bool run(void) {
1075 return clone_after_failed_copy(Phase::PropagatorCopy,0) &&
1076 clone_after_failed_copy(Phase::PropagatorCopy,1);
1077 }
1078 };
1079
1080 class CloneBrancherCopy : public Base {
1081 public:
1083 : Base("Fault::Clone::BrancherCopy") {}
1084 virtual bool run(void) {
1085 return clone_after_failed_copy(Phase::BrancherCopy,0) &&
1086 clone_after_failed_copy(Phase::BrancherCopy,1);
1087 }
1088 };
1089
1090 class CloneAdvisorCopy : public Base {
1091 public:
1093 : Base("Fault::Clone::AdvisorCopy") {}
1094 virtual bool run(void) {
1096 }
1097 };
1098
1100 public:
1102 : Base("Fault::Clone::DerivedSpaceCopy") {}
1103 virtual bool run(void) {
1104 return expect_memory_exhausted(Phase::DerivedSpaceCopy,0);
1105 }
1106 };
1107
1109 public:
1111 : Base("Fault::Clone::LocalObjectCopy") {}
1112 virtual bool run(void) {
1114 }
1115 };
1116
1130#ifdef GECODE_HAS_FLOAT_VARS
1132#endif
1133#ifdef GECODE_HAS_SET_VARS
1135#endif
1142
1143}}
1144
1145// STATISTICS: test-fault
Base-class for both propagators and branchers.
Definition core.hpp:635
friend class Space
Definition core.hpp:637
virtual size_t dispose(Space &home)
Delete actor and return its size.
Definition core.hpp:3430
Propagator & propagator(void) const
Return the advisor's propagator.
Definition core.hpp:4091
Advisor(Space &home, Propagator &p, Council< A > &c)
Constructor for creation.
Definition core.hpp:4060
void dispose(Space &home, Council< A > &c)
Dispose the advisor.
Definition core.hpp:4098
friend class Council
Definition core.hpp:1310
Class to iterate over advisors of a council.
Definition core.hpp:1282
A & advisor(void) const
Return advisor.
Definition core.hpp:4255
Archive representation
Definition archive.hpp:42
Miscealloneous Boolean expressions.
Boolean expressions.
Passing Boolean variables.
Definition int.hh:739
Boolean integer variables.
Definition int.hh:534
Base-class for branchers.
Definition core.hpp:1460
friend class Space
Definition core.hpp:1462
Brancher(Home home)
Constructor for creation.
Definition core.hpp:3822
friend class Choice
Definition core.hpp:1463
Choice for performing commit
Definition core.hpp:1430
Choice(const Brancher &b, const unsigned int a)
Initialize for particular brancher b and alternatives a.
Definition core.hpp:3995
virtual void archive(Archive &e) const
Archive into e.
Definition core.cpp:958
Depth-first search engine.
Definition search.hh:1211
Passing float variables.
Definition float.hh:977
Home class for posting propagators
Definition core.hpp:863
void notice(Actor &a, ActorProperty p, bool duplicate=false)
Notice actor property.
Definition core.hpp:3373
Passing integer arguments.
Definition int.hh:653
Class for specifying integer propagation levels used by minimodel.
Definition minimodel.hh:110
Integer sets.
Definition int.hh:179
static const IntSet empty
Empty set.
Definition int.hh:302
Passing integer variables.
Definition int.hh:681
Integer variable array.
Definition int.hh:792
Float expressions
Definition minimodel.hh:846
Linear expressions over integer variables.
Definition minimodel.hh:258
LocalHandle(void)
Create local handle pointing to nullptr object.
Definition core.hpp:3968
void update(Space &home, LocalHandle &lh)
Updating during cloning.
Definition core.hpp:3985
LocalObject * object(void) const
Access to the local object.
Definition core.hpp:3981
friend class Space
Definition core.hpp:1553
LocalObject(Home home)
Constructor for creation.
Definition core.hpp:3950
Exception: Memory exhausted
Definition exception.hpp:63
Propagation cost.
Definition core.hpp:493
static PropCost unary(PropCost::Mod m)
Single variable for modifier pcm.
Definition core.hpp:5097
Base-class for propagators.
Definition core.hpp:1073
friend class Space
Definition core.hpp:1075
friend class Council
Definition core.hpp:1078
Propagator(Home home)
Constructor for posting.
Definition core.hpp:3707
virtual T * next(void)
Return next solution (nullptr, if none exists or search has been stopped).
Definition base.hpp:46
Set expressions
Passing set variables.
Definition set.hh:491
Computation spaces.
Definition core.hpp:1787
A lock as a scoped frontend for a mutex.
Definition thread.hpp:114
A mutex for mutual exclausion among several threads.
Definition thread.hpp:78
Base(std::string s)
Create and register a standard test with name s.
Definition test.cpp:125
bool advisors_point_to_self(void) const
Definition fault.cpp:121
virtual void reschedule(Space &)
Schedule function.
Definition fault.cpp:137
static AdvisorCopyPropagator * post(Home home)
Definition fault.cpp:118
virtual size_t dispose(Space &home)
Delete actor and return its size.
Definition fault.cpp:141
AdvisorCopyPropagator(Space &home, AdvisorCopyPropagator &p)
Definition fault.cpp:113
virtual PropCost cost(const Space &, const ModEventDelta &) const
Cost function.
Definition fault.cpp:134
virtual Actor * copy(Space &home)
Create copy.
Definition fault.cpp:131
Council< ThrowingAdvisor > c
Definition fault.cpp:108
virtual ExecStatus propagate(Space &, const ModEventDelta &)
Propagation function.
Definition fault.cpp:138
AdvisorCopyPropagator * p
Definition fault.cpp:343
AdvisorCopySpace(AdvisorCopySpace &s)
Definition fault.cpp:346
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:347
bool advisors_point_to_source(void) const
Definition fault.cpp:350
virtual bool run(void)
Run test.
Definition fault.cpp:998
virtual bool run(void)
Run test.
Definition fault.cpp:1007
BranchPostSpace(BranchPostSpace &s)
Definition fault.cpp:361
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:364
virtual bool run(void)
Run test.
Definition fault.cpp:1094
virtual bool run(void)
Run test.
Definition fault.cpp:1084
CloneCopySpace(CloneCopySpace &s)
Definition fault.cpp:199
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:200
virtual bool run(void)
Run test.
Definition fault.cpp:1103
virtual bool run(void)
Run test.
Definition fault.cpp:962
virtual bool run(void)
Run test.
Definition fault.cpp:953
virtual bool run(void)
Run test.
Definition fault.cpp:989
virtual bool run(void)
Run test.
Definition fault.cpp:1112
virtual bool run(void)
Run test.
Definition fault.cpp:1074
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:279
DerivedCopySpace(DerivedCopySpace &s)
Definition fault.cpp:275
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:295
DerivedUpdateSpace(DerivedUpdateSpace &s)
Definition fault.cpp:291
virtual bool run(void)
Run test.
Definition fault.cpp:944
virtual bool run(void)
Run test.
Definition fault.cpp:935
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:214
DisposeSpace(DisposeSpace &s)
Definition fault.cpp:211
virtual void post(Home, BoolVar, bool, const IntPropLevels &)
Definition fault.cpp:897
virtual ~FaultBoolMisc(void)
Definition fault.cpp:894
FaultLocalHandle(FaultLocalObject *o)
Definition fault.cpp:319
void update(Space &home, FaultLocalHandle &h)
Definition fault.cpp:320
FaultLocalObject(Home home, int v)
Definition fault.cpp:303
virtual size_t dispose(Space &)
Delete actor and return its size.
Definition fault.cpp:311
FaultLocalObject(Space &home, FaultLocalObject &o)
Definition fault.cpp:304
virtual Actor * copy(Space &home)
Create copy.
Definition fault.cpp:308
virtual bool run(void)
Run test.
Definition fault.cpp:971
virtual bool run(void)
Run test.
Definition fault.cpp:980
virtual bool run(void)
Run test.
Definition fault.cpp:1016
FaultLocalHandle h
Definition fault.cpp:330
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:336
LocalCopySpace(LocalCopySpace &s)
Definition fault.cpp:333
virtual bool run(void)
Run test.
Definition fault.cpp:1043
virtual bool run(void)
Run test.
Definition fault.cpp:926
virtual bool run(void)
Run test.
Definition fault.cpp:1053
virtual bool run(void)
Run test.
Definition fault.cpp:1025
virtual bool run(void)
Run test.
Definition fault.cpp:1034
virtual bool run(void)
Run test.
Definition fault.cpp:1064
MiniModelSpace(MiniModelSpace &s)
Definition fault.cpp:262
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:263
static void post(Home home)
Definition fault.cpp:226
virtual Actor * copy(Space &home)
Create copy.
Definition fault.cpp:229
virtual size_t dispose(Space &home)
Delete actor and return its size.
Definition fault.cpp:232
NoticeDisposeSpace(int registered=0, bool fail_next=false)
Definition fault.cpp:243
virtual Space * copy(void)
Copying member function.
Definition fault.cpp:254
NoticeDisposeSpace(NoticeDisposeSpace &s)
Definition fault.cpp:253
void dispose(Space &home, Council< ThrowingAdvisor > &c)
Definition fault.cpp:101
ThrowingAdvisor(Space &home, ThrowingAdvisor &a)
Definition fault.cpp:94
Propagator * owner(void) const
Definition fault.cpp:98
ThrowingAdvisor(Space &home, Propagator &p, Council< ThrowingAdvisor > &c, int id0)
Definition fault.cpp:91
virtual bool status(const Space &) const
Check status of brancher, return true if alternatives left.
Definition fault.cpp:168
virtual ExecStatus commit(Space &, const Choice &, unsigned int)
Commit for choice c and alternative a.
Definition fault.cpp:177
virtual const Choice * choice(Space &)
Return choice.
Definition fault.cpp:171
virtual void print(const Space &, const Choice &, unsigned int, std::ostream &) const
Print branch for choice c and alternative a.
Definition fault.cpp:181
virtual Actor * copy(Space &home)
Create copy.
Definition fault.cpp:183
static void post(Home home)
Definition fault.cpp:165
ThrowingBrancher(Space &home, ThrowingBrancher &b)
Definition fault.cpp:160
virtual const Choice * choice(const Space &, Archive &)
Return choice from e.
Definition fault.cpp:174
virtual size_t dispose(Space &)
Delete actor and return its size.
Definition fault.cpp:186
ThrowingChoice(const Brancher &b)
Definition fault.cpp:150
virtual void archive(Archive &e) const
Archive into e.
Definition fault.cpp:151
virtual PropCost cost(const Space &, const ModEventDelta &) const
Cost function.
Definition fault.cpp:72
static void post(Home home)
Definition fault.cpp:66
ThrowingPropagator(Space &home, ThrowingPropagator &p)
Definition fault.cpp:61
virtual size_t dispose(Space &home)
Delete actor and return its size.
Definition fault.cpp:79
virtual Actor * copy(Space &home)
Create copy.
Definition fault.cpp:69
virtual ExecStatus propagate(Space &home, const ModEventDelta &)
Propagation function.
Definition fault.cpp:76
virtual void reschedule(Space &)
Schedule function.
Definition fault.cpp:75
Heap heap
The single global heap.
Definition heap.cpp:44
ExecStatus ES_SUBSUMED(Propagator &p)
Propagator p is subsumed
Definition core.hpp:3780
void ignore(Actor &a, ActorProperty p, bool duplicate=false)
Ignore actor property.
Definition core.hpp:4321
int ModEventDelta
Modification event deltas.
Definition core.hpp:94
@ AP_DISPOSE
Actor must always be disposed.
Definition core.hpp:569
void branch(Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatValBranch vals, FloatBranchFilter bf=nullptr, FloatVarValPrint vvp=nullptr)
Branch over x with variable selection vars and value selection vals.
Definition branch.cpp:39
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
Space(void)
Default constructor.
Definition core.cpp:121
Space * clone(void) const
Clone space.
Definition core.hpp:3384
const Choice * choice(void)
Create new choice for current brancher.
Definition core.cpp:568
SpaceStatus status(StatusStatistics &stat)
Query space status.
Definition core.cpp:281
void commit(const Choice &c, unsigned int a)
Commit choice c for alternative a.
Definition core.hpp:3398
@ SS_FAILED
Space is failed
Definition core.hpp:1727
Phase
Named phase for deterministic test failure injection.
Definition failpoint.hpp:49
void reset(void)
Reset all failpoint state.
void check(Phase p)
Check failpoint for phase p.
unsigned long long count(void)
Number of checks observed for the configured phase.
void fail_after(Phase p, unsigned long long n)
Fail after n successful checks for phase p.
Gecode toplevel namespace
IntVarBranch INT_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest action divided by domain size with decay factor d.
Definition var.hpp:256
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
IntValBranch INT_VAL_MIN(void)
Select smallest value.
Definition val.hpp:55
SetExpr setunion(const SetVarArgs &)
Union of set variables.
Definition set-expr.cpp:705
ExecStatus
Definition core.hpp:479
@ ES_OK
Execution is okay.
Definition core.hpp:483
@ ES_FIX
Propagation has computed fixpoint.
Definition core.hpp:484
IntVarBranch INT_VAR_CHB_SIZE_MAX(IntCHB c, BranchTbl tbl=nullptr)
Select variable with largest CHB Q-score divided by domain size.
Definition var.hpp:276
IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest domain size.
Definition var.hpp:206
bool dispose_notice_resize_failure_does_not_dispose_unregistered_actor(void)
Definition fault.cpp:851
bool minimodel_failure_releases_default_nodes(void)
Definition fault.cpp:868
bool clone_after_failed_disposal_array(void)
Definition fault.cpp:486
bool linear_sum_constructor_heap_failures_release_nodes(int kind)
Definition fault.cpp:711
bool clone_heap_failures_recover_source(void)
Definition fault.cpp:583
bool dispose_notice_initial_failure_does_not_dispose_actor(void)
Definition fault.cpp:833
HeapReallocation heap_reallocation
Definition fault.cpp:1125
MiniModelSetHeapFailures minimodel_set_heap_failures
Definition fault.cpp:1134
bool clone_after_failed_derived_update(void)
Definition fault.cpp:523
DisposeNoticeArray dispose_notice_array
Definition fault.cpp:1122
HeapAllocation heap_allocation
Definition fault.cpp:1124
MiniModelDefaultNodes minimodel_default_nodes
Definition fault.cpp:1127
bool clone_after_failed_copy(Phase p, unsigned long long n)
Definition fault.cpp:378
CloneHeapFailures clone_heap_failures
Definition fault.cpp:1121
ClonePropagatorCopy clone_propagator_copy
Definition fault.cpp:1136
CloneDisposalArray clone_disposal_array
Definition fault.cpp:1119
bool minimodel_heap_failure_releases_bool_misc(void)
Definition fault.cpp:902
bool minimodel_float_heap_failures_are_recoverable(void)
Definition fault.cpp:776
CloneLocalObjectCopy clone_local_object_copy
Definition fault.cpp:1140
bool heap_reallocation_failpoint_throws(void)
Definition fault.cpp:562
bool clone_after_failed_local_object_copy(void)
Definition fault.cpp:436
MiniModelFloatHeapFailures minimodel_float_heap_failures
Definition fault.cpp:1131
BranchActionHeapFailures branch_action_heap_failures
Definition fault.cpp:1117
bool expect_memory_exhausted(Phase p, unsigned long long n)
Definition fault.cpp:407
MiniModelLinearSumHeapFailures minimodel_linear_sum_heap_failures
Definition fault.cpp:1141
bool branch_post_heap_failures_are_recoverable(bool chb)
Definition fault.cpp:611
Support::Mutex fault_mutex
Definition fault.cpp:44
bool clone_after_failed_advisor_copy(void)
Definition fault.cpp:460
CloneDerivedSpaceUpdate clone_derived_space_update
Definition fault.cpp:1120
bool minimodel_set_heap_failures_are_recoverable(void)
Definition fault.cpp:805
IntSetHeapFailures int_set_heap_failures
Definition fault.cpp:1126
bool derived_update_space_is_usable(DerivedUpdateSpace &s)
Definition fault.cpp:513
bool minimodel_linear_sum_heap_failures_release_nodes(void)
Definition fault.cpp:768
bool int_set_heap_failures_release_object(void)
Definition fault.cpp:650
CloneDerivedSpaceCopy clone_derived_space_copy
Definition fault.cpp:1139
CloneBrancherCopy clone_brancher_copy
Definition fault.cpp:1137
BranchChbHeapFailures branch_chb_heap_failures
Definition fault.cpp:1118
CloneAdvisorCopy clone_advisor_copy
Definition fault.cpp:1138
MiniModelBoolMiscHeapFailure minimodel_bool_misc_heap_failure
Definition fault.cpp:1128
MiniModelHeapFailures minimodel_heap_failures
Definition fault.cpp:1129
DisposeNoticeArrayResize dispose_notice_array_resize
Definition fault.cpp:1123
bool heap_allocation_failpoint_throws(void)
Definition fault.cpp:544
bool minimodel_heap_failures_release_nodes(void)
Definition fault.cpp:680
General test support.
Definition afc.cpp:41