C++ 双重自由或腐败（out）-C++；

我尝试在CUDA中使用最小值、最大值、总和和平均值来实现并行归约

这是我目前的主要代码片段

int main()
{
    const auto count = 8;
    const int size = count * sizeof(int);
    int h[] = {13, 27, 15, 14, 33, 2, 24, 6};

    int* d;
    int choice = 0;
    do{
        cout <<"\n ---MENU--- \n";
        cout <<"1. Find Sum of Numbers in Array\n";
        cout <<"2. Find Max of Array\n";
        cout <<"3. Find Min of Array\n";
        cout <<"4. Find Average of Array\n";
        cout <<"5. Exit\n";
        cout <<"Enter your Choice : ";
        cin >> choice;
        switch(choice){
            case 1:
                cudaMalloc(&d, size);
                cudaMemcpy(d, h, size, cudaMemcpyHostToDevice);

                sum <<<1, count / 2 >>>(d);

                int result;
                cudaMemcpy(&result, d, sizeof(int), cudaMemcpyDeviceToHost);

                cout << "Sum is " << result << endl;

                getchar();

                cudaFree(d);
                delete[] h;
                break;
            case 5:
                break;
            default:
                cout<<"Wrong Input!! Try Again!";
                break;
        }
    }while(choice != 5);
return 0;
}

intmain（）
{
常数自动计数=8；
常量int size=count*sizeof（int）；
inth[]={13,27,15,14,33,2,24,6}；
int*d；
int-choice=0；
做{
cout不要忽略编译器警告。您正在对非动态分配的数组调用
delete[]
。这是未定义的行为，可能是导致内核转储的原因

您不需要为堆栈上的数组调用
delete[]
。
不要忽略编译器警告。您正在对非动态分配的数组调用
delete[]
。这是未定义的行为，可能是导致内核转储的原因

您不需要调用
delete[]
用于堆栈上的阵列。
不要忽略您的警告？您需要阅读有关自动分配的内容。您是否在Valgrind下运行了它？这是诊断分配和解除分配错误的常用方法。请使用您的代码将其简化为您的问题的一部分。您当前的代码包含了许多与您的问题无关的内容—最小的sample通常看起来类似于一个好的单元测试：只执行一个任务，输入值为可再现性指定。不要忽略您的警告？您需要阅读有关自动分配的内容。您是否在Valgrind下运行了它？这是诊断分配和解除分配错误的常用方法。请使用您的代码将其减少到问题的一部分。您当前的代码包含了许多与您的问题无关的内容-一个最小的样本通常看起来类似于一个好的单元测试：只执行一个任务，输入值指定为再现性。谢谢！！删除delete[]帮助了我！谢谢！！删除delete[]帮助了我！
__global__ void sum(int* input)
{
    const int tid = threadIdx.x;
    auto step_size = 1;
    int number_of_threads = blockDim.x;

    while (number_of_threads > 0)
    {
        if (tid < number_of_threads) // still alive?
        {
            const auto fst = tid * step_size * 2;
            const auto snd = fst + step_size;
            input[fst] += input[snd];
        }

        step_size <<= 1; 
        number_of_threads >>= 1;
    }
}