CloudSim Broker Policy Implementation

In CloudSim, the DatacenterBroker plays a central role in managing the interactions between users’ tasks (cloudlets) and the resources (VMs) in a cloud environment.

The broker policy defines how cloudlets are allocated to virtual machines (VMs) and how the available resources are distributed.

Understanding how to implement and customize broker policies in CloudSim is key to simulating cloud environments effectively.

What is a CloudSim Broker?

The DatacenterBroker (often called simply broker) is responsible for:

1. Submitting cloudlets (tasks) to virtual machines (VMs) for execution.
2. Managing resource allocation based on user requirements.
3. Handling task scheduling, migration, and load balancing.
4. Optimizing resource utilization by distributing cloudlets across VMs efficiently.

The broker policy determines the logic behind scheduling cloudlets on VMs and executing tasks within a cloud infrastructure.

Depending on the type of research or simulation, you can modify or extend the broker’s behavior.

Default CloudSim Broker Policy

By default, CloudSim provides a basic implementation of the DatacenterBroker class that uses a simple First-Come-First-Served (FCFS) approach for scheduling tasks.

It assigns the cloudlets to VMs in the order they are submitted without taking other factors into account, such as workload distribution, performance, or energy efficiency.

However, CloudSim allows you to implement custom broker policies to meet specific requirements, such as load balancing, dynamic task scheduling, and energy efficiency.

Key Responsibilities of DatacenterBroker

1. VM Provisioning:

The broker provisions the VMs by selecting appropriate data centers and hosts to place the VMs, ensuring efficient resource allocation and workload distribution.

public void submitVmList(List<Vm> list) {
    getVmsCreatedList().addAll(list);
}

In CloudSim, data centers consist of multiple hosts, each with varying capacities of CPU, memory, storage, and bandwidth. When provisioning VMs, the broker evaluates the available resources in these hosts and selects the most suitable ones based on the simulation’s requirements.

2. Cloudlet Submission:

The broker submits the cloudlets (tasks) to the appropriate VMs for processing. CloudSim assigns cloudlets based on the predefined policy (e.g., first-fit, round-robin).

public void submitCloudletList(List<Cloudlet> list) {
    getCloudletList().addAll(list);
}

3. Task Scheduling:

CloudSim’s default policy assigns cloudlets to VMs as they arrive. The broker allocates tasks to available VMs, but this can be modified for more complex scheduling algorithms.

public void processCloudletSubmit(CloudSimEvent ev, boolean ack) {
    cloudlet = (Cloudlet) ev.getData();
    int vmId = getVmIdForCloudlet(cloudlet); // You can customize how the VM is selected
    sendNow(datacenterId, CloudSimTags.CLOUDLET_SUBMIT, cloudlet);
}

4. VM and Task Monitoring:

The broker monitors the status of each VM and cloudlet. When a task finishes, it is returned to the broker for processing, and results are collected.

public void processCloudletReturn(CloudSimEvent ev) {
    Cloudlet cloudlet = (Cloudlet) ev.getData();
    getCloudletReceivedList().add(cloudlet);
}

Implementing Custom Broker Policies in CloudSim

To customize broker behaviour, you can extend the DatacenterBroker class and implement custom scheduling or allocation policies.

Here are some standard broker policies you might want to implement:

1. Load Balancing Policy:

Distribute cloudlets evenly across VMs to avoid overloading any single VM. The broker ensures that VMs receive cloudlets based on their load (number of tasks running).

Example: In a round-robin policy, cloudlets are assigned to VMs in a cyclic order to ensure a balanced distribution.

public int getVmIdForCloudlet(Cloudlet cloudlet) {
    int vmIndex = (cloudlet.getCloudletId() % getVmList().size());  // Round-robin selection
    return getVmList().get(vmIndex).getId();
}

2. Energy-Efficient Scheduling Policy:

This policy aims to minimize energy consumption by dynamically assigning cloudlets to VMs based on energy usage.

The broker can migrate cloudlets to more energy-efficient VMs or consolidate VMs to reduce energy consumption.

Example: Assign cloudlets to VMs based on energy usage. Lower energy-consuming VMs are prioritized for cloudlet assignment.

public int getEnergyEfficientVm(Cloudlet cloudlet) {
    int bestVmId = -1;
    double minEnergy = Double.MAX_VALUE;
    for (Vm vm : getVmList()) {
        double energy = calculateEnergyConsumption(vm);
        if (energy < minEnergy) {
            minEnergy = energy;
            bestVmId = vm.getId();
        }
    }
    return bestVmId;
}

3. Priority-Based Scheduling:

You can implement a priority-based policy where specific tasks (cloudlets) are given higher priority based on user requirements.

For instance, urgent or critical tasks might be executed immediately, while lower-priority tasks are queued.

Example: Assign cloudlets with higher priority to VMs first, based on priority level.

public int getVmForHighPriorityCloudlet(Cloudlet cloudlet) {
    if (cloudlet.getPriority() == Cloudlet.HIGH_PRIORITY) {
        // Assign to a VM with higher resources
        return getVmWithHighestCapacity();
    } else {
        return getVmWithLowestLoad();
    }
}

4. Dynamic Resource Allocation:

In dynamic resource allocation, VMs can be created or destroyed dynamically based on the workload.

If the demand increases, the broker can allocate more VMs; if the demand drops, it can deallocate VMs to save resources.

Example: Create new VMs when cloudlet demand exceeds available resources.

public void dynamicallyAllocateVms() {
    if (getCloudletList().size() > getVmList().size()) {
        Vm newVm = createNewVm(); // Method to create a new VM
        getVmList().add(newVm);
    }
}

How to Extend the DatacenterBroker in CloudSim

To implement a custom broker policy in CloudSim, you need to extend the DatacenterBroker class and override the methods that handle cloudlet submission and task allocation.

public class CustomDatacenterBroker extends DatacenterBroker {

    public CustomDatacenterBroker(String name) throws Exception {
        super(name);
    }

    // Override the method to implement a custom cloudlet-to-VM assignment strategy
    @Override
    protected void processCloudletSubmit(SimEvent ev, boolean ack) {
        Cloudlet cloudlet = (Cloudlet) ev.getData();
        int vmId = selectVmForCloudlet(cloudlet); // Implement custom policy
        sendNow(getDatacenterId(), CloudSimTags.CLOUDLET_SUBMIT, cloudlet);
    }

    // Custom method for selecting a VM based on specific criteria
    protected int selectVmForCloudlet(Cloudlet cloudlet) {
        // Custom VM selection logic (e.g., round-robin, load balancing, etc.)
        return getVmList().get(cloudlet.getCloudletId() % getVmList().size()).getId();
    }
}

In the code snippet above:

• The processCloudletSubmit method is overridden to define how cloudlets are submitted to VMs.
• The selectVmForCloudlet method can be customized to implement your own broker policy for task scheduling.

For more understanding on the datacenterbroker, you may watch this webinar(very long duration):

Conclusion

Implementing a custom broker policy in CloudSim lets you control how cloudlets (tasks) are allocated to VMs and how resources are managed in your simulated cloud environment.

By extending the DatacenterBroker class, you can introduce policies for load balancing, energy efficiency, priority scheduling, and dynamic resource allocation to simulate various scenarios and optimize cloud infrastructure management.

Also, Feel free to join our learners community through an online self-paced course named “Essential Cloudsim Tutorials”. Look forward to connect with over there!