Beispiel #1
0
  /**
   * print scheduling for debug purposes
   *
   * @param cluster
   * @param topologies
   */
  public static String printScheduling(Cluster cluster, Topologies topologies) {
    StringBuilder str = new StringBuilder();
    Map<String, Map<String, Map<WorkerSlot, Collection<ExecutorDetails>>>> schedulingMap =
        new HashMap<String, Map<String, Map<WorkerSlot, Collection<ExecutorDetails>>>>();
    for (TopologyDetails topo : topologies.getTopologies()) {
      if (cluster.getAssignmentById(topo.getId()) != null) {
        for (Map.Entry<ExecutorDetails, WorkerSlot> entry :
            cluster.getAssignmentById(topo.getId()).getExecutorToSlot().entrySet()) {
          WorkerSlot slot = entry.getValue();
          String nodeId = slot.getNodeId();
          ExecutorDetails exec = entry.getKey();
          if (!schedulingMap.containsKey(nodeId)) {
            schedulingMap.put(
                nodeId, new HashMap<String, Map<WorkerSlot, Collection<ExecutorDetails>>>());
          }
          if (schedulingMap.get(nodeId).containsKey(topo.getId()) == false) {
            schedulingMap
                .get(nodeId)
                .put(topo.getId(), new HashMap<WorkerSlot, Collection<ExecutorDetails>>());
          }
          if (schedulingMap.get(nodeId).get(topo.getId()).containsKey(slot) == false) {
            schedulingMap
                .get(nodeId)
                .get(topo.getId())
                .put(slot, new LinkedList<ExecutorDetails>());
          }
          schedulingMap.get(nodeId).get(topo.getId()).get(slot).add(exec);
        }
      }
    }

    for (Map.Entry<String, Map<String, Map<WorkerSlot, Collection<ExecutorDetails>>>> entry :
        schedulingMap.entrySet()) {
      if (cluster.getSupervisorById(entry.getKey()) != null) {
        str.append(
            "/** Node: "
                + cluster.getSupervisorById(entry.getKey()).getHost()
                + "-"
                + entry.getKey()
                + " **/\n");
      } else {
        str.append("/** Node: Unknown may be dead -" + entry.getKey() + " **/\n");
      }
      for (Map.Entry<String, Map<WorkerSlot, Collection<ExecutorDetails>>> topo_sched :
          schedulingMap.get(entry.getKey()).entrySet()) {
        str.append("\t-->Topology: " + topo_sched.getKey() + "\n");
        for (Map.Entry<WorkerSlot, Collection<ExecutorDetails>> ws :
            topo_sched.getValue().entrySet()) {
          str.append("\t\t->Slot [" + ws.getKey().getPort() + "] -> " + ws.getValue() + "\n");
        }
      }
    }
    return str.toString();
  }
  public void linkBasedScheduling(
      Topologies topos, Cluster cluster, GlobalState globalState, GlobalResources globalResources) {
    for (TopologyDetails td : topos.getTopologies()) {
      String topId = td.getId();
      Map<Node, Collection<ExecutorDetails>> taskToNodesMap;
      if (cluster.needsScheduling(td) && cluster.getUnassignedExecutors(td).size() > 0) {
        LOG.info("/********Scheduling topology {} ************/", topId);
        int totalTasks = td.getExecutors().size();
        int executorsNotRunning = cluster.getUnassignedExecutors(td).size();
        LOG.info(
            "Total number of executors: {} " + "Total number of Unassigned Executors: {}",
            totalTasks,
            executorsNotRunning);
        LOG.info("executors that need scheduling: {}", cluster.getUnassignedExecutors(td));

        LinkBasedStrategy rs =
            new LinkBasedStrategy(globalState, globalResources, null, td, cluster, topos);
        taskToNodesMap = rs.schedule(td, cluster.getUnassignedExecutors(td));

        if (taskToNodesMap != null) {
          try {
            for (Map.Entry<Node, Collection<ExecutorDetails>> entry : taskToNodesMap.entrySet()) {
              entry.getKey().assign(td.getId(), entry.getValue(), cluster);
              LOG.info(
                  "ASSIGNMENT    TOPOLOGY: {}  TASKS: {} To Node: "
                      + entry.getKey().getId()
                      + " Slots left: "
                      + entry.getKey().totalSlotsFree(),
                  td.getId(),
                  entry.getValue());
            }
            LOG.info(
                "Toplogy: {} assigned to {} nodes", td.getId(), taskToNodesMap.keySet().size());

            HelperFuncs.setTopoStatus(td.getId(), "Fully Scheduled");
          } catch (IllegalStateException ex) {
            LOG.error(ex.toString());
            LOG.error("Unsuccessfull in scheduling topology {}", td.getId());
            HelperFuncs.setTopoStatus(td.getId(), "Unsuccessfull in scheduling topology");
          }
        } else {
          LOG.error("Unsuccessfull in scheduling topology {}", td.getId());
          HelperFuncs.setTopoStatus(td.getId(), "Unsuccessfull in scheduling topology");
        }
      } else {
        HelperFuncs.setTopoStatus(td.getId(), "Fully Scheduled");
      }
    }
  }
 public ResourceAwareStrategy(Cluster cluster, Topologies topologies) {
   _topologies = topologies;
   _cluster = cluster;
   _nodes = RAS_Node.getAllNodesFrom(cluster, _topologies);
   _availNodes = this.getAvailNodes();
   this.LOG = LoggerFactory.getLogger(this.getClass());
   _clusterInfo = cluster.getNetworkTopography();
   LOG.debug(this.getClusterInfo());
 }
  public Map<WorkerSlot, Collection<ExecutorDetails>> schedule(TopologyDetails td) {
    if (_availNodes.size() <= 0) {
      LOG.warn("No available nodes to schedule tasks on!");
      return null;
    }
    Collection<ExecutorDetails> unassignedExecutors = _cluster.getUnassignedExecutors(td);
    Map<WorkerSlot, Collection<ExecutorDetails>> schedulerAssignmentMap =
        new HashMap<WorkerSlot, Collection<ExecutorDetails>>();
    LOG.debug("ExecutorsNeedScheduling: {}", unassignedExecutors);
    Collection<ExecutorDetails> scheduledTasks = new ArrayList<ExecutorDetails>();
    List<Component> spouts = this.getSpouts(_topologies, td);

    if (spouts.size() == 0) {
      LOG.error("Cannot find a Spout!");
      return null;
    }

    Queue<Component> ordered__Component_list = bfs(_topologies, td, spouts);

    Map<Integer, List<ExecutorDetails>> priorityToExecutorMap =
        getPriorityToExecutorDetailsListMap(ordered__Component_list, unassignedExecutors);
    Collection<ExecutorDetails> executorsNotScheduled =
        new HashSet<ExecutorDetails>(unassignedExecutors);
    Integer longestPriorityListSize = this.getLongestPriorityListSize(priorityToExecutorMap);
    // Pick the first executor with priority one, then the 1st exec with priority 2, so on an so
    // forth.
    // Once we reach the last priority, we go back to priority 1 and schedule the second task with
    // priority 1.
    for (int i = 0; i < longestPriorityListSize; i++) {
      for (Entry<Integer, List<ExecutorDetails>> entry : priorityToExecutorMap.entrySet()) {
        Iterator<ExecutorDetails> it = entry.getValue().iterator();
        if (it.hasNext()) {
          ExecutorDetails exec = it.next();
          LOG.debug(
              "\n\nAttempting to schedule: {} of component {}[avail {}] with rank {}",
              new Object[] {
                exec,
                td.getExecutorToComponent().get(exec),
                td.getTaskResourceReqList(exec),
                entry.getKey()
              });
          WorkerSlot targetSlot = this.findWorkerForExec(exec, td, schedulerAssignmentMap);
          if (targetSlot != null) {
            RAS_Node targetNode = this.idToNode(targetSlot.getNodeId());
            if (!schedulerAssignmentMap.containsKey(targetSlot)) {
              schedulerAssignmentMap.put(targetSlot, new LinkedList<ExecutorDetails>());
            }

            schedulerAssignmentMap.get(targetSlot).add(exec);
            targetNode.consumeResourcesforTask(exec, td);
            scheduledTasks.add(exec);
            LOG.debug(
                "TASK {} assigned to Node: {} avail [mem: {} cpu: {}] total [mem: {} cpu: {}] on slot: {}",
                exec,
                targetNode,
                targetNode.getAvailableMemoryResources(),
                targetNode.getAvailableCpuResources(),
                targetNode.getTotalMemoryResources(),
                targetNode.getTotalCpuResources(),
                targetSlot);
          } else {
            LOG.error("Not Enough Resources to schedule Task {}", exec);
          }
          it.remove();
        }
      }
    }

    executorsNotScheduled.removeAll(scheduledTasks);
    LOG.debug("/* Scheduling left over task (most likely sys tasks) */");
    // schedule left over system tasks
    for (ExecutorDetails exec : executorsNotScheduled) {
      WorkerSlot targetSlot = this.findWorkerForExec(exec, td, schedulerAssignmentMap);
      if (targetSlot != null) {
        RAS_Node targetNode = this.idToNode(targetSlot.getNodeId());
        if (schedulerAssignmentMap.containsKey(targetSlot) == false) {
          schedulerAssignmentMap.put(targetSlot, new LinkedList<ExecutorDetails>());
        }

        schedulerAssignmentMap.get(targetSlot).add(exec);
        targetNode.consumeResourcesforTask(exec, td);
        scheduledTasks.add(exec);
        LOG.debug(
            "TASK {} assigned to Node: {} avail [mem: {} cpu: {}] total [mem: {} cpu: {}] on slot: {}",
            exec,
            targetNode,
            targetNode.getAvailableMemoryResources(),
            targetNode.getAvailableCpuResources(),
            targetNode.getTotalMemoryResources(),
            targetNode.getTotalCpuResources(),
            targetSlot);
      } else {
        LOG.error("Not Enough Resources to schedule Task {}", exec);
      }
    }
    executorsNotScheduled.removeAll(scheduledTasks);
    if (executorsNotScheduled.size() > 0) {
      LOG.error("Not all executors successfully scheduled: {}", executorsNotScheduled);
      schedulerAssignmentMap = null;
    } else {
      LOG.debug("All resources successfully scheduled!");
    }
    if (schedulerAssignmentMap == null) {
      LOG.error("Topology {} not successfully scheduled!", td.getId());
    }
    return schedulerAssignmentMap;
  }