Examples with Cluster org.apache.storm.scheduler.Cluster used on opensource projects

Example 56 with Cluster

use of org.apache.storm.scheduler.Cluster in project storm by apache.

the class TestResourceAwareScheduler method TestSubmitUsersWithNoGuarantees.

@Test
public void TestSubmitUsersWithNoGuarantees() {
    INimbus iNimbus = new TestUtilsForResourceAwareScheduler.INimbusTest();
    Map<String, Number> resourceMap = new HashMap<String, Number>();
    resourceMap.put(Config.SUPERVISOR_CPU_CAPACITY, 100.0);
    resourceMap.put(Config.SUPERVISOR_MEMORY_CAPACITY_MB, 1000.0);
    Map<String, SupervisorDetails> supMap = TestUtilsForResourceAwareScheduler.genSupervisors(4, 4, resourceMap);
    Config config = new Config();
    config.putAll(Utils.readDefaultConfig());
    config.put(Config.RESOURCE_AWARE_SCHEDULER_EVICTION_STRATEGY, org.apache.storm.scheduler.resource.strategies.eviction.DefaultEvictionStrategy.class.getName());
    config.put(Config.RESOURCE_AWARE_SCHEDULER_PRIORITY_STRATEGY, org.apache.storm.scheduler.resource.strategies.priority.DefaultSchedulingPriorityStrategy.class.getName());
    config.put(Config.TOPOLOGY_SCHEDULER_STRATEGY, org.apache.storm.scheduler.resource.strategies.scheduling.DefaultResourceAwareStrategy.class.getName());
    config.put(Config.TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT, 100.0);
    config.put(Config.TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB, 500);
    config.put(Config.TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB, 500);
    Map<String, Map<String, Number>> resourceUserPool = new HashMap<String, Map<String, Number>>();
    resourceUserPool.put("jerry", new HashMap<String, Number>());
    resourceUserPool.get("jerry").put("cpu", 200.0);
    resourceUserPool.get("jerry").put("memory", 2000.0);
    config.put(Config.RESOURCE_AWARE_SCHEDULER_USER_POOLS, resourceUserPool);
    Cluster cluster = new Cluster(iNimbus, supMap, new HashMap<String, SchedulerAssignmentImpl>(), config);
    config.put(Config.TOPOLOGY_SUBMITTER_USER, "jerry");
    TopologyDetails topo1 = TestUtilsForResourceAwareScheduler.getTopology("topo-1", config, 1, 0, 1, 0, currentTime - 2, 10);
    TopologyDetails topo2 = TestUtilsForResourceAwareScheduler.getTopology("topo-2", config, 1, 0, 1, 0, currentTime - 2, 20);
    TopologyDetails topo3 = TestUtilsForResourceAwareScheduler.getTopology("topo-3", config, 1, 0, 1, 0, currentTime - 2, 20);
    config.put(Config.TOPOLOGY_SUBMITTER_USER, "bobby");
    TopologyDetails topo4 = TestUtilsForResourceAwareScheduler.getTopology("topo-4", config, 1, 0, 1, 0, currentTime - 2, 10);
    TopologyDetails topo5 = TestUtilsForResourceAwareScheduler.getTopology("topo-5", config, 1, 0, 1, 0, currentTime - 2, 20);
    Map<String, TopologyDetails> topoMap = new HashMap<String, TopologyDetails>();
    topoMap.put(topo1.getId(), topo1);
    topoMap.put(topo2.getId(), topo2);
    topoMap.put(topo3.getId(), topo3);
    topoMap.put(topo4.getId(), topo4);
    topoMap.put(topo5.getId(), topo5);
    Topologies topologies = new Topologies(topoMap);
    ResourceAwareScheduler rs = new ResourceAwareScheduler();
    rs.prepare(config);
    rs.schedule(topologies, cluster);
    for (TopologyDetails topo : rs.getUser("jerry").getTopologiesRunning()) {
        Assert.assertTrue("assert topology success", TestUtilsForResourceAwareScheduler.assertStatusSuccess(cluster.getStatusMap().get(topo.getId())));
    }
    Assert.assertEquals("# of running topologies", 3, rs.getUser("jerry").getTopologiesRunning().size());
    Assert.assertEquals("# of pending topologies", 0, rs.getUser("jerry").getTopologiesPending().size());
    Assert.assertEquals("# of attempted topologies", 0, rs.getUser("jerry").getTopologiesAttempted().size());
    Assert.assertEquals("# of invalid topologies", 0, rs.getUser("jerry").getTopologiesInvalid().size());
    for (TopologyDetails topo : rs.getUser("bobby").getTopologiesRunning()) {
        Assert.assertTrue("assert topology success", TestUtilsForResourceAwareScheduler.assertStatusSuccess(cluster.getStatusMap().get(topo.getId())));
    }
    Assert.assertEquals("# of running topologies", 1, rs.getUser("bobby").getTopologiesRunning().size());
    Assert.assertEquals("# of pending topologies", 0, rs.getUser("bobby").getTopologiesPending().size());
    Assert.assertEquals("# of attempted topologies", 1, rs.getUser("bobby").getTopologiesAttempted().size());
    Assert.assertEquals("# of invalid topologies", 0, rs.getUser("bobby").getTopologiesInvalid().size());
}

