CUDA无法运行/复制内存 我编写了一个程序来并行执行多个副本，以加速对50000个不同输入的评估。代码通常在C++ CPU上运行大约0.0005秒，在我的测试中，它的内部循环运行大约3000个周期，所以我认为在GPU线程上运行可能并不太复杂。此外，我使用Visual Studio 2013和GTX 860m编写程序，没有编译其他用CUDA C编写的程序

这是我的代码：（您可以从这里获取数据文件）

更新

---

如果我将

numElements

的值设置为1，则代码运行良好，但这不是并行计算的要点。我还检查了GPU-Z中的GPU统计数据，内存利用率小于1MB，最大GPU负载小于1%。（发布版本）

我已将版本从调试更改为发布版本，程序运行良好！另外，通过增加窗口注册表中的GPU超时设置（WDDM），这个问题几乎被消除

请编辑您的问题并重新格式化代码。从字面上看，你发布的内容有一半是无意义的评论或空行。如果您希望有人查看您的一百行代码，至少可以减轻他们的工作难度。为什么在内核代码中使用

std:：fabsf

？您是在VisualStudio中构建调试项目还是发布项目？你在哪个GPU上运行这个？您是否为该GPU正确设置了编译目标？@RobertCrovella我想这是一个有点坏的习惯（std:）。不过，非常感谢您指出可能的设置！所以您遇到了WDDM超时。发布代码内核比调试代码内核运行得更快。调试代码内核花费了足够长的时间来触发WDDM超时。如果您进一步修改代码（处理更多数据），您可能会再次遇到这种情况，即使是在发布模式下。

