예제 #1
0
 @Override
 public String toString() {
   return "Machine(S:"
       + currentState
       + " C:"
       + internalReallyFreeCaps.getRequiredCPUs()
       + " M:"
       + internalReallyFreeCaps.getRequiredMemory()
       + " "
       + localDisk.toString()
       + " "
       + super.toString()
       + ")";
 }
예제 #2
0
/**
 * @author "Gabor Kecskemeti, Distributed and Parallel Systems Group, University of Innsbruck (c)
 *     2013" "Gabor Kecskemeti, Laboratory of Parallel and Distributed Systems, MTA SZTAKI (c) 2012"
 */
public class PhysicalMachine extends MaxMinProvider
    implements VMManager<PhysicalMachine, ResourceConstraints> {

  public static final int defaultAllocLen = 1000;
  public static final int migrationAllocLen = 1000000;
  public static final double smallUtilization = 0.001;

  /**
   * Represents the possible states of the physical machines modeled in the system
   *
   * @author "Gabor Kecskemeti, Distributed and Parallel Systems Group, University of Innsbruck (c)
   *     2013"
   */
  public static enum State {
    /** The machine is completely switched off, minimal consumption is recorded. */
    OFF,
    /** The machine is under preparation to serve VMs. Some consumption is recorded already. */
    SWITCHINGON,
    /** The machine is currently serving VMs. The machine and its VMs are consuming energy. */
    RUNNING,
    /**
     * The machine is about to be switched off. It no longer accepts VM requests but it still
     * consumes energy.
     */
    SWITCHINGOFF
  };

  public static final EnumSet<State> ToOnorRunning = EnumSet.of(State.SWITCHINGON, State.RUNNING);
  public static final EnumSet<State> ToOfforOff = EnumSet.of(State.SWITCHINGOFF, State.OFF);
  public static final EnumSet<State> StatesOfHighEnergyConsumption =
      EnumSet.of(State.SWITCHINGON, State.RUNNING, State.SWITCHINGOFF);

  public interface StateChangeListener {
    void stateChanged(PhysicalMachine pm, State oldState, State newState);
  }

  public class ResourceAllocation extends DeferredEvent implements VirtualMachine.StateChange {
    public final ResourceConstraints allocated;
    private final ResourceConstraints realAllocated;
    private VirtualMachine user = null;
    private final int myPromisedIndex;
    private boolean swept = false;

    private ResourceAllocation(
        final ResourceConstraints realAlloc, final ResourceConstraints alloc, final int until) {
      super(until);
      allocated = alloc;
      realAllocated = realAlloc;
      int prLen = promisedResources.length;
      int i = 0;
      for (i = 0; i < prLen && promisedResources[i] != null; i++) ;
      if (i == prLen) {
        ResourceAllocation[] alls = new ResourceAllocation[prLen * 2];
        System.arraycopy(promisedResources, 0, alls, 0, prLen);
        promisedResources = alls;
        promisedResources[prLen] = this;
        myPromisedIndex = prLen;
      } else {
        promisedResources[i] = this;
        myPromisedIndex = i;
      }
      promisedCapacities.singleAdd(realAllocated);
      internalReallyFreeCaps.subtract(realAllocated);
      promisedAllocationsCount++;
    }

    @Override
    protected void eventAction() {
      System.err.println("Warning! Expiring resource allocation.");
      swept = true;
      promisedCapacityUpdater();
    }

    private void promisedCapacityUpdater() {
      promisedResources[myPromisedIndex] = null;
      promisedAllocationsCount--;
      if (promisedAllocationsCount == 0) {
        promisedCapacities.subtract(promisedCapacities);
      } else {
        promisedCapacities.subtract(realAllocated);
      }
      if (isUnUsed()) {
        internalReallyFreeCaps.singleAdd(realAllocated);
      }
    }

    public void cancel() {
      super.cancel();
      promisedCapacityUpdater();
    }

    void use(final VirtualMachine vm) throws VMManagementException {
      if (swept) {
        throw new VMManagementException("Tried to use an already expired allocation");
      }
      if (user == null) {
        user = vm;
        internalAvailableCaps.subtract(realAllocated);
        vms.add(vm);
        vm.subscribeStateChange(this);
        cancel();
      } else {
        throw new VMManagementException("Tried to use a resource allocation more than once!");
      }
    }

    @Override
    public void stateChanged(
        VirtualMachine vm, VirtualMachine.State oldState, VirtualMachine.State newState) {
      if (oldState.equals(VirtualMachine.State.RUNNING)) {
        release();
      }
    }

    void release() {
      if (user != null) {
        vms.remove(user);
        user.unsubscribeStateChange(this);
        completedVMs++;
        internalAvailableCaps.singleAdd(realAllocated);
        internalReallyFreeCaps.singleAdd(realAllocated);
        increasingFreeCapacityListenerManager.notifyListeners(
            Collections.singletonList(realAllocated));
        user = null;
        swept = true;
      }
    }

    public boolean isUnUsed() {
      return user == null;
    }

    public boolean isAvailable() {
      return isUnUsed() && !swept;
    }

    @Override
    public String toString() {
      return "RA(Canc:" + swept + " " + allocated + ")";
    }

    public PhysicalMachine getHost() {
      return PhysicalMachine.this;
    }
  }

  public class PowerStateDelayer extends ConsumptionEventAdapter {
    private State newState;
    // The end of the list is the upcoming task
    final TDoubleLinkedList tasksDue;
    public final long transitionStart;
    ResourceConsumption currentConsumption = null;

    public PowerStateDelayer(final double[] tasklist, final State newPowerState) {
      onOffEvent = this;
      newState = newPowerState;
      tasksDue = new TDoubleLinkedList();
      tasksDue.add(tasklist);
      sendTask();
      transitionStart = Timed.getFireCount();
    }

    private void sendTask() {
      // Did we finish all the tasks for the state change?
      if (tasksDue.size() == 0) {
        // Mark the completion of the state change
        onOffEvent = null;
        setState(newState);
        return;
      }

      // No we did not, lets send some more to our direct consumer
      final double totalConsumption = tasksDue.removeAt(0);
      final double limit = tasksDue.removeAt(0);
      currentConsumption =
          new ResourceConsumption(
              totalConsumption, limit, directConsumer, PhysicalMachine.this, this);
      if (!currentConsumption.registerConsumption()) {
        throw new IllegalStateException(
            "PowerStateChange was not successful because resource consumption could not be registered");
      }
    }

    @Override
    public void conComplete() {
      sendTask();
    }

    @Override
    public void conCancelled(ResourceConsumption problematic) {
      throw new IllegalStateException("Unexpected termination of one of the state changing tasks");
    }

    public void addFurtherTasks(final double[] tasklist) {
      tasksDue.add(tasklist);
    }

    public void setNewState(State newState) {
      this.newState = newState;
    }
  }

  private final ConstantConstraints totalCapacities;
  // Available physical resources:
  private final AlterableResourceConstraints internalAvailableCaps;
  /**
   * This field can automatically update between two checks! If you need unaltered data please make
   * a copy.
   */
  public final UnalterableConstraintsPropagator availableCapacities;

  private AlterableResourceConstraints promisedCapacities =
      AlterableResourceConstraints.getNoResources();
  private final AlterableResourceConstraints internalReallyFreeCaps;
  /**
   * This field can automatically update between two checks! If you need unaltered data please make
   * a copy.
   */
  public final UnalterableConstraintsPropagator freeCapacities;

  public final Repository localDisk;
  private ResourceAllocation[] promisedResources = new ResourceAllocation[2];
  private int promisedAllocationsCount = 0;

  // Internal state management
  private State currentState = null;
  private final double[] onTransition;
  private final double[] offTransition;
  private final long onDelayEstimate;
  private final long offDelayEstimate;

  public static enum PowerStateKind {
    host,
    storage,
    network
  };

  private final EnumMap<State, PowerState> hostPowerBehavior;
  private final EnumMap<State, PowerState> storagePowerBehavior;
  private final EnumMap<State, PowerState> networkPowerBehavior;
  private final StateDependentEventHandler<StateChangeListener, Pair<State, State>>
      stateListenerManager =
          new StateDependentEventHandler<PhysicalMachine.StateChangeListener, Pair<State, State>>(
              new SingleNotificationHandler<StateChangeListener, Pair<State, State>>() {
                @Override
                public void sendNotification(
                    final StateChangeListener onObject, final Pair<State, State> states) {
                  onObject.stateChanged(PhysicalMachine.this, states.getLeft(), states.getRight());
                }
              });

  // Managed VMs
  private final HashSet<VirtualMachine> vms = new HashSet<VirtualMachine>(); // current
  public final Set<VirtualMachine> publicVms = Collections.unmodifiableSet(vms);
  private long completedVMs = 0; // Past
  // The onOffEvent here is managed by the delayer itself.
  private PowerStateDelayer onOffEvent = null;
  private final StateDependentEventHandler<
          CapacityChangeEvent<ResourceConstraints>, List<ResourceConstraints>>
      increasingFreeCapacityListenerManager =
          new StateDependentEventHandler<
              VMManager.CapacityChangeEvent<ResourceConstraints>, List<ResourceConstraints>>(
              new SingleNotificationHandler<
                  CapacityChangeEvent<ResourceConstraints>, List<ResourceConstraints>>() {
                @Override
                public void sendNotification(
                    final CapacityChangeEvent<ResourceConstraints> onObject,
                    final List<ResourceConstraints> recentlyFreedUpResources) {
                  onObject.capacityChanged(freeCapacities, recentlyFreedUpResources);
                }
              });

  // The "hidden" - non VM - consumer (representing the VMM's actions and the
  // PM's own operations
  public final MaxMinConsumer directConsumer;
  private boolean directConsumerUsageMoratory = true;

  /**
   * Defines a new physical machine, ensures that there are no VMs running so far
   *
   * @param cores defines the number of CPU cores this machine has under control
   * @param perCorePocessing defines the processing capabilities of a single CPU core in this
   *     machine (in instructions/tick)
   * @param memory defines the total physical memory this machine has under control (in bytes)
   * @param disk defines the local physical disk & networking this machine has under control
   * @param onD defines the time delay between the machine's switch on and the first time it can
   *     serve VM requests
   * @param offD defines the time delay the machine needs to shut down all of its operations while
   *     it does not serve any more VMs
   * @param powerTransitions determines the applied power state transitions while the physical
   *     machine state changes. This is the principal way to alter a PM's energy consumption
   *     behavior.
   */
  public PhysicalMachine(
      double cores,
      double perCorePocessing,
      long memory,
      Repository disk,
      int onD,
      int offD,
      EnumMap<PowerStateKind, EnumMap<State, PowerState>> powerTransitions) {
    this(
        cores,
        perCorePocessing,
        memory,
        disk,
        new double[] {
          onD * perCorePocessing * smallUtilization, perCorePocessing * smallUtilization
        },
        new double[] {
          offD * perCorePocessing * smallUtilization, perCorePocessing * smallUtilization
        },
        powerTransitions);
  }

  /**
   * @param on which taskset needs to be prepared
   * @param array the task array
   * @return the estimated runtime of all tasks in the array
   */
  private long prepareTransitionalTasks(boolean on, double[] array) {
    final double[] writeHere = on ? onTransition : offTransition;
    System.arraycopy(array, 0, writeHere, 0, array.length);
    long odSum = 0;
    for (int i = 0; i < array.length; i += 2) {
      odSum += (long) (array[i] / array[i + 1]);
    }
    return odSum;
  }

  public PhysicalMachine(
      double cores,
      double perCorePocessing,
      long memory,
      Repository disk,
      double[] turnonOperations,
      double[] switchoffOperations,
      EnumMap<PowerStateKind, EnumMap<State, PowerState>> powerTransitions) {
    super(cores * perCorePocessing);
    // Init resources:
    totalCapacities = new ConstantConstraints(cores, perCorePocessing, memory);
    internalAvailableCaps = new AlterableResourceConstraints(totalCapacities);
    availableCapacities = new UnalterableConstraintsPropagator(internalAvailableCaps);
    internalReallyFreeCaps = new AlterableResourceConstraints(totalCapacities);
    freeCapacities = new UnalterableConstraintsPropagator(internalReallyFreeCaps);
    localDisk = disk;

    hostPowerBehavior = powerTransitions.get(PowerStateKind.host);
    storagePowerBehavior = powerTransitions.get(PowerStateKind.storage);
    networkPowerBehavior = powerTransitions.get(PowerStateKind.network);
    onTransition = new double[turnonOperations.length];
    onDelayEstimate = prepareTransitionalTasks(true, turnonOperations);
    offTransition = new double[switchoffOperations.length];
    offDelayEstimate = prepareTransitionalTasks(false, switchoffOperations);

    if (hostPowerBehavior == null || storagePowerBehavior == null || networkPowerBehavior == null) {
      throw new IllegalStateException(
          "Cannot initialize physical machine without a complete power behavior set");
    }

    setState(State.OFF);
    directConsumer = new MaxMinConsumer(getPerTickProcessingPower());
  }

  /**
   * Starts the turn off procedure for the physical machine so it no longer accepts VM requests but
   * it does not consume anymore
   *
   * @param migrateHere the physical machine where the currently hosted VMs of this VM should go
   *     before the actual switch off operation will happen
   * @return
   *     <ul>
   *       <li>true if the switch off procedure has started
   *       <li>false if there are still VMs running and migration target was not specified thus the
   *           switch off is not possible
   *     </ul>
   *
   * @throws NetworkException
   * @throws VMManager.VMManagementException
   */
  public boolean switchoff(final PhysicalMachine migrateHere)
      throws VMManagementException, NetworkException {
    if (migrateHere != null) {
      final VirtualMachine[] vmarr = vms.toArray(new VirtualMachine[vms.size()]);
      class MultiMigrate implements VirtualMachine.StateChange {
        private int counter = 0;

        @Override
        public void stateChanged(
            VirtualMachine vm, VirtualMachine.State oldState, VirtualMachine.State newState) {
          switch (newState) {
            case RUNNING:
              counter++;
              break;
            case SUSPENDED_MIG:
              // There is a problem but we cannot do here anything
              // right now...
            default:
          }
          if (counter == vmarr.length) {
            for (int i = 0; i < vmarr.length; i++) {
              vmarr[i].unsubscribeStateChange(this);
            }
            actualSwitchOff();
          }
        }
      }
      MultiMigrate mm = new MultiMigrate();
      for (int i = 0; i < vmarr.length; i++) {
        vmarr[i].subscribeStateChange(mm);
        migrateVM(vmarr[i], migrateHere);
      }
    } else {
      if (vms.size() + promisedAllocationsCount > 0) {
        return false;
      }
      actualSwitchOff();
    }
    return true;
  }

  private void actualSwitchOff() {
    switch (currentState) {
      case SWITCHINGON:
        setState(State.SWITCHINGOFF);
        onOffEvent.addFurtherTasks(offTransition);
        onOffEvent.setNewState(State.OFF);
        break;
      case RUNNING:
        setState(State.SWITCHINGOFF);
        new Timed() {
          @Override
          public void tick(final long fires) {
            ResourceSpreader.FreqSyncer syncer = getSyncer();
            // Ensures that the switching off activities are only
            // started once all runtime activities complete for the
            // directConsumer
            if (syncer != null
                && syncer.isSubscribed()
                && (underProcessing.size() + toBeAdded.size() - toBeRemoved.size() > 0)) {
              updateFrequency(syncer.getNextEvent() - fires + 1);
            } else {
              unsubscribe();
              new PowerStateDelayer(offTransition, State.OFF);
            }
          }
        }.tick(Timed.getFireCount());
        break;
      case OFF:
      case SWITCHINGOFF:
        // Nothing to do
        System.err.println("WARNING: an already off PM was tasked to switch off!");
    }
  }

  /**
   * Determines if the machine can be used for VM instantiation.
   *
   * @return
   *     <ul>
   *       <li>true if the machine is ready to accept VM requests
   *       <li>false otherwise
   *     </ul>
   */
  public boolean isRunning() {
    return currentState.equals(State.RUNNING);
  }

  public State getState() {
    return currentState;
  }

  /**
   * Turns on the physical machine so it allows energy and resource consumption and opens the
   * possibility to receive VM requests.
   */
  public void turnon() {
    switch (currentState) {
      case SWITCHINGOFF:
      case OFF:
        if (onOffEvent == null) {
          new PowerStateDelayer(onTransition, State.RUNNING);
        } else {
          onOffEvent.addFurtherTasks(onTransition);
          onOffEvent.setNewState(State.RUNNING);
        }

        setState(State.SWITCHINGON);
        break;
      case RUNNING:
      case SWITCHINGON:
        // Nothing to do
        System.err.println("WARNING: an already running PM was tasked to switch on!");
    }
  }

  @Override
  public void migrateVM(final VirtualMachine vm, final PhysicalMachine target)
      throws VMManagementException, NetworkNode.NetworkException {
    if (vms.contains(vm)) {
      vm.migrate(
          target.allocateResources(vm.getResourceAllocation().allocated, true, migrationAllocLen));
    }
  }

  @Override
  public void reallocateResources(
      final VirtualMachine vm, final ResourceConstraints newresources) {}

  /**
   * Ensures the requested amount of resources are going to be available in the foreseeable future
   * on this physical machine.
   *
   * @param requested The amount of resources needed by the caller
   * @return With a time limited offer on the requested resources. If the requested
   *     resourceconstraints cannot be met by the function then it returns with the maximum amount
   *     of resources it can serve. If there are no available resources it returns with <i>null</i>!
   *     If the requested resources are available then the original requested resourceconstraints
   *     object is stored in the returned resource allocation. If the resourceconstraints only
   *     specified a minimum resource limit, then a new resourceconstraints object is returned with
   *     details of the maximum possible resource constraints that can fit into the machine.
   */
  public ResourceAllocation allocateResources(
      final ResourceConstraints requested, final boolean strict, final int allocationValidityLength)
      throws VMManagementException {
    if (!currentState.equals(State.RUNNING)) {
      throw new VMManagementException("The PM is not running and thus cannot offer resources yet");
    }
    // Basic tests for resource availability for the host
    if (internalReallyFreeCaps.getRequiredCPUs() == 0
        || internalReallyFreeCaps.getRequiredMemory() == 0
        || requested.getRequiredProcessingPower()
            > internalReallyFreeCaps.getRequiredProcessingPower()) {
      return null;
    }
    // Allocation type test (i.e. do we allow underprovisioning?)
    for (int i = 0; i < promisedResources.length; i++) {
      ResourceAllocation olderAllocation = promisedResources[i];
      if (olderAllocation != null) {
        if (olderAllocation.allocated.isRequiredProcessingIsMinimum()
            == requested.isRequiredProcessingIsMinimum()) {
          break;
        } else {
          return null;
        }
      }
    }
    // Promised resources for the virtual machine
    double vmCPU = requested.getRequiredCPUs();
    long vmMem = requested.getRequiredMemory();
    final double vmPrPow =
        requested.isRequiredProcessingIsMinimum()
            ? totalCapacities.getRequiredProcessingPower()
            : requested.getRequiredProcessingPower();

    // Actually allocated resources (memory is equivalent in both cases)
    final double allocPrPow = totalCapacities.getRequiredProcessingPower();
    final double allocCPU = vmCPU * requested.getRequiredProcessingPower() / allocPrPow;
    if (0 <= internalReallyFreeCaps.getRequiredCPUs() - allocCPU) {
      if (0 <= internalReallyFreeCaps.getRequiredMemory() - requested.getRequiredMemory()) {
        return new ResourceAllocation(
            new ConstantConstraints(allocCPU, allocPrPow, vmMem),
            requested.isRequiredProcessingIsMinimum()
                ? new ConstantConstraints(vmCPU, vmPrPow, true, vmMem)
                : requested,
            allocationValidityLength);
      } else {
        vmMem = internalReallyFreeCaps.getRequiredMemory();
      }
    } else if (0 <= internalReallyFreeCaps.getRequiredMemory() - requested.getRequiredMemory()) {
      vmCPU = internalReallyFreeCaps.getRequiredCPUs();
    } else {
      vmCPU = internalReallyFreeCaps.getRequiredCPUs();
      vmMem = internalReallyFreeCaps.getRequiredMemory();
    }
    if (strict) {
      return null;
    } else {
      final ResourceConstraints updatedConstraints =
          new ConstantConstraints(vmCPU, vmPrPow, requested.isRequiredProcessingIsMinimum(), vmMem);
      return new ResourceAllocation(
          updatedConstraints, updatedConstraints, allocationValidityLength);
    }
  }

  private boolean checkAllocationsPresence(final ResourceAllocation allocation) {
    return promisedResources.length > allocation.myPromisedIndex
        && promisedResources[allocation.myPromisedIndex] == allocation;
  }

  public boolean cancelAllocation(final ResourceAllocation allocation) {
    if (checkAllocationsPresence(allocation)) {
      allocation.cancel();
      return true;
    }
    return false;
  }

  public boolean isHostableRequest(final ResourceConstraints requested) {
    return requested.compareTo(totalCapacities) <= 0;
  }

  public void deployVM(
      final VirtualMachine vm, final ResourceAllocation ra, final Repository vaSource)
      throws VMManagementException, NetworkNode.NetworkException {
    if (checkAllocationsPresence(ra)) {
      final VirtualAppliance va = vm.getVa();
      final StorageObject foundLocal = localDisk.lookup(va.id);
      final StorageObject foundRemote = vaSource == null ? null : vaSource.lookup(va.id);
      if (foundLocal != null || foundRemote != null) {
        vm.switchOn(ra, vaSource);
      } else {
        throw new VMManagementException("No VA available!");
      }
    } else {
      throw new VMManagementException("Tried to deploy VM with an expired resource allocation");
    }
  }

  /**
   * Initiates a VM on this physical machine. If the physical machine cannot host VMs for some
   * reason an exception is thrown, if the machine cannot host this particular VA then a null VM is
   * returned.
   *
   * @param va The appliance for the VM to be created.
   * @param rc The resource requirements of the VM
   * @param vaSource The storage where the VA resides.
   * @param count The number of VMs to be created with the above specification
   * @return The virtual machine(s) that will be instantiated on the PM. Null if the constraints
   *     specify VMs that cannot fit the available resources of the machine.
   * @throws VMManagementException If the machine is not accepting requests currently.<br>
   *     If the VM startup has failed.
   */
  public VirtualMachine[] requestVM(
      final VirtualAppliance va,
      final ResourceConstraints rc,
      final Repository vaSource,
      final int count)
      throws VMManagementException, NetworkException {
    final VirtualMachine[] vms = new VirtualMachine[count];
    final ResourceAllocation[] ras = new ResourceAllocation[count];
    boolean canDeployAll = true;
    for (int i = 0; i < count && canDeployAll; i++) {
      ras[i] = allocateResources(rc, true, defaultAllocLen);
      vms[i] = null;
      canDeployAll &= ras[i] != null && ras[i].allocated == rc;
    }
    if (canDeployAll) {
      for (int i = 0; i < count; i++) {
        vms[i] = new VirtualMachine(va);
        deployVM(vms[i], ras[i], vaSource);
      }
    } else {
      for (int i = 0; i < count && ras[i] != null; i++) {
        ras[i].cancel();
      }
    }
    return vms;
  }

  /**
   * Scheduling constraints are ignored currently! As this is too low level to handle them in the
   * current state of the simulator.
   */
  @Override
  public VirtualMachine[] requestVM(
      VirtualAppliance va,
      ResourceConstraints rc,
      Repository vaSource,
      int count,
      HashMap<String, Object> schedulingConstraints)
      throws VMManagementException, NetworkException {
    return requestVM(va, rc, vaSource, count);
  }

  @Override
  public void terminateVM(final VirtualMachine vm, final boolean killTasks)
      throws NoSuchVMException, VMManagementException {
    if (!vms.contains(vm)) {
      throw new NoSuchVMException("Termination request was received for an unknown VM");
    }
    vm.switchoff(killTasks);
  }

  @Override
  public Collection<VirtualMachine> listVMs() {
    return publicVms;
  }

  public int numofCurrentVMs() {
    return vms.size();
  }

  @Override
  protected boolean isAcceptableConsumption(final ResourceConsumption con) {
    final ResourceSpreader consumer = con.getConsumer();
    final boolean internalConsumer =
        (consumer == directConsumer)
            && (directConsumerUsageMoratory
                ? (onOffEvent == null ? false : onOffEvent.currentConsumption == con)
                : true);
    final boolean runningVirtualMachine;
    if (internalConsumer) {
      runningVirtualMachine = false;
    } else {
      if (consumer instanceof VirtualMachine) {
        runningVirtualMachine = vms.contains((VirtualMachine) consumer);
      } else {
        runningVirtualMachine = false;
      }
    }
    return internalConsumer || runningVirtualMachine ? super.isAcceptableConsumption(con) : false;
  }

  public boolean isHostingVMs() {
    return !vms.isEmpty();
  }

  public long getCompletedVMs() {
    return completedVMs;
  }

  public long getCurrentOnOffDelay() {
    if (onOffEvent == null) {
      switch (currentState) {
        case OFF:
          return onDelayEstimate;
        case RUNNING:
          return offDelayEstimate;
        default:
          throw new IllegalStateException("The onOffEvent is null while doing switchon/off");
      }
    } else {
      long remainingTime = onOffEvent.transitionStart - Timed.getFireCount();
      switch (currentState) {
        case SWITCHINGOFF:
          remainingTime += offDelayEstimate;
          break;
        case SWITCHINGON:
          remainingTime += onDelayEstimate;
          break;
        default:
          throw new IllegalStateException(
              "The onOffEvent is not null while not in switchon/off mode");
      }
      return remainingTime;
    }
  }

  @Override
  public String toString() {
    return "Machine(S:"
        + currentState
        + " C:"
        + internalReallyFreeCaps.getRequiredCPUs()
        + " M:"
        + internalReallyFreeCaps.getRequiredMemory()
        + " "
        + localDisk.toString()
        + " "
        + super.toString()
        + ")";
  }

  public void subscribeStateChangeEvents(final StateChangeListener sl) {
    stateListenerManager.subscribeToEvents(sl);
  }

  public void unsubscribeStateChangeEvents(final StateChangeListener sl) {
    stateListenerManager.unsubscribeFromEvents(sl);
  }

  private void setState(final State newState) {
    final State pastState = currentState;
    currentState = newState;
    directConsumerUsageMoratory = newState != State.RUNNING;
    stateListenerManager.notifyListeners(Pair.of(pastState, newState));

    // Power state management:
    setCurrentPowerBehavior(hostPowerBehavior.get(newState));
    // TODO: if the repository class also implements proper power state
    // management then this must move there
    localDisk.diskinbws.setCurrentPowerBehavior(storagePowerBehavior.get(newState));
    localDisk.diskoutbws.setCurrentPowerBehavior(storagePowerBehavior.get(newState));
    localDisk.inbws.setCurrentPowerBehavior(networkPowerBehavior.get(newState));
    localDisk.outbws.setCurrentPowerBehavior(networkPowerBehavior.get(newState));
  }

  public ResourceConstraints getCapacities() {
    return totalCapacities;
  }

  @Override
  public void subscribeToCapacityChanges(final CapacityChangeEvent<ResourceConstraints> e) {
    // FIXME: not important yet
  }

  @Override
  public void unsubscribeFromCapacityChanges(final CapacityChangeEvent<ResourceConstraints> e) {
    // FIXME: not important yet
  }

  public void subscribeToIncreasingFreeapacityChanges(
      final CapacityChangeEvent<ResourceConstraints> e) {
    increasingFreeCapacityListenerManager.subscribeToEvents(e);
    ;
  }

  public void unsubscribeFromIncreasingFreeCapacityChanges(
      final CapacityChangeEvent<ResourceConstraints> e) {
    increasingFreeCapacityListenerManager.unsubscribeFromEvents(e);
  }

  public boolean isDirectConsumerUsageMoratory() {
    return directConsumerUsageMoratory;
  }
}
예제 #3
0
  /**
   * Ensures the requested amount of resources are going to be available in the foreseeable future
   * on this physical machine.
   *
   * @param requested The amount of resources needed by the caller
   * @return With a time limited offer on the requested resources. If the requested
   *     resourceconstraints cannot be met by the function then it returns with the maximum amount
   *     of resources it can serve. If there are no available resources it returns with <i>null</i>!
   *     If the requested resources are available then the original requested resourceconstraints
   *     object is stored in the returned resource allocation. If the resourceconstraints only
   *     specified a minimum resource limit, then a new resourceconstraints object is returned with
   *     details of the maximum possible resource constraints that can fit into the machine.
   */
  public ResourceAllocation allocateResources(
      final ResourceConstraints requested, final boolean strict, final int allocationValidityLength)
      throws VMManagementException {
    if (!currentState.equals(State.RUNNING)) {
      throw new VMManagementException("The PM is not running and thus cannot offer resources yet");
    }
    // Basic tests for resource availability for the host
    if (internalReallyFreeCaps.getRequiredCPUs() == 0
        || internalReallyFreeCaps.getRequiredMemory() == 0
        || requested.getRequiredProcessingPower()
            > internalReallyFreeCaps.getRequiredProcessingPower()) {
      return null;
    }
    // Allocation type test (i.e. do we allow underprovisioning?)
    for (int i = 0; i < promisedResources.length; i++) {
      ResourceAllocation olderAllocation = promisedResources[i];
      if (olderAllocation != null) {
        if (olderAllocation.allocated.isRequiredProcessingIsMinimum()
            == requested.isRequiredProcessingIsMinimum()) {
          break;
        } else {
          return null;
        }
      }
    }
    // Promised resources for the virtual machine
    double vmCPU = requested.getRequiredCPUs();
    long vmMem = requested.getRequiredMemory();
    final double vmPrPow =
        requested.isRequiredProcessingIsMinimum()
            ? totalCapacities.getRequiredProcessingPower()
            : requested.getRequiredProcessingPower();

    // Actually allocated resources (memory is equivalent in both cases)
    final double allocPrPow = totalCapacities.getRequiredProcessingPower();
    final double allocCPU = vmCPU * requested.getRequiredProcessingPower() / allocPrPow;
    if (0 <= internalReallyFreeCaps.getRequiredCPUs() - allocCPU) {
      if (0 <= internalReallyFreeCaps.getRequiredMemory() - requested.getRequiredMemory()) {
        return new ResourceAllocation(
            new ConstantConstraints(allocCPU, allocPrPow, vmMem),
            requested.isRequiredProcessingIsMinimum()
                ? new ConstantConstraints(vmCPU, vmPrPow, true, vmMem)
                : requested,
            allocationValidityLength);
      } else {
        vmMem = internalReallyFreeCaps.getRequiredMemory();
      }
    } else if (0 <= internalReallyFreeCaps.getRequiredMemory() - requested.getRequiredMemory()) {
      vmCPU = internalReallyFreeCaps.getRequiredCPUs();
    } else {
      vmCPU = internalReallyFreeCaps.getRequiredCPUs();
      vmMem = internalReallyFreeCaps.getRequiredMemory();
    }
    if (strict) {
      return null;
    } else {
      final ResourceConstraints updatedConstraints =
          new ConstantConstraints(vmCPU, vmPrPow, requested.isRequiredProcessingIsMinimum(), vmMem);
      return new ResourceAllocation(
          updatedConstraints, updatedConstraints, allocationValidityLength);
    }
  }