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