azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merging callback services into single facade - phase 2 - rewriting interfaces and implementations

Browse Source
This commit is contained in:
Ilya Chernikov
2015-10-07 12:17:13 +02:00
parent 0f33633cc5
commit 391c292b8d
9 changed files with 135 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/CompilerCallbackServicesFacadeServer.kt
+51 -71
View File
@@ -18,89 +18,69 @@ package org.jetbrains.kotlin.rmi.kotlinr
import org.jetbrains.kotlin.incremental.components.LookupTracker
import org.jetbrains.kotlin.incremental.components.ScopeKind
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
import org.jetbrains.kotlin.modules.TargetId
import org.jetbrains.kotlin.progress.CompilationCanceledStatus
import org.jetbrains.kotlin.rmi.*
import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade
import org.jetbrains.kotlin.rmi.LoopbackNetworkInterface
import org.jetbrains.kotlin.rmi.SOCKET_ANY_FREE_PORT
import java.rmi.server.UnicastRemoteObject
public class RemoteIncrementalCompilationComponentsServer(val base: IncrementalCompilationComponents, val port: Int = SOCKET_ANY_FREE_PORT) : RemoteIncrementalCompilationComponents {
public class CompilerCallbackServicesFacadeServer(
val incrementalCompilationComponents: IncrementalCompilationComponents? = null,
val compilationCancelledStatus: CompilationCanceledStatus? = null,
port: Int = SOCKET_ANY_FREE_PORT
) : CompilerCallbackServicesFacade {
init {
UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory)
}
private val cacheServers = hashMapOf<TargetId, RemoteIncrementalCacheServer>()
private val lookupTrackerServer by lazy { RemoteLookupTrackerServer(base.getLookupTracker()) }
override fun getIncrementalCache(target: TargetId): RemoteIncrementalCache =
cacheServers.get(target) ?: {
val newServer = RemoteIncrementalCacheServer(base.getIncrementalCache(target), port)
cacheServers.put(target, newServer)
newServer
}()
override fun getLookupTracker(): RemoteLookupTracker = lookupTrackerServer
}
public class RemoteIncrementalCacheServer(val cache: IncrementalCache, port: Int = SOCKET_ANY_FREE_PORT) : RemoteIncrementalCache {
init {
UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory)
}
override fun getObsoletePackageParts(): Collection<String> = cache.getObsoletePackageParts()
override fun getObsoleteMultifileClassFacades(): Collection<String> = cache.getObsoleteMultifileClasses()
override fun getMultifileFacadeParts(internalName: String): Collection<String>? = cache.getStableMultifileFacadeParts(internalName)
override fun getMultifileFacade(partInternalName: String): String? = cache.getMultifileFacade(partInternalName)
override fun getPackagePartData(fqName: String): JvmPackagePartProto? = cache.getPackagePartData(fqName)
override fun getModuleMappingData(): ByteArray? = cache.getModuleMappingData()
override fun registerInline(fromPath: String, jvmSignature: String, toPath: String) {
cache.registerInline(fromPath, jvmSignature, toPath)
}
override fun getClassFilePath(internalClassName: String): String = cache.getClassFilePath(internalClassName)
override fun close() {
cache.close()
}
public fun disconnect() {
UnicastRemoteObject.unexportObject(this, true)
}
override fun hasIncrementalCaches(): Boolean = incrementalCompilationComponents != null
override fun hasLookupTracker(): Boolean = incrementalCompilationComponents != null
override fun hasCompilationCanceledStatus(): Boolean = compilationCancelledStatus != null
// TODO: consider replacing NPE with other reporting, although NPE here means most probably incorrect usage
override fun incrementalCache_getObsoletePackageParts(target: TargetId): Collection<String> = incrementalCompilationComponents!!.getIncrementalCache(target).getObsoletePackageParts()
override fun incrementalCache_getObsoleteMultifileClassFacades(target: TargetId): Collection<String> = incrementalCompilationComponents!!.getIncrementalCache(target).getObsoleteMultifileClasses()
override fun incrementalCache_getMultifileFacadeParts(target: TargetId, internalName: String): Collection<String>? = incrementalCompilationComponents!!.getIncrementalCache(target).getStableMultifileFacadeParts(internalName)
override fun incrementalCache_getMultifileFacade(target: TargetId, partInternalName: String): String? = incrementalCompilationComponents!!.getIncrementalCache(target).getMultifileFacade(partInternalName)
override fun incrementalCache_getPackagePartData(target: TargetId, fqName: String): JvmPackagePartProto? = incrementalCompilationComponents!!.getIncrementalCache(target).getPackagePartData(fqName)
override fun incrementalCache_getModuleMappingData(target: TargetId): ByteArray? = incrementalCompilationComponents!!.getIncrementalCache(target).getModuleMappingData()
override fun incrementalCache_registerInline(target: TargetId, fromPath: String, jvmSignature: String, toPath: String) {
incrementalCompilationComponents!!.getIncrementalCache(target).registerInline(fromPath, jvmSignature, toPath)
}
override fun incrementalCache_getClassFilePath(target: TargetId, internalClassName: String): String = incrementalCompilationComponents!!.getIncrementalCache(target).getClassFilePath(internalClassName)
override fun incrementalCache_close(target: TargetId) {
incrementalCompilationComponents!!.getIncrementalCache(target).close()
}
override fun lookupTracker_record(lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, scopeFqName: String, scopeKind: ScopeKind, name: String) {
incrementalCompilationComponents!!.getLookupTracker().record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name)
}
private val lookupTracker_isDoNothing: Boolean = incrementalCompilationComponents != null && incrementalCompilationComponents.getLookupTracker() == LookupTracker.DO_NOTHING
override fun lookupTracker_isDoNothing(): Boolean = lookupTracker_isDoNothing
override fun compilationCanceledStatus_checkCanceled() {
compilationCancelledStatus!!.checkCanceled()
}
}
public class RemoteLookupTrackerServer(val base: LookupTracker, port: Int = SOCKET_ANY_FREE_PORT) : RemoteLookupTracker {
init {
UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory)
}
override fun record(lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, scopeFqName: String, scopeKind: ScopeKind, name: String) {
base.record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name)
}
private val _isDoNothing: Boolean = base == LookupTracker.DO_NOTHING
override fun isDoNothing(): Boolean = _isDoNothing
}
public class RemoteCompilationCanceledStatusServer(val base: CompilationCanceledStatus, port: Int = SOCKET_ANY_FREE_PORT) : RemoteCompilationCanceledStatus {
init {
UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory)
}
override fun checkCanceled() {
base.checkCanceled()
}
}
compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/KotlinCompilerClient.kt
+9 -12
View File
@@ -114,10 +114,12 @@ public object KotlinCompilerClient {
public fun compile(compiler: CompileService, args: Array<out String>, out: OutputStream): Int {
val outStrm = RemoteOutputStreamServer(out)
val servicesFacade = CompilerCallbackServicesFacadeServer()
try {
return compiler.remoteCompile(args, makeRemoteServices(CompilationServices()), outStrm, CompileService.OutputFormat.PLAIN, outStrm)
return compiler.remoteCompile(args, servicesFacade, outStrm, CompileService.OutputFormat.PLAIN, outStrm)
}
finally {
servicesFacade.disconnect()
outStrm.disconnect()
}
}
@@ -127,24 +129,17 @@ public object KotlinCompilerClient {
val compilerOutStreamServer = RemoteOutputStreamServer(compilerOut)
val daemonOutStreamServer = RemoteOutputStreamServer(daemonOut)
val cacheServers = hashMapOf<TargetId, RemoteIncrementalCacheServer>()
val servicesFacade = CompilerCallbackServicesFacadeServer(incrementalCompilationComponents = services.incrementalCompilationComponents, compilationCancelledStatus = services.compilationCanceledStatus)
try {
return profiler.withMeasure(this) { compiler.remoteIncrementalCompile(args, makeRemoteServices(services), compilerOutStreamServer, CompileService.OutputFormat.XML, daemonOutStreamServer) }
return profiler.withMeasure(this) { compiler.remoteIncrementalCompile(args, servicesFacade, compilerOutStreamServer, CompileService.OutputFormat.XML, daemonOutStreamServer) }
}
finally {
cacheServers.forEach { it.getValue().disconnect() }
servicesFacade.disconnect()
compilerOutStreamServer.disconnect()
daemonOutStreamServer.disconnect()
}
}
fun makeRemoteServices(services: CompilationServices): RemoteCompilationServices =
RemoteCompilationServices(
incrementalCompilationComponents = if (services.incrementalCompilationComponents == null) null else RemoteIncrementalCompilationComponentsServer(services.incrementalCompilationComponents),
compilationCanceledStatus = if (services.compilationCanceledStatus == null) null else RemoteCompilationCanceledStatusServer(services.compilationCanceledStatus)
)
data class ClientOptions(
public var stop: Boolean = false
) : OptionsGroup {
@@ -202,11 +197,12 @@ public object KotlinCompilerClient {
else -> {
println("Executing daemon compilation with args: " + filteredArgs.joinToString(" "))
val outStrm = RemoteOutputStreamServer(System.out)
val servicesFacade = CompilerCallbackServicesFacadeServer()
try {
val memBefore = daemon.getUsedMemory() / 1024
val startTime = System.nanoTime()
val res = daemon.remoteCompile(filteredArgs.toArrayList().toTypedArray(), makeRemoteServices(CompilationServices()), outStrm, CompileService.OutputFormat.PLAIN, outStrm)
val res = daemon.remoteCompile(filteredArgs.toArrayList().toTypedArray(), servicesFacade, outStrm, CompileService.OutputFormat.PLAIN, outStrm)
val endTime = System.nanoTime()
println("Compilation result code: $res")
@@ -215,6 +211,7 @@ public object KotlinCompilerClient {
println("Used memory $memAfter (${"%+d".format(memAfter - memBefore)} kb)")
}
finally {
servicesFacade.disconnect()
outStrm.disconnect()
}
}
compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompileService.kt
+2 -2
View File
@@ -38,7 +38,7 @@ public interface CompileService : Remote {
@Throws(RemoteException::class)
public fun remoteCompile(
args: Array<out String>,
services: RemoteCompilationServices,
servicesFacade: CompilerCallbackServicesFacade,
compilerOutputStream: RemoteOutputStream,
outputFormat: OutputFormat,
serviceOutputStream: RemoteOutputStream
@@ -47,7 +47,7 @@ public interface CompileService : Remote {
@Throws(RemoteException::class)
public fun remoteIncrementalCompile(
args: Array<out String>,
services: RemoteCompilationServices,
servicesFacade: CompilerCallbackServicesFacade,
compilerOutputStream: RemoteOutputStream,
compilerOutputFormat: OutputFormat,
serviceOutputStream: RemoteOutputStream
compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompilerCallbackServicesFacade.kt
+39 -34
View File
@@ -19,42 +19,59 @@ package org.jetbrains.kotlin.rmi
import org.jetbrains.kotlin.incremental.components.ScopeKind
import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
import org.jetbrains.kotlin.modules.TargetId
import java.io.Serializable
import java.rmi.Remote
import java.rmi.RemoteException
public interface RemoteIncrementalCache : Remote {
@Throws(RemoteException::class)
public fun getObsoletePackageParts(): Collection<String>
/**
* common facade for compiler services exposed from client process (e.g. JPS) to the compiler running on daemon
* the reason for having common facade is attempt to reduce number of connections between client and daemon
* Note: non-standard naming convention used to denote combining several entities in one facade - prefix <entityName>_ is used for every function belonging to the entity
*/
public interface CompilerCallbackServicesFacade : Remote {
@Throws(RemoteException::class)
public fun getObsoleteMultifileClassFacades(): Collection<String>
public fun hasIncrementalCaches(): Boolean
@Throws(RemoteException::class)
public fun getMultifileFacade(partInternalName: String): String?
public fun hasLookupTracker(): Boolean
@Throws(RemoteException::class)
public fun getPackagePartData(fqName: String): JvmPackagePartProto?
public fun hasCompilationCanceledStatus(): Boolean
// ----------------------------------------------------
// IncrementalCache
@Throws(RemoteException::class)
public fun incrementalCache_getObsoletePackageParts(target: TargetId): Collection<String>
@Throws(RemoteException::class)
public fun getModuleMappingData(): ByteArray?
public fun incrementalCache_getObsoleteMultifileClassFacades(target: TargetId): Collection<String>
@Throws(RemoteException::class)
public fun registerInline(fromPath: String, jvmSignature: String, toPath: String)
public fun incrementalCache_getMultifileFacade(target: TargetId, partInternalName: String): String?
@Throws(RemoteException::class)
fun getClassFilePath(internalClassName: String): String
public fun incrementalCache_getPackagePartData(target: TargetId, fqName: String): JvmPackagePartProto?
@Throws(RemoteException::class)
public fun close()
public fun incrementalCache_getModuleMappingData(target: TargetId): ByteArray?
@Throws(RemoteException::class)
public fun getMultifileFacadeParts(internalName: String): Collection<String>?
}
public fun incrementalCache_registerInline(target: TargetId, fromPath: String, jvmSignature: String, toPath: String)
public interface RemoteLookupTracker : Remote {
@Throws(RemoteException::class)
fun record(
fun incrementalCache_getClassFilePath(target: TargetId, internalClassName: String): String
@Throws(RemoteException::class)
public fun incrementalCache_close(target: TargetId)
@Throws(RemoteException::class)
public fun incrementalCache_getMultifileFacadeParts(target: TargetId, internalName: String): Collection<String>?
// ----------------------------------------------------
// LookupTracker
@Throws(RemoteException::class)
fun lookupTracker_record(
lookupContainingFile: String,
lookupLine: Int?,
lookupColumn: Int?,
@@ -62,25 +79,13 @@ public interface RemoteLookupTracker : Remote {
scopeKind: ScopeKind,
name: String
)
@Throws(RemoteException::class)
fun isDoNothing(): Boolean
fun lookupTracker_isDoNothing(): Boolean
// ----------------------------------------------------
// CompilationCanceledStatus
@Throws(RemoteException::class)
fun compilationCanceledStatus_checkCanceled(): Unit
}
public interface RemoteIncrementalCompilationComponents : Remote {
@Throws(RemoteException::class)
public fun getIncrementalCache(target: TargetId): RemoteIncrementalCache
@Throws(RemoteException::class)
public fun getLookupTracker(): RemoteLookupTracker
}
public interface RemoteCompilationCanceledStatus : Remote {
@Throws(RemoteException::class)
fun checkCanceled(): Unit
}
public data class RemoteCompilationServices(
public val incrementalCompilationComponents: RemoteIncrementalCompilationComponents? = null,
public val compilationCanceledStatus: RemoteCompilationCanceledStatus? = null
) : Serializable
compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/CompileServiceImpl.kt
+11 -7
View File
@@ -59,7 +59,7 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
}
override fun remoteCompile(args: Array<out String>,
services: RemoteCompilationServices,
servicesFacade: CompilerCallbackServicesFacade,
compilerOutputStream: RemoteOutputStream,
outputFormat: CompileService.OutputFormat,
serviceOutputStream: RemoteOutputStream
@@ -67,12 +67,12 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
doCompile(args, compilerOutputStream, serviceOutputStream) { printStream, profiler ->
when (outputFormat) {
CompileService.OutputFormat.PLAIN -> compiler.exec(printStream, *args)
CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(services, profiler), *args)
CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(servicesFacade, profiler), *args)
}
}
override fun remoteIncrementalCompile(args: Array<out String>,
services: RemoteCompilationServices,
servicesFacade: CompilerCallbackServicesFacade,
compilerOutputStream: RemoteOutputStream,
compilerOutputFormat: CompileService.OutputFormat,
serviceOutputStream: RemoteOutputStream
@@ -80,7 +80,7 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
doCompile(args, compilerOutputStream, serviceOutputStream) { printStream, profiler ->
when (compilerOutputFormat) {
CompileService.OutputFormat.PLAIN -> throw NotImplementedError("Only XML output is supported in remote incremental compilation")
CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(services, profiler), *args)
CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(servicesFacade, profiler), *args)
}
}
@@ -134,10 +134,14 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
}
}
private fun createCompileServices(services: RemoteCompilationServices, rpcProfiler: Profiler): Services {
private fun createCompileServices(facade: CompilerCallbackServicesFacade, rpcProfiler: Profiler): Services {
val builder = Services.Builder()
services.incrementalCompilationComponents?.let { builder.register(IncrementalCompilationComponents::class.java, RemoteIncrementalCompilationComponentsClient(it, rpcProfiler)) }
services.compilationCanceledStatus?.let { builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(it, rpcProfiler)) }
if (facade.hasIncrementalCaches() || facade.hasLookupTracker()) {
builder.register(IncrementalCompilationComponents::class.java, RemoteIncrementalCompilationComponentsClient(facade, rpcProfiler))
}
if (facade.hasCompilationCanceledStatus()) {
builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(facade, rpcProfiler))
}
return builder.build()
}
compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteCompilationCanceledStatusClient.kt
+3 -3
View File
@@ -17,13 +17,13 @@
package org.jetbrains.kotlin.rmi.service
import org.jetbrains.kotlin.progress.CompilationCanceledStatus
import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade
import org.jetbrains.kotlin.rmi.DummyProfiler
import org.jetbrains.kotlin.rmi.Profiler
import org.jetbrains.kotlin.rmi.RemoteCompilationCanceledStatus
class RemoteCompilationCanceledStatusClient(val proxy: RemoteCompilationCanceledStatus, val profiler: Profiler = DummyProfiler()): CompilationCanceledStatus {
class RemoteCompilationCanceledStatusClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()): CompilationCanceledStatus {
override fun checkCanceled() {
profiler.withMeasure(this) { proxy.checkCanceled() }
profiler.withMeasure(this) { facade.compilationCanceledStatus_checkCanceled() }
}
}
compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCacheClient.kt
+12 -11
View File
@@ -18,29 +18,30 @@ package org.jetbrains.kotlin.rmi.service
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
import org.jetbrains.kotlin.modules.TargetId
import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade
import org.jetbrains.kotlin.rmi.DummyProfiler
import org.jetbrains.kotlin.rmi.Profiler
import org.jetbrains.kotlin.rmi.RemoteIncrementalCache
public class RemoteIncrementalCacheClient(val cache: RemoteIncrementalCache, val profiler: Profiler = DummyProfiler()): IncrementalCache {
public class RemoteIncrementalCacheClient(val facade: CompilerCallbackServicesFacade, val target: TargetId, val profiler: Profiler = DummyProfiler()): IncrementalCache {
override fun getObsoletePackageParts(): Collection<String> = profiler.withMeasure(this) { cache.getObsoletePackageParts() }
override fun getObsoletePackageParts(): Collection<String> = profiler.withMeasure(this) { facade.incrementalCache_getObsoletePackageParts(target) }
override fun getObsoleteMultifileClasses(): Collection<String> = profiler.withMeasure(this) { cache.getObsoleteMultifileClassFacades() }
override fun getObsoleteMultifileClasses(): Collection<String> = profiler.withMeasure(this) { facade.incrementalCache_getObsoleteMultifileClassFacades(target) }
override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection<String>? = profiler.withMeasure(this) { cache.getMultifileFacadeParts(facadeInternalName) }
override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection<String>? = profiler.withMeasure(this) { facade.incrementalCache_getMultifileFacadeParts(target, facadeInternalName) }
override fun getPackagePartData(fqName: String): JvmPackagePartProto? = profiler.withMeasure(this) { cache.getPackagePartData(fqName) }
override fun getPackagePartData(fqName: String): JvmPackagePartProto? = profiler.withMeasure(this) { facade.incrementalCache_getPackagePartData(target, fqName) }
override fun getMultifileFacade(partInternalName: String): String? = profiler.withMeasure(this) { cache.getMultifileFacade(partInternalName) }
override fun getMultifileFacade(partInternalName: String): String? = profiler.withMeasure(this) { facade.incrementalCache_getMultifileFacade(target, partInternalName) }
override fun getModuleMappingData(): ByteArray? = profiler.withMeasure(this) { cache.getModuleMappingData() }
override fun getModuleMappingData(): ByteArray? = profiler.withMeasure(this) { facade.incrementalCache_getModuleMappingData(target) }
override fun registerInline(fromPath: String, jvmSignature: String, toPath: String) {
profiler.withMeasure(this) { cache.registerInline(fromPath, jvmSignature, toPath) }
profiler.withMeasure(this) { facade.incrementalCache_registerInline(target, fromPath, jvmSignature, toPath) }
}
override fun getClassFilePath(internalClassName: String): String = profiler.withMeasure(this) { cache.getClassFilePath(internalClassName) }
override fun getClassFilePath(internalClassName: String): String = profiler.withMeasure(this) { facade.incrementalCache_getClassFilePath(target,internalClassName) }
override fun close(): Unit = profiler.withMeasure(this) { cache.close() }
override fun close(): Unit = profiler.withMeasure(this) { facade.incrementalCache_close(target) }
}
compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCompilationComponentsClient.kt
+4 -4
View File
@@ -20,14 +20,14 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
import org.jetbrains.kotlin.modules.TargetId
import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade
import org.jetbrains.kotlin.rmi.DummyProfiler
import org.jetbrains.kotlin.rmi.Profiler
import org.jetbrains.kotlin.rmi.RemoteIncrementalCompilationComponents
class RemoteIncrementalCompilationComponentsClient(val proxy: RemoteIncrementalCompilationComponents, val profiler: Profiler = DummyProfiler()) : IncrementalCompilationComponents {
class RemoteIncrementalCompilationComponentsClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()) : IncrementalCompilationComponents {
override fun getIncrementalCache(target: TargetId): IncrementalCache = RemoteIncrementalCacheClient(profiler.withMeasure(this) { proxy.getIncrementalCache(target) }, profiler)
override fun getIncrementalCache(target: TargetId): IncrementalCache = RemoteIncrementalCacheClient(facade, target, profiler)
override fun getLookupTracker(): LookupTracker = RemoteLookupTrackerClient(profiler.withMeasure(this) { proxy.getLookupTracker() }, profiler)
override fun getLookupTracker(): LookupTracker = RemoteLookupTrackerClient(facade, profiler)
}
compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteLookupTrackerClient.kt
+4 -4
View File
@@ -18,19 +18,19 @@ package org.jetbrains.kotlin.rmi.service
import org.jetbrains.kotlin.incremental.components.LookupTracker
import org.jetbrains.kotlin.incremental.components.ScopeKind
import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade
import org.jetbrains.kotlin.rmi.DummyProfiler
import org.jetbrains.kotlin.rmi.Profiler
import org.jetbrains.kotlin.rmi.RemoteLookupTracker
class RemoteLookupTrackerClient(val proxy: RemoteLookupTracker, val profiler: Profiler = DummyProfiler()) : LookupTracker {
class RemoteLookupTrackerClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()) : LookupTracker {
private val isDoNothing = profiler.withMeasure(this) { proxy.isDoNothing() }
private val isDoNothing = profiler.withMeasure(this) { facade.lookupTracker_isDoNothing() }
override fun record(lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, scopeFqName: String, scopeKind: ScopeKind, name: String) {
if (!isDoNothing) {
profiler.withMeasure(this) {
proxy.record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name)
facade.lookupTracker_record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name)
}
}
}