TestEnvironment.java

package mvd.jester;

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.model.SystemSetup;
import mvd.jester.priority.PriorityManager;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.tests.AbstractTest;

/**
 * TestEnvironment
 */
public class TestEnvironment {

    private final long numberOfTaskSets;
    private final SystemSetup systemSetup;
    private final SystemSetup.Builder builder;
    private final Set<Constructor<? extends AbstractTest>> abstractTests;
    private final Set<Constructor<? extends AbstractSimulator>> abstractSimulators;
    private final Set<PriorityManager> schedulingAlgorithms;

    public TestEnvironment(SystemSetup.Builder builder, long numberOfTaskSets) {
        this.numberOfTaskSets = numberOfTaskSets;
        this.abstractTests = new HashSet<>();
        this.abstractSimulators = new HashSet<>();
        this.schedulingAlgorithms = new HashSet<>();

        this.builder = builder;
        this.systemSetup = builder.build();
    }

    public TestEnvironment registerSchedulingAlgorithm(PriorityManager priorityManager) {
        schedulingAlgorithms.add(priorityManager);

        return this;
    }

    public TestEnvironment registerTest(Class<? extends AbstractTest> abstractTest) {
        try {
            abstractTests.add(abstractTest.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract test!");
        }

        return this;
    }

    public TestEnvironment registerSimulator(Class<? extends AbstractSimulator> abstractSimulator) {
        try {
            abstractSimulators.add(abstractSimulator.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract simulator!");
        }

        return this;
    }

    public TestEnvironment registerTestPair(Class<? extends AbstractTest> abstractTest,
            Class<? extends AbstractSimulator> abstractSimulator) {
        try {
            abstractTests.add(abstractTest.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract test!");
        }
        try {
            abstractSimulators.add(abstractSimulator.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract simulator!");
        }

        return this;
    }

    public void runTests() {
        Set<Pair<AbstractTest>> abstractTestInstances = new HashSet<>();
        Set<Pair<AbstractSimulator>> abstractSimulatorInstances = new HashSet<>();

        Map<Long, Long> totalNumberOfTasksets = new HashMap<>();

        Table<Long, Pair<AbstractTest>, Set<SchedulingInfo>> testResults = HashBasedTable.create();
        Table<Long, Pair<AbstractSimulator>, Set<SchedulingInfo>> simulatorResults =
                HashBasedTable.create();

        for (PriorityManager pm : schedulingAlgorithms) {
            for (Constructor<? extends AbstractTest> c : abstractTests) {
                try {
                    abstractTestInstances
                            .add(new Pair<AbstractTest>(pm, c.newInstance(this.systemSetup)));
                } catch (Exception e) {
                    System.out.println("Could not instantiate object of AbstractTest!");
                }
            }

            for (Constructor<? extends AbstractSimulator> c : abstractSimulators) {
                try {
                    abstractSimulatorInstances
                            .add(new Pair<AbstractSimulator>(pm, c.newInstance(this.systemSetup)));
                } catch (Exception e) {
                    System.out.println("Could not instantiate object of AbstractSimulator!");
                }
            }
        }

        long checkedTasksets = 0;

        while (checkedTasksets < numberOfTaskSets) {
            builder.rebuild(this.systemSetup);

            double utilization = this.systemSetup.getUtilization();

            while (utilization <= this.systemSetup.getNumberOfProcessors()
                    && checkedTasksets < numberOfTaskSets) {
                checkedTasksets++;

                if (checkedTasksets % 100 == 0) {
                    System.out.println(checkedTasksets + " bereits geschafft");
                }

                long roundedUtilization = (long) (utilization * 10);

                totalNumberOfTasksets.compute(roundedUtilization, (k, v) -> v == null ? 1 : v + 1);

                for (Pair<AbstractTest> testInstance : abstractTestInstances) {
                    PriorityManager priorityManager = testInstance.getPriorityManager();
                    AbstractTest abstractTest = testInstance.getAbstractValue();
                    if (!testResults.contains(roundedUtilization, testInstance)) {
                        testResults.put(roundedUtilization, testInstance, new HashSet<>());
                    }

                    if (priorityManager.hasTest(abstractTest)) {
                        SchedulingInfo schedulingInfo =
                                abstractTest.runSchedulabilityCheck(priorityManager);
                        testResults.get(roundedUtilization, testInstance).add(schedulingInfo);
                    }
                }

                for (Pair<AbstractSimulator> simulatorInstance : abstractSimulatorInstances) {
                    PriorityManager priorityManager = simulatorInstance.getPriorityManager();
                    AbstractSimulator abstractSimulator = simulatorInstance.getAbstractValue();
                    if (!simulatorResults.contains(roundedUtilization, simulatorInstance)) {
                        simulatorResults.put(roundedUtilization, simulatorInstance,
                                new HashSet<>());
                    }

                    if (priorityManager.hasSimulator(abstractSimulator)) {
                        SchedulingInfo schedulingInfo =
                                abstractSimulator.runSimulation(priorityManager);
                        simulatorResults.get(roundedUtilization, simulatorInstance)
                                .add(schedulingInfo);
                    }
                }

                builder.addTask(systemSetup);

                utilization = this.systemSetup.getUtilization();
            }
        }

        ResultCollector resultCollector = new ResultCollector(testResults, simulatorResults,
                totalNumberOfTasksets, systemSetup.getNumberOfProcessors());

        resultCollector.logAll();
    }

}