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
node-gyp：7.2.0
ffi：2.2.0
ref：1.3.3
Rust：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。以下是Node.js模块的内存使用情况，包括C和Rust实现：

我在没有更改Node.js代码的情况下尝试了一个无操作库，找到了令我自己惊讶的东西：

用Rust

0 个答案: