Examples with SchedulerException org.btrplace.scheduler.SchedulerException used on opensource projects

Example 11 with SchedulerException

use of org.btrplace.scheduler.SchedulerException in project scheduler by btrplace.

the class CShareableResourceTest method testInitiallyUnsatisfied.

@Test
public void testInitiallyUnsatisfied() throws SchedulerException {
    Model mo = new DefaultModel();
    Node n1 = mo.newNode();
    Node n2 = mo.newNode();
    ShareableResource rc = new ShareableResource("cpu", 1, 1);
    VM v1 = mo.newVM();
    VM v2 = mo.newVM();
    mo.getMapping().addOnlineNode(n1);
    mo.getMapping().addOnlineNode(n2);
    mo.getMapping().addRunningVM(v1, n1);
    mo.getMapping().addRunningVM(v2, n1);
    mo.attach(rc);
    ChocoScheduler s = new DefaultChocoScheduler();
    try {
        Assert.assertNull(s.solve(mo, new ArrayList<>()));
        Assert.fail("Should have thrown an exception");
    } catch (@SuppressWarnings("unused") SchedulerException e) {
        Assert.assertEquals(s.getStatistics().getMetrics().backtracks(), 0);
    }
}

Example 12 with SchedulerException

use of org.btrplace.scheduler.SchedulerException in project scheduler by btrplace.

the class SolverTuning method run.

@Override
@SuppressWarnings("squid:S1166")
public void run() {
    // Make a default model with 500 nodes hosting 3,000 VMs
    Model model = makeModel();
    Set<SatConstraint> constraints = new HashSet<>();
    // We allow memory over-commitment with a overbooking ratio of 50%
    // i.e. 1MB physical RAM for 1.5MB virtual RAM
    constraints.addAll(Overbook.newOverbooks(model.getMapping().getAllNodes(), "mem", 1.5));
    /**
     * On 10 nodes, 4 of the 6 hosted VMs ask now for a 4GB bandwidth
     */
    for (int i = 0; i < 5; i++) {
        Node n = nodes.get(i);
        Set<VM> vmsOnN = model.getMapping().getRunningVMs(n);
        Iterator<VM> ite = vmsOnN.iterator();
        for (int j = 0; ite.hasNext() && j < 4; j++) {
            VM v = ite.next();
            constraints.add(new Preserve(v, "bandwidth", 4));
        }
    }
    ChocoScheduler cra = new DefaultChocoScheduler();
    // Customize the estimated duration of actions
    cra.getDurationEvaluators().register(MigrateVM.class, new LinearToAResourceActionDuration<VM>("mem", 1, 3));
    // We want the best possible solution, computed in up to 5 sec.
    cra.doOptimize(true);
    cra.setTimeLimit(5);
    // We solve without the repair mode
    cra.doRepair(false);
    try {
        solve(cra, model, constraints);
    } catch (@SuppressWarnings("unused") SchedulerException ex) {
    // Just in case the testing environment is not performant enough
    // It does not matter that much if there is no enough time to get a solution here
    }
    // Re-solve using the repair mode to check for the improvement
    cra.doRepair(true);
    solve(cra, model, constraints);
}

Example 13 with SchedulerException

use of org.btrplace.scheduler.SchedulerException in project scheduler by btrplace.

the class CSerializeTest method testOk.

