Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://scip.zib.de/doc/html/concurrent_8c_source.php below:

SCIP Doxygen Documentation: concurrent.c Source File

SCIP_ConcurrentData

assert(concsolver !=

);

assert(varperm !=

);

->concurrent->concsolver = concsolver;

->concurrent->solidx =

->stat->solindex;

->stat->subscipdepth = 0;

->concurrent->dettime = 0.0;

->concurrent->wallclock =

;

->concurrent->eventglobalbnd =

;

(

->set->concurrent_commvarbnds )

->set->nconcsolvers;

->set->concsolvers;

assert(

->concurrent->varperm !=

);

(

->concurrent->mainscip !=

)

->concurrent->mainscip->stat->detertimecnt +=

->stat->detertimecnt;

->stat->detertimecnt = 0;

(

->concurrent->wallclock !=

)

wallclock =

->concurrent->wallclock;

mainscip =

->concurrent->mainscip;

( wallclock ==

)

->concurrent->dettime += val;

(

->concurrent->dettime >= syncfreq )

->concurrent->dettime = 0.0;

( timesincelastsync >= syncfreq )

assert(

->concurrent !=

);

->concurrent->mainscip->concurrent->solidx =

->concurrent->mainscip->stat->solindex;

(

->concurrent->eventglobalbnd !=

)

assert(

->concurrent !=

);

(

->concurrent->eventglobalbnd !=

)

assert(

->concurrent !=

);

(

->concurrent->eventglobalbnd !=

)

(memtotal, concmemtotal);

assert(syncstore !=

);

assert(syncstore !=

);

assert(

->concurrent !=

);

assert(

->concurrent !=

);

assert(

->concurrent !=

);

assert(sol !=

);

assert(var !=

);

assert(

->concurrent !=

);

assert(

->concurrent->propsync !=

);

assert(source !=

);

assert(target !=

);

assert(

->concurrent !=

);

assert(

->concurrent->varperm !=

);

assert(var !=

);

assert(

->concurrent !=

);

assert(sol !=

);

assert(

->concurrent !=

);

(

->concurrent->eventglobalbnd !=

)

assert(args !=

);

= concurrentdata->scip;

solverindex = concurrentdata->solverindex;

concsolvers =

->set->concsolvers;

nconcsolvers =

->set->nconcsolvers;

( i = 0; i < nconcsolvers; ++i )

( i = 0; i < nconcsolvers; ++i )

concurrentdata[i]->scip =

;

concurrentdata[i]->solverindex = i;

assert(idx >= 0 && idx < nconcsolvers);

( idx < 0 || idx >= nconcsolvers )

( i = nconcsolvers - 1; i >= 0; i-- )

assert(source !=

);

assert(target !=

);

( i = 0; i < nheurs; ++i )

( i = 0; i < nprops; ++i )

( i = 0; i < npresols; ++i )

( presol !=

)

( i = 0; i < nsepas; ++i )

void SCIPconcsolverSetTimeSinceLastSync(SCIP_CONCSOLVER *concsolver, SCIP_Real time)

SCIP_RETCODE SCIPconcsolverExec(SCIP_CONCSOLVER *concsolver)

SCIP_Real SCIPconcsolverGetSyncFreq(SCIP_CONCSOLVER *concsolver)

SCIP_RETCODE SCIPconcsolverGetSolvingData(SCIP_CONCSOLVER *concsolver, SCIP *scip)

SCIP_RETCODE SCIPconcsolverSync(SCIP_CONCSOLVER *concsolver, SCIP_SET *set)

SCIP_Longint SCIPconcsolverGetMemTotal(SCIP_CONCSOLVER *concsolver)

datastructures for concurrent solvers

SCIP_Real SCIPgetConcurrentDualbound(SCIP *scip)

SCIP_RETCODE SCIPconcurrentSolve(SCIP *scip)

SCIP_Real SCIPgetConcurrentPrimalbound(SCIP *scip)

SCIP_RETCODE SCIPsynchronize(SCIP *scip)

SCIP_RETCODE SCIPincrementConcurrentTime(SCIP *scip, SCIP_Real val)

int SCIPgetConcurrentVaridx(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPfreeConcurrent(SCIP *scip)

SCIP_RETCODE SCIPaddConcurrentBndchg(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)

SCIP_RETCODE SCIPcopySolStats(SCIP_SOL *source, SCIP_SOL *target)

SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)

SCIP_RETCODE SCIPcreateConcurrent(SCIP *scip, SCIP_CONCSOLVER *concsolver, int *varperm)

SCIP_BOUNDSTORE * SCIPgetConcurrentGlobalBoundChanges(SCIP *scip)

SCIP_RETCODE SCIPaddConcurrentSolver(SCIP *scip, SCIP_CONCSOLVER *concsolver)

static SCIP_RETCODE execConcsolver(void *args)

SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)

SCIP_Bool SCIPIsConcurrentSolNew(SCIP *scip, SCIP_SOL *sol)

