Результат CUDA возвращает мусор с использованием очень большого массива, но не сообщает об ошибке

Я создаю тестовую программу, которая создаст устройство и массив массива хоста. N а затем запустить ядро, которое создает N потоки, которые выделяют постоянное значение 0,95f для каждого местоположения в массиве устройств. После завершения массив устройств копируется в массив хостов, и все записи суммируются, и отображается итоговая сумма.

Кажется, что приведенная ниже программа отлично работает для массивов размером примерно до 60 миллионов операций с плавающей запятой и очень быстро возвращает правильные результаты, но при достижении 70 миллионов программа на некоторое время зависает и в итоге возвращает результат NAN для общего количества. Проверка массива хоста после 60-миллионного прогона показывает, что он правильно заполнен 0,95f, но проверка после 70-миллионного прогона показывает, что он заполнен NAN. Насколько мне известно, ни один из вызовов CUDA не возвращает ошибки.

Я использую 2GB GT640m (Compute 3.0), что дает мне максимальный размер блока 1024 и максимальный размер сетки 2147483647.

Я уверен, что есть лучшие способы достижения чего-то подобного, и я хотел бы услышать предложения. Но я также хотел бы понять, что здесь пошло не так, чтобы я мог извлечь из этого уроки.

#include "cuda_runtime.h"#include "device_launch_parameters.h"
#include <stdio.h>
#include <fstream>

void cudaErrorHandler(cudaError_t status)
{
// Cuda call returned an error, just print error for now
if(status != cudaSuccess)
{
printf("Error");
}
}

__global__ void addKernel(float* _Results, int _TotalCombinations)
{
// Get thread Id
unsigned int Id = (blockDim.x * blockDim.y * blockIdx.x) + (blockDim.x * threadIdx.y) + threadIdx.x;

//If the Id is within simulation range, log it
if(Id < _TotalCombinations)
{
_Results[Id] = 0.95f;
}
}

#define BLOCK_DIM_X 32
#define BLOCK_DIM_Y 32
#define BLOCK_SIZE BLOCK_DIM_X * BLOCK_DIM_Y // Statc block size of 32*32 (1024)
#define CUDA_CALL(x) cudaErrorHandler(x)

int main()
{
// The number of simulations to run
unsigned int totalCombinations = 45000000;

int gridsize = 1;

// Work out how many blocks of size 1024 are required to perform all of totalCombinations
for(unsigned int totalsize = gridsize * BLOCK_SIZE; totalsize < totalCombinations;
gridsize++, totalsize = gridsize * BLOCK_SIZE)
;

// Allocate host memory
float* host_results = new float[totalCombinations];
memset(host_results, 0, sizeof(float) * totalCombinations);
float *dev_results = 0;

cudaSetDevice(0);

// Allocate device memory
CUDA_CALL(cudaMalloc((void**)&dev_results, totalCombinations * sizeof(float)));

dim3 grid, block;

block = dim3(BLOCK_DIM_X, BLOCK_DIM_Y);

grid = dim3(gridsize);

// Launch kernel
addKernel<<<gridsize, block>>>(dev_results, totalCombinations);

// Wait for synchronize
CUDA_CALL(cudaDeviceSynchronize());

// Copy device data back to host
CUDA_CALL(cudaMemcpy(host_results, dev_results, totalCombinations * sizeof(float), cudaMemcpyDeviceToHost));

double total = 0.0;

// Total the results in the host array
for(unsigned int i = 0; i < totalCombinations; i++)
total+=host_results[i];

// Print results to screen
printf("Total %f\n", total);

delete[] host_results;

return 0;
}