#include <stdio.h>
#include<iostream>
#include <math.h>
#include <fstream>
#include <cmath>
#include <cuda_runtime.h>
using namespace std;
__global__ void
vectorAdd(const float *A, const float *p, float *u, float *v, float *a, float *fs, float *rhat, float *phat, int j, int numElements)
{
    int ni = blockDim.x * blockIdx.x + threadIdx.x;
    int ti = 10000 * ni;
    float t = A[ni];
    float m = 1.0f;
    float epsilon = 10.0f;
    float gamma = 0.5f;
    float beta = 1.0f / 4.0f;
    float pi = 3.14159f;
    float ksy = 0.04f;
    float dt = 0.02f;
    float fy = 1000.0f;
    float c = 4.0f * ksy * pi / t;
    float a1 = m / (beta * dt * dt) + gamma * c / (beta * dt);
    float a2 = m / (beta * dt) + c*(gamma / beta - 1.0f);
    float a3 = (1.0f / (2.0f *beta) - 1.0f)* m + dt*(gamma / (2.0f *beta) - 1.0f) *c;
    float k = m * (2.0f*pi / t)*(2.0f*pi / t);
    float fz;
    float ab;

    if (ni < numElements)
    {
    v[10000 * ni] = 0.0f;
    u[10000 * ni] = 0.0f;
    fs[10000 * ni] = 0.0f;
    a[10000 * ni] = 0.0f;

        for (size_t i = 0 + 10000 * ni; i < j-1 + 10000 * ni; i++)
        {
            u[i + 1] = u[i];
            fs[i + 1] = fs[i];
            phat[i + 1] = p[i + 1] + a1 * u[i] + a2*v[i] + a3*a[i];
            rhat[i + 1] = phat[i + 1] - fs[i + 1] - a1 * u[i + 1];
            ab = std::fabsf(rhat[i + 1]);
            while (ab >= epsilon)
            {
                u[i + 1] = u[i + 1] + rhat[i + 1] / (k + a1);
                fz = fs[i] + k*(u[i + 1] - u[i]);
                if (fz > 0.0)
                {
                    fs[i + 1] = fminf(fz, fy);
                }
                else
                {
                    fs[i + 1] = fmaxf(fz, -fy);

                }
                rhat[i + 1] = phat[i + 1] - fs[i + 1] - a1 * u[i + 1];
                ab = std::fabsf(rhat[i + 1]);
            }
            v[i + 1] = gamma*(u[i + 1] - u[i]) / beta / dt + (1.0f - gamma / beta)*v[i] + dt*(1.0f - gamma / 2.0f / beta)*a[i];
            a[i + 1] = (u[i + 1] - u[i]) / beta / dt / dt - (1.0f / beta / dt)*v[i] + (1.0f - 1.0f / 2.0f / beta)*a[i];
        }
    }
}
int
main(void)
{

    int numElements = 16;
    int kore;
    FILE* myfile;
    size_t size = numElements * sizeof(float);
    printf("[Vector addition of %d elements]\n", numElements);
    float *h_data = (float *)malloc(10000);
    float *h_datat = (float *)malloc(10000);
    myfile = fopen("ElCentro-import2.txt", "r");
    std::cout << "file is opened\n";
    kore = 0;
    while (EOF != fscanf(myfile, "%f %f \n", &h_datat[kore], &h_data[kore])) 
    {
        kore++;
    }
    std::cout << kore << "file is read\n";
    kore--;
    size_t nsize = 10000 * numElements * sizeof(float);
    float *h_A = (float *)malloc(size);
    float *h_u = (float *)malloc(nsize);
    float *h_v = (float *)malloc(nsize);
    float *h_a = (float *)malloc(nsize);
    float *h_p = (float *)malloc(nsize);

    for (int i = 0; i < kore; ++i)
    {
        h_p[i] = -10000 * h_data[i];
    }
    for (int i = 0; i < numElements; ++i)
    {
        h_A[i] = 1.0f;
    }
    float *d_A = NULL;
    err = cudaMalloc((void **)&d_A, size);
    float *d_p = NULL;
    err = cudaMalloc((void **)&d_p, nsize);
    float *d_u = NULL;
    err = cudaMalloc((void **)&d_u, nsize);
    float *d_v = NULL;
    err = cudaMalloc((void **)&d_v, nsize);
    float *d_a = NULL;
    err = cudaMalloc((void **)&d_a, nsize);
    float *d_fs = NULL;
    err = cudaMalloc((void **)&d_fs, nsize);
    float *d_rhat = NULL;
    err = cudaMalloc((void **)&d_rhat, nsize);
    float *d_phat = NULL;
    err = cudaMalloc((void **)&d_phat, nsize);
    printf("Copy input data from the host memory to the CUDA device\n");
    err = cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
    err = cudaMemcpy(d_p, h_p, nsize, cudaMemcpyHostToDevice);
    int threadsPerBlock = 1;
    int blocksPerGrid = (numElements + threadsPerBlock - 1) / threadsPerBlock;
    printf("CUDA kernel launch with %d blocks of %d threads\n", blocksPerGrid, threadsPerBlock);

    vectorAdd <<<blocksPerGrid, threadsPerBlock >>>(d_A, d_p, d_u, d_v, d_a, d_fs, d_rhat, d_phat, kore-1, numElements);
    err = cudaGetLastError();
    cudaDeviceSynchronize();

    printf("Copy output data from the CUDA device to the host memory\n");
    err = cudaMemcpy(h_u, d_u, nsize, cudaMemcpyDeviceToHost);
    }
    for (int i = 0; i < numElements; ++i)
    {
        std::cout << h_u[1000+kore * i] << "\n";;
    }


    printf("Test PASSED\n");
    err = cudaFree(d_A);
    err = cudaFree(d_p);
    err = cudaFree(d_u);
    err = cudaFree(d_v);
    err = cudaFree(d_a);
    err = cudaFree(d_fs);
    err = cudaFree(d_rhat);
    err = cudaFree(d_phat);
    free(h_A);
    free(h_p);
    free(h_u);
    free(h_v);
    free(h_a);
    free(h_data);
    free(h_datat);
    err = cudaDeviceReset();
    printf("Done\n");
    return 0;
}

for (int i = 0; i < numElements; ++i)
{
    std::cout << h_u[1000+kore * i] << "\n";;
}