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-2019 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 visit 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 = scip->stat->solindex;
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  /* cppcheck-suppress unassignedVariable */
505  SCIP_JOB* job;
506  SCIP_SUBMITSTATUS status;
507 
508  SCIP_CALL_ABORT( SCIPtpiCreateJob(&job, jobid, execConcsolver, scip) );
509  SCIP_CALL_ABORT( SCIPtpiSumbitJob(job, &status) );
510 
511  assert(status == SCIP_SUBMIT_SUCCESS);
512  }
513  }
514  }
515 
516  retcode = SCIPtpiCollectJobs(jobid);
517  idx = SCIPsyncstoreGetWinner(syncstore);
518  assert(idx >= 0 && idx < nconcsolvers);
519 
520  SCIP_CALL( SCIPconcsolverGetSolvingData(concsolvers[idx], scip) );
521 
522  return retcode;
523 }
524 
525 /** copy solving statistics */
527  SCIP* source, /**< SCIP data structure */
528  SCIP* target /**< target SCIP data structure */
529  )
530 {
531  SCIP_Real tmptime;
532  SCIP_HEUR* heur;
533  SCIP_NODE* root;
534  SCIP_PROP* prop;
535  SCIP_SEPA* sepa;
536  SCIP_PRESOL* presol;
537  SCIP_HEUR** heurs;
538  int nheurs;
539  SCIP_PROP** props;
540  int nprops;
541  SCIP_SEPA** sepas;
542  int nsepas;
543  SCIP_PRESOL** presols;
544  int npresols;
545  int i;
546 
547  assert(source != NULL);
548  assert(target != NULL);
549 
550  heurs = SCIPgetHeurs(target);
551  nheurs = SCIPgetNHeurs(target);
552 
553  for( i = 0; i < nheurs; ++i )
554  {
555  heur = SCIPfindHeur(source, SCIPheurGetName(heurs[i]));
556 
557  if( heur != NULL )
558  {
559  heurs[i]->nbestsolsfound += heur->nbestsolsfound;
560  heurs[i]->ncalls += heur->ncalls;
561  heurs[i]->nsolsfound += heur->nsolsfound;
562  /* TODO divesets */
563  tmptime = SCIPgetClockTime(target, heurs[i]->setuptime);
564  tmptime += SCIPgetClockTime(source, heur->setuptime);
565  SCIP_CALL( SCIPsetClockTime(target, heurs[i]->setuptime, tmptime) );
566 
567  tmptime = SCIPgetClockTime(target, heurs[i]->heurclock);
568  tmptime += SCIPgetClockTime(source, heur->heurclock);
569  SCIP_CALL( SCIPsetClockTime(target, heurs[i]->heurclock, tmptime) );
570  }
571  }
572 
573  props = SCIPgetProps(target);
574  nprops = SCIPgetNProps(target);
575 
576  for( i = 0; i < nprops; ++i )
577  {
578  prop = SCIPfindProp(source, SCIPpropGetName(props[i]));
579 
580  if( prop != NULL )
581  {
582  props[i]->ncalls += prop->ncalls;
583  props[i]->nrespropcalls += prop->nrespropcalls;
584  props[i]->ncutoffs += prop->ncutoffs;
585  props[i]->ndomredsfound += prop->ndomredsfound;
586 
587  tmptime = SCIPgetClockTime(target, props[i]->proptime);
588  tmptime += SCIPgetClockTime(source, prop->proptime);
589  SCIP_CALL( SCIPsetClockTime(target, props[i]->proptime, tmptime) );
590 
591  tmptime = SCIPgetClockTime(target, props[i]->sbproptime);
592  tmptime += SCIPgetClockTime(source, prop->sbproptime);
593  SCIP_CALL( SCIPsetClockTime(target, props[i]->sbproptime, tmptime) );
594 
595  tmptime = SCIPgetClockTime(target, props[i]->resproptime);
596  tmptime += SCIPgetClockTime(source, prop->resproptime);
597  SCIP_CALL( SCIPsetClockTime(target, props[i]->resproptime, tmptime) );
598 
599  tmptime = SCIPgetClockTime(target, props[i]->presoltime);
600  tmptime += SCIPgetClockTime(source, prop->presoltime);
601  SCIP_CALL( SCIPsetClockTime(target, props[i]->presoltime, tmptime) );
602 
603  tmptime = SCIPgetClockTime(target, props[i]->setuptime);
604  tmptime += SCIPgetClockTime(source, prop->setuptime);
605  SCIP_CALL( SCIPsetClockTime(target, props[i]->setuptime, tmptime) );
606  }
607  }
608 
609  presols = SCIPgetPresols(target);
610  npresols = SCIPgetNPresols(target);
611 
612  for( i = 0; i < npresols; ++i )
613  {
614  presol = SCIPfindPresol(source, SCIPpresolGetName(presols[i]));
615 
616  if( presol != NULL )
617  {
618  presols[i]->ncalls += presol->ncalls;
619  presols[i]->nfixedvars += presol->nfixedvars;
620  presols[i]->naggrvars += presol->naggrvars;
621  presols[i]->nchgvartypes += presol->nchgvartypes;
622  presols[i]->nchgbds += presol->nchgbds;
623  presols[i]->naddholes += presol->naddholes;
624  presols[i]->ndelconss += presol->ndelconss;
625  presols[i]->naddconss += presol->naddconss;
626  presols[i]->nupgdconss += presol->nupgdconss;
627  presols[i]->nchgcoefs += presol->nchgcoefs;
628  presols[i]->nchgsides += presol->nchgsides;
629  presols[i]->nfixedvars += presol->nfixedvars;
630  presols[i]->nfixedvars += presol->nfixedvars;
631  presols[i]->nfixedvars += presol->nfixedvars;
632 
633  tmptime = SCIPgetClockTime(target, presols[i]->setuptime);
634  tmptime += SCIPgetClockTime(source, presol->setuptime);
635  SCIP_CALL( SCIPsetClockTime(target, presols[i]->setuptime, tmptime) );
636 
637  tmptime = SCIPgetClockTime(target, presols[i]->presolclock);
638  tmptime += SCIPgetClockTime(source, presol->presolclock);
639  SCIP_CALL( SCIPsetClockTime(target, presols[i]->presolclock, tmptime) );
640  }
641  }
642 
643  sepas = SCIPgetSepas(target);
644  nsepas = SCIPgetNSepas(target);
645 
646  for( i = 0; i < nsepas; ++i )
647  {
648  sepa = SCIPfindSepa(source, SCIPsepaGetName(sepas[i]));
649 
650  if( sepa != NULL )
651  {
652  sepas[i]->lastsepanode = sepa->lastsepanode;
653  sepas[i]->ncalls += sepa->ncalls;
654  sepas[i]->ncutoffs += sepa->ncutoffs;
655  sepas[i]->ncutsfound += sepa->ncutsfound;
656  sepas[i]->ncutsapplied += sepa->ncutsapplied;
657  sepas[i]->nconssfound += sepa->nconssfound;
658  sepas[i]->ndomredsfound += sepa->ndomredsfound;
659  sepas[i]->maxbounddist = MAX(sepas[i]->maxbounddist, sepa->maxbounddist);
660 
661  tmptime = SCIPgetClockTime(target, sepas[i]->setuptime);
662  tmptime += SCIPgetClockTime(source, sepa->setuptime);
663  SCIP_CALL( SCIPsetClockTime(target, sepas[i]->setuptime, tmptime) );
664 
665  tmptime = SCIPgetClockTime(target, sepas[i]->sepaclock);
666  tmptime += SCIPgetClockTime(source, sepa->sepaclock);
667  SCIP_CALL( SCIPsetClockTime(target, sepas[i]->sepaclock, tmptime) );
668  }
669  }
670 
671  target->primal->nsolsfound = source->primal->nsolsfound;
672  target->primal->nbestsolsfound = source->primal->nbestsolsfound;
673  target->primal->nlimsolsfound = source->primal->nlimsolsfound;
674  SCIPprobSetDualbound(target->transprob, SCIPprobExternObjval(target->transprob, target->origprob, target->set, SCIPgetDualbound(source)));
675  root = SCIPgetRootNode(target);
676 
677  if( root != NULL )
678  {
679  /* in the copied SCIP the dualbound is in the transformed space of the target */
680  SCIP_CALL( SCIPupdateNodeLowerbound(target, root, SCIPgetDualbound(source)) );
681  }
682 
683  target->stat->nlpiterations = source->stat->nlpiterations;
684  target->stat->nrootlpiterations = source->stat->nrootlpiterations;
686  target->stat->nprimallpiterations = source->stat->nprimallpiterations;
687  target->stat->nduallpiterations = source->stat->nduallpiterations;
693  target->stat->nnodelpiterations = source->stat->nnodelpiterations;
694  target->stat->ninitlpiterations = source->stat->ninitlpiterations;
695  target->stat->ndivinglpiterations = source->stat->ndivinglpiterations;
698  target->stat->nsblpiterations = source->stat->nsblpiterations;
699  target->stat->nrootsblpiterations = source->stat->nrootsblpiterations;
701  target->stat->nnodes = source->stat->nnodes;
702  target->stat->ninternalnodes = source->stat->ninternalnodes;
703  target->stat->nobjleaves = source->stat->nobjleaves;
704  target->stat->nfeasleaves = source->stat->nfeasleaves;
705  target->stat->ninfeasleaves = source->stat->ninfeasleaves;
706  target->stat->ntotalnodes = source->stat->ntotalnodes;
707  target->stat->ntotalinternalnodes = source->stat->ntotalinternalnodes;
708  target->stat->ncreatednodes = source->stat->ncreatednodes;
709  target->stat->ncreatednodesrun = source->stat->ncreatednodesrun;
710  target->stat->nactivatednodes = source->stat->nactivatednodes;
711  target->stat->ndeactivatednodes = source->stat->ndeactivatednodes;
712  target->stat->nearlybacktracks = source->stat->nearlybacktracks;
713  target->stat->nnodesaboverefbound = source->stat->nnodesaboverefbound;
714  target->stat->nbacktracks = source->stat->nbacktracks;
715  target->stat->ndelayedcutoffs = source->stat->ndelayedcutoffs;
716  target->stat->nreprops = source->stat->nreprops;
717  target->stat->nrepropboundchgs = source->stat->nrepropboundchgs;
718  target->stat->nrepropcutoffs = source->stat->nrepropcutoffs;
719  target->stat->nlpsolsfound = source->stat->nlpsolsfound;
720  target->stat->npssolsfound = source->stat->npssolsfound;
721  target->stat->nsbsolsfound = source->stat->nsbsolsfound;
722  target->stat->nlpbestsolsfound = source->stat->nlpbestsolsfound;
723  target->stat->npsbestsolsfound = source->stat->npsbestsolsfound;
724  target->stat->nsbbestsolsfound = source->stat->nsbbestsolsfound;
725  target->stat->nexternalsolsfound = source->stat->nexternalsolsfound;
726  target->stat->lastdispnode = source->stat->lastdispnode;
727  target->stat->lastdivenode = source->stat->lastdivenode;
728  target->stat->lastconflictnode = source->stat->lastconflictnode;
729  target->stat->bestsolnode = source->stat->bestsolnode;
730  target->stat->domchgcount = source->stat->domchgcount;
731  target->stat->nboundchgs = source->stat->nboundchgs;
732  target->stat->nholechgs = source->stat->nholechgs;
733  target->stat->nprobboundchgs = source->stat->nprobboundchgs;
734  target->stat->nprobholechgs = source->stat->nprobholechgs;
735  target->stat->nsbdowndomchgs = source->stat->nsbdowndomchgs;
736  target->stat->nsbupdomchgs = source->stat->nsbupdomchgs;
737  target->stat->nsbtimesiterlimhit = source->stat->nsbtimesiterlimhit;
738  target->stat->nnodesbeforefirst = source->stat->nnodesbeforefirst;
739  target->stat->ninitconssadded = source->stat->ninitconssadded;
740  target->stat->firstlpdualbound = SCIPprobExternObjval(target->transprob, target->origprob, target->set, source->stat->firstlpdualbound);
741  target->stat->rootlowerbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->rootlowerbound);
742  target->stat->vsidsweight = source->stat->vsidsweight;
743  target->stat->firstprimalbound = SCIPprobExternObjval(target->transprob, target->origprob, target->set, source->stat->firstprimalbound);
744  target->stat->firstprimaltime = source->stat->firstprimaltime;
745  target->stat->firstsolgap = source->stat->firstsolgap;
746  target->stat->lastsolgap = source->stat->lastsolgap;
747  target->stat->primalzeroittime = source->stat->primalzeroittime;
748  target->stat->dualzeroittime = source->stat->dualzeroittime;
749  target->stat->barrierzeroittime = source->stat->barrierzeroittime;
750  target->stat->maxcopytime = MAX(source->stat->maxcopytime, target->stat->maxcopytime);
751  target->stat->mincopytime = MIN(source->stat->mincopytime, target->stat->mincopytime);
752  target->stat->firstlptime = source->stat->firstlptime;
753  target->stat->lastbranchvalue = source->stat->lastbranchvalue;
754  target->stat->primaldualintegral = source->stat->primaldualintegral;
755  target->stat->previousgap = source->stat->previousgap;
757  target->stat->lastprimalbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastprimalbound);
758  target->stat->lastdualbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastdualbound);
759  target->stat->lastlowerbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastlowerbound);
760  target->stat->lastupperbound = SCIPprobExternObjval(source->transprob, source->origprob, source->set, source->stat->lastupperbound);
761  target->stat->rootlpbestestimate = source->stat->rootlpbestestimate;
762  target->stat->referencebound = source->stat->referencebound;
763 
764  /*tmptime = SCIPgetClockTime(target, target->stat->solvingtime);
765  tmptime += SCIPgetClockTime(source, source->stat->solvingtime);
766  SCIP_CALL( SCIPsetClockTime(target, target->stat->solvingtime, tmptime) );*/
767 
768  /* TODO */
769  tmptime = SCIPgetClockTime(target, target->stat->solvingtimeoverall);
770  tmptime += SCIPgetClockTime(source, source->stat->solvingtimeoverall);
771  SCIP_CALL( SCIPsetClockTime(target, target->stat->solvingtimeoverall, tmptime) );
772 
773  tmptime = SCIPgetClockTime(target, target->stat->presolvingtime);
774  tmptime += SCIPgetClockTime(source, source->stat->presolvingtime);
775  SCIP_CALL( SCIPsetClockTime(target, target->stat->presolvingtime, tmptime) );
776 
777  tmptime = SCIPgetClockTime(target, target->stat->presolvingtimeoverall);
778  tmptime += SCIPgetClockTime(source, source->stat->presolvingtimeoverall);
779  SCIP_CALL( SCIPsetClockTime(target, target->stat->presolvingtimeoverall, tmptime) );
780 
781  tmptime = SCIPgetClockTime(target, target->stat->primallptime);
782  tmptime += SCIPgetClockTime(source, source->stat->primallptime);
783  SCIP_CALL( SCIPsetClockTime(target, target->stat->primallptime, tmptime) );
784 
785  tmptime = SCIPgetClockTime(target, target->stat->duallptime);
786  tmptime += SCIPgetClockTime(source, source->stat->duallptime);
787  SCIP_CALL( SCIPsetClockTime(target, target->stat->duallptime, tmptime) );
788 
789  tmptime = SCIPgetClockTime(target, target->stat->lexduallptime);
790  tmptime += SCIPgetClockTime(source, source->stat->lexduallptime);
791  SCIP_CALL( SCIPsetClockTime(target, target->stat->lexduallptime, tmptime) );
792 
793  tmptime = SCIPgetClockTime(target, target->stat->barrierlptime);
794  tmptime += SCIPgetClockTime(source, source->stat->barrierlptime);
795  SCIP_CALL( SCIPsetClockTime(target, target->stat->barrierlptime, tmptime) );
796 
797  tmptime = SCIPgetClockTime(target, target->stat->divinglptime);
798  tmptime += SCIPgetClockTime(source, source->stat->divinglptime);
799  SCIP_CALL( SCIPsetClockTime(target, target->stat->divinglptime, tmptime) );
800 
801  tmptime = SCIPgetClockTime(target, target->stat->strongbranchtime);
802  tmptime += SCIPgetClockTime(source, source->stat->strongbranchtime);
803  SCIP_CALL( SCIPsetClockTime(target, target->stat->strongbranchtime, tmptime) );
804 
805  tmptime = SCIPgetClockTime(target, target->stat->conflictlptime);
806  tmptime += SCIPgetClockTime(source, source->stat->conflictlptime);
807  SCIP_CALL( SCIPsetClockTime(target, target->stat->conflictlptime, tmptime) );
808 
809  tmptime = SCIPgetClockTime(target, target->stat->lpsoltime);
810  tmptime += SCIPgetClockTime(source, source->stat->lpsoltime);
811  SCIP_CALL( SCIPsetClockTime(target, target->stat->lpsoltime, tmptime) );
812 
813  tmptime = SCIPgetClockTime(target, target->stat->pseudosoltime);
814  tmptime += SCIPgetClockTime(source, source->stat->pseudosoltime);
815  SCIP_CALL( SCIPsetClockTime(target, target->stat->pseudosoltime, tmptime) );
816 
817  tmptime = SCIPgetClockTime(target, target->stat->sbsoltime);
818  tmptime += SCIPgetClockTime(source, source->stat->sbsoltime);
819  SCIP_CALL( SCIPsetClockTime(target, target->stat->sbsoltime, tmptime) );
820 
821  tmptime = SCIPgetClockTime(target, target->stat->nodeactivationtime);
822  tmptime += SCIPgetClockTime(source, source->stat->nodeactivationtime);
823  SCIP_CALL( SCIPsetClockTime(target, target->stat->nodeactivationtime, tmptime) );
824 
825  tmptime = SCIPgetClockTime(target, target->stat->nlpsoltime);
826  tmptime += SCIPgetClockTime(source, source->stat->nlpsoltime);
827  SCIP_CALL( SCIPsetClockTime(target, target->stat->nlpsoltime, tmptime) );
828 
829  tmptime = SCIPgetClockTime(target, target->stat->strongpropclock);
830  tmptime += SCIPgetClockTime(source, source->stat->strongpropclock);
831  SCIP_CALL( SCIPsetClockTime(target, target->stat->strongpropclock, tmptime) );
832 
833  tmptime = SCIPgetClockTime(target, target->stat->reoptupdatetime);
834  tmptime += SCIPgetClockTime(source, source->stat->reoptupdatetime);
835  SCIP_CALL( SCIPsetClockTime(target, target->stat->reoptupdatetime, tmptime) );
836 
837  heur = source->stat->firstprimalheur;
838 
839  if( heur != NULL )
840  target->stat->firstprimalheur = SCIPfindHeur(target, SCIPheurGetName(heur));
841 
842  target->stat->status = source->stat->status;
843  target->stat->lastbranchdir = source->stat->lastbranchdir;
844  target->stat->lastsblpsolstats[0] = source->stat->lastsblpsolstats[0];
845  target->stat->lastsblpsolstats[1] = source->stat->lastsblpsolstats[1];
846  target->stat->nnz = source->stat->nnz;
847  target->stat->lpcount = source->stat->lpcount;
848  target->stat->nlps = source->stat->nlps;
849  target->stat->nrootlps = source->stat->nrootlps;
850  target->stat->nprimallps = source->stat->nprimallps;
851  target->stat->nprimalzeroitlps = source->stat->nprimalzeroitlps;
852  target->stat->nduallps = source->stat->nduallps;
853  target->stat->ndualzeroitlps = source->stat->ndualzeroitlps;
854  target->stat->nlexduallps = source->stat->nlexduallps;
855  target->stat->nbarrierlps = source->stat->nbarrierlps;
856  target->stat->nbarrierzeroitlps = source->stat->nbarrierzeroitlps;
857  target->stat->nprimalresolvelps = source->stat->nprimalresolvelps;
858  target->stat->ndualresolvelps = source->stat->ndualresolvelps;
859  target->stat->nlexdualresolvelps = source->stat->nlexdualresolvelps;
860  target->stat->nnodelps = source->stat->nnodelps;
861  target->stat->ninitlps = source->stat->ninitlps;
862  target->stat->ndivinglps = source->stat->ndivinglps;
863  target->stat->ndivesetlps = source->stat->ndivesetlps;
864  target->stat->nsbdivinglps = source->stat->nsbdivinglps;
865  target->stat->nstrongbranchs = source->stat->nstrongbranchs;
866  target->stat->nrootstrongbranchs = source->stat->nrootstrongbranchs;
867  target->stat->nconflictlps = source->stat->nconflictlps;
868  target->stat->nnlps = source->stat->nnlps;
869  target->stat->nisstoppedcalls = source->stat->nisstoppedcalls;
870  target->stat->totaldivesetdepth = source->stat->totaldivesetdepth;
871  target->stat->ndivesetcalls = source->stat->ndivesetcalls;
872  target->stat->nruns = source->stat->nruns;
873  target->stat->nconfrestarts = source->stat->nconfrestarts;
874  target->stat->nrootboundchgs = source->stat->nrootboundchgs;
875  target->stat->nrootboundchgsrun = source->stat->nrootboundchgsrun;
876  target->stat->nrootintfixings = source->stat->nrootintfixings;
877  target->stat->nrootintfixingsrun = source->stat->nrootintfixingsrun;
878  target->stat->prevrunnvars = source->stat->prevrunnvars;
879  target->stat->npricerounds = source->stat->npricerounds;
880  target->stat->nseparounds = source->stat->nseparounds;
881  target->stat->maxdepth = source->stat->maxdepth;
882  target->stat->maxtotaldepth = source->stat->maxtotaldepth;
883  target->stat->plungedepth = source->stat->plungedepth;
884  target->stat->npresolrounds += source->stat->npresolrounds;
885  target->stat->npresolroundsfast += source->stat->npresolroundsfast;
886  target->stat->npresolroundsmed += source->stat->npresolroundsmed;
887  target->stat->npresolroundsext += source->stat->npresolroundsext;
888  target->stat->npresolfixedvars += source->stat->npresolfixedvars;
889  target->stat->npresolaggrvars += source->stat->npresolaggrvars;
890  target->stat->npresolchgvartypes += source->stat->npresolchgvartypes;
891  target->stat->npresolchgbds += source->stat->npresolchgbds;
892  target->stat->npresoladdholes += source->stat->npresoladdholes;
893  target->stat->npresoldelconss += source->stat->npresoldelconss;
894  target->stat->npresoladdconss += source->stat->npresoladdconss;
895  target->stat->npresolupgdconss += source->stat->npresolupgdconss;
896  target->stat->npresolchgcoefs += source->stat->npresolchgcoefs;
897  target->stat->npresolchgsides += source->stat->npresolchgsides;
898  target->stat->nrunsbeforefirst = source->stat->nrunsbeforefirst;
899  target->stat->firstprimaldepth = source->stat->firstprimaldepth;
900  target->stat->ncopies += source->stat->ncopies;
901  target->stat->nreoptruns = source->stat->nreoptruns;
902 
903  /* set the stage but do not set to earlier stage */
904  target->set->stage = MAX(source->set->stage, target->set->stage);
905 
906  return SCIP_OKAY;
907 }
SCIP_Longint nlexduallps
Definition: struct_stat.h:182
SCIP_Longint nprimallps
Definition: struct_stat.h:178
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:97
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:138
SCIP_Longint nsbdivinglps
Definition: struct_stat.h:192
int npresoladdconss
Definition: struct_stat.h:235
SCIP_Longint ninfeasleaves
Definition: struct_stat.h:77
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Real firstlpdualbound
Definition: struct_stat.h:118
int npresolroundsfast
Definition: struct_stat.h:226
#define NULL
Definition: def.h:253
internal methods for managing events
SCIP_Longint nnodelpiterations
Definition: struct_stat.h:63
SCIP_Longint nlpsolsfound
Definition: struct_stat.h:92
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:134
int solindex
Definition: struct_stat.h:253
SCIP_CLOCK * setuptime
Definition: struct_sepa.h:59
SCIP_Longint nsbdowndomchgs
Definition: struct_stat.h:110
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1254
SCIP_STATUS status
Definition: struct_stat.h:170
SCIP_Longint nlpiterations
Definition: struct_stat.h:53
SCIP_RETCODE SCIPsetIncludeConcsolver(SCIP_SET *set, SCIP_CONCSOLVER *concsolver)
Definition: set.c:4372
SCIP_Longint nfeasleaves
Definition: struct_stat.h:76
SCIP_CONCSOLVER ** concsolvers
Definition: struct_set.h:91
SCIP_Longint ndeactivatednodes
Definition: struct_stat.h:84
int SCIPgetNConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:107
SCIP_Longint nlexdualresolvelps
Definition: struct_stat.h:187
int npricerounds
Definition: struct_stat.h:216
SCIP_Bool concurrent_commvarbnds
Definition: struct_set.h:535
datastructures for presolvers
SCIP_Longint nlps
Definition: struct_stat.h:176
int depth
Definition: struct_sol.h:79
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:2153
SCIP_Longint nbarrierlpiterations
Definition: struct_stat.h:59
SCIP_Longint ninitconssadded
Definition: struct_stat.h:114
static SCIP_RETCODE execConcsolver(void *args)
Definition: concurrent.c:457
SCIP_CLOCK * conflictlptime
Definition: struct_stat.h:155
int nrunsbeforefirst
Definition: struct_stat.h:254
SCIP_Real SCIPgetConcurrentPrimalbound(SCIP *scip)
Definition: concurrent.c:311
SCIP_Real rootlowerbound
Definition: struct_stat.h:119
enum SCIP_Submitstatus SCIP_SUBMITSTATUS
Definition: type_tpi.h:45
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
Definition: scip_event.c:224
SCIP_Longint ntotalnodes
Definition: struct_stat.h:78
SCIP_Real previntegralevaltime
Definition: struct_stat.h:134
int npresolaggrvars
Definition: struct_stat.h:230
SCIP_Longint nodenum
Definition: struct_sol.h:67
SCIP_Real lastbranchvalue
Definition: struct_stat.h:131
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip_heur.c:261
eventhdlr for storing all global bound changes
SCIP_Longint nrootfirstlpiterations
Definition: struct_stat.h:55
SCIP_RETCODE SCIPincludePropSync(SCIP *scip)
Definition: prop_sync.c:278
SCIP_Longint ndivinglps
Definition: struct_stat.h:190
SCIP_RETCODE SCIPeventCreateSync(SCIP_EVENT **event, BMS_BLKMEM *blkmem)
Definition: event.c:473
int nconcsolvers
Definition: struct_set.h:134
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:78
SCIP_Longint nsbtimesiterlimhit
Definition: struct_stat.h:112
void SCIPeventGlobalbndDisableBoundStorage(SCIP_EVENTHDLR *eventhdlr)
SCIP_BRANCHDIR lastbranchdir
Definition: struct_stat.h:171
int npresolfixedvars
Definition: struct_stat.h:229
SCIP_PRIMAL * primal
Definition: struct_scip.h:83
SCIP_CLOCK * presoltime
Definition: struct_prop.h:61
SCIP_Real lastsolgap
Definition: struct_stat.h:124
SCIP_Longint nrootstrongbranchs
Definition: struct_stat.h:195
SCIP_CONCURRENT * concurrent
Definition: struct_scip.h:99
int nreoptruns
Definition: struct_stat.h:257
SCIP_CLOCK * proptime
Definition: struct_prop.h:58
int npresoldelconss
Definition: struct_stat.h:234
SCIP_Longint nstrongbranchs
Definition: struct_stat.h:194
SCIP_CLOCK * presolclock
Definition: struct_presol.h:50
SCIP_Longint ncalls
Definition: struct_prop.h:39
SCIP_Longint nholechgs
Definition: struct_stat.h:107
SCIP_Longint nrootsblpiterations
Definition: struct_stat.h:69
#define FALSE
Definition: def.h:73
SCIP_Real detertimecnt
Definition: struct_stat.h:143
SCIP_Longint ncutoffs
Definition: struct_prop.h:41
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
Definition: scip_presol.c:225
SCIP_Longint nrootlps
Definition: struct_stat.h:177
SCIP_Longint ncreatednodes
Definition: struct_stat.h:81
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:132
SCIP_Real maxbounddist
Definition: struct_sepa.h:46
SCIP_STAGE stage
Definition: struct_set.h:63
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Longint nnlps
Definition: struct_stat.h:197
SCIP_Longint nbacktracks
Definition: struct_stat.h:87
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:365
SCIP_Longint nsolsfound
Definition: struct_primal.h:39
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:95
int maxtotaldepth
Definition: struct_stat.h:220
SCIP_CLOCK * barrierlptime
Definition: struct_stat.h:151
SCIP_Longint lastdispnode
Definition: struct_stat.h:101
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip_mem.c:103
SCIP_Longint nnodesaboverefbound
Definition: struct_stat.h:86
SCIP_PROB * transprob
Definition: struct_scip.h:87
int npresolroundsext
Definition: struct_stat.h:228
SCIP_CLOCK * setuptime
Definition: struct_presol.h:49
SCIP_Real rootlpbestestimate
Definition: struct_stat.h:139
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:78
int maxdepth
Definition: struct_stat.h:219
SCIP_Real SCIPsyncstoreGetLastUpperbound(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:259
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip_presol.c:238
SCIP_CLOCK * nlpsoltime
Definition: struct_stat.h:161
SCIP_RETCODE SCIPincludeHeurSync(SCIP *scip)
Definition: heur_sync.c:151
SCIP_Real lastdualbound
Definition: struct_stat.h:136
int runnum
Definition: struct_sol.h:78
SCIP_Longint nlpbestsolsfound
Definition: struct_stat.h:96
SCIP_RETCODE SCIPconcurrentSolve(SCIP *scip)
Definition: concurrent.c:474
SCIP_Real dualzeroittime
Definition: struct_stat.h:126
SCIP_PROB * origprob
Definition: struct_scip.h:70
SCIP_Longint nexternalsolsfound
Definition: struct_stat.h:100
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:300
int nrootintfixings
Definition: struct_stat.h:207
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip_heur.c:248
SCIP_Longint nsblpiterations
Definition: struct_stat.h:68
SCIP_Real primalzeroittime
Definition: struct_stat.h:125
int nrootboundchgs
Definition: struct_stat.h:205
SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)
Definition: concurrent.c:278
int nconfrestarts
Definition: struct_stat.h:204
SCIP_Longint nlexduallpiterations
Definition: struct_stat.h:58
SCIP_CLOCK * strongpropclock
Definition: struct_stat.h:163
SCIP_Longint SCIPconcsolverGetMemTotal(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:509
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
Definition: scip_mem.h:92
int npresolchgcoefs
Definition: struct_stat.h:237
int npresolchgvartypes
Definition: struct_stat.h:231
SCIP_Longint nrespropcalls
Definition: struct_prop.h:40
SCIP_Real barrierzeroittime
Definition: struct_stat.h:127
void SCIPdisableConcurrentBoundStorage(SCIP *scip)
Definition: concurrent.c:254
SCIP_RETCODE SCIPconcsolverGetSolvingData(SCIP_CONCSOLVER *concsolver, SCIP *scip)
Definition: concsolver.c:333
SCIP_Longint nobjleaves
Definition: struct_stat.h:75
SCIP_Longint npssolsfound
Definition: struct_stat.h:94
SCIP_HEUR * heursync
SCIP_Real mincopytime
Definition: struct_stat.h:129
int npresolroundsmed
Definition: struct_stat.h:227
void SCIPconcsolverSetTimeSinceLastSync(SCIP_CONCSOLVER *concsolver, SCIP_Real time)
Definition: concsolver.c:521
int prevrunnvars
Definition: struct_stat.h:209
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_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition: scip_sepa.c:237
SCIP_Real SCIPsyncstoreGetLastLowerbound(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:270
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:174
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:201
SCIP_Longint bestsolnode
Definition: struct_stat.h:104
SCIP_Real SCIPconcsolverGetSyncFreq(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:499
SCIP_Longint nconflictlpiterations
Definition: struct_stat.h:70
int npresolchgsides
Definition: struct_stat.h:238
SCIP_CLOCK * pseudosoltime
Definition: struct_stat.h:158
SCIP_RETCODE SCIPincludeEventHdlrGlobalbnd(SCIP *scip)
SCIP_Longint nsbupdomchgs
Definition: struct_stat.h:111
SCIP_HEUR * firstprimalheur
Definition: struct_stat.h:169
#define TPI_PARA
Definition: def_openmp.h:69
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:47
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
Definition: scip_tree.c:99
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:931
SCIP_LPSOLSTAT lastsblpsolstats[2]
Definition: struct_stat.h:172
SCIP_Longint ninitlpiterations
Definition: struct_stat.h:64
SCIP_CLOCK * solvingtimeoverall
Definition: struct_stat.h:145
SCIP_EXPORT SCIP_RETCODE SCIPtpiCollectJobs(int jobid)
Definition: tpi_none.c:57
SCIP_Longint SCIPpropSyncGetNTightenedBnds(SCIP_PROP *prop)
Definition: prop_sync.c:353
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip_prob.c:3753
SCIP_CLOCK * resproptime
Definition: struct_prop.h:60
void SCIPeventGlobalbndClearBoundChanges(SCIP_EVENTHDLR *eventhdlr)
SCIP_Longint nsbdivinglpiterations
Definition: struct_stat.h:67
SCIP_Longint nprimalresolvelpiterations
Definition: struct_stat.h:60
int nseparounds
Definition: struct_stat.h:217
void SCIPeventGlobalbndEnableBoundStorage(SCIP_EVENTHDLR *eventhdlr)
SCIP_Longint SCIPpropSyncGetNTightenedIntBnds(SCIP_PROP *prop)
Definition: prop_sync.c:368
primal heuristic that adds given solutions
SCIP_Longint nconflictlps
Definition: struct_stat.h:196
int npresolchgbds
Definition: struct_stat.h:232
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:365
int npresoladdholes
Definition: struct_stat.h:233
SCIP main data structure.
SCIP_Longint nsbbestsolsfound
Definition: struct_stat.h:99
SCIP_Longint nduallpiterations
Definition: struct_stat.h:57
SCIP_Longint nbarrierzeroitlps
Definition: struct_stat.h:184
SCIP_EXPORT const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:696
SCIP_CLOCK * setuptime
Definition: struct_prop.h:57
int SCIPgetNOrigVars(SCIP *scip)
Definition: scip_prob.c:2427
SCIP_RETCODE SCIPaddConcurrentSol(SCIP *scip, SCIP_SOL *sol)
Definition: concurrent.c:362
SCIP_Real vsidsweight
Definition: struct_stat.h:120
int SCIPgetNSepas(SCIP *scip)
Definition: scip_sepa.c:263
SCIP_Longint ncreatednodesrun
Definition: struct_stat.h:82
datastructures for storing primal CIP solutions
SCIP_Longint nprimalresolvelps
Definition: struct_stat.h:185
SCIP_CLOCK * divinglptime
Definition: struct_stat.h:153
SCIP_Longint nprobboundchgs
Definition: struct_stat.h:108
SCIP_CLOCK * presolvingtimeoverall
Definition: struct_stat.h:147
SCIP_Longint nduallps
Definition: struct_stat.h:180
the function declarations for the synchronization store
datastructures for primal heuristics
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Longint nisstoppedcalls
Definition: struct_stat.h:198
#define SCIP_Bool
Definition: def.h:70
SCIP_BOUNDSTORE * SCIPeventGlobalbndGetBoundChanges(SCIP_EVENTHDLR *eventhdlr)
SCIP_Real lastprimalbound
Definition: struct_stat.h:135
SCIP_Longint ndivesetlpiterations
Definition: struct_stat.h:66
SCIP_Longint ndualresolvelps
Definition: struct_stat.h:186
SCIP_CLOCK * sbsoltime
Definition: struct_stat.h:159
SCIP_Longint ndivesetlps
Definition: struct_stat.h:191
SCIP_Longint ndomredsfound
Definition: struct_prop.h:42
SCIP_CLOCK * sbproptime
Definition: struct_prop.h:59
SCIP_CLOCK * presolvingtime
Definition: struct_stat.h:146
int npresolrounds
Definition: struct_stat.h:225
SCIP_Longint nearlybacktracks
Definition: struct_stat.h:85
SCIP_Longint nlexdualresolvelpiterations
Definition: struct_stat.h:62
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip_sepa.c:250
SCIP_Real lastlowerbound
Definition: struct_stat.h:137
int SCIPgetConcurrentVaridx(SCIP *scip, SCIP_VAR *var)
Definition: concurrent.c:413
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:589
void SCIPenableConcurrentBoundStorage(SCIP *scip)
Definition: concurrent.c:266
SCIP_Longint nrepropcutoffs
Definition: struct_stat.h:91
#define TPI_SINGLE
Definition: def_openmp.h:74
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip_prop.c:332
SCIP_EXPORT SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
Definition: var.c:16867
SCIP_RETCODE SCIPfreeConcurrent(SCIP *scip)
Definition: concurrent.c:142
#define MIN(x, y)
Definition: def.h:223
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
Definition: scip_prop.c:319
SCIP_Longint lastdivenode
Definition: struct_stat.h:102
SCIP_EXPORT int SCIPsolGetIndex(SCIP_SOL *sol)
Definition: sol.c:2584
SCIP_RETCODE SCIPheurSyncPassSol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)
Definition: heur_sync.c:180
propagator for applying global bound changes that were communicated by other concurrent solvers ...
int parallel_mode
Definition: struct_set.h:527
int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:516
SCIP_Longint ncutoffs
Definition: struct_sepa.h:41
SCIP_RETCODE SCIPcopyConcurrentSolvingStats(SCIP *source, SCIP *target)
Definition: concurrent.c:526
SCIP_Real maxcopytime
Definition: struct_stat.h:128
SCIP_RETCODE SCIPincrementConcurrentTime(SCIP *scip, SCIP_Real val)
Definition: concurrent.c:180
datastructures for problem statistics
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:117
SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)
Definition: misc.c:10589
SCIP_Longint nnz
Definition: struct_stat.h:173
helper functions for concurrent scip solvers
SCIP_CLOCK * lexduallptime
Definition: struct_stat.h:150
SCIP_Longint nnodesbeforefirst
Definition: struct_stat.h:113
SCIP_Longint nrootlpiterations
Definition: struct_stat.h:54
SCIP_CLOCK * strongbranchtime
Definition: struct_stat.h:154
SCIP_RETCODE SCIPcopySolStats(SCIP_SOL *source, SCIP_SOL *target)
Definition: concurrent.c:395
SCIP_Real firstsolgap
Definition: struct_stat.h:123
#define MAX(x, y)
Definition: def.h:222
datastructures for propagators
SCIP_EXPORT SCIP_RETCODE SCIPtpiCreateJob(SCIP_JOB **job, int jobid, SCIP_RETCODE(*jobfunc)(void *args), void *jobarg)
Definition: tpi_none.c:28
SCIP_Real SCIPgetConcurrentGap(SCIP *scip)
Definition: concurrent.c:326
SCIP_Longint lastconflictnode
Definition: struct_stat.h:103
int SCIPgetNPresols(SCIP *scip)
Definition: scip_presol.c:251
SCIP_Longint domchgcount
Definition: struct_stat.h:105
SCIP_Longint ncalls
Definition: struct_heur.h:81
SCIP_Real SCIPgetConcurrentDualbound(SCIP *scip)
Definition: concurrent.c:296
SCIP_EXPORT int SCIPtpiGetThreadNum(void)
Definition: tpi_openmp.c:332
SCIP_RETCODE SCIPconcsolverExec(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:315
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
SCIP_Longint nbarrierlps
Definition: struct_stat.h:183
SCIP_Longint nprimalzeroitlps
Definition: struct_stat.h:179
SCIP_CLOCK * primallptime
Definition: struct_stat.h:148
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:246
SCIP_Longint SCIPgetConcurrentNTightenedIntBnds(SCIP *scip)
Definition: concurrent.c:351
SCIP_Longint npsbestsolsfound
Definition: struct_stat.h:98
int nrootboundchgsrun
Definition: struct_stat.h:206
SCIP_Longint ncutsapplied
Definition: struct_sepa.h:43
SCIP_Longint ndomredsfound
Definition: struct_sepa.h:45
SCIP_Longint nboundchgs
Definition: struct_stat.h:106
SCIP_Longint nbestsolsfound
Definition: struct_heur.h:83
SCIP_Real time
Definition: struct_sol.h:66
#define SCIP_Real
Definition: def.h:164
internal methods for problem statistics
void SCIPprobSetDualbound(SCIP_PROB *prob, SCIP_Real dualbound)
Definition: prob.c:1438
SCIP_Real firstprimaltime
Definition: struct_stat.h:122
SCIP_Real referencebound
Definition: struct_stat.h:140
SCIP_EXPORT int SCIPtpiGetNewJobID(void)
Definition: tpi_openmp.c:357
SCIP_Longint nrepropboundchgs
Definition: struct_stat.h:90
datastructures for separators
SCIP_Real firstprimalbound
Definition: struct_stat.h:121
datastructures for collecting primal CIP solutions and primal informations
SCIP_Longint ntotalinternalnodes
Definition: struct_stat.h:79
SCIP_RETCODE SCIPpropSyncAddBndchg(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)
Definition: prop_sync.c:313
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:151
SCIP_CLOCK * duallptime
Definition: struct_stat.h:149
SCIP_CLOCK * reoptupdatetime
Definition: struct_stat.h:164
#define SCIP_Longint
Definition: def.h:149
SCIP_Bool SCIPIsConcurrentSolNew(SCIP *scip, SCIP_SOL *sol)
Definition: concurrent.c:429
SCIP_Longint nactivatednodes
Definition: struct_stat.h:83
SCIP_Longint nprimallpiterations
Definition: struct_stat.h:56
SCIP_Longint nreprops
Definition: struct_stat.h:89
SCIP_BOUNDSTORE * SCIPgetConcurrentGlobalBoundChanges(SCIP *scip)
Definition: concurrent.c:442
SCIP_Longint nsbsolsfound
Definition: struct_stat.h:95
SCIP_EVENTHDLR * eventglobalbnd
SCIP_CLOCK * nodeactivationtime
Definition: struct_stat.h:160
SCIP_Longint ndualzeroitlps
Definition: struct_stat.h:181
SCIP_Real firstlptime
Definition: struct_stat.h:130
SCIP_PROP * propsync
SCIP_Longint ninternalnodes
Definition: struct_stat.h:74
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition: prob.c:2074
int plungedepth
Definition: struct_stat.h:221
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
Definition: scip_timing.c:315
SCIP_Real previousgap
Definition: struct_stat.h:133
SCIP_Longint nnodelps
Definition: struct_stat.h:188
SCIP_Longint nnodes
Definition: struct_stat.h:73
concurrent data struct
int nrootintfixingsrun
Definition: struct_stat.h:208
SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:118
#define SCIP_CALL_ABORT(x)
Definition: def.h:344
SCIP_EXPORT SCIP_RETCODE SCIPtpiSumbitJob(SCIP_JOB *job, SCIP_SUBMITSTATUS *status)
Definition: tpi_none.c:44
int firstprimaldepth
Definition: struct_stat.h:255
SCIP_Real SCIPgetDualbound(SCIP *scip)
SCIP_Longint nprobholechgs
Definition: struct_stat.h:109
int SCIPsyncstoreGetNSolvers(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:540
SCIP_Longint nlimsolsfound
Definition: struct_primal.h:40
int npresolupgdconss
Definition: struct_stat.h:236
SCIP_CONCSOLVER * concsolver
datastructures for global SCIP settings
int SCIPgetNProps(SCIP *scip)
Definition: scip_prop.c:345
int subscipdepth
Definition: struct_stat.h:200
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:100
SCIP_RETCODE SCIPsynchronize(SCIP *scip)
Definition: concurrent.c:236
SCIP_Longint ninitlps
Definition: struct_stat.h:189
SCIP callable library.
SCIP_Longint ndelayedcutoffs
Definition: struct_stat.h:88
SCIP_EXPORT int SCIPvarGetIndex(SCIP_VAR *var)
Definition: var.c:17035
SCIP_CLOCK * lpsoltime
Definition: struct_stat.h:156
SCIP_Longint totaldivesetdepth
Definition: struct_stat.h:199
SCIP_RETCODE SCIPcreateConcurrent(SCIP *scip, SCIP_CONCSOLVER *concsolver, int *varperm)
Definition: concurrent.c:48
SCIP_Longint ndivinglpiterations
Definition: struct_stat.h:65
int SCIPgetNHeurs(SCIP *scip)
Definition: scip_heur.c:274