Adds Java to the performance measurement.

Author: modlfo

src/generators/java.ml

@@ -26,8 +26,6 @@ open Core.Prog
 
 let runtime =
   {%pla|
-import java.util.Arrays;
-import java.util.Random;
 
 static int clip(int x, int minv, int maxv) {
     if(x > maxv)
@@ -286,6 +284,15 @@ let rec print_exp e =
   | ECall { path = "not"; args = [ e1 ] } ->
     let e1 = print_exp e1 in
     {%pla|!(<#e1#>)|}
+  | ECall { path = "real"; args = [ e1 ] } ->
+    let e1 = print_exp e1 in
+    {%pla|(float)(<#e1#>)|}
+  | ECall { path = "int"; args = [ e1 ] } ->
+    let e1 = print_exp e1 in
+    {%pla|(int)(<#e1#>)|}
+  | ECall { path = "bool"; args = [ e1 ] } ->
+    let e1 = print_exp e1 in
+    {%pla|((<#e1#>) != 0)|}
   | ECall { path; args } ->
     let args = Pla.map_sep Pla.commaspace print_exp args in
     {%pla|<#path#s>(<#args#>)|}
@@ -427,17 +434,30 @@ let print_arg ({ name; t; _ } : param) =
   {%pla|<#t#> <#name#s>|}
 
 
-let print_function_def (def : function_def) =
+let print_function_def ?(force_public = false) ?(is_performance = false) (def : function_def) =
   let name = def.name in
   let args = Pla.map_sep Pla.commaspace print_arg def.args in
   let ret = print_type_ (snd def.t) in
   let visibility =
-    if def.info.is_root then
+    if def.info.is_root || force_public then
       "public"
+    else if is_performance && String.contains name '_' then
+      (* Make _alloc and _default functions public for performance template *)
+      let suffix = String.sub name (String.rindex name '_') (String.length name - String.rindex name '_') in
+      if suffix = "_alloc" || suffix = "_default" then
+        "public"
+      else
+        "private"
     else
       "private"
   in
-  {%pla|<#visibility#s> static <#ret#> <#name#s>(<#args#>) {|}
+  let static_keyword =
+    if is_performance then
+      ""
+    else
+      "static "
+  in
+  {%pla|<#visibility#s> <#static_keyword#s><#ret#> <#name#s>(<#args#>) {|}
 
 
 let print_body body =
@@ -485,12 +505,39 @@ let print_struct_def { path; members; _ } =
   {%pla|public static class <#path#s> {<#members_decl#+><#default_constructor#+><#param_constructor#+>}|}
 
 
-let print_top_stmt (_args : Util.Args.args) t =
+(* Generate type alias as inheritance *)
+let print_type_alias alias_name base_name =
+  {%pla|public static class <#alias_name#s> extends <#base_name#s> {
+    public <#alias_name#s>() { super(); }
+}|}
+
+
+let print_top_stmt (args : Util.Args.args) t =
   match t.top with
-  | TopFunction (def, body) ->
-    let def = print_function_def def in
-    let body = print_body body in
-    {%pla|<#def#><#body#><#><#>|}
+  | TopFunction (func_def, body) ->
+    let is_performance = args.template = Some "performance" in
+    let force_public = is_performance in
+    let def = print_function_def ~force_public ~is_performance func_def in
+    let name = func_def.name in
+    (* Check if this is a type alias allocation function *)
+    if String.contains name '_' && CCString.suffix ~suf:"_type_alloc" name && List.length func_def.args > 0 then
+      let parts = String.split_on_char '_' name in
+      let len = List.length parts in
+      if len >= 4 then
+        (* This is a type alias allocation function - override body to create correct type *)
+        let name_len = String.length name in
+        let alias_type = String.sub name 0 (name_len - 6) in
+        (* Remove "_alloc" *)
+        let body = {%pla|
+   return new <#alias_type#s>();
+}|} in
+        {%pla|<#def#><#body#><#><#>|}
+      else
+        let body = print_body body in
+        {%pla|<#def#><#body#><#><#>|}
+    else
+      let body = print_body body in
+      {%pla|<#def#><#body#><#><#>|}
   | TopExternal _ -> Pla.unit
   | TopType descr -> print_struct_def descr
   | TopAlias _ -> Pla.unit
@@ -500,12 +547,58 @@ let print_top_stmt (_args : Util.Args.args) t =
     {%pla|public static final <#t#> <#name#s> = <#rhs#>;<#>|}
 
 
-let print_prog args t = Pla.map_join (print_top_stmt args) t
+(* Collect type aliases needed based on function signatures *)
+let collect_type_aliases stmts =
+  let aliases = ref [] in
+  let collect_from_stmt stmt =
+    match stmt.top with
+    | TopFunction (def, _) ->
+      let name = def.name in
+      (* Look for pattern: *_function_type_alloc that takes arguments (indicating it's a type alias) *)
+      if String.contains name '_' && CCString.suffix ~suf:"_type_alloc" name && List.length def.args > 0 then
+        let parts = String.split_on_char '_' name in
+        (* Handle patterns like Module_noteOn_type_alloc or Module_submodule_pulse_start_type_alloc *)
+        let len = List.length parts in
+        if len >= 4 then
+          (* Check for various patterns including perf variants *)
+          if len >= 5 && List.nth parts (len - 4) = "perf" then
+            (* Handle perf patterns like Module_perf_noteOn_type_alloc *)
+            let module_parts = CCList.take (len - 4) parts in
+            let module_name = String.concat "_" module_parts in
+            let name_len = String.length name in
+            let alias_type = String.sub name 0 (name_len - 6) in
+            (* Remove "_alloc" *)
+            let base_type = module_name ^ "_perf_process_type" in
+            aliases := (alias_type, base_type) :: !aliases
+          else
+            (* Handle regular patterns like Module_noteOn_type_alloc or Module_pulse_start_type_alloc *)
+            let module_parts = CCList.take (len - 3) parts in
+            let module_name = String.concat "_" module_parts in
+            let name_len = String.length name in
+            let alias_type = String.sub name 0 (name_len - 6) in
+            (* Remove "_alloc" *)
+            let base_type = module_name ^ "_process_type" in
+            aliases := (alias_type, base_type) :: !aliases
+    | _ -> ()
+  in
+  List.iter collect_from_stmt stmts;
+  !aliases
+
+
+let print_prog args t =
+  let aliases = collect_type_aliases t in
+  let main_code = Pla.map_join (print_top_stmt args) t in
+  let alias_code = Pla.map_sep_all Pla.newline (fun (alias, base) -> print_type_alias alias base) aliases in
+  if aliases = [] then
+    main_code
+  else
+    {%pla|<#main_code#><#alias_code#+>|}
+
 
 let getTemplateCode (args : Util.Args.args) =
   match args.template with
   | None -> Pla.unit, Pla.unit
-  | Some "performance" -> Pla.unit, Pla.unit (* TODO: implement T_performance.generateJava *)
+  | Some "performance" -> T_performance.generateJava args
   | Some name -> Util.Error.raiseErrorMsg ("Unknown template '" ^ name ^ "'")
 
 
@@ -523,15 +616,42 @@ let generate (args : Util.Args.args) (stmts : top_stmt list) =
   in
   let code = print_prog args stmts in
   let pre, post = getTemplateCode args in
-  let full_code =
-    {%pla|
+  match args.template with
+  | Some "performance" ->
+    (* For performance template, generate two files: main class and performance test *)
+    let main_code =
+      {%pla|
 package <#package_name#s>;
 
+import java.util.Arrays;
+import java.util.Random;
+
+public class <#class_name#s> {
 <#runtime#>
+<#code#>
+}
+|}
+    in
+    let perf_file = Common.setExt "Perf.java" args.output in
+    let perf_code = {%pla|
+package <#package_name#s>;
+
+<#post#>
+|} in
+    [ main_code, file; perf_code, perf_file ]
+  | _ ->
+    (* Regular template or no template *)
+    let full_code =
+      {%pla|
+package <#package_name#s>;
+
+import java.util.Arrays;
+import java.util.Random;
 
 public class <#class_name#s> {
+<#runtime#>
 <#pre#><#code#><#post#>
 }
 |}
-  in
-  [ full_code, file ]
+    in
+    [ full_code, file ]

src/generators/t_performance.ml

@@ -195,3 +195,54 @@ measure_performance()
 
 
 let generateJulia (args : Util.Args.args) = Pla.unit, juliaPost args
+
+let javaPost (args : Util.Args.args) =
+  let module_name =
+    match args.files with
+    | Util.Args.File s :: _ -> Pparser.Parse.moduleName s
+    | _ -> "Top"
+  in
+  let class_name =
+    match args.output with
+    | Some output -> String.capitalize_ascii (Filename.basename (Filename.remove_extension output))
+    | None -> "VultCode"
+  in
+  {%pla|
+public class <#module_name#s>Perf {
+    public static void main(String[] args) {
+        <#class_name#s> vult = new <#class_name#s>();
+        <#class_name#s>.<#module_name#s>_process_type data = vult.<#module_name#s>_process_type_alloc();
+        vult.<#module_name#s>_default(data);
+        
+        double time = <#time#f>;
+        int samples = (int)(44100 * time);
+        
+        // Warm up - run iterations to allow JVM JIT compilation
+        for (int i = 0; i < 10000; i++) {
+            vult.<#module_name#s>_process(data, (float)0.0);
+        }
+        
+        // Actual performance measurement
+        long startTime = System.nanoTime();
+        double acc = 0.0;
+        double ramp = 0.0;
+        
+        for (int i = 0; i < samples; i++) {
+            ramp += 0.001;
+            if (ramp > 1.0) {
+                ramp = ramp - 1.0;
+            }
+            acc += vult.<#module_name#s>_process(data, (float)ramp);
+        }
+        
+        long endTime = System.nanoTime();
+        double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+        double msPerSecond = (elapsedSeconds / time) * 1000.0;
+        
+        System.out.printf("<#module_name#s>\tJava\t%.2f ms/s\n", msPerSecond);
+    }
+}
+|}
+
+
+let generateJava (args : Util.Args.args) = Pla.unit, javaPost args

test/perf.ml

@@ -165,6 +165,21 @@ let generateJulia (filename : string) (output : string) : unit =
   CCList.iter (Driver.Cli.showResult args) output
 
 
+let generateJava (filename : string) (output : string) : unit =
+  let args =
+    { default_arguments with
+      files = [ File filename ]
+    ; code = JavaCode
+    ; output = Some output
+    ; real = Float
+    ; template = Some "performance"
+    ; includes
+    }
+  in
+  let output = Driver.Cli.driver args in
+  CCList.iter (Driver.Cli.showResult args) output
+
+
 let realString f =
   match f with
   | Fixed -> "fixed"
@@ -231,6 +246,48 @@ let runJulia vultfile =
   | e -> showError e
 
 
+[@@@warning "-32"]
+
+let runJava vultfile =
+  try
+    let output = Filename.chop_extension (Filename.basename vultfile) in
+    let module_name = Pparser.Parse.moduleName vultfile in
+    let class_name = String.capitalize_ascii output in
+    Sys.chdir tmp_dir;
+    generateJava vultfile output;
+    (* Now we have two files: output.java and outputPerf.java *)
+    let main_java_file = output ^ ".java" in
+    let perf_java_file = output ^ "Perf.java" in
+    let proper_main_file = class_name ^ ".java" in
+    let proper_perf_file = module_name ^ "Perf.java" in
+    (* Rename files to match class names *)
+    Sys.rename main_java_file proper_main_file;
+    Sys.rename perf_java_file proper_perf_file;
+    (* Create package directory *)
+    ignore (Sys.command "mkdir -p vult");
+    (* Compile both Java files *)
+    let compile_cmd = "javac " ^ proper_main_file ^ " " ^ proper_perf_file in
+    if Sys.command compile_cmd <> 0 then (
+      (* If compilation fails, print a warning but don't fail the whole test *)
+      Printf.eprintf "Warning: Java compilation failed for %s\n%!" module_name;
+      Printf.printf "%s\tJava\tCompilation Failed\n%!" module_name)
+    else (
+      (* Move class files to package directory *)
+      ignore (Sys.command "mv *.class vult/");
+      (* Run the performance test *)
+      let run_cmd = "java -cp . vult." ^ module_name ^ "Perf" in
+      ignore (Sys.command run_cmd));
+    (* Clean up *)
+    (try Sys.remove proper_main_file with
+    | _ -> ());
+    (try Sys.remove proper_perf_file with
+    | _ -> ());
+    ignore (Sys.command "rm -rf vult/");
+    Sys.chdir init_dir
+  with
+  | e -> showError e
+
+
 let runInterpreter vultfile =
   try
     let module_name = Pparser.Parse.moduleName vultfile in
@@ -269,6 +326,7 @@ let main () =
       runLua f;
       runJs f;
       runJulia f;
+      runJava f;
       runInterpreter f)
     files