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