How to Categorize and Analyze Cloudlets Based on Computational Length in Containercloudsim to Improve Task Allocation and Performance Analysis?
Share
Condition for Categorize and Analyze Cloudlets Based on Computational Length in Containercloudsim
Description: This project presents a cloudlet categorization and performance analysis model for container-based cloud computing using ContainerCloudSim. The objective is to classify cloudlets (tasks) based on their computational length—Short, Medium, Long, and Very Long—and evaluate how these categories influence resource utilization, task execution time, and completion efficiency.The simulation creates a data center with multiple hosts, virtual machines (VMs), and containers, managed through energy-aware allocation and scheduling policies. Each cloudlet’s length (in Million Instructions - MI) determines its category, which enables systematic workload characterization. The system then computes and displays category-wise performance statistics, such as execution time, completion rate, and percentage contribution to the total workload.By integrating task categorization with container-based scheduling, the model demonstrates how differentiated workloads can be analyzed to achieve better task management, balanced resource allocation, and improved Quality of Service (QoS) in cloud environments. This approach provides valuable insights into optimizing scheduling algorithms for diverse cloud workloads.
/**
* A simple example showing how to create a data center with one host, one VM,
* one container and run one cloudlet on it.
* Enhanced with Cloudlet Categorization by Length feature.
*/
public class CloudletCategorization {
/**
* 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;
/**
* Cloudlet categories based on length
*/
private static enum CloudletCategory {
SHORT("Short", 0, 10000), // 0-10,000 MI
MEDIUM("Medium", 10001, 30000), // 10,001-30,000 MI
LONG("Long", 30001, 100000), // 30,001-100,000 MI
VERY_LONG("Very Long", 100001, Long.MAX_VALUE); // 100,001+ MI
private final String name;
private final long minLength;
private final long maxLength;
CloudletCategory(String name, long minLength, long maxLength) {
this.name = name;
this.minLength = minLength;
this.maxLength = maxLength;
}
public String getName() { return name; }
public long getMinLength() { return minLength; }
public long getMaxLength() { return maxLength; }
public static CloudletCategory getCategory(long cloudletLength) {
for (CloudletCategory category : values()) {
if (cloudletLength >= category.minLength && cloudletLength <= category.maxLength) {
return category;
}
}
return VERY_LONG;
}
}
/**
* Creates main() to run this example.
*
* @param args the args
*/
public static void main(String[] args) {
Log.printLine("Starting ContainerCloudSim with Cloudlet Categorization...");
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);
// Print top 5 longest cloudlets in this category
if (!cloudlets.isEmpty()) {
Log.printLine("\nTop 5 Longest Cloudlets in " + category.getName() + " category:");
List sorted = new ArrayList<>(cloudlets);
sorted.sort((c1, c2) -> Long.compare(c2.getCloudletLength(), c1.getCloudletLength()));
int limit = Math.min(5, sorted.size());
for (int i = 0; i < limit; i++) {
ContainerCloudlet cloudlet = sorted.get(i);
Log.printLine(" Cloudlet " + cloudlet.getCloudletId() +
": " + df.format(cloudlet.getCloudletLength()) + " MI" +
(cloudlet.getCloudletStatusString().equals("Success") ?
" (Completed in " + df.format(cloudlet.getActualCPUTime()) + "s)" : " (Not completed)"));
}
}
}
/**
* 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 < ConstantsExamples.VM_PES[vmType]; ++j) {
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 ContainerSchedulerTimeSharedOverSubscription(peList),
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);
/**
* Creating the cloudlet list that are going to run on containers
* Enhanced to create cloudlets with varying lengths for categorization
*
* @param brokerId
* @param numberOfCloudlets
* @return
* @throws FileNotFoundException
*/
public static List createContainerCloudletList(int brokerId, int numberOfCloudlets)
throws FileNotFoundException {
String inputFolderName = "/home/soft13/soft13/Project 2019/Cloudsim-4.0-examples/src/workload/planetlab";
ArrayList cloudletList = new ArrayList();
long fileSize = 300L;
long outputSize = 300L;
UtilizationModelNull utilizationModelNull = new UtilizationModelNull();
// Create cloudlets with varying lengths for better categorization demonstration
Random random = new Random();
int createdCloudlets = 0;
// Try to use PlanetLab workload files if available
java.io.File inputFolder1 = new java.io.File(inputFolderName);
if (inputFolder1.exists() && inputFolder1.listFiles() != null) {
java.io.File[] files1 = inputFolder1.listFiles();
for (java.io.File aFiles1 : files1) {
java.io.File inputFolder = new java.io.File(aFiles1.toString());
java.io.File[] files = inputFolder.listFiles();
if (files != null) {
for (int i = 0; i < files.length; ++i) {
if (createdCloudlets < numberOfCloudlets) {
ContainerCloudlet cloudlet = null;
try {
// Vary cloudlet lengths for categorization
long variedLength = ConstantsExamples.CLOUDLET_LENGTH +
(random.nextInt(5) * 10000); // Add 0-40k variation
cloudlet = new ContainerCloudlet(IDs.pollId(ContainerCloudlet.class),
variedLength, 1,
fileSize, outputSize,
new UtilizationModelPlanetLabInMemoryExtended(files[i].getAbsolutePath(), 300.0D),
utilizationModelNull, utilizationModelNull);
} catch (Exception var13) {
var13.printStackTrace();
// Fallback to simple cloudlet creation
cloudlet = createSimpleCloudlet(IDs.pollId(ContainerCloudlet.class), brokerId);
}
// If not enough cloudlets created from files, create simple ones
while (createdCloudlets < numberOfCloudlets) {
ContainerCloudlet cloudlet = createSimpleCloudlet(IDs.pollId(ContainerCloudlet.class), brokerId);
cloudletList.add(cloudlet);
createdCloudlets += 1;
}
return cloudletList;
}
/**
* Creates a simple cloudlet with random length for categorization demonstration
*/
private static ContainerCloudlet createSimpleCloudlet(int cloudletId, int brokerId) {
Random random = new Random();
// Create cloudlets with lengths that will fall into different categories
long[] possibleLengths = {5000, 15000, 25000, 50000, 150000}; // Cover all categories
long length = possibleLengths[random.nextInt(possibleLengths.length)];
ContainerCloudlet cloudlet = new ContainerCloudlet(cloudletId, length, 1,
300L, 300L, new UtilizationModelNull(),
new UtilizationModelNull(), new UtilizationModelNull());
cloudlet.setUserId(brokerId);
return cloudlet;
}
/**
* Additional method: Categorize and assign cloudlets to appropriate VMs based on length
*/
public static void assignCloudletsByCategory(List cloudlets,
List vms,
List containers) {
Log.printLine("\n=== Category-Based Cloudlet Assignment ===");
// Group cloudlets by category
Map> cloudletsByCategory = new HashMap<>();
for (CloudletCategory category : CloudletCategory.values()) {
cloudletsByCategory.put(category, new ArrayList<>());
}
/**
* Returns assignment strategy description for each category
*/
private static String getAssignmentStrategy(CloudletCategory category) {
switch (category) {
case SHORT:
return "Assign to any available VM (low priority)";
case MEDIUM:
return "Assign to balanced VMs (medium priority)";
case LONG:
return "Assign to high-performance VMs (high priority)";
case VERY_LONG:
return "Assign to dedicated high-performance VMs (highest priority)";
default:
return "Standard assignment";
}
}
}
Research Breakthrough Possible @S-Logix
