node.js - 用 Rust 编写的 Node.js 扩展中的内存泄漏

Question

我正在用 Rust 编写一个 Node.js 扩展。我从 C 中调用了这个玩具库，用 Valgrind 进行了检查，没有发现内存泄漏。

我从 Python 和 Ruby 中调用了同一个库，在无限循环中运行，并且没有看到内存泄漏的迹象。（由于这里的声誉不足，我无法发布图片）。

当从 Node.js 调用同一个库时，内存使用量似乎随时间增加：

时间单位是循环的周期，而不是实时。

下面是 Rust 代码：

#[repr(C)]
pub struct Matrix {
    m: Vec<Vec<f64>>,
}

#[no_mangle]
pub extern "C" fn matrix_new(nrow: usize, ncol: usize) -> *mut Matrix {
    let mut m = Vec::new();
    for _ in 0..(nrow) {
        let mut n = Vec::new();

        for _ in 0..(ncol) {
            n.push(0.0);
        }

        m.push(n);
    }

    Box::into_raw(Box::new(Matrix { m: m }))
}

#[no_mangle]
pub extern "C" fn matrix_free(matrix: *mut Matrix) {
    if matrix.is_null() {
        return
    }

    unsafe { Box::from_raw(matrix); }
}

这是原始的 Node.js 代码：

var ref = require('ref');
var ffi = require('ffi');

var c_matrix = ref.types.void;
var c_matrix_ptr = ref.refType(c_matrix);

var libmatrix = ffi.Library('./target/release/libmatrix.so', {
    'matrix_new': [ c_matrix_ptr, ['size_t', 'size_t']],
    'matrix_get': [ 'double', [ c_matrix_ptr, 'size_t', 'size_t']],
    'matrix_set': [ 'double', [ c_matrix_ptr, 'size_t', 'size_t', 'double']],
    'matrix_free': [ 'void', [ c_matrix_ptr ]]
});

var matrix = function(nrow, ncol) {
    "use strict";

    var matrix = libmatrix.matrix_new(nrow, ncol);

    Object.defineProperty(this, '_matrix', {
        value: matrix,
        writeable: false
    });

    return this;
};

matrix.prototype.get = function(row, col) {
    "use strict";

    return libmatrix.matrix_get(this._matrix, row, col);
};

matrix.prototype.set = function(row, col, value) {
    "use strict";

    libmatrix.matrix_set(this._matrix, row, col, value);
};

matrix.prototype.free = function() {
    "use strict";

    libmatrix.matrix_free(this._matrix);
};

module.exports = matrix;

if (!module.parent) {
    while (true) {
        var m = new matrix(3, 3);

        m.free();
        m = null;
        delete global.m;

        global.gc();
        console.log(process.memoryUsage().rss);
    }
}

一些信息：

• 操作系统：Debian GNU/Linux (Jessie)
• Node.js：7.2.0
• 节点gyp：7.2.0
• 菲：2.2.0
• 参考：1.3.3
• 锈：1.13.0

我用 C 重写了同一个库：

typedef struct Matrix {
    size_t nrow;
    size_t ncol;
    double** mtx;
} Matrix;

void* matrix_new(size_t row, size_t col) {
    Matrix* m = malloc(sizeof(Matrix));
    m->nrow = row;
    m->ncol = col;

    m->mtx = malloc(m->nrow * sizeof(double*));

    for (int i = 0; i < m->nrow; i++) {
        *((m->mtx)+i) = (double*) malloc(m->ncol * sizeof(double));
    }

    for (int i = 0; i < m->nrow; i++) {
        for (int j = 0; j < m->ncol; j++) {
            m->mtx[i][j] = 0.0;
        }
    }

    return (void*) m;
}

void matrix_free(void* m) {
    if (m == NULL) {
        return;
    }

    double** ptr = ((Matrix*) m)->mtx;
    for (int i = 0; i < ((Matrix*) m)->nrow; i++) {
        free((void*) (ptr[i]));
    }

   free((void*) ((Matrix*) m)->mtx);
   free((void*) m);
}

我还将 Node 的版本从 7.2.0 更改为 7.3.0。以下是具有 C 和 Rust 实现的 Node.js 模块的内存使用情况：

我在不更改 Node.js 代码的情况下尝试了一个无操作库，发现一些令我惊讶的东西：