Re-factoring the LanguageCache so that languages can be re-initialized with reflection.

This feature is required for running an AOT compilation server that can process
requests for different sets of languages. On each compilation the server must
remove the unused languages in order to remove them from compilation.

Author: vjovanov

truffle/com.oracle.truffle.api.test/src/com/oracle/truffle/api/vm/LanguageCacheReflectiveReinitializationTest.java

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ *
+ * 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 com.oracle.truffle.api.vm;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import org.junit.Test;
+
+public class LanguageCacheReflectiveReinitializationTest {
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void canReinitializeLanguages() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        System.setProperty("com.oracle.truffle.aot", "true");
+
+        Class<?> languageCacheClass = Class.forName("com.oracle.truffle.api.vm.LanguageCache");
+        Field languageCacheField = languageCacheClass.getDeclaredField("CACHE");
+        languageCacheField.setAccessible(true);
+        assert languageCacheField.get(null) == null;
+
+        Method initMethod = languageCacheClass.getDeclaredMethod("initializeLanguages", ClassLoader.class);
+        initMethod.setAccessible(true);
+        Map<String, Object> languages = (Map<String, Object>) initMethod.invoke(null, Thread.currentThread().getContextClassLoader());
+
+        assert languages.containsKey("application/x-test") : "Re-initialized languages must contain application/x-test language after reflective initialization.";
+    }
+}

truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/LanguageCache.java

@@ -46,7 +46,7 @@
  * cache with languages found in application classloader.
  */
 final class LanguageCache {
-    static final boolean PRELOAD;
+    private static final boolean PRELOAD;
     private static final Map<String, LanguageCache> CACHE;
     private TruffleLanguage<?> language;
     private final String className;
@@ -55,18 +55,29 @@ final class LanguageCache {
     private final String version;
 
     static {
-        Map<String, LanguageCache> map = null;
-        if (TruffleOptions.AOT) {
-            map = languages();
-            for (LanguageCache info : map.values()) {
-                info.getImpl(true);
-            }
-        }
-        CACHE = map;
+        CACHE = TruffleOptions.AOT ? initializeLanguages(loader()) : null;
         PRELOAD = CACHE != null;
     }
 
-    LanguageCache(String prefix, Properties info, TruffleLanguage<?> language) {
+    /**
+     * This method initializes all languages under the provided classloader.
+     *
+     * NOTE: Method's signature should not be changed as it is reflectively invoked from AOT
+     * compilation.
+     *
+     * @param loader The classloader to be used for finding languages.
+     * @return A map of initialized languages.
+     */
+    private static Map<String, LanguageCache> initializeLanguages(ClassLoader loader) {
+        Map<String, LanguageCache> map;
+        map = createLanguages(loader);
+        for (LanguageCache info : map.values()) {
+            info.createLanguage(loader);
+        }
+        return map;
+    }
+
+    private LanguageCache(String prefix, Properties info, TruffleLanguage<?> language) {
         this.className = info.getProperty(prefix + "className");
         this.name = info.getProperty(prefix + "name");
         this.version = info.getProperty(prefix + "version");
@@ -90,20 +101,14 @@ private static ClassLoader loader() {
         return l;
     }
 
-    private static TruffleLanguage<?> find(String name, ClassLoader loader) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
-        if (PRELOAD) {
-            return CACHE.get(name).language;
-        } else {
-            Class<?> langClazz = Class.forName(name, true, loader);
-            return (TruffleLanguage<?>) langClazz.getField("INSTANCE").get(null);
-        }
-    }
-
     static Map<String, LanguageCache> languages() {
         if (PRELOAD) {
             return CACHE;
         }
-        ClassLoader loader = loader();
+        return createLanguages(loader());
+    }
+
+    private static Map<String, LanguageCache> createLanguages(ClassLoader loader) {
         Map<String, LanguageCache> map = new LinkedHashMap<>();
         Enumeration<URL> en;
         try {
@@ -154,13 +159,20 @@ TruffleLanguage<?> getImpl(boolean create) {
             return language;
         }
         if (create) {
-            try {
-                language = LanguageCache.find(className, loader());
-            } catch (Exception ex) {
-                throw new IllegalStateException("Cannot initialize " + getName() + " language with implementation " + className, ex);
-            }
+            createLanguage(loader());
         }
         return language;
     }
 
+    private void createLanguage(ClassLoader loader) {
+        try {
+            TruffleLanguage<?> result;
+            Class<?> langClazz = Class.forName(className, true, loader);
+            result = (TruffleLanguage<?>) langClazz.getField("INSTANCE").get(null);
+            language = result;
+        } catch (Exception ex) {
+            throw new IllegalStateException("Cannot initialize " + getName() + " language with implementation " + className, ex);
+        }
+    }
+
 }