TableServiceAsyncTest: Eliminate Compiler Overhead Variance; Close QueryCompiler's JavaFileManager

engine/context/src/main/java/io/deephaven/engine/context/QueryCompiler.java

@@ -683,19 +683,60 @@ private void maybeCreateClass(String className, String code, String packageName,
         }
     }
 
+    private static JavaCompiler JAVA_COMPILER = null;
+
+    private static JavaCompiler getJavaCompiler() {
+        JavaCompiler localCompiler = JAVA_COMPILER;
+        if (localCompiler != null) {
+            return localCompiler;
+        }
+        synchronized (QueryCompiler.class) {
+            localCompiler = JAVA_COMPILER;
+            if (localCompiler != null) {
+                return localCompiler;
+            }
+            localCompiler = JAVA_COMPILER = ToolProvider.getSystemJavaCompiler();
+            if (localCompiler == null) {
+                throw new RuntimeException("No Java compiler provided - are you using a JRE instead of a JDK?");
+            }
+        }
+        return localCompiler;
+    }
+
+    /**
+     * While the JavaFileManager should be closed to clean up resources, using a singleton avoids repeated processing of
+     * the classpath, which is <b>very</b> expensive.
+     */
+    private static JavaFileManager JAVA_FILE_MANAGER = null;
+
+    private static JavaFileManager getJavaFileManager() {
+        JavaFileManager localManager = JAVA_FILE_MANAGER;
+        if (localManager != null) {
+            return localManager;
+        }
+        synchronized (QueryCompiler.class) {
+            localManager = JAVA_FILE_MANAGER;
+            if (localManager != null) {
+                return localManager;
+            }
+            localManager = JAVA_FILE_MANAGER = getJavaCompiler().getStandardFileManager(null, null, null);
+            if (localManager == null) {
+                throw new RuntimeException("No Java compiler provided - are you using a JRE instead of a JDK?");
+            }
+        }
+        return localManager;
+    }
+
     private void maybeCreateClassHelper(String fqClassName, String finalCode, String[] splitPackageName,
             String rootPathAsString, String tempDirAsString) {
         final StringWriter compilerOutput = new StringWriter();
 
-        final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
-        if (compiler == null) {
-            throw new RuntimeException("No Java compiler provided - are you using a JRE instead of a JDK?");
-        }
+        final JavaCompiler compiler = getJavaCompiler();
 
         final String classPathAsString = getClassPath() + File.pathSeparator + getJavaClassPath();
         final List<String> compilerOptions = Arrays.asList("-d", tempDirAsString, "-cp", classPathAsString);
 
-        final StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
+        final JavaFileManager fileManager = getJavaFileManager();
 
         final boolean result = compiler.getTask(compilerOutput,
                 fileManager,
@@ -735,7 +776,7 @@ private void maybeCreateClassHelper(String fqClassName, String finalCode, String
      * @return a Pair of success, and the compiler output
      */
     private Pair<Boolean, String> tryCompile(File basePath, Collection<File> javaFiles) throws IOException {
-        final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        final JavaCompiler compiler = getJavaCompiler();
         if (compiler == null) {
             throw new RuntimeException("No Java compiler provided - are you using a JRE instead of a JDK?");
         }

java-client/session-dagger/src/test/java/io/deephaven/client/impl/TableServiceAsyncTest.java

@@ -19,7 +19,7 @@
 public class TableServiceAsyncTest extends DeephavenSessionTestBase {
 
     private static final Duration GETTIME = Duration.ofSeconds(15);
-    private static final int CHAIN_OPS = 50;
+    private static final int CHAIN_OPS = 250;
     private static final int CHAIN_ROWS = 1000;
 
     @Test(timeout = 20000)
@@ -93,8 +93,11 @@ private static List<TableSpec> createLongChain(int numColumns, int numRows) {
             if (i == 0) {
                 longChain.add(TableSpec.empty(numRows).view("I_0=ii"));
             } else {
+                // create a chain using the previous table even though we don't need the data
                 final TableSpec prev = longChain.get(i - 1);
-                longChain.add(prev.updateView("I_" + i + " = 1 + I_" + (i - 1)));
+                // to avoid timeouts due to compilation variance reuse the same expression, including the destination
+                // column which shows up in the generated formula's FormulaEvaluationException
+                longChain.add(prev.updateView("I_1 = 1 + I_0"));
             }
         }
         return longChain;