질문

C 애플리케이션을 C #으로 이식하고 있습니다. C 앱은 타사 DLL에서 많은 함수를 호출하므로 이러한 함수에 대한 P / Invoke 래퍼를 C #으로 작성했습니다. 이러한 C의 기능 중 일부는 내가 사용, 그래서 나는 C #을 응용 프로그램에서 사용할 수있는 데이터를 할당 IntPtr'들, Marshal.PtrToStructure그리고 Marshal.Copy관리 변수로 기본 데이터 (배열과 구조)을 복사 할 수 있습니다.

불행히도 C # 앱은 C 버전보다 훨씬 느린 것으로 판명되었습니다. 빠른 성능 분석은 위에서 언급 한 마샬링 기반 데이터 복사가 병목임을 보여주었습니다. 대신 포인터를 사용하도록 다시 작성하여 C # 코드의 속도를 높이는 것을 고려하고 있습니다. C #에서 안전하지 않은 코드와 포인터에 대한 경험이 없기 때문에 다음 질문 에 대한 전문가 의견이 필요합니다 .

1. and ing unsafe대신 코드와 포인터 를 사용하는 단점은 무엇입니까 ? 예를 들어, 어떤 식 으로든 더 안전하지 않습니까 (의도 된 말장난)? 사람들은 마샬링을 선호하는 것 같지만 이유를 모르겠습니다.IntPtrMarshal
2. 마샬링을 사용하는 것보다 P / Invoking에 포인터를 사용하는 것이 정말 빠릅니까? 대략 어느 정도의 속도 향상을 기대할 수 있습니까? 이에 대한 벤치 마크 테스트를 찾을 수 없습니다.

예제 코드

상황을 더 명확하게하기 위해 작은 예제 코드를 함께 해킹했습니다 (실제 코드는 훨씬 더 복잡합니다). 이 예제가 "안전하지 않은 코드 및 포인터"대 "IntPtr 및 Marshal"에 대해 말할 때 제가 의미하는 바를 보여주기를 바랍니다.

C 라이브러리 (DLL)

MyLib.h

#ifndef _MY_LIB_H_
#define _MY_LIB_H_

struct MyData 
{
  int length;
  unsigned char* bytes;
};

__declspec(dllexport) void CreateMyData(struct MyData** myData, int length);
__declspec(dllexport) void DestroyMyData(struct MyData* myData);

#endif // _MY_LIB_H_

MyLib.c

#include <stdlib.h>
#include "MyLib.h"

void CreateMyData(struct MyData** myData, int length)
{
  int i;

  *myData = (struct MyData*)malloc(sizeof(struct MyData));
  if (*myData != NULL)
  {
    (*myData)->length = length;
    (*myData)->bytes = (unsigned char*)malloc(length * sizeof(char));
    if ((*myData)->bytes != NULL)
      for (i = 0; i < length; ++i)
        (*myData)->bytes[i] = (unsigned char)(i % 256);
  }
}

void DestroyMyData(struct MyData* myData)
{
  if (myData != NULL)
  {
    if (myData->bytes != NULL)
      free(myData->bytes);
    free(myData);
  }
}

C 신청

Main.c

#include <stdio.h>
#include "MyLib.h"

void main()
{
  struct MyData* myData = NULL;
  int length = 100 * 1024 * 1024;

  printf("=== C++ test ===\n");
  CreateMyData(&myData, length);
  if (myData != NULL)
  {
    printf("Length: %d\n", myData->length);
    if (myData->bytes != NULL)
      printf("First: %d, last: %d\n", myData->bytes[0], myData->bytes[myData->length - 1]);
    else
      printf("myData->bytes is NULL");
  }
  else
    printf("myData is NULL\n");
  DestroyMyData(myData);
  getchar();
}

IntPtr및 사용하는 C # 응용 프로그램Marshal

Program.cs

using System;
using System.Runtime.InteropServices;

public static class Program
{
  [StructLayout(LayoutKind.Sequential)]
  private struct MyData
  {
    public int Length;
    public IntPtr Bytes;
  }

  [DllImport("MyLib.dll")]
  private static extern void CreateMyData(out IntPtr myData, int length);

  [DllImport("MyLib.dll")]
  private static extern void DestroyMyData(IntPtr myData);

  public static void Main()
  {
    Console.WriteLine("=== C# test, using IntPtr and Marshal ===");
    int length = 100 * 1024 * 1024;
    IntPtr myData1;
    CreateMyData(out myData1, length);
    if (myData1 != IntPtr.Zero)
    {
      MyData myData2 = (MyData)Marshal.PtrToStructure(myData1, typeof(MyData));
      Console.WriteLine("Length: {0}", myData2.Length);
      if (myData2.Bytes != IntPtr.Zero)
      {
        byte[] bytes = new byte[myData2.Length];
        Marshal.Copy(myData2.Bytes, bytes, 0, myData2.Length);
        Console.WriteLine("First: {0}, last: {1}", bytes[0], bytes[myData2.Length - 1]);
      }
      else
        Console.WriteLine("myData.Bytes is IntPtr.Zero");
    }
    else
      Console.WriteLine("myData is IntPtr.Zero");
    DestroyMyData(myData1);
    Console.ReadKey(true);
  }
}

unsafe코드와 포인터 를 사용하는 C # 애플리케이션

Program.cs

using System;
using System.Runtime.InteropServices;

public static class Program
{
  [StructLayout(LayoutKind.Sequential)]
  private unsafe struct MyData
  {
    public int Length;
    public byte* Bytes;
  }

  [DllImport("MyLib.dll")]
  private unsafe static extern void CreateMyData(out MyData* myData, int length);

  [DllImport("MyLib.dll")]
  private unsafe static extern void DestroyMyData(MyData* myData);

  public unsafe static void Main()
  {
    Console.WriteLine("=== C# test, using unsafe code ===");
    int length = 100 * 1024 * 1024;
    MyData* myData;
    CreateMyData(out myData, length);
    if (myData != null)
    {
      Console.WriteLine("Length: {0}", myData->Length);
      if (myData->Bytes != null)
        Console.WriteLine("First: {0}, last: {1}", myData->Bytes[0], myData->Bytes[myData->Length - 1]);
      else
        Console.WriteLine("myData.Bytes is null");
    }
    else
      Console.WriteLine("myData is null");
    DestroyMyData(myData);
    Console.ReadKey(true);
  }
}