org.optaplanner.core.impl.solver.scope

Class DefaultSolverScope<Solution_>

java.lang.Object

org.optaplanner.core.impl.solver.scope.DefaultSolverScope<Solution_>

Type Parameters:

Solution_ - the solution type, the class with the PlanningSolution annotation

public class DefaultSolverScope<Solution_>
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
protected Score	bestScore
protected Solution_	bestSolution
protected Long	bestSolutionTimeMillis
protected Long	endingSystemTimeMillis
protected org.slf4j.Logger	logger
protected Semaphore	runnableThreadSemaphore Used for capping CPU power usage in multi-threaded scenario's
protected InnerScoreDirector<Solution_>	scoreDirector
protected Score	startingInitializedScore
protected int	startingSolverCount
protected Long	startingSystemTimeMillis
protected Random	workingRandom

Constructor Summary

Constructors

Constructor and Description
DefaultSolverScope()

Method Summary

Modifier and Type	Method and Description
void	assertExpectedWorkingScore(Score expectedWorkingScore, Object completedAction)
void	assertScoreFromScratch(Solution_ solution)
void	assertShadowVariablesAreNotStale(Score workingScore, Object completedAction)
void	assertWorkingScoreFromScratch(Score workingScore, Object completedAction)
Score	calculateScore()
long	calculateTimeMillisSpentUpToNow()
void	checkYielding() Similar to Thread.yield(), but allows capping the number of active solver threads at less than the CPU processor count, so other threads (for example servlet threads that handle REST calls) and other processes (such as SSH) have access to uncontested CPU's and don't suffer any latency.
DefaultSolverScope<Solution_>	createChildThreadSolverScope(ChildThreadType childThreadType)
void	destroyYielding()
void	endingNow()
Score	getBestScore()
Solution_	getBestSolution()
Long	getBestSolutionTimeMillis()
Long	getBestSolutionTimeMillisSpent()
Long	getEndingSystemTimeMillis()
long	getScoreCalculationCount()
long	getScoreCalculationSpeed()
ScoreDefinition	getScoreDefinition()
InnerScoreDirector<Solution_>	getScoreDirector()
SolutionDescriptor<Solution_>	getSolutionDescriptor()
Score	getStartingInitializedScore()
int	getStartingSolverCount()
Long	getStartingSystemTimeMillis()
long	getTimeMillisSpent()
int	getWorkingEntityCount()
List<Object>	getWorkingEntityList()
Random	getWorkingRandom()
Solution_	getWorkingSolution()
int	getWorkingValueCount()
void	initializeYielding()
boolean	isBestSolutionInitialized()
void	setBestScore(Score bestScore)
void	setBestSolution(Solution_ bestSolution) The best solution must never be the same instance as the working solution, it should be a (un)changed clone.
void	setBestSolutionTimeMillis(Long bestSolutionTimeMillis)
void	setRunnableThreadSemaphore(Semaphore runnableThreadSemaphore)
void	setScoreDirector(InnerScoreDirector<Solution_> scoreDirector)
void	setStartingInitializedScore(Score startingInitializedScore)
void	setStartingSolverCount(int startingSolverCount)
void	setWorkingRandom(Random workingRandom)
void	setWorkingSolutionFromBestSolution()
void	startingNow()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

protected final transient org.slf4j.Logger logger

startingSolverCount

protected int startingSolverCount

workingRandom

protected Random workingRandom

scoreDirector

protected InnerScoreDirector<Solution_> scoreDirector

runnableThreadSemaphore

protected Semaphore runnableThreadSemaphore

Used for capping CPU power usage in multi-threaded scenario's

startingSystemTimeMillis

protected Long startingSystemTimeMillis

endingSystemTimeMillis

protected Long endingSystemTimeMillis

startingInitializedScore

protected Score startingInitializedScore

bestSolution

protected volatile Solution_ bestSolution

bestScore

protected volatile Score bestScore

