# Wasmtime AOT 编译
wasmtime compile app.wasm -o app.cwasm

# 运行预编译文件（启动更快）
wasmtime run app.cwasm

// 使用 Wasmtime API 进行 AOT
use wasmtime::*;

let engine = Engine::new(&Config::new())?;

// 编译并序列化
let module = Module::from_file(&engine, "app.wasm")?;
module.serialize_to_file("app.cwasm")?;

// 加载预编译模块（跳过解码和验证）
let module = unsafe { Module::deserialize_file(&engine, "app.cwasm")? };

// V8 会自动对热点函数进行 JIT 优化
// 以下方式可以帮助 V8 更好地优化 Wasm：

// 1. 使用 typed 调用（避免 JS ↔ Wasm 类型转换）
const result = instance.exports.f64_add(1.5, 2.5);  // 直接传递 f64

// 2. 避免频繁的 JS ↔ Wasm 切换
// ❌ 慢：频繁切换
for (let i = 0; i < 1000000; i++) {
  instance.exports.increment();
}

// ✅ 快：在 Wasm 内部循环
instance.exports.process_batch(1000000);

// Cargo.toml:
// [dependencies]
// packed_simd_2 = "0.3"

use packed_simd_2::*;

#[wasm_bindgen]
pub fn vector_add_simd(a: &[f32], b: &[f32]) -> Vec<f32> {
    assert_eq!(a.len(), b.len());
    let mut result = vec![0.0f32; a.len()];
    
    let chunks = a.len() / 4;
    for i in 0..chunks {
        let va = f32x4::from_slice_unaligned(&a[i*4..]);
        let vb = f32x4::from_slice_unaligned(&b[i*4..]);
        let vr = va + vb;
        vr.write_to_slice_unaligned(&mut result[i*4..]);
    }
    
    // 处理余数
    for i in (chunks*4)..a.len() {
        result[i] = a[i] + b[i];
    }
    
    result
}

function hasSIMD() {
  try {
    const bytes = new Uint8Array([
      0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,
      10,10,1,8,0,65,0,253,15,253,98,11
    ]);
    return WebAssembly.validate(bytes);
  } catch (e) {
    return false;
  }
}

// 渐进增强：支持 SIMD 则加载优化版本
const wasmUrl = hasSIMD() ? 'app-simd.wasm' : 'app.wasm';

# Cargo.toml
[profile.release]
opt-level = "z"       # 最小体积
lto = true             # 链接时优化
codegen-units = 1      # 单编译单元
strip = true           # 剥离符号
panic = "abort"        # panic 时 abort（不展开栈）

[profile.release.build-override]
opt-level = 0          # 构建脚本不优化（加快编译）

# Emscripten 优化
emcc input.c -o output.js \
  -Oz \
  -flto \
  -s FILESYSTEM=0 \
  -s DISABLE_EXCEPTION_CATCHING=1 \
  -s MINIMAL_RUNTIME \
  --closure 1

# 后处理
wasm-opt -Oz output.wasm -o output.wasm

# twiggy (Rust)
cargo install twiggy
twiggy top -n 20 app.wasm
twiggy dominators app.wasm

# bloaty (C/C++)
bloaty app.wasm -d sections
bloaty app.wasm -d compileunits

# wasm-tools
wasm-tools dump app.wasm  # 查看段信息

// 1. 流式编译（边下载边编译）
const { instance } = await WebAssembly.instantiateStreaming(
  fetch('app.wasm'), imports
);

// 2. 编译缓存到 IndexedDB
async function compileWithCache(url) {
  const cacheKey = `wasm:${url}`;
  const db = await openCache();
  
  // 尝试从缓存加载
  const cached = await db.get(cacheKey);
  if (cached) {
    return WebAssembly.instantiate(cached, imports);  // 跳过编译
  }
  
  // 编译并缓存
  const module = await WebAssembly.compileStreaming(fetch(url));
  await db.put(cacheKey, module);
  return WebAssembly.instantiate(module, imports);
}

// 3. AOT 预编译（服务端或构建时）
// 在部署前完成编译，运行时直接实例化

// 4. 预编译 + 冻结
// V8 支持将编译后的代码序列化到磁盘
// Chrome: chrome://flags/#v8-cache-options

// 简单的 Arena 分配器
struct Arena {
    buffer: Vec<u8>,
    offset: usize,
}

impl Arena {
    fn new(size: usize) -> Self {
        Arena {
            buffer: vec![0u8; size],
            offset: 0,
        }
    }
    
    fn alloc(&mut self, size: usize, align: usize) -> *mut u8 {
        let aligned = (self.offset + align - 1) & !(align - 1);
        if aligned + size > self.buffer.len() {
            return std::ptr::null_mut();  // 内存不足
        }
        self.offset = aligned + size;
        unsafe { self.buffer.as_mut_ptr().add(aligned) }
    }
    
    fn reset(&mut self) {
        self.offset = 0;  // O(1) 重置
    }
}

// 预分配足够内存，避免频繁 grow
// ❌ 频繁增长
let mut data = Vec::new();
for i in 0..1000000 {
    data.push(i);  // 可能多次 grow
}

// ✅ 预分配
let mut data = Vec::with_capacity(1000000);
for i in 0..1000000 {
    data.push(i);  // 不会 grow
}

// 创建共享内存
const memory = new WebAssembly.Memory({
  initial: 1,
  maximum: 16,
  shared: true
});

// 多个 Worker 操作同一块内存
const workers = Array.from({ length: 4 }, () => new Worker('worker.js'));

// 分配不同区域给不同 Worker
const chunkSize = 64 * 1024;  // 64KB 每块
for (let i = 0; i < workers.length; i++) {
  workers[i].postMessage({
    memory,
    offset: i * chunkSize,
    length: chunkSize
  });
}

// Wasm 内部使用原子操作
use std::sync::atomic::{AtomicI32, Ordering};

static COUNTER: AtomicI32 = AtomicI32::new(0);

#[wasm_bindgen]
pub fn increment_counter() -> i32 {
    COUNTER.fetch_add(1, Ordering::SeqCst)
}

#[wasm_bindgen]
pub fn get_counter() -> i32 {
    COUNTER.load(Ordering::SeqCst)
}

// 精确计时
performance.mark('wasm-start');
instance.exports.heavy_compute();
performance.mark('wasm-end');
performance.measure('wasm', 'wasm-start', 'wasm-end');

const measures = performance.getEntriesByName('wasm');
console.log(`Wasm: ${measures[0].duration}ms`);

# 使用 perf 工具
perf record -g wasmtime app.wasm
perf report

# 使用 Wasmtime 内置计时
wasmtime --profile=perfmap app.wasm