TestEnvironment.java

package mvd.jester;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.SchedulingInfo.Feasiblity;
import mvd.jester.model.DagTask;
import mvd.jester.model.SortedTaskSet;
import mvd.jester.model.SynchronousTask;
import mvd.jester.model.Task;
import mvd.jester.model.SystemSetup.DagTaskBuilder;
import mvd.jester.model.SystemSetup.SynchronousTaskBuilder;
import mvd.jester.priority.PriorityManager;
import mvd.jester.tests.AbstractTest;

/**
 * TestEnvironment
 */
public class TestEnvironment {


    public TestEnvironment() {
    }

    public <T extends Task> List<AbstractTest<T>> registerTests(final List<AbstractTest<T>> tests) {
        // Set<ResultCollector<AbstractTest<T>>> testSet = new HashSet<>();
        // for (AbstractTest<T> t : tests) {
        // testSet.add(new ResultCollector<AbstractTest<T>>(t.getPriorityManager(), t));
        // }
        return new ArrayList<>(tests);
    }


    public void runExperiments(final SynchronousTaskBuilder builder,
            final Set<ResultCollector<AbstractTest<SynchronousTask>>> abstractTestInstances,
            final long numberOfProcessors, final long numberOfTaskSets) {

        long checkedTasksets = 0;
        System.out.print(Math.round((double) checkedTasksets / numberOfTaskSets * 100) + "% of "
                + numberOfTaskSets + " tasksets tested!\r");
        while (checkedTasksets < numberOfTaskSets) {
            final Set<SynchronousTask> tasks = builder.generateTaskSet();

            double utilization = tasks.stream().mapToDouble(SynchronousTask::getUtilization).sum();

            while (utilization <= numberOfProcessors && checkedTasksets < numberOfTaskSets) {
                checkedTasksets++;

                if (checkedTasksets % 10 == 0) {
                    System.out.print(Math.round((double) checkedTasksets / numberOfTaskSets * 100)
                            + "% of " + numberOfTaskSets + " tasksets tested!\r");
                }

                for (final ResultCollector<AbstractTest<SynchronousTask>> testInstance : abstractTestInstances) {
                    final PriorityManager priorityManager = testInstance.getPriorityManager();
                    final AbstractTest<SynchronousTask> abstractTest =
                            testInstance.getAbstractValue();

                    final SortedTaskSet<SynchronousTask> sortedTaskSet =
                            new SortedTaskSet<>(priorityManager);
                    sortedTaskSet.addAll(tasks);
                    final SchedulingInfo schedulingInfo =
                            abstractTest.runSchedulabilityCheck(sortedTaskSet);
                    testInstance.addResult(schedulingInfo);
                }

                builder.addTask(tasks);

                utilization = tasks.stream().mapToDouble(SynchronousTask::getUtilization).sum();
            }
        }
        System.out.println("");
        final ResultLogger resultLogger = new ResultLogger(numberOfProcessors);

        // resultLogger.logTests(abstractTestInstances);
    }


    public void runExperiments(final DagTaskBuilder builder,
            final List<AbstractTest<DagTask>> abstractTestInstances, final long numberOfProcessors,
            final long numberOfTaskSetsPerUtil) {

        long checkedTasksets = 0;
        final long numberOfTaskSets = ((numberOfProcessors * 4) - 3) * numberOfTaskSetsPerUtil;

        final ResultLogger resultLogger = new ResultLogger(numberOfProcessors);
        final Map<AbstractTest<DagTask>, Long> resultMap = new LinkedHashMap<>();
        abstractTestInstances.forEach(t -> resultMap.put(t, (long) 0));
        for (double util = 1; util <= numberOfProcessors; util += 0.25) {
            resultMap.replaceAll((k, v) -> (long) 0);
            nextTry: for (int i = 0; i < numberOfTaskSetsPerUtil; ++i) {
                final Set<DagTask> taskSet = builder.generateTaskSet(util);

                System.out.print(Math.round((double) checkedTasksets / numberOfTaskSets * 100)
                        + "% of " + numberOfTaskSets + " tasksets tested!\r");
                for (final AbstractTest<DagTask> testInstance : abstractTestInstances) {
                    final PriorityManager priorityManager = testInstance.getPriorityManager();

                    final SortedTaskSet<DagTask> sortedTaskSet =
                            new SortedTaskSet<>(priorityManager);
                    sortedTaskSet.addAll(taskSet);
                    final SchedulingInfo schedulingInfo;
                    try {
                        schedulingInfo = testInstance.runSchedulabilityCheck(sortedTaskSet);
                    } catch (Exception e) {
                        i--;
                        continue nextTry;
                        // TODO: remove this exception
                    }

                    if (schedulingInfo.getFeasibility() == Feasiblity.SUCCEEDED) {
                        resultMap.computeIfPresent(testInstance, (k, v) -> v + 1);
                    }
                }
                checkedTasksets++;
            }
            resultLogger.logLine(util, resultMap);
            resultLogger.newLine();
        }
        System.out.println("");
        resultLogger.finalize();
    }
}