Experiment.kt

package se.lth.cs.util

import se.lth.cs.bcgen.BCBenchmarkPackage
import se.lth.cs.papicounters.EventSetBuilder
import se.lth.cs.papicounters.PAPICounter
import se.lth.cs.papicounters.PapiBenchmarkAnalyzer
import se.lth.cs.papicounters.PapiTracerRunner
import se.lth.cs.smartmodules.tracer.Tracer
import se.lth.cs.timing.OperationTypeTable
import java.util.stream.Stream

class Experiment(val numberIterations : Int,
                 val benchmark : BCBenchmarkPackage<*>,
                 val features : FeatureSet,
                 val papiRunner : PapiTracerRunner) : FeatureVisitor {

    inner class Result(val iterationNumber : Int,
                 val benchmark : BCBenchmarkPackage<*>,
                 val values : Map<Feature, Double>) {
        /**
         * Returns only the features we specified in the feature set
         * If feature F1 requires F2, but F2 is not explicitly requested
         * we omit it.
         */
        fun strict() : Result {
            return Result(iterationNumber, benchmark,
                values.filterKeys { it in features } )
        }
    }

    fun getIterations(): Stream<List<PapiTracerRunner.TraceRecord>> {
        val iterations = papiRunner.runIterations(
            PapiBenchmarkAnalyzer.RunSpec(numberIterations, features, benchmark)
        )

        return iterations.stream()
    }

    private fun runIteration(i : List<PapiTracerRunner.TraceRecord>,
                     iterationNumber: Int): Result {
        currentIteration = i
        currentIterationResults = mutableMapOf()
        // We aggregate all our features for that
        // specific iteration!
        features.accept(this)
        val values = currentIterationResults.toMap()

        return Result(iterationNumber, benchmark, values)
    }

    fun run() : Stream<Result> {
        if (features.isEmpty()) { return Stream.empty() }

        val iterations = getIterations()

        var iterationNumber = 0

        return iterations.map {
            val r = runIteration(it, iterationNumber)
            iterationNumber++
            r
        }
    }

    var currentIteration : List<PapiTracerRunner.TraceRecord> = listOf()

    var currentIterationResults : MutableMap<Feature, Double> = mutableMapOf()

    override fun visitPAPICounter(c: PAPICounter) {
        if (currentIterationResults.containsKey(c)) {
            return
        }

        val values = currentIteration.filter { it.featureName == c.toHexa() }
            .map { it.featureValue }

        currentIterationResults[c] = values.sum().toDouble()
    }

    override fun visitConstant(constantFeature: ConstantFeature) {
        currentIterationResults[constantFeature] = constantFeature.value
    }

    override fun visitCost(costFeature: CostFeature) {
        costFeature.counter.accept(this)

        val sum = currentIteration.filter {
            val methodType = OperationTypeTable.getType(it.method)

            val rightMethodType = methodType.map { opType ->
                opType == costFeature.opType
            }.orElse(false)

            val rightCounter = it.featureName == costFeature.counter.toHexa()
            rightMethodType && rightCounter
        }.sumBy { it.featureValue }

        currentIterationResults[costFeature] = sum.toDouble()
    }

    override fun visitRatio(featureRatio: FeatureRatio) {
        featureRatio.f1.accept(this)
        featureRatio.f2.accept(this)

        val f1Value = currentIterationResults[featureRatio.f1]
        val f2Value = currentIterationResults[featureRatio.f2]

        if (f1Value != null && f2Value != null) {
            currentIterationResults[featureRatio] = f1Value / f2Value
        }
    }

    override fun visitFeatureSet(featureSet: FeatureSet) {
        for (f in featureSet) {
            f.accept(this)
        }
    }

    override fun visitMethodInvocations(methodInvocations: MethodInvocations) {
        val invokes = benchmark.methodHistogram()[methodInvocations.method]!!
        currentIterationResults[methodInvocations] = invokes.toDouble()
    }

    override fun visitTotalMethodInvocations(totalMethodInvocations: TotalMethodInvocations) {
        currentIterationResults[totalMethodInvocations] = benchmark.traceSize.toDouble()
    }
}