Scippy

SCIP

Solving Constraint Integer Programs

scip_timing.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-2018 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 scip_timing.c
17  * @brief public methods for timing
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  * @author Gerald Gamrath
21  * @author Robert Lion Gottwald
22  * @author Stefan Heinz
23  * @author Gregor Hendel
24  * @author Thorsten Koch
25  * @author Alexander Martin
26  * @author Marc Pfetsch
27  * @author Michael Winkler
28  * @author Kati Wolter
29  *
30  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
31  */
32 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #include <ctype.h>
36 #include <stdarg.h>
37 #include <assert.h>
38 #include <string.h>
39 #if defined(_WIN32) || defined(_WIN64)
40 #else
41 #include <strings.h> /*lint --e{766}*/
42 #endif
43 
44 
45 #include "lpi/lpi.h"
46 #include "nlpi/exprinterpret.h"
47 #include "nlpi/nlpi.h"
48 #include "scip/benders.h"
49 #include "scip/benderscut.h"
50 #include "scip/branch.h"
51 #include "scip/branch_nodereopt.h"
52 #include "scip/clock.h"
53 #include "scip/compr.h"
54 #include "scip/concsolver.h"
55 #include "scip/concurrent.h"
56 #include "scip/conflict.h"
57 #include "scip/conflictstore.h"
58 #include "scip/cons.h"
59 #include "scip/cons_linear.h"
60 #include "scip/cutpool.h"
61 #include "scip/cuts.h"
62 #include "scip/debug.h"
63 #include "scip/def.h"
64 #include "scip/dialog.h"
65 #include "scip/dialog_default.h"
66 #include "scip/disp.h"
67 #include "scip/event.h"
68 #include "scip/heur.h"
69 #include "scip/heur_ofins.h"
70 #include "scip/heur_reoptsols.h"
72 #include "scip/heuristics.h"
73 #include "scip/history.h"
74 #include "scip/implics.h"
75 #include "scip/interrupt.h"
76 #include "scip/lp.h"
77 #include "scip/mem.h"
78 #include "scip/message_default.h"
79 #include "scip/misc.h"
80 #include "scip/nlp.h"
81 #include "scip/nodesel.h"
82 #include "scip/paramset.h"
83 #include "scip/presol.h"
84 #include "scip/presolve.h"
85 #include "scip/pricer.h"
86 #include "scip/pricestore.h"
87 #include "scip/primal.h"
88 #include "scip/prob.h"
89 #include "scip/prop.h"
90 #include "scip/reader.h"
91 #include "scip/relax.h"
92 #include "scip/reopt.h"
93 #include "scip/retcode.h"
94 #include "scip/scipbuildflags.h"
95 #include "scip/scipcoreplugins.h"
96 #include "scip/scipgithash.h"
97 #include "scip/sepa.h"
98 #include "scip/sepastore.h"
99 #include "scip/set.h"
100 #include "scip/sol.h"
101 #include "scip/solve.h"
102 #include "scip/stat.h"
103 #include "scip/syncstore.h"
104 #include "scip/table.h"
105 #include "scip/tree.h"
106 #include "scip/var.h"
107 #include "scip/visual.h"
108 #include "xml/xml.h"
109 
110 #include "scip/scip_numerics.h"
111 #include "scip/scip_timing.h"
112 
113 #include "scip/pub_message.h"
114 
115 
116 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
117  * this structure except the interface methods in scip.c.
118  * In optimized mode, the structure is included in scip.h, because some of the methods
119  * are implemented as defines for performance reasons (e.g. the numerical comparisons)
120  */
121 #ifndef NDEBUG
122 #include "scip/struct_scip.h"
123 #endif
124 
125 /** gets current time of day in seconds (standard time zone)
126  *
127  * @return the current time of day in seconds (standard time zone).
128  */
130  SCIP* scip /**< SCIP data structure */
131  )
132 {
133  assert(scip != NULL);
134 
135  return SCIPclockGetTimeOfDay();
136 }
137 
138 /** creates a clock using the default clock type
139  *
140  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
141  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
142  */
144  SCIP* scip, /**< SCIP data structure */
145  SCIP_CLOCK** clck /**< pointer to clock timer */
146  )
147 {
148  assert(scip != NULL);
149 
151 
152  return SCIP_OKAY;
153 }
154 
155 /** creates a clock counting the CPU user seconds
156  *
157  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
158  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
159  */
161  SCIP* scip, /**< SCIP data structure */
162  SCIP_CLOCK** clck /**< pointer to clock timer */
163  )
164 {
165  assert(scip != NULL);
166 
168 
169  return SCIP_OKAY;
170 }
171 
172 /** creates a clock counting the wall clock seconds
173  *
174  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
175  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
176  */
178  SCIP* scip, /**< SCIP data structure */
179  SCIP_CLOCK** clck /**< pointer to clock timer */
180  )
181 {
182  assert(scip != NULL);
183 
185 
186  return SCIP_OKAY;
187 }
188 
189 /** frees a clock
190  *
191  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
192  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
193  */
195  SCIP* scip, /**< SCIP data structure */
196  SCIP_CLOCK** clck /**< pointer to clock timer */
197  )
198 {
199  assert(scip != NULL);
200 
201  SCIPclockFree(clck);
202 
203  return SCIP_OKAY;
204 }
205 
206 /** resets the time measurement of a clock to zero and completely stops the clock
207  *
208  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
209  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
210  */
212  SCIP* scip, /**< SCIP data structure */
213  SCIP_CLOCK* clck /**< clock timer */
214  )
215 {
216  assert(scip != NULL);
217 
218  SCIPclockReset(clck);
219 
220  return SCIP_OKAY;
221 }
222 
223 /** starts the time measurement of a clock
224  *
225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
227  */
229  SCIP* scip, /**< SCIP data structure */
230  SCIP_CLOCK* clck /**< clock timer */
231  )
232 {
233  assert(scip != NULL);
234 
235  SCIPclockStart(clck, scip->set);
236 
237  return SCIP_OKAY;
238 }
239 
240 /** stops the time measurement of a clock
241  *
242  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
243  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
244  */
246  SCIP* scip, /**< SCIP data structure */
247  SCIP_CLOCK* clck /**< clock timer */
248  )
249 {
250  assert(scip != NULL);
251 
252  SCIPclockStop(clck, scip->set);
253 
254  return SCIP_OKAY;
255 }
256 
257 /** enables or disables all statistic clocks of SCIP concerning plugin statistics,
258  * LP execution time, strong branching time, etc.
259  *
260  * Method reads the value of the parameter timing/statistictiming. In order to disable statistic timing,
261  * set the parameter to FALSE.
262  *
263  * @note: The (pre-)solving time clocks which are relevant for the output during (pre-)solving
264  * are not affected by this method
265  *
266  * @see: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE
267  *
268  * @pre This method can be called if SCIP is in one of the following stages:
269  * - \ref SCIP_STAGE_INIT
270  * - \ref SCIP_STAGE_PROBLEM
271  * - \ref SCIP_STAGE_TRANSFORMING
272  * - \ref SCIP_STAGE_TRANSFORMED
273  * - \ref SCIP_STAGE_INITPRESOLVE
274  * - \ref SCIP_STAGE_PRESOLVING
275  * - \ref SCIP_STAGE_EXITPRESOLVE
276  * - \ref SCIP_STAGE_PRESOLVED
277  * - \ref SCIP_STAGE_INITSOLVE
278  * - \ref SCIP_STAGE_SOLVING
279  * - \ref SCIP_STAGE_SOLVED
280  * - \ref SCIP_STAGE_EXITSOLVE
281  * - \ref SCIP_STAGE_FREETRANS
282  *
283  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
284  */
286  SCIP* scip /**< SCIP data structure */
287  )
288 {
289  SCIP_CALL( SCIPcheckStage(scip, "SCIPenableOrDisableStatisticTiming", TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
290 
292 
293  if( scip->set->stage > SCIP_STAGE_INIT )
294  {
295  assert(scip->stat != NULL);
297  }
298  if( scip->set->stage >= SCIP_STAGE_TRANSFORMING )
299  {
300  assert(scip->conflict != NULL);
302  }
303 
304  return SCIP_OKAY;
305 }
306 
307 /** starts the current solving time
308  *
309  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
311  *
312  * @pre This method can be called if SCIP is in one of the following stages:
313  * - \ref SCIP_STAGE_PROBLEM
314  * - \ref SCIP_STAGE_TRANSFORMING
315  * - \ref SCIP_STAGE_TRANSFORMED
316  * - \ref SCIP_STAGE_INITPRESOLVE
317  * - \ref SCIP_STAGE_PRESOLVING
318  * - \ref SCIP_STAGE_EXITPRESOLVE
319  * - \ref SCIP_STAGE_PRESOLVED
320  * - \ref SCIP_STAGE_INITSOLVE
321  * - \ref SCIP_STAGE_SOLVING
322  * - \ref SCIP_STAGE_SOLVED
323  * - \ref SCIP_STAGE_EXITSOLVE
324  * - \ref SCIP_STAGE_FREETRANS
325  *
326  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
327  */
329  SCIP* scip /**< SCIP data structure */
330  )
331 {
332  SCIP_CALL( SCIPcheckStage(scip, "SCIPstartSolvingTime", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
333 
334  SCIPclockStart(scip->stat->solvingtime, scip->set);
335  SCIPclockStart(scip->stat->solvingtimeoverall, scip->set);
336 
337  return SCIP_OKAY;
338 }
339 
340 /** stops the current solving time in seconds
341  *
342  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
343  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
344  *
345  * @pre This method can be called if SCIP is in one of the following stages:
346  * - \ref SCIP_STAGE_PROBLEM
347  * - \ref SCIP_STAGE_TRANSFORMING
348  * - \ref SCIP_STAGE_TRANSFORMED
349  * - \ref SCIP_STAGE_INITPRESOLVE
350  * - \ref SCIP_STAGE_PRESOLVING
351  * - \ref SCIP_STAGE_EXITPRESOLVE
352  * - \ref SCIP_STAGE_PRESOLVED
353  * - \ref SCIP_STAGE_INITSOLVE
354  * - \ref SCIP_STAGE_SOLVING
355  * - \ref SCIP_STAGE_SOLVED
356  * - \ref SCIP_STAGE_EXITSOLVE
357  * - \ref SCIP_STAGE_FREETRANS
358  *
359  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
360  */
362  SCIP* scip /**< SCIP data structure */
363  )
364 {
365  SCIP_CALL( SCIPcheckStage(scip, "SCIPstopSolvingTime", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
366 
367  SCIPclockStop(scip->stat->solvingtime, scip->set);
368  SCIPclockStop(scip->stat->solvingtimeoverall, scip->set);
369 
370  return SCIP_OKAY;
371 }
372 
373 /** gets the measured time of a clock in seconds
374  *
375  * @return the measured time of a clock in seconds.
376  */
378  SCIP* scip, /**< SCIP data structure */
379  SCIP_CLOCK* clck /**< clock timer */
380  )
381 {
382  assert(scip != NULL);
383 
384  return SCIPclockGetTime(clck);
385 }
386 
387 /** sets the measured time of a clock to the given value in seconds
388  *
389  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
390  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
391  */
393  SCIP* scip, /**< SCIP data structure */
394  SCIP_CLOCK* clck, /**< clock timer */
395  SCIP_Real sec /**< time in seconds to set the clock's timer to */
396  )
397 {
398  assert(scip != NULL);
399 
400  SCIPclockSetTime(clck, sec);
401 
402  return SCIP_OKAY;
403 }
404 
405 /** gets the current total SCIP time in seconds, possibly accumulated over several problems.
406  *
407  * @return the current total SCIP time in seconds, ie. the total time since the SCIP instance has been created
408  */
410  SCIP* scip /**< SCIP data structure */
411  )
412 {
413  assert(scip != NULL);
414 
415  return SCIPclockGetTime(scip->totaltime);
416 }
417 
418 /** gets the current solving time in seconds
419  *
420  * @return the current solving time in seconds.
421  *
422  * @pre This method can be called if SCIP is in one of the following stages:
423  * - \ref SCIP_STAGE_PROBLEM
424  * - \ref SCIP_STAGE_TRANSFORMING
425  * - \ref SCIP_STAGE_TRANSFORMED
426  * - \ref SCIP_STAGE_INITPRESOLVE
427  * - \ref SCIP_STAGE_PRESOLVING
428  * - \ref SCIP_STAGE_EXITPRESOLVE
429  * - \ref SCIP_STAGE_PRESOLVED
430  * - \ref SCIP_STAGE_INITSOLVE
431  * - \ref SCIP_STAGE_SOLVING
432  * - \ref SCIP_STAGE_SOLVED
433  *
434  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
435  */
437  SCIP* scip /**< SCIP data structure */
438  )
439 {
440  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetSolvingTime", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
441 
442  return SCIPclockGetTime(scip->stat->solvingtime);
443 }
444 
445 /** gets the current reading time in seconds
446  *
447  * @return the current reading time in seconds.
448  *
449  * @pre This method can be called if SCIP is in one of the following stages:
450  * - \ref SCIP_STAGE_PROBLEM
451  * - \ref SCIP_STAGE_TRANSFORMING
452  * - \ref SCIP_STAGE_TRANSFORMED
453  * - \ref SCIP_STAGE_INITPRESOLVE
454  * - \ref SCIP_STAGE_PRESOLVING
455  * - \ref SCIP_STAGE_EXITPRESOLVE
456  * - \ref SCIP_STAGE_PRESOLVED
457  * - \ref SCIP_STAGE_INITSOLVE
458  * - \ref SCIP_STAGE_SOLVING
459  * - \ref SCIP_STAGE_SOLVED
460  *
461  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
462  */
464  SCIP* scip /**< SCIP data structure */
465  )
466 {
467  SCIP_Real readingtime;
468  int r;
469 
470  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetReadingTime", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
471 
472  readingtime = 0.0;
473 
474  /* sum up the reading time of all readers */
475  for( r = 0; r < scip->set->nreaders; ++r )
476  {
477  assert(scip->set->readers[r] != NULL);
478  assert(!SCIPisNegative(scip, SCIPreaderGetReadingTime(scip->set->readers[r])));
479  readingtime += SCIPreaderGetReadingTime(scip->set->readers[r]);
480  }
481 
482  return readingtime;
483 }
484 
485 /** gets the current presolving time in seconds
486  *
487  * @return the current presolving time in seconds.
488  *
489  * @pre This method can be called if SCIP is in one of the following stages:
490  * - \ref SCIP_STAGE_INITPRESOLVE
491  * - \ref SCIP_STAGE_PRESOLVING
492  * - \ref SCIP_STAGE_EXITPRESOLVE
493  * - \ref SCIP_STAGE_PRESOLVED
494  * - \ref SCIP_STAGE_INITSOLVE
495  * - \ref SCIP_STAGE_SOLVING
496  * - \ref SCIP_STAGE_SOLVED
497  *
498  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
499  */
501  SCIP* scip /**< SCIP data structure */
502  )
503 {
504  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPresolvingTime", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
505 
506  return SCIPclockGetTime(scip->stat->presolvingtime);
507 }
508 
509 /** gets the time need to solve the first LP in the root node
510  *
511  * @return the solving time for the first LP in the root node in seconds.
512  *
513  * @pre This method can be called if SCIP is in one of the following stages:
514  * - \ref SCIP_STAGE_TRANSFORMING
515  * - \ref SCIP_STAGE_TRANSFORMED
516  * - \ref SCIP_STAGE_INITPRESOLVE
517  * - \ref SCIP_STAGE_PRESOLVING
518  * - \ref SCIP_STAGE_EXITPRESOLVE
519  * - \ref SCIP_STAGE_PRESOLVED
520  * - \ref SCIP_STAGE_INITSOLVE
521  * - \ref SCIP_STAGE_SOLVING
522  * - \ref SCIP_STAGE_SOLVED
523  *
524  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
525  */
527  SCIP* scip /**< SCIP data structure */
528  )
529 {
530  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPTime", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
531 
532  return scip->stat->firstlptime;
533 }
void SCIPconflictEnableOrDisableClocks(SCIP_CONFLICT *conflict, SCIP_Bool enable)
Definition: conflict.c:8969
internal methods for separators
SCIP_STAT * stat
Definition: struct_scip.h:69
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:436
#define NULL
Definition: def.h:239
internal methods for managing events
SCIP_READER ** readers
Definition: struct_set.h:68
default message handler
trivialnegation primal heuristic
internal methods for storing primal CIP solutions
methods to interpret (evaluate) an expression tree "fast"
internal methods for branch and bound tree
SCIP_CONFLICT * conflict
Definition: struct_scip.h:85
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
Definition: scip_timing.c:392
SCIP_Real SCIPgetReadingTime(SCIP *scip)
Definition: scip_timing.c:463
methods for implications, variable bounds, and cliques
internal methods for clocks and timing issues
SCIP_RETCODE SCIPcreateCPUClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:160
internal methods for NLPI solver interfaces
SCIP_CLOCK * totaltime
Definition: struct_scip.h:66
public methods for timing
interface methods for specific LP solvers
internal methods for displaying statistics tables
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:245
SCIP_Bool time_statistictiming
Definition: struct_set.h:554
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:350
#define FALSE
Definition: def.h:65
void SCIPstatEnableOrDisableStatClocks(SCIP_STAT *stat, SCIP_Bool enable)
Definition: stat.c:647
methods for the aggregation rows
internal methods for Benders&#39; decomposition
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:280
SCIP_STAGE stage
Definition: struct_set.h:63
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
#define TRUE
Definition: def.h:64
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
methods commonly used by primal heuristics
internal methods for branching rules and branching candidate storage
datastructures for concurrent solvers
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
Definition: scip_timing.c:285
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:194
internal methods for handling parameter settings
methods for creating output for visualization tools (VBC, BAK)
nodereopt branching rule
SCIP_Real SCIPgetPresolvingTime(SCIP *scip)
Definition: scip_timing.c:500
internal methods for LP management
internal methods for branching and inference history
public methods for numerical tolerances
internal methods for collecting primal CIP solutions and primal informations
internal methods for propagators
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:177
void SCIPclockSetTime(SCIP_CLOCK *clck, SCIP_Real sec)
Definition: clock.c:518
git hash methods
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip_timing.c:143
internal methods for storing and manipulating the main problem
methods for block memory pools and memory buffers
void SCIPclockReset(SCIP_CLOCK *clck)
Definition: clock.c:199
register additional core functionality that is designed as plugins
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition: debug.c:1933
internal methods for presolvers
SCIP_CLOCK * solvingtimeoverall
Definition: struct_stat.h:145
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
Definition: clock.c:428
internal methods for NLP management
internal miscellaneous methods
internal methods for node selectors and node priority queues
internal methods for variable pricers
internal methods for global SCIP settings
internal methods for storing conflicts
#define SCIP_CALL(x)
Definition: def.h:351
SCIP main data structure.
internal methods for storing priced variables
internal methods for relaxators
internal methods for storing separated cuts
SCIP_RETCODE SCIPstopSolvingTime(SCIP *scip)
Definition: scip_timing.c:361
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
Definition: clock.c:160
methods commonly used for presolving
methods for catching the user CTRL-C interrupt
internal methods for problem variables
data structures and methods for collecting reoptimization information
the function declarations for the synchronization store
internal methods for user interface dialog
SCIP_Real SCIPreaderGetReadingTime(SCIP_READER *reader)
Definition: reader.c:597
SCIP_CLOCK * presolvingtime
Definition: struct_stat.h:146
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:377
internal methods for input file readers
void SCIPclockFree(SCIP_CLOCK **clck)
Definition: clock.c:175
SCIP_RETCODE SCIPstartSolvingTime(SCIP *scip)
Definition: scip_timing.c:328
int nreaders
Definition: struct_set.h:97
methods for debugging
SCIP_Real SCIPclockGetTimeOfDay(void)
Definition: clock.c:600
reoptsols primal heuristic
internal methods for storing cuts in a cut pool
Constraint handler for linear constraints in their most general form, .
SCIP_Real SCIPgetTimeOfDay(SCIP *scip)
Definition: scip_timing.c:129
helper functions for concurrent scip solvers
void SCIPsetEnableOrDisablePluginClocks(SCIP_SET *set, SCIP_Bool enabled)
Definition: set.c:830
internal methods for return codes for SCIP methods
SCIP_Real * r
Definition: circlepacking.c:50
internal methods for conflict analysis
internal methods for tree compressions
internal methods for main solving loop and node processing
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:211
SCIP_CLOCK * solvingtime
Definition: struct_stat.h:144
SCIP_SET * set
Definition: struct_scip.h:62
public methods for message output
default user interface dialog
#define SCIP_Real
Definition: def.h:150
internal methods for problem statistics
internal methods for constraints and constraint handlers
SCIP_Real SCIPgetTotalTime(SCIP *scip)
Definition: scip_timing.c:409
declarations for XML parsing
build flags methods
SCIP_Real firstlptime
Definition: struct_stat.h:130
common defines and data types used in all packages of SCIP
#define SCIP_CALL_ABORT(x)
Definition: def.h:330
internal methods for primal heuristics
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip_timing.c:228
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
Definition: scip_timing.c:526
internal methods for Benders&#39; decomposition cuts
internal methods for displaying runtime statistics
OFINS - Objective Function Induced Neighborhood Search - a primal heuristic for reoptimization.