build.gradle

/*
 * This build file was auto generated by running the Gradle 'init' task
 * by 'noricc' at '9/17/18 11:09 AM' with Gradle 2.10
 *
 * This generated file contains a commented-out sample Java project to get you started.
 * For more details take a look at the Java Quickstart chapter in the Gradle
 * user guide available at https://docs.gradle.org/2.10/userguide/tutorial_java_projects.html
 */

plugins {
    id 'java'
    // id 'idea'
    // If this doesn't work, update gradle using // $ ./gradlew wrapper
    // $ ./gradlew wrapper --gradle-version <version>
    id 'org.jetbrains.kotlin.jvm' version "1.3.72"
}

repositories {
    mavenCentral()
    jcenter()
    maven {
        url "https://plugins.gradle.org/m2/"
    }
}

compileJava {
    sourceCompatibility = 8
    targetCompatibility = 8
}

import java.nio.file.Paths;

// We'll make a plugin for anything that uses PAPI

class PAPIPlugin implements Plugin<Project> {
    def foundPapi(path) {
        return path.toFile().exists();
    }

    def findPapi() {
        def options = [Paths.get("/usr", "local", "lib", "libpapi.so"),
		       Paths.get("/usr", "lib", "x86_64-linux-gnu", "libpapi.so"),
                       Paths.get("/usr", "local", "lib", "x86_64-linux-gnu", "libpapi.so")]

        def env = System.getenv()
        if (env.containsKey("PAPI_LIBRARY_PATH")) {
            options.add(Paths.get(env["PAPI_LIBRARY_PATH"].toString(),
                                      "libpapi.so"))
        }

        def p = options.find({ foundPapi(it) });

        if (p == null) {
            throw new RuntimeException("Papi not found in the paths $options")
        }

        def path = p.parent
        println("PAPI found in: '$path'")
        return path
    }

    def papi_path = findPapi()

    // We want to define some properties...
    void apply(Project project) {
        def papi_java_path = "${project.rootProject.projectDir}/papi-java"
        def library_path = "$papi_path:$papi_java_path".toString()

        project.ext.papi_library_path = library_path
    }
}


subprojects {
    apply plugin: 'java'
    apply plugin: 'kotlin'
    apply plugin: PAPIPlugin

    compileKotlin {
        kotlinOptions {
            jvmTarget = "1.8"
        }
    }

    compileTestKotlin {
        kotlinOptions {
            jvmTarget = "1.8"
        }
    }

    test {
        useJUnitPlatform()
        systemProperty "java.library.path", papi_library_path

        testLogging {
            exceptionFormat = 'full'
        }

        dependsOn cleanTest
    }
}

project(':benchmarking-synthetic') {
    dependencies {
        implementation project(':core')
        compile 'org.json:json:20190722'
        compile 'net.time4j:time4j-core:4.38'
        compile 'org.apache.commons:commons-lang3:3.9'
        compile 'org.openjdk.jmh:jmh-core:1.22'
        annotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.22'
        implementation 'com.google.code.gson:gson:2.8.5'
    }
}

project(':benchmarking-traces') {
    dependencies {
        implementation project(':core')
        compile 'org.json:json:20190722'
        compile 'net.time4j:time4j-core:4.38'
        compile 'org.apache.commons:commons-lang3:3.9'
        compile 'org.openjdk.jmh:jmh-core:1.22'
        annotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.22'
        implementation 'com.google.code.gson:gson:2.8.5'
    }
}

project(':core') {
    apply plugin: PAPIPlugin
    apply plugin: 'application'

    run {
        systemProperty 'java.library.path', papi_library_path
 	applicationDefaultJvmArgs = ['-Xmx6g']
        mainClassName = 'se.lth.cs.Main'
        workingDir = '..'
    }
}

def jmhOptionsMap = [
    "resultFormat": "-rf",
    "benchmarkParameters" : "-p",
    "iterations": "-i",
    "timeOnIteration": "-r",
    "warmupIterations": "-wi",
    "warmup": "-w",
    "include": "", // No option, just add to end of command
    "fork": "-f",
    "timeUnit": "-tu",
    "failOnError": "-foe",
    "outputFile" : "-rff",
    "logFile" : "-o" // For STDOUT
]

def createJMHOptions(optionsMap, valuesMap) {
    def options = []
    for (e in optionsMap) {
        def optionFlag = e.value
        if (!valuesMap.containsKey(e.key)) {
            println("Argument not found: $e.key")
        }
        def argValue = valuesMap[e.key]
        // If one if a map, it's probably the benchmarkParameters
        if (e.key == "benchmarkParameters") {
            // We want for each param a couple
            // -p PARAM=v1,v2,v3
            def arguments = argValue.collect{it.key + "=" + it.value.join(",")}
            arguments.each{
                options.add(optionFlag)
                options.add(it)
            }
        } else {
            if (e.key == "include") {
                // do nothing, we'll add later
            } else {
                options.add(optionFlag)
                options.add(argValue)
            }
        }
    }

    for (v in valuesMap["include"]) {
        options.add(v)
    }

    return options
}