Example 57 with Cluster

use of org.apache.storm.scheduler.Cluster in project storm by apache.

the class NodeSorterHostProximity method sortObjectResourcesGeneric.

/**
 * Sort objects by the following two criteria.
 *
 * <li>the number executors of the topology that needs to be scheduled is already on the
 * object (node or rack) in descending order. The reasoning to sort based on criterion 1 is so we schedule the rest
 * of a topology on the same object (node or rack) as the existing executors of the topology.</li>
 *
 * <li>the subordinate/subservient resource availability percentage of a rack in descending order We calculate the
 * resource availability percentage by dividing the resource availability of the object (node or rack) by the
 * resource availability of the entire rack or cluster depending on if object references a node or a rack.
 * How this differs from the DefaultResourceAwareStrategy is that the percentage boosts the node or rack if it is
 * requested by the executor that the sorting is being done for and pulls it down if it is not.
 * By doing this calculation, objects (node or rack) that have exhausted or little of one of the resources mentioned
 * above will be ranked after racks that have more balanced resource availability and nodes or racks that have
 * resources that are not requested will be ranked below . So we will be less likely to pick a rack that
 * have a lot of one resource but a low amount of another and have a lot of resources that are not requested by the executor.</li>
 *
 * @param allResources         contains all individual ObjectResources as well as cumulative stats
 * @param exec                 executor for which the sorting is done
 * @param existingScheduleFunc a function to get existing executors already scheduled on this object
 * @return an {@link Iterable} of sorted {@link ObjectResourcesItem}
 */
@Deprecated
private Iterable<ObjectResourcesItem> sortObjectResourcesGeneric(final ObjectResourcesSummary allResources, ExecutorDetails exec, final ExistingScheduleFunc existingScheduleFunc) {
    ObjectResourcesSummary affinityBasedAllResources = new ObjectResourcesSummary(allResources);
    final NormalizedResourceOffer availableResourcesOverall = allResources.getAvailableResourcesOverall();
    final NormalizedResourceRequest requestedResources = (exec != null) ? topologyDetails.getTotalResources(exec) : null;
    affinityBasedAllResources.getObjectResources().forEach(x -> {
        if (requestedResources != null) {
            // negate unrequested resources
            x.availableResources.updateForRareResourceAffinity(requestedResources);
        }
        x.minResourcePercent = availableResourcesOverall.calculateMinPercentageUsedBy(x.availableResources);
        x.avgResourcePercent = availableResourcesOverall.calculateAveragePercentageUsedBy(x.availableResources);
        LOG.trace("for {}: minResourcePercent={}, avgResourcePercent={}, numExistingSchedule={}", x.id, x.minResourcePercent, x.avgResourcePercent, existingScheduleFunc.getNumExistingSchedule(x.id));
    });
    Comparator<ObjectResourcesItem> comparator = (o1, o2) -> {
        int execsScheduled1 = existingScheduleFunc.getNumExistingSchedule(o1.id);
        int execsScheduled2 = existingScheduleFunc.getNumExistingSchedule(o2.id);
        if (execsScheduled1 > execsScheduled2) {
            return -1;
        } else if (execsScheduled1 < execsScheduled2) {
            return 1;
        }
        double o1Avg = o1.avgResourcePercent;
        double o2Avg = o2.avgResourcePercent;
        if (o1Avg > o2Avg) {
            return -1;
        } else if (o1Avg < o2Avg) {
            return 1;
        }
        return o1.id.compareTo(o2.id);
    };
    TreeSet<ObjectResourcesItem> sortedObjectResources = new TreeSet<>(comparator);
    sortedObjectResources.addAll(affinityBasedAllResources.getObjectResources());
    LOG.debug("Sorted Object Resources: {}", sortedObjectResources);
    return sortedObjectResources;
}

Example 58 with Cluster

use of org.apache.storm.scheduler.Cluster in project storm by apache.

the class NodeSorterHostProximity method sortObjectResourcesDefault.

