Performance work and hardening

Author: shai-almog

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

@@ -19,6 +19,7 @@ static void write(File outputDirectory, List<ByteCodeClass> classes) throws IOEx
         writeTranslatedClasses(outputDirectory, classes);
         writeWorker(outputDirectory);
         writeIndex(outputDirectory);
+        writeProtocol(outputDirectory);
     }
 
     private static void writeRuntime(File outputDirectory) throws IOException {
@@ -71,6 +72,10 @@ private static void writeIndex(File outputDirectory) throws IOException {
         writeResource(outputDirectory, "index.html", "index.html");
     }
 
+    private static void writeProtocol(File outputDirectory) throws IOException {
+        writeResource(outputDirectory, "vm_protocol.md", "vm_protocol.md");
+    }
+
     private static void writeResource(File outputDirectory, String targetName, String resourceName) throws IOException {
         Files.write(new File(outputDirectory, targetName).toPath(),
                 loadResource(resourceName).getBytes(StandardCharsets.UTF_8));

vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js

@@ -50,6 +50,8 @@ const jvm = {
   classes: {},
   literalStrings: Object.create(null),
   methodTailCache: Object.create(null),
+  remappedMethodIdCache: Object.create(null),
+  resolvedVirtualCache: Object.create(null),
   nextIdentity: 1,
   nextThreadId: 1,
   nextHostCallId: 1,
@@ -123,6 +125,7 @@ const jvm = {
     const classDef = this.classes[className];
     const obj = { __class: className, __classDef: classDef, __id: this.nextIdentity++, __monitor: this.createMonitor() };
     this.initInstanceFields(obj, className);
+    this.initFieldAliases(obj, className);
     return obj;
   },
   initInstanceFields(obj, className) {
@@ -140,6 +143,41 @@ const jvm = {
       }
     }
   },
+  initFieldAliases(obj, className) {
+    const hierarchy = [];
+    let current = className;
+    while (current) {
+      hierarchy.push(current);
+      const cls = this.classes[current];
+      current = cls ? cls.baseClass : null;
+    }
+    for (let i = hierarchy.length - 1; i >= 0; i--) {
+      const owner = hierarchy[i];
+      const cls = this.classes[owner];
+      if (!cls || !cls.instanceFields) {
+        continue;
+      }
+      for (let j = 0; j < cls.instanceFields.length; j++) {
+        const field = cls.instanceFields[j];
+        const canonicalProp = field.prop || this.fieldProperty(field.owner, field.name);
+        for (let k = 0; k < i; k++) {
+          const aliasProp = this.fieldProperty(hierarchy[k], field.name);
+          if (aliasProp === canonicalProp || Object.prototype.hasOwnProperty.call(obj, aliasProp)) {
+            continue;
+          }
+          Object.defineProperty(obj, aliasProp, {
+            configurable: true,
+            enumerable: false,
+            get: function() { return obj[canonicalProp]; },
+            set: function(value) { obj[canonicalProp] = value; }
+          });
+        }
+      }
+    }
+  },
+  fieldProperty(owner, name) {
+    return "cn1_" + owner + "_" + name;
+  },
   newArray(size, componentClass, dimensions) {
     size = size | 0;
     if (size < 0) {
@@ -233,18 +271,27 @@ const jvm = {
     return componentClass.indexOf("JAVA_") === 0;
   },
   resolveVirtual(className, methodId) {
+    const cacheKey = className + "|" + methodId;
+    let cached = this.resolvedVirtualCache[cacheKey];
+    if (cached) {
+      return cached;
+    }
     const tail = this.methodTail(methodId);
     let current = className;
     while (current) {
       const cls = this.classes[current];
       if (cls && cls.methods) {
         if (cls.methods[methodId]) {
-          return cls.methods[methodId];
+          cached = cls.methods[methodId];
+          this.resolvedVirtualCache[cacheKey] = cached;
+          return cached;
         }
         if (tail) {
-          const remappedId = "cn1_" + current + tail;
+          const remappedId = this.remappedMethodId(current, methodId, tail);
           if (cls.methods[remappedId]) {
-            return cls.methods[remappedId];
+            cached = cls.methods[remappedId];
+            this.resolvedVirtualCache[cacheKey] = cached;
+            return cached;
           }
         }
       }
@@ -272,6 +319,16 @@ const jvm = {
     this.methodTailCache[methodId] = null;
     return null;
   },
+  remappedMethodId(className, methodId, tail) {
+    const cacheKey = className + "|" + methodId;
+    let cached = this.remappedMethodIdCache[cacheKey];
+    if (cached !== undefined) {
+      return cached;
+    }
+    cached = tail ? "cn1_" + className + tail : null;
+    this.remappedMethodIdCache[cacheKey] = cached;
+    return cached;
+  },
   instanceOf(obj, className) {
     return !!(obj && obj.__classDef && obj.__classDef.assignableTo && obj.__classDef.assignableTo[className]);
   },

vm/ByteCodeTranslator/src/javascript/vm_protocol.md

@@ -0,0 +1,26 @@
+# ParparVM JavaScript VM Protocol
+
+Version: 1
+
+This file documents the worker boundary emitted by the `javascript` backend.
+
+Messages from host to worker:
+- `start`: boot the translated application and invoke the translated `main`.
+- `protocol-info`: request the protocol/version handshake without starting the app.
+- `event`: inject a generic host event into the VM event queue.
+- `ui-event`: inject a UI-oriented host event into the VM event queue.
+- `timer-wake`: wake the scheduler after a host-driven timer tick.
+- `host-callback`: deliver the completion or failure of a pending host call.
+
+Messages from worker to host:
+- `protocol`: reply to `protocol-info` with the explicit protocol version and message names.
+- `host-call`: request a host-provided native operation or callback.
+- `log`: emit a VM/runtime log line.
+- `result`: report normal translated application completion.
+- `error`: report fatal translated application or protocol failure.
+
+Host hook native categories:
+- Runtime-implemented natives: handled entirely inside `parparvm_runtime.js`.
+- Host-hook natives: compiled to `host-call` messages and completed via `host-callback`.
+- Unsupported natives: fail deterministically with a backend-specific unsupported message.
+- Uncategorized natives: treated as backend bugs and should fail tests.

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

@@ -29,34 +29,11 @@ void translatesMeaningfulCodenameOneCoreSliceWithoutUncategorizedNativeGaps() th
         assertTrue(CompilerHelper.isJavaApiCompatible(config),
                 "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
 
-        Path sourceDir = Files.createTempDirectory("js-cn1-core-src");
-        Path classesDir = Files.createTempDirectory("js-cn1-core-classes");
-        Path javaApiDir = Files.createTempDirectory("js-cn1-core-javaapi");
-
-        Files.write(sourceDir.resolve("JsCodenameOneCoreSliceApp.java"),
-                JavascriptTargetIntegrationTest.loadFixture("JsCodenameOneCoreSliceApp.java").getBytes(StandardCharsets.UTF_8));
-
-        Path coreJar = findDependencyJar("codenameone-core");
-        assertNotNull(coreJar, "codenameone-core dependency jar should be available in target/benchmark-dependencies");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-        compileFixtureAgainstJavaApiAndCore(config, sourceDir, classesDir, javaApiDir, coreJar);
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-        unzipMatching(coreJar, classesDir,
-                "com/codename1/io/",
-                "com/codename1/util/",
-                "com/codename1/compat/java/",
-                "com/codename1/l10n/",
-                "com/codename1/ui/events/",
-                "com/codename1/xml/");
-
-        Path outputDir = Files.createTempDirectory("js-cn1-core-output");
-        JavascriptTargetIntegrationTest.runJavascriptTranslator(classesDir, outputDir, "JsCodenameOneCoreSliceApp");
-
-        Path distDir = outputDir.resolve("dist").resolve("JsCodenameOneCoreSliceApp-js");
+        Path distDir = translateCn1CoreSlice(config);
         assertTrue(Files.exists(distDir.resolve("translated_app.js")),
                 "Translator should emit translated JS for the Codename One core slice");
+        assertTrue(Files.exists(distDir.resolve("vm_protocol.md")),
+                "Translator should emit the VM protocol artifact for the Codename One core slice");
 
         String translatedApp = new String(Files.readAllBytes(distDir.resolve("translated_app.js")), StandardCharsets.UTF_8);
         assertTrue(translatedApp.contains("JsCodenameOneCoreSliceApp"),
@@ -65,6 +42,21 @@ void translatesMeaningfulCodenameOneCoreSliceWithoutUncategorizedNativeGaps() th
                 "CN1 core slice translation should not retain uncategorized javascript native fallback stubs");
     }
 
+    @Test
+    void executesMeaningfulCodenameOneCoreSliceInWorkerRuntime() throws Exception {
+        Parser.cleanup();
+
+        CompilerHelper.CompilerConfig config = selectRepresentativeCompiler();
+        Path distDir = translateCn1CoreSlice(config);
+
+        JavascriptRuntimeSemanticsTest.WorkerRunResult result = JavascriptRuntimeSemanticsTest.runGeneratedWorkerBundle(distDir);
+        assertEquals("result", result.type,
+                "CN1 core slice should complete through the generated worker protocol. Raw worker payload: " + result.rawMessage);
+        assertEquals(7, result.result, "CN1 core slice should execute JSON and StringUtil behavior correctly");
+        assertTrue(result.errorMessage == null || result.errorMessage.isEmpty(),
+                "CN1 core slice should not emit a worker error. Raw worker payload: " + result.rawMessage);
+    }
+
     private static CompilerHelper.CompilerConfig selectRepresentativeCompiler() {
         String[] preferredTargets = new String[] {"11", "17", "21"};
         for (String target : preferredTargets) {
@@ -105,6 +97,34 @@ private static void compileFixtureAgainstJavaApiAndCore(CompilerHelper.CompilerC
                 "Compilation failed for Codename One core slice fixture with " + config + ": " + CompilerHelper.getLastErrorLog());
     }
 
+    private static Path translateCn1CoreSlice(CompilerHelper.CompilerConfig config) throws Exception {
+        Path sourceDir = Files.createTempDirectory("js-cn1-core-src");
+        Path classesDir = Files.createTempDirectory("js-cn1-core-classes");
+        Path javaApiDir = Files.createTempDirectory("js-cn1-core-javaapi");
+
+        Files.write(sourceDir.resolve("JsCodenameOneCoreSliceApp.java"),
+                JavascriptTargetIntegrationTest.loadFixture("JsCodenameOneCoreSliceApp.java").getBytes(StandardCharsets.UTF_8));
+
+        Path coreJar = findDependencyJar("codenameone-core");
+        assertNotNull(coreJar, "codenameone-core dependency jar should be available in target/benchmark-dependencies");
+
+        CompilerHelper.compileJavaAPI(javaApiDir, config);
+        compileFixtureAgainstJavaApiAndCore(config, sourceDir, classesDir, javaApiDir, coreJar);
+
+        CompilerHelper.copyDirectory(javaApiDir, classesDir);
+        unzipMatching(coreJar, classesDir,
+                "com/codename1/io/",
+                "com/codename1/util/",
+                "com/codename1/compat/java/",
+                "com/codename1/l10n/",
+                "com/codename1/ui/events/",
+                "com/codename1/xml/");
+
+        Path outputDir = Files.createTempDirectory("js-cn1-core-output");
+        JavascriptTargetIntegrationTest.runJavascriptTranslator(classesDir, outputDir, "JsCodenameOneCoreSliceApp");
+        return outputDir.resolve("dist").resolve("JsCodenameOneCoreSliceApp-js");
+    }
+
     private static Path findDependencyJar(String namePart) throws IOException {
         Path depsDir = Paths.get("target", "benchmark-dependencies");
         if (!Files.exists(depsDir)) {

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

@@ -94,6 +94,12 @@ void translatesObjectTypeAndDispatchCoverageFixture() throws Exception {
         assertTrue(!translatedApp.contains("jvm.instanceOf("),
                 "Translated object/type checks should avoid the generic runtime instanceof helper");
         assertTrue(runtime.contains("resolveVirtual(className, methodId)"), "Runtime should resolve virtual methods by class name");
+        assertTrue(runtime.contains("resolvedVirtualCache: Object.create(null)")
+                        && runtime.contains("remappedMethodIdCache: Object.create(null)"),
+                "Runtime virtual dispatch should keep per-method caches for resolved and remapped ids");
+        assertTrue(runtime.contains("const cacheKey = className + \"|\" + methodId;")
+                        && runtime.contains("const remappedId = this.remappedMethodId(current, methodId, tail);"),
+                "Runtime virtual dispatch should cache both resolved lookups and remapped owner-specific ids");
         assertTrue(runtime.contains("obj.__classDef.assignableTo[className]"), "Runtime instanceof should use emitted class assignability tables");
         assertTrue(runtime.contains("errorClass === entry.type || (errorClassDef && errorClassDef.assignableTo && errorClassDef.assignableTo[entry.type])"),
                 "Runtime exception matching should use direct class and assignability checks");