Generated on for Gecode by doxygen 1.17.0
pbs.hpp
Go to the documentation of this file.
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Christian Schulte <schulte@gecode.dev>
5 *
6 * Copyright:
7 * Christian Schulte, 2015
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 <cmath>
35#include <algorithm>
36#include <memory>
38
39namespace Gecode { namespace Search {
40
42 forceinline void
43 pbscleanup(Engine** slaves, Stop** stops, unsigned int n_slaves,
44 Space* master) {
45 for (unsigned int i=0U; i<n_slaves; i++) {
46 delete slaves[i];
47 delete stops[i];
48 }
49 delete master;
50 }
51
53 forceinline void
55 for (int i=0; i<sebs.size(); i++)
56 delete sebs[i];
57 }
58
60 forceinline void
61 pbscontrol(const Options& opt) {
62 if ((opt.assets > 1U) &&
64 throw WorkerControlInUse("PBS::PBS");
65 }
66
68 forceinline int
69 pbsadmitted(const SEBs& sebs, const Options& opt) {
70#ifdef GECODE_HAS_THREADS
71 if (opt.threads > 1.0)
72 return std::min(static_cast<int>(opt.threads),sebs.size());
73#endif
74 return sebs.size();
75 }
76
78 forceinline void
79 pbscontrol(const SEBs& sebs, const Options& opt) {
80 if (opt.worker_control.engaged())
81 throw WorkerControlInUse("PBS::PBS");
82#ifdef GECODE_HAS_THREADS
83 const bool parallel = opt.threads > 1.0;
84#else
85 const bool parallel = false;
86#endif
87 int admitted = pbsadmitted(sebs,opt);
88 for (int i=0; i<admitted; i++) {
89 const WorkerControl& x = sebs[i]->options().worker_control;
90 if (!x.engaged())
91 continue;
92 // Sequential PBS cannot move past an asset blocked by a pause request.
93 if (!parallel)
94 throw WorkerControlInUse("PBS::PBS");
95 for (int j=0; j<i; j++) {
96 const WorkerControl& y = sebs[j]->options().worker_control;
97 if (y.engaged() &&
99 throw WorkerControlInUse("PBS::PBS");
100 }
101 }
102 }
103
108 template<class E>
110 static constexpr bool value = false;
111 };
112
117 template<class T, template<class> class E>
118 struct PbsOwnsCutoff<RBS<T,E> > {
119 static constexpr bool value = true;
120 };
121
126 template<class T, template<class> class E>
127 struct PbsOwnsCutoff<PBS<T,E> > {
128 static constexpr bool value = PbsOwnsCutoff<E<T> >::value;
129 };
130
142 class PbsCutoffs : public HeapAllocated {
143 public:
149 unsigned int n;
151 bool owner;
153 PbsCutoffs(Cutoff* c0) : c(c0), n(1U), owner(false) {}
155 static void release(PbsCutoffs* s) {
156 bool last;
157 {
158 Support::Lock lock(s->m);
159 last = (--s->n == 0U);
160 }
161 if (last) {
162 if (s->owner)
163 delete s->c;
164 delete s;
165 }
166 }
167 };
168
173 class PbsCutoff : public Cutoff {
174 protected:
178 unsigned long long int v;
179 public:
181 PbsCutoff(PbsCutoffs* s0) : s(s0) {
182 Support::Lock lock(s->m);
183 v = (*s->c)();
184 s->n++;
185 }
186
187 unsigned long long int operator ()(void) const override {
188 return v;
189 }
190
191 unsigned long long int operator ++(void) override {
192 Support::Lock lock(s->m);
193 v = ++(*s->c);
194 return v;
195 }
196
197 ~PbsCutoff(void) override {
199 }
200 };
201
210 template<class E>
211 forceinline PbsCutoffs*
212 make_pbs_cutoffs(const Options& opt, unsigned int n_slaves) {
213 if (!PbsOwnsCutoff<E>::value || (opt.cutoff == nullptr) ||
214 (n_slaves < 2U))
215 return nullptr;
216 return new PbsCutoffs(opt.cutoff);
217 }
218
226 forceinline void
228 if (cs == nullptr)
229 return;
230 {
231 Support::Lock lock(cs->m);
232 cs->owner = built;
233 }
235 }
236
238 template<class T, template<class> class E>
239 class PbsBuilder : public Builder {
240 using Builder::opt;
241 public:
243 PbsBuilder(const Options& opt);
245 virtual Engine* operator() (Space* s) const;
246 };
247
248 template<class T, template<class> class E>
249 inline
251 : Builder(opt,E<T>::best) {}
252
253 template<class T, template<class> class E>
254 Engine*
256 return build<T,PBS<T,E> >(s,opt);
257 }
258
259}}
260
262
263namespace Gecode { namespace Search { namespace Seq {
264
267 pbsstop(Stop* so);
268
271 pbsstop(Stop* so, Stop* po);
272
275 pbsengine(Engine** slaves, Stop** stops, unsigned int n_slaves,
276 const Statistics& stat, const Search::Options& opt, bool best);
277
278}}}
279
280namespace Gecode { namespace Search { namespace Par {
281
284 pbsstop(Stop* so, const WorkerControl& control);
285
288 pbsstop(Stop* so, Stop* po, const WorkerControl& control);
289
292 pbsengine(Engine** slaves, Stop** stops, unsigned int n_slaves,
293 const Statistics& stat, bool best);
294
295}}}
296
297namespace Gecode { namespace Search {
298
299 template<class T, template<class> class E>
300 Engine*
301 pbsseq(T* master, const Search::Statistics& stat, Options& opt) {
302 Stop* stop = opt.stop;
303 // Retain each seed: a throwing nested builder may consume its own clone.
304 opt.clone = true;
305 Region r;
306
307 // In case there are more threads than assets requested
308 opt.threads = std::max(floor(opt.threads /
309 static_cast<double>(opt.assets)),1.0);
310
311 unsigned int n_slaves = opt.assets;
312 Engine** slaves = r.alloc<Engine*>(n_slaves);
313 Stop** stops = r.alloc<Stop*>(n_slaves);
314 for (unsigned int i=0U; i<n_slaves; i++) {
315 slaves[i] = nullptr;
316 stops[i] = nullptr;
317 }
318
321
322 Space* unowned_master = master;
323 PbsCutoffs* cutoffs = make_pbs_cutoffs<E<T> >(opt,n_slaves);
324 try {
325 for (unsigned int i=0U; i<n_slaves; i++) {
326 opt.stop = stops[i] = Seq::pbsstop(stop);
327 std::unique_ptr<Space> slave((i == n_slaves-1) ?
328 master : master->clone());
329 if (slave.get() == master)
330 unowned_master = nullptr;
331 (void) slave->slave(i);
332 std::unique_ptr<Cutoff> cutoff;
333 if (cutoffs != nullptr) {
334 cutoff.reset(new PbsCutoff(cutoffs));
335 opt.cutoff = cutoff.get();
336 }
337 slaves[i] = build<T,E>(slave.get(),opt);
338 // The asset owns its cutoff
339 (void) cutoff.release();
340 }
342 slaves,stops,n_slaves,stat,opt,E<T>::best);
343 release_pbs_cutoffs(cutoffs,true);
344 return e;
345 } catch (...) {
346 pbscleanup(slaves,stops,n_slaves,unowned_master);
347 release_pbs_cutoffs(cutoffs,false);
348 throw;
349 }
350 }
351
352 template<class T, template<class> class E>
353 Engine*
354 pbsseq(T* master, SEBs& sebs,
355 const Search::Statistics& stat, Options& opt, bool best) {
356 Region r;
357
358 int n_slaves = sebs.size();
359 Engine** slaves = r.alloc<Engine*>(n_slaves);
360 Stop** stops = r.alloc<Stop*>(n_slaves);
361 for (int i=0; i<n_slaves; i++) {
362 slaves[i] = nullptr;
363 stops[i] = nullptr;
364 }
365
368 static_cast<unsigned int>(n_slaves));
369
370 Space* unowned_master = master;
371 bool builders_owned = true;
372 try {
373 for (int i=0; i<n_slaves; i++) {
374 // Re-configure slave options, the portfolio stop applies as well
375 stops[i] = Seq::pbsstop(sebs[i]->options().stop,opt.stop);
376 sebs[i]->options().stop = stops[i];
377 sebs[i]->options().clone = true;
378 std::unique_ptr<Space> slave((i == n_slaves-1) ?
379 master : master->clone());
380 if (slave.get() == master)
381 unowned_master = nullptr;
382 (void) slave->slave(static_cast<unsigned int>(i));
383 slaves[i] = (*sebs[i])(slave.get());
384 }
385 pbscleanup(sebs);
386 builders_owned = false;
387 return Seq::pbsengine(
388 slaves,stops,static_cast<unsigned int>(n_slaves),stat,opt,best);
389 } catch (...) {
390 if (builders_owned)
391 pbscleanup(sebs);
392 pbscleanup(slaves,stops,static_cast<unsigned int>(n_slaves),
393 unowned_master);
394 throw;
395 }
396 }
397
398#ifdef GECODE_HAS_THREADS
399
400 template<class T, template<class> class E>
401 Engine*
402 pbspar(T* master, const Search::Statistics& stat, Options& opt) {
403 Stop* stop = opt.stop;
404 // Retain each seed: a throwing nested builder may consume its own clone.
405 opt.clone = true;
406 Region r;
407
408 // Limit the number of slaves to the number of threads
409 unsigned int n_slaves = std::min(static_cast<unsigned int>(opt.threads),
410 opt.assets);
411 // Redistribute additional threads to slaves
412 opt.threads = floor(opt.threads / static_cast<double>(n_slaves));
413
416
417 Engine** slaves = r.alloc<Engine*>(n_slaves);
418 Stop** stops = r.alloc<Stop*>(n_slaves);
419 for (unsigned int i=0U; i<n_slaves; i++) {
420 slaves[i] = nullptr;
421 stops[i] = nullptr;
422 }
423
424 Space* unowned_master = master;
425 PbsCutoffs* cutoffs = make_pbs_cutoffs<E<T> >(opt,n_slaves);
426 try {
427 for (unsigned int i=0U; i<n_slaves; i++) {
428 opt.stop = stops[i] = Par::pbsstop(stop,opt.worker_control);
429 std::unique_ptr<Space> slave((i == n_slaves-1) ?
430 master : master->clone());
431 if (slave.get() == master)
432 unowned_master = nullptr;
433 (void) slave->slave(static_cast<unsigned int>(i));
434 std::unique_ptr<Cutoff> cutoff;
435 if (cutoffs != nullptr) {
436 cutoff.reset(new PbsCutoff(cutoffs));
437 opt.cutoff = cutoff.get();
438 }
439 slaves[i] = build<T,E>(slave.get(),opt);
440 // The asset owns its cutoff
441 (void) cutoff.release();
442 }
443 Engine* e = Par::pbsengine(slaves,stops,n_slaves,stat,E<T>::best);
444 release_pbs_cutoffs(cutoffs,true);
445 return e;
446 } catch (...) {
447 pbscleanup(slaves,stops,n_slaves,unowned_master);
448 release_pbs_cutoffs(cutoffs,false);
449 throw;
450 }
451 }
452
453 template<class T, template<class> class E>
454 Engine*
455 pbspar(T* master, SEBs& sebs,
456 const Search::Statistics& stat, Options& opt, bool best) {
457 Region r;
458
459 // Limit the number of slaves to the number of threads
460 int n_slaves = std::min(static_cast<int>(opt.threads),
461 sebs.size());
462
465 static_cast<unsigned int>(n_slaves));
466
467 Engine** slaves = r.alloc<Engine*>(n_slaves);
468 Stop** stops = r.alloc<Stop*>(n_slaves);
469 for (int i=0; i<n_slaves; i++) {
470 slaves[i] = nullptr;
471 stops[i] = nullptr;
472 }
473
474 Space* unowned_master = master;
475 bool builders_owned = true;
476 try {
477 for (int i=0; i<n_slaves; i++) {
478 // Re-configure slave options, the portfolio stop applies as well
479 stops[i] = Par::pbsstop(sebs[i]->options().stop,opt.stop,
480 sebs[i]->options().worker_control);
481 sebs[i]->options().stop = stops[i];
482 sebs[i]->options().clone = true;
483 std::unique_ptr<Space> slave((i == n_slaves-1) ?
484 master : master->clone());
485 if (slave.get() == master)
486 unowned_master = nullptr;
487 (void) slave->slave(static_cast<unsigned int>(i));
488 slaves[i] = (*sebs[i])(slave.get());
489 }
490 pbscleanup(sebs);
491 builders_owned = false;
492 return Par::pbsengine(
493 slaves,stops,static_cast<unsigned int>(n_slaves),stat,best);
494 } catch (...) {
495 if (builders_owned)
496 pbscleanup(sebs);
497 pbscleanup(slaves,stops,static_cast<unsigned int>(n_slaves),
498 unowned_master);
499 throw;
500 }
501 }
502
503#endif
504
505}}
506
507namespace Gecode {
508
509 template<class T, template<class> class E>
511 Search::Options opt(o.expand());
512
513 if (opt.assets == 0)
514 throw Search::NoAssets("PBS::PBS");
516
518
519 if (s->status(stat) == SS_FAILED) {
520 stat.fail++;
521 if (!opt.clone)
522 delete s;
523 e = Search::Seq::dead(opt,stat);
524 /*
525 * The assets would own the cutoff, but a dead engine does not take
526 * it. This includes the cutoff of an outer portfolio when this is
527 * one of its assets.
528 */
529 if (Search::PbsOwnsCutoff<E<T> >::value)
530 delete opt.cutoff;
531 return;
532 }
533
534 // Check whether a clone must be used
535 T* master = opt.clone ?
536 dynamic_cast<T*>(s->clone()) : s;
537 opt.clone = false;
538
539 // Always execute master function
540 (void) master->master(0);
541
542 // No need to create a portfolio engine but must run slave function
543 if (o.assets == 1) {
544 std::unique_ptr<T> seed(master);
545 (void) master->slave(0);
546 // Retain the seed if a nested builder rejects its worker control.
547 opt.clone = true;
548 e = Search::build<T,E>(seed.get(),opt);
549 return;
550 }
551
552#ifdef GECODE_HAS_THREADS
553 if (opt.threads > 1.0)
554 e = Search::pbspar<T,E>(master,stat,opt);
555 else
556#endif
557 e = Search::pbsseq<T,E>(master,stat,opt);
558 }
559
560 template<class T, template<class> class E>
561 void
562 PBS<T,E>::build(T* s, SEBs& sebs, const Search::Options& o) {
563 Search::Options opt(o.expand());
564 Search::pbscontrol(sebs,opt);
565
566 // Check whether all sebs do either best solution search or not
567 bool best;
568 {
569 int b = 0;
570 for (int i=0; i<sebs.size(); i++)
571 b += sebs[i]->best() ? 1 : 0;
572 if ((b > 0) && (b < sebs.size()))
573 throw Search::MixedBest("PBS::PBS");
574 best = (b == sebs.size());
575 }
576
578
579 if (s->status(stat) == SS_FAILED) {
580 stat.fail++;
581 if (!opt.clone)
582 delete s;
583 Search::pbscleanup(sebs);
584 e = Search::Seq::dead(opt,stat);
585 return;
586 }
587
588 // Check whether a clone must be used
589 T* master = opt.clone ?
590 dynamic_cast<T*>(s->clone()) : s;
591 opt.clone = false;
592
593 // Always execute master function
594 (void) master->master(0);
595
596#ifdef GECODE_HAS_THREADS
597 if (opt.threads > 1.0)
598 e = Search::pbspar<T,E>(master,sebs,stat,opt,best);
599 else
600#endif
601 e = Search::pbsseq<T,E>(master,sebs,stat,opt,best);
602 }
603
604 template<class T, template<class> class E>
605 inline
606 PBS<T,E>::PBS(T* s, SEBs& sebs, const Search::Options& o) {
607 build(s,sebs,o);
608 }
609
610 template<class T, template<class> class E>
611 inline void
613 e->constrain(b);
614 }
615
616 template<class T, template<class> class E>
617 inline T*
618 pbs(T* s, const Search::Options& o) {
619 PBS<T,E> r(s,o);
620 return r.next();
621 }
622
623 template<class T, template<class> class E>
624 inline SEB
626 return new Search::PbsBuilder<T,E>(o);
627 }
628
629}
630
631// STATISTICS: search-other
int size(void) const
Return size of array (number of elements).
Definition array.hpp:1606
Base class for heap allocated objects.
Definition heap.hpp:344
void assets(unsigned int n)
Set default number of assets in a portfolio.
Definition options.hpp:404
void threads(double n)
Set number of parallel threads.
Definition options.hpp:330
Meta engine using a portfolio of search engines.
Definition search.hh:1563
void constrain(const T &b)
Constrain future portfolio solutions to be better than b.
Definition pbs.hpp:612
void build(T *s, SEBs &sebs, const Search::Options &o)
The actual build function.
Definition pbs.hpp:562
PBS(T *s, const Search::Options &o=Search::Options::def)
Initialize with engines running copies of s with options o.
Definition pbs.hpp:510
static const bool best
Whether engine does best solution search.
Definition search.hh:1589
Meta-engine performing restart-based search.
Definition search.hh:1471
Handle to region.
Definition region.hpp:55
Passing search engine builder arguments.
Definition search.hh:1177
@ PBS
Engine is a PBS engine.
Definition search.hh:206
Engine * e
The actual search engine.
Definition search.hh:1107
Options opt
Stored and already expanded options.
Definition search.hh:1143
Builder(const Options &opt, bool best)
Initialize with options opt and best solution search support.
Definition build.hpp:37
bool best(void) const
Whether engine is a best solution search engine.
Definition build.hpp:48
Base class for cutoff generators for restart-based meta engine.
Definition search.hh:480
Cutoff(void)
Default constructor.
Definition cutoff.hpp:41
Search engine implementation interface
Definition search.hh:1063
Exception: Mixed non-best and best solution search requested
Definition exception.hpp:54
Exception: No assets requested for portfolio-based search
Definition exception.hpp:48
Search engine options
Definition search.hh:848
WorkerControl worker_control
Definition search.hh:861
bool clone
Whether engines create a clone when being initialized.
Definition search.hh:851
Cutoff * cutoff
Cutoff for restart-based search.
Definition search.hh:877
Options expand(void) const
Expand with real number of threads.
Definition options.cpp:43
Stop * stop
Stop object for stopping search.
Definition search.hh:875
SearchTracer * tracer
Tracer object for tracing search.
Definition search.hh:879
unsigned int assets
Number of assets (engines) in a portfolio.
Definition search.hh:869
double threads
Number of threads to use.
Definition search.hh:853
Parallel depth-first search engine
Definition engine.hh:52
A PBS engine builder.
Definition pbs.hpp:239
PbsBuilder(const Options &opt)
The constructor.
Definition pbs.hpp:250
virtual Engine * operator()(Space *s) const
The actual build function.
Definition pbs.hpp:255
Cutoff of a portfolio asset, the assets share the sequence of values.
Definition pbs.hpp:173
unsigned long long int operator()(void) const override
Return the current cutoff value.
Definition pbs.hpp:187
unsigned long long int v
The current cutoff value of this asset.
Definition pbs.hpp:178
~PbsCutoff(void) override
Release the reference to the shared sequence.
Definition pbs.hpp:197
PbsCutoffs * s
The shared sequence.
Definition pbs.hpp:176
unsigned long long int operator++(void) override
Take the next value of the shared sequence and return it.
Definition pbs.hpp:191
PbsCutoff(PbsCutoffs *s0)
Initialize as a new reference to s0.
Definition pbs.hpp:181
Cutoff sequence shared by the assets of a portfolio.
Definition pbs.hpp:142
Support::Mutex m
Mutex protecting the sequence, assets can run in parallel.
Definition pbs.hpp:145
unsigned int n
Number of references.
Definition pbs.hpp:149
PbsCutoffs(Cutoff *c0)
Initialize for cutoff c0 with the reference held while building.
Definition pbs.hpp:153
Cutoff * c
The shared cutoff sequence.
Definition pbs.hpp:147
static void release(PbsCutoffs *s)
Release a reference.
Definition pbs.hpp:155
bool owner
Whether the cutoff sequence is disposed with the last reference.
Definition pbs.hpp:151
Search engine statistics
Definition search.hh:155
unsigned long long int fail
Number of failed nodes in search tree.
Definition search.hh:158
Base-class for Stop-object.
Definition search.hh:919
static bool same_identity(const WorkerControl &x, const WorkerControl &y)
Return whether x and y share one control identity.
Exception: Worker control is already bound or used in an unsupported engine
Definition exception.hpp:78
External control for the requested number of search workers.
Definition search.hh:773
bool engaged(void) const noexcept
Whether this handle is engaged.
static void engine(SearchTracer *tracer, SearchTracer::EngineType t, unsigned int n)
Register engine.
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
virtual bool slave(const MetaInfo &mi)
Slave configuration function for meta search engines.
Definition core.cpp:918
T * pbs(T *s, const Search::Options &o=Search::Options::def)
Run a portfolio of search engines.
Definition pbs.hpp:618
@ SS_FAILED
Space is failed
Definition core.hpp:1727
Engine * pbsengine(Engine **slaves, Stop **stops, unsigned int n_slaves, const Statistics &stat, bool best)
Create parallel portfolio engine.
Definition pbs.cpp:76
Stop * pbsstop(Stop *so, const WorkerControl &control)
Create stop object.
Definition pbs.cpp:66
Engine * dead(const Options &o, const Statistics &stat)
Definition dead.cpp:90
Stop * pbsstop(Stop *so)
Create stop object.
Definition pbs.cpp:39
Engine * pbsengine(Engine **slaves, Stop **stops, unsigned int n_slaves, const Statistics &stat, const Search::Options &opt, bool best)
Create sequential portfolio engine.
Definition pbs.cpp:49
Search engines
int pbsadmitted(const SEBs &sebs, const Options &opt)
Return the number of explicit builders admitted by this portfolio.
Definition pbs.hpp:69
void release_pbs_cutoffs(PbsCutoffs *cs, bool built)
Release the cutoffs cs held while building.
Definition pbs.hpp:227
Engine * build(Space *s, const Options &opt)
Build an engine of type E for a script T.
Definition build.hpp:55
PbsCutoffs * make_pbs_cutoffs(const Options &opt, unsigned int n_slaves)
Return the cutoffs shared by the assets of a portfolio.
Definition pbs.hpp:212
void pbscleanup(Engine **slaves, Stop **stops, unsigned int n_slaves, Space *master)
Dispose partially constructed portfolio assets.
Definition pbs.hpp:43
Engine * pbspar(T *master, const Search::Statistics &stat, Options &opt)
Definition pbs.hpp:402
void pbscontrol(const Options &opt)
Validate worker-control placement for a homogeneous portfolio.
Definition pbs.hpp:61
Engine * pbsseq(T *master, const Search::Statistics &stat, Options &opt)
Definition pbs.hpp:301
Gecode toplevel namespace
Search::Builder * SEB
Type for a search engine builder.
Definition search.hh:1168
#define GECODE_SEARCH_EXPORT
Definition search.hh:75
Whether engine E takes ownership of the cutoff in its options.
Definition pbs.hpp:109
static constexpr bool value
Definition pbs.hpp:110
#define forceinline
Definition config.hpp:144