34 #define EVENTHDLR_NAME "sync" 35 #define EVENTHDLR_DESC "event handler for synchronization of concurrent scip sovlers" 42 struct SCIP_EventhdlrData
58 assert(eventhdlr !=
NULL);
62 assert(eventhdlrdata !=
NULL);
81 assert(eventhdlr !=
NULL);
85 assert(eventhdlrdata !=
NULL);
88 assert(syncstore !=
NULL);
106 assert(eventhdlr !=
NULL);
110 assert(eventhdlrdata !=
NULL);
113 if( eventhdlrdata->filterpos >= 0 )
116 eventhdlrdata->filterpos = -1;
126 assert(eventhdlr !=
NULL);
128 assert(event !=
NULL);
147 eventhdlrdata->filterpos = -1;
151 assert(eventhdlr !=
NULL);
161 struct SCIP_ConcSolverTypeData
168 struct SCIP_ConcSolverData
201 static char childsel[] = {
'h',
'i',
'p',
'r',
'l',
'd',
'u' };
203 assert(concsolver !=
NULL);
206 assert(data !=
NULL);
228 assert(scip !=
NULL);
229 assert(concsolver !=
NULL);
232 assert(data !=
NULL);
248 for( i = 0; i < data->nvars; i++ )
282 assert(concsolvertype !=
NULL);
283 assert(concsolver !=
NULL);
293 if( typedata->loademphasis )
307 for( i = 0; i < nparams; ++i )
313 if( strncmp(paramname,
"limits/", 7) == 0 ||
314 strncmp(paramname,
"numerics/", 9) == 0 ||
315 strncmp(paramname,
"memory/", 7) == 0 ||
316 strncmp(paramname,
"concurrent/sync/", 16) == 0 ||
317 strncmp(paramname,
"heuristics/sync/", 16) == 0 ||
318 strncmp(paramname,
"propagating/sync/", 17) == 0 )
320 fixedparams[nfixedparams++] = params[i];
327 for( i = 0; i < nfixedparams; ++i )
384 assert(concsolver !=
NULL);
387 assert(data !=
NULL);
388 assert(data->solverscip !=
NULL);
416 assert(concsolver !=
NULL);
419 assert(data !=
NULL);
446 assert(concsolver !=
NULL);
449 assert(data !=
NULL);
450 assert(data->solverscip !=
NULL);
459 assert(nvars == data->nvars);
465 for( i = 0; i < nsols; ++i )
500 assert(concsolver !=
NULL);
503 assert(data !=
NULL);
529 assert(concsolver !=
NULL);
532 assert(data !=
NULL);
553 assert(data !=
NULL);
573 nsols =
MIN(nsols, maxcandsols);
576 for( i = 0; i < nsols; ++i )
591 if( solvals ==
NULL )
598 if( *nsolsshared == maxsharedsols )
605 if( boundstore !=
NULL )
627 assert(data !=
NULL);
635 for( i = 0; i < nsols; ++i )
640 if( concsolverids[i] == concsolverid )
658 *ntighterintbnds = 0;
662 for( i = 0; i < nbndchgs; ++i )
691 ++(*ntighterintbnds);
706 assert(scip !=
NULL);
713 data->loademphasis =
FALSE;
715 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
716 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
719 data->loademphasis =
TRUE;
722 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
723 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
726 data->loademphasis =
TRUE;
729 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
730 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
733 data->loademphasis =
TRUE;
736 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
737 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
740 data->loademphasis =
TRUE;
743 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
744 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
747 data->loademphasis =
TRUE;
750 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
751 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
754 data->loademphasis =
TRUE;
757 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
758 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
761 data->loademphasis =
TRUE;
764 concsolverScipExec, concsolverGetSolvingData, concsolverScipStop, concsolverScipSyncWrite,
765 concsolverScipSyncRead, concsolverTypeScipFreeData, data) );
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
enum SCIP_BoundType SCIP_BOUNDTYPE
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
struct SCIP_ConcSolverTypeData SCIP_CONCSOLVERTYPEDATA
#define SCIPallocBlockMemoryArray(scip, ptr, num)
static SCIP_DECL_CONCSOLVEREXEC(concsolverScipExec)
static SCIP_RETCODE includeEventHdlrSync(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
static SCIP_DECL_EVENTEXIT(eventExitSync)
int SCIPboundstoreGetNChgs(SCIP_BOUNDSTORE *boundstore)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
static SCIP_DECL_CONCSOLVERTYPEFREEDATA(concsolverTypeScipFreeData)
SCIP_STATUS SCIPsyncdataGetStatus(SCIP_SYNCDATA *syncdata)
SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
static SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA(concsolverGetSolvingData)
void SCIPsyncdataSetUpperbound(SCIP_SYNCDATA *syncdata, SCIP_Real upperbound)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
SCIP_SOL ** SCIPgetSols(SCIP *scip)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
char * SCIPconcsolverGetName(SCIP_CONCSOLVER *concsolver)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPsyncdataSetLowerbound(SCIP_SYNCDATA *syncdata, SCIP_Real lowerbound)
enum SCIP_Retcode SCIP_RETCODE
const char * SCIPparamGetName(SCIP_PARAM *param)
datastructures for concurrent solvers
#define SCIPfreeBlockMemory(scip, ptr)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
#define SCIPfreeBufferArray(scip, ptr)
SCIP_RETCODE SCIPcreate(SCIP **scip)
#define BMSfreeMemory(ptr)
#define SCIPallocBlockMemory(scip, ptr)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
void SCIPconcsolverSetData(SCIP_CONCSOLVER *concsolver, SCIP_CONCSOLVERDATA *data)
static SCIP_DECL_CONCSOLVERSYNCWRITE(concsolverScipSyncWrite)
static SCIP_RETCODE initConcsolver(SCIP *scip, SCIP_CONCSOLVER *concsolver)
void SCIPeventhdlrSetData(SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_Bool SCIPfileExists(const char *filename)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
void SCIPsyncdataGetSolutionBuffer(SCIP_SYNCSTORE *syncstore, SCIP_SYNCDATA *syncdata, SCIP_Real solobj, int ownerid, SCIP_Real **buffer)
SCIP_RETCODE SCIPincludeConcsolverType(SCIP *scip, const char *name, SCIP_Real prefpriodefault, SCIP_DECL_CONCSOLVERCREATEINST((*concsolvercreateinst)), SCIP_DECL_CONCSOLVERDESTROYINST((*concsolverdestroyinst)), SCIP_DECL_CONCSOLVERINITSEEDS((*concsolverinitseeds)), SCIP_DECL_CONCSOLVEREXEC((*concsolverexec)), SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA((*concsolvercopysolvdata)), SCIP_DECL_CONCSOLVERSTOP((*concsolverstop)), SCIP_DECL_CONCSOLVERSYNCWRITE((*concsolversyncwrite)), SCIP_DECL_CONCSOLVERSYNCREAD((*concsolversyncread)), SCIP_DECL_CONCSOLVERTYPEFREEDATA((*concsolvertypefreedata)), SCIP_CONCSOLVERTYPEDATA *data)
int SCIPboundstoreGetChgVaridx(SCIP_BOUNDSTORE *boundstore, int i)
implementation of concurrent solver interface for SCIP
SCIP_RETCODE SCIPsolve(SCIP *scip)
const char * SCIPheurGetName(SCIP_HEUR *heur)
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
#define SCIPallocMemory(scip, ptr)
SCIP_RETCODE SCIPaddConcurrentBndchg(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)
SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real SCIPgetDualbound(SCIP *scip)
void SCIPsyncdataSetStatus(SCIP_SYNCDATA *syncdata, SCIP_STATUS status, int solverid)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
the interface of the boundstore structure
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPaddConcurrentSol(SCIP *scip, SCIP_SOL *sol)
static SCIP_DECL_CONCSOLVERSTOP(concsolverScipStop)
static SCIP_RETCODE disableConflictingDualReductions(SCIP *scip)
the function declarations for the synchronization store
#define SCIPallocBufferArray(scip, ptr, num)
static SCIP_DECL_EVENTFREE(eventFreeSync)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
void SCIPsyncdataAddMemTotal(SCIP_SYNCDATA *syncdata, SCIP_Longint memtotal)
static SCIP_DECL_EVENTEXEC(eventExecSync)
enum SCIP_Status SCIP_STATUS
static const char * paramname[]
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
static SCIP_DECL_CONCSOLVERSYNCREAD(concsolverScipSyncRead)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
int SCIPgetNSols(SCIP *scip)
SCIP_RETCODE SCIPcopyConcurrentSolvingStats(SCIP *source, SCIP *target)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
SCIP_CONCSOLVERDATA * SCIPconcsolverGetData(SCIP_CONCSOLVER *concsolver)
helper functions for concurrent scip solvers
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
int SCIPgetNVars(SCIP *scip)
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
static SCIP_DECL_CONCSOLVERCREATEINST(concsolverScipCreateInstance)
SCIP_RETCODE SCIPcopySolStats(SCIP_SOL *source, SCIP_SOL *target)
int SCIPconcsolverGetIdx(SCIP_CONCSOLVER *concsolver)
SCIP_RETCODE SCIPincludeConcurrentScipSolvers(SCIP *scip)
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
SCIP_Real SCIPboundstoreGetChgVal(SCIP_BOUNDSTORE *boundstore, int i)
SCIP_BOUNDSTORE * SCIPsyncdataGetBoundChgs(SCIP_SYNCDATA *syncdata)
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
static SCIP_DECL_CONCSOLVERDESTROYINST(concsolverScipDestroyInstance)
SCIP_RETCODE SCIPcopy(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
#define BMSallocMemory(ptr)
SCIP_Bool SCIPIsConcurrentSolNew(SCIP *scip, SCIP_SOL *sol)
int SCIPvarGetIndex(SCIP_VAR *var)
static SCIP_RETCODE setChildSelRule(SCIP_CONCSOLVER *concsolver)
SCIP_BOUNDSTORE * SCIPgetConcurrentGlobalBoundChanges(SCIP *scip)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
static SCIP_DECL_EVENTINIT(eventInitSync)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_CONCSOLVERTYPEDATA * SCIPconcsolverTypeGetData(SCIP_CONCSOLVERTYPE *concsolvertype)
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
SCIP_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)
#define SCIP_EVENTTYPE_SYNC
SCIP_BOUNDTYPE SCIPboundstoreGetChgType(SCIP_BOUNDSTORE *boundstore, int i)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
int SCIPgetNParams(SCIP *scip)
static SCIP_DECL_CONCSOLVERINITSEEDS(concsolverScipInitSeeds)
SCIP_RETCODE SCIPsyncdataAddBoundChanges(SCIP_SYNCSTORE *syncstore, SCIP_SYNCDATA *syncdata, SCIP_BOUNDSTORE *boundstore)
SCIP_RETCODE SCIPsynchronize(SCIP *scip)
void SCIPsyncdataGetSolutions(SCIP_SYNCDATA *syncdata, SCIP_Real ***solvalues, int **solowner, int *nsols)
struct SCIP_ConcSolverData SCIP_CONCSOLVERDATA
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPcreateConcurrent(SCIP *scip, SCIP_CONCSOLVER *concsolver, int *varperm)