/** * Log a bunch of stuff for debugging. */ private void logClusterInfo() { if (LOG.isDebugEnabled()) { LOG.debug("Cluster:"); for (Map.Entry<String, List<String>> clusterEntry : networkTopography.entrySet()) { String rackId = clusterEntry.getKey(); LOG.debug("Rack: {}", rackId); for (String nodeHostname : clusterEntry.getValue()) { for (RAS_Node node : hostnameToNodes(nodeHostname)) { LOG.debug("-> Node: {} {}", node.getHostname(), node.getId()); LOG.debug( "--> Avail Resources: {Mem {}, CPU {} Slots: {}}", node.getAvailableMemoryResources(), node.getAvailableCpuResources(), node.totalSlotsFree()); LOG.debug( "--> Total Resources: {Mem {}, CPU {} Slots: {}}", node.getTotalMemoryResources(), node.getTotalCpuResources(), node.totalSlots()); } } } } }
@Override public String toString() { return "{Node: " + ((sup == null) ? "null (possibly down)" : sup.getHost()) + ", Avail [ Mem: " + getAvailableMemoryResources() + ", CPU: " + getAvailableCpuResources() + ", Slots: " + this.getFreeSlots() + "] Total [ Mem: " + ((sup == null) ? "N/A" : this.getTotalMemoryResources()) + ", CPU: " + ((sup == null) ? "N/A" : this.getTotalCpuResources()) + ", Slots: " + this.slots.values() + " ]}"; }
RAS_Node node = nodes.get(worker.getNodeId()); if (node.getAvailableMemoryResources() < 0.0 && node.getAvailableCpuResources() < 0.0) { LOG.error("Incorrect Scheduling: found node with negative available resources"); return false; return false; if (node.getAvailableMemoryResources() != (node.getTotalMemoryResources() - memoryUsed)) { LOG.error("Incorrect Scheduling: node {} has consumed incorrect amount of memory. Expected: {}" + " Actual: {} Executors scheduled on node: {}", node.getId(), (node.getTotalMemoryResources() - memoryUsed), node.getAvailableMemoryResources(), execs); return false;
exec, targetNode.getHostname(), targetNode.getAvailableMemoryResources(), targetNode.getAvailableCpuResources(), targetNode.getTotalMemoryResources(),
WorkerSlot ws = entry.getKey(); WorkerResources wr = entry.getValue(); double memoryBefore = nodes.get(ws.getNodeId()).getAvailableMemoryResources(); double cpuBefore = nodes.get(ws.getNodeId()).getAvailableCpuResources(); double memoryUsedByWorker = wr.get_mem_on_heap() + wr.get_mem_off_heap(); assertEquals("Check if CPU used by worker is calculated correctly", 100.0, cpuUsedByWorker, 0.001); nodes.get(ws.getNodeId()).free(ws); double memoryAfter = nodes.get(ws.getNodeId()).getAvailableMemoryResources(); double cpuAfter = nodes.get(ws.getNodeId()).getAvailableCpuResources(); assertEquals("Check if free correctly frees amount of memory", memoryBefore + memoryUsedByWorker, memoryAfter, 0.001);
/** * Free all slots on this node. This will update the Cluster too. */ public void freeAllSlots() { if (!_isAlive) { LOG.warn("Freeing all slots on a dead node {} ", _nodeId); } _cluster.freeSlots(_slots.values()); _availCPU = getTotalCpuResources(); _availMemory = getAvailableMemoryResources(); //clearing assignments _topIdToUsedSlots.clear(); }
private void updateSupervisorsResources(Cluster cluster, Topologies topologies) { Map<String, Double[]> supervisors_resources = new HashMap<String, Double[]>(); Map<String, RAS_Node> nodes = RAS_Nodes.getAllNodesFrom(cluster, topologies); for (Map.Entry<String, RAS_Node> entry : nodes.entrySet()) { RAS_Node node = entry.getValue(); Double totalMem = node.getTotalMemoryResources(); Double totalCpu = node.getTotalCpuResources(); Double usedMem = totalMem - node.getAvailableMemoryResources(); Double usedCpu = totalCpu - node.getAvailableCpuResources(); Double[] resources = {totalMem, totalCpu, usedMem, usedCpu}; supervisors_resources.put(entry.getKey(), resources); } cluster.setSupervisorsResourcesMap(supervisors_resources); }
/** * Schedule executor exec from topology td * * @param exec the executor to schedule * @param td the topology executor exec is a part of * @param schedulerAssignmentMap the assignments already calculated * @param scheduledTasks executors that have been scheduled */ private void scheduleExecutor(ExecutorDetails exec, TopologyDetails td, Map<WorkerSlot, Collection<ExecutorDetails>> schedulerAssignmentMap, Collection<ExecutorDetails> scheduledTasks) { 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: {} on Rack: {}", exec, targetNode.getHostname(), targetNode.getAvailableMemoryResources(), targetNode.getAvailableCpuResources(), targetNode.getTotalMemoryResources(), targetNode.getTotalCpuResources(), targetSlot, nodeToRack(targetNode)); } else { LOG.error("Not Enough Resources to schedule Task {}", exec); } }
/** * Get the amount of resources available and total for each node * * @return a String with cluster resource info for debug */ private String getClusterInfo() { String retVal = "Cluster info:\n"; for (Map.Entry<String, List<String>> clusterEntry : _clusterInfo.entrySet()) { String clusterId = clusterEntry.getKey(); retVal += "Rack: " + clusterId + "\n"; for (String nodeHostname : clusterEntry.getValue()) { RAS_Node node = this.idToNode(this.NodeHostnameToId(nodeHostname)); retVal += "-> Node: " + node.getHostname() + " " + node.getId() + "\n"; retVal += "--> Avail Resources: {Mem " + node.getAvailableMemoryResources() + ", CPU " + node.getAvailableCpuResources() + " Slots: " + node.totalSlotsFree() + "}\n"; retVal += "--> Total Resources: {Mem " + node.getTotalMemoryResources() + ", CPU " + node.getTotalCpuResources() + " Slots: " + node.totalSlots() + "}\n"; } } return retVal; }
for (String nodeId : nodeIds) { RAS_Node node = _nodes.getNodeById(this.NodeHostnameToId(nodeId)); double availMem = node.getAvailableMemoryResources(); double availCpu = node.getAvailableCpuResources(); double totalMem = node.getTotalMemoryResources();
/** * Get the best worker to assign executor exec on a rack * * @param exec the executor to schedule * @param td the topology that the executor is a part of * @param rackId the rack id of the rack to find a worker on * @param scheduleAssignmentMap already calculated assignments * @return a worker to assign executor exec to. Returns null if a worker cannot be successfully found on rack with rackId */ private WorkerSlot getBestWorker(ExecutorDetails exec, TopologyDetails td, String rackId, Map<WorkerSlot, Collection<ExecutorDetails>> scheduleAssignmentMap) { if (!_rackIdToSortedNodes.containsKey(rackId)) { _rackIdToSortedNodes.put(rackId, sortNodes(this.getAvailableNodesFromRack(rackId), rackId, td.getId(), scheduleAssignmentMap)); } TreeSet<ObjectResources> sortedNodes = _rackIdToSortedNodes.get(rackId); double taskMem = td.getTotalMemReqTask(exec); double taskCPU = td.getTotalCpuReqTask(exec); for (ObjectResources nodeResources : sortedNodes) { RAS_Node n = _nodes.getNodeById(nodeResources.id); if (n.getAvailableCpuResources() >= taskCPU && n.getAvailableMemoryResources() >= taskMem && n.getFreeSlots().size() > 0) { for (WorkerSlot ws : n.getFreeSlots()) { if (checkWorkerConstraints(exec, ws, td, scheduleAssignmentMap)) { return ws; } } } } return null; }
ObjectResources node = new ObjectResources(nodeId); double availMem = ras_node.getAvailableMemoryResources(); double availCpu = ras_node.getAvailableCpuResources(); int freeSlots = ras_node.totalSlotsFree();