Example #1
0
  @Override
  public void execute() {

    double util = 0;
    double power = 0;
    double prevSlavWork;
    double prevWork;

    // store current work and SLA violated work values
    prevSlavWork = totalSlavWork;
    prevWork = totalWork;

    // reset total work values
    totalSlavWork = 0;
    totalWork = 0;

    totalPower = 0;

    for (Host host : dc.getHosts()) {

      // store host CPU utilization
      if (!hostUtil.containsKey(host)) {
        hostUtil.put(host, new DescriptiveStatistics());
      }

      hostUtil.get(host).addValue(host.getCpuManager().getCpuInUse());

      util += host.getCpuManager().getCpuInUse();

      // get VM SLA values
      for (VMAllocation vmAlloc : host.getVMAllocations()) {
        totalSlavWork += vmAlloc.getVm().getApplication().getTotalSLAViolatedWork();
        totalWork +=
            vmAlloc
                .getVm()
                .getApplication()
                .getTotalIncomingWork(); // NOTE: This ONLY works with SINGLE TIERED applications.
        // For multi-tiered applications, this will count incoming
        // work multiple times!!
      }

      // get power consumption
      power += host.getCurrentPowerConsumption();
      totalPower += host.getPowerConsumed();
    }

    dcUtil.addValue(util);

    dcPower.addValue(power);
    dcPowerEfficiency.addValue(util / power);
    double optimalPowerConsumption = calculateOptimalPowerConsumption(util);
    dcOptimalPower.addValue(optimalPowerConsumption);
    dcOptimalPowerEfficiency.addValue(util / optimalPowerConsumption);

    dcOptimalPowerRatio.addValue((util / optimalPowerConsumption) / (util / power));

    // records the total fraction of SLA violated incoming work since the last time interval
    dcSla.addValue((totalSlavWork - prevSlavWork) / (totalWork - prevWork));
  }
  @Override
  public void schedulePrivDomain(VMAllocation privDomainAllocation) {
    // schedule privileged domain as much CPU as it requires (takes priority over all other VMs)
    double cpuConsumed = privDomainAllocation.getVm().execute(getAvailableCpu());

    consumeAvailableCpu(cpuConsumed);
  }
  @Override
  public boolean processVM(VMAllocation vmAllocation) {

    double cpuAvail =
        Math.min(
            roundCpuShare,
            getAvailableCpu()); // overcome rounding errors that allow sightly more CPU to be used
                                // than available

    double cpuConsumed = vmAllocation.getVm().execute(cpuAvail);

    if (cpuConsumed == 0) {
      --nVms; // once a VM does not execute any work, it will no longer have any work for this
              // interval, due to the order in which dependent VMs are scheduled by the master
              // scheduler
      return false;
    }

    consumeAvailableCpu(cpuConsumed);

    return true;
  }
Example #4
0
  /**
   * Execute the VMs in the simulation
   *
   * @param hosts
   */
  public void execute(ArrayList<Host> hosts) {

    // retrieve ordered list of vm allocations
    ArrayList<VMAllocation> vmList = buildVmList(hosts);

    // calculate the resources each VM has available
    for (VMAllocation vmAllocation : vmList) {
      if (vmAllocation.getVm() != null) vmAllocation.getVm().prepareExecution();
    }

    // prepare hosts for VM execution
    for (Host host : hosts) {
      // if the Host is ON
      if (host.getState() == Host.HostState.ON) {
        // allow the Host's CPU Scheduler to prepare for scheduling
        host.getCpuScheduler().prepareScheduler();
        host.getCpuScheduler().beginScheduling();

        // prepare the privileged domain VM for execution
        host.getPrivDomainAllocation().getVm().prepareExecution();

        // instruct the Host's CPU Scheduler to run the priviledged domain VM
        host.getCpuScheduler().schedulePrivDomain(host.getPrivDomainAllocation());
      }
    }

    HashSet<VMAllocation> completedVms =
        new HashSet<VMAllocation>(); // set of VMs that have completed execution
    boolean notDone = true; // true while execution is not complete

    // execute VMs in rounds until complete. In each round, every VM has a chance to execute
    do {
      notDone = false; // start by assuming done

      // instruct Host CPU Schedulers to begin a round of scheduling
      for (Host host : hosts) {
        if (host.getState() == Host.HostState.ON) host.getCpuScheduler().beginRound();
      }

      // execute VMs
      for (VMAllocation vmAllocation : vmList) {
        // if the VM has not be executed, the VM Allocation actually contains a VM, and the host is
        // ON
        if (!completedVms.contains(vmAllocation)
            && vmAllocation.getVm() != null
            && vmAllocation.getHost().getState()
                == Host.HostState.ON) { // ensure that a VM is instantiated within the allocation
          // if the CPU scheduler has not indicated that is is COMPLETE (i.e. out of resources)
          if (vmAllocation.getHost().getCpuScheduler().getState()
              != CpuScheduler.CpuSchedulerState.COMPLETE) {
            // run the VM
            if (vmAllocation.getHost().getCpuScheduler().processVM(vmAllocation)) {
              // returned true = VM is not finished executing (still has work to complete)
              notDone = true; // not done yet
            } else {
              // returned false = VM is done (no more work to complete)
              completedVms.add(vmAllocation);
            }
          }
        }
      }

      // instruct Host CPU Schedulers that the round has completed
      for (Host host : hosts) {
        if (host.getState() == Host.HostState.ON) host.getCpuScheduler().endRound();
      }

    } while (notDone); // if not done, execute another round

    // instruct Host CPU Schedulers that scheduling is complete
    for (Host host : hosts) {
      if (host.getState() == Host.HostState.ON) {
        host.getCpuScheduler().endScheduling();

        host.getPrivDomainAllocation().getVm().completeExecution();
      }
    }

    // update the resourcesInUse for each VM
    for (VMAllocation vmAllocation : vmList) {
      if (vmAllocation.getVm() != null) {
        vmAllocation.getVm().completeExecution();
      }
    }
  }