| /* |
| * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package jdk.internal.loader; |
| |
| import jdk.internal.misc.JavaLangAccess; |
| import jdk.internal.misc.SharedSecrets; |
| |
| import java.lang.reflect.UndeclaredThrowableException; |
| import java.util.Iterator; |
| import java.util.Objects; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.function.BiFunction; |
| import java.util.function.Supplier; |
| |
| /** |
| * AbstractClassLoaderValue is a superclass of root-{@link ClassLoaderValue} |
| * and {@link Sub sub}-ClassLoaderValue. |
| * |
| * @param <CLV> the type of concrete ClassLoaderValue (this type) |
| * @param <V> the type of values associated with ClassLoaderValue |
| */ |
| public abstract class AbstractClassLoaderValue<CLV extends AbstractClassLoaderValue<CLV, V>, V> { |
| |
| /** |
| * Sole constructor. |
| */ |
| AbstractClassLoaderValue() {} |
| |
| /** |
| * Returns the key component of this ClassLoaderValue. The key component of |
| * the root-{@link ClassLoaderValue} is the ClassLoaderValue itself, |
| * while the key component of a {@link #sub(Object) sub}-ClassLoaderValue |
| * is what was given to construct it. |
| * |
| * @return the key component of this ClassLoaderValue. |
| */ |
| public abstract Object key(); |
| |
| /** |
| * Constructs new sub-ClassLoaderValue of this ClassLoaderValue with given |
| * key component. |
| * |
| * @param key the key component of the sub-ClassLoaderValue. |
| * @param <K> the type of the key component. |
| * @return a sub-ClassLoaderValue of this ClassLoaderValue for given key |
| */ |
| public <K> Sub<K> sub(K key) { |
| return new Sub<>(key); |
| } |
| |
| /** |
| * Returns {@code true} if this ClassLoaderValue is equal to given {@code clv} |
| * or if this ClassLoaderValue was derived from given {@code clv} by a chain |
| * of {@link #sub(Object)} invocations. |
| * |
| * @param clv the ClassLoaderValue to test this against |
| * @return if this ClassLoaderValue is equal to given {@code clv} or |
| * its descendant |
| */ |
| public abstract boolean isEqualOrDescendantOf(AbstractClassLoaderValue<?, V> clv); |
| |
| /** |
| * Returns the value associated with this ClassLoaderValue and given ClassLoader |
| * or {@code null} if there is none. |
| * |
| * @param cl the ClassLoader for the associated value |
| * @return the value associated with this ClassLoaderValue and given ClassLoader |
| * or {@code null} if there is none. |
| */ |
| public V get(ClassLoader cl) { |
| Object val = AbstractClassLoaderValue.<CLV>map(cl).get(this); |
| try { |
| return extractValue(val); |
| } catch (Memoizer.RecursiveInvocationException e) { |
| // propagate recursive get() for the same key that is just |
| // being calculated in computeIfAbsent() |
| throw e; |
| } catch (Throwable t) { |
| // don't propagate exceptions thrown from Memoizer - pretend |
| // that there was no entry |
| // (computeIfAbsent invocation will try to remove it anyway) |
| return null; |
| } |
| } |
| |
| /** |
| * Associates given value {@code v} with this ClassLoaderValue and given |
| * ClassLoader and returns {@code null} if there was no previously associated |
| * value or does nothing and returns previously associated value if there |
| * was one. |
| * |
| * @param cl the ClassLoader for the associated value |
| * @param v the value to associate |
| * @return previously associated value or null if there was none |
| */ |
| public V putIfAbsent(ClassLoader cl, V v) { |
| ConcurrentHashMap<CLV, Object> map = map(cl); |
| @SuppressWarnings("unchecked") |
| CLV clv = (CLV) this; |
| while (true) { |
| try { |
| Object val = map.putIfAbsent(clv, v); |
| return extractValue(val); |
| } catch (Memoizer.RecursiveInvocationException e) { |
| // propagate RecursiveInvocationException for the same key that |
| // is just being calculated in computeIfAbsent |
| throw e; |
| } catch (Throwable t) { |
| // don't propagate exceptions thrown from foreign Memoizer - |
| // pretend that there was no entry and retry |
| // (foreign computeIfAbsent invocation will try to remove it anyway) |
| } |
| // TODO: |
| // Thread.onSpinLoop(); // when available |
| } |
| } |
| |
| /** |
| * Removes the value associated with this ClassLoaderValue and given |
| * ClassLoader if the associated value is equal to given value {@code v} and |
| * returns {@code true} or does nothing and returns {@code false} if there is |
| * no currently associated value or it is not equal to given value {@code v}. |
| * |
| * @param cl the ClassLoader for the associated value |
| * @param v the value to compare with currently associated value |
| * @return {@code true} if the association was removed or {@code false} if not |
| */ |
| public boolean remove(ClassLoader cl, Object v) { |
| return AbstractClassLoaderValue.<CLV>map(cl).remove(this, v); |
| } |
| |
| /** |
| * Returns the value associated with this ClassLoaderValue and given |
| * ClassLoader if there is one or computes the value by invoking given |
| * {@code mappingFunction}, associates it and returns it. |
| * <p> |
| * Computation and association of the computed value is performed atomically |
| * by the 1st thread that requests a particular association while holding a |
| * lock associated with this ClassLoaderValue and given ClassLoader. |
| * Nested calls from the {@code mappingFunction} to {@link #get}, |
| * {@link #putIfAbsent} or {@link #computeIfAbsent} for the same association |
| * are not allowed and throw {@link IllegalStateException}. Nested call to |
| * {@link #remove} for the same association is allowed but will always return |
| * {@code false} regardless of passed-in comparison value. Nested calls for |
| * other association(s) are allowed, but care should be taken to avoid |
| * deadlocks. When two threads perform nested computations of the overlapping |
| * set of associations they should always request them in the same order. |
| * |
| * @param cl the ClassLoader for the associated value |
| * @param mappingFunction the function to compute the value |
| * @return the value associated with this ClassLoaderValue and given |
| * ClassLoader. |
| * @throws IllegalStateException if a direct or indirect invocation from |
| * within given {@code mappingFunction} that |
| * computes the value of a particular association |
| * to {@link #get}, {@link #putIfAbsent} or |
| * {@link #computeIfAbsent} |
| * for the same association is attempted. |
| */ |
| public V computeIfAbsent(ClassLoader cl, |
| BiFunction< |
| ? super ClassLoader, |
| ? super CLV, |
| ? extends V |
| > mappingFunction) throws IllegalStateException { |
| ConcurrentHashMap<CLV, Object> map = map(cl); |
| @SuppressWarnings("unchecked") |
| CLV clv = (CLV) this; |
| Memoizer<CLV, V> mv = null; |
| while (true) { |
| Object val = (mv == null) ? map.get(clv) : map.putIfAbsent(clv, mv); |
| if (val == null) { |
| if (mv == null) { |
| // create Memoizer lazily when 1st needed and restart loop |
| mv = new Memoizer<>(cl, clv, mappingFunction); |
| continue; |
| } |
| // mv != null, therefore sv == null was a result of successful |
| // putIfAbsent |
| try { |
| // trigger Memoizer to compute the value |
| V v = mv.get(); |
| // attempt to replace our Memoizer with the value |
| map.replace(clv, mv, v); |
| // return computed value |
| return v; |
| } catch (Throwable t) { |
| // our Memoizer has thrown, attempt to remove it |
| map.remove(clv, mv); |
| // propagate exception because it's from our Memoizer |
| throw t; |
| } |
| } else { |
| try { |
| return extractValue(val); |
| } catch (Memoizer.RecursiveInvocationException e) { |
| // propagate recursive attempts to calculate the same |
| // value as being calculated at the moment |
| throw e; |
| } catch (Throwable t) { |
| // don't propagate exceptions thrown from foreign Memoizer - |
| // pretend that there was no entry and retry |
| // (foreign computeIfAbsent invocation will try to remove it anyway) |
| } |
| } |
| // TODO: |
| // Thread.onSpinLoop(); // when available |
| } |
| } |
| |
| /** |
| * Removes all values associated with given ClassLoader {@code cl} and |
| * {@link #isEqualOrDescendantOf(AbstractClassLoaderValue) this or descendants} |
| * of this ClassLoaderValue. |
| * This is not an atomic operation. Other threads may see some associations |
| * be already removed and others still present while this method is executing. |
| * <p> |
| * The sole intention of this method is to cleanup after a unit test that |
| * tests ClassLoaderValue directly. It is not intended for use in |
| * actual algorithms. |
| * |
| * @param cl the associated ClassLoader of the values to be removed |
| */ |
| public void removeAll(ClassLoader cl) { |
| ConcurrentHashMap<CLV, Object> map = map(cl); |
| for (Iterator<CLV> i = map.keySet().iterator(); i.hasNext(); ) { |
| if (i.next().isEqualOrDescendantOf(this)) { |
| i.remove(); |
| } |
| } |
| } |
| |
| private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess(); |
| |
| /** |
| * @return a ConcurrentHashMap for given ClassLoader |
| */ |
| @SuppressWarnings("unchecked") |
| private static <CLV extends AbstractClassLoaderValue<CLV, ?>> |
| ConcurrentHashMap<CLV, Object> map(ClassLoader cl) { |
| return (ConcurrentHashMap<CLV, Object>) |
| (cl == null ? BootLoader.getClassLoaderValueMap() |
| : JLA.createOrGetClassLoaderValueMap(cl)); |
| } |
| |
| /** |
| * @return value extracted from the {@link Memoizer} if given |
| * {@code memoizerOrValue} parameter is a {@code Memoizer} or |
| * just return given parameter. |
| */ |
| @SuppressWarnings("unchecked") |
| private V extractValue(Object memoizerOrValue) { |
| if (memoizerOrValue instanceof Memoizer) { |
| return ((Memoizer<?, V>) memoizerOrValue).get(); |
| } else { |
| return (V) memoizerOrValue; |
| } |
| } |
| |
| /** |
| * A memoized supplier that invokes given {@code mappingFunction} just once |
| * and remembers the result or thrown exception for subsequent calls. |
| * If given mappingFunction returns null, it is converted to NullPointerException, |
| * thrown from the Memoizer's {@link #get()} method and remembered. |
| * If the Memoizer is invoked recursively from the given {@code mappingFunction}, |
| * {@link RecursiveInvocationException} is thrown, but it is not remembered. |
| * The in-flight call to the {@link #get()} can still complete successfully if |
| * such exception is handled by the mappingFunction. |
| */ |
| private static final class Memoizer<CLV extends AbstractClassLoaderValue<CLV, V>, V> |
| implements Supplier<V> { |
| |
| private final ClassLoader cl; |
| private final CLV clv; |
| private final BiFunction<? super ClassLoader, ? super CLV, ? extends V> |
| mappingFunction; |
| |
| private volatile V v; |
| private volatile Throwable t; |
| private boolean inCall; |
| |
| Memoizer(ClassLoader cl, |
| CLV clv, |
| BiFunction<? super ClassLoader, ? super CLV, ? extends V> |
| mappingFunction |
| ) { |
| this.cl = cl; |
| this.clv = clv; |
| this.mappingFunction = mappingFunction; |
| } |
| |
| @Override |
| public V get() throws RecursiveInvocationException { |
| V v = this.v; |
| if (v != null) return v; |
| Throwable t = this.t; |
| if (t == null) { |
| synchronized (this) { |
| if ((v = this.v) == null && (t = this.t) == null) { |
| if (inCall) { |
| throw new RecursiveInvocationException(); |
| } |
| inCall = true; |
| try { |
| this.v = v = Objects.requireNonNull( |
| mappingFunction.apply(cl, clv)); |
| } catch (Throwable x) { |
| this.t = t = x; |
| } finally { |
| inCall = false; |
| } |
| } |
| } |
| } |
| if (v != null) return v; |
| if (t instanceof Error) { |
| throw (Error) t; |
| } else if (t instanceof RuntimeException) { |
| throw (RuntimeException) t; |
| } else { |
| throw new UndeclaredThrowableException(t); |
| } |
| } |
| |
| static class RecursiveInvocationException extends IllegalStateException { |
| private static final long serialVersionUID = 1L; |
| |
| RecursiveInvocationException() { |
| super("Recursive call"); |
| } |
| } |
| } |
| |
| /** |
| * sub-ClassLoaderValue is an inner class of {@link AbstractClassLoaderValue} |
| * and also a subclass of it. It can therefore be instantiated as an inner |
| * class of either an instance of root-{@link ClassLoaderValue} or another |
| * instance of itself. This enables composing type-safe compound keys of |
| * arbitrary length: |
| * <pre>{@code |
| * ClassLoaderValue<V> clv = new ClassLoaderValue<>(); |
| * ClassLoaderValue<V>.Sub<K1>.Sub<K2>.Sub<K3> clv_k123 = |
| * clv.sub(k1).sub(k2).sub(k3); |
| * }</pre> |
| * From which individual components are accessible in a type-safe way: |
| * <pre>{@code |
| * K1 k1 = clv_k123.parent().parent().key(); |
| * K2 k2 = clv_k123.parent().key(); |
| * K3 k3 = clv_k123.key(); |
| * }</pre> |
| * This allows specifying non-capturing lambdas for the mapping function of |
| * {@link #computeIfAbsent(ClassLoader, BiFunction)} operation that can |
| * access individual key components from passed-in |
| * sub-[sub-...]ClassLoaderValue instance in a type-safe way. |
| * |
| * @param <K> the type of {@link #key()} component contained in the |
| * sub-ClassLoaderValue. |
| */ |
| public final class Sub<K> extends AbstractClassLoaderValue<Sub<K>, V> { |
| |
| private final K key; |
| |
| Sub(K key) { |
| this.key = key; |
| } |
| |
| /** |
| * @return the parent ClassLoaderValue this sub-ClassLoaderValue |
| * has been {@link #sub(Object) derived} from. |
| */ |
| public AbstractClassLoaderValue<CLV, V> parent() { |
| return AbstractClassLoaderValue.this; |
| } |
| |
| /** |
| * @return the key component of this sub-ClassLoaderValue. |
| */ |
| @Override |
| public K key() { |
| return key; |
| } |
| |
| /** |
| * sub-ClassLoaderValue is a descendant of given {@code clv} if it is |
| * either equal to it or if its {@link #parent() parent} is a |
| * descendant of given {@code clv}. |
| */ |
| @Override |
| public boolean isEqualOrDescendantOf(AbstractClassLoaderValue<?, V> clv) { |
| return equals(Objects.requireNonNull(clv)) || |
| parent().isEqualOrDescendantOf(clv); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (!(o instanceof Sub)) return false; |
| @SuppressWarnings("unchecked") |
| Sub<?> that = (Sub<?>) o; |
| return this.parent().equals(that.parent()) && |
| Objects.equals(this.key, that.key); |
| } |
| |
| @Override |
| public int hashCode() { |
| return 31 * parent().hashCode() + |
| Objects.hashCode(key); |
| } |
| } |
| } |
