Enhanced the output of cache miss counts and branch miss counts for performance event groups; added snapshot index printing functionality; updated userspace code generation tests to verify variable reuse logic.

Author: SiyuanSun0736

examples/perf_cache_miss.ks

@@ -22,9 +22,35 @@ fn main() -> i32 {
     print("Cache-miss count: %lld", cache_count)
     var branch_count = read(branch)
     print("Branch-miss count: %lld", branch_count)
+    
+    var prev = read_details(cache)
+    // Simulate workload with cache misses and branch misses.
+    var x = 0
+    var i = 0
+    for (i in 0..10000000) {
+        if (i % 100 == 0) {
+            x = x + 1
+        } else {
+            x = x * 2
+        }
+    }
+    var cur = read_details(cache)
+    var delta = cur.scaled - prev.scaled
+    var dt_ns = cur.time_enabled - prev.time_enabled
+    if (dt_ns > 0) {
+        var per_sec = (delta * 1000000000) / dt_ns
+        print("Cache misses/sec: %lld", per_sec)
+    }
+
     var snapshot = read_group(cache)
     print("Grouped snapshot entries: %u", snapshot.count)
 
+    var snapshot_index = 0
+    while (snapshot_index < snapshot.count) {
+        print("id=%llu value=%lld", snapshot.ids[snapshot_index], snapshot.values[snapshot_index])
+        snapshot_index = snapshot_index + 1
+    }
+
     detach(branch)
     detach(cache)
     detach(prog)

src/ir_generator.ml

@@ -877,7 +877,7 @@ let rec lower_expression ctx (expr : Ast.expr) =
                 emit_variable_decl_val ctx ptr_val ptr_val.val_type (Some ptr_expr) expr.expr_pos;
 
                 (* result = *ptr *)
-                let load_expr = make_ir_expr (IRValue ptr_val) element_type expr.expr_pos in
+                let load_expr = make_ir_expr (IRUnOp (IRDeref, ptr_val)) element_type expr.expr_pos in
                 emit_variable_decl_val ctx result_val element_type (Some load_expr) expr.expr_pos);
 
            result_val)
@@ -3572,4 +3572,4 @@ let generate_ir ?(use_type_annotations=false) ast symbol_table source_name =
   with
   | exn ->
       Printf.eprintf "IR generation failed: %s\n" (Printexc.to_string exn);
-      raise exn
+      raise exn

src/userspace_codegen.ml

@@ -1895,7 +1895,11 @@ let rec generate_c_instruction_from_ir ctx instruction =
            (match init_expr_opt with
             | Some init_expr ->
                 let init_str = generate_c_expression_from_ir ctx init_expr in
-                sprintf "%s = %s;" array_decl init_str
+                (match init_expr.expr_desc with
+                 | IRValue { value_desc = IRLiteral (ArrayLit _); _ } ->
+                     sprintf "%s = %s;" array_decl init_str
+                 | _ ->
+                     sprintf "%s;\n    memcpy(%s, %s, sizeof(%s));" array_decl c_var_name init_str c_var_name)
             | None ->
                 sprintf "%s;" array_decl)
        | _ ->
@@ -2394,8 +2398,33 @@ let collect_undeclared_variables_in_function ir_func =
     | _ -> ()
   in
 
+  let rec collect_declared_from_instr ir_instr =
+    collect_declared_vars ir_instr;
+    match ir_instr.instr_desc with
+    | IRIf (_, then_instrs, else_instrs_opt) ->
+        List.iter collect_declared_from_instr then_instrs;
+        (match else_instrs_opt with
+         | Some else_instrs -> List.iter collect_declared_from_instr else_instrs
+         | None -> ())
+    | IRIfElseChain (conditions_and_bodies, final_else) ->
+        List.iter (fun (_, instrs) ->
+          List.iter collect_declared_from_instr instrs
+        ) conditions_and_bodies;
+        (match final_else with
+         | Some instrs -> List.iter collect_declared_from_instr instrs
+         | None -> ())
+    | IRBpfLoop (_, _, _, _, body_instructions) ->
+        List.iter collect_declared_from_instr body_instructions
+    | IRTry (try_instrs, catch_clauses) ->
+        List.iter collect_declared_from_instr try_instrs;
+        List.iter (fun clause ->
+          List.iter collect_declared_from_instr clause.catch_body
+        ) catch_clauses
+    | _ -> ()
+  in
+
   let collect_declared_from_instrs instrs =
