Scippy

UG

Ubiquity Generator framework

scipParaObjCommPointHdlr.cpp
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and software framework */
4 /* UG --- Ubquity Generator Framework */
5 /* */
6 /* Copyright Written by Yuji Shinano <shinano@zib.de>, */
7 /* Copyright (C) 2021 by Zuse Institute Berlin, */
8 /* licensed under LGPL version 3 or later. */
9 /* Commercial licenses are available through <licenses@zib.de> */
10 /* */
11 /* This code is free software; you can redistribute it and/or */
12 /* modify it under the terms of the GNU Lesser General Public License */
13 /* as published by the Free Software Foundation; either version 3 */
14 /* of the License, or (at your option) any later version. */
15 /* */
16 /* This program is distributed in the hope that it will be useful, */
17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
19 /* GNU Lesser General Public License for more details. */
20 /* */
21 /* You should have received a copy of the GNU Lesser General Public License */
22 /* along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* */
24 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
25 
26 /**@file scipParaObjCommPointHdlr.cpp
27  * @brief Event handlr for communication point.
28  * @author Yuji Shinano
29  *
30  *
31  *
32  */
33 
34 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
35 
36 #include <cassert>
37 #include <cmath>
38 #include <string>
39 #include <sstream>
40 #include <iostream>
41 
42 #include "scipParaObjCommPointHdlr.h"
43 #include "scip/struct_nodesel.h"
44 #include "scip/tree.h"
45 #ifdef UG_DEBUG_SOLUTION
46 #ifndef WITH_DEBUG_SOLUTION
47 #define WITH_DEBUG_SOLUTION
48 #endif
49 #include "scip/debug.h"
50 #endif
51 
52 #include "scipParaSolution.h"
53 #include "scipParaDiffSubproblem.h"
54 
55 using namespace ParaSCIP;
56 
57 void
58 ScipParaObjCommPointHdlr::processNewSolution(
59  SCIP* scip, /**< SCIP data structure */
60  SCIP_EVENT* event /**< event to process */
61  )
62 {
63  SCIP_SOL *sol = SCIPeventGetSol(event);
64  int nVars = SCIPgetNOrigVars(scip);
65  SCIP_VAR **vars = SCIPgetOrigVars(scip);
66  SCIP_Real *vals = new SCIP_Real[nVars];
67  SCIP_CALL_ABORT( SCIPgetSolVals(scip, sol, nVars, vars, vals) );
68 
69  // SCIP_CALL_ABORT( SCIPprintSol(scip,sol,NULL, FALSE) );
70  SCIP_Bool feasible;
71  SCIP_CALL_ABORT( SCIPcheckSolOrig(scip,sol,&feasible,1,1 ) );
72 
73  DEF_SCIP_PARA_COMM( scipParaComm, paraComm);
74 
75  if( scipParaSolver->isCopyIncreasedVariables() )
76  {
77  SCIP_VAR **varsInOrig = new SCIP_VAR*[nVars];
78  SCIP_Real *valsInOrig = new SCIP_Real[nVars]();
79  int nVarsInOrig = 0;
80  for( int i = 0; i < nVars; i++ )
81  {
82  if( scipParaSolver->getOriginalIndex(SCIPvarGetIndex(vars[i])) >= 0 )
83  {
84  varsInOrig[nVarsInOrig] = vars[i];
85  valsInOrig[nVarsInOrig] = vals[i];
86  nVarsInOrig++;
87  }
88  }
89 
90  scipParaSolver->saveIfImprovedSolutionWasFound(
91  scipParaComm->createScipParaSolution(
92  scipParaSolver,
93  SCIPgetSolOrigObj(scip, sol),
94  nVarsInOrig,
95  varsInOrig,
96  valsInOrig
97  )
98  );
99  delete [] varsInOrig;
100  delete [] valsInOrig;
101  }
102  else
103  {
104  scipParaSolver->saveIfImprovedSolutionWasFound(
105  scipParaComm->createScipParaSolution(
106  scipParaSolver,
107  SCIPgetSolOrigObj(scip, sol),
108  nVars,
109  vars,
110  vals
111  )
112  );
113  // std::cout << "*** event handler ***" << std::endl;
114  // SCIP_CALL_ABORT( SCIPprintSol(scip, sol, NULL, FALSE) );
115  // scipParaSolver->checkVarsAndIndex("***found solution***",scip);
116  }
117  delete [] vals;
118 }
119 
120 SCIP_RETCODE
121 ScipParaObjCommPointHdlr::scip_exec(
122  SCIP* scip, /**< SCIP data structure */
123  SCIP_EVENTHDLR* eventhdlr, /**< the event handler itself */
124  SCIP_EVENT* event, /**< event to process */
125  SCIP_EVENTDATA* eventdata /**< user data for the event */
126  )
127 {
128  DEF_SCIP_PARA_COMM( scipParaComm, paraComm);
129  if( !scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) )
130  {
131  scipParaComm->lockInterruptMsg();
132  }
133  assert(eventhdlr != NULL);
134  assert(strcmp(SCIPeventhdlrGetName(eventhdlr), "ScipParaObjCommPointHdlr") == 0);
135  assert(event != NULL);
136 #ifdef SCIP_EVENTTYPE_COMM
137  assert(SCIPeventGetType(event) &
138  ( SCIP_EVENTTYPE_GBDCHANGED |
139  SCIP_EVENTTYPE_BOUNDTIGHTENED |
140  SCIP_EVENTTYPE_LPEVENT |
141  SCIP_EVENTTYPE_ROWEVENT |
142  // SCIP_EVENTTYPE_NODEFOCUSED |
143  SCIP_EVENTTYPE_NODEEVENT |
144  SCIP_EVENTTYPE_BESTSOLFOUND |
145  SCIP_EVENTTYPE_COMM
146  )
147  );
148 #else
149  assert(SCIPeventGetType(event) &
150  ( SCIP_EVENTTYPE_GBDCHANGED |
151  SCIP_EVENTTYPE_BOUNDTIGHTENED |
152  SCIP_EVENTTYPE_LPEVENT |
153  SCIP_EVENTTYPE_ROWEVENT |
154  // SCIP_EVENTTYPE_NODEFOCUSED |
155  SCIP_EVENTTYPE_NODEEVENT |
156  SCIP_EVENTTYPE_BESTSOLFOUND
157  )
158  );
159 #endif
160 
161 #if SCIP_VERSION == 211 && SCIP_SUBVERSION == 0
162  if( SCIPgetStage(scip) >= SCIP_STAGE_FREESOLVE )
163 #else
164  if( SCIPgetStage(scip) >= SCIP_STAGE_EXITSOLVE )
165 #endif
166  {
167  if( !scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) )
168  {
169  scipParaComm->unlockInterruptMsg();
170  }
171  return SCIP_OKAY;
172  }
173 
174  double detTime = -1.0;
175  SCIP *subScip = 0;
176  if( cloned )
177  {
178  subScip = scip;
179  scip = originalScip;
180  }
181 
182  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) )
183  {
184  assert(scipParaSolver->getDeterministicTimer());
185  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::EventWeightedDeterministic) )
186  {
187  if( SCIPeventGetType(event) == SCIP_EVENTTYPE_FIRSTLPSOLVED )
188  {
189  SCIP_Longint totalLpIter = 0;
190  if( cloned )
191  {
192  totalLpIter = SCIPgetNLPIterations(subScip);
193  }
194  else
195  {
196  totalLpIter = SCIPgetNLPIterations(scip);
197  }
198  SCIP_Longint lpIter = totalLpIter - previousLpIter;
199  if( lpIter < 0 )
200  {
201  lpIter = totalLpIter;
202  }
203  scipParaSolver->getDeterministicTimer()->update(lpIter);
204  previousLpIter = totalLpIter;
205 
206  }
207  else if ( SCIPeventGetType(event) == SCIP_EVENTTYPE_LPSOLVED )
208  {
209  SCIP_Longint totalLpIter = 0;
210  if( cloned )
211  {
212  totalLpIter = SCIPgetNLPIterations(subScip);
213  }
214  else
215  {
216  totalLpIter = SCIPgetNLPIterations(scip);
217  }
218  SCIP_Longint lpIter = totalLpIter - previousLpIter;
219  if( lpIter < 0 )
220  {
221  lpIter = totalLpIter;
222  }
223  scipParaSolver->getDeterministicTimer()->update(lpIter);
224  previousLpIter = totalLpIter;
225  }
226  else if ( SCIPeventGetType(event) == SCIP_EVENTTYPE_BESTSOLFOUND
227  || SCIPeventGetType(event) == SCIP_EVENTTYPE_NODEFOCUSED )
228  {
229  }
230  else
231  {
232  scipParaSolver->getDeterministicTimer()->update(1.0);
233  }
234  }
235  else
236  {
237  if ( SCIPeventGetType(event) != SCIP_EVENTTYPE_BESTSOLFOUND
238  && SCIPeventGetType(event) != SCIP_EVENTTYPE_NODEFOCUSED )
239  {
240  scipParaSolver->getDeterministicTimer()->update(1.0);
241  }
242  }
243  detTime = scipParaSolver->getDeterministicTimer()->getElapsedTime();
244  if( ( detTime - scipParaSolver->getPreviousCommTime() )
245  < ( scipParaSolver->getParaParamSet()->getRealParamValue(UG::NotificationInterval) ) )
246  {
247  if( SCIPeventGetType(event) == SCIP_EVENTTYPE_BESTSOLFOUND )
248  {
249  if( cloned )
250  {
251  if( !scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) )
252  {
253  scipParaComm->unlockInterruptMsg();
254  }
255  return SCIP_OKAY;
256  }
257  else
258  {
259  processNewSolution(scip, event);
260  }
261  }
262  }
263  do
264  {
265  scipParaSolver->iReceiveMessages();
266  } while( !scipParaSolver->waitToken(scipParaSolver->getRank()) );
267  }
268  else
269  {
270  if( SCIPeventGetType(event) == SCIP_EVENTTYPE_BESTSOLFOUND )
271  {
272  if( cloned )
273  {
274  if( !scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) )
275  {
276  scipParaComm->unlockInterruptMsg();
277  }
278  return SCIP_OKAY;
279  }
280  else
281  {
282  processNewSolution(scip, event);
283  }
284  }
285  }
286 
287  //
288  // the following interrupt routine moved from the inside of the following if clause
289  // and scipParaSolver->iReceiveMessages() before solution sending is also removed (comment out)
290  //
291  /*********************************************************************************************
292  * check if there are messages: this is the first thing to do for communication *
293  ********************************************************************************************/
294  scipParaSolver->iReceiveMessages();
295  if( !scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) )
296  {
297  scipParaComm->unlockInterruptMsg();
298  }
299 
300  if( scipParaSolver->getParaParamSet()->getIntParamValue(UG::RampUpPhaseProcess) == 3 &&
301  !scipParaSolver->isRampUp() )
302  {
303  return SCIP_OKAY;
304  }
305 
306  if( scipParaSolver->isGlobalIncumbentUpdated() &&
307  SCIPgetStage(scip) != SCIP_STAGE_PRESOLVING
308  && SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE )
309  {
310  if( !cloned
311  // && SCIPeventGetType(event) != SCIP_EVENTTYPE_BOUNDTIGHTENED
312  // && SCIPeventGetType(event) != SCIP_EVENTTYPE_ROWDELETEDLP
313  &&
314  ( SCIPeventGetType(event) & (SCIP_EVENTTYPE_NODEEVENT | SCIP_EVENTTYPE_LPEVENT)
315  )
316  )
317  {
318  /** set cutoff value */
319  if( scipParaSolver->getGlobalBestIncumbentValue() < SCIPgetObjlimit(scip) )
320  {
321  scipParaObjLimitUpdator->update();
322  // SCIP_CALL_ABORT( SCIPsetObjlimit(scip, scipParaSolver->getGlobalBestIncumbentValue()) );
323  }
324  // scipParaSolver->globalIncumbnetValueIsReflected();
325  // std::cout << "***** R." << scipParaSolver->getRank() << ", in event = " << SCIPeventGetType(event) << std::endl;
326  if( !interrupting && SCIPisObjIntegral(scip) )
327  {
328  if( SCIPfeasCeil(scip, dynamic_cast<UG::BbParaNode *>(scipParaSolver->getCurrentNode())->getDualBoundValue())
329  >= scipParaSolver->getGlobalBestIncumbentValue() )
330  {
331 #ifdef UG_DEBUG_SOLUTION
332  if( SCIPdebugSolIsEnabled(scip) )
333  {
334  throw "Optimal solution going to be lost!";
335  }
336 #endif
337  SCIP_CALL_ABORT( SCIPinterruptSolve(scip) );
338  interrupting = true;
339  // std::cout << "***** R." << scipParaSolver->getRank() << "Interrupted!" << std::endl;
340  }
341  }
342  }
343  }
344 
345  if( scipParaSolver->isRacingStage()
346  && scipParaSolver->getParaParamSet()->getBoolParamValue(UG::CommunicateTighterBoundsInRacing)
347  // && SCIPgetStage(scip) != SCIP_STAGE_PRESOLVING
348  // && SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE
349  && (SCIPeventGetType(event) & SCIP_EVENTTYPE_GBDCHANGED )
350  && (SCIPvarGetStatus(SCIPeventGetVar(event)) != SCIP_VARSTATUS_LOOSE )
351  && (SCIPvarGetStatus(SCIPeventGetVar(event)) != SCIP_VARSTATUS_AGGREGATED )
352  )
353  {
354  // assert( scipParaSolver->getCurrentNode()->isRootTask() ); /// This is fail for racing at restart
355  SCIP_BOUNDTYPE boundtype;
356  SCIP_Var *var = SCIPeventGetVar(event);
357  switch( SCIPeventGetType(event) )
358  {
359  case SCIP_EVENTTYPE_GLBCHANGED:
360  boundtype = SCIP_BOUNDTYPE_LOWER;
361  break;
362  case SCIP_EVENTTYPE_GUBCHANGED:
363  boundtype = SCIP_BOUNDTYPE_UPPER;
364  break;
365  default:
366  SCIPABORT();
367  return SCIP_ERROR;
368  }
369  SCIP_Real newbound = SCIPeventGetNewbound(event);
370  SCIP_Real constant = 0.0;
371  SCIP_Real scalar = 1.0;
372  SCIP_CALL_ABORT( SCIPvarGetOrigvarSum(&var, &scalar, &constant) );
373  if( var != NULL )
374  {
375  assert(SCIPvarIsOriginal(var));
376  int index = SCIPvarGetIndex(var);
377  boundtype = scalar < 0.0 ? (SCIP_BOUNDTYPE)(1 - boundtype) : boundtype;
378  newbound = (newbound - constant) / scalar;
379  if( scipParaSolver->isProbIndeciesMap() )
380  {
381  index = scipParaSolver->getProbIndex(index);
382  }
383  if( index < scipParaSolver->getNOrgVars() )
384  {
385  if( boundtype == SCIP_BOUNDTYPE_LOWER )
386  {
387  if( SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS )
388  {
389  assert( SCIPisFeasIntegral(scip, newbound) );
390  newbound = SCIPfeasCeil(scip, newbound);
391  }
392  #ifdef UG_DEBUG_SOLUTION
393  SCIP_Real solvalue = 0.0;
394  SCIP_CALL(SCIPdebugGetSolVal(scip,var, &solvalue));
395  std::cout << "Sender side SolValue: " << SCIPvarGetName(var) << " = " << solvalue << std::endl;
396  std::cout << "Sender side (SCIP_BOUNDTYPE_LOWER): " << SCIPvarGetName(var) << " = " << newbound << std::endl;
397  SCIP_CALL_ABORT( SCIPdebugCheckLbGlobal(scip,var,newbound) );
398  #endif
399  // assert( SCIPisLE(scip,scipParaSolver->getOrgVarLb(index), newbound) &&
400  assert( SCIPisGE(scip,scipParaSolver->getOrgVarUb(index), newbound) );
401  if( SCIPisGT(scip, newbound, scipParaSolver->getTightenedVarLb(index) ) ) // &&
402  // SCIPisLE(scip, newbound, scipParaSolver->getTightenedVarUb(index) ) ) // just for safety
403  {
404  // this assertion may not be hold
405  // assert( SCIPisLE(scip,scipParaSolver->getTightenedVarLb(index), newbound) &&
406  // SCIPisGE(scip,scipParaSolver->getTightenedVarUb(index), newbound) );
407  scipParaSolver->setTightenedVarLb(index, newbound);
408  int orgIndex = SCIPvarGetIndex(var);
409  if( scipParaSolver->isOriginalIndeciesMap() )
410  {
411  orgIndex = scipParaSolver->getOriginalIndex(orgIndex);
412  }
413  PARA_COMM_CALL(
414  paraComm->send((void *)&orgIndex, 1, UG::ParaINT, 0, UG::TagLbBoundTightenedIndex )
415  );
416  PARA_COMM_CALL(
417  paraComm->send((void *)&newbound, 1, UG::ParaDOUBLE, 0, UG::TagLbBoundTightenedBound )
418  );
419  /*
420  std::cout << "Rank " << paraComm->getRank()
421  << ": send tightened lower bond. idx = " << index
422  << ", bound = " << newbound
423  << ", var status = " << SCIPvarGetStatus(SCIPeventGetVar(event))
424  << std::endl; */
425  }
426  }
427  else
428  {
429  if( SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS )
430  {
431  assert( SCIPisFeasIntegral(scip, newbound) );
432  newbound = SCIPfeasFloor(scip, newbound);
433  }
434  #ifdef UG_DEBUG_SOLUTION
435  SCIP_Real solvalue = 0.0;
436  SCIP_CALL(SCIPdebugGetSolVal(scip,var, &solvalue));
437  std::cout << "Sender side SolValue: " << SCIPvarGetName(var) << " = " << solvalue << std::endl;
438  std::cout << "Sender side (SCIP_BOUNDTYPE_UPPER): " << SCIPvarGetName(var) << " = " << newbound << std::endl;
439  SCIP_CALL_ABORT( SCIPdebugCheckUbGlobal(scip,var,newbound) );
440  #endif
441  assert( SCIPisLE(scip,scipParaSolver->getOrgVarLb(index), newbound) );
442  // && SCIPisGE(scip,scipParaSolver->getOrgVarUb(index), newbound) );
443  if( SCIPisLT(scip, newbound, scipParaSolver->getTightenedVarUb(index) ) ) // &&
444  // SCIPisGE(scip, newbound, scipParaSolver->getTightenedVarLb(index) ) ) // just for safety
445  {
446  // This asertion may not be hold
447  // assert( SCIPisLE(scip,scipParaSolver->getTightenedVarLb(index), newbound) &&
448  // SCIPisGE(scip,scipParaSolver->getTightenedVarUb(index), newbound) );
449  scipParaSolver->setTightenedVarUb(index, newbound);
450  int orgIndex = SCIPvarGetIndex(var);
451  if( scipParaSolver->isOriginalIndeciesMap() )
452  {
453  orgIndex = scipParaSolver->getOriginalIndex(orgIndex);
454  }
455  PARA_COMM_CALL(
456  paraComm->send((void *)&orgIndex, 1, UG::ParaINT, 0, UG::TagUbBoundTightenedIndex )
457  );
458  PARA_COMM_CALL(
459  paraComm->send((void *)&newbound, 1, UG::ParaDOUBLE, 0, UG::TagUbBoundTightenedBound )
460  );
461  /*
462  std::cout << "Rank " << paraComm->getRank()
463  << ": send tightened upper bond. idx = " << index
464  << ", bound = " << newbound
465  << ", var status = " << SCIPvarGetStatus(SCIPeventGetVar(event))
466  << std::endl; */
467  }
468  }
469  }
470  }
471  }
472 
473 
474  /*********************************************************************************************
475  * update solution. This have to do right after receiving message *
476  ********************************************************************************************/
477  scipParaSolver->sendLocalSolution(); // if local solution exists, it should be sent right after iReceiveMessages
478  if( !cloned )
479  {
480  // paraComm->lockApp();
481  scipParaSolver->updatePendingSolution();
482  // paraComm->unlockApp();
483  }
484  if( scipParaSolver->newParaNodeExists() ||
485  scipParaSolver->isInterrupting() ||
486  scipParaSolver->isRacingInterruptRequested() ||
487  scipParaSolver->isTerminationRequested() ||
488  scipParaSolver->isGivenGapReached()
489  )
490  {
491  if( !interrupting )
492  {
493  if( cloned )
494  {
495  if( SCIPgetStage(subScip) != SCIP_STAGE_INITSOLVE )
496  {
497  SCIP_CALL_ABORT( SCIPinterruptSolve(subScip) );
498  interrupting = true;
499  }
500  }
501  else
502  {
503  if( SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE )
504  {
505  if( scipParaSolver->getParaParamSet()->getRealParamValue(UG::FinalCheckpointGeneratingTime) < 0.0 ||
506  ( scipParaSolver->isInterrupting() && (!scipParaSolver->isCollecingInterrupt()) ) ||
507  ( scipParaSolver->isRacingStage() && (!scipParaSolver->isRacingWinner()) ) )
508  {
509  #ifdef UG_DEBUG_SOLUTION
510  if( scipParaSolver->isRacingStage() && scipParaSolver->isRacingWinner() )
511  {
512  std::cout << "racing stage = " << scipParaSolver->isRacingStage() << ", winner = " << scipParaSolver->isRacingWinner() << std::endl;
513  if( SCIPdebugSolIsEnabled(scip) )
514  {
515  throw "Optimal solution going to be lost!";
516  }
517  }
518  SCIPdebugSolDisable(scip);
519  std::cout << "R." << paraComm->getRank() << ": disable debug, this solver is interrupted." << std::endl;
520  #endif
521  SCIP_CALL_ABORT( SCIPinterruptSolve(scip) );
522  interrupting = true;
523  }
524  }
525  }
526  return SCIP_OKAY;
527  }
528  if( scipParaSolver->getParaParamSet()->getRealParamValue(UG::FinalCheckpointGeneratingTime) < 0.0 ||
529  ( !scipParaSolver->isCollecingInterrupt() ) ||
530  ( !scipParaSolver->isRampUp() ) )
531  {
532  return SCIP_OKAY;
533  }
534  }
535 
536  if( (!cloned ) &&
537  scipParaSolver->getParaParamSet()->getBoolParamValue(UG::ControlCollectingModeOnSolverSide) &&
538  scipParaSolver->isCollectingModeProhibited() )
539  {
540  int maxrestarts = 0;
541  SCIP_CALL( SCIPgetIntParam(scip, "presolving/maxrestarts", &maxrestarts) );
542  if( SCIPgetNRuns( scip ) >= maxrestarts )
543  {
544  if( !scipParaSolver->isRacingStage() )
545  {
546  PARA_COMM_CALL(
547  paraComm->send( NULL, 0, UG::ParaBYTE, 0, UG::TagAllowToBeInCollectingMode);
548  );
549  }
550  scipParaSolver->allowCollectingMode();
551  }
552  /*
553  else
554  {
555  if( scipParaSolver->isRacingStage() )
556  {
557  return SCIP_OKAY; // during racing stage, just keep running for all restart
558  }
559  }
560  */
561  }
562 
563  SCIP_Longint nNodes = 0;
564  if( SCIPgetStage(scip) != SCIP_STAGE_PRESOLVING
565  && SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE
566  && (!scipParaSolver->isCollectingModeProhibited() ) ) // restarting is considered as root node process in ug[SCIP,*])
567  {
568  nNodes = SCIPgetNTotalNodes(scip);
569  }
570 
571  if( previousNNodesSolved == nNodes
572  // && (!scipParaSolver->isCollectingModeProhibited() ) ) // setting cutoff value works well
573  || scipParaSolver->isCollectingModeProhibited() ) // setting cutoff value works well
574  {
575  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic)
576  && ( !scipParaSolver->isInCollectingMode() )
577  && ( !scipParaSolver->newParaNodeExists() )
578  && ( !scipParaSolver->isInterrupting() )
579  && ( !scipParaSolver->isRacingInterruptRequested() )
580  && ( !scipParaSolver->isTerminationRequested() )
581  && ( !scipParaSolver->isGivenGapReached() )
582  )
583  {
584  scipParaSolver->passToken(scipParaSolver->getRank());
585  scipParaSolver->setPreviousCommTime(detTime);
586  }
587 
588  return SCIP_OKAY;
589  }
590  previousNNodesSolved = nNodes;
591 
592  /** if root node is solved, set root node time */
593  if( nNodes == 2 && SCIPgetNNodes(scip) == 2 )
594  {
595  /** when a problem is solved at root,
596  * its root node process time is set on paraSolver main loop */
597  scipParaSolver->setRootNodeTime();
598  scipParaSolver->setRootNodeSimplexIter(scipParaSolver->getSimplexIter());
599  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::DualBoundGainTest) &&
600  scipParaSolver->isDualBoundGainTestNeeded()
601  )
602  {
603  if( ( SCIPgetDualbound(scip) - dynamic_cast<UG::BbParaNode *>(scipParaSolver->getCurrentNode())->getDualBoundValue() )
604  < scipParaSolver->getAverageDualBoundGain()*scipParaSolver->getParaParamSet()->getRealParamValue(UG::DualBoundGainBranchRatio) )
605  {
606  scipParaSolver->setNotEnoughGain();
607  }
608  }
609  if( scipParaSolver->getCurrentSolivingNodeMergingStatus() == 0 &&
610  SCIPgetDualbound(scip) <
611  scipParaSolver->getCurrentSolvingNodeInitialDualBound() * ( 1.0 - scipParaSolver->getParaParamSet()->getRealParamValue(UG::AllowableRegressionRatioInMerging)) )
612  {
613  if( !interrupting )
614  {
615  if( cloned )
616  {
617  SCIP_CALL_ABORT( SCIPinterruptSolve(subScip) );
618  }
619  else
620  {
621  dynamic_cast<UG::BbParaNode *>(scipParaSolver->getCurrentNode())->setMergingStatus(3); // cannot be merged
622  SCIP_CALL_ABORT( SCIPinterruptSolve(scip) );
623  }
624  interrupting = true;
625  }
626  return SCIP_OKAY;
627  }
628  }
629 
630  /*****************************************************************************
631  * sends solver state message if it is necessary, that is, *
632  * notification interval time has been passed from the previous notification *
633  *****************************************************************************/
634  double bestDualBoundValue = -SCIPinfinity(scip);
635  if( SCIPgetStage(scip) == SCIP_STAGE_TRANSFORMED ||
636  SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING ||
637  SCIPgetStage(scip) == SCIP_STAGE_INITSOLVE
638  )
639  {
640  bestDualBoundValue = dynamic_cast<UG::BbParaNode *>(scipParaSolver->getCurrentNode())->getDualBoundValue();
641  }
642  else
643  {
644  bestDualBoundValue = std::max(SCIPgetDualbound(scip), dynamic_cast<UG::BbParaNode *>(scipParaSolver->getCurrentNode())->getDualBoundValue());
645  }
646 
647  /************************************************************
648  * check if global best incumbent value is updated or not. *
649  * if it is updated, set cutoff value *
650  ************************************************************/
651 // if( scipParaSolver->isGlobalIncumbentUpdated() &&
652 // SCIPgetStage(scip) != SCIP_STAGE_PRESOLVING
653 // && SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE )
654 // {
655 // if( !cloned
656 // && SCIPeventGetType(event) != SCIP_EVENTTYPE_BOUNDTIGHTENED
657 // )
658 // {
659 // /** set cutoff value */
660 // // if( scipParaSolver->getGlobalBestIncumbentValue() > bestDualBoundValue )
661 // // {
662 // SCIP_CALL_ABORT( SCIPsetObjlimit(scip, scipParaSolver->getGlobalBestIncumbentValue()) );
663 // // }
664 // scipParaSolver->globalIncumbnetValueIsReflected();
665 //std::cout << "R." << paraComm->getRank() << " ** UPDATED **" << std::endl;
666 // }
667 // }
668 
669  if( scipParaSolver->getGlobalBestIncumbentValue() < bestDualBoundValue )
670  {
671  if( !interrupting )
672  {
673  if( cloned )
674  {
675  if( SCIPgetStage(subScip) != SCIP_STAGE_INITSOLVE )
676  {
677  SCIP_CALL_ABORT( SCIPinterruptSolve(subScip) );
678  interrupting = true;
679  }
680  }
681  else
682  {
683  if( SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE )
684  {
685 #ifdef UG_DEBUG_SOLUTION
686  if( scipParaSolver->isRacingStage() && scipParaSolver->isRacingWinner() )
687  {
688  std::cout << "racing stage = " << scipParaSolver->isRacingStage() << ", winner = " << scipParaSolver->isRacingWinner() << std::endl;
689  if( SCIPdebugSolIsEnabled(scip) )
690  {
691  throw "Optimal solution going to be lost!";
692  }
693  }
694  SCIPdebugSolDisable(scip);
695  std::cout << "R." << paraComm->getRank() << ": disable debug, this solver is interrupted." << std::endl;
696 #endif
697  SCIP_CALL_ABORT( SCIPinterruptSolve(scip) );
698  interrupting = true;
699  }
700  }
701  }
702  return SCIP_OKAY;
703  }
704 
705  if( scipParaSolver->isCollectingModeProhibited() || nNodes < 2 ) // do not have to send status to LC yet.
706  {
707  return SCIP_OKAY;
708  }
709 
710  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::GenerateReducedCheckpointFiles) )
711  {
712  needToSendNode = true;
713  }
714 
715  if ( needToSendNode
716  || scipParaSolver->notificationIsNecessary()
717  || nNodes == 2
718  || scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic) ) // always notify
719  {
720  if( bestDualBoundValue >= -1e+10 ) // only after some dual bound value is computed, notify its status
721  {
722  int nNodesLeft = 0;
723  if( SCIPgetStage(scip) != SCIP_STAGE_TRANSFORMED &&
724  SCIPgetStage(scip) != SCIP_STAGE_PRESOLVING &&
725  SCIPgetStage(scip) != SCIP_STAGE_INITSOLVE )
726  {
727  nNodesLeft = SCIPgetNNodesLeft(scip);
728  }
729  scipParaSolver->sendSolverState(nNodes, nNodesLeft, bestDualBoundValue, detTime);
730  scipParaSolver->waitMessageIfNecessary();
731  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::GenerateReducedCheckpointFiles) &&
732  nNodes > 2 )
733  {
734  dynamic_cast<UG::BbParaNode *>(scipParaSolver->getCurrentNode())->setMergingStatus(3); // cannot be merged: this is a dummy status
735  SCIP_CALL_ABORT( SCIPinterruptSolve(scip) );
736  return SCIP_OKAY;
737  }
738  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::Deterministic)
739  && ( !needToSendNode )
740  && ( !scipParaSolver->isManyNodesCollectionRequested() )
741  && !( !scipParaSolver->isRacingStage()
742  && scipParaSolver->isAggressivePresolvingSpecified()
743  && scipParaSolver->getSubMipDepth() <
744  ( scipParaSolver->getOffsetDepth() + scipParaSolver->getAggresivePresolvingStopDepth() ) &&
745  SCIPgetDepth(scip) > scipParaSolver->getAggresivePresolvingDepth() )
746  )
747  {
748  scipParaSolver->passToken(scipParaSolver->getRank());
749  scipParaSolver->setPreviousCommTime(detTime);
750  }
751  }
752  }
753 
754  if( scipParaSolver->getNStopSolvingMode() > 0 &&
755  !scipParaSolver->isRacingStage() &&
756  ( nNodes < scipParaSolver->getNStopSolvingMode() ) &&
757  ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() ) > 0.0 &&
758  REALABS( ( bestDualBoundValue - std::max(scipParaSolver->getLcBestDualBoundValue(),-SCIPinfinity(scip) ) )
759  / std::max(std::fabs(scipParaSolver->getLcBestDualBoundValue()), 1.0) ) > scipParaSolver->getBoundGapForStopSolving() )
760  {
761  if( scipParaSolver->getBigDualGapSubtreeHandlingStrategy() == 0 )
762  {
763  if( scipParaSolver->getTimeStopSolvingMode() < 0 ||
764  ( scipParaSolver->getTimeStopSolvingMode() > 0 &&
765  scipParaSolver->getElapsedTimeOfNodeSolving() < scipParaSolver->getTimeStopSolvingMode() ) )
766  {
767  scipParaSolver->sendAnotherNodeRequest(bestDualBoundValue); // throw away nodes
768  }
769  }
770  else if( scipParaSolver->getBigDualGapSubtreeHandlingStrategy() == 1 )
771  {
772  if( scipParaSolver->getCurrentSolivingNodeMergingStatus() != 0 )
773  {
774  scipParaSolver->setSendBackAllNodes();
775  }
776  }
777  else
778  {
779  THROW_LOGICAL_ERROR2("Invalid big dual gap handling strategy. startegy = ",
780  scipParaSolver->getBigDualGapSubtreeHandlingStrategy() );
781  }
782  }
783 
784  if( scipParaSolver->getTimeStopSolvingMode() > 0 &&
785  !scipParaSolver->isRacingStage() &&
786  ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() ) > 0.0 &&
787  REALABS( ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() )
788  / scipParaSolver->getLcBestDualBoundValue() ) > scipParaSolver->getBoundGapForStopSolving() &&
789  ( scipParaSolver->getElapsedTimeOfNodeSolving() < scipParaSolver->getTimeStopSolvingMode() ) )
790  {
791  if( scipParaSolver->getBigDualGapSubtreeHandlingStrategy() == 0 )
792  {
793  if( scipParaSolver->getNStopSolvingMode() < 0 ||
794  ( scipParaSolver->getNStopSolvingMode() > 0 &&
795  nNodes < scipParaSolver->getNStopSolvingMode() ) )
796  {
797  scipParaSolver->sendAnotherNodeRequest(bestDualBoundValue); // throw away nodes
798  }
799  }
800  else if( scipParaSolver->getBigDualGapSubtreeHandlingStrategy() == 1 )
801  {
802  if( scipParaSolver->getCurrentSolivingNodeMergingStatus() != 0 )
803  {
804  scipParaSolver->setSendBackAllNodes();
805  }
806  }
807  else
808  {
809  THROW_LOGICAL_ERROR2("Invalid big dual gap handling strategy. startegy = ",
810  scipParaSolver->getBigDualGapSubtreeHandlingStrategy() );
811  }
812  }
813  /*******************************************************************
814  * if new ParaNode was received or Interrupt message was received, *
815  * stop solving the current ParaNode *
816  ******************************************************************/
817  if( cloned ||
818  ( SCIPeventGetType(event) != SCIP_EVENTTYPE_NODEFOCUSED
819  && !scipParaSolver->isInCollectingMode() ) )
820  {
821  return SCIP_OKAY; // process until SCIP_EVENTTYPE_NODEFOCUSED event
822  }
823 
824  if( scipParaSolver->getCurrentNode()->isRootTask() &&
825  (!startedCollectingNodesForInitialRampUp ) &&
826  scipParaSolver->getParaParamSet()->getIntParamValue(UG::NumberOfNodesKeepingInRootSolver) > 0
827  )
828  {
829  if( SCIPgetNNodesLeft(scip) < scipParaSolver->getParaParamSet()->getIntParamValue(UG::NumberOfNodesKeepingInRootSolver) )
830  {
831  return SCIP_OKAY;
832  }
833  else
834  {
835  startedCollectingNodesForInitialRampUp = true;
836  }
837  }
838 
839  /******************************************************************
840  * if node depth is smaller than that specified by parameter,
841  * not to send nodes and keep them.
842  *****************************************************************/
843  if( SCIPnodeGetDepth( SCIPgetCurrentNode( scip ) )
844  < scipParaSolver->getParaParamSet()->getIntParamValue(UG::KeepNodesDepth) &&
845  !scipParaSolver->isCollectingAllNodes() )
846  {
847  return SCIP_OKAY;
848  }
849 
850  /*******************************************************************
851  * if ParaNode transfer has been requested, send a ParaNode *
852  ******************************************************************/
853  if( ( needToSendNode &&
854  (
855  SCIPgetNNodesLeft( scip ) > scipParaSolver->getThresholdValue(SCIPgetNNodes(scip)) ||
856  scipParaSolver->isInterrupting() ||
857  ( SCIPgetNNodesLeft( scip ) > 1 &&
858  ( scipParaSolver->isAggressiveCollecting() ||
859  ( !scipParaSolver->isRampUp() &&
860  ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() < 0.0 ||
861  ( ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() ) > 0.0 &&
862  ( REALABS( ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() )
863  / std::max(REALABS(scipParaSolver->getLcBestDualBoundValue()),1.0) ) < scipParaSolver->getBoundGapForCollectingMode() )
864  )
865  )
866  )
867  )
868  )
869  )
870  )
871  || scipParaSolver->isManyNodesCollectionRequested()
872  || ( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::DualBoundGainTest) &&
873  scipParaSolver->isDualBoundGainTestNeeded() &&
874  (!scipParaSolver->isEnoughGainObtained()) )
875  || ( !scipParaSolver->isRacingStage() &&
876  scipParaSolver->isAggressivePresolvingSpecified() &&
877  scipParaSolver->getSubMipDepth() <
878  ( scipParaSolver->getOffsetDepth() + scipParaSolver->getAggresivePresolvingStopDepth() ) &&
879  SCIPgetDepth(scip) > scipParaSolver->getAggresivePresolvingDepth() )
880  )
881  {
882  if( !scipParaSolver->getParaParamSet()->getBoolParamValue(UG::GenerateReducedCheckpointFiles) &&
883  !scipParaSolver->isAnotherNodeIsRequested() )
884  {
885  if( checkRootNodeSolvabilityAndSendParaNode(scip) )
886  {
887  if( ( scipParaSolver->isManyNodesCollectionRequested() && (!scipParaSolver->isCollectingAllNodes() ) ) &&
888  scipParaSolver->isBreaking() &&
889  ( scipParaSolver->isTransferLimitReached() ||
890  ( bestDualBoundValue > scipParaSolver->getTargetBound() ) ) )
891  {
892  scipParaSolver->resetBreakingInfo();
893  }
894  }
895  else
896  {
897  return SCIP_OKAY;
898  }
899 
900  }
901  else
902  {
903  assert( nNodes <=2 );
904  return SCIP_OKAY;
905  }
906  }
907 
908  if( !scipParaSolver->isManyNodesCollectionRequested() )
909  {
910  if( !scipParaSolver->isRampUp() )
911  {
912  // if( ( !scipParaSolver->isWarmStarted() ) && scipParaSolver->isRacingRampUp() )
913  if( scipParaSolver->isRacingRampUp() )
914  {
915  if( scipParaSolver->isRacingWinner() || !scipParaSolver->isRacingStage() )
916  {
917  if( originalSelectionStrategy )
918  // if( originalSelectionStrategy && SCIPgetNNodesLeft(scip) > scipParaSolver->getNPreviousNodesLeft() )
919  {
920  changeSearchStrategy(scip);
921  }
922  needToSendNode = true;
923  }
924  }
925  else
926  {
927  if( ( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::BreakFirstSubtree)
928  && paraComm->getRank() == 1 ) ||
929  bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() < 0.0 ||
930  ( ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() ) > 0.0 &&
931  ( REALABS( ( bestDualBoundValue - scipParaSolver->getLcBestDualBoundValue() )
932  / scipParaSolver->getLcBestDualBoundValue() ) < scipParaSolver->getBoundGapForCollectingMode() ) ) )
933  {
934  if( originalSelectionStrategy )
935  // if( originalSelectionStrategy && SCIPgetNNodesLeft(scip) > scipParaSolver->getNPreviousNodesLeft() )
936  {
937  changeSearchStrategy(scip);
938  }
939  if( scipParaSolver->getParaParamSet()->getIntParamValue(UG::NoAlternateSolving) > 0 &&
940  SCIPgetNNodesLeft(scip) > scipParaSolver->getParaParamSet()->getIntParamValue(UG::NoAlternateSolving) )
941  {
942  needToSendNode = true;
943  }
944  else
945  {
946  if( needToSendNode ) needToSendNode = false;
947  else needToSendNode = true;
948  }
949  }
950  else
951  {
952  needToSendNode = false;
953  }
954  }
955  }
956  else
957  {
958  /*********************************************
959  * check if solver is in collecting mode *
960  ********************************************/
961  if( scipParaSolver->isInCollectingMode() )
962  {
963  if( originalSelectionStrategy )
964  // if( originalSelectionStrategy && SCIPgetNNodesLeft(scip) > scipParaSolver->getNPreviousNodesLeft() )
965  {
966  changeSearchStrategy(scip);
967  }
968  if( scipParaSolver->getNSendInCollectingMode() > 0 || scipParaSolver->isAggressiveCollecting() )
969  {
970  needToSendNode = true;
971  }
972  else
973  {
974  if( scipParaSolver->getParaParamSet()->getIntParamValue(UG::NoAlternateSolving) > 0 &&
975  SCIPgetNNodesLeft(scip) > scipParaSolver->getParaParamSet()->getIntParamValue(UG::NoAlternateSolving) )
976  {
977  needToSendNode = true;
978  }
979  else
980  {
981  if( needToSendNode ) needToSendNode = false;
982  else needToSendNode = true;
983  }
984  }
985  }
986  else
987  {
988  if( !originalSelectionStrategy )
989  {
990  SCIP_NODESEL *nodesel = SCIPgetNodesel(scip);
991  SCIP_CALL_ABORT( SCIPsetNodeselStdPriority(scip, nodesel,
992  scipParaSolver->getOriginalPriority() ) );
993  originalSelectionStrategy = true;
994  scipParaSolver->setNPreviousNodesLeft(SCIPgetNNodesLeft(scip));
995  }
996  needToSendNode = false; // In iReceive, more than on collecting mode message may be received
997  }
998  }
999  }
1000 
1001  return SCIP_OKAY;
1002 }
1003 
1004 // void
1005 bool
1006 ScipParaObjCommPointHdlr::checkRootNodeSolvabilityAndSendParaNode(
1007  SCIP* scip
1008  )
1009 {
1010  SCIP_NODE* node = SCIPgetCurrentNode( scip );
1011  int depth = SCIPnodeGetDepth( node );
1012  SCIP_VAR **branchVars = new SCIP_VAR*[depth];
1013  SCIP_Real *branchBounds = new SCIP_Real[depth];
1014  SCIP_BOUNDTYPE *boundTypes = new SCIP_BOUNDTYPE[depth];
1015  int nBranchVars;
1016  SCIPnodeGetAncestorBranchings( node, branchVars, branchBounds, boundTypes, &nBranchVars, depth );
1017  if( nBranchVars > depth ) // did not have enough memory, then reallocate
1018  {
1019  delete [] branchVars;
1020  delete [] branchBounds;
1021  delete [] boundTypes;
1022  branchVars = new SCIP_VAR*[nBranchVars];
1023  branchBounds = new SCIP_Real[nBranchVars];
1024  boundTypes = new SCIP_BOUNDTYPE[nBranchVars];
1025  SCIPnodeGetAncestorBranchings( node, branchVars, branchBounds, boundTypes, &nBranchVars, nBranchVars );
1026  }
1027 
1028  if( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::AllBoundChangesTransfer) &&
1029  !( scipParaSolver->getParaParamSet()->getBoolParamValue(UG::NoAllBoundChangesTransferInRacing) &&
1030  scipParaSolver->isRacingStage() ) )
1031  {
1032  int nVars = SCIPgetNVars(scip);
1033  SCIP_VAR **vars = SCIPgetVars(scip);
1034  int *iBranchVars = new int[nBranchVars];
1035  /* create the variable mapping hash map */
1036  SCIP_HASHMAP* varmapLb;
1037  SCIP_HASHMAP* varmapUb;
1038  SCIP_CALL_ABORT( SCIPhashmapCreate(&varmapLb, SCIPblkmem(scip), nVars) );
1039  SCIP_CALL_ABORT( SCIPhashmapCreate(&varmapUb, SCIPblkmem(scip), nVars) );
1040  for( int i = 0; i < nBranchVars; i++ )
1041  {
1042  iBranchVars[i] = i;
1043  if( boundTypes[i] == SCIP_BOUNDTYPE_LOWER )
1044  {
1045  if( !SCIPhashmapGetImage(varmapLb, branchVars[i]) )
1046  {
1047  SCIP_CALL_ABORT( SCIPhashmapInsert(varmapLb, branchVars[i], &iBranchVars[i] ) );
1048  }
1049  }
1050  else
1051  {
1052  if( !SCIPhashmapGetImage(varmapUb, branchVars[i]) )
1053  {
1054  SCIP_CALL_ABORT( SCIPhashmapInsert(varmapUb, branchVars[i], &iBranchVars[i] ) );
1055  }
1056  }
1057  }
1058  SCIP_VAR **preBranchVars = branchVars;
1059  SCIP_Real *preBranchBounds = branchBounds;
1060  SCIP_BOUNDTYPE *preBboundTypes = boundTypes;
1061  branchVars = new SCIP_VAR*[nBranchVars+nVars*2];
1062  branchBounds = new SCIP_Real[nBranchVars+nVars*2];
1063  boundTypes = new SCIP_BOUNDTYPE[nBranchVars+nVars*2];
1064  for( int i = 0; i < nBranchVars; i++ )
1065  {
1066  branchVars[i] = preBranchVars[i];
1067  branchBounds[i] = preBranchBounds[i];
1068  boundTypes[i] = preBboundTypes[i];
1069  }
1070  int *iBranchVar = NULL;
1071  for( int i = 0; i < nVars; i++ )
1072  {
1073  if( scipParaSolver->isCopyIncreasedVariables() &&
1074  scipParaSolver->getOriginalIndex(i) >= scipParaSolver->getNOrgVars() )
1075  {
1076  continue;
1077  }
1078  iBranchVar = (int *)SCIPhashmapGetImage(varmapLb, vars[i]);
1079  if( iBranchVar )
1080  {
1081  // assert( EPSGE(preBranchBounds[*iBranchVar], SCIPvarGetLbLocal(vars[i]) ,DEFAULT_NUM_EPSILON ) );
1082  if( EPSLT(preBranchBounds[*iBranchVar], SCIPvarGetLbLocal(vars[i]) ,DEFAULT_NUM_EPSILON ) )
1083  {
1084  branchBounds[*iBranchVar] = SCIPvarGetLbLocal(vars[i]); // node is current node
1085  if ( EPSGT(branchBounds[*iBranchVar], SCIPvarGetUbGlobal(vars[i]), DEFAULT_NUM_EPSILON) ) abort();
1086  }
1087  }
1088  else
1089  {
1090  if( EPSGT( SCIPvarGetLbLocal(vars[i]), SCIPvarGetLbGlobal(vars[i]), MINEPSILON ) )
1091  {
1092  branchVars[nBranchVars] = vars[i];
1093  branchBounds[nBranchVars] = SCIPvarGetLbLocal(vars[i]);
1094  boundTypes[nBranchVars] = SCIP_BOUNDTYPE_LOWER;
1095  if ( EPSGT(branchBounds[nBranchVars], SCIPvarGetUbGlobal(vars[i]), DEFAULT_NUM_EPSILON) ) abort();
1096  nBranchVars++;
1097  }
1098  }
1099  iBranchVar = (int *)SCIPhashmapGetImage(varmapUb, vars[i]);
1100  if( iBranchVar )
1101  {
1102  // assert( EPSLE(preBranchBounds[*iBranchVar], SCIPvarGetUbLocal(vars[i]) ,DEFAULT_NUM_EPSILON ) );
1103  if( EPSGT(preBranchBounds[*iBranchVar], SCIPvarGetUbLocal(vars[i]) ,DEFAULT_NUM_EPSILON ) )
1104  {
1105  branchBounds[*iBranchVar] = SCIPvarGetUbLocal(vars[i]); // node is current node
1106  if ( EPSLT(branchBounds[*iBranchVar], SCIPvarGetLbGlobal(vars[i]),DEFAULT_NUM_EPSILON) ) abort();
1107  }
1108  }
1109  else
1110  {
1111  if( EPSLT( SCIPvarGetUbLocal(vars[i]), SCIPvarGetUbGlobal(vars[i]), MINEPSILON ) )
1112  {
1113  branchVars[nBranchVars] = vars[i];
1114  branchBounds[nBranchVars] = SCIPvarGetUbLocal(vars[i]);
1115  boundTypes[nBranchVars] = SCIP_BOUNDTYPE_UPPER;
1116  if ( EPSLT(branchBounds[nBranchVars], SCIPvarGetLbGlobal(vars[i]),DEFAULT_NUM_EPSILON) ) abort();
1117  nBranchVars++;
1118  }
1119  }
1120  }
1121  SCIPhashmapFree(&varmapLb);
1122  SCIPhashmapFree(&varmapUb);
1123  delete [] preBranchVars;
1124  delete [] preBranchBounds;
1125  delete [] preBboundTypes;
1126  delete [] iBranchVars;
1127  }
1128 
1129  /** check root node solvability */
1130  if( scipParaSolver->getParaParamSet()->getBoolParamValue(RootNodeSolvabilityCheck) )
1131  {
1132  SCIP_CALL_ABORT( SCIPtransformProb(scipToCheckRootSolvability) );
1133  SCIP_VAR **copyVars = SCIPgetVars(scipToCheckRootSolvability);
1134  for(int v = 0; v < nBranchVars; v++)
1135  {
1136  int index = SCIPvarGetProbindex(branchVars[v]);
1137  assert(index != -1);
1138  assert(std::string(SCIPvarGetName(branchVars[v]))==std::string(SCIPvarGetName(copyVars[index])));
1139  if( boundTypes[v] == SCIP_BOUNDTYPE_LOWER )
1140  {
1141  SCIP_CALL_ABORT(SCIPchgVarLbGlobal(scipToCheckRootSolvability,copyVars[index], branchBounds[v]));
1142  }
1143  else if (boundTypes[v] == SCIP_BOUNDTYPE_UPPER)
1144  {
1145  SCIP_CALL_ABORT(SCIPchgVarUbGlobal(scipToCheckRootSolvability,copyVars[index], branchBounds[v]));
1146  }
1147  else
1148  {
1149  THROW_LOGICAL_ERROR2("Invalid bound type: type = ", static_cast<int>(boundTypes[v]));
1150  }
1151  }
1152  SCIP_CALL_ABORT(SCIPsetLongintParam(scipToCheckRootSolvability,"limits/nodes", 1));
1153  SCIP_CALL_ABORT(SCIPsetObjlimit(scipToCheckRootSolvability, scipParaSolver->getGlobalBestIncumbentValue()));
1154  SCIP_CALL_ABORT(SCIPsolve(scipToCheckRootSolvability));
1155 
1156  SCIP_STATUS status = SCIPgetStatus(scipToCheckRootSolvability);
1157 
1158  switch(status)
1159  {
1160  case SCIP_STATUS_OPTIMAL :
1161  {
1162  SCIP_SOL *bestSol = SCIPgetBestSol( scip );
1163  int nVars = SCIPgetNOrigVars(scip);
1164  SCIP_VAR **vars = SCIPgetOrigVars(scip);
1165  SCIP_Real *vals = new SCIP_Real[nVars];
1166  SCIP_CALL_ABORT( SCIPgetSolVals(scip, bestSol, nVars, vars, vals) );
1167  DEF_SCIP_PARA_COMM( scipParaComm, paraComm);
1168  scipParaSolver->saveIfImprovedSolutionWasFound(
1169  scipParaComm->createScipParaSolution(
1170  scipParaSolver,
1171  SCIPgetSolOrigObj(scip, bestSol),
1172  nVars,
1173  vars,
1174  vals
1175  )
1176  );
1177  delete [] vals;
1178  /** remove the node sent from SCIP environment */
1179  SCIP_CALL_ABORT( SCIPcutoffNode( scip, node) );
1180  needToSendNode = false; // This means that a node is sent in the next time again,
1181  // because this flag is flipped when collecting mode is checked
1182  scipParaSolver->countInPrecheckSolvedParaNodes();
1183  break;
1184  }
1185  case SCIP_STATUS_INFEASIBLE :
1186  case SCIP_STATUS_INFORUNBD :
1187  {
1188  /** remove the node sent from SCIP environment */
1189  SCIP_CALL_ABORT( SCIPcutoffNode( scip, node ) );
1190  needToSendNode = false; // This means that a node is sent in the next time again,
1191  // because this flag is flipped when collecting mode is checked
1192  scipParaSolver->countInPrecheckSolvedParaNodes();
1193  break;
1194  }
1195  case SCIP_STATUS_NODELIMIT :
1196  {
1197  sendNode(scip, node, depth, nBranchVars, branchVars, branchBounds, boundTypes);
1198  break;
1199  }
1200  default:
1201  THROW_LOGICAL_ERROR2("Invalid status after root solvability check: status = ", static_cast<int>(status));
1202  }
1203 
1204  SCIP_CALL_ABORT( SCIPfreeTransform(scipToCheckRootSolvability) );
1205  }
1206  else
1207  {
1208  if( scipParaSolver->isCopyIncreasedVariables() ) // this may not need, but only for this error occurred so far.
1209  {
1210  if( !ifFeasibleInOriginalProblem(scip, nBranchVars, branchVars, branchBounds) )
1211  {
1212  delete [] branchVars;
1213  delete [] branchBounds;
1214  delete [] boundTypes;
1215  return false;
1216  }
1217  }
1218  sendNode(scip, node, depth, nBranchVars, branchVars, branchBounds, boundTypes);
1219  }
1220 
1221  delete [] branchVars;
1222  delete [] branchBounds;
1223  delete [] boundTypes;
1224 
1225  return true;
1226 }
1227 
1228 void
1229 ScipParaObjCommPointHdlr::sendNode(
1230  SCIP *scip,
1231  SCIP_NODE* node,
1232  int depth,
1233  int nNewBranchVars,
1234  SCIP_VAR **newBranchVars,
1235  SCIP_Real *newBranchBounds,
1236  SCIP_BOUNDTYPE *newBoundTypes
1237  )
1238 {
1239 
1240  SCIP_CONS** addedcons = 0;
1241  int addedconsssize = SCIPnodeGetNAddedConss(node);
1242  int naddedconss = 0;
1243  if( addedconsssize > 0 )
1244  {
1245  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &addedcons, addedconsssize) );
1246  SCIPnodeGetAddedConss(node, addedcons, &naddedconss, addedconsssize);
1247  }
1248 
1249 
1250  DEF_SCIP_PARA_COMM( scipParaComm, paraComm);
1251  ScipParaDiffSubproblem *diffSubproblem = scipParaComm->createScipParaDiffSubproblem(
1252  scip,
1253  scipParaSolver,
1254  nNewBranchVars,
1255  newBranchVars,
1256  newBranchBounds,
1257  newBoundTypes,
1258  naddedconss,
1259  addedcons
1260  );
1261 
1262  if( naddedconss )
1263  {
1264  SCIPfreeBufferArray(scip, &addedcons);
1265  }
1266 
1267 
1268  long long n = SCIPnodeGetNumber( node );
1269  double dualBound = SCIPgetDualbound(scip);
1270  // if( SCIPisObjIntegral(scip) )
1271  // {
1272  // dualBound = ceil(dualBound);
1273  // }
1274  assert(SCIPisFeasGE(scip, SCIPnodeGetLowerbound(node) , SCIPgetLowerbound(scip)));
1275  double estimateValue = SCIPnodeGetEstimate( node );
1276  assert(SCIPisFeasGE(scip, estimateValue, SCIPnodeGetLowerbound(node) ));
1277 #ifdef UG_DEBUG_SOLUTION
1278  SCIP_Bool valid = 0;
1279  SCIP_CALL_ABORT( SCIPdebugSolIsValidInSubtree(scip, &valid) );
1280  diffSubproblem->setOptimalSolIndicator(valid);
1281  std::cout << "* R." << scipParaSolver->getRank() << ", debug = " << SCIPdebugSolIsEnabled(scip) << ", valid = " << valid << std::endl;
1282 #endif
1283  scipParaSolver->sendParaNode(n, depth, dualBound, estimateValue, diffSubproblem);
1284 
1285  /** remove the node sent from SCIP environment */
1286 #ifdef UG_DEBUG_SOLUTION
1287  if( valid )
1288  {
1289  SCIPdebugSolDisable(scip);
1290  std::cout << "R." << paraComm->getRank() << ": disable debug, node which contains optmal solution is sent." << std::endl;
1291  }
1292 #endif
1293  SCIP_CALL_ABORT( SCIPcutoffNode( scip, node) );
1294 }
1295 
1296 void
1297 ScipParaObjCommPointHdlr::changeSearchStrategy(
1298  SCIP* scip
1299  )
1300 {
1301  scipParaSolver->setNPreviousNodesLeft(SCIPgetNNodesLeft(scip));
1302  int numnodesels = SCIPgetNNodesels( scip );
1303  SCIP_NODESEL** nodesels = SCIPgetNodesels( scip );
1304  int i;
1305  for( i = 0; i < numnodesels; ++i )
1306  {
1307  std::string nodeselname(SCIPnodeselGetName(nodesels[i]));
1308  if( std::string(nodeselname) == std::string(changeNodeSelName) )
1309  {
1310  SCIP_CALL_ABORT( SCIPsetNodeselStdPriority(scip, nodesels[i], 536870911 ) );
1311  originalSelectionStrategy = false;
1312  int maxrestarts;
1313  SCIP_CALL_ABORT( SCIPgetIntParam(scip, "presolving/maxrestarts", &maxrestarts) );
1314  if( maxrestarts != 0 )
1315  {
1316  SCIP_CALL_ABORT( SCIPsetIntParam(scip, "presolving/maxrestarts", 0) );
1317  }
1318  break;
1319  }
1320  }
1321  assert( i != numnodesels );
1322 }
1323 
1324 bool
1325 ScipParaObjCommPointHdlr::ifFeasibleInOriginalProblem(
1326  SCIP *scip,
1327  int nNewBranchVars,
1328  SCIP_VAR **newBranchVars,
1329  SCIP_Real *newBranchBounds)
1330 {
1331 
1332  bool feasible = true;
1333  SCIP_Real *branchBounds = new SCIP_Real[nNewBranchVars];
1334  for( int v = nNewBranchVars -1 ; v >= 0; --v )
1335  {
1336  SCIP_VAR *transformVar = newBranchVars[v];
1337  SCIP_Real scalar = 1.0;
1338  SCIP_Real constant = 0.0;
1339  SCIP_CALL_ABORT( SCIPvarGetOrigvarSum(&transformVar, &scalar, &constant ) );
1340  if( transformVar == NULL ) continue;
1341  // assert( scalar == 1.0 && constant == 0.0 );
1342  branchBounds[v] = ( newBranchBounds[v] - constant ) / scalar;
1343  if( SCIPvarGetType(transformVar) != SCIP_VARTYPE_CONTINUOUS
1344  && SCIPvarGetProbindex(transformVar) < scipParaSolver->getNOrgVars() )
1345  {
1346  if( !(SCIPisLE(scip,scipParaSolver->getOrgVarLb(SCIPvarGetProbindex(transformVar)), branchBounds[v]) &&
1347  SCIPisGE(scip,scipParaSolver->getOrgVarUb(SCIPvarGetProbindex(transformVar)), branchBounds[v])) )
1348  {
1349  feasible = false;
1350  break;
1351  }
1352  }
1353  }
1354  delete [] branchBounds;
1355 
1356  return feasible;
1357 }
UG::BbParaSolver::newParaNodeExists
bool newParaNodeExists()
check if a new ParaNode was received or not
Definition: bbParaSolver.h:883
ParaSCIP::ScipParaSolver::setTightenedVarUb
void setTightenedVarUb(int i, double v)
Definition: scipParaSolver.h:372
ParaSCIP::ScipParaObjCommPointHdlr::scipParaObjLimitUpdator
ScipParaObjLimitUpdator * scipParaObjLimitUpdator
Definition: scipParaObjCommPointHdlr.h:58
UG::NumberOfNodesKeepingInRootSolver
static const int NumberOfNodesKeepingInRootSolver
Definition: bbParaParamSet.h:126
ParaSCIP::ScipParaSolver::getOriginalIndex
int getOriginalIndex(int index)
Definition: scipParaSolver.h:347
UG::BbParaSolver::getLcBestDualBoundValue
double getLcBestDualBoundValue()
get LoadCorrdinator best dual bound value
Definition: bbParaSolver.h:746
ParaSCIP::ScipParaSolver::getProbIndex
int getProbIndex(int index)
Definition: scipParaSolver.h:355
UG::BbParaSolver::isBreaking
bool isBreaking()
check if Solver is in racing stage or not
Definition: bbParaSolver.h:1091
UG::GenerateReducedCheckpointFiles
static const int GenerateReducedCheckpointFiles
Definition: bbParaParamSet.h:102
UG::BbParaSolver::getBoundGapForStopSolving
double getBoundGapForStopSolving()
get bound gap for stop solving. This value is not used to decide stop solving. It is used a part of c...
Definition: bbParaSolver.h:789
DEFAULT_NUM_EPSILON
#define DEFAULT_NUM_EPSILON
Definition: paraDef.h:49
UG::BbParaSolver::isAggressivePresolvingSpecified
bool isAggressivePresolvingSpecified()
check if aggressive presolving is specified
Definition: bbParaSolver.h:1154
scipParaDiffSubproblem.h
ParaInitialStat extension for SCIP solver.
UG::FinalCheckpointGeneratingTime
static const int FinalCheckpointGeneratingTime
Definition: paraParamSet.h:108
scipParaObjCommPointHdlr.h
Event handlr for communication point.
UG::BbParaSolver::countInPrecheckSolvedParaNodes
void countInPrecheckSolvedParaNodes()
count ParaNode solved at root node in pre-check
Definition: bbParaSolver.h:1020
ParaSCIP::RootNodeSolvabilityCheck
static const int RootNodeSolvabilityCheck
Definition: scipParaParamSet.h:60
UG::BbParaSolver::setRootNodeSimplexIter
void setRootNodeSimplexIter(int iter)
set number of simplex iteration at root node
Definition: bbParaSolver.h:1257
UG::BbParaSolver::getGlobalBestIncumbentValue
double getGlobalBestIncumbentValue()
get global best incumbent value
Definition: bbParaSolver.h:971
UG::BbParaSolver::isRacingRampUp
bool isRacingRampUp()
check if this solver is in racing ramp-up or not
Definition: bbParaSolver.h:1352
UG::BbParaSolver::getSubMipDepth
int getSubMipDepth()
get depth of sub-MIP root node in global search tree
Definition: bbParaSolver.h:1184
UG::BbParaSolver::getBigDualGapSubtreeHandlingStrategy
int getBigDualGapSubtreeHandlingStrategy()
get big dual gap subtree handling strategy
Definition: bbParaSolver.h:1214
UG::BbParaSolver::isAggressiveCollecting
bool isAggressiveCollecting()
check if Solver is in aggressive collecting mode or not
Definition: bbParaSolver.h:903
UG::BbParaSolver::isRacingInterruptRequested
bool isRacingInterruptRequested()
check if racing interrupt was requested or not
Definition: bbParaSolver.h:834
UG::ParaTask::isRootTask
bool isRootTask()
check if root task or not
Definition: paraTask.h:624
scipParaSolution.h
ParaSolution extension for SCIP solver.
UG::BbParaSolver::getAggresivePresolvingDepth
int getAggresivePresolvingDepth()
get depth to apply aggressive presolving
Definition: bbParaSolver.h:1164
UG::ControlCollectingModeOnSolverSide
static const int ControlCollectingModeOnSolverSide
Definition: bbParaParamSet.h:99
UG::BbParaSolver::iReceiveMessages
virtual void iReceiveMessages()
non-blocking receive messages
Definition: bbParaSolver.cpp:1188
UG::BbParaSolver::isRacingStage
bool isRacingStage()
check if Solver is in racing stage or not
Definition: bbParaSolver.h:1363
UG::BbParaSolver::getTimeStopSolvingMode
double getTimeStopSolvingMode()
get time to stop solving. This value is not used to decide stop solving. It is used a part of conditi...
Definition: bbParaSolver.h:768
UG::BbParaSolver::setRootNodeTime
virtual void setRootNodeTime()
set root node computing time
Definition: bbParaSolver.cpp:1246
UG::BbParaSolver::setNotEnoughGain
void setNotEnoughGain()
set dual bound gain is not enough
Definition: bbParaSolver.h:1322
UG::BbParaSolver::isCollecingInterrupt
bool isCollecingInterrupt()
check if collecting interrupt (interrupt with collecting all nodes) is requested or not ...
Definition: bbParaSolver.h:844
REALABS
#define REALABS(x)
Definition: paraDef.h:165
UG::TagLbBoundTightenedBound
static const int TagLbBoundTightenedBound
Definition: bbParaTagDef.h:63
UG::ParaSolver::getDeterministicTimer
ParaDeterministicTimer * getDeterministicTimer()
get deterministic timer object
Definition: paraSolver.h:739
ParaSCIP::ScipParaSolver::getTightenedVarUb
double getTightenedVarUb(int i)
Definition: scipParaSolver.h:370
UG::BbParaSolver::sendAnotherNodeRequest
virtual void sendAnotherNodeRequest(double bestDualBoundValue)
send another node request
Definition: bbParaSolver.cpp:2072
PARA_COMM_CALL
#define PARA_COMM_CALL(paracommcall)
Definition: paraComm.h:47
UG::Deterministic
static const int Deterministic
Definition: paraParamSet.h:76
UG::ParaComm::getRank
virtual int getRank()=0
get rank of this process or this thread depending on run-time environment
UG::ParaSolver::isTerminationRequested
bool isTerminationRequested()
check if termination was requested or not
Definition: paraSolver.h:589
UG::BbParaSolver::getCurrentSolivingNodeMergingStatus
int getCurrentSolivingNodeMergingStatus()
get current solving node merging status
Definition: bbParaSolver.h:1293
UG::BbParaSolver::getAggresivePresolvingStopDepth
int getAggresivePresolvingStopDepth()
get depth to stop aggressive presolving
Definition: bbParaSolver.h:1174
UG::ParaDOUBLE
static const int ParaDOUBLE
Definition: paraComm.h:76
UG::BbParaSolver::getTargetBound
double getTargetBound()
get target bound for breaking
Definition: bbParaSolver.h:1101
UG::ParaDeterministicTimer::getElapsedTime
virtual double getElapsedTime()=0
getter of the deterministic time
UG::BbParaSolver::passToken
void passToken(int rank)
pass token to the next process
Definition: bbParaSolver.h:1282
UG::BbParaSolver::isGivenGapReached
bool isGivenGapReached()
check if given gap is reached or not
Definition: bbParaSolver.h:1224
UG::NoAlternateSolving
static const int NoAlternateSolving
Definition: bbParaParamSet.h:143
UG::ParaParamSet::getRealParamValue
double getRealParamValue(int param)
for real parameters
Definition: paraParamSet.cpp:336
ParaSCIP::ScipParaObjCommPointHdlr::ifFeasibleInOriginalProblem
bool ifFeasibleInOriginalProblem(SCIP *scip, int nNewBranchVars, SCIP_VAR **newBranchVars, SCIP_Real *newBranchBounds)
Definition: scipParaObjCommPointHdlr.cpp:1325
UG::BbParaSolver::getCurrentNode
ParaTask * getCurrentNode()
get current ParaNode object
Definition: bbParaSolver.h:981
UG::ParaSolver::isRacingWinner
bool isRacingWinner()
check if this solver is in racing ramp-up or not
Definition: paraSolver.h:530
UG::BbParaSolver::waitMessageIfNecessary
virtual void waitMessageIfNecessary()
wait a notification id message if it is needed to synchronize with LoadCoordinaor ...
Definition: bbParaSolver.cpp:2100
UG::BbParaSolver::sendLocalSolution
virtual void sendLocalSolution()
send solution found in this Solver
Definition: bbParaSolver.cpp:1716
UG::BbParaSolver::getRank
virtual int getRank()
get rank of this Solver
Definition: bbParaSolver.h:1011
UG::DualBoundGainBranchRatio
static const int DualBoundGainBranchRatio
Definition: bbParaParamSet.h:192
UG::BbParaSolver::resetBreakingInfo
void resetBreakingInfo()
reset breaking information
Definition: bbParaSolver.h:1120
EPSLT
#define EPSLT(x, y, eps)
Definition: paraDef.h:167
UG::ParaSolver::getPreviousCommTime
double getPreviousCommTime()
get previous communication time for deterministic execution
Definition: paraSolver.h:828
UG::TagUbBoundTightenedIndex
static const int TagUbBoundTightenedIndex
Definition: bbParaTagDef.h:64
UG::ParaSolver::setPreviousCommTime
void setPreviousCommTime(double detTime)
set previous communication time for deterministic execution
Definition: paraSolver.h:817
ParaSCIP::ScipParaSolver::setTightenedVarLb
void setTightenedVarLb(int i, double v)
Definition: scipParaSolver.h:371
UG::BbParaSolver::getCurrentSolvingNodeInitialDualBound
double getCurrentSolvingNodeInitialDualBound()
get initial dual bound of current solving node
Definition: bbParaSolver.h:1303
UG::BbParaSolver::isInCollectingMode
bool isInCollectingMode()
check if Solver is in collecting mode or not
Definition: bbParaSolver.h:893
ParaSCIP::ScipParaSolver::getTightenedVarLb
double getTightenedVarLb(int i)
Definition: scipParaSolver.h:369
UG::TagAllowToBeInCollectingMode
static const int TagAllowToBeInCollectingMode
Definition: bbParaTagDef.h:57
THROW_LOGICAL_ERROR2
#define THROW_LOGICAL_ERROR2(msg1, msg2)
Definition: paraDef.h:69
UG::BbParaSolver::getElapsedTimeOfNodeSolving
double getElapsedTimeOfNodeSolving()
the following functions may be called from callback routines of the target Solver ...
Definition: bbParaSolver.h:726
UG::BbParaSolver::saveIfImprovedSolutionWasFound
virtual bool saveIfImprovedSolutionWasFound(ParaSolution *sol)
save improved solution if it was found in this Solver
Definition: bbParaSolver.cpp:2172
UG::NoAllBoundChangesTransferInRacing
static const int NoAllBoundChangesTransferInRacing
Definition: bbParaParamSet.h:94
UG::BbParaSolver::getThresholdValue
virtual int getThresholdValue(int nNodes)
get threshold value to send ParaNodes to LoadCoordinator
Definition: bbParaSolver.cpp:1916
UG::BbParaSolver::getAverageDualBoundGain
double getAverageDualBoundGain()
get average dual bound gain
Definition: bbParaSolver.h:1313
UG::ParaBYTE
static const int ParaBYTE
Definition: paraComm.h:79
UG::BbParaSolver::getBoundGapForCollectingMode
double getBoundGapForCollectingMode()
get bound gap for collecting mode
Definition: bbParaSolver.h:799
UG::BbParaNode
class BbParaNode
Definition: bbParaNode.h:61
UG::ParaSolver::isRampUp
bool isRampUp()
check if this solver is ramp-up or not
Definition: paraSolver.h:509
UG::NotificationInterval
static const int NotificationInterval
Definition: paraParamSet.h:105
ParaSCIP::ScipParaObjCommPointHdlr::processNewSolution
void processNewSolution(SCIP *scip, SCIP_EVENT *event)
Definition: scipParaObjCommPointHdlr.cpp:58
EPSGT
#define EPSGT(x, y, eps)
Definition: paraDef.h:169
UG::AllowableRegressionRatioInMerging
static const int AllowableRegressionRatioInMerging
Definition: bbParaParamSet.h:187
ParaSCIP::ScipParaObjCommPointHdlr::sendNode
void sendNode(SCIP *scip, SCIP_NODE *node, int depth, int nBranchVars, SCIP_VAR **branchVars, SCIP_Real *branchBounds, SCIP_BOUNDTYPE *boundTypes)
Definition: scipParaObjCommPointHdlr.cpp:1229
UG::ParaSolver::updatePendingSolution
virtual void updatePendingSolution()
update pending solution
Definition: paraSolver.h:759
UG::BbParaSolver::isDualBoundGainTestNeeded
bool isDualBoundGainTestNeeded()
check if dual bound gain needs to be tested or not
Definition: bbParaSolver.h:1342
UG::RampUpPhaseProcess
static const int RampUpPhaseProcess
Definition: bbParaParamSet.h:118
UG::BbParaSolver::isCollectingAllNodes
bool isCollectingAllNodes()
check if Solver is sending all nodes to LoadCoordinaor or not
Definition: bbParaSolver.h:1204
UG::BbParaSolver::notificationIsNecessary
virtual bool notificationIsNecessary()
check if a notification message needs to send or not
Definition: bbParaSolver.cpp:1746
UG::CommunicateTighterBoundsInRacing
static const int CommunicateTighterBoundsInRacing
Definition: bbParaParamSet.h:104
UG::ParaComm::send
virtual int send(void *bufer, int count, const int datatypeId, int dest, const int tag)=0
send function for standard ParaData types
UG::TagLbBoundTightenedIndex
static const int TagLbBoundTightenedIndex
Definition: bbParaTagDef.h:62
UG::BbParaSolver::setSendBackAllNodes
void setSendBackAllNodes()
set counter and flag to indicate that all nodes are sent to LoadCooordinator
Definition: bbParaSolver.h:1193
UG::BbParaSolver::getNStopSolvingMode
int getNStopSolvingMode()
get number of nodes to stop solving. This number is not used to decide stop solving. It is used a part of conditions.
Definition: bbParaSolver.h:757
UG::TagUbBoundTightenedBound
static const int TagUbBoundTightenedBound
Definition: bbParaTagDef.h:65
ParaSCIP::ScipParaSolver::setNPreviousNodesLeft
void setNPreviousNodesLeft(long long n)
Definition: scipParaSolver.h:362
ParaSCIP::ScipParaObjCommPointHdlr::scip_exec
virtual SCIP_RETCODE scip_exec(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENT *event, SCIP_EVENTDATA *eventdata)
Definition: scipParaObjCommPointHdlr.cpp:121
MINEPSILON
#define MINEPSILON
Definition: paraDef.h:50
UG::ParaINT
static const int ParaINT
Definition: paraComm.h:66
UG::BbParaSolver::waitToken
bool waitToken(int rank)
wait token for deterministic mode
Definition: bbParaSolver.h:1268
UG::ParaParamSet::getIntParamValue
int getIntParamValue(int param)
for int parameters
Definition: paraParamSet.cpp:228
UG::BbParaSolver::sendSolverState
virtual void sendSolverState(long long nNodesSolved, int nNodesLeft, double bestDualBoundValue, double detTime)
send Solver state to LoadCoordinator
Definition: bbParaSolver.cpp:1865
UG::BbParaSolver::isGlobalIncumbentUpdated
bool isGlobalIncumbentUpdated()
check if global incumbent value is updated or not
Definition: bbParaSolver.h:815
UG::BbParaSolver::getParaParamSet
ParaParamSet * getParaParamSet()
get ParaParamSet object
Definition: bbParaSolver.h:1001
UG::BreakFirstSubtree
static const int BreakFirstSubtree
Definition: bbParaParamSet.h:95
UG::EventWeightedDeterministic
static const int EventWeightedDeterministic
Definition: bbParaParamSet.h:89
UG::ParaDeterministicTimer::update
virtual void update(double value)=0
update function of the deterministic time. the deterministic time is a kind of counter ...
UG::BbParaSolver::sendParaNode
virtual void sendParaNode(long long n, int depth, double dualBound, double estimateValue, ParaDiffSubproblem *diffSubproblem)
send a branch-and-bound node as ParaNode to LoadCoordinator
Definition: bbParaSolver.cpp:1971
UG::AllBoundChangesTransfer
static const int AllBoundChangesTransfer
Definition: bbParaParamSet.h:93
UG::DualBoundGainTest
static const int DualBoundGainTest
Definition: bbParaParamSet.h:101
UG::BbParaSolver::isAnotherNodeIsRequested
bool isAnotherNodeIsRequested()
check if another node is requested or not
Definition: bbParaSolver.h:1494
UG::BbParaSolver::getNSendInCollectingMode
int getNSendInCollectingMode()
get number of ParaNodes already sent in a collecting mode
Definition: bbParaSolver.h:1036
UG::KeepNodesDepth
static const int KeepNodesDepth
Definition: bbParaParamSet.h:142
UG::BbParaSolver::isManyNodesCollectionRequested
bool isManyNodesCollectionRequested()
check if many nodes collection was requested or not
Definition: bbParaSolver.h:913
DEF_SCIP_PARA_COMM
#define DEF_SCIP_PARA_COMM(scip_para_comm, comm)
Definition: scipParaCommMpi.h:201
UG::BbParaSolver::isEnoughGainObtained
bool isEnoughGainObtained()
check if dual bound gains enough or not
Definition: bbParaSolver.h:1332
UG::ParaParamSet::getBoolParamValue
bool getBoolParamValue(int param)
for bool parameters
Definition: paraParamSet.cpp:174
UG::BbParaSolver::isTransferLimitReached
bool isTransferLimitReached()
check if the number of ParaNodes sent is reached to transfer limit specified
Definition: bbParaSolver.h:1111