使用 HGlobalAlloc 将非托管缓冲区从 C++ 传递到 C# 而无需复制

Question

我继承了 .NET 框架 C#/非托管 C++ 项目的维护，并被要求尝试改进它的性能。在追求低调的果实和一些分析之后，我可以轻松做的下一件事似乎是试图降低跨 C#/C++ 互操作边界传输大型缓冲区的成本，因为程序花费了大约 30% 的时间来做这个编组/复制。我认为这很简单，因为 C# 具有良好的互操作支持，并且文档似乎表明这是可能的。

在尝试了几种方法但都失败后，我制作了一个测试解决方案来简化事情并确保我理解正在发生的事情。从原始代码库中删除抽象后，该示例的 C# 代码如下所示：

using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Diagnostics;


namespace InteropExample
{
    internal class Program
    {
        static void Main()
        {
            UnsafeNativeMethods.InitCpp();
            IntPtr buf = Marshal.AllocHGlobal(4096);
            int size = 0;
            UnsafeNativeMethods.OnGetDataBuffer(buf, ref size);
            Debug.WriteLine("C# buffer in:\t{0:X}", buf);

            Marshal.FreeHGlobal(buf);
        }
        // docs say we should see "substantial performance savings" with this attribute
        [SuppressUnmanagedCodeSecurity] 
        internal static class UnsafeNativeMethods
        {
            [DllImport("CppSide.dll")]
            public static extern void InitCpp();

            [DllImport("CppSide.dll")]
            public static extern void OnGetDataBuffer(IntPtr buffer, ref int size);

        }
    }
}

C++ 方面，我对原始代码库中的各个部分的注释和抽象被删除：

#include "CppSide.h"
#include <memory>

// way more complicated, former owner implemented their own shared_ptr
// and Memorypool system and has a ton of getter, setter, and helper functions for it
class Buffer
{
public:
    size_t _size;
    size_t _usedSize;
    char* _data;

    Buffer() :
        _size(4096),
        _data(NULL)
    {
        size_t charSize = _size / sizeof(char);
        // guessing this is to get around destructors running
        // and get better SSE2 vectorization
        _data = (char*)_aligned_malloc(_size, (size_t)256);
        
        // used size is set by the user after it has requested a buffer from the buffer pool
        // for now we set it to an arbitrary value
        _usedSize = 768;

    }
    ~Buffer() {
        _aligned_free(_data);
    }
};

std::shared_ptr<Buffer> out;

extern "C" __declspec (dllexport) void InitCpp()
{
    // in real program this starts up various threads and pipelines 
    // that produce and accept the buffers, for now we will simulate this
    // just by creating one buffer heading out
        
    out = std::make_shared<Buffer>();
}

extern "C" __declspec (dllexport) void OnGetDataBuffer(char* buffer, int size) {
    memcpy(buffer, out->_data, out->_usedSize);
    size = out->_usedSize;
    std::ostringstream ss;
    ss << "C++ out Buffer ptr:\t" << std::hex << static_cast<void*>(buffer) << std::endl;
    OutputDebugStringA(ss.str().c_str());
    out = NULL;
    // The actual code doesn't do remove out explicitly
    // but the buffer is returned to the pool soon after
    // being called by the pipeline replacing it
}

当我尝试删除 memcpy 和 HGlobalAlloc 时，将 _data 指针直接传递到 C# 端，并固定共享指针以使缓冲区不会被删除，我将 IntPtr 设置为零回到 C# 端。我认为这可能是我分配方式的问题，HGlobalAlloc 的底层分配器是GlobalAlloc，所以我还将缓冲区中的_aligned_malloc 和_aligned_free 调用与GlobalAlloc(GPTR, charSize) 和GlobalFree 交换，但仍然得到了相同的结果。这给我留下了当前无效的例子：

using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Diagnostics;

namespace InteropExample
{
    internal class Program
    {
        static void Main()
        {
            UnsafeNativeMethods.InitCpp();
            IntPtr buf = IntPtr.Zero;
            int size = 0;
            UnsafeNativeMethods.OnGetDataBuffer(ref buf, ref size);
            Debug.WriteLine("C# buffer in:\t{0:X}", buf);
        }

        [SuppressUnmanagedCodeSecurity]
        internal static class UnsafeNativeMethods
        {
            [DllImport("CppSide.dll")]
            public static extern void InitCpp();

            [DllImport("CppSide.dll")]
            public static extern void OnGetDataBuffer(ref IntPtr buffer, ref int size);
        }
    }
}

#include "CppSide.h"
#include <memory>
#include <windows.h>
#include <iostream>
#include <sstream>

class Buffer
{
public:
    size_t _size;
    size_t _usedSize;
    char* _data;

    Buffer() :
        _size(4096),
        _data(NULL)
    {
        size_t charSize = _size / sizeof(char);
        _data = (char *)GlobalAlloc(GPTR, charSize);

        // used size is set by the user after it has requested a buffer from the buffer pool
        // for now we set it to an arbitrary value
        _usedSize = 768;

    }
    ~Buffer() {
        GlobalFree(_data);
    }
};

std::shared_ptr<Buffer> out;

extern "C" __declspec (dllexport) void InitCpp()
{
    out = std::make_shared<Buffer>();
}

extern "C" __declspec (dllexport) void OnGetDataBuffer(char* buffer, int size) {
    buffer = out->_data;
    size = out->_usedSize;
    std::ostringstream ss;
    ss << "C++ out Buffer ptr:\t" << std::hex << static_cast<void*>(buffer) << std::endl;
    OutputDebugStringA(ss.str().c_str());
}

再次查看 C# 互操作文档后，我找不到能够将指针传回非托管内存的示例，所以我想我的问题如下：

1. 是否可以将指向从 C++ 分配的非托管内存的指针传回 C# 以避免编组/复制大型缓冲区？
2. 如果必须在托管端分配缓冲区，然后将非托管缓冲区的内容复制到其中，是否有更有效的方法？我可以使用哪些池化策略？我查看了MemoryPool，但我不明白它是否/如何用于替换原始代码中的Marshal.AllocHGlobal 调用。

Answer 1

事实证明，我还没有完全恢复思考指针的想法。将互操作接口更改为在 C++ 端使用 char** 并重写围绕它的代码解决了这个问题，因为我忘记了我正在传递指针。测试似乎表明分配方法也有效。