使用jCuda操作复数的最佳方法是什么？我应该使用cuComplex格式还是有其他解决方案（比如一个接着有实部和虚部的数组）？我真的很感激使用这种类型的计算的java代码示例。
由于我的目的是使用GPU解决具有复数的大型线性方程组，我不想只附加到jCuda。使用GPU进行此类计算的替代方法是什么？
答案 0 :(得分：2)
首先，关于你在GPU上使用Java进行计算的问题，我写了一些关于这个here的文字。
您的应用案例似乎非常具体。您应该更详细地描述您的实际意图，因为这将决定所有设计决策。到现在为止，我只能给出一些基本的提示。决定哪种解决方案最适合您。
在Java世界和GPU世界之间架起桥梁的主要困难之一是根本不同的内存处理。
CUDA中的cuComplex结构定义为
typedef float2 cuFloatComplex
typedef cuFloatComplex cuComplex;
其中float2基本上类似于
struct float2 {
float x;
float y;
};
（有一些额外的对齐说明符等）。
现在，当您在C / C ++程序中分配cuComplex值数组时，您只需编写类似
cuComplex *c = new cuComplex[100];
在这种情况下，保证所有这些cuComplex值的内存将是单个连续内存块。此内存块只包含复数的所有x和y值，一个接一个：
_____________________________
c -> | x0 | y0 | x1 | y1 | x2 | y2 |...
|____|____|____|____|____|____|
这个连续的内存块可以很容易地复制到设备：一个接收指针，并调用类似
的调用cudaMemcpy(device, c, sizeof(cuComplex)*n, cudaMemcpyHostToDevice);
考虑这样一种情况，即创建一个结构上与cuComplex结构相同的Java类，并分配这些类的数组：
class cuComplex {
public float x;
public float y;
}
cuComplex c[] = new cuComplex[100];
然后你不有一个float值的连续内存块。相反，您有一组引用到cuComplex个对象，并且各自的x和y值分散在各处：
____________________
c -> | c0 | c1 | c2 |...
|______|______|______|
| | |
v v v
[x,y] [x,y] [x,y]
这里的关键点是：
您无法将cuComplex个对象的{Java]数组复制到设备中！。
这有几个含义。在评论中，您已经引用了以cublasSetVector数组作为参数的cuComplex方法，并且我试图强调这不是最有效的解决方案，但仅为方便起见。实际上，此方法通过内部创建新的ByteBuffer来实现，以便拥有连续的内存块，使用ByteBuffer数组中的值填充此cuComplex[]，然后复制此ByteBuffer 1}}到设备。
当然，这会增加您在性能关键型应用程序中最可能要避免的开销。
有几种方法可以解决这个问题。幸运的是，对于复杂的数字，解决方案相对容易：
不要使用cuComplex结构来表示复数数组
相反，您应该将复数的数组表示为单个连续的内存块，其中复数的实部和虚部是交错的，每个都是单个float或double值， 分别。这将允许不同后端之间的最大互操作性（省略某些细节，如对齐要求）。
不幸的是，这可能会带来一些不便并引发一些问题，而且没有一个通用的解决方案。
如果有人试图概括这一点，不仅要参考复数，而且要参考＆＃34;结构＆＃34;总的来说，有一个＆＃34;模式＆＃34;可以应用：可以为结构创建接口，并创建这些结构的集合，这是实现此接口的类的实例列表，它们都由连续的内存块支持。这可能适用于某些情况。但是对于复数，每个复数的Java对象的内存开销可能非常大。
仅处理原始float[]或double[]数组的另一个极端可能也不是最佳解决方案。例如：如果您有一个表示复数的float值数组，那么您如何将这些复数中的一个乘以另一个呢？
一个＆＃34;中间＆＃34;解决方案可以创建一个接口，允许访问复数的实部和虚部。在实现中，如上所述，这些复数存储在单个阵列中。
我在这里草拟了这样的实现。
这只是作为一个例子，用于展示基本思想，并展示它如何与JCublas一起工作。对于你来说，根据你的实际目标，一个不同的策略可能更合适：应该有哪些其他后端（除了JCuda）？如何方便＆＃34;是应该处理Java端的复杂数字？用于处理Java端复杂数字的结构（类/接口）应该是什么样的？
简而言之：在继续实施之前，您应该对非常清楚了解应用程序/库应该做些什么。
import static jcuda.jcublas.JCublas2.*;
import static jcuda.jcublas.cublasOperation.CUBLAS_OP_N;
import static jcuda.runtime.JCuda.*;
import java.util.Random;
import jcuda.*;
import jcuda.jcublas.cublasHandle;
import jcuda.runtime.cudaMemcpyKind;
// An interface describing an array of complex numbers, residing
// on the host, with methods for accessing the real and imaginary
// parts of the complex numbers, as well as methods for copying
// the underlying data from and to the device
interface cuComplexHostArray
{
int size();
float getReal(int i);
float getImag(int i);
void setReal(int i, float real);
void setImag(int i, float imag);
void set(int i, cuComplex c);
void set(int i, float real, float imag);
cuComplex get(int i, cuComplex c);
void copyToDevice(Pointer devicePointer);
void copyFromDevice(Pointer devicePointer);
}
// A default implementation of a cuComplexHostArray, backed
// by a single float[] array
class DefaultCuComplexHostArray implements cuComplexHostArray
{
private final int size;
private final float data[];
DefaultCuComplexHostArray(int size)
{
this.size = size;
this.data = new float[size * 2];
}
@Override
public int size()
{
return size;
}
@Override
public float getReal(int i)
{
return data[i+i];
}
@Override
public float getImag(int i)
{
return data[i+i+1];
}
@Override
public void setReal(int i, float real)
{
data[i+i] = real;
}
@Override
public void setImag(int i, float imag)
{
data[i+i+1] = imag;
}
@Override
public void set(int i, cuComplex c)
{
data[i+i+0] = c.x;
data[i+i+1] = c.y;
}
@Override
public void set(int i, float real, float imag)
{
data[i+i+0] = real;
data[i+i+1] = imag;
}
@Override
public cuComplex get(int i, cuComplex c)
{
float real = getReal(i);
float imag = getImag(i);
if (c != null)
{
c.x = real;
c.y = imag;
return c;
}
return cuComplex.cuCmplx(real, imag);
}
@Override
public void copyToDevice(Pointer devicePointer)
{
cudaMemcpy(devicePointer, Pointer.to(data),
size * Sizeof.FLOAT * 2,
cudaMemcpyKind.cudaMemcpyHostToDevice);
}
@Override
public void copyFromDevice(Pointer devicePointer)
{
cudaMemcpy(Pointer.to(data), devicePointer,
size * Sizeof.FLOAT * 2,
cudaMemcpyKind.cudaMemcpyDeviceToHost);
}
}
// An example that performs a "gemm" with complex numbers, once
// in Java and once in JCublas2, and verifies the result
public class JCublas2ComplexSample
{
public static void main(String args[])
{
testCgemm(500);
}
public static void testCgemm(int n)
{
cuComplex alpha = cuComplex.cuCmplx(0.3f, 0.2f);
cuComplex beta = cuComplex.cuCmplx(0.1f, 0.7f);
int nn = n * n;
System.out.println("Creating input data...");
Random random = new Random(0);
cuComplex[] rhA = createRandomComplexRawArray(nn, random);
cuComplex[] rhB = createRandomComplexRawArray(nn, random);
cuComplex[] rhC = createRandomComplexRawArray(nn, random);
random = new Random(0);
cuComplexHostArray hA = createRandomComplexHostArray(nn, random);
cuComplexHostArray hB = createRandomComplexHostArray(nn, random);
cuComplexHostArray hC = createRandomComplexHostArray(nn, random);
System.out.println("Performing Cgemm with Java...");
cgemmJava(n, alpha, rhA, rhB, beta, rhC);
System.out.println("Performing Cgemm with JCublas...");
cgemmJCublas(n, alpha, hA, hB, beta, hC);
boolean passed = isCorrectResult(hC, rhC);
System.out.println("testCgemm "+(passed?"PASSED":"FAILED"));
}
private static void cgemmJCublas(
int n,
cuComplex alpha,
cuComplexHostArray A,
cuComplexHostArray B,
cuComplex beta,
cuComplexHostArray C)
{
int nn = n * n;
// Create a CUBLAS handle
cublasHandle handle = new cublasHandle();
cublasCreate(handle);
// Allocate memory on the device
Pointer dA = new Pointer();
Pointer dB = new Pointer();
Pointer dC = new Pointer();
cudaMalloc(dA, nn * Sizeof.FLOAT * 2);
cudaMalloc(dB, nn * Sizeof.FLOAT * 2);
cudaMalloc(dC, nn * Sizeof.FLOAT * 2);
// Copy the memory from the host to the device
A.copyToDevice(dA);
B.copyToDevice(dB);
C.copyToDevice(dC);
// Execute cgemm
Pointer pAlpha = Pointer.to(new float[]{alpha.x, alpha.y});
Pointer pBeta = Pointer.to(new float[]{beta.x, beta.y});
cublasCgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, n, n, n,
pAlpha, dA, n, dB, n, pBeta, dC, n);
// Copy the result from the device to the host
C.copyFromDevice(dC);
// Clean up
cudaFree(dA);
cudaFree(dB);
cudaFree(dC);
cublasDestroy(handle);
}
private static void cgemmJava(
int n,
cuComplex alpha,
cuComplex A[],
cuComplex B[],
cuComplex beta,
cuComplex C[])
{
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
cuComplex prod = cuComplex.cuCmplx(0, 0);
for (int k = 0; k < n; ++k)
{
cuComplex ab =
cuComplex.cuCmul(A[k * n + i], B[j * n + k]);
prod = cuComplex.cuCadd(prod, ab);
}
cuComplex ap = cuComplex.cuCmul(alpha, prod);
cuComplex bc = cuComplex.cuCmul(beta, C[j * n + i]);
C[j * n + i] = cuComplex.cuCadd(ap, bc);
}
}
}
private static cuComplex[] createRandomComplexRawArray(
int n, Random random)
{
cuComplex c[] = new cuComplex[n];
for (int i = 0; i < n; i++)
{
float real = random.nextFloat();
float imag = random.nextFloat();
c[i] = cuComplex.cuCmplx(real, imag);
}
return c;
}
private static cuComplexHostArray createRandomComplexHostArray(
int n, Random random)
{
cuComplexHostArray c = new DefaultCuComplexHostArray(n);
for (int i = 0; i < n; i++)
{
float real = random.nextFloat();
float imag = random.nextFloat();
c.setReal(i, real);
c.setImag(i, imag);
}
return c;
}
private static boolean isCorrectResult(
cuComplexHostArray result, cuComplex reference[])
{
float errorNormX = 0;
float errorNormY = 0;
float refNormX = 0;
float refNormY = 0;
for (int i = 0; i < result.size(); i++)
{
float diffX = reference[i].x - result.getReal(i);
float diffY = reference[i].y - result.getImag(i);
errorNormX += diffX * diffX;
errorNormY += diffY * diffY;
refNormX += reference[i].x * result.getReal(i);
refNormY += reference[i].y * result.getImag(i);
}
errorNormX = (float) Math.sqrt(errorNormX);
errorNormY = (float) Math.sqrt(errorNormY);
refNormX = (float) Math.sqrt(refNormX);
refNormY = (float) Math.sqrt(refNormY);
if (Math.abs(refNormX) < 1e-6)
{
return false;
}
if (Math.abs(refNormY) < 1e-6)
{
return false;
}
return
(errorNormX / refNormX < 1e-6f) &&
(errorNormY / refNormY < 1e-6f);
}
}
（顺便说一句：我可能会接受这个答案的部分内容并将其扩展为样本和/或＆＃34;如何...＆＃34; JCuda的页面。提供这样的信息的任务已经在我的＆＃34; todo＆＃34;列表上已经有一段时间了。）