import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
private HostBuilder(int numberOfCores, double mips, int ramSize, long bw, long storageCapacity,
        Class<? extends PeProvisioner> cpuProvisionerClass, Class<? extends RamProvisioner> ramProvisionerClass,
        Class<? extends VmScheduler> vmSchedulerClass,
        Class<? extends BwProvisioner> bwProvisionerClass)
{
    this.numberOfCores_ = numberOfCores;
    this.mips_ = mips;
    this.ramSize_ = ramSize;
    this.bw_ = bw;
    this.storageCapacity_ = storageCapacity;
    
    this.cpuProvisionerClass_ = cpuProvisionerClass;
    this.ramProvisionerClass_ = ramProvisionerClass;
    this.vmSchedulerClass_ = vmSchedulerClass;
    this.bwProvisionerClass_ = bwProvisionerClass;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
public List<Pe> create(final double amount, final double mipsOfEachPe) {
    try {
        validateAmount(amount);
        final List<Pe> peList = new ArrayList<>();
        final Constructor cons =
                provisionerClass.getConstructor();
        for (int i = 0; i < amount; i++) {
            peList.add(new PeSimple(mipsOfEachPe, (PeProvisioner) cons.newInstance()));
        }
        return peList;
    } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
        throw new RuntimeException("It wasn't possible to instantiate a list of Pe", ex);
    }
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
@Override
public double getMaxAvailableMips() {
    return getWorkingPeList().stream()
            .map(Pe::getPeProvisioner)
            .mapToDouble(PeProvisioner::getAvailableResource)
            .max().orElse(0.0);
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
@Override
public final Pe setPeProvisioner(PeProvisioner peProvisioner) {
    Objects.requireNonNull(peProvisioner);
    this.peProvisioner = peProvisioner;
    this.peProvisioner.setPe(this);
    return this;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Gets the max utilization percentage (between [0 and 1]) among all PEs.
 *
 * @param peList the pe list
 * @return the max utilization percentage (between [0 and 1])
 */
public static double getMaxUtilization(List<? extends Pe> peList) {
    return peList.stream()
        .map(Pe::getPeProvisioner)
        .mapToDouble(PeProvisioner::getUtilization)
        .max().orElse(0);
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Gets the max utilization percentage among all PEs allocated to a VM.
 *
 * @param vm the vm to get the maximum utilization percentage
 * @param peList the pe list
 * @return the max utilization percentage
 */
public static double getMaxUtilizationAmongVmsPes(List<? extends Pe> peList, Vm vm) {
    return peList.stream()
        .map(Pe::getPeProvisioner)
        .filter(pv -> pv.getAllocatedResourceForVm(vm) > 0)
        .mapToDouble(PeProvisioner::getUtilization)
        .max().orElse(0);
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
@Override
public WithRam provisioner(Class<? extends PeProvisioner> cpuProvisionerType)
{
    cpuProvisionerClass_ = cpuProvisionerType;
    return new WithRam()
    {
        @Override
        public RamBuilder with(int ram)
        {
            ramSize_ = ram;
            return new RamBuilderImpl();
        }
    };
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
public Class<? extends PeProvisioner> getProvisionerClass() {
    return provisionerClass;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
public PeBuilder setProvisioner(Class<? extends PeProvisioner> defaultProvisioner) {
    this.provisionerClass = defaultProvisioner;
    return this;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
@Override public PeProvisioner getPeProvisioner() {
    return new PeProvisionerSimple();
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
@Override public Pe setPeProvisioner(PeProvisioner peProvisioner) {
    return Pe.NULL;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
private PeSimple createPe(PeProvisioner peProvisioner) {
    return new PeSimple(0, peProvisioner);
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
public static PeProvisioner newPeProvisioner(final HostRegistry hr) throws RuntimeException {
    return resourceProvisioner("Pe", hr.getPeProvisioner());
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Allocates a new Pe object.
 * 
 * @param id the Pe ID
 * @param peProvisioner the pe provisioner
 * @pre id >= 0
 * @pre peProvisioner != null
 * @post $none
 */
public Pe(int id, PeProvisioner peProvisioner) {
	setId(id);
	setPeProvisioner(peProvisioner);

	// when created it should be set to FREE, i.e. available for use.
	status = FREE;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * 一个新的PE
 * Allocates a new Pe object.
 * 
 * @param id the Pe ID
 * @param peProvisioner the pe provisioner
 * @pre id >= 0
 * @pre peProvisioner != null
 * @post $none
 */
public Pe(int id, PeProvisioner peProvisioner) {
	setId(id);
	setPeProvisioner(peProvisioner);

	// when created it should be set to FREE, i.e. available for use.
	status = FREE;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Instantiates a new PE object.
 * The id of the PE is just set when a List of PEs is assigned to a Host.
 *
 * @param mipsCapacity the capacity of the PE in MIPS (Million Instructions per Second)
 * @param peProvisioner the provisioner that will manage the allocation of this physical Pe for VMs
 * @pre peProvisioner != null
 * @post $none
 */
public PeSimple(double mipsCapacity, PeProvisioner peProvisioner) {
    super((long)mipsCapacity);
    setId(-1);
    setPeProvisioner(peProvisioner);

    // when created it should be set to FREE, i.e. available for use.
    setStatus(Status.FREE);
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Sets the pe provisioner.
 * 
 * @param peProvisioner the new pe provisioner
 */
protected void setPeProvisioner(PeProvisioner peProvisioner) {
	this.peProvisioner = peProvisioner;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Gets the Pe provisioner.
 * 
 * @return the Pe provisioner
 */
public PeProvisioner getPeProvisioner() {
	return peProvisioner;
}
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Sets the {@link #getPeProvisioner()} that manages the allocation
 * of this physical PE to virtual machines.
 * This method is automatically called when a {@link PeProvisioner} is created
 * passing a Pe instance. Thus, the PeProvisioner for a Pe doesn't have to be
 * set manually.
 *
 * @param peProvisioner the new PE provisioner
 * @return 
 */
Pe setPeProvisioner(PeProvisioner peProvisioner);
 

import org.cloudbus.cloudsim.provisioners.PeProvisioner; //导入依赖的package包/类
/**
 * Gets the PE provisioner that manages the allocation
 * of this physical PE to virtual machines.
 *
 * @return the PE provisioner
 */
PeProvisioner getPeProvisioner();