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