IT评测·应用市场-qidao123.com

标题: [C#] Bgr24彩色位图转为灰度的Bgr24位图的跨平台SIMD硬件加快向量算法 [打印本页]
作者: 悠扬随风    时间: 2024-11-21 02:24
标题: [C#] Bgr24彩色位图转为灰度的Bgr24位图的跨平台SIMD硬件加快向量算法
在上一篇文章里，我们讲解了“Bgr24彩色位图转为Gray8灰度位图”算法。本文将探讨“Bgr24彩色位图转为灰度的Bgr24位图”。区别在于目标位图也是Bgr24格式的，只是将像素数据由彩色转为了灰度。这些算法也是跨平台的，同一份源代码，能在 X86及Arm架构上运行，且均享有SIMD硬件加快。
一、标量算法

1.1 算法实现

算法原理与上一篇文章是一样，唯一区别是目标位图的地址盘算与写入处理。由于现在对于每一个像素，需要写入3个字节。
源代码如下。
  1. public static unsafe void ScalarDoBatch(byte* pSrc, int strideSrc, int width, int height, byte* pDst, int strideDst) {
  2.     const int cbPixel = 3; // Bgr24
  3.     const int shiftPoint = 16;
  4.     const int mulPoint = 1 << shiftPoint; // 0x10000
  5.     const int mulRed = (int)(0.299 * mulPoint + 0.5); // 19595
  6.     const int mulGreen = (int)(0.587 * mulPoint + 0.5); // 38470
  7.     const int mulBlue = mulPoint - mulRed - mulGreen; // 7471
  8.     byte* pRow = pSrc;
  9.     byte* qRow = pDst;
  10.     for (int i = 0; i < height; i++) {
  11.         byte* p = pRow;
  12.         byte* q = qRow;
  13.         for (int j = 0; j < width; j++) {
  14.             byte gray = (byte)((p[2] * mulRed + p[1] * mulGreen + p[0] * mulBlue) >> shiftPoint);
  15.             q[0] = q[1] = q[2] = gray;
  16.             p += cbPixel; // Bgr24
  17.             q += cbPixel; // Bgr24 store grayscale.
  18.         }
  19.         pRow += strideSrc;
  20.         qRow += strideDst;
  21.     }
  22. }
复制代码
1.2 基准测试代码

使用 BenchmarkDotNet 进行基准测试。
可以使用上一篇文章的公共函数，写好标量算法的基准测试代码。源代码如下。
  1. [Benchmark(Baseline = true)]
  2. public void Scalar() {
  3.     ScalarDo(_sourceBitmapData, _destinationBitmapData, 0);
  4. }
  6. [Benchmark]
  7. public void ScalarParallel() {
  8.     ScalarDo(_sourceBitmapData, _destinationBitmapData, 1);
  9. }
  11. public static unsafe void ScalarDo(BitmapData src, BitmapData dst, int parallelFactor = 0) {
  12.     int width = src.Width;
  13.     int height = src.Height;
  14.     int strideSrc = src.Stride;
  15.     int strideDst = dst.Stride;
  16.     byte* pSrc = (byte*)src.Scan0.ToPointer();
  17.     byte* pDst = (byte*)dst.Scan0.ToPointer();
  18.     int processorCount = Environment.ProcessorCount;
  19.     int batchSize = 0;
  20.     if (parallelFactor > 1) {
  21.         batchSize = height / (processorCount * parallelFactor);
  22.     } else if (parallelFactor == 1) {
  23.         if (height >= processorCount) batchSize = 1;
  24.     }
  25.     bool allowParallel = (batchSize > 0) && (processorCount > 1);
  26.     if (allowParallel) {
  27.         int batchCount = (height + batchSize - 1) / batchSize; // ceil((double)length / batchSize)
  28.         Parallel.For(0, batchCount, i => {
  29.             int start = batchSize * i;
  30.             int len = batchSize;
  31.             if (start + len > height) len = height - start;
  32.             byte* pSrc2 = pSrc + start * strideSrc;
  33.             byte* pDst2 = pDst + start * strideDst;
  34.             ScalarDoBatch(pSrc2, strideSrc, width, len, pDst2, strideDst);
  35.         });
  36.     } else {
  37.         ScalarDoBatch(pSrc, strideSrc, width, height, pDst, strideDst);
  38.     }
  39. }
复制代码
二、向量算法

2.1 算法思路

对于24位转8位灰度，可以使用这种办法: 每次从源位图读取3个向量，进行3-元素组的解交织运算，得到 R,G,B 平面数据。随后使用向量化的乘法与加法，来盘算灰度值。最后将存储了灰度值的那一个向量，进行3-元素组的交织运算，便能存储到目标位图。
它与“Bgr24彩色位图转为Gray8灰度位图”向量算法的区别，在于最后需做“3-元素组的交织运算”。
例如 Sse指令集使用的是128位向量，此时1个向量为16字节。每次从源位图读取3个向量，就是读取了48字节，即16个RGB像素。最后将灰度向量做“3-元素组的交织运算”，结果是3个向量。将那3个向量存储到目标位图，就是写入了48字节，即16个RGB像素。
对于3-元素组的交织，可以使用 shuffle 种别的指令来实现。例如对于X86架构的 128位向量，可以使用 SSSE3 的 _mm_shuffle_epi8 指令，它对应 NET 中的 Ssse3.Shuffle 方法。源代码如下。
  1. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_X_Part0 = Vector128.Create((sbyte)0, -1, -1, 1, -1, -1, 2, -1, -1, 3, -1, -1, 4, -1, -1, 5).AsByte();
  2. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_X_Part1 = Vector128.Create((sbyte)-1, 0, -1, -1, 1, -1, -1, 2, -1, -1, 3, -1, -1, 4, -1, -1).AsByte();
  3. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_X_Part2 = Vector128.Create((sbyte)-1, -1, 0, -1, -1, 1, -1, -1, 2, -1, -1, 3, -1, -1, 4, -1).AsByte();
  4. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_Y_Part0 = Vector128.Create((sbyte)-1, -1, 6, -1, -1, 7, -1, -1, 8, -1, -1, 9, -1, -1, 10, -1).AsByte();
  5. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_Y_Part1 = Vector128.Create((sbyte)5, -1, -1, 6, -1, -1, 7, -1, -1, 8, -1, -1, 9, -1, -1, 10).AsByte();
  6. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_Y_Part2 = Vector128.Create((sbyte)-1, 5, -1, -1, 6, -1, -1, 7, -1, -1, 8, -1, -1, 9, -1, -1).AsByte();
  7. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_Z_Part0 = Vector128.Create((sbyte)-1, 11, -1, -1, 12, -1, -1, 13, -1, -1, 14, -1, -1, 15, -1, -1).AsByte();
  8. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_Z_Part1 = Vector128.Create((sbyte)-1, -1, 11, -1, -1, 12, -1, -1, 13, -1, -1, 14, -1, -1, 15, -1).AsByte();
  9. static readonly Vector128<byte> YGroup3Zip_Shuffle_Byte_Z_Part2 = Vector128.Create((sbyte)10, -1, -1, 11, -1, -1, 12, -1, -1, 13, -1, -1, 14, -1, -1, 15).AsByte();
  11. public static Vector128<byte> YGroup3Zip_Shuffle(Vector128<byte> x, Vector128<byte> y, Vector128<byte> z, out Vector128<byte> data1, out Vector128<byte> data2) {
  12.     var f0A = YGroup3Zip_Shuffle_Byte_X_Part0;
  13.     var f0B = YGroup3Zip_Shuffle_Byte_X_Part1;
  14.     var f0C = YGroup3Zip_Shuffle_Byte_X_Part2;
  15.     var f1A = YGroup3Zip_Shuffle_Byte_Y_Part0;
  16.     var f1B = YGroup3Zip_Shuffle_Byte_Y_Part1;
  17.     var f1C = YGroup3Zip_Shuffle_Byte_Y_Part2;
  18.     var f2A = YGroup3Zip_Shuffle_Byte_Z_Part0;
  19.     var f2B = YGroup3Zip_Shuffle_Byte_Z_Part1;
  20.     var f2C = YGroup3Zip_Shuffle_Byte_Z_Part2;
  21.     var rt0 = Sse2.Or(Sse2.Or(Ssse3.Shuffle(x, f0A), Ssse3.Shuffle(y, f0B)), Ssse3.Shuffle(z, f0C));
  22.     var rt1 = Sse2.Or(Sse2.Or(Ssse3.Shuffle(x, f1A), Ssse3.Shuffle(y, f1B)), Ssse3.Shuffle(z, f1C));
  23.     var rt2 = Sse2.Or(Sse2.Or(Ssse3.Shuffle(x, f2A), Ssse3.Shuffle(y, f2B)), Ssse3.Shuffle(z, f2C));
  24.     data1 = rt1;
  25.     data2 = rt2;
  26.     return rt0;
  27. }
复制代码
VectorTraits 库已经集成了上述算法，提供了“Vectors.YGroup3Zip”方法。该方法可以或许跨平台，它会使用各个平台的shuffle指令。
2.2 算法实现

有了 YGroup3Unzip、YGroup3Zip 方法后，便能方便的编写彩色转灰度的算法了。灰度系数有8位精度，于是需要将 8位数据变宽为16位后，再来盘算乘法与加法。最后再将 16位数据，变窄为8位。源代码如下。
  1. public static unsafe void UseVectorsDoBatch(byte* pSrc, int strideSrc, int width, int height, byte* pDst, int strideDst) {
  2.     const int cbPixel = 3; // Bgr24
  3.     const int shiftPoint = 8;
  4.     const int mulPoint = 1 << shiftPoint; // 0x100
  5.     const ushort mulRed = (ushort)(0.299 * mulPoint + 0.5); // 77
  6.     const ushort mulGreen = (ushort)(0.587 * mulPoint + 0.5); // 150
  7.     const ushort mulBlue = mulPoint - mulRed - mulGreen; // 29
  8.     Vector<ushort> vmulRed = new Vector<ushort>(mulRed);
  9.     Vector<ushort> vmulGreen = new Vector<ushort>(mulGreen);
  10.     Vector<ushort> vmulBlue = new Vector<ushort>(mulBlue);
  11.     int vectorWidth = Vector<byte>.Count;
  12.     int maxX = width - vectorWidth;
  13.     byte* pRow = pSrc;
  14.     byte* qRow = pDst;
  15.     for (int i = 0; i < height; i++) {
  16.         Vector<byte>* pLast = (Vector<byte>*)(pRow + maxX * cbPixel); // Bgr24
  17.         Vector<byte>* qLast = (Vector<byte>*)(qRow + maxX * cbPixel); // Bgr24 store grayscale.
  18.         Vector<byte>* p = (Vector<byte>*)pRow;
  19.         Vector<byte>* q = (Vector<byte>*)qRow;
  20.         for (; ; ) {
  21.             Vector<byte> r, g, b, gray, gray0, gray1, gray2;
  22.             Vector<ushort> wr0, wr1, wg0, wg1, wb0, wb1;
  23.             // Load.
  24.             b = Vectors.YGroup3Unzip(p[0], p[1], p[2], out g, out r);
  25.             // widen(r) * mulRed + widen(g) * mulGreen + widen(b) * mulBlue
  26.             Vector.Widen(r, out wr0, out wr1);
  27.             Vector.Widen(g, out wg0, out wg1);
  28.             Vector.Widen(b, out wb0, out wb1);
  29.             wr0 = Vectors.Multiply(wr0, vmulRed);
  30.             wr1 = Vectors.Multiply(wr1, vmulRed);
  31.             wg0 = Vectors.Multiply(wg0, vmulGreen);
  32.             wg1 = Vectors.Multiply(wg1, vmulGreen);
  33.             wb0 = Vectors.Multiply(wb0, vmulBlue);
  34.             wb1 = Vectors.Multiply(wb1, vmulBlue);
  35.             wr0 = Vector.Add(wr0, wg0);
  36.             wr1 = Vector.Add(wr1, wg1);
  37.             wr0 = Vector.Add(wr0, wb0);
  38.             wr1 = Vector.Add(wr1, wb1);
  39.             // Shift right and narrow.
  40.             wr0 = Vectors.ShiftRightLogical_Const(wr0, shiftPoint);
  41.             wr1 = Vectors.ShiftRightLogical_Const(wr1, shiftPoint);
  42.             gray = Vector.Narrow(wr0, wr1);
  43.             // Store.
  44.             gray0 = Vectors.YGroup3Zip(gray, gray, gray, out gray1, out gray2);
  45.             q[0] = gray0;
  46.             q[1] = gray1;
  47.             q[2] = gray2;
  48.             // Next.
  49.             if (p >= pLast) break;
  50.             p += cbPixel;
  51.             q += cbPixel;
  52.             if (p > pLast) p = pLast; // The last block is also use vector.
  53.             if (q > qLast) q = qLast;
  54.         }
  55.         pRow += strideSrc;
  56.         qRow += strideDst;
  57.     }
  58. }
复制代码
2.3 基准测试代码

随后为该算法编写基准测试代码。
  1. [Benchmark]
  2. public void UseVectors() {
  3.     UseVectorsDo(_sourceBitmapData, _destinationBitmapData, 0);
  4. }
  6. [Benchmark]
  7. public void UseVectorsParallel() {
  8.     UseVectorsDo(_sourceBitmapData, _destinationBitmapData, 1);
  9. }
  11. public static unsafe void UseVectorsDo(BitmapData src, BitmapData dst, int parallelFactor = 0) {
  12.     int vectorWidth = Vector<byte>.Count;
  13.     int width = src.Width;
  14.     int height = src.Height;
  15.     if (width <= vectorWidth) {
  16.         ScalarDo(src, dst, parallelFactor);
  17.         return;
  18.     }
  19.     int strideSrc = src.Stride;
  20.     int strideDst = dst.Stride;
  21.     byte* pSrc = (byte*)src.Scan0.ToPointer();
  22.     byte* pDst = (byte*)dst.Scan0.ToPointer();
  23.     int processorCount = Environment.ProcessorCount;
  24.     int batchSize = 0;
  25.     if (parallelFactor > 1) {
  26.         batchSize = height / (processorCount * parallelFactor);
  27.     } else if (parallelFactor == 1) {
  28.         if (height >= processorCount) batchSize = 1;
  29.     }
  30.     bool allowParallel = (batchSize > 0) && (processorCount > 1);
  31.     if (allowParallel) {
  32.         int batchCount = (height + batchSize - 1) / batchSize; // ceil((double)length / batchSize)
  33.         Parallel.For(0, batchCount, i => {
  34.             int start = batchSize * i;
  35.             int len = batchSize;
  36.             if (start + len > height) len = height - start;
  37.             byte* pSrc2 = pSrc + start * strideSrc;
  38.             byte* pDst2 = pDst + start * strideDst;
  39.             UseVectorsDoBatch(pSrc2, strideSrc, width, len, pDst2, strideDst);
  40.         });
  41.     } else {
  42.         UseVectorsDoBatch(pSrc, strideSrc, width, height, pDst, strideDst);
  43.     }
  44. }
复制代码
完整源码在 Bgr24ToGrayBgr24Benchmark.cs
三、基准测试结果

3.1 X86 架构

X86架构下的基准测试结果如下。
  1. BenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4460/23H2/2023Update/SunValley3)
  2. AMD Ryzen 7 7840H w/ Radeon 780M Graphics, 1 CPU, 16 logical and 8 physical cores
  3. .NET SDK 8.0.403
  4.   [Host]     : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
  5.   DefaultJob : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
  8. | Method               | Width | Mean         | Error      | StdDev     | Ratio |
  9. |--------------------- |------ |-------------:|-----------:|-----------:|------:|
  10. | Scalar               | 1024  |  1,128.81 us |   4.436 us |   3.932 us |  1.00 |
  11. | ScalarParallel       | 1024  |    157.96 us |   1.007 us |   0.942 us |  0.14 |
  12. | UseVectors           | 1024  |    123.79 us |   1.144 us |   1.014 us |  0.11 |
  13. | UseVectorsParallel   | 1024  |     26.05 us |   0.503 us |   0.471 us |  0.02 |
  14. |                      |       |              |            |            |       |
  15. | Scalar               | 2048  |  4,279.99 us |  37.658 us |  35.226 us |  1.00 |
  16. | ScalarParallel       | 2048  |    622.01 us |   3.989 us |   3.537 us |  0.15 |
  17. | UseVectors           | 2048  |    631.53 us |   6.741 us |   6.305 us |  0.15 |
  18. | UseVectorsParallel   | 2048  |    330.47 us |   5.479 us |   4.857 us |  0.08 |
  19. |                      |       |              |            |            |       |
  20. | Scalar               | 4096  | 17,252.90 us | 106.215 us |  99.353 us |  1.00 |
  21. | ScalarParallel       | 4096  |  3,743.78 us |  25.989 us |  24.310 us |  0.22 |
  22. | UseVectors           | 4096  |  3,273.92 us |  32.645 us |  30.537 us |  0.19 |
  23. | UseVectorsParallel   | 4096  |  3,746.83 us |  11.083 us |   9.255 us |  0.22 |
复制代码
3.2 Arm 架构

同样的源代码可以在 Arm 架构上运行。基准测试结果如下。
  1. BenchmarkDotNet v0.14.0, macOS Sequoia 15.0.1 (24A348) [Darwin 24.0.0]
  2. Apple M2, 1 CPU, 8 logical and 8 physical cores
  3. .NET SDK 8.0.204
  4.   [Host]     : .NET 8.0.4 (8.0.424.16909), Arm64 RyuJIT AdvSIMD
  5.   DefaultJob : .NET 8.0.4 (8.0.424.16909), Arm64 RyuJIT AdvSIMD
  8. | Method               | Width | Mean         | Error      | StdDev     | Median       | Ratio | RatioSD |
  9. |--------------------- |------ |-------------:|-----------:|-----------:|-------------:|------:|--------:|
  10. | Scalar               | 1024  |    719.32 us |   0.215 us |   0.201 us |    719.34 us |  1.00 |    0.00 |
  11. | ScalarParallel       | 1024  |    157.38 us |   1.423 us |   1.111 us |    157.25 us |  0.22 |    0.00 |
  12. | UseVectors           | 1024  |    169.25 us |   0.538 us |   0.503 us |    169.40 us |  0.24 |    0.00 |
  13. | UseVectorsParallel   | 1024  |     57.81 us |   0.998 us |   2.149 us |     58.11 us |  0.08 |    0.00 |
  14. |                      |       |              |            |            |              |       |         |
  15. | Scalar               | 2048  |  2,963.48 us |   6.674 us |   5.211 us |  2,961.39 us |  1.00 |    0.00 |
  16. | ScalarParallel       | 2048  |    627.47 us |  11.680 us |  25.142 us |    616.63 us |  0.21 |    0.01 |
  17. | UseVectors           | 2048  |    716.27 us |   2.097 us |   1.961 us |    717.02 us |  0.24 |    0.00 |
  18. | UseVectorsParallel   | 2048  |    368.49 us |   7.320 us |  21.469 us |    378.95 us |  0.12 |    0.01 |
  19. |                      |       |              |            |            |              |       |         |
  20. | Scalar               | 4096  | 12,449.32 us | 177.868 us | 157.676 us | 12,508.13 us |  1.00 |    0.02 |
  21. | ScalarParallel       | 4096  |  2,510.22 us |  34.541 us |  30.620 us |  2,501.37 us |  0.20 |    0.00 |
  22. | UseVectors           | 4096  |  2,968.72 us |  20.503 us |  18.175 us |  2,965.71 us |  0.24 |    0.00 |
  23. | UseVectorsParallel   | 4096  |  1,728.46 us |   4.362 us |   4.080 us |  1,729.00 us |  0.14 |    0.00 |
复制代码
四、对算法进行检查

以往想对算法进行检查法时，直接对各个字节做相等比力就行了。
但“Bgr24彩色位图转为灰度的Bgr24位图”不适合那样的验证。由于整数运算有精度损失，造成部分像素值会有一些小的偏差。若直接对各个字节做相等比力，那么结果总是 false.
于是可以编写一个统计偏差的函数。可通过偏差的大小，来判断算法是否正确，以及比力算法的优劣。
  1. private unsafe long SumDifference(BitmapData expected, BitmapData dst, out long countByteDifference, out int maxDifference) {
  2.     const int cbPixel = 3; // Bgr24 store grayscale.
  3.     long totalDifference = 0;
  4.     countByteDifference = 0;
  5.     maxDifference = 0;
  6.     int maxPosX = -1, maxPosY = -1;
  7.     int width = expected.Width;
  8.     int height = expected.Height;
  9.     int strideSrc = expected.Stride;
  10.     int strideDst = dst.Stride;
  11.     byte* pRow = (byte*)expected.Scan0.ToPointer();
  12.     byte* qRow = (byte*)dst.Scan0.ToPointer();
  13.     for (int i = 0; i < height; i++) {
  14.         byte* p = pRow;
  15.         byte* q = qRow;
  16.         for (int j = 0; j < width; j++) {
  17.             for (int k = 0; k < cbPixel; ++k) {
  18.                 int difference = Math.Abs((int)(*q) - *p);
  19.                 if (0 != difference) {
  20.                     totalDifference += difference;
  21.                     ++countByteDifference;
  22.                     if (maxDifference < difference) {
  23.                         maxDifference = difference;
  24.                         maxPosX = j;
  25.                         maxPosY = i;
  26.                     }
  27.                 }
  28.                 ++p;
  29.                 ++q;
  30.             }
  31.         }
  32.         pRow += strideSrc;
  33.         qRow += strideDst;
  34.     }
  35.     if (maxDifference > 0) {
  36.         //Console.WriteLine(string.Format("SumDifference maxDifference={0}, at ({1}, {2})", maxDifference, maxPosX, maxPosY));
  37.     }
  38.     return totalDifference;
  39. }
复制代码
在 Setup 方法里增加检查代码。
  1. // Check.
  2. bool allowCheck = true;
  3. if (allowCheck) {
  4.     try {
  5.         TextWriter writer = Console.Out;
  6.         long totalDifference, countByteDifference;
  7.         int maxDifference;
  8.         double averageDifference;
  9.         long totalByte = Width * Height * 3;
  10.         double percentDifference;
  11.         // Baseline
  12.         ScalarDo(_sourceBitmapData, _expectedBitmapData);
  13.         // ScalarParallel
  14.         ScalarParallel();
  15.         totalDifference = SumDifference(_expectedBitmapData, _destinationBitmapData, out countByteDifference, out maxDifference);
  16.         averageDifference = (countByteDifference > 0) ? (double)totalDifference / countByteDifference : 0;
  17.         percentDifference = 100.0 * countByteDifference / totalByte;
  18.         writer.WriteLine(string.Format("Difference of ScalarParallel: {0}/{1}={2}, max={3}, percentDifference={4:0.000000}%", totalDifference, countByteDifference, averageDifference, maxDifference, percentDifference));
  19.         // UseVectors
  20.         UseVectors();
  21.         totalDifference = SumDifference(_expectedBitmapData, _destinationBitmapData, out countByteDifference, out maxDifference);
  22.         averageDifference = (countByteDifference > 0) ? (double)totalDifference / countByteDifference : 0;
  23.         percentDifference = 100.0 * countByteDifference / totalByte;
  24.         writer.WriteLine(string.Format("Difference of UseVectors: {0}/{1}={2}, max={3}, percentDifference={4:0.000000}%", totalDifference, countByteDifference, averageDifference, maxDifference, percentDifference));
  25.         // UseVectorsParallel
  26.         UseVectorsParallel();
  27.         totalDifference = SumDifference(_expectedBitmapData, _destinationBitmapData, out countByteDifference, out maxDifference);
  28.         averageDifference = (countByteDifference > 0) ? (double)totalDifference / countByteDifference : 0;
  29.         percentDifference = 100.0 * countByteDifference / totalByte;
  30.         writer.WriteLine(string.Format("Difference of UseVectorsParallel: {0}/{1}={2}, max={3}, percentDifference={4:0.000000}%", totalDifference, countByteDifference, averageDifference, maxDifference, percentDifference));
  31.     } catch (Exception ex) {
  32.         Debug.WriteLine(ex.ToString());
  33.     }
  34. }
复制代码
字段说明:
运行程序，可以看到相干的输出信息。
  1. Difference of ScalarParallel: 0/0=0, max=0, percentDifference=0.000000%
  2. Difference of UseVectors: 422400/422400=1, max=1, percentDifference=13.427734%
  3. Difference of UseVectorsParallel: 422400/422400=1, max=1, percentDifference=13.427734%
复制代码
“max”最大为“1”，表示字节的最大偏差只有1。整数算法本身是存在舍入偏差的，而现在只有1，表示偏差已经控制的很好了，算法的质量很高了。
附录

    出处：http://www.cnblogs.com/zyl910/    版权声明：自由转载-非商用-非衍生-保持署名 | Creative Commons BY-NC-ND 3.0.
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4