Elena Lepilkina
306 lines
10 KiB
Groovy
306 lines
10 KiB
Groovy
import org.jetbrains.kotlin.RegressionsReporter
|
|
import org.jetbrains.kotlin.RegressionsSummaryReporter
|
|
import org.jetbrains.kotlin.BuildRegister
|
|
import org.jetbrains.kotlin.MPPTools
|
|
|
|
buildscript {
|
|
ext.rootBuildDirectory = file('..')
|
|
|
|
apply from: "$rootBuildDirectory/gradle/loadRootProperties.gradle"
|
|
apply from: "$rootBuildDirectory/gradle/kotlinGradlePlugin.gradle"
|
|
repositories {
|
|
maven { url 'https://cache-redirector.jetbrains.com/jcenter'}
|
|
maven { url 'https://cache-redirector.jetbrains.com/maven-central' }
|
|
mavenCentral()
|
|
maven { url buildKotlinCompilerRepo }
|
|
maven { url kotlinCompilerRepo }
|
|
jcenter()
|
|
maven { url "https://kotlin.bintray.com/kotlinx" }
|
|
maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
|
|
}
|
|
|
|
dependencies {
|
|
classpath "org.jetbrains.kotlin:kotlin-native-build-tools:$konanVersion"
|
|
}
|
|
}
|
|
|
|
def rootBuildDirectory = projectDir.parentFile
|
|
|
|
task konanRun {
|
|
subprojects.each {
|
|
dependsOn "${it.path}:konanRun"
|
|
}
|
|
}
|
|
|
|
task jvmRun {
|
|
subprojects.each {
|
|
dependsOn "${it.path}:jvmRun"
|
|
}
|
|
}
|
|
|
|
task clean {
|
|
subprojects.each {
|
|
dependsOn "${it.path}:clean"
|
|
}
|
|
doLast {
|
|
delete "${buildDir.absolutePath}"
|
|
}
|
|
}
|
|
|
|
defaultTasks 'konanRun'
|
|
|
|
private static String getAnalyzerTargetName() {
|
|
// Copy-pasted from tools/benchmarksAnalyzer/build.gradle.
|
|
String target = System.getProperty("os.name")
|
|
if (target == 'Linux') return 'linux'
|
|
if (target.startsWith('Windows')) return 'windows'
|
|
if (target.startsWith('Mac')) return 'macos'
|
|
return 'unknown'
|
|
}
|
|
|
|
private String findAnalyzerBinary() {
|
|
String result = "${projectDir}/../${analyzerToolDirectory}/${getAnalyzerTargetName()}/" +
|
|
"${analyzerTool}ReleaseExecutable/${analyzerTool}${MPPTools.getNativeProgramExtension()}"
|
|
|
|
if (file(result).exists()) return result
|
|
else return null
|
|
}
|
|
|
|
// Produce and send slack report.
|
|
task slackReport(type: RegressionsReporter) {
|
|
def analyzerBinary = MPPTools.findFile("${analyzerTool}${MPPTools.getNativeProgramExtension()}",
|
|
"${rootBuildDirectory}/${analyzerToolDirectory}")
|
|
def teamcityConfig = System.getenv("TEAMCITY_BUILD_PROPERTIES_FILE")
|
|
if (teamcityConfig && analyzerBinary != null) {
|
|
// Create folder for report (root Kotlin project settings make create report in separate folder).
|
|
def reportDirectory = new File(outputReport).parentFile
|
|
mkdir reportDirectory
|
|
def targetsResults = new File(new File("${rootBuildDirectory}"), "targetsResults").toString()
|
|
mkdir targetsResults
|
|
currentBenchmarksReportFile = "${buildDir.absolutePath}/${nativeJson}"
|
|
analyzer = analyzerBinary
|
|
htmlReport = outputReport
|
|
defaultBranch = project.findProperty('kotlin.native.default.branch') ?: "master"
|
|
def target = System.getProperty("os.name")
|
|
summaryFile = "${targetsResults}/${target}.txt"
|
|
bundleBuild = project.findProperty('kotlin.bundleBuild') == null ? false : true
|
|
}
|
|
}
|
|
|
|
task slackSummary(type: RegressionsSummaryReporter) {
|
|
targetsResultFiles = ['Linux': "${rootBuildDirectory}/targetsResults/Linux.txt".toString(),
|
|
'MacOSX': "${rootBuildDirectory}/targetsResults/Mac OS X.txt".toString(),
|
|
'Windows': "${rootBuildDirectory}/targetsResults/Windows 10.txt".toString()]
|
|
}
|
|
|
|
private String getUploadedFile(String fileName) {
|
|
def teamcityConfig = System.getenv("TEAMCITY_BUILD_PROPERTIES_FILE")
|
|
if (teamcityConfig) {
|
|
def buildProperties = new Properties()
|
|
buildProperties.load(new FileInputStream(teamcityConfig))
|
|
def buildNumber = buildProperties.getProperty("build.number")
|
|
def target = System.getProperty("os.name").replaceAll("\\s", "")
|
|
return "${target}/${buildNumber}/${fileName}"
|
|
}
|
|
return null
|
|
}
|
|
|
|
private def uploadBenchmarkResultToArtifactory(String fileName) {
|
|
def teamcityConfig = System.getenv("TEAMCITY_BUILD_PROPERTIES_FILE")
|
|
if (teamcityConfig) {
|
|
def uploadedFile = getUploadedFile(fileName)
|
|
def buildProperties = new Properties()
|
|
buildProperties.load(new FileInputStream(teamcityConfig))
|
|
def password = buildProperties.getProperty("artifactory.apikey")
|
|
MPPTools.uploadFileToArtifactory("${artifactoryUrl}", "${artifactoryRepo}",
|
|
uploadedFile, "${buildDir.absolutePath}/${fileName}", password)
|
|
}
|
|
}
|
|
|
|
// Register external benchmarks reports (e.g. results of libraries benchmarks)
|
|
task registerExternalBenchmarks {
|
|
doLast {
|
|
def reports = externalReports.split(';')
|
|
def jsonReports = []
|
|
reports.each {
|
|
def reportFile = new File(buildDir, it)
|
|
if (!reportFile.exists())
|
|
return
|
|
|
|
def lines = reportFile.readLines()
|
|
if (lines.size < 4) {
|
|
project.logger.warn("Couldn't use report to register benchmarks. Wrong format.")
|
|
return
|
|
}
|
|
def name = lines[0]
|
|
def options = lines[1]
|
|
if (!options.startsWith("OPTIONS")) {
|
|
project.logger.warn("Couldn't use report to register benchmarks. Wrong format in options description.")
|
|
return
|
|
}
|
|
def optionsList = options.replace("OPTIONS ", "").replaceAll("\\[|\\]", "").split(",\\s*").toList()
|
|
def status = lines[2]
|
|
def compileTime = null
|
|
def codeSize = null
|
|
lines.drop(3).each {
|
|
if (it.startsWith("COMPILE_TIME")) {
|
|
compileTime = it
|
|
}
|
|
if (it.startsWith("CODE_SIZE")) {
|
|
codeSize = it
|
|
}
|
|
}
|
|
// Create benchmarks report.
|
|
def properties = [
|
|
"cpu": System.getProperty("os.arch"),
|
|
"os": System.getProperty("os.name"),
|
|
"jdkVersion": System.getProperty("java.version"),
|
|
"jdkVendor": System.getProperty("java.vendor"),
|
|
"kotlinVersion": kotlinVersion,
|
|
"type": "native",
|
|
"compilerVersion": konanVersion,
|
|
"flags": optionsList,
|
|
"benchmarks": "[]"]
|
|
if (compileTime != null) {
|
|
def compileBenchmark = MPPTools.toCompileBenchmark(compileTime, status, name)
|
|
properties += ["compileTime": [compileBenchmark]]
|
|
}
|
|
if (codeSize != null) {
|
|
properties += ["codeSize": MPPTools.toCodeSizeBenchmark(codeSize, status, name)]
|
|
}
|
|
def output = MPPTools.createJsonReport(properties)
|
|
def jsonFile = new File(buildDir, it.replace(".txt", ".json"))
|
|
jsonFile.write(output)
|
|
jsonReports.add(jsonFile)
|
|
}
|
|
def merged = MPPTools.mergeReports(jsonReports)
|
|
if (!merged.isEmpty()) {
|
|
mkdir buildDir.absolutePath
|
|
new File(buildDir, externalBenchmarksReport).write(merged)
|
|
uploadBenchmarkResultToArtifactory(externalBenchmarksReport)
|
|
}
|
|
}
|
|
}
|
|
|
|
task registerBuild(type: BuildRegister) {
|
|
onlyBranch = project.findProperty('kotlin.register.branch')
|
|
def uploadedFile = getUploadedFile(nativeJson)
|
|
if (uploadedFile != null) {
|
|
println("Use file from Artifacrory $uploadedFile")
|
|
fileWithResult = uploadedFile
|
|
}
|
|
// Get bundle size.
|
|
bundleSize = null
|
|
if (project.findProperty('kotlin.bundleBuild') != null) {
|
|
def dist = findProperty('kotlin.native.home') ?: 'dist'
|
|
dist = (new File(dist)).isAbsolute() ? dist : "${project.getProjectDir()}/$dist"
|
|
bundleSize = (new File(dist)).directorySize()
|
|
}
|
|
}
|
|
|
|
task registerExternalBuild(type: BuildRegister) {
|
|
onlyBranch = project.findProperty('kotlin.register.branch')
|
|
def uploadedFile = getUploadedFile(externalBenchmarksReport)
|
|
if (uploadedFile != null) {
|
|
println("Use file from Artifacrory $uploadedFile")
|
|
fileWithResult = uploadedFile
|
|
} else {
|
|
fileWithResult = externalBenchmarksReport
|
|
}
|
|
|
|
}
|
|
|
|
registerExternalBenchmarks.finalizedBy registerExternalBuild
|
|
|
|
def mergeReports(String fileName) {
|
|
def reports = []
|
|
subprojects.each {
|
|
def reportFile = new File("${it.buildDir.absolutePath}/${fileName}")
|
|
if (reportFile.exists()) {
|
|
reports.add(reportFile)
|
|
}
|
|
}
|
|
def output = MPPTools.mergeReports(reports)
|
|
mkdir buildDir.absolutePath
|
|
new File("${buildDir.absolutePath}/${fileName}").write(output)
|
|
}
|
|
|
|
task mergeNativeReports {
|
|
doLast {
|
|
mergeReports(nativeJson)
|
|
uploadBenchmarkResultToArtifactory(nativeJson)
|
|
}
|
|
}
|
|
|
|
task mergeJvmReports {
|
|
doLast {
|
|
mergeReports(jvmJson)
|
|
uploadBenchmarkResultToArtifactory(jvmJson)
|
|
}
|
|
}
|
|
|
|
subprojects.each {
|
|
it.afterEvaluate {
|
|
it.jvmJsonReport.finalizedBy mergeJvmReports
|
|
it.konanJsonReport.finalizedBy mergeNativeReports
|
|
}
|
|
}
|
|
|
|
task teamCityStat(type:Exec) {
|
|
def analyzer = findAnalyzerBinary()
|
|
if (analyzer != null) {
|
|
commandLine "${analyzer}", "-r", "teamcity", "${buildDir.absolutePath}/${nativeJson}"
|
|
} else {
|
|
println("No analyzer $analyzerTool found in subdirectories of ${rootBuildDirectory}/${analyzerToolDirectory}")
|
|
}
|
|
}
|
|
|
|
task cinterop {
|
|
dependsOn 'clean'
|
|
dependsOn 'cinterop:konanRun'
|
|
}
|
|
|
|
task framework {
|
|
dependsOn 'clean'
|
|
dependsOn 'framework:konanRun'
|
|
}
|
|
|
|
task helloworld {
|
|
dependsOn 'clean'
|
|
dependsOn 'helloworld:konanRun'
|
|
}
|
|
|
|
task objcinterop {
|
|
dependsOn 'clean'
|
|
dependsOn 'objcinterop:konanRun'
|
|
}
|
|
|
|
task ring {
|
|
dependsOn 'clean'
|
|
dependsOn 'ring:konanRun'
|
|
}
|
|
|
|
task numerical {
|
|
dependsOn 'clean'
|
|
dependsOn 'numerical:konanRun'
|
|
}
|
|
|
|
task startup {
|
|
dependsOn 'clean'
|
|
dependsOn 'startup:konanRun'
|
|
}
|
|
|
|
task swiftinterop {
|
|
dependsOn 'clean'
|
|
dependsOn 'swiftinterop:konanRun'
|
|
}
|
|
|
|
task videoplayer {
|
|
dependsOn 'clean'
|
|
dependsOn 'videoplayer:konanRun'
|
|
}
|
|
|
|
task KotlinVsSwift {
|
|
dependsOn 'clean'
|
|
dependsOn 'KotlinVsSwift:konanRun'
|
|
} |