跨函数临时数组内存分配检查及Eigen内存限制作用范围咨询

我来帮你解答这两个Eigen内存分配相关的问题，都是实际开发中很实用的点：

问题1：如何检查跨函数场景下临时数组的内存分配情况 #

Eigen提供了几种灵活的方式来追踪跨函数的内存分配，这里推荐两种最常用的方案：

方法1：使用内置malloc计数器与运行时禁用分配 #

Eigen内部维护了一个线程局部的malloc调用计数器，你可以在调用函数链的前后获取计数器值，差值就是这段代码内Eigen触发的动态分配次数。如果想快速定位是否存在分配（而非仅统计次数），可以临时禁用内存分配——此时任何Eigen的动态分配都会触发断言（Debug模式下默认生效），直接帮你定位问题点。

示例代码：

#include <Eigen/Core>
#include <iostream>

// 子函数，包含临时数组分配
void funcB() {
    Eigen::MatrixXd temp(1000, 1000); // 触发动态内存分配
}

// 调用方函数
void funcA() {
    funcB();
}

int main() {
    // 统计跨函数的分配次数
    auto start_count = Eigen::internal::malloc_counter();
    funcA();
    auto end_count = Eigen::internal::malloc_counter();
    std::cout << "跨函数调用链中Eigen的malloc次数：" << end_count - start_count << std::endl;

    // 禁用分配，检测是否存在分配操作
    Eigen::internal::set_is_malloc_allowed(false);
    try {
        funcA(); // 如果funcB里有分配，这里会触发断言
    } catch (...) {
        std::cout << "调用链中检测到动态内存分配！" << std::endl;
    }
    // 记得恢复分配允许状态
    Eigen::internal::set_is_malloc_allowed(true);

    return 0;
}

这个方法无需修改现有代码的对象定义，就能快速完成跨函数的分配追踪。

方法2：自定义追踪分配器 #

如果需要更精确的日志（比如记录分配字节数、调用栈），可以自定义一个继承自Eigen默认分配器的追踪分配器，在allocate和deallocate方法中添加日志逻辑。这种方式能精确追踪每个Eigen对象（包括临时数组）的分配行为，不管它在哪个函数里创建。

示例代码：

#include <Eigen/Core>
#include <iostream>

template <typename T>
struct TrackingAllocator : Eigen::Allocator<T> {
    typedef typename Eigen::Allocator<T>::pointer pointer;
    typedef typename Eigen::Allocator<T>::size_type size_type;

    pointer allocate(size_type num, const void* hint = nullptr) {
        const size_t bytes = num * sizeof(T);
        std::cout << "[Allocator] 分配 " << bytes << " 字节" << std::endl;
        return Eigen::Allocator<T>::allocate(num, hint);
    }

    void deallocate(pointer p, size_type num) {
        const size_t bytes = num * sizeof(T);
        std::cout << "[Allocator] 释放 " << bytes << " 字节" << std::endl;
        Eigen::Allocator<T>::deallocate(p, num);
    }
};

// 在函数中使用自定义分配器的Eigen对象
void funcB() {
    // 临时数组使用追踪分配器
    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, TrackingAllocator<double>> temp(1000, 1000);
}

void funcA() {
    funcB();
}

int main() {
    funcA();
    return 0;
}

运行后会输出每次分配/释放的字节数，方便你定位具体的分配点。

问题2：已定义#define EIGEN_RUNTIME_NO_MALLOC，函数A调用内联函数B，在A中设置set_is_malloc_allowed(false)后，是否会同时检查A与B中的分配？ #

答案是肯定的，不管B是否是内联函数，A和B中的Eigen内存分配都会被检查。这里需要理清两个机制的核心区别：

1. EIGEN_RUNTIME_NO_MALLOC的作用：这是一个编译时宏，它会让Eigen在编译阶段尽可能避免动态内存分配（比如强制固定大小矩阵使用栈内存），如果代码中存在无法避免的动态分配，编译时会直接报错。但它不影响运行时的内存分配检查逻辑。

2. set_is_malloc_allowed(false)的作用：这是一个运行时的全局（线程局部）开关，一旦设置为false，在后续的代码执行路径中，所有Eigen的动态内存分配都会被拦截（Debug模式下触发断言，Release模式下可能直接崩溃）。

因为内联函数在编译时会被展开到调用方函数中，即使不内联，只要在set_is_malloc_allowed(false)之后调用B，B的代码执行时也处于禁用分配的状态，所以B中的分配同样会被检查。

示例代码验证：

#define EIGEN_RUNTIME_NO_MALLOC
#include <Eigen/Core>

inline void funcB() {
    // 如果此时禁用了分配，这行代码会触发断言
    Eigen::MatrixXd temp(100, 100);
}

void funcA() {
    Eigen::internal::set_is_malloc_allowed(false);
    funcB(); // 内联的B中的分配会被检查
    // 自己的分配也会被检查
    // Eigen::MatrixXd temp(50,50); // 同样触发断言
    Eigen::internal::set_is_malloc_allowed(true);
}

int main() {
    funcA();
    return 0;
}

运行这段代码，Debug模式下会直接触发断言，说明B中的分配确实被检查到了。

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