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 java.util.Map.Entry;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import com.google.common.base.Stopwatch;
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.SystemManager;
import mvd.jester.model.Task;
import mvd.jester.model.SystemManager.DagTaskBuilder;
import mvd.jester.model.SystemManager.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) {
        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 measureExecutionTimes(final DagTaskBuilder builder,
            final List<AbstractTest<DagTask>> abstractTestInstances,
            final long numberOfMeasurements) {
        Map<AbstractTest<DagTask>, List<Long>> results = new LinkedHashMap<>();
        abstractTestInstances.forEach(t -> results.put(t, new ArrayList<>()));
        for (int i = 0; i < numberOfMeasurements; ++i) {
            double utilization = ThreadLocalRandom.current().nextDouble(1, 7);
            Set<DagTask> taskSet = builder.generateTaskSet(utilization);
            for (AbstractTest<DagTask> testInstance : abstractTestInstances) {
                final PriorityManager priorityManager = testInstance.getPriorityManager();

                final SortedTaskSet<DagTask> sortedTaskSet = new SortedTaskSet<>(priorityManager);
                sortedTaskSet.addAll(taskSet);
                Stopwatch w = Stopwatch.createStarted();
                testInstance.runSchedulabilityCheck(sortedTaskSet);
                w.stop();
                long micros = w.elapsed(TimeUnit.MICROSECONDS);
                results.get(testInstance).add(micros);
            }
        }

        for (Entry<AbstractTest<DagTask>, List<Long>> entry : results.entrySet()) {
            long size = entry.getValue().size();
            long total = entry.getValue().stream().reduce((long) 0, Long::sum);
            System.out.println(entry.getKey().getName() + ": " + (double) total / size + " µs");
        }

    }

    public void varyNumberOfProcessors(final DagTaskBuilder builder,
            final List<AbstractTest<DagTask>> abstractTestInstances, SystemManager manager,
            final long numberOfTaskSetsPerStep) {
        long checkedTasksets = 0;
        final long numberOfTaskSets = 8 * numberOfTaskSetsPerStep;

        final ResultLogger resultLogger = new ResultLogger("numberOfProcessors");
        final Map<AbstractTest<DagTask>, Long> resultMap = new LinkedHashMap<>();
        abstractTestInstances.forEach(t -> resultMap.put(t, (long) 0));
        resultLogger.logHeader(resultMap, "NoOfProcessors");

        for (long numberOfProcessors = 2; numberOfProcessors <= 16; numberOfProcessors += 2) {
            manager.setNumberOfProcessors(numberOfProcessors);
            resultMap.replaceAll((k, v) -> (long) 0);
            for (int i = 0; i < numberOfTaskSetsPerStep; ++i) {
                final Set<DagTask> taskSet = builder.generateUUnifastTaskSet(
                        (long) (1.5 * numberOfProcessors), (double) numberOfProcessors * 0.5);

                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 =
                            testInstance.runSchedulabilityCheck(sortedTaskSet);

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


    public void varyNumberOfTasks(final DagTaskBuilder builder,
            final List<AbstractTest<DagTask>> abstractTestInstances, final long numberOfProcessors,
            final long numberOfTaskSetsPerStep) {
        long checkedTasksets = 0;
        final long numberOfTaskSets = 9 * numberOfTaskSetsPerStep;

        final ResultLogger resultLogger = new ResultLogger("numberOfTasks_" + numberOfProcessors);
        final Map<AbstractTest<DagTask>, Long> resultMap = new LinkedHashMap<>();
        abstractTestInstances.forEach(t -> resultMap.put(t, (long) 0));
        resultLogger.logHeader(resultMap, "NoOfTasks");

        for (long numberOfTasks = 4; numberOfTasks <= 20; numberOfTasks += 2) {
            resultMap.replaceAll((k, v) -> (long) 0);
            for (int i = 0; i < numberOfTaskSetsPerStep; ++i) {
                final Set<DagTask> taskSet = builder.generateUUnifastTaskSet(numberOfTasks,
                        (double) numberOfProcessors * 0.5);

                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 =
                            testInstance.runSchedulabilityCheck(sortedTaskSet);

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

    public void varyUtilization(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("utilization_" + numberOfProcessors);
        final Map<AbstractTest<DagTask>, Long> resultMap = new LinkedHashMap<>();
        abstractTestInstances.forEach(t -> resultMap.put(t, (long) 0));
        resultLogger.logHeader(resultMap, "Utilization");

        for (double util = 1; util <= numberOfProcessors; util += 0.25) {
            resultMap.replaceAll((k, v) -> (long) 0);
            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 =
                            testInstance.runSchedulabilityCheck(sortedTaskSet);

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