/**
 * Sort objects by the following two criteria.
 *
 * <li>the number executors of the topology that needs to be scheduled is already on the
 * object (node or rack) in descending order. The reasoning to sort based on criterion 1 is so we schedule the rest
 * of a topology on the same object (node or rack) as the existing executors of the topology.</li>
 *
 * <li>the subordinate/subservient resource availability percentage of a rack in descending order We calculate the
 * resource availability percentage by dividing the resource availability of the object (node or rack) by the
 * resource availability of the entire rack or cluster depending on if object references a node or a rack.
 * By doing this calculation, objects (node or rack) that have exhausted or little of one of the resources mentioned
 * above will be ranked after racks that have more balanced resource availability. So we will be less likely to pick
 * a rack that have a lot of one resource but a low amount of another.</li>
 *
 * @param allResources         contains all individual ObjectResources as well as cumulative stats
 * @param existingScheduleFunc a function to get existing executors already scheduled on this object
 * @return an {@link Iterable} of sorted {@link ObjectResourcesItem}
 */
@Deprecated
private Iterable<ObjectResourcesItem> sortObjectResourcesDefault(final ObjectResourcesSummary allResources, final ExistingScheduleFunc existingScheduleFunc) {
    final NormalizedResourceOffer availableResourcesOverall = allResources.getAvailableResourcesOverall();
    for (ObjectResourcesItem objectResources : allResources.getObjectResources()) {
        objectResources.minResourcePercent = availableResourcesOverall.calculateMinPercentageUsedBy(objectResources.availableResources);
        objectResources.avgResourcePercent = availableResourcesOverall.calculateAveragePercentageUsedBy(objectResources.availableResources);
        LOG.trace("for {}: minResourcePercent={}, avgResourcePercent={}, numExistingSchedule={}", objectResources.id, objectResources.minResourcePercent, objectResources.avgResourcePercent, existingScheduleFunc.getNumExistingSchedule(objectResources.id));
    }
    Comparator<ObjectResourcesItem> comparator = (o1, o2) -> {
        int execsScheduled1 = existingScheduleFunc.getNumExistingSchedule(o1.id);
        int execsScheduled2 = existingScheduleFunc.getNumExistingSchedule(o2.id);
        if (execsScheduled1 > execsScheduled2) {
            return -1;
        } else if (execsScheduled1 < execsScheduled2) {
            return 1;
        }
        if (o1.minResourcePercent > o2.minResourcePercent) {
            return -1;
        } else if (o1.minResourcePercent < o2.minResourcePercent) {
            return 1;
        }
        double diff = o1.avgResourcePercent - o2.avgResourcePercent;
        if (diff > 0.0) {
            return -1;
        } else if (diff < 0.0) {
            return 1;
        }
        return o1.id.compareTo(o2.id);
    };
    TreeSet<ObjectResourcesItem> sortedObjectResources = new TreeSet<>(comparator);
    sortedObjectResources.addAll(allResources.getObjectResources());
    LOG.debug("Sorted Object Resources: {}", sortedObjectResources);
    return sortedObjectResources;
}

Example 59 with Cluster

use of org.apache.storm.scheduler.Cluster in project storm by apache.

the class NodeSorter method sortObjectResourcesGeneric.

/**
 * Sort objects by the following two criteria.
 *
 * <li>the number executors of the topology that needs to be scheduled is already on the
 * object (node or rack) in descending order. The reasoning to sort based on criterion 1 is so we schedule the rest
 * of a topology on the same object (node or rack) as the existing executors of the topology.</li>
 *
 * <li>the subordinate/subservient resource availability percentage of a rack in descending order We calculate the
 * resource availability percentage by dividing the resource availability of the object (node or rack) by the
 * resource availability of the entire rack or cluster depending on if object references a node or a rack.
 * How this differs from the DefaultResourceAwareStrategy is that the percentage boosts the node or rack if it is
 * requested by the executor that the sorting is being done for and pulls it down if it is not.
 * By doing this calculation, objects (node or rack) that have exhausted or little of one of the resources mentioned
 * above will be ranked after racks that have more balanced resource availability and nodes or racks that have
 * resources that are not requested will be ranked below . So we will be less likely to pick a rack that
 * have a lot of one resource but a low amount of another and have a lot of resources that are not requested by the executor.</li>
 *
 * @param allResources         contains all individual ObjectResources as well as cumulative stats
 * @param exec                 executor for which the sorting is done
 * @param existingScheduleFunc a function to get existing executors already scheduled on this object
 * @return a sorted list of ObjectResources
 */
