Getting Started with VMPlaceS

This "Getting Started" guide will cover the following points:

Installation of VMPlaceS' dependencies
Installation of VMPlaceS
Creation of a Simulation Resolver
Creation of a Reconfiguration Planner
Running a simulation

I- Installation of VMPlaceS' dependencies

Before installing VMPlaceS, we need to install some dependencies:

Python
SBT
Simgrid

These dependencies can easily be installed by using a package manager. We provides instructions for brew and APT.

A- via brew (macos)

brew install simgrid sbt@1

B- via APT (linux)

echo "deb https://dl.bintray.com/sbt/debian /" | sudo tee -a /etc/apt/sources.list.d/sbt.list
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2EE0EA64E40A89B84B2DF73499E82A75642AC823
sudo apt-get update
apt-get install -y simgrid python sbt

II- Installation of VMPlaceS

First, clone the git repository of VMPlaceS:

git clone https://github.com/BeyondTheClouds/VMPlaceS.git

Then, browse in the VMPlaceS folder and run those two commands in order to build a java jar archive of VMPlaceS:

sbt update
sbt assembly

To validate the installation of VMPlaceS and its dependencies, run the following command:

bash run_example.sh

A simulation (based on a simple scheduling algorithm implemented in VMPlaceS) should start and simulate the functioning of a small cloud infrastructure during 1800s.

III- Implementing a new scheduling algorithm in VMPlaceS

A- Creation of a Simulation Resolver

Create a new java file located in src/main/java/simulation/ExampleResolver.java with the following content :

package simulation;

import org.simgrid.msg.Host;
import org.simgrid.msg.HostNotFoundException;
import org.simgrid.msg.MsgException;
import org.simgrid.msg.Process;
import scheduling.Scheduler;
import scheduling.example.ExampleReconfigurationPlanner;

public class ExampleResolver extends Process {

    private ExampleReconfigurationPlanner planner = new ExampleReconfigurationPlanner();

    ExampleResolver(Host host, String name, String[] args) throws HostNotFoundException {
        super(host, name, args);
    }

    public void main(String[] args) throws MsgException {
        while (!SimulatorManager.isEndOfInjection()) {
            System.out.println("Checking");

            Scheduler.ComputingResult configurationResult = planner.computeReconfigurationPlan();

            if (configurationResult.state != Scheduler.ComputingResult.State.NO_RECONFIGURATION_NEEDED) {
                planner.applyReconfigurationPlan();
            }

            waitFor(30);
        }
    }
}

B- Creation of a Reconfiguration Planner

Create a new java file located in src/main/java/scheduling/example/ExampleReconfigurationPlanner.java with the following content :

package scheduling.example;

import configuration.XHost;
import configuration.XVM;
import migration.MigrationPlan;
import scheduling.AbstractScheduler;
import simulation.SimulatorManager;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ExampleReconfigurationPlanner extends AbstractScheduler {

    private ComputingResult lastComputingResult = null;
    private List<MigrationPlan> migrationsPlans = new ArrayList<MigrationPlan>();

    public ComputingResult computeReconfigurationPlan(){
        ComputingResult result = new ComputingResult();
        lastComputingResult = result;

        Collection<XHost> hosts = SimulatorManager.getSGHostingHosts();
        List<XHost> overloadedHosts = new ArrayList<>();
        List<XHost> underloadedHosts = new ArrayList<>();

        // Find the overloaded hosts
        for(XHost host : hosts) {
            double demand = host.computeCPUDemand();
            if (host.getCPUCapacity() < demand)
                overloadedHosts.add(host);
            else if(demand < 0.5 * host.getCPUCapacity()) {
                underloadedHosts.add(host);
            }
        }

        if (underloadedHosts.size() > 0) {
            // Migrate some VMs from overloaded hosts to underloaded hosts
            int index = 0;
            for (XHost overloadedHost : overloadedHosts) {
                // Prepare a future migration
                MigrationPlan migrationPlan = new MigrationPlan();
                // Pick an underloaded host
                XHost underloadedHost = underloadedHosts.get(index % underloadedHosts.size());
                // Pick a VM
                XVM vm = overloadedHost.getVMs().iterator().next();
                migrationPlan.origin = overloadedHost;
                migrationPlan.destination = underloadedHost;
                migrationPlan.vm = vm;
                // Add the migration order to order
                migrationsPlans.add(migrationPlan);
                index += 1;
            }
        }

        return result;
    }

    public void applyReconfigurationPlan() {
        System.out.println("Applying reconfiguration plan");
        // For each migration decided by the "computeReconfigurationPlan",
        // the migration will be started in the following block
        for(MigrationPlan migrationPlan: this.migrationsPlans) {
            // Check if the destination node is turned off. If it is
            // the case, the destination node is turned on
            if(migrationPlan.destination.isOff())
                SimulatorManager.turnOn(migrationPlan.destination);

            relocateVM(migrationPlan.vm.getName(),
                       migrationPlan.origin.getName(),
                       migrationPlan.destination.getName());
        }
        // Reset the count of migrations
        this.migrationsPlans = new ArrayList<MigrationPlan>();
    }
}

C- Creating a deployment file

Add the following lines in the "algorithms" section of the config/algorithms.json file:

<?xml version='1.0'?>
    <!DOCTYPE platform SYSTEM "http://simgrid.gforge.inria.fr/simgrid/simgrid.dtd">
    <platform version="4">
    <process host="node{{ nb_hosts + 1 }}" function="injector.Injector"> </process>
    <process host="node{{ nb_hosts }}" function="simulation.ExampleResolver"> </process>
</platform>

D- Adding the algorithms to VMPlaceS

Add the following lines in the "algorithms" section of the config/algorithms.json file:

"example": {
  "resolver": "simulation.ExampleResolver",
  "scheduling_algorithm": [
    "scheduling.example.ExampleReconfigurationPlanner"
  ],
  "can_select_scheduling_algorithm": false,
  "deploy_xml_template": "templates/example.xml"
}

IV- Run a simulation

A- Command line

sbt assembly
java -Xmx4G -d64 -cp target/simulation.jar simulation.SimpleMain --algo=example --duration 1800 --nb_hosts=10 --nb_vms=93 --load_mean=60.0

B - IntelliJ Idea (IDE)

Step 1 and 2: Launch the simulation and stop it immediately

Step 3 and 4: Customize the simulation executable

Step 5: Enter the parameters of the simulation

Step 6: Validate the configuration

Step 7: Run the simulation again