Scippy

SCIP

Solving Constraint Integer Programs

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"
34 #include "scip/struct_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"
50 #include "scip/event_globalbnd.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 
72  nvars = SCIPgetNOrigVars(scip);
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  {
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 concurent 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 */
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 
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 
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  {
213  SCIP_EVENT* event;
215  scip->concurrent->dettime = 0.0;
216  SCIP_CALL( SCIPeventCreateSync(&event, SCIPblkmem(mainscip)) );
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  {
228  SCIP_EVENT* event;
229  SCIPconcsolverSetTimeSinceLastSync(scip->concurrent->concsolver, timesincelastsync);
230 
231  SCIP_CALL( SCIPeventCreateSync(&event, SCIPblkmem(mainscip)) );
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 
253 
255 
256  if( scip->concurrent->eventglobalbnd != NULL )
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 )
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 )
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  {
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 
342  primalbound = SCIPgetConcurrentPrimalbound(scip);
343  dualbound = SCIPgetConcurrentDualbound(scip);
344 
345  return SCIPcomputeGap(SCIPepsilon(scip), SCIPinfinity(scip), primalbound, dualbound);
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 
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 
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);
431  assert(SCIPvarIsOriginal(var));
432  assert(SCIPvarGetIndex(var) < SCIPgetNOrigVars(scip));
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 )
460 
461  return NULL;
462 }
463 
464 /** executes the concurrent solver corresponding to the current thread */
465 static
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 
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 
501  assert(SCIPsyncstoreIsInitialized(syncstore));
502  assert(SCIPsyncstoreGetNSolvers(syncstore) == nconcsolvers);
503 
505  jobid = SCIPtpiGetNewJobID();
506 
507  TPI_PARA
508  {
509  TPI_SINGLE
510  {
511  for( i = 0; i < nconcsolvers; ++i )
512  {
513  /* cppcheck-suppress unassignedVariable */
514  SCIP_JOB* job;
515  SCIP_SUBMITSTATUS status;
516 
517  SCIP_CALL_ABORT( SCIPtpiCreateJob(&job, jobid, execConcsolver, scip) );
518  SCIP_CALL_ABORT( SCIPtpiSumbitJob(job, &status) );
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;
549  SCIP_PRESOL* presol;
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);
577  tmptime += SCIPgetClockTime(source, heur->setuptime);
578  SCIP_CALL( SCIPsetClockTime(target, heurs[i]->setuptime, tmptime) );
579 
580  tmptime = SCIPgetClockTime(target, heurs[i]->heurclock);
581  tmptime += SCIPgetClockTime(source, heur->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);
601  tmptime += SCIPgetClockTime(source, prop->proptime);
602  SCIP_CALL( SCIPsetClockTime(target, props[i]->proptime, tmptime) );
603 
604  tmptime = SCIPgetClockTime(target, props[i]->sbproptime);
605  tmptime += SCIPgetClockTime(source, prop->sbproptime);
606  SCIP_CALL( SCIPsetClockTime(target, props[i]->sbproptime, tmptime) );
607 
608  tmptime = SCIPgetClockTime(target, props[i]->resproptime);
609  tmptime += SCIPgetClockTime(source, prop->resproptime);
610  SCIP_CALL( SCIPsetClockTime(target, props[i]->resproptime, tmptime) );
611 
612  tmptime = SCIPgetClockTime(target, props[i]->presoltime);
613  tmptime += SCIPgetClockTime(source, prop->presoltime);
614  SCIP_CALL( SCIPsetClockTime(target, props[i]->presoltime, tmptime) );
615 
616  tmptime = SCIPgetClockTime(target, props[i]->setuptime);
617  tmptime += SCIPgetClockTime(source, prop->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  {
627  presol = SCIPfindPresol(source, SCIPpresolGetName(presols[i]));
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;
672  sepas[i]->ncutsappliedviapool += sepa->ncutsappliedviapool;
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);
679  tmptime += SCIPgetClockTime(source, sepa->setuptime);
680  SCIP_CALL( SCIPsetClockTime(target, sepas[i]->setuptime, tmptime) );
681 
682  tmptime = SCIPgetClockTime(target, sepas[i]->sepaclock);
683  tmptime += SCIPgetClockTime(source, sepa->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;
691  SCIPprobSetDualbound(target->transprob, SCIPprobExternObjval(target->transprob, target->origprob, target->set, SCIPgetDualbound(source)));
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 */
697  SCIP_CALL( SCIPupdateNodeLowerbound(target, root, SCIPgetDualbound(source)) );
698  }
699 
700  target->stat->nlpiterations = source->stat->nlpiterations;
701  target->stat->nrootlpiterations = source->stat->nrootlpiterations;
703  target->stat->nprimallpiterations = source->stat->nprimallpiterations;
704  target->stat->nduallpiterations = source->stat->nduallpiterations;
710  target->stat->nnodelpiterations = source->stat->nnodelpiterations;
711  target->stat->ninitlpiterations = source->stat->ninitlpiterations;
712  target->stat->ndivinglpiterations = source->stat->ndivinglpiterations;
715  target->stat->nsblpiterations = source->stat->nsblpiterations;
716  target->stat->nrootsblpiterations = source->stat->nrootsblpiterations;
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;
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 }
SCIP_Longint nlexduallps
Definition: struct_stat.h:198
SCIP_Longint nprimallps
Definition: struct_stat.h:194
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:110
SCIP_STAT * stat
Definition: struct_scip.h:79
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
SCIP_Longint ndualresolvelpiterations
Definition: struct_stat.h:70
SCIP_Real lastupperbound
Definition: struct_stat.h:154
SCIP_Longint nsbdivinglps
Definition: struct_stat.h:209
int npresoladdconss
Definition: struct_stat.h:252
SCIP_Longint ninfeasleaves
Definition: struct_stat.h:86
SCIP_Real firstlpdualbound
Definition: struct_stat.h:130
int npresolroundsfast
Definition: struct_stat.h:243
internal methods for managing events
SCIP_Longint nnodelpiterations
Definition: struct_stat.h:72
SCIP_Longint nlpsolsfound
Definition: struct_stat.h:101
int solindex
Definition: struct_stat.h:270
SCIP_CLOCK * setuptime
Definition: struct_sepa.h:74
SCIP_Longint nsbdowndomchgs
Definition: struct_stat.h:119
SCIP_STATUS status
Definition: struct_stat.h:186
SCIP_Longint nlpiterations
Definition: struct_stat.h:62
SCIP_RETCODE SCIPsetIncludeConcsolver(SCIP_SET *set, SCIP_CONCSOLVER *concsolver)
Definition: set.c:4565
SCIP_Real primalrefintegral
Definition: struct_stat.h:145
SCIP_Longint nfeasleaves
Definition: struct_stat.h:85
SCIP_CONCSOLVER ** concsolvers
Definition: struct_set.h:109
SCIP_Longint ndeactivatednodes
Definition: struct_stat.h:93
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
Definition: scip_timing.c:334
int SCIPgetNConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:116
SCIP_Longint nlexdualresolvelps
Definition: struct_stat.h:203
int npricerounds
Definition: struct_stat.h:233
SCIP_Bool concurrent_commvarbnds
Definition: struct_set.h:578
datastructures for presolvers
SCIP_Longint nlps
Definition: struct_stat.h:192
int depth
Definition: struct_sol.h:88
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
Definition: scip_prop.c:329
SCIP_CLOCK * sepaclock
Definition: struct_sepa.h:75
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_Longint nbarrierlpiterations
Definition: struct_stat.h:68
SCIP_Longint SCIPpropSyncGetNTightenedBnds(SCIP_PROP *prop)
Definition: prop_sync.c:363
SCIP_Longint ninitconssadded
Definition: struct_stat.h:123
static SCIP_RETCODE execConcsolver(void *args)
Definition: concurrent.c:466
SCIP_CLOCK * conflictlptime
Definition: struct_stat.h:171
int nrunsbeforefirst
Definition: struct_stat.h:271
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition: scip_sepa.c:247
SCIP_Real SCIPgetConcurrentPrimalbound(SCIP *scip)
Definition: concurrent.c:320
SCIP_Real rootlowerbound
Definition: struct_stat.h:131
enum SCIP_Submitstatus SCIP_SUBMITSTATUS
Definition: type_tpi.h:54
SCIP_Longint ntotalnodes
Definition: struct_stat.h:87
SCIP_Real previntegralevaltime
Definition: struct_stat.h:150
int npresolaggrvars
Definition: struct_stat.h:247
SCIP_Longint nodenum
Definition: struct_sol.h:77
SCIP_Real lastbranchvalue
Definition: struct_stat.h:143
eventhdlr for storing all global bound changes
SCIP_Longint nrootfirstlpiterations
Definition: struct_stat.h:64
int SCIPgetNOrigVars(SCIP *scip)
Definition: scip_prob.c:2440
SCIP_Longint ndivinglps
Definition: struct_stat.h:207
SCIP_RETCODE SCIPeventCreateSync(SCIP_EVENT **event, BMS_BLKMEM *blkmem)
Definition: event.c:483
int nconcsolvers
Definition: struct_set.h:156
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:89
SCIP_Longint nsbtimesiterlimhit
Definition: struct_stat.h:121
void SCIPeventGlobalbndDisableBoundStorage(SCIP_EVENTHDLR *eventhdlr)
SCIP_BRANCHDIR lastbranchdir
Definition: struct_stat.h:187
int npresolfixedvars
Definition: struct_stat.h:246
SCIP_PRIMAL * primal
Definition: struct_scip.h:94
SCIP_CLOCK * presoltime
Definition: struct_prop.h:70
SCIP_Real lastsolgap
Definition: struct_stat.h:136
SCIP_Longint nrootstrongbranchs
Definition: struct_stat.h:212
SCIP_CONCURRENT * concurrent
Definition: struct_scip.h:110
int nreoptruns
Definition: struct_stat.h:274
SCIP_CLOCK * proptime
Definition: struct_prop.h:67
int npresoldelconss
Definition: struct_stat.h:251
SCIP_Longint nstrongbranchs
Definition: struct_stat.h:211
SCIP_CLOCK * presolclock
Definition: struct_presol.h:59
SCIP_Longint ncalls
Definition: struct_prop.h:48
SCIP_Longint nholechgs
Definition: struct_stat.h:116
SCIP_Longint nrootsblpiterations
Definition: struct_stat.h:78
#define FALSE
Definition: def.h:96
SCIP_Real detertimecnt
Definition: struct_stat.h:159
SCIP_Longint ncutoffs
Definition: struct_prop.h:50
SCIP_Longint nrootlps
Definition: struct_stat.h:193
SCIP_Longint ncreatednodes
Definition: struct_stat.h:90
SCIP_Longint nsolsfound
Definition: struct_heur.h:100
SCIP_Longint SCIPgetConcurrentNTightenedBnds(SCIP *scip)
Definition: concurrent.c:349
SCIP_CLOCK * heurclock
Definition: struct_heur.h:114
SCIP_Real primaldualintegral
Definition: struct_stat.h:146
SCIP_Longint ncutsapplieddirect
Definition: struct_sepa.h:58
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Real maxbounddist
Definition: struct_sepa.h:61
SCIP_STAGE stage
Definition: struct_set.h:74
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:743
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_Longint nnlps
Definition: struct_stat.h:214
SCIP_Longint nbacktracks
Definition: struct_stat.h:96
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip_heur.c:271
SCIP_Longint ncutsfound
Definition: struct_sepa.h:52
SCIP_CLOCK * setuptime
Definition: struct_heur.h:113
datastructures for concurrent solvers
SCIP_RETCODE SCIPconcsolverSync(SCIP_CONCSOLVER *concsolver, SCIP_SET *set)
Definition: concsolver.c:375
SCIP_Real previousdualrefgap
Definition: struct_stat.h:148
SCIP_Longint nsolsfound
Definition: struct_primal.h:48
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
int maxtotaldepth
Definition: struct_stat.h:237
SCIP_CLOCK * barrierlptime
Definition: struct_stat.h:167
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
Definition: scip_event.c:234
SCIP_Longint lastdispnode
Definition: struct_stat.h:110
SCIP_Longint nnodesaboverefbound
Definition: struct_stat.h:95
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:127
SCIP_PROB * transprob
Definition: struct_scip.h:98
int npresolroundsext
Definition: struct_stat.h:245
int SCIPgetNPresols(SCIP *scip)
Definition: scip_presol.c:262
SCIP_CLOCK * setuptime
Definition: struct_presol.h:58
SCIP_Real rootlpbestestimate
Definition: struct_stat.h:155
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
int maxdepth
Definition: struct_stat.h:236
SCIP_Real SCIPsyncstoreGetLastUpperbound(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:268
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
Definition: scip_tree.c:110
SCIP_CLOCK * nlpsoltime
Definition: struct_stat.h:177
SCIP_Real lastdualbound
Definition: struct_stat.h:152
int runnum
Definition: struct_sol.h:87
SCIP_Longint nlpbestsolsfound
Definition: struct_stat.h:105
SCIP_RETCODE SCIPconcurrentSolve(SCIP *scip)
Definition: concurrent.c:483
SCIP_Real dualzeroittime
Definition: struct_stat.h:138
SCIP_PROB * origprob
Definition: struct_scip.h:80
SCIP_Longint nexternalsolsfound
Definition: struct_stat.h:109
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Longint nrootcalls
Definition: struct_sepa.h:50
int nrootintfixings
Definition: struct_stat.h:224
SCIP_Longint nsblpiterations
Definition: struct_stat.h:77
SCIP_Real primalzeroittime
Definition: struct_stat.h:137
int nrootboundchgs
Definition: struct_stat.h:222
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:110
SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)
Definition: concurrent.c:287
int nconfrestarts
Definition: struct_stat.h:221
SCIP_Longint nlexduallpiterations
Definition: struct_stat.h:67
SCIP_CLOCK * strongpropclock
Definition: struct_stat.h:179
SCIP_Longint SCIPconcsolverGetMemTotal(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:520
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
Definition: scip_mem.h:105
int npresolchgcoefs
Definition: struct_stat.h:254
int npresolchgvartypes
Definition: struct_stat.h:248
SCIP_Longint nrespropcalls
Definition: struct_prop.h:49
SCIP_Real barrierzeroittime
Definition: struct_stat.h:139
void SCIPdisableConcurrentBoundStorage(SCIP *scip)
Definition: concurrent.c:263
SCIP_RETCODE SCIPconcsolverGetSolvingData(SCIP_CONCSOLVER *concsolver, SCIP *scip)
Definition: concsolver.c:343
SCIP_Longint nobjleaves
Definition: struct_stat.h:84
SCIP_Longint npssolsfound
Definition: struct_stat.h:103
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip_prop.c:342
SCIP_HEUR * heursync
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1450
SCIP_Real mincopytime
Definition: struct_stat.h:141
int npresolroundsmed
Definition: struct_stat.h:244
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip_heur.c:258
void SCIPconcsolverSetTimeSinceLastSync(SCIP_CONCSOLVER *concsolver, SCIP_Real time)
Definition: concsolver.c:532
int prevrunnvars
Definition: struct_stat.h:226
SCIP_Longint nconssfound
Definition: struct_sepa.h:59
SCIP_RETCODE SCIPaddConcurrentBndchg(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)
Definition: concurrent.c:386
internal methods for storing and manipulating the main problem
SCIP_Real SCIPsyncstoreGetLastLowerbound(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:279
SCIP_CLOCK * wallclock
SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:789
SCIP_EVENTFILTER * eventfilter
Definition: struct_scip.h:88
SCIP_Longint lastsepanode
Definition: struct_sepa.h:48
SCIP_Longint lpcount
Definition: struct_stat.h:190
SCIP_Longint nbestsolsfound
Definition: struct_primal.h:51
SCIP_Longint ncalls
Definition: struct_sepa.h:49
the type definitions for the SCIP parallel interface
int ndivesetcalls
Definition: struct_stat.h:218
SCIP_Longint bestsolnode
Definition: struct_stat.h:113
SCIP_Real SCIPconcsolverGetSyncFreq(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:510
SCIP_Longint nconflictlpiterations
Definition: struct_stat.h:79
int npresolchgsides
Definition: struct_stat.h:255
SCIP_CLOCK * pseudosoltime
Definition: struct_stat.h:174
SCIP_RETCODE SCIPincludeEventHdlrGlobalbnd(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
int SCIPtpiGetNewJobID(void)
Definition: tpi_openmp.c:374
SCIP_Longint nsbupdomchgs
Definition: struct_stat.h:120
SCIP_HEUR * firstprimalheur
Definition: struct_stat.h:185
#define TPI_PARA
Definition: def_openmp.h:78
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:57
SCIP_LPSOLSTAT lastsblpsolstats[2]
Definition: struct_stat.h:188
SCIP_Longint ninitlpiterations
Definition: struct_stat.h:73
SCIP_CLOCK * solvingtimeoverall
Definition: struct_stat.h:161
SCIP_RETCODE SCIPtpiCollectJobs(int jobid)
Definition: tpi_none.c:66
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
Definition: scip_presol.c:236
SCIP_RETCODE SCIPincludeHeurSync(SCIP *scip)
Definition: heur_sync.c:161
SCIP_CLOCK * resproptime
Definition: struct_prop.h:69
void SCIPeventGlobalbndClearBoundChanges(SCIP_EVENTHDLR *eventhdlr)
SCIP_Longint nsbdivinglpiterations
Definition: struct_stat.h:76
#define NULL
Definition: lpi_spx1.cpp:164
SCIP_Longint nprimalresolvelpiterations
Definition: struct_stat.h:69
int nseparounds
Definition: struct_stat.h:234
void SCIPeventGlobalbndEnableBoundStorage(SCIP_EVENTHDLR *eventhdlr)
primal heuristic that adds given solutions
SCIP_RETCODE SCIPheurSyncPassSol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)
Definition: heur_sync.c:190
SCIP_Longint nconflictlps
Definition: struct_stat.h:213
int npresolchgbds
Definition: struct_stat.h:249
SCIP_Longint ncutsaddedviapool
Definition: struct_sepa.h:55
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:394
int npresoladdholes
Definition: struct_stat.h:250
SCIP_RETCODE SCIPincludePropSync(SCIP *scip)
Definition: prop_sync.c:288
SCIP main data structure.
SCIP_RETCODE SCIPpropSyncAddBndchg(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)
Definition: prop_sync.c:323
SCIP_Longint nsbbestsolsfound
Definition: struct_stat.h:108
SCIP_Longint ncutsappliedviapool
Definition: struct_sepa.h:57
SCIP_Longint nduallpiterations
Definition: struct_stat.h:66
SCIP_Longint nbarrierzeroitlps
Definition: struct_stat.h:200
SCIP_CLOCK * setuptime
Definition: struct_prop.h:66
SCIP_RETCODE SCIPaddConcurrentSol(SCIP *scip, SCIP_SOL *sol)
Definition: concurrent.c:371
SCIP_Real vsidsweight
Definition: struct_stat.h:132
SCIP_Real previousprimalrefgap
Definition: struct_stat.h:149
SCIP_Longint ncreatednodesrun
Definition: struct_stat.h:91
SCIP_RETCODE SCIPtpiCreateJob(SCIP_JOB **job, int jobid, SCIP_RETCODE(*jobfunc)(void *args), void *jobarg)
Definition: tpi_none.c:37
datastructures for storing primal CIP solutions
SCIP_Longint nprimalresolvelps
Definition: struct_stat.h:201
SCIP_CLOCK * divinglptime
Definition: struct_stat.h:169
SCIP_Longint nprobboundchgs
Definition: struct_stat.h:117
SCIP_CLOCK * presolvingtimeoverall
Definition: struct_stat.h:163
SCIP_Longint nduallps
Definition: struct_stat.h:196
the function declarations for the synchronization store
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
Definition: var.c:17393
datastructures for primal heuristics
SCIP_Longint nisstoppedcalls
Definition: struct_stat.h:215
#define SCIP_Bool
Definition: def.h:93
SCIP_BOUNDSTORE * SCIPeventGlobalbndGetBoundChanges(SCIP_EVENTHDLR *eventhdlr)
SCIP_Real lastprimalbound
Definition: struct_stat.h:151
SCIP_Longint ndivesetlpiterations
Definition: struct_stat.h:75
SCIP_Longint ndualresolvelps
Definition: struct_stat.h:202
SCIP_CLOCK * sbsoltime
Definition: struct_stat.h:175
SCIP_Longint ndivesetlps
Definition: struct_stat.h:208
SCIP_Longint ndomredsfound
Definition: struct_prop.h:51
SCIP_CLOCK * sbproptime
Definition: struct_prop.h:68
SCIP_CLOCK * presolvingtime
Definition: struct_stat.h:162
int npresolrounds
Definition: struct_stat.h:242
SCIP_Longint nearlybacktracks
Definition: struct_stat.h:94
SCIP_Longint nlexdualresolvelpiterations
Definition: struct_stat.h:71
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:319
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
SCIP_Real lastlowerbound
Definition: struct_stat.h:153
int SCIPgetConcurrentVaridx(SCIP *scip, SCIP_VAR *var)
Definition: concurrent.c:422
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip_prob.c:3765
void SCIPenableConcurrentBoundStorage(SCIP *scip)
Definition: concurrent.c:275
SCIP_Longint nrepropcutoffs
Definition: struct_stat.h:100
#define TPI_SINGLE
Definition: def_openmp.h:83
#define MAX(x, y)
Definition: tclique_def.h:92
SCIP_RETCODE SCIPfreeConcurrent(SCIP *scip)
Definition: concurrent.c:151
SCIP_Longint lastdivenode
Definition: struct_stat.h:111
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:599
propagator for applying global bound changes that were communicated by other concurrent solvers ...
int parallel_mode
Definition: struct_set.h:570
int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:525
SCIP_Longint ncutoffs
Definition: struct_sepa.h:51
SCIP_RETCODE SCIPcopyConcurrentSolvingStats(SCIP *source, SCIP *target)
Definition: concurrent.c:539
SCIP_Real maxcopytime
Definition: struct_stat.h:140
SCIP_RETCODE SCIPincrementConcurrentTime(SCIP *scip, SCIP_Real val)
Definition: concurrent.c:189
datastructures for problem statistics
SCIP_Longint ncutsaddeddirect
Definition: struct_sepa.h:56
SCIP_Longint nnz
Definition: struct_stat.h:189
helper functions for concurrent scip solvers
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:941
SCIP_CLOCK * lexduallptime
Definition: struct_stat.h:166
SCIP_Longint nnodesbeforefirst
Definition: struct_stat.h:122
SCIP_Longint nrootlpiterations
Definition: struct_stat.h:63
SCIP_CLOCK * strongbranchtime
Definition: struct_stat.h:170
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip_presol.c:249
int SCIPgetNHeurs(SCIP *scip)
Definition: scip_heur.c:282
SCIP_RETCODE SCIPcopySolStats(SCIP_SOL *source, SCIP_SOL *target)
Definition: concurrent.c:404
SCIP_Real firstsolgap
Definition: struct_stat.h:135
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip_mem.c:113
datastructures for propagators
SCIP_Real SCIPgetConcurrentGap(SCIP *scip)
Definition: concurrent.c:335
SCIP_Longint lastconflictnode
Definition: struct_stat.h:112
SCIP_Longint domchgcount
Definition: struct_stat.h:114
SCIP_Longint ncalls
Definition: struct_heur.h:99
SCIP_Real SCIPgetConcurrentDualbound(SCIP *scip)
Definition: concurrent.c:305
SCIP_RETCODE SCIPconcsolverExec(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:325
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:144
SCIP_RETCODE SCIPtpiSumbitJob(SCIP_JOB *job, SCIP_SUBMITSTATUS *status)
Definition: tpi_none.c:53
SCIP_Longint nbarrierlps
Definition: struct_stat.h:199
SCIP_Longint nprimalzeroitlps
Definition: struct_stat.h:195
SCIP_CLOCK * primallptime
Definition: struct_stat.h:164
SCIP_RETCODE SCIPaddConcurrentSolver(SCIP *scip, SCIP_CONCSOLVER *concsolver)
Definition: concurrent.c:138
SCIP_SET * set
Definition: struct_scip.h:72
void SCIPsyncstoreSetSolveIsStopped(SCIP_SYNCSTORE *syncstore, SCIP_Bool stopped)
Definition: syncstore.c:255
SCIP_Longint SCIPgetConcurrentNTightenedIntBnds(SCIP *scip)
Definition: concurrent.c:360
SCIP_Longint npsbestsolsfound
Definition: struct_stat.h:107
int nrootboundchgsrun
Definition: struct_stat.h:223
SCIP_Longint ndomredsfound
Definition: struct_sepa.h:60
SCIP_Longint nboundchgs
Definition: struct_stat.h:115
SCIP_Longint SCIPpropSyncGetNTightenedIntBnds(SCIP_PROP *prop)
Definition: prop_sync.c:378
SCIP_Longint nbestsolsfound
Definition: struct_heur.h:101
SCIP_Real time
Definition: struct_sol.h:76
#define SCIP_Real
Definition: def.h:186
internal methods for problem statistics
void SCIPprobSetDualbound(SCIP_PROB *prob, SCIP_Real dualbound)
Definition: prob.c:1453
SCIP_Real firstprimaltime
Definition: struct_stat.h:134
SCIP_Real referencebound
Definition: struct_stat.h:156
SCIP_Longint nrepropboundchgs
Definition: struct_stat.h:99
datastructures for separators
SCIP_Real firstprimalbound
Definition: struct_stat.h:133
datastructures for collecting primal CIP solutions and primal informations
SCIP_Longint ntotalinternalnodes
Definition: struct_stat.h:88
SCIP_CLOCK * duallptime
Definition: struct_stat.h:165
int SCIPtpiGetThreadNum(void)
Definition: tpi_openmp.c:349
SCIP_CLOCK * reoptupdatetime
Definition: struct_stat.h:180
#define SCIP_Longint
Definition: def.h:171
SCIP_Bool SCIPIsConcurrentSolNew(SCIP *scip, SCIP_SOL *sol)
Definition: concurrent.c:438
int SCIPvarGetIndex(SCIP_VAR *var)
Definition: var.c:17603
SCIP_Longint nactivatednodes
Definition: struct_stat.h:92
SCIP_Longint nprimallpiterations
Definition: struct_stat.h:65
SCIP_Longint nreprops
Definition: struct_stat.h:98
SCIP_BOUNDSTORE * SCIPgetConcurrentGlobalBoundChanges(SCIP *scip)
Definition: concurrent.c:451
SCIP_Longint nsbsolsfound
Definition: struct_stat.h:104
SCIP_EVENTHDLR * eventglobalbnd
SCIP_CLOCK * nodeactivationtime
Definition: struct_stat.h:176
SCIP_Longint ndualzeroitlps
Definition: struct_stat.h:197
SCIP_Real firstlptime
Definition: struct_stat.h:142
SCIP_PROP * propsync
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip_sepa.c:260
SCIP_Longint ninternalnodes
Definition: struct_stat.h:83
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition: prob.c:2116
int plungedepth
Definition: struct_stat.h:238
SCIP_Real previousgap
Definition: struct_stat.h:147
SCIP_Longint nnodelps
Definition: struct_stat.h:204
int SCIPgetNSepas(SCIP *scip)
Definition: scip_sepa.c:273
SCIP_Longint nnodes
Definition: struct_stat.h:82
concurrent data struct
int nrootintfixingsrun
Definition: struct_stat.h:225
SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:127
#define SCIP_CALL_ABORT(x)
Definition: def.h:373
int firstprimaldepth
Definition: struct_stat.h:272
SCIP_Longint nprobholechgs
Definition: struct_stat.h:118
int SCIPsyncstoreGetNSolvers(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:549
SCIP_Longint nlimsolsfound
Definition: struct_primal.h:49
int npresolupgdconss
Definition: struct_stat.h:253
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:161
SCIP_CONCSOLVER * concsolver
datastructures for global SCIP settings
int SCIPsolGetIndex(SCIP_SOL *sol)
Definition: sol.c:2644
SCIP_Real dualrefintegral
Definition: struct_stat.h:144
int SCIPgetNProps(SCIP *scip)
Definition: scip_prop.c:355
int subscipdepth
Definition: struct_stat.h:217
SCIP_RETCODE SCIPsynchronize(SCIP *scip)
Definition: concurrent.c:245
SCIP_Longint ninitlps
Definition: struct_stat.h:206
SCIP callable library.
SCIP_Longint ndelayedcutoffs
Definition: struct_stat.h:97
SCIP_CLOCK * lpsoltime
Definition: struct_stat.h:172
SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)
Definition: misc.c:11114
SCIP_Longint totaldivesetdepth
Definition: struct_stat.h:216
SCIP_RETCODE SCIPcreateConcurrent(SCIP *scip, SCIP_CONCSOLVER *concsolver, int *varperm)
Definition: concurrent.c:57
SCIP_Longint ndivinglpiterations
Definition: struct_stat.h:74