-    List.iter collect_declared_vars instrs
+    List.iter collect_declared_from_instr instrs
   in
 
   List.iter (fun block ->
@@ -2614,6 +2643,10 @@ let generate_c_function_from_ir ?(global_variables = []) ?(base_name = "") ?(con
   let rec collect_declared_vars ir_instr =
     match ir_instr.instr_desc with
     | IRVariableDecl (dest_val, _, _) ->
+        (match dest_val.value_desc with
+         | IRVariable var_name | IRTempVariable var_name ->
+             Hashtbl.replace ctx.declared_via_ir var_name ()
+         | _ -> ());
         (* Only user variables (IRVariable) need var_ prefix, not compiler temps (IRTempVariable) *)
         (match dest_val.value_desc with
          | IRVariable var_name ->

tests/test_perf_event_attach.ml

@@ -580,6 +580,11 @@ fn main() -> i32 {
     var details = read_details(cache)
     var snapshot = read_group(cache)
     print("raw=%lld scaled=%lld group=%u", raw, details.scaled, snapshot.count)
+    var i = 0
+    while (i < snapshot.count) {
+        print("id=%llu value=%lld", snapshot.ids[i], snapshot.values[i])
+        i = i + 1
+    }
     detach(branch)
     detach(cache)
     detach(prog)
@@ -599,6 +604,11 @@ fn main() -> i32 {
     (contains_substr code "PERF_FORMAT_ID" && contains_substr code "PERF_FORMAT_GROUP");
   check bool "group values are multiplex scaled" true
     (contains_substr code "ks_scale_perf_count(group.values[i].value")
+  ;
+  check bool "array field snapshots are copied before indexing" true
+    (contains_substr code "memcpy(__field_access_");
+  check bool "array snapshot indexing dereferences element pointer" true
+    (contains_substr code "*__array_ptr_")
 
 let test_perf_group_too_large_static_group_rejected () =
   Unix.putenv "KERNELSCRIPT_PERF_GROUP_MAX_EVENTS" "4";

tests/test_userspace_for_codegen.ml

@@ -357,6 +357,37 @@ fn main() -> i32 {
   with
   | exn -> fail ("Test failed with exception: " ^ Printexc.to_string exn)
 
+(** Test 9: A later variable declaration with the same name as a for counter
+    should own the declaration instead of producing a duplicate function-scope
+    predeclaration. *)
+let test_for_counter_reused_by_later_var_decl () =
+  let program_text = {|
+@xdp fn test(ctx: *xdp_md) -> xdp_action {
+  return 2
+}
+
+fn main() -> i32 {
+  var total = 0
+  for (i in 0..3) {
+    total = total + i
+  }
+  var i = 0
+  while (i < 2) {
+    i = i + 1
+  }
+  return 0
+}
+|} in
+
+  try
+    let result = generate_userspace_code_from_program program_text "test_for_reuse" in
+    check bool "for loop still generated" true (contains_pattern result "for.*var_i");
+    check bool "later declaration generated once" true (contains_pattern result "uint32_t var_i = 0");
+    check bool "no duplicate predeclaration for reused counter" false
+      (contains_pattern result "uint32_t var_i;[\\s\\S]*uint32_t var_i = 0")
+  with
+  | exn -> fail ("Test failed with exception: " ^ Printexc.to_string exn)
+
 (** All global function for statement codegen tests *)
 let global_function_for_codegen_tests = [
   "basic_for_loop_constant_bounds", `Quick, test_basic_for_loop_constant_bounds;
@@ -367,6 +398,7 @@ let global_function_for_codegen_tests = [
   "for_loop_zero_iterations", `Quick, test_for_loop_zero_iterations;
   "for_loop_in_helper_function", `Quick, test_for_loop_in_helper_function;
   "global_functions_vs_ebpf_differences", `Quick, test_global_functions_vs_ebpf_for_loop_differences;
+  "for_counter_reused_by_later_var_decl", `Quick, test_for_counter_reused_by_later_var_decl;
 ]
 
 let () =