@Test
public void testOk() throws SchedulerException {
    // New default model
    Model mo = new DefaultModel();
    Mapping ma = mo.getMapping();
    // Create and boot 2 source nodes and 1 destination node
    Node srcNode1 = mo.newNode(), srcNode2 = mo.newNode(), dstNode = mo.newNode();
    ma.addOnlineNode(srcNode1);
    ma.addOnlineNode(srcNode2);
    ma.addOnlineNode(dstNode);
    // Attach a network view
    Network net = new Network();
    mo.attach(net);
    // Connect the nodes through a main non-blocking switch
    // The destination node have twice the bandwidth of source nodes
    Switch swMain = net.newSwitch();
    net.connect(1000, swMain, srcNode1, srcNode2);
    net.connect(2000, swMain, dstNode);
    // Create and host 1 VM per source node
    VM vm1 = mo.newVM();
    VM vm2 = mo.newVM();
    ma.addRunningVM(vm1, srcNode1);
    ma.addRunningVM(vm2, srcNode2);
    // Attach CPU and Mem resource views and assign nodes capacity and VMs consumption
    int mem_vm = 8, cpu_vm = 4, mem_src = 8, cpu_src = 4, mem_dst = 16, cpu_dst = 8;
    ShareableResource rcMem = new ShareableResource("mem", 0, 0), rcCPU = new ShareableResource("cpu", 0, 0);
    mo.attach(rcMem);
    mo.attach(rcCPU);
    // VMs
    rcMem.setConsumption(vm1, mem_vm).setConsumption(vm2, mem_vm);
    rcCPU.setConsumption(vm1, cpu_vm).setConsumption(vm2, cpu_vm);
    // Nodes
    rcMem.setCapacity(srcNode1, mem_src).setCapacity(srcNode2, mem_src).setCapacity(dstNode, mem_dst);
    rcCPU.setCapacity(srcNode1, cpu_src).setCapacity(srcNode2, cpu_src).setCapacity(dstNode, cpu_dst);
    // Set VM attributes 'memory used', 'hot dirty page size', 'hot dirty page duration' and 'cold dirty pages rate'
    int vm_mu = 6000, vm_mds = 46, vm_mdd = 2;
    double vm_cdr = 23.6;
    // vm1 is an 'idle' VM (with no special memory activity) but still consumes 6 GiB of memory
    mo.getAttributes().put(vm1, "memUsed", vm_mu);
    // vm2 consumes 6 GiB memory and has a memory intensive workload equivalent to "stress --vm 1000 --bytes 50K"
    // VM with a workload
    mo.getAttributes().put(vm2, "memUsed", vm_mu);
    mo.getAttributes().put(vm2, "hotDirtySize", vm_mds);
    mo.getAttributes().put(vm2, "hotDirtyDuration", vm_mdd);
    mo.getAttributes().put(vm2, "coldDirtyRate", vm_cdr);
    // Create constraints
    List<SatConstraint> cstrs = new ArrayList<>();
    // Placement constraints, we want to shutdown the source nodes to force the migration to destination nodes
    cstrs.add(new Offline(srcNode1));
    cstrs.add(new Offline(srcNode2));
    // SERIALIZE THE TWO MIGRATIONS
    Serialize serial = new Serialize(vm1, vm2);
    cstrs.add(serial);
    // Solve it using the Min Max Time To Repair Migration scheduling oriented objective
    ReconfigurationPlan p = new DefaultChocoScheduler().solve(mo, cstrs, new MinMTTRMig());
    Assert.assertNotNull(p);
    // Check if the serialize constraint is respected
    MigrateVM mig1 = (MigrateVM) p.getActions().stream().filter(s -> s instanceof MigrateVM && ((MigrateVM) s).getVM().equals(vm1)).findAny().get();
    MigrateVM mig2 = (MigrateVM) p.getActions().stream().filter(s -> s instanceof MigrateVM && ((MigrateVM) s).getVM().equals(vm2)).findAny().get();
    Assert.assertTrue(mig1.getStart() >= mig2.getEnd() || mig2.getStart() >= mig1.getEnd());
    // TODO: use methods on SerializeChecker to verify that the actions are serialized ?
    Assert.assertTrue(serial.isSatisfied(p));
}

Example 14 with SchedulerException

use of org.btrplace.scheduler.SchedulerException in project scheduler by btrplace.

the class Bench method solve.

private static void solve(LabelledInstance i, Parameters ps) throws IOException {
    ChocoScheduler s = new DefaultChocoScheduler().setParameters(ps);
    String status = "OK";
    try {
        s.solve(i);
    } catch (@SuppressWarnings("unused") UnstatableProblemException ex) {
        status = "TO";
    } catch (@SuppressWarnings("unused") SchedulerException ex) {
        status = "FAIL";
    }
    if (opts.single()) {
        out(0, "%s%n", s.getStatistics());
    } else {
        SolvingStatistics stats = s.getStatistics();
        if (stats.getSolutions().isEmpty()) {
            status = "KO*";
        } else {
            status = "OK";
            if (stats.completed()) {
                status += "*";
            }
        }
        if (opts.verbosity() == 0) {
            out(0, "%s: %s%n", i.label, status);
        } else {
            out(1, "----- %s -----%n", i.label);
            out(1, "%s%n", stats);
            out(1, "%n");
        }
        File output = opts.output();
        store(i, stats, output);
    }
}

