JiangYi.java

package mvd.jester.tests;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.SchedulingInfo.Feasiblity;
import mvd.jester.model.ContainerTask;
import mvd.jester.model.DagTask;
import mvd.jester.model.SortedTaskSet;
import mvd.jester.model.SystemManagerInterface;
import mvd.jester.model.Task;
import mvd.jester.priority.EarliestDeadlineFirst;
import mvd.jester.priority.PriorityManager;

public class JiangYi extends AbstractTest<DagTask> {

    private final EarliestDeadlineFirst priorityManager;

    public JiangYi(SystemManagerInterface manager) {
        super(manager);
        this.priorityManager = new EarliestDeadlineFirst();
    }



    @Override
    public SchedulingInfo runSchedulabilityCheck(SortedTaskSet<DagTask> tasks) {
        Set<DagTask> heavyTasks = new HashSet<>();
        Set<Task> lightTasks = new HashSet<>();

        for (DagTask t : tasks) {
            if (t.getDensity() < 1) {
                lightTasks.add(t);
            } else {
                heavyTasks.add(t);
            }
        }

        long remainingProcessors = manager.getNumberOfProcessors();

        for (DagTask t : heavyTasks) {
            double processingCapacity = ((double) t.getWorkload() - t.getCriticalPath())
                    / (t.getDeadline() - t.getCriticalPath());
            long minimumProcessingCapacity = (long) Math.floor(processingCapacity);
            if (remainingProcessors < minimumProcessingCapacity) {
                return new SchedulingInfo(Feasiblity.FAILED);
            }
            remainingProcessors -= minimumProcessingCapacity;

            double loadBound = processingCapacity - minimumProcessingCapacity;

            lightTasks.add(new ContainerTask(t.getPeriod(), t.getDeadline(), loadBound));
        }

        return scheduleLightTasks(lightTasks, remainingProcessors);
    }

    private SchedulingInfo scheduleLightTasks(Set<Task> tasks, long numberOfprocessors) {
        if (numberOfprocessors == 0 && tasks.size() > 0) {
            return new SchedulingInfo(Feasiblity.FAILED);
        }
        List<Task> taskList = new LinkedList<>(tasks);
        Collections.sort(taskList, (a, b) -> Double.compare(b.getDensity(), a.getDensity()));
        List<Double> bins = new ArrayList<>();

        for (int i = 0; i < numberOfprocessors; ++i) {
            bins.add((double) 0);
        }

        Iterator<Task> taskIterator = taskList.iterator();
        while (taskIterator.hasNext()) {
            Collections.sort(bins);
            Task t = taskIterator.next();
            taskIterator.remove();
            if (bins.get(0) + t.getDensity() <= 1) {
                bins.set(0, bins.get(0) + t.getDensity());
            } else {
                return new SchedulingInfo(Feasiblity.FAILED);
            }

        }

        return new SchedulingInfo(Feasiblity.SUCCEEDED);
    }


    @Override
    public PriorityManager getPriorityManager() {
        return priorityManager;
    }

    @Override
    public String getName() {
        return "JiangYi";
    }

}