俄罗斯贵宾会-俄罗斯贵宾会官网
做最好的网站

C#内存映射大文件并使用Marshal解析结构体信息

内存映射数据处理类主要函数及变量如下:

转载 结构体对齐详解

 1        string _filepath;
 2        /// <summary>
 3         /// 引用内存映射文件
 4         /// </summary>
 5         private MemoryMappedFile _memoryFile = null;
 6         /// <summary>
 7         /// 用于访问内存映射文件的存取对象
 8         /// </summary>
 9         private MemoryMappedViewAccessor _accessor = null;
10         public ScientificData _ScientificData = new ScientificData();
11         long _lenByte = 0;
12         public DatFileInfo(string filepath)
13         {
14             _filepath = filepath;
15             _memoryFile = MemoryMappedFile.CreateFromFile(_filepath);
16             _accessor = _memoryFile.CreateViewAccessor();
17             // _stream = _memoryFile.CreateViewStream();
18             FileInfo finfo = new FileInfo(filepath);
19             _lenByte = finfo.Length;//文件字节大小
20         }
21         public void SaveRawData(string savepath)
22         {
23             
24             int currentByteNum = 0;//当前字节位置
25             uint ACountint = 0;
26             uint RCountint = 0;
27             ScientificData scientificData = new ScientificData();
28             byte[] data = new byte[1036 * 1036];
29             while (currentByteNum<= (_lenByte- 1036 * 1036))
30             {
31                 _accessor.Read<uint>(currentByteNum, out RCountint);
32                 _accessor.Read<uint>(currentByteNum+4, out ACountint);
33                 if (RCountint < 1400 && ACountint < 1401 && _accessor.ReadByte(currentByteNum+8)==0x0a && _accessor.ReadByte(currentByteNum + 9) == 0x0b)//初步判断条件,节省解析结构体时间
34                 {
35                     _accessor.ReadArray(currentByteNum, data, 0, data.Length);//读取结构体数据到字节数组
36                     scientificData = ByteToStructure<ScientificData>(data);//字节数组解析到结构体
37                     if((scientificData.aux_3a1 == 0x3A) && (scientificData.aux_3a3 == 0x3A))//进一步判断
38                     {
39                         ushort[,] sdata = scientificData.GetImageData();//得到所需的数据
40                         saveRawData(savepath + ((int)((ACountint - 1)/15+1)).ToString()+ "_" + (ACountint-1).ToString() + "_"+ACountint + "_"+scientificData.aux_num + ".raw" , sdata);
41                         currentByteNum += 1036 * 1036;
42                     }
43                     else
44                         currentByteNum++;
45                 }
46                 else
47                     currentByteNum++;
48 
49 
50             }
51         }
52         /// <summary>
53         /// 由byte数组转换为结构体
54         /// </summary>
55         public static T ByteToStructure<T>(byte[] dataBuffer)
56         {
57             object structure = null;
58             int size = Marshal.SizeOf(typeof(T));
59             IntPtr allocIntPtr = Marshal.AllocHGlobal(size);
60             try
61             {
62                 Marshal.Copy(dataBuffer, 0, allocIntPtr, size);
63                 structure = Marshal.PtrToStructure(allocIntPtr, typeof(T));
64             }
65             finally
66             {
67                 Marshal.FreeHGlobal(allocIntPtr);
68             }
69             return (T)structure;
70         }
71         private void saveRawData(string savepath,ushort[,] data)
72         {
73             int len = data.Length*2;
74             byte[] bdata = new byte[len];
75             Buffer.BlockCopy(data,0,bdata,0,len);
76             File.WriteAllBytes(savepath, bdata);
77         }
78         /// <summary>
79         /// 由结构体转换为byte数组
80         /// </summary>
81         public static byte[] StructureToByte<T>(T structure)
82         {
83             int size = Marshal.SizeOf(typeof(T));
84             byte[] buffer = new byte[size];
85             IntPtr bufferIntPtr = Marshal.AllocHGlobal(size);
86             try
87             {
88                 Marshal.StructureToPtr(structure, bufferIntPtr, true);
89                 Marshal.Copy(bufferIntPtr, buffer, 0, size);
90             }
91             finally
92             {
93                 Marshal.FreeHGlobal(bufferIntPtr);
94             }
95             return buffer;
96         }

结构体数据成员对齐的意义

许多实际的计算机系统对基本类型数据在内存中存放的位置有限制,它们会要求这些数据的起始地址的值是某个数k的倍数,这就是所谓的内存对齐,而这个k则被称为该数据类型的对齐模数(alignment modulus)。这种强制的要求一来简化了处理器与内存之间传输系统的设计,二来可以提升读取数据的速度。

