How to implement Round Robin Scheduling Algorithm in ContainerCloudSim?
Share
Condition for Round Robin Scheduling Algorithm in ContainerCloudSim
Description: To develop a new ContainerSchedulerRoundRobin extends ContainerScheduler and implements a time-sliced allocation strategy. The core logic involves maintaining a list of active containers and cycling through them in a circular order, allocating the CPU to each container for a fixed time quantum (e.g., 100 ms) before preempting it and moving to the next, which ensures fair resource distribution among all containers and prevents any single container from monopolizing the processor.
This approach differs from your FCFS model by introducing time-based preemption, requiring you to override methods like updateContainerAllocation to manage the scheduling queue and handle context switching between containers at each time slice interval.
/**
* A simple example showing how to create a data center with one host, one VM,
* one container and run one cloudlet on it.
*/
public class ContainerCloudSim {
/**
* The cloudlet list.
*/
private static List cloudletList;
/**
* The vmlist.
*/
private static List vmList;
/**
* The vmlist.
*/
private static List containerList;
/**
* The hostList.
*/
private static List hostList;
/**
* Creates main() to run this example.
*
* @param args the args
*/
public static void main(String[] args) {
Log.printLine("Starting ContainerCloudSimExample1...");
try {
/**
* number of cloud Users
*/
int num_user = 1;
/**
* The fields of calender have been initialized with the current
* date and time.
*/
Calendar calendar = Calendar.getInstance();
/**
* Deactivating the event tracing
*/
boolean trace_flag = false;
/**
* 1- Like CloudSim the first step is initializing the CloudSim
* Package before creating any entities.
*
*/
CloudSim.init(num_user, calendar, trace_flag);
/**
* 2- Defining the container allocation Policy. This policy
* determines how Containers are allocated to VMs in the data
* center.
*
*/
ContainerAllocationPolicy containerAllocationPolicy = new PowerContainerAllocationPolicySimple();
/**
* 3- Defining the VM selection Policy. This policy determines which
* VMs should be selected for migration when a host is identified as
* over-loaded.
*
*/
PowerContainerVmSelectionPolicy vmSelectionPolicy = new PowerContainerVmSelectionPolicyMaximumUsage();
/**
* 4- Defining the host selection Policy. This policy determines
* which hosts should be selected as migration destination.
*
*/
HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();
/**
* 5- Defining the thresholds for selecting the under-utilized and
* over-utilized hosts.
*/
double overUtilizationThreshold = 0.80;
double underUtilizationThreshold = 0.70;
/**
* 6- The host list is created considering the number of hosts, and
* host types which are specified in the {@link ConstantsExamples}.
*/
hostList = new ArrayList();
hostList = createHostList(ConstantsExamples.NUMBER_HOSTS);
cloudletList = new ArrayList();
vmList = new ArrayList();
/**
* 7- The container allocation policy which defines the allocation
* of VMs to containers.
*/
ContainerVmAllocationPolicy vmAllocationPolicy = new PowerContainerVmAllocationPolicyMigrationAbstractHostSelection(hostList, vmSelectionPolicy,
hostSelectionPolicy, overUtilizationThreshold, underUtilizationThreshold);
/**
* 8- The overbooking factor for allocating containers to VMs. This
* factor is used by the broker for the allocation process.
*/
int overBookingFactor = 80;
ContainerDatacenterBroker broker = createBroker(overBookingFactor);
int brokerId = broker.getId();
/**
* 9- Creating the cloudlet, container and VM lists for submitting
* to the broker.
*/
cloudletList = createContainerCloudletList(brokerId, ConstantsExamples.NUMBER_CLOUDLETS);
containerList = createContainerList(brokerId, ConstantsExamples.NUMBER_CLOUDLETS);
vmList = createVmList(brokerId, ConstantsExamples.NUMBER_VMS);
/**
* 10- The address for logging the statistics of the VMs, containers
* in the data center.
*/
String logAddress = "~/Results";
/**
* 11- Submitting the cloudlet's , container's , and VM's lists to
* the broker.
*/
broker.submitCloudletList(cloudletList.subList(0, containerList.size()));
broker.submitContainerList(containerList);
broker.submitVmList(vmList);
/**
* 12- Determining the simulation termination time according to the
* cloudlet's workload.
*/
CloudSim.terminateSimulation(86400.00);
/**
* 13- Starting the simualtion.
*/
CloudSim.startSimulation();
/**
* 14- Stopping the simualtion.
*/
CloudSim.stopSimulation();
/**
* 15- Printing the results when the simulation is finished.
*/
List newList = broker.getCloudletReceivedList();
printCloudletList(newList);
/**
* It creates a specific name for the experiment which is used for creating
* the Log address folder.
*/
private static String getExperimentName(String... args) {
StringBuilder experimentName = new StringBuilder();
for (int i = 0; i < args.length; ++i) {
if (!args[i].isEmpty()) {
if (i != 0) {
experimentName.append("_");
}
/**
* Prints the Cloudlet objects.
*
* @param list list of Cloudlets
*/
private static void printCloudletList(List list) {
int size = list.size();
ContainerCloudlet cloudlet;
/**
* Create the Virtual machines and add them to the list
*
* @param brokerId
* @param containerVmsNumber
*/
private static ArrayList createVmList(int brokerId, int containerVmsNumber) {
ArrayList containerVms = new ArrayList();
for (int i = 0; i < containerVmsNumber; ++i) {
ArrayList peList = new ArrayList();
int vmType = i / (int) Math.ceil((double) containerVmsNumber / 4.0D);
for (int j = 0; j < 5; ++j) {// 5 = No of PEs
peList.add(new ContainerPe(j, new ContainerPeProvisionerSimple((double) ConstantsExamples.VM_MIPS[vmType])));
}
containerVms.add(new PowerContainerVm(IDs.pollId(ContainerVm.class), brokerId,
(double) ConstantsExamples.VM_MIPS[vmType], (float) ConstantsExamples.VM_RAM[vmType],
ConstantsExamples.VM_BW, ConstantsExamples.VM_SIZE, "Xen",
new ContainerSchedulerRoundRobin(peList, 5),
new ContainerRamProvisionerSimple(ConstantsExamples.VM_RAM[vmType]),
new ContainerBwProvisionerSimple(ConstantsExamples.VM_BW),
peList, ConstantsExamples.SCHEDULING_INTERVAL));
}
return containerVms;
}
/**
* Create the host list considering the specs listed in the
* {@link ConstantsExamples}.
*
* @param hostsNumber
* @return
*/
public static List createHostList(int hostsNumber) {
ArrayList hostList = new ArrayList();
for (int i = 0; i < hostsNumber; ++i) {
int hostType = i / (int) Math.ceil((double) hostsNumber / 3.0D);
ArrayList peList = new ArrayList();
for (int j = 0; j < ConstantsExamples.HOST_PES[hostType]; ++j) {
peList.add(new ContainerVmPe(j,
new ContainerVmPeProvisionerSimple((double) ConstantsExamples.HOST_MIPS[hostType])));
}
hostList.add(new PowerContainerHostUtilizationHistory(IDs.pollId(ContainerHost.class),
new ContainerVmRamProvisionerSimple(ConstantsExamples.HOST_RAM[hostType]),
new ContainerVmBwProvisionerSimple(1000000L), 1000000L, peList,
new ContainerVmSchedulerTimeSharedOverSubscription(peList),
ConstantsExamples.HOST_POWER[hostType]));
}
/**
* create the containers for hosting the cloudlets and binding them
* together.
*
* @param brokerId
* @param containersNumber
* @return
*/
public static List createContainerList(int brokerId, int containersNumber) {
ArrayList containers = new ArrayList();
for (int i = 0; i < containersNumber; ++i) {
int containerType = i / (int) Math.ceil((double) containersNumber / 3.0D);
2. SourceCode2:
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
package RoundRobin;
public class ContainerSchedulerRoundRobin extends ContainerScheduler {
// A list to keep track of all containers for round-robin scheduling
private List containerList;
// Index to track the last scheduled container
private int currentContainerIndex;
// The fixed time quantum for each container
private double timeQuantum;
@Override
public boolean allocatePesForContainer(Container container, List mipsShare) {
// Add the container to the list if it's not already present
if (!containerList.contains(container)) {
containerList.add(container);
Log.printLine("Round Robin: Added Container ID " + container.getId() + " to the scheduler.");
}
// The actual round-robin logic would typically be in a method that updates allocations over time.
if (getPeCapacity() < mipsShare.size()) {
Log.printLine("Round Robin: Not enough PE capacity. Needed: " + mipsShare.size() + ", Available: " + getPeCapacity());
return false;
}
if (container.getContainerPeAllocation() == null) {
List allocatedPes = new ArrayList<>();
for (int i = 0; i < mipsShare.size(); i++) {
ContainerPe pe = getPeList().get(i);
allocatedPes.add(pe);
}
container.setContainerPeAllocation(allocatedPes);
getMipsMap().put(container.getUid(), mipsShare);
getPeMap().put(container.getUid(), allocatedPes);
Log.printLine("Round Robin: Initially allocated " + mipsShare.size() + " PEs to Container ID " + container.getId());
}
return true;
}
// This method would be called by the simulation core to update allocations per time quantum.
public void updateContainerAllocation() {
if (containerList.isEmpty()) {
return;
}
// Get the next container in a circular manner
currentContainerIndex = (currentContainerIndex + 1) % containerList.size();
Container containerToRun = containerList.get(currentContainerIndex);
Log.printLine("Round Robin: Time slot allocated to Container ID " + containerToRun.getId());
// Here, you would implement the logic to:
// 1. Potentially deallocate the previously running container if its quantum expired.
// 2. Ensure the 'containerToRun' is set as the currently active one.
// The exact implementation depends on the ContainerCloudSim internal methods.
}
@Override
public void deallocatePesForContainer(Container container) {
if (container != null) {
Log.printLine("Round Robin: Deallocating PEs for Container ID " + container.getId());
container.setCurrentAllocatedMips(null);
getMipsMap().remove(container.getUid());
getPeMap().remove(container.getUid());
containerList.remove(container); // Also remove from the round-robin list
}
}
}
Research Breakthrough Possible @S-Logix