Example 15 with SchedulerException

use of org.btrplace.scheduler.SchedulerException in project scheduler by btrplace.

the class UCC15 method decommissioning_100gb.

public SolvingStatistics decommissioning_100gb() throws SchedulerException {
    // Set nb of nodes and vms
    int nbNodesRack = 24;
    int nbSrcNodes = nbNodesRack * 20;
    int nbDstNodes = nbNodesRack * 10;
    int nbVMs = nbSrcNodes * 2;
    // Set mem + cpu for VMs and Nodes
    int memVM = 4, cpuVM = 1;
    int memSrcNode = 16, cpuSrcNode = 4;
    int memDstNode = 16, cpuDstNode = 4;
    // Set memoryUsed and dirtyRate (for all VMs)
    int tpl1MemUsed = 2000, tpl1MaxDirtySize = 5, tpl1MaxDirtyDuration = 3;
    // idle vm
    double tpl1DirtyRate = 0;
    int tpl2MemUsed = 4000, tpl2MaxDirtySize = 96, tpl2MaxDirtyDuration = 2;
    // stress --vm 1000 --bytes 70K
    double tpl2DirtyRate = 3;
    int tpl3MemUsed = 2000, tpl3MaxDirtySize = 96, tpl3MaxDirtyDuration = 2;
    // stress --vm 1000 --bytes 70K
    double tpl3DirtyRate = 3;
    int tpl4MemUsed = 4000, tpl4MaxDirtySize = 5, tpl4MaxDirtyDuration = 3;
    // idle vm
    double tpl4DirtyRate = 0;
    // New default model
    Model mo = new DefaultModel();
    Mapping ma = mo.getMapping();
    // Create online source nodes and offline destination nodes
    List<Node> srcNodes = new ArrayList<>(), dstNodes = new ArrayList<>();
    for (int i = 0; i < nbSrcNodes; i++) {
        srcNodes.add(mo.newNode());
        ma.addOnlineNode(srcNodes.get(i));
    }
    for (int i = 0; i < nbDstNodes; i++) {
        dstNodes.add(mo.newNode());
        ma.addOfflineNode(dstNodes.get(i));
    }
    // Set boot and shutdown time
    for (Node n : dstNodes) {
        mo.getAttributes().put(n, "boot", 1);
    /*~2 minutes to boot*/
    }
    for (Node n : srcNodes) {
        mo.getAttributes().put(n, "shutdown", 1);
    /*~30 seconds to shutdown*/
    }
    // Create running VMs on src nodes
    List<VM> vms = new ArrayList<>();
    VM v;
    for (int i = 0; i < nbSrcNodes; i++) {
        if (i % 2 == 0) {
            v = mo.newVM();
            vms.add(v);
            mo.getAttributes().put(v, "memUsed", tpl1MemUsed);
            mo.getAttributes().put(v, "coldDirtyRate", tpl1DirtyRate);
            mo.getAttributes().put(v, "hotDirtySize", tpl1MaxDirtySize);
            mo.getAttributes().put(v, "hotDirtyDuration", tpl1MaxDirtyDuration);
            ma.addRunningVM(v, srcNodes.get(i));
            v = mo.newVM();
            vms.add(v);
            mo.getAttributes().put(v, "memUsed", tpl2MemUsed);
            mo.getAttributes().put(v, "coldDirtyRate", tpl2DirtyRate);
            mo.getAttributes().put(v, "hotDirtySize", tpl2MaxDirtySize);
            mo.getAttributes().put(v, "hotDirtyDuration", tpl2MaxDirtyDuration);
            ma.addRunningVM(v, srcNodes.get(i));
        } else {
            v = mo.newVM();
            vms.add(v);
            mo.getAttributes().put(v, "memUsed", tpl3MemUsed);
            mo.getAttributes().put(v, "coldDirtyRate", tpl3DirtyRate);
            mo.getAttributes().put(v, "hotDirtySize", tpl3MaxDirtySize);
            mo.getAttributes().put(v, "hotDirtyDuration", tpl3MaxDirtyDuration);
            ma.addRunningVM(v, srcNodes.get(i));
            v = mo.newVM();
            vms.add(v);
            mo.getAttributes().put(v, "memUsed", tpl4MemUsed);
            mo.getAttributes().put(v, "coldDirtyRate", tpl4DirtyRate);
            mo.getAttributes().put(v, "hotDirtySize", tpl4MaxDirtySize);
            mo.getAttributes().put(v, "hotDirtyDuration", tpl4MaxDirtyDuration);
            ma.addRunningVM(v, srcNodes.get(i));
        }
    }
    // Add resource decorators
    ShareableResource rcMem = new ShareableResource("mem", 0, 0);
    ShareableResource rcCPU = new ShareableResource("cpu", 0, 0);
    for (Node n : srcNodes) {
        rcMem.setCapacity(n, memSrcNode);
        rcCPU.setCapacity(n, cpuSrcNode);
    }
    for (Node n : dstNodes) {
        rcMem.setCapacity(n, memDstNode);
        rcCPU.setCapacity(n, cpuDstNode);
    }
    for (VM vm : vms) {
        rcMem.setConsumption(vm, memVM);
        rcCPU.setConsumption(vm, cpuVM);
    }
    // mo.attach(rcMem);
    // mo.attach(rcCPU);
    // Add a NetworkView view
    Network net = new Network();
    Switch swSrcRack1 = net.newSwitch();
    Switch swSrcRack2 = net.newSwitch();
    Switch swSrcRack3 = net.newSwitch();
    Switch swSrcRack4 = net.newSwitch();
    Switch swSrcRack5 = net.newSwitch();
    Switch swSrcRack6 = net.newSwitch();
    Switch swSrcRack7 = net.newSwitch();
    Switch swSrcRack8 = net.newSwitch();
    Switch swSrcRack9 = net.newSwitch();
    Switch swSrcRack10 = net.newSwitch();
    Switch swSrcRack11 = net.newSwitch();
    Switch swSrcRack12 = net.newSwitch();
    Switch swSrcRack13 = net.newSwitch();
    Switch swSrcRack14 = net.newSwitch();
    Switch swSrcRack15 = net.newSwitch();
    Switch swSrcRack16 = net.newSwitch();
    Switch swSrcRack17 = net.newSwitch();
    Switch swSrcRack18 = net.newSwitch();
    Switch swSrcRack19 = net.newSwitch();
    Switch swSrcRack20 = net.newSwitch();
    Switch swDstRack1 = net.newSwitch();
    Switch swDstRack2 = net.newSwitch();
    Switch swDstRack3 = net.newSwitch();
    Switch swDstRack4 = net.newSwitch();
    Switch swDstRack5 = net.newSwitch();
    Switch swDstRack6 = net.newSwitch();
    Switch swDstRack7 = net.newSwitch();
    Switch swDstRack8 = net.newSwitch();
    Switch swDstRack9 = net.newSwitch();
    Switch swDstRack10 = net.newSwitch();
    Switch swMain = net.newSwitch();
    net.connect(1000, swSrcRack1, srcNodes.subList(0, nbNodesRack));
    net.connect(1000, swSrcRack2, srcNodes.subList(nbNodesRack, nbNodesRack * 2));
    net.connect(1000, swSrcRack3, srcNodes.subList(nbNodesRack * 2, nbNodesRack * 3));
    net.connect(1000, swSrcRack4, srcNodes.subList(nbNodesRack * 3, nbNodesRack * 4));
    net.connect(1000, swSrcRack5, srcNodes.subList(nbNodesRack * 4, nbNodesRack * 5));
    net.connect(1000, swSrcRack6, srcNodes.subList(nbNodesRack * 5, nbNodesRack * 6));
    net.connect(1000, swSrcRack7, srcNodes.subList(nbNodesRack * 6, nbNodesRack * 7));
    net.connect(1000, swSrcRack8, srcNodes.subList(nbNodesRack * 7, nbNodesRack * 8));
    net.connect(1000, swSrcRack9, srcNodes.subList(nbNodesRack * 8, nbNodesRack * 9));
    net.connect(1000, swSrcRack10, srcNodes.subList(nbNodesRack * 9, nbNodesRack * 10));
    net.connect(1000, swSrcRack11, srcNodes.subList(nbNodesRack * 10, nbNodesRack * 11));
    net.connect(1000, swSrcRack12, srcNodes.subList(nbNodesRack * 11, nbNodesRack * 12));
    net.connect(1000, swSrcRack13, srcNodes.subList(nbNodesRack * 12, nbNodesRack * 13));
    net.connect(1000, swSrcRack14, srcNodes.subList(nbNodesRack * 13, nbNodesRack * 14));
    net.connect(1000, swSrcRack15, srcNodes.subList(nbNodesRack * 14, nbNodesRack * 15));
    net.connect(1000, swSrcRack16, srcNodes.subList(nbNodesRack * 15, nbNodesRack * 16));
    net.connect(1000, swSrcRack17, srcNodes.subList(nbNodesRack * 16, nbNodesRack * 17));
    net.connect(1000, swSrcRack18, srcNodes.subList(nbNodesRack * 17, nbNodesRack * 18));
    net.connect(1000, swSrcRack19, srcNodes.subList(nbNodesRack * 18, nbNodesRack * 19));
    net.connect(1000, swSrcRack20, srcNodes.subList(nbNodesRack * 19, nbNodesRack * 20));
    net.connect(1000, swDstRack1, dstNodes.subList(0, nbNodesRack));
    net.connect(1000, swDstRack2, dstNodes.subList(nbNodesRack, nbNodesRack * 2));
    net.connect(1000, swDstRack3, dstNodes.subList(nbNodesRack * 2, nbNodesRack * 3));
    net.connect(1000, swDstRack4, dstNodes.subList(nbNodesRack * 3, nbNodesRack * 4));
    net.connect(1000, swDstRack5, dstNodes.subList(nbNodesRack * 4, nbNodesRack * 5));
    net.connect(1000, swDstRack6, dstNodes.subList(nbNodesRack * 5, nbNodesRack * 6));
    net.connect(1000, swDstRack7, dstNodes.subList(nbNodesRack * 6, nbNodesRack * 7));
    net.connect(1000, swDstRack8, dstNodes.subList(nbNodesRack * 7, nbNodesRack * 8));
    net.connect(1000, swDstRack9, dstNodes.subList(nbNodesRack * 8, nbNodesRack * 9));
    net.connect(1000, swDstRack10, dstNodes.subList(nbNodesRack * 9, nbNodesRack * 10));
    net.connect(100000, swMain, swSrcRack1, swSrcRack2, swSrcRack3, swSrcRack4, swSrcRack5, swSrcRack6, swSrcRack7, swSrcRack8, swSrcRack9, swSrcRack10, swSrcRack11, swSrcRack12, swSrcRack13, swSrcRack14, swSrcRack15, swSrcRack16, swSrcRack17, swSrcRack18, swSrcRack19, swSrcRack20, swDstRack1, swDstRack2, swDstRack3, swDstRack4, swDstRack5, swDstRack6, swDstRack7, swDstRack8, swDstRack9, swDstRack10);
    mo.attach(net);
    // net.generateDot(path + "topology.dot", false);
    // Set parameters
    DefaultParameters ps = new DefaultParameters();
    ps.setVerbosity(0);
    ps.setTimeLimit(0);
    // ps.setMaxEnd(600);
    ps.doOptimize(false);
    // Migrate all VMs to destination nodes
    List<SatConstraint> cstrs = new ArrayList<>();
    int vm_num = 0;
    for (int i = 0; i < nbDstNodes; i++) {
        cstrs.add(new Fence(vms.get(vm_num), Collections.singleton(dstNodes.get(i))));
        cstrs.add(new Fence(vms.get(vm_num + 1), Collections.singleton(dstNodes.get(i))));
        cstrs.add(new Fence(vms.get(nbVMs - 1 - vm_num), Collections.singleton(dstNodes.get(i))));
        cstrs.add(new Fence(vms.get(nbVMs - 2 - vm_num), Collections.singleton(dstNodes.get(i))));
        vm_num += 2;
    }
    // Shutdown source nodes
    cstrs.addAll(srcNodes.stream().map(Offline::new).collect(Collectors.toList()));
    // Set a custom objective
    DefaultChocoScheduler sc = new DefaultChocoScheduler(ps);
    Instance i = new Instance(mo, cstrs, new MinMTTRMig());
    ReconfigurationPlan p;
    try {
        p = sc.solve(i);
        System.out.println(sc.getStatistics());
        Assert.assertNotNull(p);
    } catch (Exception e) {
        e.printStackTrace();
    }
    // finally {
    return sc.getStatistics();
// }
}