比如这么一种处理器,它每次读写内存的时候都从某个8倍数的地址开始,一次读出或写入8个字节的数据,假如软件能保证double类型的数据都从8倍数地址开始,那么读或写一个double类型数据就只需要一次内存操作。否则,我们就可能需要
两次内存操作才能完成这个动作,因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。

科学数据结构体定义如下:

结构体对齐包括两个方面的含义

  • 结构体总长度;
  • 结构体内各数据成员的内存对齐,即该数据成员相对结构体的起始位置;
  //一幅1036*1036字节数据定义
    public struct ScientificData
     {
        /参数信息
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
       public byte[] RelativePacketCount;
      [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
       public Byte[] AbsolutePacketCount;
     ........
      public byte aux_3a;//填充3A H
       .........
      [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1036)]
        public OneImageRow[] ImageData;//图像数据行
/// <summary>
/// 获取raw图数据
/// </summary>
/// <returns>图像数据</returns>
public ushort[,] GetImageData()
{
ushort[,] rawdata = new ushort[1036, 512];
for (int i = 0; i < 1036; i++)
{
var onerow = ImageData[i];
for (int j = 0; j < 512; j++)
{
rawdata[i, j] = (ushort)(((onerow.imagedata[j * 2] << 8) | onerow.imagedata[j * 2 + 1])) ;
}
}
return rawdata;
}
}

结构体大小的计算方法和步骤

  1. 将结构体内所有数据成员的长度值相加,记为sum_a;
  1. 将各数据成员为了内存对齐,按各自对齐模数而填充的字节数累加到和sum_a上,记为sum_b。对齐模数是#pragma pack 指定的数值以及该数据成员自身长度中数值较小者。该数据相对起始位置应该是对齐模式的整数倍;
  2. 将和sum_俄罗斯贵宾会,b向结构体模数对齐,该模数是 #pragma pack指定的数值未指定#pragma pack时,系统默认的对齐模数(32位系统为4字节,64位为8字节)结构体内部最大的基本数据类型成员 长度中数值较小者。结构体的长度应该是该模数的整数倍。

图像数据结构体如下:

结构体大小计算举例

在计算之前,我们首先需要明确的是各个数据成员的对齐模数,对齐模数和数据成员本身的长度以及pragma pack编译参数有关,其值是二者中最小数。如果程序没有明确指出,就需要知道编译器默认的对齐模数值。下表是Windows XP/DEV-C++和Linux/GCC中基本数据类型的长度和默认对齐模数。

char short int long float double long long long double
Win-32长度 1 2 4 4 4 8 8 8
模数 1 2 4 4 4 8 8 8
Linux-32长度 1 2 4 4 4 8 8 12
模数 1 2 4 4 4 4 4 4
Linux-64长度 1 2 4 8 4 8 8 16
模数 1 2 4 8 4 8 8 16

 

例子1:

struct my_struct 
{ 
    char a; 
    long double b; 
};

此例子Windows和Linux计算方法有些许不一致。

在Windows中计算步骤如下:

  1. 所有数据成员自身长度和:1B + 8B = 9B --> sum_a = 9B
  1. 数据成员a放在相对偏移0处,之前不需要填充字节;数据成员b为了内存对齐,根据“结构体大小的计算方法和步骤”中第二条原则,其对齐模数是8,之前需填充7个字节,sum_a + 7 = 16B --> sum_b = 16 B
  2. 按照定义,结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者,前者为8后者为4,所以结构体对齐模数是4。sum_b是4的4倍,不需再次对齐。

综上3步,可知结构体的长度是16B,各数据成员在内存中的分布如图1-1所示。

在Linux中计算步骤如下:

  1. 所有数据成员自身长度和:1B + 12B = 13B --> sum_a = 13B
  1. 数据成员a放在相对偏移0处,之前不需要填充字节;数据成员b为了内存对齐,根据“结构体大小的计算方法和步骤”中第二条原则,其对齐模数是4,之前需填充3个字节,sum_a + 3 = 16B --> sum_b = 16 B
  2. 按照定义,结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者,前者为12后者为4,所以结构体对齐模数是4。sum_b是4的4倍,不需再次对齐。

综上3步,可知结构体的长度是16B,各数据成员在内存中的分布如图1-2所示。

俄罗斯贵宾会 1

我是图片.jpg

本文由俄罗斯贵宾会发布于编程,转载请注明出处:C#内存映射大文件并使用Marshal解析结构体信息

您可能还会对下面的文章感兴趣: