Don't join the current thread if SubstrateTruffleRuntime#teardown that waits for all truffle compilation threads is executed from one of the compilation threads.

Author: jchalou

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/BackgroundCompileQueue.java

@@ -45,6 +45,8 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
@@ -145,15 +147,9 @@ private ExecutorService getExecutorService(OptimizedCallTarget callTarget) {
             long keepAliveTime = compilerIdleDelay >= 0 ? compilerIdleDelay : 0;
 
             this.compilationQueue = createQueue(callTarget, threads);
-            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(threads, threads,
+            ThreadPoolExecutor threadPoolExecutor = new TruffleThreadPoolExecutor(threads, threads,
                             keepAliveTime, TimeUnit.MILLISECONDS,
-                            compilationQueue, factory) {
-                @Override
-                @SuppressWarnings({"unchecked"})
-                protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
-                    return (RunnableFuture<T>) new CompilationTask.ExecutorServiceWrapper((CompilationTask) callable);
-                }
-            };
+                            compilationQueue, factory);
 
             if (compilerIdleDelay > 0) {
                 // There are two mechanisms to signal idleness: if core threads can timeout, then
@@ -247,7 +243,6 @@ public void shutdownAndAwaitTermination(long timeout) {
                 return;
             }
         }
-
         threadPool.shutdownNow();
         try {
             threadPool.awaitTermination(timeout, TimeUnit.MILLISECONDS);
@@ -282,9 +277,40 @@ public enum Tier {
 
     }
 
-    private final class TruffleCompilerThreadFactory implements ThreadFactory {
+    private final class TruffleThreadPoolExecutor extends ThreadPoolExecutor {
+        private TruffleThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
+            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
+        }
+
+        @Override
+        @SuppressWarnings({"unchecked"})
+        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
+            return (RunnableFuture<T>) new CompilationTask.ExecutorServiceWrapper((CompilationTask) callable);
+        }
+
+        @Override
+        public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+            ThreadFactory threadFactory = getThreadFactory();
+            if (threadFactory instanceof JoinableThreadFactory) {
+                return ((JoinableThreadFactory) threadFactory).joinOtherThreads(timeout, unit);
+            } else {
+                return super.awaitTermination(timeout, unit);
+            }
+        }
+    }
+
+    public interface JoinableThreadFactory extends ThreadFactory {
+        /**
+         * Join all but the current thread. If the current thread belongs to this thread factory,
+         * its interrupted status is just cleared instead of joining it.
+         */
+        boolean joinOtherThreads(long timeout, TimeUnit unit) throws InterruptedException;
+    }
+
+    private final class TruffleCompilerThreadFactory implements JoinableThreadFactory {
         private final String namePrefix;
         private final OptimizedTruffleRuntime runtime;
+        private final Set<Thread> threads = Collections.synchronizedSet(Collections.newSetFromMap(new WeakHashMap<>()));
 
         TruffleCompilerThreadFactory(final String namePrefix, OptimizedTruffleRuntime runtime) {
             this.namePrefix = namePrefix;
@@ -315,8 +341,33 @@ public void run() {
             t.setName(namePrefix + "-" + t.getId());
             t.setPriority(Thread.MAX_PRIORITY);
             t.setDaemon(true);
+            threads.add(t);
             return t;
         }
+
+        @Override
+        public boolean joinOtherThreads(long timeout, TimeUnit unit) throws InterruptedException {
+            long timeoutNanos = unit.toNanos(timeout);
+            synchronized (threads) {
+                if (threads.contains(Thread.currentThread())) {
+                    // clear interrupt status
+                    Thread.interrupted();
+                }
+                for (Thread thread : threads) {
+                    if (thread == Thread.currentThread()) {
+                        continue;
+                    }
+                    long joinStart = System.nanoTime();
+                    TimeUnit.NANOSECONDS.timedJoin(thread, timeoutNanos);
+                    long joinEnd = System.nanoTime();
+                    timeoutNanos -= (joinEnd - joinStart);
+                    if (timeoutNanos <= 0) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
     }
 
     /**