关于c＃4.0：如何在C＃中进行快速复杂运算

How to do Speedy Complex Arithmetic in C#

我现在正在研究一个C分形生成器项目，它需要很多复杂数字的算术运算，我正在努力思考加速数学运算的方法。下面是一组简化的代码，使用三种数据存储方法之一测试Mandelbrot计算的速度，如TestNumericsComplex、TestCustomComplex和TestPairedDoubles所示。请理解Mandelbrot只是一个例子，我希望未来的开发人员能够创建插件分形公式。

基本上，我看到使用System.Numerics.Complex是一个不错的想法，而使用一对double或自定义复杂结构是可以接受的想法。我可以使用GPU执行算法，但这不会限制或破坏可移植性吗？我试过改变内环的顺序(i，x，y)，但没有用。我还能做些什么来加速内部循环？我是否遇到页面错误问题？与浮点值相比，使用定点数字系统能提高我的速度吗？

我已经知道C 4.0中的Parallel.For；为了清晰起见，代码示例中省略了它。我也知道，对于高性能来说，C语言通常不是一种好语言；我使用C语言来利用插件的反射和窗口化的WPF。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

using System;
using System.Diagnostics;

namespace SpeedTest {
class Program {
private const int ITER = 512;
private const int XL = 1280, YL = 1024;

static void Main(string[] args) {
var timer = new Stopwatch();
timer.Start();
//TODO use one of these two lines
//TestCustomComplex();
//TestNumericsComplex();
//TestPairedDoubles();
timer.Stop();
Console.WriteLine(timer.ElapsedMilliseconds);
Console.ReadKey();
}

/// <summary>
/// ~14000 ms on my machine
/// </summary>
static void TestNumericsComplex() {
var vals = new System.Numerics.Complex[XL,YL];
var loc = new System.Numerics.Complex[XL,YL];

for (int x = 0; x < XL; x++) for (int y = 0; y < YL; y++) {
loc[x, y] = new System.Numerics.Complex((x - XL/2)/256.0, (y - YL/2)/256.0);
vals[x, y] = new System.Numerics.Complex(0, 0);
}

for (int i = 0; i < ITER; i++) {
for (int x = 0; x < XL; x++)
for (int y = 0; y < YL; y++) {
if(vals[x,y].Real>4) continue;
vals[x, y] = vals[x, y] * vals[x, y] + loc[x, y];
}
}
}

/// <summary>
/// ~17000 on my machine
/// </summary>
static void TestPairedDoubles() {
var vals = new double[XL, YL, 2];
var loc = new double[XL, YL, 2];

for (int x = 0; x < XL; x++) for (int y = 0; y < YL; y++) {
loc[x, y, 0] = (x - XL / 2) / 256.0;
loc[x, y, 1] = (y - YL / 2) / 256.0;
vals[x, y, 0] = 0;
vals[x, y, 1] = 0;
}

for (int i = 0; i < ITER; i++) {
for (int x = 0; x < XL; x++)
for (int y = 0; y < YL; y++) {
if (vals[x, y, 0] > 4) continue;
var a = vals[x, y, 0] * vals[x, y, 0] - vals[x, y, 1] * vals[x, y, 1];
var b = vals[x, y, 0] * vals[x, y, 1] * 2;
vals[x, y, 0] = a + loc[x, y, 0];
vals[x, y, 1] = b + loc[x, y, 1];
}
}
}

/// <summary>
/// ~16900 ms on my machine
/// </summary>
static void TestCustomComplex() {
var vals = new Complex[XL, YL];
var loc = new Complex[XL, YL];

for (int x = 0; x < XL; x++) for (int y = 0; y < YL; y++) {
loc[x, y] = new Complex((x - XL / 2) / 256.0, (y - YL / 2) / 256.0);
vals[x, y] = new Complex(0, 0);
}

for (int i = 0; i < ITER; i++) {
for (int x = 0; x < XL; x++)
for (int y = 0; y < YL; y++) {
if (vals[x, y].Real > 4) continue;
vals[x, y] = vals[x, y] * vals[x, y] + loc[x, y];
}
}
}

}

public struct Complex {
public double Real, Imaginary;
public Complex(double a, double b) {
Real = a;
Imaginary = b;
}
public static Complex operator + (Complex a, Complex b) {
return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
}
public static Complex operator * (Complex a, Complex b) {
return new Complex(a.Real*b.Real - a.Imaginary*b.Imaginary, a.Real*b.Imaginary + a.Imaginary*b.Real);
}
}

}

编辑

GPU似乎是唯一可行的解决方案，我忽视了与C/C++的互操作性，因为我觉得加速不会太大以至于强迫我强制将来的插件进行互操作。

在研究了现有的GPU选项之后(我已经研究了一段时间了)，我终于找到了我认为是一个很好的折衷方案。我选择了OpenCL，希望在我的程序发布时，大多数设备都能支持这个标准。OpenCLTemplate使用CLO提供一个易于理解的.NET(用于应用程序逻辑)和"OpenCLC99"(用于并行代码)之间的接口。插件可以包括用于硬件加速的OpenCL内核，以及用于System.Numerics.Complex的标准实现，以便于集成。

我希望随着处理器供应商采用OpenCLC99标准，有关编写OpenCLC99代码的可用教程数量会快速增长。这使我不需要在插件开发人员身上强制执行GPU编码，同时为他们提供了一种良好的语言，如果他们选择利用这个选项的话。这也意味着Ironpython脚本在编译时之前都不知道，尽管它们对GPU加速的访问是相同的，因为代码将直接通过opencl进行转换。

对于将来有兴趣将GPU加速与.NET项目集成的任何人，我强烈推荐OpenCLTemplate。opencl c99的学习开销是允许的。然而，它只比学习一个替代的API稍微困难一点，并且可能会得到示例和一般社区的更好支持。