SCIP_Longint SCIPgetConcurrentNTightenedBnds(SCIP *scip)

void SCIPenableConcurrentBoundStorage(SCIP *scip)

int SCIPgetNConcurrentSolvers(SCIP *scip)

SCIP_RETCODE SCIPcopyConcurrentSolvingStats(SCIP *source, SCIP *target)

SCIP_RETCODE SCIPaddConcurrentSol(SCIP *scip, SCIP_SOL *sol)

SCIP_Real SCIPgetConcurrentGap(SCIP *scip)

struct SCIP_ConcurrentData SCIP_CONCURRENTDATA

void SCIPdisableConcurrentBoundStorage(SCIP *scip)

SCIP_Longint SCIPgetConcurrentNTightenedIntBnds(SCIP *scip)

helper functions for concurrent scip solvers

#define SCIP_CALL_ABORT(x)

wrappers for OpenMP defines

SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)

SCIP_RETCODE SCIPeventCreateSync(SCIP_EVENT **event, BMS_BLKMEM *blkmem)

internal methods for managing events

void SCIPeventGlobalbndClearBoundChanges(SCIP_EVENTHDLR *eventhdlr)

SCIP_RETCODE SCIPincludeEventHdlrGlobalbnd(SCIP *scip)

void SCIPeventGlobalbndEnableBoundStorage(SCIP_EVENTHDLR *eventhdlr)

SCIP_BOUNDSTORE * SCIPeventGlobalbndGetBoundChanges(SCIP_EVENTHDLR *eventhdlr)

void SCIPeventGlobalbndDisableBoundStorage(SCIP_EVENTHDLR *eventhdlr)

eventhdlr for storing all global bound changes

int SCIPgetNOrigVars(SCIP *scip)

SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)

SCIP_RETCODE SCIPheurSyncPassSol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)

SCIP_Longint SCIPpropSyncGetNTightenedBnds(SCIP_PROP *prop)

SCIP_RETCODE SCIPpropSyncAddBndchg(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE bndtype)

SCIP_Longint SCIPpropSyncGetNTightenedIntBnds(SCIP_PROP *prop)

SCIP_RETCODE SCIPincludeHeurSync(SCIP *scip)

SCIP_RETCODE SCIPincludePropSync(SCIP *scip)

SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)

SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)

int SCIPgetNHeurs(SCIP *scip)

SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)

const char * SCIPheurGetName(SCIP_HEUR *heur)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPfreeBlockMemory(scip, ptr)

SCIP_Longint SCIPgetMemTotal(SCIP *scip)

#define SCIPallocBlockMemory(scip, ptr)

#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)

SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)

SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)

SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)

int SCIPgetNPresols(SCIP *scip)

const char * SCIPpresolGetName(SCIP_PRESOL *presol)

SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)

int SCIPgetNProps(SCIP *scip)

const char * SCIPpropGetName(SCIP_PROP *prop)

SCIP_PROP ** SCIPgetProps(SCIP *scip)

int SCIPgetNSepas(SCIP *scip)

const char * SCIPsepaGetName(SCIP_SEPA *sepa)

SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)

SCIP_SEPA ** SCIPgetSepas(SCIP *scip)

int SCIPsolGetIndex(SCIP_SOL *sol)

SCIP_Real SCIPgetDualbound(SCIP *scip)

SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)

SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)

SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)

SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)

SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)

SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Real SCIPepsilon(SCIP *scip)

SCIP_NODE * SCIPgetRootNode(SCIP *scip)

int SCIPvarGetIndex(SCIP_VAR *var)

SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)

primal heuristic that adds given solutions

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

void SCIPprobSetDualbound(SCIP_PROB *prob, SCIP_Real dualbound)

internal methods for storing and manipulating the main problem

propagator for applying global bound changes that were communicated by other concurrent solvers

SCIP_RETCODE SCIPsetIncludeConcsolver(SCIP_SET *set, SCIP_CONCSOLVER *concsolver)

internal methods for global SCIP settings

internal methods for problem statistics

SCIP_Longint nbestsolsfound

SCIP_Longint nbestsolsfound

SCIP_Longint nlimsolsfound

SCIP_Longint ndomredsfound

SCIP_Longint nrespropcalls

SCIP_Longint ncutsaddedviapool

SCIP_Longint ndomredsfound

SCIP_Longint lastsepanode

SCIP_Longint ncutsappliedviapool

SCIP_Longint ncutsapplieddirect

SCIP_Longint ncutsaddeddirect

SCIP_Longint nlexdualresolvelpiterations

SCIP_Longint nearlybacktracks

SCIP_Longint ndualresolvelpiterations

SCIP_Longint nrootstrongbranchs

SCIP_Longint nprimalresolvelpiterations

SCIP_Real dualrefintegral

SCIP_CLOCK * strongpropclock

SCIP_Longint nsbdowndomchgs

SCIP_Longint nprimalzeroitlps

SCIP_Longint nsblpiterations

SCIP_CLOCK * strongbranchtime

SCIP_Real previousdualrefgap

