Segmentation Fault while executing CUDA program

Question

I am new to programming on NVIDIA CUDA and am getting 'Segmentation Fault' on executing my program, which uses CUBLAS library. I have installed NVIDIA CUDA Toolkit 6.5.

Following is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Includes, cuda */
#include <cuda_runtime.h>
#include <cublas_v2.h>
#include <helper_cuda.h>

int main(int argc, char **argv)
{
    cublasStatus_t status;
    float *h_A;
    float *h_B;
    float *h_C;
    float *d_A = 0;
    float *d_B = 0;
    float *d_C = 0;
    int n2 = 5;

    float *h_T;

    cublasHandle_t handle;

    int dev = findCudaDevice(argc, (const char **)argv);

    if (dev == -1)
    {
        return EXIT_FAILURE;
    }

    /* Initialize CUBLAS */
    printf("simpleCUBLAS test running..\n");

    status = cublasCreate(&handle);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! CUBLAS initialization error\n");
        return EXIT_FAILURE;
    }

    printf("Allocating A\n");

    /* Allocate host memory for the matrices */
    h_A = (float *)malloc(n2 * sizeof(h_A[0]));

    if (h_A == 0)
    {
        fprintf(stderr, "!!!! host memory allocation error (A)\n");
        return EXIT_FAILURE;
    }

    printf("Allocated A\n");

    h_B = (float *)malloc(n2 * sizeof(h_B[0]));

    if (h_B == 0)
    {
        fprintf(stderr, "!!!! host memory allocation error (B)\n");
        return EXIT_FAILURE;
    }

    printf("Allocated B\n");

    h_C = (float *)malloc(n2 * sizeof(h_C[0]));

    if (h_C == 0)
    {
        fprintf(stderr, "!!!! host memory allocation error (C)\n");
        return EXIT_FAILURE;
    }

    printf("Allocated C\n");


    h_T = (float *)malloc(n2 * sizeof(h_T[0]));

    if (h_T == 0)
    {
        fprintf(stderr, "!!!! host memory allocation error (C)\n");
        return EXIT_FAILURE;
    }


    /* Fill the matrices with test data */
    int i;
    for (i = 0; i < n2; i++)
    {
        h_A[i] = i;
        h_B[i] = i;

        //h_A[i] = rand() / (float)RAND_MAX;
        //h_B[i] = rand() / (float)RAND_MAX;
        h_C[i] = 0;
    }

    printf("Filled A,, B, C\n");

    /* Allocate device memory for the matrices */
    if (cudaMalloc((void **)&d_A, n2 * sizeof(d_A[0])) != cudaSuccess)
    {
        fprintf(stderr, "!!!! device memory allocation error (allocate A)\n");
        return EXIT_FAILURE;
    }

    printf("Allocated d_A\n");

    if (cudaMalloc((void **)&d_B, n2 * sizeof(d_B[0])) != cudaSuccess)
    {
        fprintf(stderr, "!!!! device memory allocation error (allocate B)\n");
        return EXIT_FAILURE;
    }

    printf("Allocated d_B\n");

    if (cudaMalloc((void **)&d_C, n2 * sizeof(d_C[0])) != cudaSuccess)
    {
        fprintf(stderr, "!!!! device memory allocation error (allocate C)\n");
        return EXIT_FAILURE;
    }

    printf("Allocated d_C\n");

    status = cublasSetVector(n2, sizeof(h_A[0]), h_A, 1, d_A, 1);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! device access error (write A)\n");
        return EXIT_FAILURE;
    }

    status = cublasSetVector(n2, sizeof(h_B[0]), h_B, 1, d_B, 1);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! device access error (write B)\n");
        return EXIT_FAILURE;
    }

    status = cublasSetVector(n2, sizeof(h_C[0]), h_C, 1, d_C, 1);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! device access error (write C)\n");
        return EXIT_FAILURE;
    }

    fprintf(stderr, "!!!! error test\n");
    printf("Vectors set.\n");

    status = cublasGetVector(n2, sizeof(h_T[0]), d_A, 1, h_T, 1);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! device access error (read T)\n");
        return EXIT_FAILURE;
    }

    int f;
    for (f = 0; f < n2; f++)
    {
        printf("T[%d]=%f\n", f, h_T[f]);
    }


    status = cublasSdot(handle, n2, d_A, 1, d_B, 1, d_C);

    printf("Dot product done.\n");

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! kernel execution error.\n");
        return EXIT_FAILURE;
    }


    status = cublasGetVector(n2, sizeof(h_C[0]), d_C, 1, h_C, 1);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! device access error (read C)\n");
        return EXIT_FAILURE;
    }

    if (cudaFree(d_A) != cudaSuccess)
    {
        fprintf(stderr, "!!!! memory free error (A)\n");
        return EXIT_FAILURE;
    }

    if (cudaFree(d_B) != cudaSuccess)
    {
        fprintf(stderr, "!!!! memory free error (B)\n");
        return EXIT_FAILURE;
    }

    if (cudaFree(d_C) != cudaSuccess)
    {
        fprintf(stderr, "!!!! memory free error (C)\n");
        return EXIT_FAILURE;
    }

    status = cublasDestroy(handle);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        fprintf(stderr, "!!!! shutdown error (A)\n");
        return EXIT_FAILURE;
    }



    return 0;
}

The program executes fine just before the call to 'cublasSdot'. I was able to deduce this by placing certain print statements.

The output of my program:

GPU Device 0: "GRID K520" with compute capability 3.0

simpleCUBLAS test running..
Allocating A
Allocated A
Allocated B
Allocated C
Filled A,, B, C
Allocated d_A
Allocated d_B
Allocated d_C
!!!! error test
Vectors set.
T[0]=0.000000
T[1]=1.000000
T[2]=2.000000
T[3]=3.000000
T[4]=4.000000
Segmentation fault

I think I may calling the method cublasSDot() in an incorrect manner. Please advice where am I wrong.

NOTE: I created the above program with reference to the CUDA Toolkit 6.5 Sample File named 'simpleCUBLAS.cpp'. I printed the value for array 'T to test the method 'cublasGetVector'. 'cublasSDot' implies vector dot product [More information].

Standard Warning : Please [do not cast](http://stackoverflow.com/q/605845/2173917) the return value of `malloc()` and family. — Sourav Ghosh, Mar 11 '15 at 06:02
`h_A = (float *)malloc(n2 * sizeof(h_A[0]));`. In this line, you are accessing `h_A[0]` before allocating memory to `h_A`. This will cause undefined behavior. Same for `h_B` and `h_C`. — sgarizvi, Mar 11 '15 at 06:03
@sgarizvi `sizeof(x)` doesn't generate an access to `x`. It's not UB. @Sourav Ghosh your suggestion applies to C, not C++. — Robert Crovella, Mar 12 '15 at 16:28
@RobertCrovella.. You are right. Sorry my mistake, I was thinking C99. — sgarizvi, Mar 13 '15 at 07:13

score 2 · Accepted Answer · edited May 23 '17 at 10:24

2

I was able to solve the problem dealing with 'Segmentation Fault' by adding the following code, just after cublasCreate().

cublasSetPointerMode(handle, CUBLAS_POINTER_MODE_DEVICE);

This will make sure that the CUBLAS library is aware that the inputs are scalars. Source: Retaining dot product on GPGPU using CUBLAS routine

edited May 23 '17 at 10:24

Community

1
1

answered Mar 11 '15 at 06:56

Rohit V

101
9

Segmentation Fault while executing CUDA program

1 Answers1