@Deprecated
private List<ObjectResourcesItem> sortObjectResourcesGeneric(final ObjectResourcesSummary allResources, ExecutorDetails exec, final ExistingScheduleFunc existingScheduleFunc) {
    ObjectResourcesSummary affinityBasedAllResources = new ObjectResourcesSummary(allResources);
    NormalizedResourceRequest requestedResources = topologyDetails.getTotalResources(exec);
    affinityBasedAllResources.getObjectResources().forEach(x -> x.availableResources.updateForRareResourceAffinity(requestedResources));
    final NormalizedResourceOffer availableResourcesOverall = allResources.getAvailableResourcesOverall();
    List<ObjectResourcesItem> sortedObjectResources = new ArrayList<>();
    Comparator<ObjectResourcesItem> comparator = (o1, o2) -> {
        int execsScheduled1 = existingScheduleFunc.getNumExistingSchedule(o1.id);
        int execsScheduled2 = existingScheduleFunc.getNumExistingSchedule(o2.id);
        if (execsScheduled1 > execsScheduled2) {
            return -1;
        } else if (execsScheduled1 < execsScheduled2) {
            return 1;
        }
        double o1Avg = availableResourcesOverall.calculateAveragePercentageUsedBy(o1.availableResources);
        double o2Avg = availableResourcesOverall.calculateAveragePercentageUsedBy(o2.availableResources);
        if (o1Avg > o2Avg) {
            return -1;
        } else if (o1Avg < o2Avg) {
            return 1;
        }
        return o1.id.compareTo(o2.id);
    };
    sortedObjectResources.addAll(affinityBasedAllResources.getObjectResources());
    sortedObjectResources.sort(comparator);
    LOG.debug("Sorted Object Resources: {}", sortedObjectResources);
    return sortedObjectResources;
}

Example 60 with Cluster

use of org.apache.storm.scheduler.Cluster in project storm by apache.

the class NodeSorter method sortObjectResourcesDefault.

/**
 * Sort objects by the following two criteria.
 *
 * <li>the number executors of the topology that needs to be scheduled is already on the
 * object (node or rack) in descending order. The reasoning to sort based on criterion 1 is so we schedule the rest
 * of a topology on the same object (node or rack) as the existing executors of the topology.</li>
 *
 * <li>the subordinate/subservient resource availability percentage of a rack in descending order We calculate the
 * resource availability percentage by dividing the resource availability of the object (node or rack) by the
 * resource availability of the entire rack or cluster depending on if object references a node or a rack.
 * By doing this calculation, objects (node or rack) that have exhausted or little of one of the resources mentioned
 * above will be ranked after racks that have more balanced resource availability. So we will be less likely to pick
 * a rack that have a lot of one resource but a low amount of another.</li>
 *
 * @param allResources         contains all individual ObjectResources as well as cumulative stats
 * @param existingScheduleFunc a function to get existing executors already scheduled on this object
 * @return a sorted list of ObjectResources
 */
@Deprecated
private List<ObjectResourcesItem> sortObjectResourcesDefault(final ObjectResourcesSummary allResources, final ExistingScheduleFunc existingScheduleFunc) {
    final NormalizedResourceOffer availableResourcesOverall = allResources.getAvailableResourcesOverall();
    for (ObjectResourcesItem objectResources : allResources.getObjectResources()) {
        objectResources.minResourcePercent = availableResourcesOverall.calculateMinPercentageUsedBy(objectResources.availableResources);
        objectResources.avgResourcePercent = availableResourcesOverall.calculateAveragePercentageUsedBy(objectResources.availableResources);
        LOG.trace("for {}: minResourcePercent={}, avgResourcePercent={}, numExistingSchedule={}", objectResources.id, objectResources.minResourcePercent, objectResources.avgResourcePercent, existingScheduleFunc.getNumExistingSchedule(objectResources.id));
    }
    List<ObjectResourcesItem> sortedObjectResources = new ArrayList<>();
    Comparator<ObjectResourcesItem> comparator = (o1, o2) -> {
        int execsScheduled1 = existingScheduleFunc.getNumExistingSchedule(o1.id);
        int execsScheduled2 = existingScheduleFunc.getNumExistingSchedule(o2.id);
        if (execsScheduled1 > execsScheduled2) {
            return -1;
        } else if (execsScheduled1 < execsScheduled2) {
            return 1;
        }
        if (o1.minResourcePercent > o2.minResourcePercent) {
            return -1;
        } else if (o1.minResourcePercent < o2.minResourcePercent) {
            return 1;
        }
        double diff = o1.avgResourcePercent - o2.avgResourcePercent;
        if (diff > 0.0) {
            return -1;
        } else if (diff < 0.0) {
            return 1;
        }
        return o1.id.compareTo(o2.id);
    };
    sortedObjectResources.addAll(allResources.getObjectResources());
    sortedObjectResources.sort(comparator);
    LOG.debug("Sorted Object Resources: {}", sortedObjectResources);
    return sortedObjectResources;
}