From 0c83832f27080b7cd13a1385f880d3c0e91458d4 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 2 Oct 2013 14:53:35 +0400 Subject: [PATCH] Use ReentrantLock instead of intrinsic locks in LockBasedStorageManager --- .../LockBasedLazyResolveStorageManager.java | 63 +++++++++++++++---- .../jet/storage/LockBasedStorageManager.java | 39 +++++++----- 2 files changed, 74 insertions(+), 28 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java index 31ccc38776d..d993a036085 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.Collection; +import java.util.concurrent.locks.Lock; public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager implements LazyResolveStorageManager { @NotNull @@ -40,10 +41,10 @@ public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager } private static class LockProtectedContext implements BindingContext { - private final Object lock; + private final Lock lock; private final BindingContext context; - private LockProtectedContext(Object lock, BindingContext context) { + private LockProtectedContext(Lock lock, BindingContext context) { this.lock = lock; this.context = context; } @@ -51,43 +52,59 @@ public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager @NotNull @Override public Diagnostics getDiagnostics() { - synchronized (lock) { + lock.lock(); + try { return context.getDiagnostics(); } + finally { + lock.unlock(); + } } @Nullable @Override public V get(ReadOnlySlice slice, K key) { - synchronized (lock) { + lock.lock(); + try { return context.get(slice, key); } + finally { + lock.unlock(); + } } @NotNull @Override public Collection getKeys(WritableSlice slice) { - synchronized (lock) { + lock.lock(); + try { return context.getKeys(slice); } + finally { + lock.unlock(); + } } @NotNull @Override @TestOnly public ImmutableMap getSliceContents(@NotNull ReadOnlySlice slice) { - synchronized (lock) { + lock.lock(); + try { return context.getSliceContents(slice); } + finally { + lock.unlock(); + } } } private static class LockProtectedTrace implements BindingTrace { - private final Object lock; + private final Lock lock; private final BindingTrace trace; private final BindingContext context; - public LockProtectedTrace(@NotNull Object lock, @NotNull BindingTrace trace) { + public LockProtectedTrace(@NotNull Lock lock, @NotNull BindingTrace trace) { this.lock = lock; this.trace = trace; this.context = new LockProtectedContext(lock, trace.getBindingContext()); @@ -100,39 +117,59 @@ public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager @Override public void record(WritableSlice slice, K key, V value) { - synchronized (lock) { + lock.lock(); + try { trace.record(slice, key, value); } + finally { + lock.unlock(); + } } @Override public void record(WritableSlice slice, K key) { - synchronized (lock) { + lock.lock(); + try { trace.record(slice, key); } + finally { + lock.unlock(); + } } @Override @Nullable public V get(ReadOnlySlice slice, K key) { - synchronized (lock) { + lock.lock(); + try { return trace.get(slice, key); } + finally { + lock.unlock(); + } } @Override @NotNull public Collection getKeys(WritableSlice slice) { - synchronized (lock) { + lock.lock(); + try { return trace.getKeys(slice); } + finally { + lock.unlock(); + } } @Override public void report(@NotNull Diagnostic diagnostic) { - synchronized (lock) { + lock.lock(); + try { trace.report(diagnostic); } + finally { + lock.unlock(); + } } } } diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java index a32d79741c1..0c837cd33a4 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java @@ -27,15 +27,12 @@ import org.jetbrains.jet.utils.WrappedValues; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; public class LockBasedStorageManager implements StorageManager { - protected final Object lock = new Object() { - @Override - public String toString() { - return "LockBasedStorageManager centralized lock"; - } - }; + protected final Lock lock = new ReentrantLock(); @NotNull @Override @@ -134,9 +131,13 @@ public class LockBasedStorageManager implements StorageManager { @Override public T compute(@NotNull Computable computable) { - synchronized (lock) { + lock.lock(); + try { return computable.compute(); } + finally { + lock.unlock(); + } } private static class LockBasedLazyValue implements NullableLazyValue { @@ -144,13 +145,13 @@ public class LockBasedStorageManager implements StorageManager { private static final Object NOT_COMPUTED = new Object(); private static final Object COMPUTING = new Object(); - private final Object lock; + private final Lock lock; private final Computable computable; @Nullable private volatile Object value = NOT_COMPUTED; - public LockBasedLazyValue(@NotNull Object lock, @NotNull Computable computable) { + public LockBasedLazyValue(@NotNull Lock lock, @NotNull Computable computable) { this.lock = lock; this.computable = computable; } @@ -165,7 +166,8 @@ public class LockBasedStorageManager implements StorageManager { Object _value = value; if (_value != NOT_COMPUTED && _value != COMPUTING) return WrappedValues.unescapeThrowable(_value); - synchronized (lock) { + lock.lock(); + try { _value = value; if (_value == COMPUTING) { Object result = recursionDetected(); @@ -188,6 +190,9 @@ public class LockBasedStorageManager implements StorageManager { throw ExceptionUtils.rethrow(throwable); } } + finally { + lock.unlock(); + } } /** @@ -206,7 +211,7 @@ public class LockBasedStorageManager implements StorageManager { private static class LockBasedNotNullLazyValue extends LockBasedLazyValue implements NotNullLazyValue { - public LockBasedNotNullLazyValue(@NotNull Object lock, @NotNull Computable computable) { + public LockBasedNotNullLazyValue(@NotNull Lock lock, @NotNull Computable computable) { super(lock, computable); } @@ -220,11 +225,11 @@ public class LockBasedStorageManager implements StorageManager { } private static class MapBasedMemoizedFunction implements MemoizedFunctionToNullable { - private final Object lock; + private final Lock lock; private final ConcurrentMap cache; private final Function compute; - public MapBasedMemoizedFunction(@NotNull Object lock, @NotNull ConcurrentMap map, @NotNull Function compute) { + public MapBasedMemoizedFunction(@NotNull Lock lock, @NotNull ConcurrentMap map, @NotNull Function compute) { this.lock = lock; this.cache = map; this.compute = compute; @@ -236,7 +241,8 @@ public class LockBasedStorageManager implements StorageManager { Object value = cache.get(input); if (value != null) return WrappedValues.unescapeExceptionOrNull(value); - synchronized (lock) { + lock.lock(); + try { value = cache.get(input); if (value != null) return WrappedValues.unescapeExceptionOrNull(value); @@ -254,13 +260,16 @@ public class LockBasedStorageManager implements StorageManager { throw ExceptionUtils.rethrow(throwable); } } + finally { + lock.unlock(); + } } } private static class MapBasedMemoizedFunctionToNotNull extends MapBasedMemoizedFunction implements MemoizedFunctionToNotNull { public MapBasedMemoizedFunctionToNotNull( - @NotNull Object lock, + @NotNull Lock lock, @NotNull ConcurrentMap map, @NotNull Function compute ) {