如何将 Rust 内存分配器用于可提供分配器的 C 库？

我正在编写与 C 库的 Rust 绑定，该库可以选择使用第三方内存分配器。它的界面如下所示：

struct allocator {
    void*(*alloc)(void *old, uint);
    void(*free)(void*);
};

我猜，相应的 Rust 结构如下：

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Allocator {
    alloc: Option<extern "C" fn(*mut c_void, c_uint) -> *mut c_void>,
    free: Option<extern "C" fn(*mut c_void)>,
}

我如何实现这两个模拟分配器的外部函数？我没有找到任何真正像 Rust 中的分配器 API 的东西（但是我明白为什么），所以我很好奇它是否可能。

这并不像您希望的那么容易。

分配方法公开在heap的模块alloc crate.

创建一些包装器方法并填充结构很简单，但我们很快遇到了一个问题：

#![feature(heap_api)]

extern crate libc;
extern crate alloc;

use libc::{c_void, c_uint};
use alloc::heap;

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Allocator {
    alloc: Option<extern "C" fn(*mut c_void, c_uint) -> *mut c_void>,
    free: Option<extern "C" fn(*mut c_void)>,
}


extern "C" fn alloc_ext(old: *mut c_void, size: c_uint) -> *mut c_void {
    if old.is_null() {
        heap::allocate(size as usize, align) as *mut c_void
    } else {
        heap::reallocate(old as *mut u8, old_size, size as usize, align) as *mut c_void
    }
}

extern "C" fn free_ext(old: *mut c_void) {
    heap::deallocate(old as *mut u8, old_size, align);
}

fn main() {
    Allocator {
        alloc: Some(alloc_ext),
        free: Some(free_ext),
    };
}

Rust 分配器期望被告知任何先前分配的大小以及所需的对齐方式。您匹配的 API 没有任何方式传递该信息。

结盟should（我不是专家）可以硬编码某个值，比如 16 个字节。尺寸比较棘手。您可能需要借鉴一些旧的 C 技巧并分配一点额外的空间来存储大小。然后您可以存储大小并返回一个刚刚过去的指针。

A 完全未经测试例子：

#![feature(alloc, heap_api)]

extern crate libc;
extern crate alloc;

use libc::{c_void, c_uint};
use alloc::heap;
use std::{mem, ptr};

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Allocator {
    alloc: Option<extern "C" fn(*mut c_void, c_uint) -> *mut c_void>,
    free: Option<extern "C" fn(*mut c_void)>,
}

const ALIGNMENT: usize = 16;

extern "C" fn alloc_ext(old: *mut c_void, size: c_uint) -> *mut c_void {
    unsafe {
        // Should check for integer overflow
        let size_size = mem::size_of::<usize>();
        let size = size as usize + size_size;

        let memory = if old.is_null() {
            heap::allocate(size, ALIGNMENT)
        } else {
            let old = old as *mut u8;
            let old = old.offset(-(size_size as isize));
            let old_size = *(old as *const usize);
            heap::reallocate(old, old_size, size, ALIGNMENT)
        };

        *(memory as *mut usize) = size;
        memory.offset(size_size as isize) as *mut c_void
    }
}

extern "C" fn free_ext(old: *mut c_void) {
    if old.is_null() { return }

    unsafe {
        let size_size = mem::size_of::<usize>();

        let old = old as *mut u8;
        let old = old.offset(-(size_size as isize));
        let old_size = *(old as *const usize);

        heap::deallocate(old as *mut u8, old_size, ALIGNMENT);
    }
}

fn main() {
    Allocator {
        alloc: Some(alloc_ext),
        free: Some(free_ext),
    };

    let pointer = alloc_ext(ptr::null_mut(), 54);
    let pointer = alloc_ext(pointer, 105);
    free_ext(pointer);
}

难道不是[...using Vec作为分配者...] 更高级的解决方案？

这当然是可能的，但我不完全确定它如何与重新分配一起工作。您还必须跟踪设备的大小和容量Vec为了重构它以重新分配/删除它。