Why my CUDA application isn't starting?

Question 1

The error is from Windows: your attempt is falling very short, as the executable you have produced is not valid for windows. It's possible you are using DEBUG DLL's with a RELEASE build. Or that you are mixing a 32 bit build with 64 bit DLL's, or many other odd combinations... (64 bit exe on 32 bit system?....)

Usually you can get more information regarding DLL problems looking in the Windows event viewer, but if you start running your application in the debugger (for sure with visual studio) you will get more information on your error.

If you can't understand what's wrong, you can try to find what is failing with http://www.dependencywalker.com/.

Question 2

1st error, which was the reason to start this thread, disappeared by installing the right glew32.dll libraries into the right folders.

2nd error, where the debugger stopped at glGenBuffers(1, vbo), was because I forgot about glewInit()

Below you can find the working application:

#include <math.h>
#include <GL\glew.h>
#include <GL\glut.h>
#include <cuda_gl_interop.h>
#include <cuda_runtime.h>
#include <device_launch_parameters.h>

GLuint vbo;
struct cudaGraphicsResource* vbo_cuda;

const unsigned int window_width = 512;
const unsigned int window_height = 512;

const unsigned int mesh_width = 256;
const unsigned int mesh_height = 256;

float tim = 0.0;

__global__ void createVertices(float4* positions, float tim, 
                                unsigned int mesh_width, unsigned int mesh_height) {
    unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
    unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;

    float u = x / (float)mesh_width;
    float v = y / (float)mesh_height;
    u = u * 2.0f - 1.0f;
    v = v * 2.0f - 1.0f;

    // calculate simple sine wave pattern
    float freq = 4.0f;
    float w = sinf(u * freq + tim)
    * cosf(v * freq + tim) * 0.5f;

    positions[y * mesh_width + x] = make_float4(u, w, v, 1.0f);
}

void runCuda(GLuint vbo)
{
    // map OpenGL buffer object for writing from CUDA
    float4* positions;
    cudaGraphicsMapResources(1, &vbo_cuda, 0);
    size_t num_bytes;
    cudaGraphicsResourceGetMappedPointer((void**)&positions,
                                        &num_bytes,
                                        vbo_cuda);

    // execute kernel
    dim3 dimBlock(16, 16, 1);
    dim3 dimGrid(mesh_width / dimBlock.x, mesh_height / dimBlock.y, 1);
    createVertices<<<dimGrid, dimBlock>>>(positions, tim,
                                            mesh_width, mesh_height);

    cudaGraphicsUnmapResources(1, &vbo_cuda, 0);
}

void init(void) {
    glewInit();
    glClearColor(0, 0, 0, 1);
    glDisable(GL_DEPTH_TEST);
}

void reshape(int w, int h) {
    // viewport
    glViewport(0, 0, w, h);
    // projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60, (GLfloat)w/(GLfloat)h, 0.1, 10);
}

void createVBO(GLuint* vbo) {
    // create buffer object
    glGenBuffers(1, vbo);
    glBindBuffer(GL_ARRAY_BUFFER, *vbo);

    // initialize buffer object
    unsigned int size = mesh_width * mesh_height * 4 * sizeof(float);
    glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    cudaGLRegisterBufferObject(*vbo);
}

void deleteVBO(GLuint* vbo) {
    cudaGraphicsUnregisterResource(vbo_cuda);
    glBindBuffer(1, *vbo);
    glDeleteBuffers(1, vbo);
    cudaGLUnregisterBufferObject(*vbo);
}

void display() {
    // run CUDA kernel to generate vertex positions
    runCuda(vbo);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // set view matrix
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    // render from the vbo
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glVertexPointer(4, GL_FLOAT, 0, 0);

    glEnableClientState(GL_VERTEX_ARRAY);
    glColor3f(1, 0, 0);
    glDrawArrays(GL_POINTS, 0, mesh_width * mesh_height);
    glDisableClientState(GL_VERTEX_ARRAY);

    glutSwapBuffers();
    glutPostRedisplay();

    tim+=1;
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key) {
    case(27) :
        deleteVBO(&vbo);
        exit(0);
    }
}

int main (int argc, char**argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutInitWindowSize(window_width, window_height);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Cuda GL interop");
    init();
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutReshapeFunc(reshape);

    // create VBO
    createVBO(&vbo);

    // run the cuda part
    runCuda(vbo);

    cudaGLSetGLDevice(0);

    glutMainLoop();

    return 0;
}