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

    All Methods Instance Methods Concrete Methods
    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 node, WorkerSlot workerSlot)`
    `SchedulingResult` | `createSchedulingResult(boolean success, String schedulerClassSimpleName)`
    `ExecutorDetails` | `currentExec()` Get the current unassigned executor.
    `void` | `freeWorkerSlotWithBoundAckers(RasNode node, WorkerSlot workerSlot)` Free a given workerSlot and all the assigned bound ackers already there.
    `int` | `getAckersPerWorker()`
    `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()`
    `Map<WorkerSlot,List<ExecutorDetails>>` | `getWorkerSlotToBoundAckers()`
    `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()

    - #### getAckersPerWorker

          public int getAckersPerWorker()

    - #### getUnassignedAckers

          public LinkedList<ExecutorDetails> getUnassignedAckers()

    - #### peekUnassignedAckers

          public ExecutorDetails peekUnassignedAckers()

    - #### getBoundAckers

          public Set<ExecutorDetails> getBoundAckers()

    - #### getExecsWithBoundAckers

          public Set<ExecutorDetails> getExecsWithBoundAckers()

    - #### getWorkerSlotToBoundAckers

          public Map<WorkerSlot,List<ExecutorDetails>> getWorkerSlotToBoundAckers()

    - #### 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 node,
                                WorkerSlot workerSlot)

    - #### 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 a given workerSlot and all the assigned bound ackers already there.

      Parameters:
        `node` - RasNode which to be freed.
        `workerSlot` - WorkerSlot on which to schedule.

    - #### 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.

Copyright © 2021 The Apache Software Foundation. All rights reserved.