import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Sets the average seek time and a new generator of seek times in seconds. The generator
 * determines a randomized seek time.
 * 
 * @param seekTime the average seek time in seconds
 * @param gen the ContinuousGenerator which generates seek times
 * @return <tt>true</tt> if the setting succeeded, <tt>false</tt> otherwise
 */
public boolean setAvgSeekTime(double seekTime, ContinuousDistribution gen) {
	if (seekTime <= 0.0) {
		return false;
	}

	avgSeekTime = seekTime;
	this.gen = gen;
	return true;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
private void changeMiBaseline() {
	double mean = 1d;
	double dev = Parameters.cpuDynamicsCV;
	ContinuousDistribution dist = Parameters.getDistribution(Parameters.cpuDynamicsDistribution, mean, Parameters.cpuDynamicsAlpha, Parameters.cpuDynamicsBeta,
	    dev, Parameters.cpuDynamicsShape, Parameters.cpuDynamicsLocation, Parameters.cpuDynamicsShift, Parameters.cpuDynamicsMin, Parameters.cpuDynamicsMax,
	    Parameters.cpuDynamicsPopulation);
	miCurrentBaseline = 0;
	while (miCurrentBaseline <= 0) {
		miCurrentBaseline = dist.sample();
	}
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
private void changeIoBaseline() {
	double mean = 1d;
	double dev = Parameters.ioDynamicsCV;
	ContinuousDistribution dist = Parameters.getDistribution(Parameters.ioDynamicsDistribution, mean, Parameters.ioDynamicsAlpha, Parameters.ioDynamicsBeta,
	    dev, Parameters.ioDynamicsShape, Parameters.ioDynamicsLocation, Parameters.ioDynamicsShift, Parameters.ioDynamicsMin, Parameters.ioDynamicsMax,
	    Parameters.ioDynamicsPopulation);
	ioCurrentBaseline = 0;
	while (ioCurrentBaseline <= 0) {
		ioCurrentBaseline = dist.sample();
	}
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
private void changeBwBaseline() {
	double mean = 1d;
	double dev = Parameters.bwDynamicsCV;
	ContinuousDistribution dist = Parameters.getDistribution(Parameters.bwDynamicsDistribution, mean, Parameters.bwDynamicsAlpha, Parameters.bwDynamicsBeta,
	    dev, Parameters.bwDynamicsShape, Parameters.bwDynamicsLocation, Parameters.bwDynamicsShift, Parameters.bwDynamicsMin, Parameters.bwDynamicsMax,
	    Parameters.bwDynamicsPopulation);
	bwCurrentBaseline = 0;
	while (bwCurrentBaseline <= 0) {
		bwCurrentBaseline = dist.sample();
	}
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Creates an array with the configuration of PEs for each Cloudlet to be
 * created in each experiment run. Every experiment will use the same
 * Cloudlets configurations.
 *
 * @return the created cloudlet PEs array
 */
private int[] createCloudletPesArray() {
    int[] pesArray = new int[CLOUDLETS_TO_CREATE];
    int totalNumberOfPes = 0;
    final ContinuousDistribution random = new NormalDistr(getBaseSeed(), 2, 0.6);
    for (int i = 0; i < CLOUDLETS_TO_CREATE; i++) {
        pesArray[i] = (int) random.sample() + 1;
        totalNumberOfPes += pesArray[i];
    }

    return pesArray;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected DatacenterBrokerHeuristicExperiment createExperiment(int i) {
    final ContinuousDistribution prng = createRandomGen(i, 0, 1);
    final DatacenterBrokerHeuristicExperiment exp
            = new DatacenterBrokerHeuristicExperiment(i, this)
                    .setRandomGen(prng)
                    .setCloudletPesArray(cloudletPesArray)
                    .setVmPesArray(vmPesArray);

    exp.setVerbose(experimentVerbose).setAfterExperimentFinish(this::afterExperimentFinish);
    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected CloudletSchedulerTimeSharedExperiment createExperiment(int i) {
    final ContinuousDistribution cloudletPesPrng = createRandomGen(i, 1, MAX_CLOUDLET_PES);
    final CloudletSchedulerTimeSharedExperiment exp = new CloudletSchedulerTimeSharedExperiment(i, this);

    exp
        .setCloudletPesPrng(cloudletPesPrng)
        .setNumCloudletsToCreate((int) getCloudletsNumberPrng().sample())
        .setAfterExperimentFinish(this::afterExperimentFinish)
        .setVerbose(false);

    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected CompletelyFairSchedulerExperiment createExperiment(int i) {
    final ContinuousDistribution cloudletPesPrng = createRandomGen(i, 1, MAX_CLOUDLET_PES);
    final CompletelyFairSchedulerExperiment exp = new CompletelyFairSchedulerExperiment(i, this);

    exp
        .setCloudletPesPrng(cloudletPesPrng)
        .setNumCloudletsToCreate((int) getCloudletsNumberPrng().sample())
        .setAfterExperimentFinish(this::afterExperimentFinish)
        .setVerbose(false);

    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected CloudletTaskTimeCompletionWorkLoadWithoutMinimizationExperiment createExperiment(int i) {
    ContinuousDistribution randCloudlet = createRandomGen(i);
    ContinuousDistribution randVm = createRandomGen(i);
    CloudletTaskTimeCompletionWorkLoadWithoutMinimizationExperiment exp
            = new CloudletTaskTimeCompletionWorkLoadWithoutMinimizationExperiment(i, this);
    exp.setVerbose(experimentVerbose).setAfterExperimentFinish(this::afterExperimentFinish);
    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected CloudletTaskTimeCompletionWithoutMinimizationExperiment createExperiment(int i) {
    CloudletTaskTimeCompletionWithoutMinimizationExperiment exp
            = new CloudletTaskTimeCompletionWithoutMinimizationExperiment(i, this);
    ContinuousDistribution randCloudlet = createRandomGen(i);
    ContinuousDistribution randVm = createRandomGen(i);
    exp.setVerbose(experimentVerbose).setAfterExperimentFinish(this::afterExperimentFinish);
    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected CloudletTaskTimeCompletionWorkLoadMinimizationExperiment createExperiment(int i) {
    CloudletTaskTimeCompletionWorkLoadMinimizationExperiment exp
            = new CloudletTaskTimeCompletionWorkLoadMinimizationExperiment(i, this);
    ContinuousDistribution randCloudlet = createRandomGen(i);
    ContinuousDistribution randVm = createRandomGen(i);
    ContinuousDistribution randMips = createRandomGen(i);

    exp.setVerbose(experimentVerbose).setAfterExperimentFinish(this::afterExperimentFinish);
    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
@Override
protected CloudletTaskTimeCompletionMinimizationExperiment createExperiment(int i) {
    CloudletTaskTimeCompletionMinimizationExperiment exp
            = new CloudletTaskTimeCompletionMinimizationExperiment(i, this);

    ContinuousDistribution randCloudlet = createRandomGen(i);
    ContinuousDistribution randVm = createRandomGen(i);
    ContinuousDistribution randCloudletPes = createRandomGen(i);
    ContinuousDistribution randMips = createRandomGen(i);
    exp.setVerbose(experimentVerbose)
            .setAfterExperimentFinish(this::afterExperimentFinish);
    return exp;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Creates a heuristic.
 *
 * @param random a random number generator
 * @param solutionClass reference to the generic class that will be used to instantiate heuristic solutions
 */
HeuristicAbstract(ContinuousDistribution random, Class<S> solutionClass){
	this.solutionClass = solutionClass;
	this.random = random;
	this.numberOfNeighborhoodSearchesByIteration = 1;
	setBestSolutionSoFar(newSolutionInstance());
	setNeighborSolution(bestSolutionSoFar);
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Sets the average seek time and a new generator of seek times in seconds. The generator
 * determines a randomized seek time.
 *
 * @param seekTime the average seek time in seconds
 * @param gen the ContinuousGenerator which generates seek times
 * @return <tt>true</tt> if the values is greater than zero and was set successfully,
 * <tt>false</tt> otherwise
 */
public boolean setAvgSeekTime(final double seekTime, final ContinuousDistribution gen) {
    if (seekTime <= 0.0) {
        return false;
    }

    avgSeekTime = seekTime;
    this.gen = gen;
    return true;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Private method called by the overloaded versions of the
 * setAvgSeekTime method.
 * @param gen A random number generator. The parameter can be
 * null in order to use the simpler version of the setAvgSeekTime.
 */
private void testSetAvgSeekTime(ContinuousDistribution gen) {
    final HarddriveStorage instance = createHardDrive();
    final double seekTime = 1;
    assertTrue(setAvgSeekTime(instance, seekTime, gen));
    assertEquals(seekTime, instance.getAvgSeekTime(), 0);

    assertFalse(setAvgSeekTime(instance, 0, gen));
    assertEquals(seekTime, instance.getAvgSeekTime(), 0);

    assertFalse(setAvgSeekTime(instance, -1, gen));
    assertEquals(seekTime, instance.getAvgSeekTime(), 0);
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
private static boolean setAvgSeekTime(
        final HarddriveStorage instance, final double seekTime,
        final ContinuousDistribution gen) {
    if(gen != null) {
        return instance.setAvgSeekTime(seekTime, gen);
    }

    return instance.setAvgSeekTime(seekTime);
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
public ContinuousDistribution getCloudletPesPrng() {
    return cloudletPesPrng;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
public CloudletSchedulerExperiment setCloudletPesPrng(ContinuousDistribution cloudletPesPrng) {
    this.cloudletPesPrng = cloudletPesPrng;
    return this;
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Creates a pseudo random number generator (PRNG) for a experiment run that
 * generates uniform values between [min and max[. If it is to apply the
 * {@link #isApplyAntitheticVariatesTechnique() "Antithetic Variates Technique"}
 * to reduce results variance, the second half of experiments will use the
 * seeds from the first half.
 *
 * @param experimentIndex
 * @param minValue the minimum value the generator will return (inclusive)
 * @param maxValue the maximum value the generator will return (exclusive)
 * @return the created PRNG
 *
 * @see UniformDistr#isApplyAntitheticVariatesTechnique()
 */
public ContinuousDistribution createRandomGen(int experimentIndex, double minValue, double maxValue) {
    if (isToReuseSeedFromFirstHalfOfExperiments(experimentIndex)) {
        final int expIndexFromFirstHalf = experimentIndex - halfSimulationRuns();
        return new UniformDistr(minValue, maxValue, seeds.get(expIndexFromFirstHalf))
                .setApplyAntitheticVariatesTechnique(true);
    }

    return new UniformDistr(minValue, maxValue, seeds.get(experimentIndex));
}
 

import org.cloudbus.cloudsim.distributions.ContinuousDistribution; //导入依赖的package包/类
/**
 * Creates a fault injection mechanism for the Hosts of a given {@link Datacenter}.
 * The failures are randomly injected according to the given
 * mean of failures to be generated per <b>minute</b>,
 * which is also called <b>event rate</b> or <b>rate parameter</b>.
 *
 * @param datacenter the Datacenter to which failures will be randomly injected for its Hosts
 *
 * @param faultArrivalTimesGeneratorInHours a Pseudo Random Number Generator which generates the
 * times (in hours) Hosts failures will occur.
 * <b>The values returned by the generator will be considered to be hours</b>.
 * Frequently it is used a
 * {@link PoissonDistr} to generate failure arrivals, but any {@link ContinuousDistribution}
 * can be used.
 */
public HostFaultInjection(Datacenter datacenter, ContinuousDistribution faultArrivalTimesGeneratorInHours) {
    super(datacenter.getSimulation());
    this.setDatacenter(datacenter);
    this.lastFailedHost = Host.NULL;
    this.faultArrivalTimesGeneratorInHours = faultArrivalTimesGeneratorInHours;
    this.random = new UniformDistr(faultArrivalTimesGeneratorInHours.getSeed()+1);
    this.vmRecoveryTimeSecsMap = new HashMap<>();
    this.hostFaultsTimeSecsMap = new HashMap<>();
    this.faultsOfAllVmsByBroker = new HashMap<>();
    this.vmClonerMap = new HashMap<>();
    this.maxTimeToGenerateFailureInHours = Double.MAX_VALUE;
}