OneFilePerformance.kt

package org.javacs.kt;

import com.intellij.openapi.Disposable;
import com.intellij.openapi.vfs.StandardFileSystems;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.openapi.vfs.VirtualFileSystem;
import com.intellij.psi.PsiManager;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.kotlin.cli.jvm.compiler.CliBindingTrace;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.config.CommonConfigurationKeys;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.container.ComponentProvider;
import org.jetbrains.kotlin.container.ValueDescriptor;
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.load.java.JvmAbi;
import org.jetbrains.kotlin.psi.KtElement;
import org.jetbrains.kotlin.psi.KtFile;
import org.jetbrains.kotlin.psi.KtPsiFactory;
import org.jetbrains.kotlin.resolve.BindingTraceContext;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.TopDownAnalysisMode;
import org.jetbrains.kotlin.resolve.calls.callUtil.getParentResolvedCall;
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory;
import org.junit.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.lang.reflect.Type;
import java.net.URL;

class OneFilePerformance {
    @State(Scope.Thread)
    class ReusableParts {
        internal var config = CompilerConfiguration()
        init {
            config.put(CommonConfigurationKeys.MODULE_NAME, JvmAbi.DEFAULT_MODULE_NAME)
        }
        internal var env = KotlinCoreEnvironment.createForProduction(object: Disposable {
            override fun dispose() {
                // Do nothing
            }
        }, config, EnvironmentConfigFiles.JVM_CONFIG_FILES)
        internal var parser = KtPsiFactory(env.project)
        internal var fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL)
        internal var bigFile = openFile("/kotlinCompilerPerformance/BigFile.kt")
        
        internal fun openFile(resourcePath: String?): KtFile {
            val locate = OneFilePerformance::class.java.getResource(resourcePath)
            val file = fileSystem.findFileByPath(locate.path)
            return PsiManager.getInstance(env.project).findFile(file!!) as KtFile
        }
        
        internal fun compile(compile: Collection<KtFile>, sourcePath: Collection<KtFile>): BindingTraceContext {
            val trace = CliBindingTrace()
            val container = CompilerFixtures.createContainer(
                env.project,
                sourcePath,
                trace,
                env.configuration,
                env::createPackagePartProvider
            )
            val analyze = container.create(LazyTopDownAnalyzer::class.java)
            analyze.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, compile, DataFlowInfoFactory.EMPTY)
            return trace
        }
    }
    
    @Benchmark
    fun recompileBigFile(state: ReusableParts) {
        val path = listOf(state.bigFile);
        state.compile(path, path)
    }
    
    @Benchmark
    fun recompileSmallFile(state: ReusableParts) {
        val smallFile = state.openFile("/kotlinCompilerPerformance/ReferencesBigFile.kt")
        val analyze = state.compile(listOf(smallFile), listOf(smallFile, state.bigFile))
        // Check reference
        val ref = PsiTreeUtil.getNonStrictParentOfType(smallFile.findElementAt(80), KtElement::class.java)
        val call = ref.getParentResolvedCall(analyze.getBindingContext(), false)
        if (!call!!.getCandidateDescriptor().getName().asString().equals("max"))
            throw RuntimeException("Expected BigFile.max but found " + call)
    }
    
    @Benchmark
    fun recompileBoth(state: ReusableParts) {
        val bigFile = state.openFile("/kotlinCompilerPerformance/BigFile.kt")
        val smallFile = state.openFile("/kotlinCompilerPerformance/ReferencesBigFile.kt")
        val analyze = state.compile(listOf(smallFile, bigFile), listOf(smallFile, bigFile))
        // Check reference
        val ref = PsiTreeUtil.getNonStrictParentOfType(smallFile.findElementAt(80), KtElement::class.java)
        val call = ref.getParentResolvedCall(analyze.getBindingContext(), false)
        if (!call!!.getCandidateDescriptor().getName().asString().equals("max"))
            throw RuntimeException("Expected BigFile.max but found " + call)
    }
    
    @Test
    fun checkRecompileBoth() {
        val state = ReusableParts()
        recompileBoth(state)
    }
    
    @Test
    fun checkRecompileOne() {
        val state = ReusableParts()
        state.compile(setOf(state.bigFile), setOf(state.bigFile))
        recompileSmallFile(state)
    }
    
    companion object {
        @Throws(RunnerException::class, InterruptedException::class)
        @JvmStatic fun main(args: Array<String>) {
            val opt = OptionsBuilder().include(OneFilePerformance::class.java.getSimpleName())
                    .forks(1)
                    .threads(1)
                    .warmupIterations(5)
                    .measurementIterations(5)
                    .build()
            Runner(opt).run()
        }
    }
}