SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
concurrent.c
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file concurrent.c
26 * @ingroup PARALLEL
27 * @brief helper functions for concurrent SCIP solvers
28 * @author Leona Gottwald
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#include "scip/concurrent.h"
35#include "scip/concsolver.h"
36#include "scip/event.h"
37#include "scip/struct_scip.h"
38#include "scip/stat.h"
39#include "scip/struct_set.h"
40#include "scip/struct_primal.h"
41#include "scip/struct_stat.h"
42#include "scip/struct_sol.h"
43#include "scip/struct_prop.h"
44#include "scip/struct_heur.h"
45#include "scip/struct_sepa.h"
46#include "scip/struct_presol.h"
47#include "scip/prob.h"
48#include "scip/prop_sync.h"
49#include "scip/heur_sync.h"
51#include "scip/scip.h"
52#include "scip/syncstore.h"
53#include "scip/set.h"
54#include "tpi/tpi.h"
55
56/** create concurrent data */
58 SCIP* scip, /**< SCIP datastructure */
59 SCIP_CONCSOLVER* concsolver, /**< concurrent solver of given SCIP instance */
60 int* varperm /**< permutation of variables for communication */
61 )
62{
63 int nvars;
64
65 assert(scip != NULL);
66 assert(concsolver != NULL);
67 assert(varperm != NULL);
68 assert(scip->concurrent == NULL);
69
70 SCIP_CALL( SCIPallocBlockMemory(scip, &scip->concurrent) );
71
73 scip->concurrent->varperm = NULL;
74
75 SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &scip->concurrent->varperm, varperm, nvars) );
76
77 scip->concurrent->concsolver = concsolver;
78 scip->concurrent->mainscip = scip;
79 scip->concurrent->solidx = scip->stat->solindex;
80 scip->stat->subscipdepth = 0;
81
82 if( scip->set->parallel_mode == (int) SCIP_PARA_DETERMINISTIC )
83 {
84 scip->concurrent->dettime = 0.0;
85 scip->concurrent->wallclock = NULL;
86 }
87 else
88 {
89 SCIP_CALL( SCIPcreateWallClock(scip, &scip->concurrent->wallclock) );
90 SCIP_CALL( SCIPstartClock(scip, scip->concurrent->wallclock) );
91 }
92
93 assert(SCIPfindHeur(scip, "sync") == NULL);
94
96 scip->concurrent->heursync = SCIPfindHeur(scip, "sync");
97
98 assert(SCIPfindProp(scip, "sync") == NULL);
99
101 scip->concurrent->propsync = SCIPfindProp(scip, "sync");
102
103 scip->concurrent->eventglobalbnd = NULL;
104 assert(SCIPfindEventhdlr(scip, "globalbnd") == NULL);
105
106 if( scip->set->concurrent_commvarbnds )
107 {
109 scip->concurrent->eventglobalbnd = SCIPfindEventhdlr(scip, "globalbnd");
110 }
111
112 return SCIP_OKAY;
113}
114
115/** get number of initialized concurrent solvers */
117 SCIP* scip /**< SCIP datastructure */
118 )
119{
120 assert(scip != NULL);
121 assert(scip->set != NULL);
122
123 return scip->set->nconcsolvers;
124}
125
126/** gets the initialized concurrent solvers */
128 SCIP* scip /**< SCIP datastructure */
129 )
130{
131 assert(scip != NULL);
132 assert(scip->set != NULL);
133
134 return scip->set->concsolvers;
135}
136
137/** adds an initialized concurrent solver */
139 SCIP* scip, /**< SCIP datastructure */
140 SCIP_CONCSOLVER* concsolver /**< concurrent solver of given SCIP instance */
141 )
142{
143 assert(scip != NULL);
144
145 SCIP_CALL( SCIPsetIncludeConcsolver(scip->set, concsolver) );
146
147 return SCIP_OKAY;
148}
149
150/** frees concurrent data */
152 SCIP* scip /**< SCIP datastructure */
153 )
154{
155 assert(scip != NULL);
156
157 if( scip->concurrent == NULL )
158 return SCIP_OKAY;
159
160 assert(scip->concurrent->varperm != NULL);
161
162 /* check if we are the SCIP that is responsible for freeing this concurrent struct
163 * or just a subscip */
164 if( scip->concurrent->mainscip != scip )
165 {
166 /* we are just a subscip, so don't free the concurrent structure and add the
167 * deterministic time that was counted in the subscip but not yet added to the main SCIP */
168 scip->concurrent->mainscip->stat->detertimecnt += scip->stat->detertimecnt;
169 scip->stat->detertimecnt = 0;
170 scip->concurrent = NULL;
171 }
172 else
173 {
174 /* we are in the main SCIP so free the concurrent structure */
175 if( scip->concurrent->wallclock != NULL )
176 {
177 SCIP_CALL( SCIPfreeClock(scip, &scip->concurrent->wallclock) );
178 }
179
180 SCIPfreeBlockMemoryArray(scip, &scip->concurrent->varperm, SCIPgetNOrigVars(scip));
181
182 SCIPfreeBlockMemory(scip, &scip->concurrent);
183 }
184
185 return SCIP_OKAY;
186}
187
188/** increments the time counter for synchronization */
190 SCIP* scip, /**< SCIP datastructure */
191 SCIP_Real val /**< value by which the time counter for synchronization is incremented */
192 )
193{
194 SCIP_Real syncfreq;
195 SCIP* mainscip;
196 SCIP_CLOCK* wallclock;
197
198 assert(scip != NULL);
199
200 if( scip->concurrent == NULL )
201 return SCIP_OKAY;
202
203 syncfreq = SCIPconcsolverGetSyncFreq(scip->concurrent->concsolver);
204 wallclock = scip->concurrent->wallclock;
205 mainscip = scip->concurrent->mainscip;
206
207 if( wallclock == NULL )
208 {
209 scip->concurrent->dettime += val;
210
211 if( scip->concurrent->dettime >= syncfreq )
212 {
214 SCIPconcsolverSetTimeSinceLastSync(scip->concurrent->concsolver, scip->concurrent->dettime);
215 scip->concurrent->dettime = 0.0;
217 SCIP_CALL( SCIPeventqueueAdd(mainscip->eventqueue, SCIPblkmem(mainscip), mainscip->set,
218 NULL, NULL, NULL, mainscip->eventfilter, &event) );
219 }
220 }
221 else
222 {
223 SCIP_Real timesincelastsync;
224 timesincelastsync = SCIPgetClockTime(mainscip, wallclock);
225
226 if( timesincelastsync >= syncfreq )
227 {
229 SCIPconcsolverSetTimeSinceLastSync(scip->concurrent->concsolver, timesincelastsync);
230
232 SCIP_CALL( SCIPeventqueueAdd(mainscip->eventqueue, SCIPblkmem(mainscip), mainscip->set,
233 NULL, NULL, NULL, mainscip->eventfilter, &event) );
234
235 SCIP_CALL( SCIPresetClock(mainscip, wallclock) );
236 SCIP_CALL( SCIPstartClock(mainscip, wallclock) );
237 }
238 }
239
240 return SCIP_OKAY;
241}
242
243
244/** synchronize with other concurrent solvers */
246 SCIP* scip /**< SCIP datastructure */
247 )
248{
249 assert(scip != NULL);
250 assert(scip->concurrent != NULL);
251
252 SCIP_CALL( SCIPconcsolverSync(scip->concurrent->concsolver, scip->concurrent->mainscip->set) );
253
254 scip->concurrent->mainscip->concurrent->solidx = scip->concurrent->mainscip->stat->solindex;
255
256 if( scip->concurrent->eventglobalbnd != NULL )
257 SCIPeventGlobalbndClearBoundChanges(scip->concurrent->eventglobalbnd);
258
259 return SCIP_OKAY;
260}
261
262/** disables storing global bound changes */
264 SCIP* scip /**< SCIP data structure */
265 )
266{
267 assert(scip != NULL);
268 assert(scip->concurrent != NULL);
269
270 if( scip->concurrent->eventglobalbnd != NULL )
271 SCIPeventGlobalbndDisableBoundStorage(scip->concurrent->eventglobalbnd);
272}
273
274/** enables storing global bound changes */
276 SCIP* scip /**< SCIP data structure */
277 )
278{
279 assert(scip != NULL);
280 assert(scip->concurrent != NULL);
281
282 if( scip->concurrent->eventglobalbnd != NULL )
283 SCIPeventGlobalbndEnableBoundStorage(scip->concurrent->eventglobalbnd);
284}
285
286/** gets total memory usage of all concurrent solvers together */
288 SCIP* scip /**< SCIP data structure */
289 )
290{
291 SCIP_Longint memtotal = SCIPgetMemTotal(scip);
292
293 assert(scip != NULL);
294
295 if( scip->concurrent == NULL || scip->concurrent->mainscip != scip || scip->concurrent->concsolver == NULL )
296 return memtotal;
297 else
298 {
299 SCIP_Longint concmemtotal = SCIPconcsolverGetMemTotal(scip->concurrent->concsolver);
300 return MAX(memtotal, concmemtotal);
301 }
302}
303
304/** gets the dualbound in the last synchronization */
306 SCIP* scip /**< SCIP data structure */
307 )
308{
309 SCIP_SYNCSTORE* syncstore;
310
311 assert(scip != NULL);
312
313 syncstore = SCIPgetSyncstore(scip);
314 assert(syncstore != NULL);
315
316 return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPsyncstoreGetLastLowerbound(syncstore));
317}
318
319/** gets the primalbound in the last synchronization */
321 SCIP* scip /**< SCIP data structure */
322 )
323{
324 SCIP_SYNCSTORE* syncstore;
325
326 assert(scip != NULL);
327
328 syncstore = SCIPgetSyncstore(scip);
329 assert(syncstore != NULL);
330
331 return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPsyncstoreGetLastUpperbound(syncstore));
332}
333
334/** gets the gap in the last synchronization */
336 SCIP* scip /**< SCIP data structure */
337 )
338{
339 SCIP_Real primalbound;
340 SCIP_Real dualbound;
341
343 dualbound = SCIPgetConcurrentDualbound(scip);
344
346}
347
348/** gives the total number of tightened bounds received from other concurrent solvers */
350 SCIP* scip /**< SCIP data structure */
351 )
352{
353 assert(scip->concurrent != NULL);
354
355 return scip->concurrent->propsync != NULL ? SCIPpropSyncGetNTightenedBnds(scip->concurrent->propsync) : 0;
356}
357
358/** gives the total number of tightened bounds for integer variables received from
359 * other concurrent solvers */
361 SCIP* scip /**< SCIP data structure */
362 )
363{
364 assert(scip->concurrent != NULL);
365
366 return scip->concurrent->propsync != NULL ? SCIPpropSyncGetNTightenedIntBnds(scip->concurrent->propsync) : 0;
367}
368
369/** pass a solution to the given SCIP instance using that was received via synchronization by using
370 * the sync heuristic */
372 SCIP* scip, /**< SCIP datastructure */
373 SCIP_SOL* sol /**< solution */
374 )
375{
376 assert(scip != NULL);
377 assert(scip->concurrent != NULL);
378 assert(sol != NULL);
379
380 SCIP_CALL( SCIPheurSyncPassSol(scip, scip->concurrent->heursync, sol) );
381
382 return SCIP_OKAY;
383}
384
385/** adds a global boundchange to the given SCIP, by passing it to the sync propagator */
387 SCIP* scip, /**< SCIP data structure */
388 SCIP_VAR* var, /**< variable for bound */
389 SCIP_Real val, /**< value of bound */
390 SCIP_BOUNDTYPE bndtype /**< type of bound */
391 )
392{
393 assert(scip != NULL);
394 assert(var != NULL);
395 assert(scip->concurrent != NULL);
396 assert(scip->concurrent->propsync != NULL);
397
398 SCIP_CALL( SCIPpropSyncAddBndchg(scip->concurrent->mainscip, scip->concurrent->propsync, var, val, bndtype) );
399
400 return SCIP_OKAY;
401}
402
403/** copy the nodenumber, depth, time, and runnumber of one solution to another one */
405 SCIP_SOL* source, /**< source for solution statistics */
406 SCIP_SOL* target /**< target for solution statistics */
407 )
408{
409 assert(source != NULL);
410 assert(target != NULL);
411
412 target->depth = source->depth;
413 target->time = source->time;
414 target->nodenum = source->nodenum;
415 target->runnum = source->runnum;
416
417 return SCIP_OKAY;
418}
419
420
421/** get variable index of original variable that is the same between concurrent solvers */
423 SCIP* scip, /**< SCIP data structure */
424 SCIP_VAR* var /**< variable */
425 )
426{
427 assert(scip != NULL);
428 assert(scip->concurrent != NULL);
429 assert(scip->concurrent->varperm != NULL);
430 assert(var != NULL);
433
434 return scip->concurrent->varperm[SCIPvarGetIndex(var)];
435}
436
437/** is the solution new since the last synchronization point */
439 SCIP* scip, /**< SCIP data structure */
440 SCIP_SOL* sol /**< the solution */
441 )
442{
443 assert(scip != NULL);
444 assert(scip->concurrent != NULL);
445 assert(sol != NULL);
446
447 return SCIPsolGetIndex(sol) >= scip->concurrent->solidx;
448}
449
450/** gets the global lower bound changes since the last synchronization point */
452 SCIP* scip /**< SCIP data structure */
453 )
454{
455 assert(scip != NULL);
456 assert(scip->concurrent != NULL);
457
458 if( scip->concurrent->eventglobalbnd != NULL )
459 return SCIPeventGlobalbndGetBoundChanges(scip->concurrent->eventglobalbnd);
460
461 return NULL;
462}
463
464/** executes the concurrent solver corresponding to the current thread */
465static
467 void* args /**< SCIP data structure passed in as a void pointer */
468 )
469{
470 SCIP* scip;
471
472 assert(args != NULL);
473
474 scip = (SCIP*) args;
475
476 SCIP_CALL( SCIPconcsolverExec(scip->set->concsolvers[SCIPtpiGetThreadNum()]) );
477 SCIP_CALL( SCIPconcsolverSync(scip->set->concsolvers[SCIPtpiGetThreadNum()], scip->set) );
478
479 return SCIP_OKAY;
480}
481
482/** start solving in parallel using the given set of concurrent solvers */
484 SCIP* scip /**< pointer to scip datastructure */
485 )
486{
487 SCIP_SYNCSTORE* syncstore;
488 int idx;
489 int jobid;
490 int i;
491 SCIP_RETCODE retcode;
492 SCIP_CONCSOLVER** concsolvers;
493 int nconcsolvers;
494
495 assert(scip != NULL);
496
497 syncstore = SCIPgetSyncstore(scip);
498 concsolvers = scip->set->concsolvers;
499 nconcsolvers = scip->set->nconcsolvers;
500
502 assert(SCIPsyncstoreGetNSolvers(syncstore) == nconcsolvers);
503
505 jobid = SCIPtpiGetNewJobID();
506
508 {
510 {
511 for( i = 0; i < nconcsolvers; ++i )
512 {
513 /* cppcheck-suppress unassignedVariable */
514 SCIP_JOB* job;
515 SCIP_SUBMITSTATUS status;
516
519
520 assert(status == SCIP_SUBMIT_SUCCESS);
521 }
522 }
523 }
524
525 retcode = SCIPtpiCollectJobs(jobid);
526 idx = SCIPsyncstoreGetWinner(syncstore);
527 assert(idx >= 0 && idx < nconcsolvers);
528
529 /* a paranoid safeguard for running in optimized mode */
530 if( idx < 0 || idx >= nconcsolvers )
531 idx = 0;
532
533 SCIP_CALL( SCIPconcsolverGetSolvingData(concsolvers[idx], scip) );
534
535 return retcode;
536}
537
538/** copy solving statistics */
540 SCIP* source, /**< SCIP data structure */
541 SCIP* target /**< target SCIP data structure */
542 )
543{
544 SCIP_Real tmptime;
545 SCIP_HEUR* heur;
546 SCIP_NODE* root;
547 SCIP_PROP* prop;
548 SCIP_SEPA* sepa;
550 SCIP_HEUR** heurs;
551 int nheurs;
552 SCIP_PROP** props;
553 int nprops;
554 SCIP_SEPA** sepas;
555 int nsepas;
556 SCIP_PRESOL** presols;
557 int npresols;
558 int i;
559
560 assert(source != NULL);
561 assert(target != NULL);
562
563 heurs = SCIPgetHeurs(target);
564 nheurs = SCIPgetNHeurs(target);
565
566 for( i = 0; i < nheurs; ++i )
567 {
568 heur = SCIPfindHeur(source, SCIPheurGetName(heurs[i]));
569
570 if( heur != NULL )
571 {
572 heurs[i]->nbestsolsfound += heur->nbestsolsfound;
573 heurs[i]->ncalls += heur->ncalls;
574 heurs[i]->nsolsfound += heur->nsolsfound;
575 /* TODO divesets */
576 tmptime = SCIPgetClockTime(target, heurs[i]->setuptime);
578 SCIP_CALL( SCIPsetClockTime(target, heurs[i]->setuptime, tmptime) );
579
580 tmptime = SCIPgetClockTime(target, heurs[i]->heurclock);
582 SCIP_CALL( SCIPsetClockTime(target, heurs[i]->heurclock, tmptime) );
583 }
584 }
585
586 props = SCIPgetProps(target);
587 nprops = SCIPgetNProps(target);
588
589 for( i = 0; i < nprops; ++i )
590 {
591 prop = SCIPfindProp(source, SCIPpropGetName(props[i]));
592
593 if( prop != NULL )
594 {
595 props[i]->ncalls += prop->ncalls;
596 props[i]->nrespropcalls += prop->nrespropcalls;
597 props[i]->ncutoffs += prop->ncutoffs;
598 props[i]->ndomredsfound += prop->ndomredsfound;
599
600 tmptime = SCIPgetClockTime(target, props[i]->proptime);
602 SCIP_CALL( SCIPsetClockTime(target, props[i]->proptime, tmptime) );
603
604 tmptime = SCIPgetClockTime(target, props[i]->sbproptime);
606 SCIP_CALL( SCIPsetClockTime(target, props[i]->sbproptime, tmptime) );
607
608 tmptime = SCIPgetClockTime(target, props[i]->resproptime);
610 SCIP_CALL( SCIPsetClockTime(target, props[i]->resproptime, tmptime) );
611
612 tmptime = SCIPgetClockTime(target, props[i]->presoltime);
614 SCIP_CALL( SCIPsetClockTime(target, props[i]->presoltime, tmptime) );
615
616 tmptime = SCIPgetClockTime(target, props[i]->setuptime);
618 SCIP_CALL( SCIPsetClockTime(target, props[i]->setuptime, tmptime) );
619 }
620 }
621
622 presols = SCIPgetPresols(target);
623 npresols = SCIPgetNPresols(target);
624
625 for( i = 0; i < npresols; ++i )
626 {
628
629 if( presol != NULL )
630 {
631 presols[i]->ncalls += presol->ncalls;
632 presols[i]->nfixedvars += presol->nfixedvars;
633 presols[i]->naggrvars += presol->naggrvars;
634 presols[i]->nchgvartypes += presol->nchgvartypes;
635 presols[i]->nchgbds += presol->nchgbds;
636 presols[i]->naddholes += presol->naddholes;
637 presols[i]->ndelconss += presol->ndelconss;
638 presols[i]->naddconss += presol->naddconss;
639 presols[i]->nupgdconss += presol->nupgdconss;
640 presols[i]->nchgcoefs += presol->nchgcoefs;
641 presols[i]->nchgsides += presol->nchgsides;
642 presols[i]->nfixedvars += presol->nfixedvars;
643 presols[i]->nfixedvars += presol->nfixedvars;
644 presols[i]->nfixedvars += presol->nfixedvars;
645
646 tmptime = SCIPgetClockTime(target, presols[i]->setuptime);
647 tmptime += SCIPgetClockTime(source, presol->setuptime);
648 SCIP_CALL( SCIPsetClockTime(target, presols[i]->setuptime, tmptime) );
649
650 tmptime = SCIPgetClockTime(target, presols[i]->presolclock);
651 tmptime += SCIPgetClockTime(source, presol->presolclock);
652 SCIP_CALL( SCIPsetClockTime(target, presols[i]->presolclock, tmptime) );
653 }
654 }
655
656 sepas = SCIPgetSepas(target);
657 nsepas = SCIPgetNSepas(target);
658
659 for( i = 0; i < nsepas; ++i )
660 {
661 sepa = SCIPfindSepa(source, SCIPsepaGetName(sepas[i]));
662
663 if( sepa != NULL )
664 {
665 sepas[i]->lastsepanode = sepa->lastsepanode;
666 sepas[i]->ncalls += sepa->ncalls;
667 sepas[i]->nrootcalls += sepa->nrootcalls;
668 sepas[i]->ncutoffs += sepa->ncutoffs;
669 sepas[i]->ncutsfound += sepa->ncutsfound;
670 sepas[i]->ncutsaddedviapool += sepa->ncutsaddedviapool;
671 sepas[i]->ncutsaddeddirect += sepa->ncutsaddeddirect;
673 sepas[i]->ncutsapplieddirect += sepa->ncutsapplieddirect;
674 sepas[i]->nconssfound += sepa->nconssfound;
675 sepas[i]->ndomredsfound += sepa->ndomredsfound;
676 sepas[i]->maxbounddist = MAX(sepas[i]->maxbounddist, sepa->maxbounddist);
677
678 tmptime = SCIPgetClockTime(target, sepas[i]->setuptime);
680 SCIP_CALL( SCIPsetClockTime(target, sepas[i]->setuptime, tmptime) );
681
682 tmptime = SCIPgetClockTime(target, sepas[i]->sepaclock);
684 SCIP_CALL( SCIPsetClockTime(target, sepas[i]->sepaclock, tmptime) );
685 }
686 }
687
688 target->primal->nsolsfound = source->primal->nsolsfound;
689 target->primal->nbestsolsfound = source->primal->nbestsolsfound;
690 target->primal->nlimsolsfound = source->primal->nlimsolsfound;
692 root = SCIPgetRootNode(target);
693
694 if( root != NULL )
695 {
696 /* in the copied SCIP the dualbound is in the transformed space of the target */
698 }
699
700 target->stat->nlpiterations = source->stat->nlpiterations;
701 target->stat->nrootlpiterations = source->stat->nrootlpiterations;
702 target->stat->nrootfirstlpiterations = source->stat->nrootfirstlpiterations;
703 target->stat->nprimallpiterations = source->stat->nprimallpiterations;
704 target->stat->nduallpiterations = source->stat->nduallpiterations;
705 target->stat->nlexduallpiterations = source->stat->nlexduallpiterations;
706 target->stat->nbarrierlpiterations = source->stat->nbarrierlpiterations;
707 target->stat->nprimalresolvelpiterations = source->stat->nprimalresolvelpiterations;
708 target->stat->ndualresolvelpiterations = source->stat->ndualresolvelpiterations;
709 target->stat->nlexdualresolvelpiterations = source->stat->nlexdualresolvelpiterations;
710 target->stat->nnodelpiterations = source->stat->nnodelpiterations;
711 target->stat->ninitlpiterations = source->stat->ninitlpiterations;
712 target->stat->ndivinglpiterations = source->stat->ndivinglpiterations;
713 target->stat->ndivesetlpiterations = source->stat->ndivesetlpiterations;
714 target->stat->nsbdivinglpiterations = source->stat->nsbdivinglpiterations;
715 target->stat->nsblpiterations = source->stat->nsblpiterations;
716 target->stat->nrootsblpiterations = source->stat->nrootsblpiterations;
717 target->stat->nconflictlpiterations = source->stat->nconflictlpiterations;
718 target->stat->nnodes = source->stat->nnodes;
719 target->stat->ninternalnodes = source->stat->ninternalnodes;
720 target->stat->nobjleaves = source->stat->nobjleaves;
721 target->stat->nfeasleaves = source->stat->nfeasleaves;
722 target->stat->ninfeasleaves = source->stat->ninfeasleaves;
723 target->stat->ntotalnodes = source->stat->ntotalnodes;
724 target->stat->ntotalinternalnodes = source->stat->ntotalinternalnodes;
725 target->stat->ncreatednodes = source->stat->ncreatednodes;
726 target->stat->ncreatednodesrun = source->stat->ncreatednodesrun;
727 target->stat->nactivatednodes = source->stat->nactivatednodes;
728 target->stat->ndeactivatednodes = source->stat->ndeactivatednodes;
729 target->stat->nearlybacktracks = source->stat->nearlybacktracks;
730 target->stat->nnodesaboverefbound = source->stat->nnodesaboverefbound;
731 target->stat->nbacktracks = source->stat->nbacktracks;
732 target->stat->ndelayedcutoffs = source->stat->ndelayedcutoffs;
733 target->stat->nreprops = source->stat->nreprops;
734 target->stat->nrepropboundchgs = source->stat->nrepropboundchgs;
735 target->stat->nrepropcutoffs = source->stat->nrepropcutoffs;
736 target->stat->nlpsolsfound = source->stat->nlpsolsfound;
737 target->stat->npssolsfound = source->stat->npssolsfound;
738 target->stat->nsbsolsfound = source->stat->nsbsolsfound;
739 target->stat->nlpbestsolsfound = source->stat->nlpbestsolsfound;
740 target->stat->npsbestsolsfound = source->stat->npsbestsolsfound;
741 target->stat->nsbbestsolsfound = source->stat->nsbbestsolsfound;
742 target->stat->nexternalsolsfound = source->stat->nexternalsolsfound;
743 target->stat->lastdispnode = source->stat->lastdispnode;
744 target->stat->lastdivenode = source->stat->lastdivenode;
745 target->stat->lastconflictnode = source->stat->lastconflictnode;
746 target->stat->bestsolnode = source->stat->bestsolnode;
747 target->stat->domchgcount = source->stat->domchgcount;
748 target->stat->nboundchgs = source->stat->nboundchgs;
749 target->stat->nholechgs = source->stat->nholechgs;
750 target->stat->nprobboundchgs = source->stat->nprobboundchgs;
751 target->stat->nprobholechgs = source->stat->nprobholechgs;
752 target->stat->nsbdowndomchgs = source->stat->nsbdowndomchgs;
753 target->stat->nsbupdomchgs = source->stat->nsbupdomchgs;
754 target->stat->nsbtimesiterlimhit = source->stat->nsbtimesiterlimhit;
755 target->stat->nnodesbeforefirst = source->stat->nnodesbeforefirst;
756 target->stat->ninitconssadded = source->stat->ninitconssadded;
757 target->stat->firstlpdualbound = SCIPprobExternObjval(target->transprob, target->origprob, target->set, source->stat->firstlpdualbound);
758 target->stat->rootlowerbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->rootlowerbound);
759 target->stat->vsidsweight = source->stat->vsidsweight;
760 target->stat->firstprimalbound = SCIPprobExternObjval(target->transprob, target->origprob, target->set, source->stat->firstprimalbound);
761 target->stat->firstprimaltime = source->stat->firstprimaltime;
762 target->stat->firstsolgap = source->stat->firstsolgap;
763 target->stat->lastsolgap = source->stat->lastsolgap;
764 target->stat->primalzeroittime = source->stat->primalzeroittime;
765 target->stat->dualzeroittime = source->stat->dualzeroittime;
766 target->stat->barrierzeroittime = source->stat->barrierzeroittime;
767 target->stat->maxcopytime = MAX(source->stat->maxcopytime, target->stat->maxcopytime);
768 target->stat->mincopytime = MIN(source->stat->mincopytime, target->stat->mincopytime);
769 target->stat->firstlptime = source->stat->firstlptime;
770 target->stat->lastbranchvalue = source->stat->lastbranchvalue;
771 target->stat->dualrefintegral = source->stat->dualrefintegral;
772 target->stat->primalrefintegral = source->stat->primalrefintegral;
773 target->stat->primaldualintegral = source->stat->primaldualintegral;
774 target->stat->previousgap = source->stat->previousgap;
775 target->stat->previousdualrefgap = source->stat->previousdualrefgap;
776 target->stat->previousprimalrefgap = source->stat->previousprimalrefgap;
777 target->stat->previntegralevaltime = source->stat->previntegralevaltime;
778 target->stat->lastprimalbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastprimalbound);
779 target->stat->lastdualbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastdualbound);
780 target->stat->lastlowerbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastlowerbound);
781 target->stat->lastupperbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastupperbound);
782 target->stat->rootlpbestestimate = source->stat->rootlpbestestimate;
783 target->stat->referencebound = source->stat->referencebound;
784
785 /*tmptime = SCIPgetClockTime(target, target->stat->solvingtime);
786 tmptime += SCIPgetClockTime(source, source->stat->solvingtime);
787 SCIP_CALL( SCIPsetClockTime(target, target->stat->solvingtime, tmptime) );*/
788
789 /* TODO */
790 tmptime = SCIPgetClockTime(target, target->stat->solvingtimeoverall);
791 tmptime += SCIPgetClockTime(source, source->stat->solvingtimeoverall);
792 SCIP_CALL( SCIPsetClockTime(target, target->stat->solvingtimeoverall, tmptime) );
793
794 tmptime = SCIPgetClockTime(target, target->stat->presolvingtime);
795 tmptime += SCIPgetClockTime(source, source->stat->presolvingtime);
796 SCIP_CALL( SCIPsetClockTime(target, target->stat->presolvingtime, tmptime) );
797
798 tmptime = SCIPgetClockTime(target, target->stat->presolvingtimeoverall);
799 tmptime += SCIPgetClockTime(source, source->stat->presolvingtimeoverall);
800 SCIP_CALL( SCIPsetClockTime(target, target->stat->presolvingtimeoverall, tmptime) );
801
802 tmptime = SCIPgetClockTime(target, target->stat->primallptime);
803 tmptime += SCIPgetClockTime(source, source->stat->primallptime);
804 SCIP_CALL( SCIPsetClockTime(target, target->stat->primallptime, tmptime) );
805
806 tmptime = SCIPgetClockTime(target, target->stat->duallptime);
807 tmptime += SCIPgetClockTime(source, source->stat->duallptime);
808 SCIP_CALL( SCIPsetClockTime(target, target->stat->duallptime, tmptime) );
809
810 tmptime = SCIPgetClockTime(target, target->stat->lexduallptime);
811 tmptime += SCIPgetClockTime(source, source->stat->lexduallptime);
812 SCIP_CALL( SCIPsetClockTime(target, target->stat->lexduallptime, tmptime) );
813
814 tmptime = SCIPgetClockTime(target, target->stat->barrierlptime);
815 tmptime += SCIPgetClockTime(source, source->stat->barrierlptime);
816 SCIP_CALL( SCIPsetClockTime(target, target->stat->barrierlptime, tmptime) );
817
818 tmptime = SCIPgetClockTime(target, target->stat->divinglptime);
819 tmptime += SCIPgetClockTime(source, source->stat->divinglptime);
820 SCIP_CALL( SCIPsetClockTime(target, target->stat->divinglptime, tmptime) );
821
822 tmptime = SCIPgetClockTime(target, target->stat->strongbranchtime);
823 tmptime += SCIPgetClockTime(source, source->stat->strongbranchtime);
824 SCIP_CALL( SCIPsetClockTime(target, target->stat->strongbranchtime, tmptime) );
825
826 tmptime = SCIPgetClockTime(target, target->stat->conflictlptime);
827 tmptime += SCIPgetClockTime(source, source->stat->conflictlptime);
828 SCIP_CALL( SCIPsetClockTime(target, target->stat->conflictlptime, tmptime) );
829
830 tmptime = SCIPgetClockTime(target, target->stat->lpsoltime);
831 tmptime += SCIPgetClockTime(source, source->stat->lpsoltime);
832 SCIP_CALL( SCIPsetClockTime(target, target->stat->lpsoltime, tmptime) );
833
834 tmptime = SCIPgetClockTime(target, target->stat->pseudosoltime);
835 tmptime += SCIPgetClockTime(source, source->stat->pseudosoltime);
836 SCIP_CALL( SCIPsetClockTime(target, target->stat->pseudosoltime, tmptime) );
837
838 tmptime = SCIPgetClockTime(target, target->stat->sbsoltime);
839 tmptime += SCIPgetClockTime(source, source->stat->sbsoltime);
840 SCIP_CALL( SCIPsetClockTime(target, target->stat->sbsoltime, tmptime) );
841
842 tmptime = SCIPgetClockTime(target, target->stat->nodeactivationtime);
843 tmptime += SCIPgetClockTime(source, source->stat->nodeactivationtime);
844 SCIP_CALL( SCIPsetClockTime(target, target->stat->nodeactivationtime, tmptime) );
845
846 tmptime = SCIPgetClockTime(target, target->stat->nlpsoltime);
847 tmptime += SCIPgetClockTime(source, source->stat->nlpsoltime);
848 SCIP_CALL( SCIPsetClockTime(target, target->stat->nlpsoltime, tmptime) );
849
850 tmptime = SCIPgetClockTime(target, target->stat->strongpropclock);
851 tmptime += SCIPgetClockTime(source, source->stat->strongpropclock);
852 SCIP_CALL( SCIPsetClockTime(target, target->stat->strongpropclock, tmptime) );
853
854 tmptime = SCIPgetClockTime(target, target->stat->reoptupdatetime);
855 tmptime += SCIPgetClockTime(source, source->stat->reoptupdatetime);
856 SCIP_CALL( SCIPsetClockTime(target, target->stat->reoptupdatetime, tmptime) );
857
858 heur = source->stat->firstprimalheur;
859
860 if( heur != NULL )
861 target->stat->firstprimalheur = SCIPfindHeur(target, SCIPheurGetName(heur));
862
863 target->stat->status = source->stat->status;
864 target->stat->lastbranchdir = source->stat->lastbranchdir;
865 target->stat->lastsblpsolstats[0] = source->stat->lastsblpsolstats[0];
866 target->stat->lastsblpsolstats[1] = source->stat->lastsblpsolstats[1];
867 target->stat->nnz = source->stat->nnz;
868 target->stat->lpcount = source->stat->lpcount;
869 target->stat->nlps = source->stat->nlps;
870 target->stat->nrootlps = source->stat->nrootlps;
871 target->stat->nprimallps = source->stat->nprimallps;
872 target->stat->nprimalzeroitlps = source->stat->nprimalzeroitlps;
873 target->stat->nduallps = source->stat->nduallps;
874 target->stat->ndualzeroitlps = source->stat->ndualzeroitlps;
875 target->stat->nlexduallps = source->stat->nlexduallps;
876 target->stat->nbarrierlps = source->stat->nbarrierlps;
877 target->stat->nbarrierzeroitlps = source->stat->nbarrierzeroitlps;
878 target->stat->nprimalresolvelps = source->stat->nprimalresolvelps;
879 target->stat->ndualresolvelps = source->stat->ndualresolvelps;
880 target->stat->nlexdualresolvelps = source->stat->nlexdualresolvelps;
881 target->stat->nnodelps = source->stat->nnodelps;
882 target->stat->ninitlps = source->stat->ninitlps;
883 target->stat->ndivinglps = source->stat->ndivinglps;
884 target->stat->ndivesetlps = source->stat->ndivesetlps;
885 target->stat->nsbdivinglps = source->stat->nsbdivinglps;
886 target->stat->nstrongbranchs = source->stat->nstrongbranchs;
887 target->stat->nrootstrongbranchs = source->stat->nrootstrongbranchs;
888 target->stat->nconflictlps = source->stat->nconflictlps;
889 target->stat->nnlps = source->stat->nnlps;
890 target->stat->nisstoppedcalls = source->stat->nisstoppedcalls;
891 target->stat->totaldivesetdepth = source->stat->totaldivesetdepth;
892 target->stat->ndivesetcalls = source->stat->ndivesetcalls;
893 target->stat->nruns = source->stat->nruns;
894 target->stat->nconfrestarts = source->stat->nconfrestarts;
895 target->stat->nrootboundchgs = source->stat->nrootboundchgs;
896 target->stat->nrootboundchgsrun = source->stat->nrootboundchgsrun;
897 target->stat->nrootintfixings = source->stat->nrootintfixings;
898 target->stat->nrootintfixingsrun = source->stat->nrootintfixingsrun;
899 target->stat->prevrunnvars = source->stat->prevrunnvars;
900 target->stat->npricerounds = source->stat->npricerounds;
901 target->stat->nseparounds = source->stat->nseparounds;
902 target->stat->maxdepth = source->stat->maxdepth;
903 target->stat->maxtotaldepth = source->stat->maxtotaldepth;
904 target->stat->plungedepth = source->stat->plungedepth;
905 target->stat->npresolrounds += source->stat->npresolrounds;
906 target->stat->npresolroundsfast += source->stat->npresolroundsfast;
907 target->stat->npresolroundsmed += source->stat->npresolroundsmed;
908 target->stat->npresolroundsext += source->stat->npresolroundsext;
909 target->stat->npresolfixedvars += source->stat->npresolfixedvars;
910 target->stat->npresolaggrvars += source->stat->npresolaggrvars;
911 target->stat->npresolchgvartypes += source->stat->npresolchgvartypes;
912 target->stat->npresolchgbds += source->stat->npresolchgbds;
913 target->stat->npresoladdholes += source->stat->npresoladdholes;
914 target->stat->npresoldelconss += source->stat->npresoldelconss;
915 target->stat->npresoladdconss += source->stat->npresoladdconss;
916 target->stat->npresolupgdconss += source->stat->npresolupgdconss;
917 target->stat->npresolchgcoefs += source->stat->npresolchgcoefs;
918 target->stat->npresolchgsides += source->stat->npresolchgsides;
919 target->stat->nrunsbeforefirst = source->stat->nrunsbeforefirst;
920 target->stat->firstprimaldepth = source->stat->firstprimaldepth;
921 target->stat->ncopies += source->stat->ncopies;
922 target->stat->nreoptruns = source->stat->nreoptruns;
923
924 /* set the stage but do not set to earlier stage */
925 target->set->stage = MAX(source->set->stage, target->set->stage);
926
927 return SCIP_OKAY;
928}
void SCIPconcsolverSetTimeSinceLastSync(SCIP_CONCSOLVER *concsolver, SCIP_Real time)
Definition concsolver.c:532
SCIP_RETCODE SCIPconcsolverExec(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:325
SCIP_Real SCIPconcsolverGetSyncFreq(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:510
SCIP_RETCODE SCIPconcsolverGetSolvingData(SCIP_CONCSOLVER *concsolver, SCIP *scip)
Definition concsolver.c:343
SCIP_RETCODE SCIPconcsolverSync(SCIP_CONCSOLVER *concsolver, SCIP_SET *set)
Definition concsolver.c:375
SCIP_Longint SCIPconcsolverGetMemTotal(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:520
datastructures for concurrent solvers
SCIP_Real SCIPgetConcurrentDualbound(SCIP *scip)
Definition concurrent.c:305
SCIP_RETCODE SCIPconcurrentSolve(SCIP *scip)
Definition concurrent.c:483
SCIP_Real SCIPgetConcurrentPrimalbound(SCIP *scip)
Definition concurrent.c:320
SCIP_RETCODE SCIPsynchronize(SCIP *scip)
Definition concurrent.c:245
SCIP_RETCODE SCIPincrementConcurrentTime(SCIP *scip, SCIP_Real val)
Definition concurrent.c:189
int SCIPgetConcurrentVaridx(SCIP *scip, SCIP_VAR *var)
Definition concurrent.c:422
SCIP_RETCODE SCIPfreeConcurrent(SCIP *scip)
Definition concurrent.c:151
SCIP_RETCODE SCIPaddConcurrentBndchg(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)
Definition concurrent.c:386
SCIP_RETCODE SCIPcopySolStats(SCIP_SOL *source, SCIP_SOL *target)
Definition concurrent.c:404
SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)
Definition concurrent.c:287
SCIP_RETCODE SCIPcreateConcurrent(SCIP *scip, SCIP_CONCSOLVER *concsolver, int *varperm)
Definition concurrent.c:57
SCIP_BOUNDSTORE * SCIPgetConcurrentGlobalBoundChanges(SCIP *scip)
Definition concurrent.c:451
SCIP_RETCODE SCIPaddConcurrentSolver(SCIP *scip, SCIP_CONCSOLVER *concsolver)
Definition concurrent.c:138
static SCIP_RETCODE execConcsolver(void *args)
Definition concurrent.c:466
SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)
Definition concurrent.c:127
SCIP_Bool SCIPIsConcurrentSolNew(SCIP *scip, SCIP_SOL *sol)
Definition concurrent.c:438
SCIP_Longint SCIPgetConcurrentNTightenedBnds(SCIP *scip)
Definition concurrent.c:349
void SCIPenableConcurrentBoundStorage(SCIP *scip)
Definition concurrent.c:275
int SCIPgetNConcurrentSolvers(SCIP *scip)
Definition concurrent.c:116
SCIP_RETCODE SCIPcopyConcurrentSolvingStats(SCIP *source, SCIP *target)
Definition concurrent.c:539
SCIP_RETCODE SCIPaddConcurrentSol(SCIP *scip, SCIP_SOL *sol)
Definition concurrent.c:371
SCIP_Real SCIPgetConcurrentGap(SCIP *scip)
Definition concurrent.c:335
void SCIPdisableConcurrentBoundStorage(SCIP *scip)
Definition concurrent.c:263
SCIP_Longint SCIPgetConcurrentNTightenedIntBnds(SCIP *scip)
Definition concurrent.c:360
helper functions for concurrent scip solvers
#define FALSE
Definition def.h:96
#define SCIP_CALL_ABORT(x)
Definition def.h:367
#define SCIP_CALL(x)
Definition def.h:388
#define TPI_SINGLE
Definition def_openmp.h:83
#define TPI_PARA
Definition def_openmp.h:78
SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)
Definition event.c:2240
SCIP_RETCODE SCIPeventCreateSync(SCIP_EVENT **event, BMS_BLKMEM *blkmem)
Definition event.c:483
internal methods for managing events
void SCIPeventGlobalbndClearBoundChanges(SCIP_EVENTHDLR *eventhdlr)
SCIP_RETCODE SCIPincludeEventHdlrGlobalbnd(SCIP *scip)
void SCIPeventGlobalbndEnableBoundStorage(SCIP_EVENTHDLR *eventhdlr)
SCIP_BOUNDSTORE * SCIPeventGlobalbndGetBoundChanges(SCIP_EVENTHDLR *eventhdlr)
void SCIPeventGlobalbndDisableBoundStorage(SCIP_EVENTHDLR *eventhdlr)
eventhdlr for storing all global bound changes
int SCIPgetNOrigVars(SCIP *scip)
Definition scip_prob.c:2432
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition scip_prob.c:3757
SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)
Definition misc.c:11114
SCIP_RETCODE SCIPheurSyncPassSol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)
Definition heur_sync.c:190
SCIP_Longint SCIPpropSyncGetNTightenedBnds(SCIP_PROP *prop)
Definition prop_sync.c:362
SCIP_RETCODE SCIPpropSyncAddBndchg(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)
Definition prop_sync.c:322
SCIP_Longint SCIPpropSyncGetNTightenedIntBnds(SCIP_PROP *prop)
Definition prop_sync.c:377
SCIP_RETCODE SCIPincludeHeurSync(SCIP *scip)
Definition heur_sync.c:161
SCIP_RETCODE SCIPincludePropSync(SCIP *scip)
Definition prop_sync.c:287
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
Definition scip_event.c:234
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition scip_heur.c:271
int SCIPgetNHeurs(SCIP *scip)
Definition scip_heur.c:282
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition scip_heur.c:258
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition heur.c:1450
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition scip_mem.h:110
#define SCIPfreeBlockMemory(scip, ptr)
Definition scip_mem.h:108
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition scip_mem.c:113
#define SCIPallocBlockMemory(scip, ptr)
Definition scip_mem.h:89
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
Definition scip_mem.h:105
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
int SCIPgetNPresols(SCIP *scip)
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition presol.c:599
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
Definition scip_prop.c:329
int SCIPgetNProps(SCIP *scip)
Definition scip_prop.c:355
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition prop.c:941
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition scip_prop.c:342
int SCIPgetNSepas(SCIP *scip)
Definition scip_sepa.c:273
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition sepa.c:743
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition scip_sepa.c:247
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition scip_sepa.c:260
int SCIPsolGetIndex(SCIP_SOL *sol)
Definition sol.c:2669
SCIP_Real SCIPgetDualbound(SCIP *scip)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
Definition scip_tree.c:110
int SCIPvarGetIndex(SCIP_VAR *var)
Definition var.c:17580
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
Definition var.c:17370
return SCIP_OKAY
static SCIP_SOL * sol
assert(minobj< SCIPgetCutoffbound(scip))
int nvars
SCIP_VAR * var
primal heuristic that adds given solutions
#define NULL
Definition lpi_spx1.cpp:161
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition scip_mem.c:57
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition prob.c:2116
void SCIPprobSetDualbound(SCIP_PROB *prob, SCIP_Real dualbound)
Definition prob.c:1453
internal methods for storing and manipulating the main problem
propagator for applying global bound changes that were communicated by other concurrent solvers
SCIP callable library.
SCIP_RETCODE SCIPsetIncludeConcsolver(SCIP_SET *set, SCIP_CONCSOLVER *concsolver)
Definition set.c:4483
internal methods for global SCIP settings
internal methods for problem statistics
SCIP_CLOCK * heurclock
SCIP_CLOCK * setuptime
SCIP_Longint ncalls
Definition struct_heur.h:99
SCIP_Longint nsolsfound
SCIP_Longint nbestsolsfound
SCIP_CLOCK * resproptime
Definition struct_prop.h:69
SCIP_CLOCK * presoltime
Definition struct_prop.h:70
SCIP_Longint ncutoffs
Definition struct_prop.h:50
SCIP_CLOCK * setuptime
Definition struct_prop.h:66
SCIP_CLOCK * sbproptime
Definition struct_prop.h:68
SCIP_CLOCK * proptime
Definition struct_prop.h:67
SCIP_Longint ndomredsfound
Definition struct_prop.h:51
SCIP_Longint ncalls
Definition struct_prop.h:48
SCIP_Longint nrespropcalls
Definition struct_prop.h:49
SCIP_Longint nrootcalls
Definition struct_sepa.h:50
SCIP_Longint ncutoffs
Definition struct_sepa.h:51
SCIP_Longint ncutsaddedviapool
Definition struct_sepa.h:55
SCIP_Longint ndomredsfound
Definition struct_sepa.h:60
SCIP_Longint ncutsfound
Definition struct_sepa.h:52
SCIP_Longint lastsepanode
Definition struct_sepa.h:48
SCIP_CLOCK * sepaclock
Definition struct_sepa.h:75
SCIP_Longint nconssfound
Definition struct_sepa.h:59
SCIP_Longint ncalls
Definition struct_sepa.h:49
SCIP_Longint ncutsappliedviapool
Definition struct_sepa.h:57
SCIP_CLOCK * setuptime
Definition struct_sepa.h:74
SCIP_Longint ncutsapplieddirect
Definition struct_sepa.h:58
SCIP_Longint ncutsaddeddirect
Definition struct_sepa.h:56
SCIP_Real maxbounddist
Definition struct_sepa.h:61
SCIP_EVENTFILTER * eventfilter
Definition struct_scip.h:88
SCIP_EVENTQUEUE * eventqueue
Definition struct_scip.h:89
SCIP_SET * set
Definition struct_scip.h:72
concurrent data struct
datastructures for primal heuristics
datastructures for presolvers
datastructures for collecting primal CIP solutions and primal informations
datastructures for propagators
SCIP main data structure.
datastructures for separators
datastructures for global SCIP settings
datastructures for storing primal CIP solutions
datastructures for problem statistics
SCIP_Real SCIPsyncstoreGetLastUpperbound(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:268
SCIP_Real SCIPsyncstoreGetLastLowerbound(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:279
int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:525
void SCIPsyncstoreSetSolveIsStopped(SCIP_SYNCSTORE *syncstore, SCIP_Bool stopped)
Definition syncstore.c:255
SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:789
int SCIPsyncstoreGetNSolvers(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:549
the function declarations for the synchronization store
#define MAX(x, y)
Definition tclique_def.h:92
the type definitions for the SCIP parallel interface
SCIP_RETCODE SCIPtpiCreateJob(SCIP_JOB **job, int jobid, SCIP_RETCODE(*jobfunc)(void *args), void *jobarg)
Definition tpi_none.c:37
SCIP_RETCODE SCIPtpiCollectJobs(int jobid)
Definition tpi_none.c:66
SCIP_RETCODE SCIPtpiSumbitJob(SCIP_JOB *job, SCIP_SUBMITSTATUS *status)
Definition tpi_none.c:53
int SCIPtpiGetThreadNum(void)
Definition tpi_openmp.c:349
int SCIPtpiGetNewJobID(void)
Definition tpi_openmp.c:374
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition type_lp.h:59
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_PARA_DETERMINISTIC
enum SCIP_Submitstatus SCIP_SUBMITSTATUS
Definition type_tpi.h:54
@ SCIP_SUBMIT_SUCCESS
Definition type_tpi.h:52