Simulator.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package br.ufrgs.inf.prosoft.tfcache;

import br.ufrgs.inf.prosoft.tfcache.configuration.Configuration;
import br.ufrgs.inf.prosoft.tfcache.metadata.Occurrence;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.LongStream;
import java.util.stream.Stream;

/**
 *
 * @author romulo
 */
public class Simulator {

    private final Metrics metrics;

    public Simulator() {
        this.metrics = new Metrics();
    }

    public Metrics getMetrics() {
        return metrics;
    }

    public void simulate(Stream<Occurrence> occurrences, long ttl) {
        simulate(occurrences, ttl, this.metrics);
    }

    public static void simulate(List<Occurrence> occurrences, Metrics metrics) {
        if (Configuration.getKernel().equals("exhaustive")) {
            simulate(occurrences, generateAllTTLs(occurrences), metrics);
        } else {
            simulate(occurrences, generateTTLsOfInterest(occurrences), metrics);
        }
    }

    public static void simulate(List<Occurrence> occurrences, Stream<Long> ttls, Metrics metrics) {
        ttls.forEach(actualTTL -> {
            simulate(occurrences.stream(), actualTTL, metrics);
        });
    }

    public static void simulate(Stream<Occurrence> occurrences, long ttl, Metrics metrics) {
        Map<String, Long> inputHasCachedTime = new HashMap<>();
        Map<String, Object> inputHasOutput = new HashMap<>();

        long simulationSavedTime = 0;
        long realSavedTime = 0;
        long hits = 0;
        long timeInCache = 0;
        long stales = 0;

        Iterator<Occurrence> iterator = occurrences.iterator();
        while (iterator.hasNext()) {
            Occurrence occurrence = iterator.next();
            long adjustedStartTime = occurrence.getStartTime() - simulationSavedTime;
            long adjustedEndTime = occurrence.getEndTime() - simulationSavedTime;
            if (inputHasCachedTime.containsKey(occurrence.getParametersSerialised())) {
                if (adjustedStartTime - inputHasCachedTime.get(occurrence.getParametersSerialised()) > ttl) {
                    inputHasCachedTime.remove(occurrence.getParametersSerialised());
                }
                if (Configuration.getStaleness().equals("shrink")) {
                    if (Objects.deepEquals(inputHasOutput.get(occurrence.getParametersSerialised()), occurrence.getReturnValue())) {
                        realSavedTime += occurrence.getExecutionTime();
                    } else {
                        stales++;
                    }
                }
                simulationSavedTime += occurrence.getExecutionTime();
                hits++;
            } else {
                inputHasCachedTime.put(occurrence.getParametersSerialised(), adjustedEndTime);
                if (Configuration.getStaleness().equals("shrink")) {
                    inputHasOutput.put(occurrence.getParametersSerialised(), occurrence.getReturnValue());
                }
                timeInCache += ttl;
            }
        }
        if (Configuration.getStaleness().equals("shrink")) {
            metrics.keepBestMetrics(ttl, hits, timeInCache, stales, realSavedTime);
        } else {
            metrics.keepBestMetrics(ttl, hits, timeInCache, stales, simulationSavedTime);
        }
    }

    public static Stream<Long> generateTTLsOfInterest(Stream<Occurrence> occurrences) {
        return generateTTLsOfInterest(occurrences.collect(Collectors.toList()));
    }

    public static Stream<Long> generateTTLsOfInterest(List<Occurrence> occurrences) {
        List<Long> windows = new ArrayList<>();
        for (int i = 1; i < occurrences.size(); i++) {
            long window = occurrences.get(i).getStartTime() - occurrences.get(i - 1).getEndTime();
            if (window > 0) {
                windows.add(window);
            }
        }

        Set<Long> ttlsOfInterest = new HashSet<>(windows);
        for (int hits = 2; hits <= windows.size(); hits++) {
            for (int shift = 0; shift <= windows.size() - hits; shift++) {
                long ttl = 0;
                for (int k = shift; k < shift + hits; k++) {
                    ttl += windows.get(k);
                }
                ttlsOfInterest.add(ttl);
            }
        }
        return ttlsOfInterest.stream().parallel();
    }

    public static Stream<Long> generateAllTTLs(List<Occurrence> occurrences) {
        long maxTTL = occurrences.get(occurrences.size() - 1).getStartTime() - occurrences.get(0).getEndTime();
        long minTTL = Long.MAX_VALUE;
        for (int i = 0; i < occurrences.size() - 1; i++) {
            long ttl = occurrences.get(i + 1).getStartTime() - occurrences.get(i).getEndTime();
            if (ttl > 0 && ttl < minTTL) {
                minTTL = ttl;
            }
        }
        return LongStream.rangeClosed(minTTL, maxTTL).boxed().parallel();
    }

}