ExperimentTest.kt

import org.junit.FixMethodOrder
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.junit.runners.MethodSorters
import papi.Constants
import papi.EventSet
import se.lth.cs.bcgen.BCBenchmarkPackage
import se.lth.cs.papicounters.PAPICounter
import se.lth.cs.papicounters.PapiTracerRunner
import se.lth.cs.smartmodules.tracer.Tracer
import se.lth.cs.timing.OperationType
import se.lth.cs.util.*
import java.util.stream.Collectors

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
class ExperimentTest {

    val runner = PapiTracerRunner()

    @Test
    fun testExperimentNoFeatures() {
        val bench = BCBenchmarkPackage.LIST(1234, 100, 0, ArrayList<Int>())

        val exp = Experiment(10, bench, FeatureSet(), runner)

        val results = exp.run().collect(Collectors.toList())
        Assertions.assertTrue(results.isEmpty())
    }

    @Test
    fun testExperiment1() {
        val bench = BCBenchmarkPackage.LIST(1234, 100, 0, ArrayList<Int>())
        val exp = Experiment(10, bench,
            FeatureSet(PAPICounter("PAPI_TOT_CYC")),
            runner
        )

        val results = exp.run().collect(Collectors.toList())

        Assertions.assertEquals(10, results.size)
        Assertions.assertEquals(
            IntRange(0, 9).toList(),
            results.map { it.iterationNumber }
        )
        Assertions.assertTrue(results.all { it.values[PAPICounter("PAPI_TOT_CYC")]!! > 0.0 })
        Assertions.assertEquals(setOf(PAPICounter("PAPI_TOT_CYC")),
            results.flatMap{ it.values.keys }.toSet())
    }

    @Test
    fun testOverflowExperiment() {
        val longBench = BCBenchmarkPackage.LIST(1234, 1000000, 0, ArrayList<Int>())
        val shortBench = BCBenchmarkPackage.LIST(1234, 100, 0, ArrayList<Int>())

        val costPerDelete = CostFeature(OperationType.DELETE)
        val cacheMissRate = FeatureRatio(
            PAPICounter("PAPI_L2_DCM"),
            PAPICounter("PAPI_L2_DCA")
        )
        val exp = Experiment(10, longBench,
            FeatureSet(
                PAPICounter("PAPI_TOT_INS"),
                PAPICounter("PAPI_TOT_CYC"),
                cacheMissRate,
                costPerDelete
            ),
            runner
        )

        // This should trigger an overflow but it's silent
        val results = exp.run().collect(Collectors.toList())

        Assertions.assertTrue(results.all { it.values[PAPICounter("PAPI_TOT_CYC")]!! > 0.0 })

        // Running another experiment afterwards should still work.
        val exp2 = Experiment(10, shortBench, FeatureSet(PAPICounter("PAPI_TOT_CYC")), runner)

        exp2.run()
    }

    @Test
    fun testExperiment2() {
        // This time, with more complicated features

        val bench = BCBenchmarkPackage.LIST(1234, 100, 0, ArrayList<Int>())

        val cacheMissRate = FeatureRatio(
            PAPICounter("PAPI_L2_DCM"),
            PAPICounter("PAPI_L2_DCA")
        )

        val costPerDelete = CostFeature(OperationType.DELETE)

        val exp = Experiment(10, bench,
            FeatureSet(
                PAPICounter("PAPI_TOT_INS"),
                costPerDelete,
                cacheMissRate
            ),
            runner
        )
        val results = exp.run()

        for (iteration in results) {
            Assertions.assertTrue(iteration.values.containsKey(PAPICounter("PAPI_TOT_INS")))
            Assertions.assertTrue(iteration.values.containsKey(costPerDelete))
            Assertions.assertTrue(iteration.values.containsKey(costPerDelete.counter))
            Assertions.assertTrue(iteration.values.containsKey(cacheMissRate))
            Assertions.assertTrue(iteration.values.containsKey(cacheMissRate.f1))
            Assertions.assertTrue(iteration.values.containsKey(cacheMissRate.f2))
        }
    }

    // @Disabled("PAPI_L1_DCA was not available on my machine, so it wouldn't work")
    @Test
    fun testExperimentBrainyFeatures() {
        val bench = BCBenchmarkPackage.LIST(1234, 100, 0, ArrayList<Int>())

        val features = brainyFeatures().checked()
        val exp = Experiment(10, bench, features,runner)

        val results = exp.run()

        // Fails for some reason. I don't understand why
        // Throws an exception with number -8
        val eventSet = EventSet.create(Constants.PAPI_TOT_CYC)
        eventSet.start()
        eventSet.stop()

        for (iteration in results) {
            Assertions.assertEquals(bench, iteration.benchmark)
            Assertions.assertTrue(iteration.values.values.all { it > 0 })
        }
    }

    @Test
    fun cacheSizeFeatures() {
        val f = cacheLineSizeFeature()
        Assertions.assertFalse(f == null)
    }

    @Test
    fun testNormalizationBrainyFeatures() {
        val bench = BCBenchmarkPackage.LIST(1234, 100, 0, ArrayList<Int>())

        val features = normalize(brainyFeatures()).checked()

        val exp = Experiment(10, bench, features,runner)

        val results = exp.run()

        for (iteration in results) {
            Assertions.assertEquals(bench, iteration.benchmark)
            Assertions.assertTrue(features.containsAll(iteration.strict().values.keys))
            Assertions.assertTrue(iteration.values.values.all { it > 0 })
            Assertions.assertTrue(iteration.strict().values.values.all { it <= 1.0 })
        }
    }
}