Clojure 性能优化与 GraalVM 原生编译

# 1. 内置耗时（粗粒度）
(time (my-hot-function data))

# 2. criterium 精确基准（消除 JIT 预热）
# 见下文第 5 节

# 3. 反射警告
# 设置 JVM 参数观察反射调用
-Dclojure.compiler.direct-linking=true -Djdk.reflect.useDirectMethodHandle

# 4. 火焰图（async-profiler）
async-profiler.sh -d 30 -f /tmp/flame.html <pid>

;; 未提示：每次调用走反射
(defn area [radius]
  (* Math/PI (Math/pow radius 2)))

;; 加提示：直接方法调用
(defn area [^double radius]
  (* Math/PI (Math/pow radius 2.0)))

(defn sum-items [^java.util.List items]
  (reduce + (map long items)))

;; 提示 reduce 的初始值类型，避免每一步装箱
(defn fast-sum [^longs xs]
  (areduce xs i acc 0 (+ acc (aget xs i))))

java -Dclojure.compiler.direct-linking=true -jar myapp.jar

;; deps.edn
:aliases {:prod {:jvm-opts ["-Dclojure.compiler.direct-linking=true"]}}

;; 声明 primitive 参数，杜绝装箱
(defn sum-range [^long n]
  (loop [i 0, acc 0]
    (if (< i n)
      (recur (unchecked-inc i) (+ acc i))
      acc)))

;; unchecked 运算：关闭溢出检查，更快（谨慎使用）
(defn mul-unchecked [^long a ^long b]
  (unchecked-multiply a b))

;; 创建 primitive 数组
(def ^longs arr (long-array 1000000))

;; amap：映射返回新数组（无装箱）
(def ^longs doubled
  (amap arr i ret
    (* 2 (aget arr i))))

;; areduce：归约（无中间对象）
(def total
  (areduce arr i acc 0
    (+ acc (aget arr i))))

;; 与向量对比：百万元素求和
;; vector: (reduce + (vec (range 1000000)))  — 元素为 Long 对象
;; long-array + areduce:  — 元素为 primitive long

;; 慢：反复 conj 产生大量中间版本
(def v (reduce conj [] (range 1000000)))

;; 快：transient 构建后一次性固化
(def v-fast
  (persistent!
    (reduce conj! (transient []) (range 1000000))))

;; transient map 构建
(def m
  (persistent!
    (reduce (fn [acc [k v]] (assoc! acc k v))
            (transient {})
            (range 1000))))

;; 注意：transient 构建期间绝不能泄漏可变版本

;; 错误用法
(let [t (transient [])]
  (first t))     ; ClassCastException！

;; 正确模式：transient 只在函数内部，返回固化结果
(defn build-index [entries]
  (persistent!
    (reduce (fn [acc e] (conj! acc e))
            (transient [])
            entries)))

;; deps.edn
{:deps {criterium/criterium {:mvn/version "0.4.6"}}}

(require '[criterium.core :as crit])

;; 快速基准
(crit/quick-bench (reduce + (vec (range 1000))))

;; 完整基准（更精确）
(crit/bench (reduce + (vec (range 1000))))

;; 带参数的基准
(def data (vec (range 10000)))
(crit/quick-bench (sort data))

Evaluation count : 34200 in 6 samples of 5700 calls.
        Execution time mean : 1.083458 ms
 Execution time std-deviation : 61.538079 µs
Execution time lower quantile : 1.009331 ms ( 2.5%)
Execution time upper quantile : 1.177335 ms (97.5%)

(defn version-a [n]
  (reduce + (range n)))

(defn version-b [n]
  (loop [i 0 acc 0]
    (if (< i n) (recur (inc i) (+ acc i)) acc)))

;; 在相同输入下分别 bench，比较 mean
(crit/quick-bench (version-a 100000))
(crit/quick-bench (version-b 100000))

# 安装 GraalVM（建议 JDK 17/21 LTS）
# https://github.com/graalvm/graalvm-ce-builds/releases

# 安装 native-image 组件
gu install native-image

# 编译（-O2 优化，-H:+ReportExceptionStackTraces 便于调试）
native-image -jar target/myapp.jar -O2 \
  -H:+ReportExceptionStackTraces \
  --no-fallback \
  -o myapp-native

;; 方式一：在代码中注册反射（推荐）
(require '[org.graalvm.nativeimage.imageio] '[org.graalvm.nativeimage.runtime])

;; 或在构建期用 resource 配置 reflect-config.json

// META-INF/native-image/reflect-config.json
[
  {"name": "java.lang.String", "methods": [{"name": "valueOf", "parameterTypes": ["int"]}]},
  {"name": "myapp.core", "methods": [{"name": "-main"}]},
  {"name": "com.zaxxer.hikari.HikariDataSource", "allDeclaredConstructors": true}
]

native-image -jar target/myapp.jar \
  -H:ReflectionConfigurationFiles=reflect-config.json \
  -H:ResourceConfigurationFiles=resource-config.json

;; deps.edn
:aliases {:native-image
          {:extra-deps {io.github.clj-easy/graal-build-time {:mvn/version "0.1.6"}}}}

;; 常用构建别名（示例）
:aliases {:native {:exec-fn clj.native-image/build-native-image
                   :exec-args {:main-class myapp.core
                               :opts ["-O2" "--no-fallback"]}}}

clojure -T:build uber     ; 先打 uberjar
clojure -M:native-image    ; 再编译原生镜像

;; deps.edn 中开启 AOT
{:paths ["src"]
 :aliases {:aot {:main-opts ["-e" "(compile 'myapp.core)"]}}}

# JVM 模式
time java -jar target/myapp.jar --version
# => real 0m2.8s

# Native 模式
time ./myapp-native --version
# => real 0m0.02s

(ns myapp.metrics
  (:require [criterium.core :as crit]))

;; 版本 1：朴素写法（反射 + 装箱 + Var 查找）
(defn v1-sum-abs [coll]
  (reduce + (map #(Math/abs %) coll)))

;; 版本 2：类型提示 + primitive 数组 + areduce
(defn v2-sum-abs [^longs arr]
  (areduce arr i acc 0
    (+ acc (Math/abs (aget arr i)))))

(def ^longs data (long-array (range 100000)))

;; 基准
(crit/quick-bench (v1-sum-abs data))
;; 注意 v1 接收 long[] 但未提示，Java 互操作走反射
(crit/quick-bench (v2-sum-abs data))

;; 典型结果：v2 比 v1 快 5~15 倍（且无对象分配）