build.gradle

/*
 * Copyright 2015-2021 Real Logic Limited.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id 'java-library'
    id 'checkstyle'
    id 'com.github.ben-manes.versions' version '0.39.0'
    id 'com.github.johnrengelman.shadow' version '7.0.0' apply false
    id 'com.google.protobuf' version '0.8.16' apply false
}

defaultTasks 'clean', 'build'

static def getBuildJavaVersion() {
    def buildJavaVersion = System.getenv('BUILD_JAVA_VERSION') ?: JavaVersion.current().getMajorVersion()
    if (buildJavaVersion.indexOf('.') > 0) {
        buildJavaVersion = buildJavaVersion.substring(0, buildJavaVersion.indexOf('.'))
    }
    if (buildJavaVersion.indexOf('-') > 0) {
        buildJavaVersion = buildJavaVersion.substring(0, buildJavaVersion.indexOf('-'))
    }
    Integer.parseInt(buildJavaVersion)
}
int buildJavaVersion = getBuildJavaVersion()

def toolchainLauncher = javaToolchains.launcherFor {
    languageVersion = JavaLanguageVersion.of(buildJavaVersion)
}

def toolchainCompiler = javaToolchains.compilerFor {
    languageVersion = JavaLanguageVersion.of(buildJavaVersion)
}

def agronaVersion = '1.11.0'
def aeronVersion = '1.34.0'
def jmhVersion = '1.32'
def hdrHistogramVersion = '2.1.12'
def disruptorVersion = '3.4.4'
def junitVersion = '5.7.2'
def mockitoVersion = '3.11.2'
def checkstyleVersion = '8.39'
def grpcVersion = '1.38.0'
def protobufVersion = '3.17.3'
def kafkaVersion = '2.8.0'
def slf4jVersion = '1.7.31'
def scalaVersion = '2.13.5'
def annotationsApiVersion = '6.0.53'
def byteBuddyVersion = '1.11.3'

allprojects {
    repositories {
        mavenLocal()
        mavenCentral()
    }

    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()

            force "net.bytebuddy:byte-buddy:${byteBuddyVersion}",
                  "net.bytebuddy:byte-buddy-agent:${byteBuddyVersion}",
                  "com.fasterxml.jackson.core:jackson-databind:2.10.5.1",
                  "org.slf4j:slf4j-api:${slf4jVersion}",
                  "org.scala-lang:scala-library:${scalaVersion}",
                  "org.scala-lang:scala-reflect:${scalaVersion}",
                  "net.sf.jopt-simple:jopt-simple:5.0.4"
        }
    }
}

subprojects {
    apply plugin: 'java-library'
    apply plugin: 'checkstyle'

    dependencies {
        testImplementation "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
        testImplementation "org.mockito:mockito-inline:${mockitoVersion}"
        testRuntimeOnly "net.bytebuddy:byte-buddy:${byteBuddyVersion}"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
    }

    checkstyle.toolVersion = "${checkstyleVersion}"

    tasks.withType(Jar) {
        enabled = true
        includeEmptyDirs = false
    }

    tasks.withType(JavaCompile) {
        if (buildJavaVersion >= 9) {
            javaCompiler.set(toolchainCompiler)
        }
        else {
            options.fork = true
            def javaHome = toolchainCompiler.get().metadata.installationPath.asFile.toPath().toAbsolutePath()
            options.forkOptions.javaHome = javaHome.toFile()
        }
        options.compilerArgs.add('-XDignore.symbol.file') // Suppress warnings about using Unsafe
        options.encoding = 'UTF-8'
        options.deprecation = true
    }

    tasks.withType(Test) {
        useJUnitPlatform()

        if (buildJavaVersion >= 9) {
            jvmArgs('--add-opens', 'java.base/sun.nio.ch=ALL-UNNAMED')
        }

        testLogging {
            showStandardStreams = true
            exceptionFormat = 'full'
        }

        javaLauncher.set(toolchainLauncher)
    }
}

project(':benchmarks-api') {
    dependencies {
        api "org.agrona:agrona:${agronaVersion}"
        implementation "org.hdrhistogram:HdrHistogram:${hdrHistogramVersion}"
    }
}

project(':benchmarks-aeron') {
    dependencies {
        api project(':benchmarks-api')
        annotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:${jmhVersion}"
        implementation "org.openjdk.jmh:jmh-core:${jmhVersion}"
        implementation "io.aeron:aeron-cluster:${aeronVersion}"
        implementation "com.lmax:disruptor:${disruptorVersion}"
    }
}

project(':benchmarks-grpc') {
    apply plugin: 'com.google.protobuf'

    dependencies {
        api project(':benchmarks-api')
        implementation "io.grpc:grpc-protobuf:${grpcVersion}"
        implementation "io.grpc:grpc-stub:${grpcVersion}"
        implementation "io.grpc:grpc-netty-shaded:${grpcVersion}"
        compileOnly "org.apache.tomcat:annotations-api:${annotationsApiVersion}"
    }

    protobuf {
        protoc { artifact = "com.google.protobuf:protoc:${protobufVersion}" }
        plugins {
            grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
        }
        generateProtoTasks {
            all()*.plugins { grpc {} }
        }
    }
}

project(':benchmarks-kafka') {
    dependencies {
        api project(':benchmarks-api')
        implementation "org.apache.kafka:kafka-clients:${kafkaVersion}"
        runtimeOnly "org.apache.kafka:kafka_2.13:${kafkaVersion}"
        runtimeOnly "org.slf4j:slf4j-log4j12:${slf4jVersion}"
        testImplementation "org.apache.kafka:kafka_2.13:${kafkaVersion}"
        testRuntimeOnly "org.slf4j:slf4j-log4j12:${slf4jVersion}"
    }
}

project(':benchmarks-all') {
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        implementation project(':benchmarks-aeron')
        implementation project(':benchmarks-grpc')
        implementation project(':benchmarks-kafka')
    }

    shadowJar {
        archiveFileName = 'benchmarks.jar'
        manifest.attributes('Main-Class': 'org.openjdk.jmh.Main')
    }

    jar.finalizedBy shadowJar
}

def benchmarkJvmArgs() {
    StringBuilder args = new StringBuilder("-Dagrona.disable.bounds.checks=true -XX:+UseParallelGC")
    if (buildJavaVersion > 8) {
        args.append(" --add-opens java.base/sun.nio.ch=ALL-UNNAMED")
    }
    return args.toString()
}

task runJavaBenchmarks(type: Exec, dependsOn: ':benchmarks-all:shadowJar') {
    commandLine toolchainLauncher.get().executablePath,
    '-jar', 'benchmarks-all/build/libs/benchmarks.jar',
    '-jvmArgs', benchmarkJvmArgs(),
    '-wi', '3', '-w', '1s', '-i', '5', '-r', '1s', '-tu', 'ns', '-f', '5'
}

task runAeronJavaBenchmarks(type: Exec, dependsOn: ':benchmarks-all:shadowJar') {
    commandLine toolchainLauncher.get().executablePath,
    '-jar', 'benchmarks-all/build/libs/benchmarks.jar',
    '-jvmArgs', benchmarkJvmArgs(),
    'Aeron',
    '-wi', '3', '-w', '1s', '-i', '5', '-r', '1s', '-tu', 'ns', '-f', '5'
}

def isNonStable = { String version ->
    def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { it -> version.toUpperCase().contains(it) }
    def regex = /^[0-9,.v-]+(-r)?$/
    return !stableKeyword && !(version ==~ regex)
}

tasks.named("dependencyUpdates").configure {
    // Reject all non stable versions
    rejectVersionIf {
        isNonStable(it.candidate.version)
    }
}

wrapper {
    gradleVersion = '7.1.1'
    distributionType = 'ALL'
}