/** * 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() + " ]}"; }
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;
targetNode.getAvailableMemoryResources(), targetNode.getAvailableCpuResources(), targetNode.getTotalMemoryResources(), targetNode.getTotalCpuResources(), targetSlot,
private void freeMemory(double amount) { LOG.debug("freeing {} memory on node {}...avail mem: {}", amount, getHostname(), _availMemory); if((_availMemory + amount) > getTotalMemoryResources()) { LOG.warn("Freeing more memory than there exists! Memory trying to free: {} Total memory on Node: {}", (_availMemory + amount), getTotalMemoryResources()); return; } _availMemory += amount; }
@Override public String toString() { return "{Node: " + ((_sup == null) ? "null (possibly down)" : _sup.getHost()) + ", Avail [ Mem: " + ((_availMemory == null) ? "N/A" : _availMemory.toString()) + ", CPU: " + ((_availCPU == null) ? "N/A" : _availCPU.toString()) + ", Slots: " + this.getFreeSlots() + "] Total [ Mem: " + ((_sup == null) ? "N/A" : this.getTotalMemoryResources()) + ", CPU: " + ((_sup == null) ? "N/A" : this.getTotalCpuResources()) + ", Slots: " + this._slots.values() + " ]}"; }
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; }
double availMem = node.getAvailableMemoryResources(); double availCpu = node.getAvailableCpuResources(); double totalMem = node.getTotalMemoryResources(); double totalCpu = node.getTotalCpuResources();
public RAS_Node(String nodeId, SupervisorDetails sup, Cluster cluster, Topologies topologies, Map<String, WorkerSlot> workerIdToWorker, Map<String, Map<String, Collection<ExecutorDetails>>> assignmentMap) { //Node ID and supervisor ID are the same. _nodeId = nodeId; if (sup == null) { _isAlive = false; } else { _isAlive = !cluster.isBlackListed(_nodeId); } _cluster = cluster; _topologies = topologies; // initialize slots for this node if (workerIdToWorker != null) { _slots = workerIdToWorker; } //initialize assignment map if (assignmentMap != null) { _topIdToUsedSlots = assignmentMap; } //check if node is alive if (_isAlive && sup != null) { _hostname = sup.getHost(); _sup = sup; _availMemory = getTotalMemoryResources(); _availCPU = getTotalCpuResources(); //intialize resource usages on node intializeResources(); } }
double availCpu = ras_node.getAvailableCpuResources(); int freeSlots = ras_node.totalSlotsFree(); double totalMem = ras_node.getTotalMemoryResources(); double totalCpu = ras_node.getTotalCpuResources(); int totalSlots = ras_node.totalSlots();