Optimize ByteCodeTranslator by parallelizing class parsing and code generation.

* Parallelized file processing in `ByteCodeTranslator.execute` using `ExecutorService`.
* Parallelized dependency updates and file writing in `Parser.writeOutput`.
* Ensured thread safety in `Parser`, `ByteCodeClass`, and `BytecodeMethod` by using synchronized collections and synchronized blocks for shared state.
* Updated `vm/JavaAPI/pom.xml` to use source/target 1.8 to fix build failure.
* Fixed brittle test `BytecodeInstructionIntegrationTest` that relied on anonymous inner class index.

Author: google-labs-jules[bot]

vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeClass.java

@@ -25,6 +25,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -78,7 +79,7 @@ public void setIsAnnotation(boolean isAnnotation) {
     private boolean isUnitTest;
 
 
-    private static Set<String> arrayTypes = new TreeSet<String>();
+    private static Set<String> arrayTypes = Collections.synchronizedSet(new TreeSet<String>());
 
     private ByteCodeClass baseClassObject;
     private List<ByteCodeClass> baseInterfacesObject;
@@ -89,10 +90,10 @@ public void setIsAnnotation(boolean isAnnotation) {
     private int classOffset;
 
     private boolean marked;
-    private static ByteCodeClass mainClass;
+    private static volatile ByteCodeClass mainClass;
     private boolean finalClass;
     private boolean isEnum;
-    private static Set<String> writableFields = new HashSet<String>();
+    private static Set<String> writableFields = Collections.synchronizedSet(new HashSet<String>());
 
     /**
      * 
@@ -151,10 +152,12 @@ static void setSaveUnitTests(boolean save) {
 
     public void addMethod(BytecodeMethod m) {
         if(m.isMain()) {
-            if (mainClass == null) {
-                mainClass = this;
-            } else {
-                throw new RuntimeException("Multiple main classes: "+mainClass.clsName+" and "+this.clsName);
+            synchronized(ByteCodeClass.class) {
+                if (mainClass == null) {
+                    mainClass = this;
+                } else {
+                    throw new RuntimeException("Multiple main classes: "+mainClass.clsName+" and "+this.clsName);
+                }
             }
         }
         m.setSourceFile(sourceFile);

vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeTranslator.java

@@ -38,6 +38,10 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 /**
  *
@@ -79,12 +83,26 @@ public String extension() {
      * Recursively parses the files in the hierarchy to the output directory
      */
     void execute(File[] sourceDirs, File outputDir) throws Exception {
-        for(File f : sourceDirs) {
-            execute(f, outputDir);
+        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+        List<Future<?>> futures = new ArrayList<Future<?>>();
+        try {
+            for(File f : sourceDirs) {
+                execute(f, outputDir, executor, futures);
+            }
+            for(Future<?> future : futures) {
+                try {
+                    future.get();
+                } catch (ExecutionException e) {
+                    if (e.getCause() instanceof Exception) throw (Exception)e.getCause();
+                    throw e;
+                }
+            }
+        } finally {
+            executor.shutdown();
         }
     }
 
-    void execute(File sourceDir, File outputDir) throws Exception {
+    void execute(File sourceDir, final File outputDir, ExecutorService executor, List<Future<?>> futures) throws Exception {
         File[] directoryList = sourceDir.listFiles(new FileFilter() {
             @Override
             public boolean accept(File pathname) {
@@ -98,19 +116,35 @@ public boolean accept(File pathname) {
             }
         });
         if(fileList != null) {
-            for(File f : fileList) {
+            for(final File f : fileList) {
                 if (f.getName().equals("module-info.class")) {
                     // Remove module-info.class that might have been added by jdk9 compile
                     System.out.println("WARNING: Found module-info.class file at "+f+".  One or more of your jars must have been built for JDK9 or higher.  -target 8 or lower is required.");
                     System.out.println("         Will ignore this warning and attempt build anyways.");
                     continue;
                 }
                 if(f.getName().endsWith(".class")) {
-                    Parser.parse(f);
+                    futures.add(executor.submit(new Runnable() {
+                        public void run() {
+                            try {
+                                Parser.parse(f);
+                            } catch(Exception e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    }));
                 } else {
                     if(!f.isDirectory()) {
                         // copy the file to the dest dir
-                        copy(new FileInputStream(f), new FileOutputStream(new File(outputDir, f.getName())));
+                        futures.add(executor.submit(new Runnable() {
+                            public void run() {
+                                try {
+                                    copy(new FileInputStream(f), new FileOutputStream(new File(outputDir, f.getName())));
+                                } catch(Exception e) {
+                                    throw new RuntimeException(e);
+                                }
+                            }
+                        }));
                     }
                 }
             }
@@ -121,7 +155,7 @@ public boolean accept(File pathname) {
                     copyDir(f, outputDir);
                     continue;
                 }
-                execute(f, outputDir);
+                execute(f, outputDir, executor, futures);
             }
         }
     }

vm/ByteCodeTranslator/src/com/codename1/tools/translator/BytecodeMethod.java

@@ -47,6 +47,7 @@
 import com.codename1.tools.translator.bytecodes.TypeInstruction;
 import com.codename1.tools.translator.bytecodes.VarOp;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Hashtable;
@@ -98,7 +99,7 @@ public static void setAcceptStaticOnEquals(boolean aAcceptStaticOnEquals) {
     private boolean virtualOverriden;
     private boolean finalMethod;
     private boolean synchronizedMethod;
-    private final static Set<String> virtualMethodsInvoked = new TreeSet<String>();    
+    private final static Set<String> virtualMethodsInvoked = Collections.synchronizedSet(new TreeSet<String>());
     private String desc;
     private boolean eliminated;
 

vm/ByteCodeTranslator/src/com/codename1/tools/translator/Parser.java

@@ -25,6 +25,10 @@
 
 import java.io.*;
 import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 import org.objectweb.asm.AnnotationVisitor;
 import org.objectweb.asm.Attribute;
@@ -49,7 +53,7 @@ public class Parser extends ClassVisitor {
     private ByteCodeClass cls;
     private String clsName;
     private static String[] nativeSources;
-    private static List<ByteCodeClass> classes = new ArrayList<ByteCodeClass>();
+    private static List<ByteCodeClass> classes = Collections.synchronizedList(new ArrayList<ByteCodeClass>());
     private int lambdaCounter;
     public static void cleanup() {
     	nativeSources = null;
@@ -102,12 +106,14 @@ private static void appendClassOffset(ByteCodeClass bc, List<Integer> clsIds) {
         }
     }
 
-    private static ArrayList<String> constantPool = new ArrayList<String>();
+    private static List<String> constantPool = Collections.synchronizedList(new ArrayList<String>());
 
     public static ByteCodeClass getClassObject(String name) {
-        for(ByteCodeClass cls : classes) {
-            if(cls.getClsName().equals(name)) {
-                return cls;
+        synchronized(classes) {
+            for(ByteCodeClass cls : classes) {
+                if(cls.getClsName().equals(name)) {
+                    return cls;
+                }
             }
         }
         return null;
@@ -116,7 +122,7 @@ public static ByteCodeClass getClassObject(String name) {
     /**
      * Adds the given string to the hardcoded constant pool strings returns the offset in the pool
      */
-    public static int addToConstantPool(String s) {
+    public static synchronized int addToConstantPool(String s) {
         int i = constantPool.indexOf(s);
         if(i < 0) {
             constantPool.add(s);
@@ -416,10 +422,25 @@ public static void writeOutput(File outputDirectory) throws Exception {
             // and the class may be purged before it even has a shot.
             readNativeFiles(outputDirectory);
 
-            for(ByteCodeClass bc : classes) {
+            ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+            List<Future<?>> futures = new ArrayList<Future<?>>();
+            for(final ByteCodeClass bc : classes) {
                 file = bc.getClsName();
-                bc.updateAllDependencies();
+                futures.add(executor.submit(new Runnable() {
+                    public void run() {
+                        bc.updateAllDependencies();
+                    }
+                }));
             }
+            for (Future<?> f : futures) {
+                try {
+                    f.get();
+                } catch (ExecutionException e) {
+                    if (e.getCause() instanceof Exception) throw (Exception)e.getCause();
+                    throw new RuntimeException(e);
+                }
+            }
+            futures.clear();
             ByteCodeClass.markDependencies(classes, nativeSources);
             Set<ByteCodeClass> unmarked = new HashSet<ByteCodeClass>(classes);
             classes = ByteCodeClass.clearUnmarked(classes);
@@ -445,11 +466,35 @@ public static void writeOutput(File outputDirectory) throws Exception {
             boolean concatenate = "true".equals(System.getProperty("concatenateFiles", "false"));
             ConcatenatingFileOutputStream cos = concatenate ? new ConcatenatingFileOutputStream(outputDirectory) : null;
 
-            for(ByteCodeClass bc : classes) {
-                file = bc.getClsName();
-                writeFile(bc, outputDirectory, cos);
+            if (cos != null) {
+                for(ByteCodeClass bc : classes) {
+                    file = bc.getClsName();
+                    writeFile(bc, outputDirectory, cos);
+                }
+                cos.realClose();
+            } else {
+                for(final ByteCodeClass bc : classes) {
+                    file = bc.getClsName();
+                    futures.add(executor.submit(new Runnable() {
+                        public void run() {
+                            try {
+                                writeFile(bc, outputDirectory, null);
+                            } catch (Exception e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    }));
+                }
+                for (Future<?> f : futures) {
+                    try {
+                        f.get();
+                    } catch (ExecutionException e) {
+                        if (e.getCause() instanceof Exception) throw (Exception)e.getCause();
+                        throw new RuntimeException(e);
+                    }
+                }
+                executor.shutdown();
             }
-            if (cos != null) cos.realClose();
 
         } catch(Throwable t) {
             System.out.println("Error while working with the class: " + file);

vm/JavaAPI/pom.xml

@@ -21,8 +21,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.11.0</version>
                 <configuration>
-                    <source>1.5</source>
-                    <target>1.5</target>
+                    <source>1.8</source>
+                    <target>1.8</target>
                     <!-- Allow compiling java.* packages -->
                     <compilerArgs>
                         <arg>-Xlint:-options</arg>

vm/tests/src/test/java/com/codename1/tools/translator/BytecodeInstructionIntegrationTest.java

@@ -378,12 +378,39 @@ public AnnotationVisitor visitArray(String name) {
 
     @Test
     void byteCodeTranslatorFilenameFilterMatchesExpectedFiles() throws Exception {
-        Class<?> filterClass = Class.forName("com.codename1.tools.translator.ByteCodeTranslator$3");
+        Class<?> filterClass = null;
+        File directory = Files.createTempDirectory("bytecode-filter").toFile();
+        // Search for the anonymous FilenameFilter class
+        for (int i = 1; i < 50; i++) {
+            try {
+                Class<?> c = Class.forName("com.codename1.tools.translator.ByteCodeTranslator$" + i);
+                if (FilenameFilter.class.isAssignableFrom(c)) {
+                    // Check if it has a no-arg constructor (static context)
+                    try {
+                        Constructor<?> ctor = c.getDeclaredConstructor();
+                        ctor.setAccessible(true);
+                        FilenameFilter filter = (FilenameFilter) ctor.newInstance();
+                        // Verify it's the correct filter by testing behavior
+                        if (filter.accept(directory, "assets.bundle") && !filter.accept(directory, "Images.xcassets")) {
+                            filterClass = c;
+                            break;
+                        }
+                    } catch (Exception e) {
+                        // It might be an instance inner class or different constructor
+                    }
+                }
+            } catch (ClassNotFoundException e) {
+                // End of inner classes
+                break;
+            }
+        }
+
+        assertNotNull(filterClass, "Could not find the expected FilenameFilter inner class in ByteCodeTranslator");
+
         Constructor<?> ctor = filterClass.getDeclaredConstructor();
         ctor.setAccessible(true);
 
         FilenameFilter filter = (FilenameFilter) ctor.newInstance();
-        File directory = Files.createTempDirectory("bytecode-filter").toFile();
 
         assertTrue(filter.accept(directory, "assets.bundle"));
         assertTrue(filter.accept(directory, "model.xcdatamodeld"));