(* 常规数组 — 每个元素是 boxed float *)
let arr1 = [| 1.0; 2.0; 3.0 |]  (* 每个 float 独立堆分配 *)

(* Float.Array — unboxed 浮点数组 *)
let arr2 = Float.Array.make 3 1.0  (* 连续内存，无额外分配 *)

(* 当老年代对象 A 的字段被修改为指向年轻代对象 B 时 *)
A.field <- B  (* 触发写屏障 *)

(* 创建带终结器的值 *)
let create_resource () =
  let fd = Unix.openfile "/tmp/data" [Unix.O_RDWR] 0o644 in
  Gc.finalise (fun fd -> Unix.close fd) fd;
  fd

(* 使用 WeakRef + finalise 更安全 *)
let safe_create () =
  let state = ref (Some (Unix.openfile "/tmp/data" [Unix.O_RDWR] 0o644)) in
  Gc.finalise (fun r ->
    match !r with
    | Some fd -> Unix.close fd; r := None
    | None -> ()
  ) state;
  state

let with_file path f =
  let fd = Unix.openfile path [Unix.O_RDWR] 0o644 in
  Fun.protect ~finally:(fun () -> Unix.close fd) (fun () -> f fd)

(* 查看 GC 统计信息 *)
let stats = Gc.stat ()
let () = Printf.printf "Minor collections: %d\n" stats.minor_collections
let () = Printf.printf "Major collections: %d\n" stats.major_collections
let () = Printf.printf "Heap words: %d\n" stats.heap_words
let () = Printf.printf "Live words: %d\n" stats.live_words

(* 修改 GC 参数 *)
let () = Gc.set { (Gc.get ()) with
  minor_heap_size = 1024 * 1024;  (* 1M words *)
  major_heap_increment = 100;      (* 增长比例 % *)
  space_overhead = 120;            (* 允许的额外空间 % *)
  max_overhead = 500;              (* 触发 compaction 的碎片 % *)
  allocation_policy = 2;           (* 2 = best-fit *)
}

(* 手动触发 GC *)
let () = Gc.compact ()    (* 完整压缩 *)
let () = Gc.full_major () (* 完整 major collection *)

(* 创建弱引用 *)
let weak_ref = Weak.create 1
let () = Weak.set weak_ref 0 (Some "hello")

(* 读取弱引用（可能返回 None） *)
match Weak.get weak_ref 0 with
| Some value -> Printf.printf "Value: %s\n" value
| None -> Printf.printf "Value was collected\n"

(* 使用 Ephemeron 实现弱哈希表 *)
module WeakCache = Ephemeron.K1.Make(struct
  type t = string
  let equal = String.equal
  let hash = Hashtbl.hash
end)

let cache = WeakCache.create 64
let () = WeakCache.add cache "key1" (compute_expensive_value "key1")

(* ❌ 泄漏：全局 list 持续增长 *)
let history = ref []
let add_event e = history := e :: !history

(* ✅ 定期清理或使用有界数据结构 *)

(* ❌ 闭包持有对大对象的引用 *)
let make_handler big_data =
  fun () -> process big_data  (* big_data 不会被回收 *)

(* ✅ 只捕获需要的数据 *)
let make_handler big_data =
  let summary = summarize big_data in
  fun () -> process_summary summary

(* ❌ *)
let cache : (string, string) Hashtbl.t = Hashtbl.create 256

(* ✅ 使用 LRU 缓存或弱引用 *)
module LRU = Lru.M.Make(String)

# 使用 OCaml 内存分析
OCAML_GC_STATS=1 ./my_program

# 使用 memprof（采样 profiling）
let () =
  Memprof.start ~sampling_rate:1e-4 {
    alloc_minor = fun _ -> None;
    alloc_major = fun _ -> None;
    promote = fun _ -> None;
    dealloc_minor = fun _ -> ();
    dealloc_major = fun _ -> ();
  }

(* 调优 GC 参数以减少延迟 *)
let setup_gc_for_server () =
  Gc.set { (Gc.get ()) with
    minor_heap_size = 4 * 1024 * 1024;  (* 4M words, 减少 minor GC *)
    space_overhead = 150;                 (* 允许更多空间换取更少 GC *)
    allocation_policy = 2;               (* best-fit *)
  }

(* 使用对象池减少分配 *)
module Pool = struct
  let pool = Array.init 1024 (fun _ -> Buffer.create 4096)
  let idx = ref 0
  let acquire () =
    let i = !idx mod 1024 in
    incr idx;
    Buffer.clear pool.(i);
    pool.(i)
end

(* 使用 Bigarray 进行数值计算，避免 GC 压力 *)
open Bigarray

let compute n =
  let arr = Array1.create Float64 C_layout n in
  for i = 0 to n - 1 do
    arr.{i} <- float_of_int i *. 3.14
  done;
  Array1.fold_left (+.) 0.0 arr