org.apache.storm.scheduler.resource.strategies.scheduling

Class SchedulingSearcherState

java.lang.Object

org.apache.storm.scheduler.resource.strategies.scheduling.SchedulingSearcherState

public class SchedulingSearcherState
extends Object

Constructor Summary

Constructors

Constructor and Description
SchedulingSearcherState(Map<WorkerSlot,Map<String,Integer>> workerCompAssignmentCnts, Map<RasNode,Map<String,Integer>> nodeCompAssignmentCnts, int maxStatesSearched, long maxTimeMs, List<ExecutorDetails> execs, LinkedList<ExecutorDetails> unassignedAckers, TopologyDetails td, Map<ExecutorDetails,String> execToComp)

Method Summary

Modifier and Type	Method and Description
boolean	areAllExecsScheduled()
boolean	areSearchLimitsExceeded()
void	assignCurrentExecutor(Map<ExecutorDetails,String> execToComp, RasNode node, WorkerSlot workerSlot) Attempt to assign current executor (execIndex points to) to worker and node.
void	assignSingleBoundAcker(RasNode node, WorkerSlot workerSlot) Remove the head of unassigned ackers and attempt to assign it to a workerSlot as a bound acker.
void	backtrack(Map<ExecutorDetails,String> execToComp, RasNode[] nodesForExec, WorkerSlot[] workerSlotForExec) Backtrack to prior executor that was directly assigned.
SchedulingResult	createSchedulingResult(boolean success, String schedulerClassSimpleName)
ExecutorDetails	currentExec() Get the current unassigned executor.
void	freeWorkerSlotWithBoundAckers(RasNode node, WorkerSlot workerSlot) Free the bound-ackers for the given node and workerSlot.
Set<ExecutorDetails>	getBoundAckers()
Map<String,Integer>	getCompAssignmentCntMapForWorker(WorkerSlot workerSlot) Get a map of component to count for the specified worker slot.
int	getComponentCntOnNode(RasNode rasNode, String comp)
int	getExecIndex()
int	getExecSize()
Set<ExecutorDetails>	getExecsWithBoundAckers()
int	getNumBacktrack()
int	getNumOfAckersToBind(ExecutorDetails exec, WorkerSlot workerSlot) Determine how many bound ackers to put in before assigning the executor to current workerSlot.
long	getStartTimeMillis()
int	getStatesSearched()
LinkedList<ExecutorDetails>	getUnassignedAckers()
void	incStatesSearched()
boolean	isExecCompDifferentFromPrior() Check if the current executor has a different component from the previous one.
void	logNodeCompAssignments() Use this method to log the current component assignments on the Node.
SchedulingSearcherState	nextExecutor()
ExecutorDetails	peekUnassignedAckers()
void	setSortedExecs(List<ExecutorDetails> sortedExecs) Reassign the list of executors as long as it contains the same executors as before.

Methods inherited from class java.lang.Object

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

Constructor Detail

SchedulingSearcherState

public SchedulingSearcherState(Map<WorkerSlot,Map<String,Integer>> workerCompAssignmentCnts,
                               Map<RasNode,Map<String,Integer>> nodeCompAssignmentCnts,
                               int maxStatesSearched,
                               long maxTimeMs,
                               List<ExecutorDetails> execs,
                               LinkedList<ExecutorDetails> unassignedAckers,
                               TopologyDetails td,
                               Map<ExecutorDetails,String> execToComp)

Method Detail

setSortedExecs

public void setSortedExecs(List<ExecutorDetails> sortedExecs)

Reassign the list of executors as long as it contains the same executors as before. Executors are normally assigned when this class is instantiated. However, this list may be resorted externally and then reassigned.

Parameters:

sortedExecs - new list to be assigned.

incStatesSearched

public void incStatesSearched()

getStartTimeMillis

public long getStartTimeMillis()

getStatesSearched

public int getStatesSearched()

getExecSize

public int getExecSize()

getNumBacktrack

public int getNumBacktrack()

getExecIndex

public int getExecIndex()

getUnassignedAckers

public LinkedList<ExecutorDetails> getUnassignedAckers()

