Rust中DlsymWeak::initialize作用及重复调用优化问题

我有一个多次调用libc::memchr的程序，性能分析时发现耗时最多的函数是DlsymWeak::initialize。该函数由memchr调用，而memchr则被我的包装函数调用：

pub fn memchr_libc_ptr(ptr: *const std::os::raw::c_void, len: usize, needle: u8) -> Option<usize> {
    let res = unsafe { // 性能分析指出此函数调用较慢
        libc::memchr(
            ptr,
            needle as i32,
            len)
    };
    if res == 0 as *mut std::os::raw::c_void {
        return None;
    }
    let res = res as *const u8;
    let ptr = ptr as *const u8;
    Some((unsafe { res.offset_from(ptr) }) as usize)
}

另外，DlsymWeak::initialize的源码注释显示该方法应为冷路径，仅在首次初始化时调用，但实际被多次调用。

请问DlsymWeak::initialize是什么？能否避免这些重复调用？

运行环境：macOS 12.3.1，rustup 1.25.1 (bb60b1e89 2022-07-12)，x86-64，发布配置如下：

[profile.release]
lto = true
codegen-units = 1
debug = true
panic = "abort"
overflow-checks = false
incremental = false

什么是DlsymWeak::initialize？ #

DlsymWeak::initialize是Rust标准库在Unix系统上用于延迟解析弱符号的内部函数。当你调用libc::memchr这类弱链接的C函数时，Rust不会在程序启动时就绑定函数地址，而是第一次调用时通过dlsym动态查找符号地址——这个查找过程就是DlsymWeak::initialize负责的，原本设计为仅执行一次的冷路径。

为什么会被多次调用？ #

在macOS上，这个问题通常和LTO（链接时优化）的特定行为有关：当开启LTO时，编译器可能没有正确保留DlsymWeak内部的初始化状态标记，导致每次调用memchr时都重新执行符号解析，而非复用已缓存的函数地址。你的发布配置中正好开启了lto = true，这大概率是触发点。

如何避免重复调用？ #

可以尝试以下几种方案：

1. 禁用LTO（快速验证） #

暂时修改Cargo.toml的release配置，关闭LTO：

[profile.release]
lto = false
# 其他配置保持不变

重新编译后观察性能分析结果，若DlsymWeak::initialize的调用次数降为1，说明LTO是问题根源。

2. 手动绑定memchr地址（推荐） #

绕过Rust的弱符号机制，直接通过dlsym手动解析memchr地址并缓存，避免反复初始化：

use std::os::raw::{c_void, c_int, c_size_t};
use std::sync::OnceLock;

// 静态缓存memchr的函数指针
static MEMCHR: OnceLock<unsafe extern "C" fn(*const c_void, c_int, c_size_t) -> *mut c_void> = OnceLock::new();

pub fn memchr_libc_ptr(ptr: *const c_void, len: usize, needle: u8) -> Option<usize> {
    let memchr = MEMCHR.get_or_init(|| unsafe {
        // 手动通过dlsym获取memchr地址
        let handle = libc::dlopen(std::ptr::null(), libc::RTLD_NOW);
        assert!(!handle.is_null(), "dlopen failed");
        let sym = libc::dlsym(handle, b"memchr\0".as_ptr() as *const _);
        assert!(!sym.is_null(), "dlsym failed to find memchr");
        std::mem::transmute(sym)
    });

    let res = unsafe { memchr(ptr, needle as c_int, len as c_size_t) };
    if res.is_null() {
        None
    } else {
        let res = res as *const u8;
        let ptr = ptr as *const u8;
        Some(unsafe { res.offset_from(ptr) } as usize)
    }
}

这个方案通过OnceLock确保dlsym只执行一次，彻底避免重复初始化的开销。

3. 使用Rust原生的memchr库 #

放弃调用libc的memchr，改用crates.io上的memchr crate（执行cargo add memchr添加依赖），它是纯Rust实现，性能通常优于系统libc版本，且完全避开弱符号解析问题：

use memchr::memchr;

pub fn memchr_libc_ptr(ptr: *const std::os::raw::c_void, len: usize, needle: u8) -> Option<usize> {
    let slice = unsafe { std::slice::from_raw_parts(ptr as *const u8, len) };
    memchr(needle, slice)
}

内容的提问来源于stack exchange，提问作者nlta