bestSolutionTimeMillis

protected Long bestSolutionTimeMillis

Constructor Detail

DefaultSolverScope

public DefaultSolverScope()

Method Detail

getStartingSolverCount

public int getStartingSolverCount()

setStartingSolverCount

public void setStartingSolverCount(int startingSolverCount)

getWorkingRandom

public Random getWorkingRandom()

setWorkingRandom

public void setWorkingRandom(Random workingRandom)

getScoreDirector

public InnerScoreDirector<Solution_> getScoreDirector()

setScoreDirector

public void setScoreDirector(InnerScoreDirector<Solution_> scoreDirector)

setRunnableThreadSemaphore

public void setRunnableThreadSemaphore(Semaphore runnableThreadSemaphore)

getStartingSystemTimeMillis

public Long getStartingSystemTimeMillis()

getEndingSystemTimeMillis

public Long getEndingSystemTimeMillis()

getSolutionDescriptor

public SolutionDescriptor<Solution_> getSolutionDescriptor()

getScoreDefinition

public ScoreDefinition getScoreDefinition()

getWorkingSolution

public Solution_ getWorkingSolution()

getWorkingEntityCount

public int getWorkingEntityCount()

getWorkingEntityList

public List<Object> getWorkingEntityList()

getWorkingValueCount

public int getWorkingValueCount()

calculateScore

public Score calculateScore()

assertExpectedWorkingScore

public void assertExpectedWorkingScore(Score expectedWorkingScore,
                                       Object completedAction)

assertWorkingScoreFromScratch

public void assertWorkingScoreFromScratch(Score workingScore,
                                          Object completedAction)

assertScoreFromScratch

public void assertScoreFromScratch(Solution_ solution)

assertShadowVariablesAreNotStale

public void assertShadowVariablesAreNotStale(Score workingScore,
                                             Object completedAction)

getStartingInitializedScore

public Score getStartingInitializedScore()

setStartingInitializedScore

public void setStartingInitializedScore(Score startingInitializedScore)

getScoreCalculationCount

public long getScoreCalculationCount()

getBestSolution

public Solution_ getBestSolution()

setBestSolution

public void setBestSolution(Solution_ bestSolution)

The best solution must never be the same instance as the working solution, it should be a (un)changed clone.

Parameters:

bestSolution - never null

getBestScore

public Score getBestScore()

setBestScore

public void setBestScore(Score bestScore)

getBestSolutionTimeMillis

public Long getBestSolutionTimeMillis()

setBestSolutionTimeMillis

public void setBestSolutionTimeMillis(Long bestSolutionTimeMillis)

startingNow

public void startingNow()

getBestSolutionTimeMillisSpent

public Long getBestSolutionTimeMillisSpent()

endingNow

public void endingNow()

isBestSolutionInitialized

public boolean isBestSolutionInitialized()

calculateTimeMillisSpentUpToNow

public long calculateTimeMillisSpentUpToNow()

getTimeMillisSpent

public long getTimeMillisSpent()

getScoreCalculationSpeed

public long getScoreCalculationSpeed()

Returns:

at least 0, per second

setWorkingSolutionFromBestSolution

public void setWorkingSolutionFromBestSolution()

createChildThreadSolverScope

public DefaultSolverScope<Solution_> createChildThreadSolverScope(ChildThreadType childThreadType)

initializeYielding

public void initializeYielding()

checkYielding

public void checkYielding()

Similar to Thread.yield(), but allows capping the number of active solver threads at less than the CPU processor count, so other threads (for example servlet threads that handle REST calls) and other processes (such as SSH) have access to uncontested CPU's and don't suffer any latency.

Needs to be called before Termination.isPhaseTerminated(AbstractPhaseScope), so the decision to start a new iteration is after any yield waiting time has been consumed (so Solver.terminateEarly() reacts immediately). Furthermore, this method will

destroyYielding

public void destroyYielding()