我应该如何释放在 Rust 中分配的 C# byte[]？
How should I free a C# byte[] allocated in Rust?
我有一个将字节数组传递给 C# 的 Rust 函数：
#[no_mangle]
pub extern "C" fn get_bytes(len: &mut i32, bytes: *mut *mut u8) {
let mut buf : Vec<u8> = get_data();
buf.shrink_to_fit();
// Set the output values
*len = buf.len() as i32;
unsafe {
*bytes = buf.as_mut_ptr();
}
std::mem::forget(buf);
}
在 C# 中，我可以调用它而不会崩溃。 （为了避免崩溃，我 假设 这是正确的，但我不是 100% 确定）：
[DllImport("my_lib")] static extern void get_bytes(ref int len,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] ref byte[] bytes);
void test()
{
int len = 0;
byte[] bytes = null;
get_bytes(ref len, ref bytes);
}
然后我使用 bytes，但我知道这个内存需要被 Rust 释放。所以我有另一个 Rust 函数来释放它：
#[no_mangle]
pub extern "C" fn free_bytes(len: i32, bytes: *mut *mut u8) {
// also tried with: -------------- bytes: *mut u8
assert!(len > 0);
// Rebuild the vec
let v = unsafe { Vec::from_raw_parts(bytes, len as usize, len as usize) };
//println!("bytes to free: {:?}", v);
drop(v); // or it could be implicitly dropped
}
以及相应的C#。拨打电话使我的应用程序崩溃：
[DllImport("my_lib")] extern void free_bytes(int len, ref byte[] bytes);
void test()
{
int len = 0;
byte[] bytes = null;
get_bytes(ref len, ref bytes);
// copy bytes to managed memory
bytes[] copy = new byte[len];
bytes.CopyTo(copy, 0);
// free the unmanaged memory
free_bytes(len, ref bytes); // crash occurs when executing this function
}
我看到 Vec::from_parts_raw“非常不安全”。因为“capacity 需要是分配给指针的容量。”，我还尝试在没有 shrink_to_fit 的情况下在 Rust 和 C# 之间传递容量以保留长度和容量。那也崩溃了。
我假设 from_parts_raw 恢复了堆上的现有内存，但我注意到 C# 中的字节内容（如 Visual Studio 所示）与 Rust 中的内容不匹配（通过 'bytes to free'println）。在我的 C# DllImport 中，在 Rust 接受的类型（例如，*mut u8 与 *mut *mut u8）中，我如何恢复要释放的 Vec<u8> 的错误也是如此，其他地方？
主要问题
一个byte*/*mut u8和一个byte[]是不同种类的对象。后者 必须 指向由 .NET GC 管理的内存。因此，虽然可以将 byte[] 视为 byte*（固定时），但您无法将任意 byte* 视为 byte[].
我不完全确定编组器在你的情况下做了什么，但它可能是这样的：
- 分配一个指针大小的space，初始化为空指针。
- 使用指向此 space 的指针作为第二个参数调用 rust 方法。
- 将 space 的更新内容解释为指向 C 样式字节数组的指针。
- 将此数组的内容复制到新分配的托管数组。
- 将该托管数组放在 C# 本地
bytes。
如您所见，您在 bytes 中获得的数组是一个新的托管数组，与 Rust 写入 *bytes 的指针没有持久关系。所以当然尝试在 bytes 上调用 free_bytes 会失败，因为它将被编组为指向由 .NET GC 而不是 Rust 管理的内存的指针。
次要问题
如果您打算通过 P/Invoke 释放内存，则无法绕过将容量传递给 C# 并保留它。这是因为 Vec::shrink_to_fit 不能保证将 capacity 减少到 len，如 the documentation 所示。您 必须 具有正确的容量才能调用 Vec::from_raw_parts.
解决方案
将 Vec 的所有权传递给其他代码的唯一合理方法是在 Rust 端使用类似的函数。
#[no_mangle]
pub unsafe extern "C" fn get_bytes(len: *mut i32, capacity: *mut i32) -> *mut u8 {
let mut buf: Vec<u8> = get_data();
*len = buf.len() as i32;
*capacity = buf.capacity() as i32;
let bytes = buf.as_mut_ptr();
std::mem::forget(buf);
return bytes;
}
#[no_mangle]
pub unsafe extern "C" fn free_bytes(data: *mut u8, len: i32, capacity: i32) {
let v = Vec::from_raw_parts(bytes, len as usize, capacity as usize);
drop(v); // or it could be implicitly dropped
}
而在 C# 方面，您将拥有类似这样的内容：
[DllImport("my_lib")]
static extern IntPtr get_bytes(out int len, out int capacity);
[DllImport("my_lib")]
static extern void free_bytes(IntPtr bytes, int len, int capacity);
void test()
{
int len, capacity;
IntPtr ptr = get_bytes(out len, out capacity);
// TODO: use the data in ptr somehow
free_bytes(ptr, len, capacity);
}
对于用什么代替 TODO，您有几个不同的选择。
- 按原样使用
IntPtr，使用 Marshal.ReadIntPtr 等方法从数组中读取数据。我不推荐这样做，因为它冗长且容易出错，并且会阻止使用大多数针对数组的 API。
- 将
IntPtr 转换为带有 (byte*)ptr.ToPointer() 的 byte* 并直接使用原始 byte*。这可能比上面的稍微不那么冗长，但它同样容易出错，而且许多有用的 API 不接受原始指针。
- 将数据从
IntPtr 复制到托管 byte[]。这有点低效，但您将拥有真正托管数组的所有优点，并且即使在对原始内存调用 free_bytes 之后也可以安全地使用该数组。然而，如果你想修改数组并让这些修改对 Rust 可见，你将不得不执行另一个副本。对于此解决方案，将注释替换为：
byte[] bytes = new byte[len];
Marshal.Copy(ptr, bytes, 0, len);
- 如果您使用的是 C# 7.2 或更高版本，则可以避免使用新的
Span<T> 类型复制内存，该类型可以表示一系列托管或非托管内存。根据您计划使用 bytes 执行的操作，Span<byte> 可能就足够了，因为许多 API 已更新为接受最新版本的 C# 中的跨度。由于 span 直接引用由 Rust 分配的内存，因此对它的任何更改都会反映在 Rust 端，并且在调用 free_bytes 释放该内存后，您不得尝试使用它。对于此解决方案，将注释替换为：
Span<byte> bytes = new Span<byte>(ptr.ToPointer(), len);
关于安全的注意事项
注意 Rust 函数 get_bytes 被标记为 unsafe。这是因为 as 运算符用于将 vec 的长度和容量转换为 i32s。如果它们不在 i32 的范围内，这将导致恐慌，据我所知，在 P/Invoke 引入的 FFI 边界上恐慌仍然是未定义的行为。在生产代码中，get_bytes 可以修改为以其他方式处理此类错误，可能是通过返回空指针，而 C# 需要检测这种情况并采取相应措施。
我有一个将字节数组传递给 C# 的 Rust 函数：
#[no_mangle]
pub extern "C" fn get_bytes(len: &mut i32, bytes: *mut *mut u8) {
let mut buf : Vec<u8> = get_data();
buf.shrink_to_fit();
// Set the output values
*len = buf.len() as i32;
unsafe {
*bytes = buf.as_mut_ptr();
}
std::mem::forget(buf);
}
在 C# 中，我可以调用它而不会崩溃。 （为了避免崩溃，我 假设 这是正确的，但我不是 100% 确定）：
[DllImport("my_lib")] static extern void get_bytes(ref int len,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] ref byte[] bytes);
void test()
{
int len = 0;
byte[] bytes = null;
get_bytes(ref len, ref bytes);
}
然后我使用 bytes，但我知道这个内存需要被 Rust 释放。所以我有另一个 Rust 函数来释放它：
#[no_mangle]
pub extern "C" fn free_bytes(len: i32, bytes: *mut *mut u8) {
// also tried with: -------------- bytes: *mut u8
assert!(len > 0);
// Rebuild the vec
let v = unsafe { Vec::from_raw_parts(bytes, len as usize, len as usize) };
//println!("bytes to free: {:?}", v);
drop(v); // or it could be implicitly dropped
}
以及相应的C#。拨打电话使我的应用程序崩溃：
[DllImport("my_lib")] extern void free_bytes(int len, ref byte[] bytes);
void test()
{
int len = 0;
byte[] bytes = null;
get_bytes(ref len, ref bytes);
// copy bytes to managed memory
bytes[] copy = new byte[len];
bytes.CopyTo(copy, 0);
// free the unmanaged memory
free_bytes(len, ref bytes); // crash occurs when executing this function
}
我看到 Vec::from_parts_raw“非常不安全”。因为“capacity 需要是分配给指针的容量。”，我还尝试在没有 shrink_to_fit 的情况下在 Rust 和 C# 之间传递容量以保留长度和容量。那也崩溃了。
我假设 from_parts_raw 恢复了堆上的现有内存，但我注意到 C# 中的字节内容（如 Visual Studio 所示）与 Rust 中的内容不匹配（通过 'bytes to free'println）。在我的 C# DllImport 中，在 Rust 接受的类型（例如，*mut u8 与 *mut *mut u8）中，我如何恢复要释放的 Vec<u8> 的错误也是如此，其他地方？
主要问题
一个byte*/*mut u8和一个byte[]是不同种类的对象。后者 必须 指向由 .NET GC 管理的内存。因此，虽然可以将 byte[] 视为 byte*（固定时），但您无法将任意 byte* 视为 byte[].
我不完全确定编组器在你的情况下做了什么，但它可能是这样的：
- 分配一个指针大小的space，初始化为空指针。
- 使用指向此 space 的指针作为第二个参数调用 rust 方法。
- 将 space 的更新内容解释为指向 C 样式字节数组的指针。
- 将此数组的内容复制到新分配的托管数组。
- 将该托管数组放在 C# 本地
bytes。
如您所见，您在 bytes 中获得的数组是一个新的托管数组，与 Rust 写入 *bytes 的指针没有持久关系。所以当然尝试在 bytes 上调用 free_bytes 会失败，因为它将被编组为指向由 .NET GC 而不是 Rust 管理的内存的指针。
次要问题
如果您打算通过 P/Invoke 释放内存，则无法绕过将容量传递给 C# 并保留它。这是因为 Vec::shrink_to_fit 不能保证将 capacity 减少到 len，如 the documentation 所示。您 必须 具有正确的容量才能调用 Vec::from_raw_parts.
解决方案
将 Vec 的所有权传递给其他代码的唯一合理方法是在 Rust 端使用类似的函数。
#[no_mangle]
pub unsafe extern "C" fn get_bytes(len: *mut i32, capacity: *mut i32) -> *mut u8 {
let mut buf: Vec<u8> = get_data();
*len = buf.len() as i32;
*capacity = buf.capacity() as i32;
let bytes = buf.as_mut_ptr();
std::mem::forget(buf);
return bytes;
}
#[no_mangle]
pub unsafe extern "C" fn free_bytes(data: *mut u8, len: i32, capacity: i32) {
let v = Vec::from_raw_parts(bytes, len as usize, capacity as usize);
drop(v); // or it could be implicitly dropped
}
而在 C# 方面，您将拥有类似这样的内容：
[DllImport("my_lib")]
static extern IntPtr get_bytes(out int len, out int capacity);
[DllImport("my_lib")]
static extern void free_bytes(IntPtr bytes, int len, int capacity);
void test()
{
int len, capacity;
IntPtr ptr = get_bytes(out len, out capacity);
// TODO: use the data in ptr somehow
free_bytes(ptr, len, capacity);
}
对于用什么代替 TODO，您有几个不同的选择。
- 按原样使用
IntPtr，使用Marshal.ReadIntPtr等方法从数组中读取数据。我不推荐这样做，因为它冗长且容易出错，并且会阻止使用大多数针对数组的 API。 - 将
IntPtr转换为带有(byte*)ptr.ToPointer()的byte*并直接使用原始byte*。这可能比上面的稍微不那么冗长，但它同样容易出错，而且许多有用的 API 不接受原始指针。 - 将数据从
IntPtr复制到托管byte[]。这有点低效，但您将拥有真正托管数组的所有优点，并且即使在对原始内存调用free_bytes之后也可以安全地使用该数组。然而，如果你想修改数组并让这些修改对 Rust 可见，你将不得不执行另一个副本。对于此解决方案，将注释替换为：
byte[] bytes = new byte[len];
Marshal.Copy(ptr, bytes, 0, len);
- 如果您使用的是 C# 7.2 或更高版本，则可以避免使用新的
Span<T>类型复制内存，该类型可以表示一系列托管或非托管内存。根据您计划使用bytes执行的操作，Span<byte>可能就足够了，因为许多 API 已更新为接受最新版本的 C# 中的跨度。由于 span 直接引用由 Rust 分配的内存，因此对它的任何更改都会反映在 Rust 端，并且在调用free_bytes释放该内存后，您不得尝试使用它。对于此解决方案，将注释替换为：
Span<byte> bytes = new Span<byte>(ptr.ToPointer(), len);
关于安全的注意事项
注意 Rust 函数 get_bytes 被标记为 unsafe。这是因为 as 运算符用于将 vec 的长度和容量转换为 i32s。如果它们不在 i32 的范围内，这将导致恐慌，据我所知，在 P/Invoke 引入的 FFI 边界上恐慌仍然是未定义的行为。在生产代码中，get_bytes 可以修改为以其他方式处理此类错误，可能是通过返回空指针，而 C# 需要检测这种情况并采取相应措施。