ResultCollector.java

package mvd.jester;

import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import com.google.common.collect.Table;
import com.google.common.math.Stats;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.TerminationInfo;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.tests.AbstractTest;
import mvd.jester.utils.Logger;

/**
 * ResultCollector
 */
public class ResultCollector {

    private final Table<Long, Pair<AbstractTest>, Set<SchedulingInfo>> testResults;
    private final Table<Long, Pair<AbstractSimulator>, Set<SchedulingInfo>> simulatorResults;
    private final Map<Long, Long> totalNumberOfTasksets;
    private final long numberOfProcessors;

    public ResultCollector(Table<Long, Pair<AbstractTest>, Set<SchedulingInfo>> testResults,
            Table<Long, Pair<AbstractSimulator>, Set<SchedulingInfo>> simulatorResults,
            Map<Long, Long> totalNumberOfTasksets, long numberOfProcessors) {
        this.testResults = testResults;
        this.simulatorResults = simulatorResults;
        this.totalNumberOfTasksets = totalNumberOfTasksets;
        this.numberOfProcessors = numberOfProcessors;
    }

    public void logAll() {
        if (!testResults.isEmpty()) {
            logResults(testResults, "test");
            logMeanTardiness(simulatorResults, "test");
            logFailedTardiness(testResults, "test");
        }
        if (!simulatorResults.isEmpty()) {
            logResults(simulatorResults, "sim");
            logMeanTardiness(simulatorResults, "sim");
            logFailedTardiness(simulatorResults, "sim");
        }
    }

    public <T extends PairInterface> void logResults(
            Table<Long, Pair<T>, Set<SchedulingInfo>> results, String type) {
        LocalTime date = LocalTime.now();
        Logger log = new Logger("./results/results_" + type + "_" + numberOfProcessors + "_"
                + date.getHour() + ":" + date.getMinute() + ".txt");
        String firstLine = new String("Utilization\tTotal");

        if (!results.isEmpty()) {
            for (Pair<T> pair : results.columnKeySet()) {
                firstLine = firstLine + "\t" + pair.getName();
            }

            log.log(firstLine);

            for (Long util : totalNumberOfTasksets.keySet()) {
                String line =
                        String.valueOf((double) util / 10) + "\t" + totalNumberOfTasksets.get(util);
                for (Pair<T> pair : results.columnKeySet()) {
                    long feasibleTasksets = results.get(util, pair).stream()
                            .filter(s -> s.checkTasksetFeasible()).count();
                    line += "\t" + feasibleTasksets;
                }
                log.log(line);
            }
        }

        log.finalize();
    }


    public <T extends PairInterface> void logFailedTardiness(
            Table<Long, Pair<T>, Set<SchedulingInfo>> results, String type) {
        LocalTime date = LocalTime.now();
        Logger log = new Logger("./results/failed_tardiness_" + type + "_" + numberOfProcessors
                + "_" + date.getHour() + ":" + date.getMinute() + ".txt");
        String firstLine = new String("Utilization\tTotal");

        if (!results.isEmpty()) {
            for (Pair<T> pair : results.columnKeySet()) {
                firstLine = firstLine + "\t" + pair.getName();
            }

            log.log(firstLine);

            for (Long kv : totalNumberOfTasksets.keySet()) {
                String line =
                        String.valueOf((double) kv / 10) + "\t" + totalNumberOfTasksets.get(kv);
                for (Pair<T> pair : results.columnKeySet()) {
                    Set<SchedulingInfo> simulationInfos = results.get(kv, pair);
                    List<Long> values = new ArrayList<>();

                    for (SchedulingInfo s : simulationInfos) {
                        Optional<TerminationInfo> failedTerminationInfo =
                                s.getFailedTerminationInfo();
                        if (failedTerminationInfo.isPresent()) {
                            values.add(failedTerminationInfo.get().getLateness());
                        }
                    }
                    double meanTardiness = 0;
                    if (!values.isEmpty()) {
                        meanTardiness = Stats.meanOf(values.iterator());
                    }
                    line += "\t" + meanTardiness;
                }
                log.log(line);
            }
        }

        log.finalize();
    }

    public <T extends PairInterface> void logMeanTardiness(
            Table<Long, Pair<T>, Set<SchedulingInfo>> results, String type) {
        LocalTime date = LocalTime.now();
        Logger log = new Logger("./results/mean_tardiness_" + type + "_" + numberOfProcessors + "_"
                + date.getHour() + ":" + date.getMinute() + ".txt");
        String firstLine = new String("Utilization\tTotal");

        if (!results.isEmpty()) {
            for (Pair<T> pair : results.columnKeySet()) {
                firstLine = firstLine + "\t" + pair.getName();
            }

            log.log(firstLine);

            for (Long kv : totalNumberOfTasksets.keySet()) {
                String line =
                        String.valueOf((double) kv / 10) + "\t" + totalNumberOfTasksets.get(kv);
                for (Pair<T> pair : results.columnKeySet()) {
                    Set<SchedulingInfo> simulationInfos = results.get(kv, pair);
                    List<Long> values = new ArrayList<>();

                    for (SchedulingInfo s : simulationInfos) {
                        for (TerminationInfo t : s.getTerminationInfos()) {
                            values.add(t.getLateness());
                        }
                    }

                    double meanTardiness = 0;
                    if (!values.isEmpty()) {
                        meanTardiness = Stats.meanOf(values.iterator());
                    }
                    line += "\t" + meanTardiness;
                }
                log.log(line);
            }
        }

        log.finalize();
    }

}