CUDA parece haberse alcanzado el límite, pero ¿qué límite es ese?
Tengo un programa CUDA que parece estar llegando a algún tipo de límite de algún recurso, pero no puedo entender cuál es ese recurso. Aquí está la función del núcleo:
__global__ void DoCheck(float2* points, int* segmentToPolylineIndexMap,
int segmentCount, int* output)
{
int segmentIndex = threadIdx.x + blockIdx.x * blockDim.x;
int pointCount = segmentCount + 1;
if(segmentIndex >= segmentCount)
return;
int polylineIndex = segmentToPolylineIndexMap[segmentIndex];
int result = 0;
if(polylineIndex >= 0)
{
float2 p1 = points[segmentIndex];
float2 p2 = points[segmentIndex+1];
float2 A = p2;
float2 a;
a.x = p2.x - p1.x;
a.y = p2.y - p1.y;
for(int i = segmentIndex+2; i < segmentCount; i++)
{
int currentPolylineIndex = segmentToPolylineIndexMap[i];
// if not a different segment within out polyline and
// not a fake segment
bool isLegit = (currentPolylineIndex != polylineIndex &&
currentPolylineIndex >= 0);
float2 p3 = points[i];
float2 p4 = points[i+1];
float2 B = p4;
float2 b;
b.x = p4.x - p3.x;
b.y = p4.y - p3.y;
float2 c;
c.x = B.x - A.x;
c.y = B.y - A.y;
float2 b_perp;
b_perp.x = -b.y;
b_perp.y = b.x;
float numerator = dot(b_perp, c);
float denominator = dot(b_perp, a);
bool isParallel = (denominator == 0.0);
float quotient = numerator / denominator;
float2 intersectionPoint;
intersectionPoint.x = quotient * a.x + A.x;
intersectionPoint.y = quotient * a.y + A.y;
result = result | (isLegit && !isParallel &&
intersectionPoint.x > min(p1.x, p2.x) &&
intersectionPoint.x > min(p3.x, p4.x) &&
intersectionPoint.x < max(p1.x, p2.x) &&
intersectionPoint.x < max(p3.x, p4.x) &&
intersectionPoint.y > min(p1.y, p2.y) &&
intersectionPoint.y > min(p3.y, p4.y) &&
intersectionPoint.y < max(p1.y, p2.y) &&
intersectionPoint.y < max(p3.y, p4.y));
}
}
output[segmentIndex] = result;
}
Aquí está la llamada para ejecutar la función del núcleo:
DoCheck<<<702, 32>>>(
(float2*)devicePoints,
deviceSegmentsToPolylineIndexMap,
numSegments,
deviceOutput);
Los tamaños de los parámetros son los siguientes:
devicePoints = 22,464 float2s = 179,712 bytesdeviceSegmentsToPolylineIndexMap = 22,463 ints = 89,852 bytesnumSegments = 1 int = 4 bytesdeviceOutput = 22,463 ints = 89,852 bytesCuando ejecuto este kernel, se bloquea la tarjeta de video. Parece que estoy llegando a algún tipo de límite, porque si ejecuto el núcleo usandoDoCheck<<<300, 32>>>(...);
, funciona. Para ser claros, los parámetros son los mismos, solo la cantidad de bloques es diferente.
¿Alguna idea de por qué uno bloquea el controlador de video y el otro no? El que falla parece estar todavía dentro del límite de la tarjeta en el número de bloques.
Actualiza Más información sobre la configuración de mi sistema:
Tarjeta de video: nVidia 8800GTCUDA Versión: 1.1OS: Windows Server 2008 R2También lo probé en una computadora portátil con la siguiente configuración, pero obtuve los mismos resultados:
Tarjeta de video: nVidia Quadro FX 880MCUDA Versión: 1.2OS: Windows 7 de 64 bits