def jmhTestArgsMap = [
    include: ["List"], // This parameter seems to be ignored?
    benchmarkParameters:["seed": (0..20).toList().collect{it.toString()},
                         "applicationSize":["1000"],
                         "baseStructureSize":["0"]],
    fork:2,
    timeOnIteration:"250ms",
    iterations:2,
    warmup:"250ms",
    warmupIterations:2,
    outputFile: "jmh-results-test.csv",
    fork:2,
    resultFormat:"CSV",
    benchmarkMode:["ss"],
    timeUnit:"ms",
    logFile: "jmh-test.log",
    failOnError : true,
]

task('jmhTest', type: Exec) {
    dependsOn 'benchmarking-synthetic:shadowJar'
    def options = createJMHOptions(jmhOptionsMap, jmhTestArgsMap)
    workingDir '.'
    commandLine = ['java', '-jar', 'benchmarking-synthetic/build/libs/benchmarks.jar'] + options
}

def jmhFullArgsMap = [
    include: ["List", "Map", "Set"],
    timeOnIteration:"250ms",
    warmup:"250ms",
    warmupIterations:2,
    fork:2,
    resultFormat:"CSV",
    timeUnit:"ms",
    failOnError: true,
    benchmarkParameters: ["seed": (0..1000).toList().collect{it.toString()},
                          "baseStructureSize": ["0"],
                          "applicationSize" : ["1000"],
                          "methodSelectionStrategyId" : ["BRAINY"]],
    duplicateClassesStrategy:'warn',
    outputFile : "jmh-results-full.csv",
    logFile: "jmh-full.log",
    iterations:5,
]

task('jmhFull', type: Exec) {
    dependsOn 'benchmarking-synthetic:shadowJar'
    def options = createJMHOptions(jmhOptionsMap, jmhFullArgsMap)
    workingDir '.'
    commandLine = ['java', '-jar', 'benchmarking-synthetic/build/libs/benchmarks.jar'] + options
}


def seedsFileName = "seeds-benchmarks.csv"

// A task where you run benchmarks with different seeds
// a print a file listing a list of seeds that should
// provide a good coverage (each collection wins "n" benchmarks)
task('sampleSeeds', type: Exec) {
    dependsOn 'benchmarking-synthetic:shadowJar'
    workingDir '.'
    commandLine = ['java', '-cp', 'benchmarking-synthetic/build/libs/benchmarks.jar', 'se.lth.cs.jmh.Main',
                   '--target-size', '100', '--number-iterations', '30', '--output-file', seedsFileName]
}

task('compareMethodSelections', type: Exec) {
    dependsOn 'benchmarking-synthetic:shadowJar'
    workingDir '.'
    commandLine = ['java', '-Djava.library.path=/usr/lib/x86_64-linux-gnu:./papi-java',
                   '-cp', 'benchmarking-synthetic/build/libs/benchmarks.jar',
                   'se.lth.cs.jmh.Main',
                   '--mode', 'compare-generation-schemes',
                   '--target-size', '100',
                   '--seed-limit', '1000',
                   '--number-iterations', '30', '--output-file', 'comparison-generation-schemes.csv']
}

import java.nio.file.Paths
import java.util.TreeSet

// Benchmarking sampled seeds with JMH
// This transforms a list of loaded seeds into the JMH table of arguments
def loadSeeds(filename, baseMap) {
    def p = Paths.get(filename)
    if (!p.toFile().exists()) {
        return baseMap
    }
    def i = p.toFile().newInputStream()
    def seeds = new TreeSet()
    def interfaces = new TreeSet()
    def lineNumber = 0
    def append = { split ->
        if (lineNumber == 0) {
            // do nothing
        } else {
            seeds.add(split[0])
            interfaces.add(split[1])
        }
        lineNumber++
    }
    i.splitEachLine(",", append)

    println("File parsed. Lines: " + lineNumber)

    def newMap = baseMap.clone()

    // '+' is the operator you use for merging maps
    newMap["benchmarkParameters"] = baseMap["benchmarkParameters"] + ["seed": seeds]

    newMap = newMap + ["include": interfaces]

    return newMap
}

import java.io.InputStream

def optionsToString(List<String> options) {
    def joined = String.join(" ", options.collect { it -> it.toString()})
    return new ByteArrayInputStream(joined.bytes)
}

task('jmhSeeds', type: Exec) {
    dependsOn 'benchmarking-synthetic:shadowJar'
    def loadedParameters = loadSeeds(seedsFileName, jmhFullArgsMap)
    def options = createJMHOptions(jmhOptionsMap, loadedParameters)
    standardInput = optionsToString(options)
    workingDir '.'
    commandLine = ['java', '-cp', 'benchmarking-synthetic/build/libs/benchmarks.jar',
                   'se.lth.cs.jmh.SeedSamplerJMHReader']
}