SCIP_CLOCK * barrierlptime

SCIP_Longint ninfeasleaves

SCIP_Longint nrepropcutoffs

SCIP_Longint nduallpiterations

SCIP_Longint ncreatednodesrun

SCIP_Longint ndelayedcutoffs

SCIP_CLOCK * nodeactivationtime

SCIP_CLOCK * reoptupdatetime

SCIP_Longint ndualresolvelps

SCIP_Real rootlpbestestimate

SCIP_Longint nbarrierlpiterations

SCIP_Longint nconflictlps

SCIP_LPSOLSTAT lastsblpsolstats[2]

SCIP_CLOCK * divinglptime

SCIP_Longint nrootsblpiterations

SCIP_Longint ndivesetlpiterations

SCIP_Longint nprobholechgs

SCIP_CLOCK * presolvingtime

SCIP_Longint nrootfirstlpiterations

SCIP_Longint ninitconssadded

SCIP_Real previousprimalrefgap

SCIP_Longint nlpiterations

SCIP_Longint nprimalresolvelps

SCIP_Longint ndivinglpiterations

SCIP_Longint nsbsolsfound

SCIP_CLOCK * solvingtimeoverall

SCIP_Longint lastdivenode

SCIP_Longint nlexdualresolvelps

SCIP_Longint ndeactivatednodes

SCIP_Longint nrepropboundchgs

SCIP_Longint nnodesaboverefbound

SCIP_Real firstlpdualbound

SCIP_Longint nlexduallpiterations

SCIP_Longint nrootlpiterations

SCIP_Real firstprimaltime

SCIP_Longint ninternalnodes

SCIP_Longint lastdispnode

SCIP_Longint lastconflictnode

SCIP_Real primalrefintegral

SCIP_Longint ntotalinternalnodes

SCIP_HEUR * firstprimalheur

SCIP_BRANCHDIR lastbranchdir

SCIP_CLOCK * pseudosoltime

SCIP_CLOCK * presolvingtimeoverall

SCIP_Longint nnodesbeforefirst

SCIP_Longint nlpbestsolsfound

SCIP_Longint npsbestsolsfound

SCIP_Real barrierzeroittime

SCIP_Longint totaldivesetdepth

SCIP_Real previntegralevaltime

SCIP_Longint nexternalsolsfound

SCIP_Longint nisstoppedcalls

SCIP_Longint ndualzeroitlps

SCIP_Longint nsbdivinglps

SCIP_Longint nnodelpiterations

SCIP_Real lastprimalbound

SCIP_Longint nactivatednodes

SCIP_Longint nsbbestsolsfound

SCIP_Longint nsbtimesiterlimhit

SCIP_Real primalzeroittime

SCIP_CLOCK * primallptime

SCIP_Longint nconflictlpiterations

SCIP_Longint nstrongbranchs

SCIP_Longint npssolsfound

SCIP_Longint nbarrierzeroitlps

SCIP_Longint nprimallpiterations

SCIP_Real primaldualintegral

SCIP_Longint nlpsolsfound

SCIP_Longint nsbupdomchgs

SCIP_Real lastbranchvalue

SCIP_Longint ninitlpiterations

SCIP_Longint nprobboundchgs

SCIP_Longint ncreatednodes

SCIP_CLOCK * conflictlptime

SCIP_Longint nsbdivinglpiterations

SCIP_Real firstprimalbound

SCIP_CLOCK * lexduallptime

SCIP_EVENTFILTER * eventfilter

SCIP_EVENTQUEUE * eventqueue

datastructures for primal heuristics

datastructures for presolvers

datastructures for collecting primal CIP solutions and primal informations

datastructures for propagators

SCIP main data structure.

datastructures for separators

datastructures for global SCIP settings

datastructures for storing primal CIP solutions

data structures for branch and bound tree

SCIP_Real SCIPsyncstoreGetLastUpperbound(SCIP_SYNCSTORE *syncstore)

SCIP_Real SCIPsyncstoreGetLastLowerbound(SCIP_SYNCSTORE *syncstore)

int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)

void SCIPsyncstoreSetSolveIsStopped(SCIP_SYNCSTORE *syncstore, SCIP_Bool stopped)

SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)

int SCIPsyncstoreGetNSolvers(SCIP_SYNCSTORE *syncstore)

the function declarations for the synchronization store

the type definitions for the SCIP parallel interface

SCIP_RETCODE SCIPtpiCreateJob(SCIP_JOB **job, int jobid, SCIP_RETCODE(*jobfunc)(void *args), void *jobarg)

SCIP_RETCODE SCIPtpiSubmitJob(SCIP_JOB *job, SCIP_SUBMITSTATUS *status)

SCIP_RETCODE SCIPtpiCollectJobs(int jobid)

int SCIPtpiGetNewJobID(void)

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_Retcode SCIP_RETCODE

the type definitions for the synchronization store

@ SCIP_PARA_DETERMINISTIC

enum SCIP_Submitstatus SCIP_SUBMITSTATUS

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4