peekUnassignedAckers

public ExecutorDetails peekUnassignedAckers()

getBoundAckers

public Set<ExecutorDetails> getBoundAckers()

getExecsWithBoundAckers

public Set<ExecutorDetails> getExecsWithBoundAckers()

areSearchLimitsExceeded

public boolean areSearchLimitsExceeded()

nextExecutor

public SchedulingSearcherState nextExecutor()

areAllExecsScheduled

public boolean areAllExecsScheduled()

currentExec

public ExecutorDetails currentExec()

Get the current unassigned executor.

Returns:

the first unassigned executor in execs list.

assignCurrentExecutor

public void assignCurrentExecutor(Map<ExecutorDetails,String> execToComp,
                                  RasNode node,
                                  WorkerSlot workerSlot)

Attempt to assign current executor (execIndex points to) to worker and node. Assignment validity check is done before calling this method.

Parameters:

execToComp - Mapping from executor to component name.

node - RasNode on which to schedule.

workerSlot - WorkerSlot on which to schedule.

getNumOfAckersToBind

public int getNumOfAckersToBind(ExecutorDetails exec,
                                WorkerSlot workerSlot)

Determine how many bound ackers to put in before assigning the executor to current workerSlot. Note that the worker slot must be a new worker to build on scheduling.

Return 0 if: 1. Either Config.TOPOLOGY_RAS_ONE_COMPONENT_PER_WORKER or Config.TOPOLOGY_RAS_ONE_EXECUTOR_PER_WORKER is enabled. 2. The exec to assign is an acker. 3. The workerSlot is not a new worker. 4. No more unassigned ackers to use.

A special scenario: If max heap limit is smaller than (this exec mem + Config.TOPOLOGY_RAS_ACKER_EXECUTORS_PER_WORKER ackers' mem), scheduler will bind fewer ackers based on max heap limit.

Parameters:

exec - the exec to assign into the workerSlot.

workerSlot - the new worker slot to build.

Returns:

the num of bound ackers to assign.

backtrack

public void backtrack(Map<ExecutorDetails,String> execToComp,
                      RasNode[] nodesForExec,
                      WorkerSlot[] workerSlotForExec)

Backtrack to prior executor that was directly assigned. This excludes bound-ackers.

Parameters:

execToComp - map from executor to component.

nodesForExec - array of nodes for all execIndex - has null values for bound-acker indices.

workerSlotForExec - array of workerSlots for all execIndex - has null values for bound-acker indices.

assignSingleBoundAcker

public void assignSingleBoundAcker(RasNode node,
                                   WorkerSlot workerSlot)

Remove the head of unassigned ackers and attempt to assign it to a workerSlot as a bound acker.

Parameters:

node - RasNode on which to schedule.

workerSlot - WorkerSlot on which to schedule.

freeWorkerSlotWithBoundAckers

public void freeWorkerSlotWithBoundAckers(RasNode node,
                                          WorkerSlot workerSlot)

Free the bound-ackers for the given node and workerSlot. All the bound-ackers for an executor (and only that executor) are on the same workerSlot.

Parameters:

node - RasNode to be freed.

workerSlot - WorkerSlot to be freed.

logNodeCompAssignments

public void logNodeCompAssignments()

Use this method to log the current component assignments on the Node. Useful for debugging and tests.

getCompAssignmentCntMapForWorker

public Map<String,Integer> getCompAssignmentCntMapForWorker(WorkerSlot workerSlot)

Get a map of component to count for the specified worker slot.

Parameters:

workerSlot - to check for.

Returns:

assignment map of count for components, may be a null.

getComponentCntOnNode

public int getComponentCntOnNode(RasNode rasNode,
                                 String comp)

createSchedulingResult

public SchedulingResult createSchedulingResult(boolean success,
                                               String schedulerClassSimpleName)

isExecCompDifferentFromPrior

public boolean isExecCompDifferentFromPrior()

Check if the current executor has a different component from the previous one. This flag can be used as a quick way to check if the nodes should be sorted.

Returns:

true if first executor or if the component is same as previous executor. False other wise.