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

Update ZipFileCache and LowMemoryWatcher from new Idea

Browse Source
This commit is contained in:
Nikolay Krasko
2015-04-13 22:24:39 +03:00
parent d036edb5c6
commit ea47e29757
4 changed files with 13 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build.xml
+4
View File
@@ -607,6 +607,10 @@
}
-keep class com.intellij.openapi.util.text.StringHash { *; }
# for gradle plugin and other server tools
-keep class com.intellij.openapi.util.io.ZipFileCache { public *; }
-keep class com.intellij.openapi.util.LowMemoryWatcher { public *; }
-keepclassmembers enum * {
public static **[] values();
public static ** valueOf(java.lang.String);
libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/com/intellij/openapi/util/LowMemoryWatcher.java
+7 -2
View File
@@ -135,13 +135,18 @@ public class LowMemoryWatcher {
ourInstances.remove(this);
}
public static void shutdown() throws InterruptedException, ListenerNotFoundException {
/**
* LowMemoryWatcher maintains a background thread where all the handlers are invoked.
* In server environments, this thread may run indefinitely and prevent the class loader from
* being gc-ed. Thus it's necessary to invoke this method to stop that thread and let the classes be garbage-collected.
*/
public static void stopAll() throws InterruptedException, ListenerNotFoundException {
ourInstances.clear();
((NotificationEmitter)ManagementFactory.getMemoryMXBean()).removeNotificationListener(lowMemoryListener);
ourExecutor.shutdown();
boolean terminated = ourExecutor.awaitTermination(1000, TimeUnit.MICROSECONDS);
boolean terminated = ourExecutor.awaitTermination(50, TimeUnit.MICROSECONDS);
if (!terminated) {
ourExecutor.shutdownNow();
}
libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/com/intellij/openapi/util/io/ZipFileCache.java
-237
View File
@@ -1,237 +0,0 @@
/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* 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
*
* http://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.
*/
package com.intellij.openapi.util.io;
import com.intellij.openapi.diagnostic.LogUtil;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.util.ConcurrencyUtil;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.zip.ZipFile;
/**
* PATCHED VERSION of com.intellij.openapi.util.io.ZipFileCache
* shutdown() method added to stop background thread.
*/
@SuppressWarnings("UnusedDeclaration")
public class ZipFileCache {
private static final int PERIOD = 10000; // disposer schedule, ms
private static final int TIMEOUT = 30000; // released file close delay, ms
private static class CacheRecord {
private final String path;
private final ZipFile file;
private int count = 1;
private long released = 0;
private CacheRecord(@NotNull String path, @NotNull ZipFile file) throws IOException {
this.path = path;
this.file = file;
}
}
private static final Object ourLock = new Object();
private static final Map<String, CacheRecord> ourPathCache = ContainerUtil.newTroveMap(FileUtil.PATH_HASHING_STRATEGY);
private static final Map<ZipFile, CacheRecord> ourFileCache = ContainerUtil.newHashMap();
private static final Map<ZipFile, Integer> ourQueue = ContainerUtil.newHashMap();
private static final ScheduledThreadPoolExecutor scheduledCloseExecutor;
static {
scheduledCloseExecutor =
ConcurrencyUtil.newSingleScheduledThreadExecutor("ZipFileCache Dispose", Thread.MIN_PRIORITY);
scheduledCloseExecutor.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
List<ZipFile> toClose = getFilesToClose(0, System.currentTimeMillis() - TIMEOUT);
if (toClose != null) {
close(toClose);
}
}
}, PERIOD, PERIOD, TimeUnit.MILLISECONDS);
}
@NotNull
public static ZipFile acquire(@NotNull String path) throws IOException {
path = FileUtil.toCanonicalPath(path);
synchronized (ourLock) {
CacheRecord record = ourPathCache.get(path);
if (record != null) {
record.count++;
return record.file;
}
}
CacheRecord record;
ZipFile file = tryOpen(path);
synchronized (ourLock) {
record = ourPathCache.get(path);
if (record == null) {
record = new CacheRecord(path, file);
ourPathCache.put(path, record);
ourFileCache.put(file, record);
return file;
}
else {
record.count++;
}
}
close(file);
return record.file;
}
private static ZipFile tryOpen(String path) throws IOException {
path = FileUtil.toSystemDependentName(path);
debug("opening %s", path);
try {
return new ZipFile(path);
}
catch (IOException e) {
String reason = e.getMessage();
if ("too many open files".equalsIgnoreCase(reason) && tryCloseFiles() > 0) {
return new ZipFile(path);
}
else {
throw e;
}
}
}
private static int tryCloseFiles() {
List<ZipFile> toClose = getFilesToClose(5, 0);
if (toClose == null) return 0;
close(toClose);
logger().warn("too many open files, closed: " + toClose.size());
return toClose.size();
}
@Nullable
private static List<ZipFile> getFilesToClose(int limit, long timeout) {
List<ZipFile> toClose = null;
synchronized (ourLock) {
Iterator<CacheRecord> i = ourPathCache.values().iterator();
while (i.hasNext() && (limit == 0 || toClose == null || toClose.size() < limit)) {
CacheRecord record = i.next();
if (record.count <= 0 && (timeout == 0 || record.released <= timeout)) {
i.remove();
ourFileCache.remove(record.file);
if (toClose == null) toClose = ContainerUtil.newArrayList();
toClose.add(record.file);
}
}
}
return toClose;
}
public static void release(@NotNull ZipFile file) {
synchronized (ourLock) {
CacheRecord record = ourFileCache.get(file);
if (record != null) {
record.count--;
record.released = System.currentTimeMillis();
logger().assertTrue(record.count >= 0, record.path);
return;
}
Integer count = ourQueue.get(file);
if (count != null) {
count--;
if (count == 0) {
ourQueue.remove(file);
close(file);
}
else {
ourQueue.put(file, count);
}
return;
}
}
logger().warn(new IllegalArgumentException("stray file: " + file.getName()));
close(file);
}
public static void reset(@NotNull Collection<String> paths) {
debug("resetting %s", paths);
List<ZipFile> toClose = ContainerUtil.newSmartList();
synchronized (ourLock) {
for (String path : paths) {
path = FileUtil.toCanonicalPath(path);
CacheRecord record = ourPathCache.remove(path);
if (record != null) {
ourFileCache.remove(record.file);
if (record.count > 0) {
ourQueue.put(record.file, record.count);
}
else {
toClose.add(record.file);
}
}
}
}
close(toClose);
}
private static void close(@NotNull List<ZipFile> files) {
for (ZipFile file : files) {
close(file);
}
}
private static void close(@NotNull ZipFile file) {
debug("closing %s", file.getName());
try {
file.close();
}
catch (IOException e) {
logger().info(file.getName(), e);
}
}
private static Logger logger() {
return Logger.getInstance(ZipFileCache.class);
}
private static void debug(@NotNull String format, Object... args) {
LogUtil.debug(logger(), format, args);
}
public static void shutdown() throws InterruptedException {
scheduledCloseExecutor.shutdown();
boolean terminated = scheduledCloseExecutor.awaitTermination(TIMEOUT, TimeUnit.MICROSECONDS);
if (!terminated) {
scheduledCloseExecutor.shutdownNow();
}
}
}
libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/FinishBuildListener.kt
+2 -2
View File
@@ -72,12 +72,12 @@ class FinishBuildListener(var pluginClassLoader: ParentLastURLClassLoader?) : Bu
}
private fun stopZipFileCache() {
callVoidStaticMethod("com.intellij.openapi.util.io.ZipFileCache", "shutdown")
callVoidStaticMethod("com.intellij.openapi.util.io.ZipFileCache", "stopBackgroundThread")
log.debug("ZipFileCache finished successfully")
}
private fun stopLowMemoryWatcher() {
callVoidStaticMethod("com.intellij.openapi.util.LowMemoryWatcher", "shutdown")
callVoidStaticMethod("com.intellij.openapi.util.LowMemoryWatcher", "stopAll")
log.debug("LowMemoryWatcher finished successfully")
}