Make reachability handlers thread safe.

Author: cstancu

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/JNIRegistrationUtil.java

@@ -28,7 +28,6 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Collections;
-import java.util.IdentityHashMap;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
@@ -41,6 +40,7 @@
 import org.graalvm.nativeimage.impl.RuntimeClassInitializationSupport;
 
 import com.oracle.svm.core.jni.JNIRuntimeAccess;
+import com.oracle.svm.core.util.ConcurrentIdentityHashMap;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.util.ReflectionUtil;
 
@@ -111,7 +111,7 @@ protected static void registerForThrowNew(FeatureAccess access, String... except
         }
     }
 
-    private static Set<Consumer<DuringAnalysisAccess>> runOnceCallbacks = Collections.newSetFromMap(new IdentityHashMap<>());
+    private static final Set<Consumer<DuringAnalysisAccess>> runOnceCallbacks = Collections.newSetFromMap(new ConcurrentIdentityHashMap<>());
 
     /** Intended to be used from within a callback to ensure that it is run only once. */
     protected static boolean isRunOnce(Consumer<DuringAnalysisAccess> callback) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/NativeLibrarySupport.java

@@ -28,6 +28,7 @@
 import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Deque;
 import java.util.List;
 import java.util.concurrent.locks.ReentrantLock;
@@ -70,7 +71,7 @@ public static NativeLibrarySupport singleton() {
 
     private final ReentrantLock lock = new ReentrantLock();
 
-    private final List<NativeLibrary> knownLibraries = new ArrayList<>();
+    private final List<NativeLibrary> knownLibraries = Collections.synchronizedList(new ArrayList<>());
 
     private final Deque<NativeLibrary> currentLoadContext = new ArrayDeque<>();
 

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/SecurityServicesFeature.java

@@ -173,7 +173,7 @@ public static class Options {
     private Map<String, Set<Service>> availableServices;
 
     /** All providers deemed to be used by this feature. */
-    private final Set<Provider> usedProviders = new HashSet<>();
+    private final Set<Provider> usedProviders = ConcurrentHashMap.newKeySet();
 
     /** Providers marked as used by the user. */
     private final Set<String> manuallyMarkedUsedProviderClassNames = new HashSet<>();
@@ -684,8 +684,7 @@ private static void registerSpiClass(Method getSpiClassMethod, String serviceTyp
     }
 
     private void registerProvider(Provider provider) {
-        if (!usedProviders.contains(provider)) {
-            usedProviders.add(provider);
+        if (usedProviders.add(provider)) {
             registerForReflection(provider.getClass());
             /* Trigger initialization of lazy field java.security.Provider.entrySet. */
             provider.entrySet();

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/NativeLibraries.java

@@ -165,12 +165,12 @@ public DependencyGraph() {
         public void add(String library, Collection<String> dependencies) {
             UserError.guarantee(library != null, "The library name must be not null and not empty");
 
-            Dependency libraryDependency = putWhenAbsent(library, new Dependency(library, new HashSet<>()));
+            Dependency libraryDependency = putWhenAbsent(library, new Dependency(library, ConcurrentHashMap.newKeySet()));
             Set<Dependency> collectedDependencies = libraryDependency.getDependencies();
 
             for (String dependency : dependencies) {
                 collectedDependencies.add(putWhenAbsent(
-                                dependency, new Dependency(dependency, new HashSet<>())));
+                                dependency, new Dependency(dependency, ConcurrentHashMap.newKeySet())));
             }
         }
 

substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleBaseFeature.java

@@ -43,6 +43,7 @@
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiConsumer;
 import java.util.function.BooleanSupplier;
 
@@ -479,17 +480,25 @@ private void registerUnsafeAccess(DuringAnalysisAccess access,
      */
     static class PossibleReplaceCandidatesSubtypeHandler implements BiConsumer<DuringAnalysisAccess, Class<?>> {
 
-        final List<Field> fields = new ArrayList<>();
+        /**
+         * The fields are added serially, from the duringAnalysis phase which is run when the
+         * analysis reaches a local fix point, so no need for synchronization.
+         */
+        List<Field> fields = new ArrayList<>();
         final Class<?> fieldType;
-        int candidateCount;
+        /**
+         * The candidates are counted from a reachability handler, which is run in parallel with the
+         * analysis.
+         */
+        final AtomicInteger candidateCount = new AtomicInteger(0);
 
         PossibleReplaceCandidatesSubtypeHandler(Class<?> fieldType) {
             this.fieldType = fieldType;
         }
 
         void addField(DuringAnalysisAccess access, Field field) {
             assert field.getType() == fieldType;
-            if (candidateCount > 1) {
+            if (candidateCount.get() > 1) {
                 /*
                  * Limit already reached no need to remember fields anymore we can directly register
                  * them as unsafe accessed.
@@ -517,13 +526,13 @@ public void accept(DuringAnalysisAccess t, Class<?> u) {
             if (Modifier.isAbstract(u.getModifiers())) {
                 return;
             }
-            candidateCount++;
 
-            if (candidateCount > 1) {
+            /* Limit reached, register the fields and clear the list. */
+            if (candidateCount.incrementAndGet() == 2) {
                 for (Field field : fields) {
                     t.registerAsUnsafeAccessed(field);
                 }
-                fields.clear();
+                fields = null;
             }
         }