I have #include <GL/gl.h>, maybe I do not have my makefile correct. I've attached the makefile, the cudart.c and all the nvidia header's need (14 of them) in one tar.bz2 file. Can someone check my makefile and all? I read through the nvidia license and it is ok to redistribute the headers.
On Mon, Jul 7, 2008 at 5:29 PM, Juan Lang <[EMAIL PROTECTED]> wrote:
> > cudart.c:261: error: expected ')' before 'bufferObj'
> > cudart.c:265: error: expected declaration specifiers or '...' before
> > 'GLuint'
> >
> > cudaError_t WINAPI wine_cudaGLRegisterBufferObject( GLuint bufferObj ){
>
> Check your includes again. GLuint is defined in <GL/gl.h> here.
> --Juan
>
/*This is a wrapper for cudart.dll and libdudart.so.2.0*/
#include <GL/gl.h>
#include <stdlib.h>
#include <string.h>
#include "cuda_runtime.h"
#include "cuda_runtime_api.h" /*I am unsure if both these headers are needed, both do contain some of the functions*/
#include "wine/debug.h"
#include <stdio.h>
WINE_DEFAULT_DEBUG_CHANNEL(cuda); /*Can I do this?*/
cudaError_t WINAPI wine_cudaGetDeviceCount( int* count ){
return cudaGetDeviceCount( count );
}
cudaError_t WINAPI wine_cudaSetDevice( int dev ){
return cudaSetDevice( dev );
}
cudaError_t WINAPI wine_cudaGetDevice( int* dev ){
return cudaGetDevice( dev );
}
cudaError_t WINAPI wine_cudaGetDeviceProperties( struct cudaDeviceProp* prop, int dev ){
return cudaGetDeviceProperties( prop, dev );
}
cudaError_t WINAPI wine_cudaChooseDevice( int* dev, const struct cudaDeviceProp* prop ){
return cudaChooseDevice( dev, prop );
}
cudaError_t WINAPI wine_cudaThreadSynchronize( void ){
return cudaThreadSynchronize( );
}
cudaError_t WINAPI wine_cudaThreadExit( void ){
return cudaThreadExit( );
}
cudaError_t WINAPI wine_cudaStreamCreate( cudaStream_t* stream ){
return cudaStreamCreate( stream );
}
cudaError_t WINAPI wine_cudaStreamQuery(cudaStream_t stream){
return cudaStreamQuery( stream );
}
cudaError_t WINAPI wine_cudaStreamSynchronize( cudaStream_t stream ){
return cudaStreamSynchronize( stream );
}
cudaError_t WINAPI wine_cudaStreamDestroy( cudaStream_t stream ){
return cudaStreamDestroy( stream );
}
cudaError_t WINAPI wine_cudaEventCreate( cudaEvent_t* event ){
return cudaEventCreate( event );
}
cudaError_t WINAPI wine_cudaEventRecord( cudaEvent_t event, cudaStream_t stream ){
return cudaEventRecord( event, stream );
}
cudaError_t WINAPI wine_cudaEventQuery( cudaEvent_t event ){
return cudaEventQuery( event );
}
cudaError_t WINAPI wine_cudaEventSynchronize( cudaEvent_t event ){
return cudaEventSynchronize( event );
}
cudaError_t WINAPI wine_cudaEventDestroy( cudaEvent_t event ){
return cudaEventDestroy( event );
}
cudaError_t WINAPI wine_cudaEventElapsedTime( float* time, cudaEvent_t start, cudaEvent_t end ){
return cudaEventElapsedTime( time, start, end );
}
cudaError_t WINAPI wine_cudaMalloc( void** devPtr, size_t count ){
return cudaMalloc( devPtr, count );
}
cudaError_t WINAPI wine_cudaMallocPitch( void** devPtr, size_t* pitch, size_t widthInBytes, size_t height ){
return cudaMallocPitch( devPtr, pitch, widthInBytes, height );
}
cudaError_t WINAPI wine_cudaFree( void* devPtr ){
return cudaFree( devPtr );
}
cudaError_t WINAPI wine_cudaMallocArray( struct cudaArray** array, const struct cudaChannelFormatDesc* desc, size_t width, size_t height ){
return cudaMallocArray( array, desc, width, height);
}
cudaError_t WINAPI wine_cudaFreeArray( struct cudaArray* array ){
return cudaFreeArray( array );
}
cudaError_t WINAPI wine_cudaMallocHost( void** hostPtr, size_t size ){
return cudaMallocHost( hostPtr, size);
}
cudaError_t WINAPI wine_cudaFreeHost( void* hostPtr ){
return cudaFreeHost( hostPtr);
}
cudaError_t WINAPI wine_cudaMemset( void* devPtr, int value, size_t count ){
return cudaMemset( devPtr, value, count);
}
cudaError_t WINAPI wine_cudaMemset2D( void* dstPtr, size_t pitch, int value, size_t width, size_t height ){
return cudaMemset2D( dstPtr, pitch, value, width, height );
}
cudaError_t WINAPI wine_cudaMemcpy( void* dst, const void* src, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpy( dst, src, count, kind );
}
cudaError_t WINAPI wine_cudaMemcpyAsync( void* dst, const void* src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyAsync( dst, src, count, kind, stream );
}
cudaError_t WINAPI wine_cudaMemcpy2D( void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2D( dst, dpitch, src, spitch, width, height, kind );
}
cudaError_t WINAPI wine_cudaMemcpy2DAsync( void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpy2DAsync( dst, dpitch, src, spitch, width, height, kind, stream );
}
cudaError_t WINAPI wine_cudaMemcpyToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpyToArray( dstArray, dstX, dstY, src, count, kind );
}
cudaError_t WINAPI wine_cudaMemcpyToArrayAsync( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyToArrayAsync( dstArray, dstX, dstY, src, count, kind, stream );\
}
cudaError_t WINAPI wine_cudaMemcpy2DToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2DToArray( dstArray, dstX, dstY, src, spitch, width, height, kind );
}
cudaError_t WINAPI wine_cudaMemcpy2DToArrayAsync( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpy2DToArrayAsync( dstArray, dstX, dstY, src, spitch, width, height, kind, stream );
}
cudaError_t WINAPI wine_cudaMemcpyFromArray( void* dst, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpyFromArray( dst, srcArray, srcX, srcY, count, kind );
}
cudaError_t WINAPI wine_cudaMemcpyFromArrayAsync( void* dst, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyFromArrayAsync( dst, srcArray, srcX, srcY, count, kind, stream );
}
cudaError_t WINAPI wine_cudaMemcpy2DFromArray( void* dst, size_t dpitch, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2DFromArray( dst, dpitch, srcArray, srcX, srcY, width, height, kind );
}
cudaError_t WINAPI wine_cudaMemcpy2DFromArrayAsync( void* dst, size_t dpitch, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpy2DFromArrayAsync( dst, dpitch, srcArray, srcX, srcY, width, height, kind, stream );
}
cudaError_t WINAPI wine_cudaMemcpyArrayToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpyArrayToArray( dstArray, dstX, dstY, srcArray, srcX, srcY, count, kind );
}
cudaError_t WINAPI wine_cudaMemcpy2DArrayToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2DArrayToArray( dstArray, dstX, dstY, srcArray, srcX, srcY, width, height, kind );
}
/*cudaError_t WINAPI wine_cudaMemcpyToSymbol( const T& symbol, const void* src, size_t count, size_t offset, enum cudaMemcpyKind kind ){
return cudaMemcpyToSymbol( symbol, src, count, offset, kind );
}
cudaError_t WINAPI wine_cudaMemcpyFromSymbol( void *dst, const T& symbol, size_t count, size_t offset, enum cudaMemcpyKind kind ){
return cudaMemcpyFromSymbol( *dst, symbol, count, offset, kind );
}
cudaError_t WINAPI wine_cudaGetSymbolAddress( void** devPtr, const T& symbol ){
return cudaGetSymbolAddress( devPtr, symbol );
}
cudaError_t WINAPI wine_cudaGetSymbolSize( size_t* size, const T& symbol ){
return cudaGetSymbolSize( size, symbol );
}*/
cudaError_t WINAPI wine_cudaMalloc3D( struct cudaPitchedPtr* pitchDevPtr, struct cudaExtent extent ){
return cudaMalloc3D( pitchDevPtr, extent );
}
cudaError_t WINAPI wine_cudaMalloc3DArray( struct cudaArray** arrayPtr, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent ){
return cudaMalloc3DArray( arrayPtr, desc, extent );
}
cudaError_t WINAPI wine_cudaMemset3D( struct cudaPitchedPtr dstPitchPtr, int value, struct cudaExtent extent ){
return cudaMemset3D( dstPitchPtr, value, extent );
}
cudaError_t WINAPI wine_cudaMemcpy3D( const struct cudaMemcpy3DParms *p ){
return cudaMemcpy3D( p );
}
cudaError_t WINAPI wine_cudaMemcpy3DAsync( const struct cudaMemcpy3DParms *p, cudaStream_t stream ){
return cudaMemcpy3DAsync( p, stream );
}
/* cudaChannelFormatDesc needs to be implemented */
cudaError_t WINAPI wine_cudaGetChannelDesc( struct cudaChannelFormatDesc* desc, const struct cudaArray* array ){
return cudaGetChannelDesc( desc, array );
}
cudaError_t WINAPI wine_cudaGetTextureReference( struct textureReference** texRef, const char* symbol){
return cudaGetTextureReference( texRef, symbol );
}
cudaError_t WINAPI wine_cudaBindTexture( size_t* offset, const struct textureReference* texRef, const void* devPtr, const struct cudaChannelFormatDesc* desc, size_t size ){ /* changed size = UINT_MAX, to just size*/
return cudaBindTexture( offset, texRef, devPtr, desc, size );
}
cudaError_t WINAPI wine_cudaBindTextureToArray( const struct textureReference* texRef, const struct cudaArray* array, const struct cudaChannelFormatDesc* desc ){
return cudaBindTextureToArray( texRef, array, desc );
}
cudaError_t WINAPI wine_cudaUnbindTexture( const struct textureReference* texRef ){
return cudaUnbindTexture( texRef );
}
cudaError_t WINAPI wine_cudaGetTextureAlignmentOffset( size_t* offset, const struct textureReference* texRef ){
return cudaGetTextureAlignmentOffset( offset, texRef );
}
/*cudaChannelFormatDesc cudaCreateChannelDesc needs to be implemented */
/* cudaError_t WINAPI wine_cudaBindTexture( size_t* offset, const struct texture < T, dim, readMode >& texRef, const void* devPtr, const struct cudaChannelFormatDesc& desc, size_t size ){ /* changed size = UINT_MAX, to just size
return cudaBindTexture( offset, texRef, devPtr, desc, size );
}
cudaError_t WINAPI wine_cudaBindTextureToArray( const struct texture < T, dim, readMode >& texRef, const struct cudaArray* cuArray, const struct cudaChannelFormatDesc& desc ){
return cudaBindTextureToArray( texRef, cuArray, desc );
}*/
cudaError_t WINAPI wine_cudaConfigureCall( dim3 gridDim, dim3 blockDim, size_t sharedMem, int tokens ){ /* changed sharedMen = 0, tokens = 0, to just sharedMem and tokens*/
return cudaConfigureCall( gridDim, blockDim, sharedMem, tokens );
}
cudaError_t WINAPI wine_cudaLaunch(T entry){
return cudaLaunch( entry );
}
cudaError_t WINAPI wine_cudaSetupArgument(void* arg, size_t count, size_t offset){
return cudaSetupArgument( arg, count, offset );
}
cudaError_t WINAPI wine_cudaGLSetGLDevice(int device){
return cudaGLSetGLDevice( device );
}
cudaError_t WINAPI wine_cudaGLRegisterBufferObject( GLUint bufferObj ){
return cudaGLRegisterBufferObject( bufferObj );
}
cudaError_t WINAPI wine_cudaGLMapBufferObject( void** devPtr, GLUint bufferObj ){
return cudaGLMapBufferObject( devPtr, bufferObj );
}
cudaError_t WINAPI wine_udaGLUnmapBufferObject( GLuint bufferObj ){
return udaGLUnmapBufferObject( bufferObj );
}
cudaError_t WINAPI wine_cudaGLUnregisterBufferObject( GLUint bufferObj ){
return cudaGLUnregisterBufferObject( bufferObj );
}
/*Direct3D functions were skipped, implementation at a later time*/
cudaError_t WINAPI wine_cudaGetLastError( ){
return cudaGetLastError( );
}
cudaError_t WINAPI wine_cudaGetErrorString( ){
return cudaGetErrorString( );
}
#
# File: cudart.dll.spec
#
# Copyrighted by Seth Shelnutt under the LGPL v2.1 or later
#
# Wine spec file for the cudart.dll built-in library (a minimal wrapper around the
# linux library libcuart)
#
# For further details of wine spec files see the Winelib documentation at
# www.winehq.org
@ stdcall cudaGetDeviceCount( int* count ) wine_cudaGetDeviceCount
@ stdcall cudaSetDevice( int dev ) wine_cudaSetDevice
@ stdcall cudaGetDevice( int* dev ) wine_cudaGetDevice
@ stdcall cudaGetDeviceProperties( struct cudaDeviceProp* prop, int dev ) wine_cudaGetDeviceProperties
@ stdcall cudaChooseDevice( int* dev, const struct cudaDeviceProp* prop ) wine_cudaChooseDevice
@ stdcall cudaThreadSynchronize(void) wine_cudaThreadSynchronize
@ stdcall cudaThreadExit(void) wine_cudaThreadExit
@ stdcall cudaStreamCreate( cudaStream_t* stream ) wine_cudaStreamCreate
@ stdcall cudaStreamQuery(cudaStream_t stream) wine_cudaStreamQuery
@ stdcall cudaStreamSynchronize( cudaStream_t stream ) wine_cudaStreamSynchronize
@ stdcall cudaStreamDestroy( cudaStream_t stream ) wine_cudaStreamDestroy
@ stdcall cudaEventCreate( cudaEvent_t* event ) wine_cudaEventCreate
@ stdcall cudaEventRecord( cudaEvent_t event, CUstream stream ) wine_cudaEventRecord
@ stdcall cudaEventQuery( cudaEvent_t event ) wine_cudaEventQuery
@ stdcall cudaEventSynchronize( cudaEvent_t event ) wine_cudaEventSynchronize
@ stdcall cudaEventDestroy( cudaEvent_t event ) wine_cudaEventDestroy
@ stdcall cudaEventElapsedTime( float* time, cudaEvent_t start, cudaEvent_t end ) wine_cudaEventElapsedTime
@ stdcall cudaMalloc( void** devPtr, size_t count ) wine_cudaMalloc
@ stdcall cudaMallocPitch( void** devPtr, size_t* pitch, size_t widthInBytes, size_t height ) wine_cudaMallocPitch
@ stdcall cudaFree( void* devPtr ) wine_cudaFree
@ stdcall cudaMallocArray( struct cudaArray** array, const struct cudaChannelFormatDesc* desc, size_t width, size_t height ) wine_cudaMallocArray
@ stdcall cudaFreeArray( struct cudaArray* array ) wine_cudaFreeArray
@ stdcall cudaMallocHost( void** hostPtr, size_t size ) wine_cudaMallocHost
@ stdcall cudaFreeHost( void* hostPtr ) wine_cudaFreeHost
@ stdcall cudaMemset( void* devPtr, int value, size_t count ) wine_cudaMemset
@ stdcall cudaMemset2D( void* dstPtr, size_t pitch, int value, size_t width, size_t height ) wine_cudaMemset2D
@ stdcall cudaMemcpy( void* dst, const void* src, size_t count, enum cudaMemcpyKind kind ) wine_cudaMemcpy
@ stdcall cudaMemcpyAsync( void* dst, const void* src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ) wine_cudaMemcpyAsync
@ stdcall cudaMemcpy2D( void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ) wine_cudaMemcpy2D
@ stdcall cudaMemcpy2DAsync( void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ) wine_cudaMemcpy2DAsync
@ stdcall cudaMemcpyToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t count, enum cudaMemcpyKind kind ) wine_cudaMemcpyToArray
@ stdcall cudaMemcpyToArrayAsync( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ) wine_cudaMemcpyToArrayAsync
@ stdcall cudaMemcpy2DToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ) wine_cudaMemcpy2DToArray
@ stdcall cudaMemcpy2DToArrayAsync( struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ) wine_cudaMemcpy2DToArrayAsync
@ stdcall cudaMemcpyFromArray( void* dst, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t count, enum cudaMemcpyKind kind ) wine_cudaMemcpyFromArray
@ stdcall cudaMemcpyFromArrayAsync( void* dst, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ) wine_cudaMemcpyFromArrayAsync
@ stdcall cudaMemcpy2DFromArray( void* dst, size_t dpitch, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t width, size_t height, enum cudaMemcpyKind kind ) wine_cudaMemcpy2DFromArray
@ stdcall cudaMemcpy2DFromArrayAsync( void* dst, size_t dpitch, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ) wine_cudaMemcpy2DFromArrayAsync
@ stdcall cudaMemcpyArrayToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t count, enum cudaMemcpyKind kind ) wine_cudaMemcpyArrayToArray
@ stdcall cudaMemcpy2DArrayToArray( struct cudaArray* dstArray, size_t dstX, size_t dstY, const struct cudaArray* srcArray, size_t srcX, size_t srcY, size_t width, size_t height, enum cudaMemcpyKind kind ) wine_cudaMemcpy2DArrayToArray
@ stdcall cudaMemcpyToSymbol( const T& symbol, const void* src, size_t count, size_t offset, enum cudaMemcpyKind kind ) wine_cudaMemcpyToSymbol
@ stdcall cudaMemcpyFromSymbol( void *dst, const T& symbol, size_t count, size_t offset, enum cudaMemcpyKind kind ) wine_cudaMemcpyFromSymbol
@ stdcall cudaGetSymbolAddress( void** devPtr, const T& symbol ) wine_cudaGetSymbolAddress
@ stdcall cudaGetSymbolSize( size_t* size, const T& symbol ) wine_cudaGetSymbolSize
@ stdcall cudaMalloc3D( struct cudaPitchedPtr* pitchDevPtr, struct cudaExtent extent ) wine_cudaMalloc3D
@ stdcall cudaMalloc3DArray( struct cudaArray** arrayPtr, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent ) wine_cudaMalloc3DArray
@ stdcall cudaMemset3D( struct cudaPitchedPtr dstPitchPtr, int value, struct cudaExtent extent ) wine_cudaMemset3D
@ stdcall cudaMemcpy3D( const struct cudaMemcpy3DParms *p ) wine_cudaMemcpy3D
@ stdcall cudaMemcpy3DAsync( const struct cudaMemcpy3DParms *p, cudaStream_t stream ) wine_cudaMemcpy3DAsync
#@ stdcall struct cudaChannelFormatDesc {
# int x, y, z, w;
# enum cudaChannelFormatKind f;
#};
# Not sure what to do here, need to look into it.
@ stdcall cudaGetChannelDesc( struct cudaChannelFormatDesc* desc, const struct cudaArray* array ) wine_cudaGetChannelDesc
@ stdcall cudaGetTextureReference( struct textureReference** texRef, const char* symbol) wine_cudaGetTextureReference
@ stdcall cudaBindTexture( size_t* offset, const struct textureReference* texRef, const void* devPtr, const struct cudaChannelFormatDesc* desc, size_t size = UINT_MAX ) wine_cudaBindTexture
@ stdcall cudaBindTextureToArray( const struct textureReference* texRef, const struct cudaArray* array, const struct cudaChannelFormatDesc* desc ) wine_cudaBindTextureToArray
@ stdcall cudaUnbindTexture( const struct textureReference* texRef ) wine_cudaUnbindTexture
@ stdcall cudaGetTextureAlignmentOffset( size_t* offset, const struct textureReference* texRef ) wine_cudaGetTextureAlignmentOffset
#@ stdcall struct cudaChannelFormatDesc cudaCreateChannelDesc <T >() wine_
@ stdcall cudaBindTexture( size_t* offset, const struct texture < T, dim, readMode >& texRef, const void* devPtr, const struct cudaChannelFormatDesc& desc, size_t size = UINT_MAX ) wine_cudaBindTexture
@ stdcall cudaBindTextureToArray( const struct texture < T, dim, readMode >& texRef, const struct cudaArray* cuArray, const struct cudaChannelFormatDesc& desc ) wine_cudaBindTextureToArray
@ stdcall cudaConfigureCall( dim3 gridDim, dim3 blockDim, size_t sharedMem = 0, int tokens = 0 ) wine_cudaConfigureCall
@ stdcall cudaLaunch(T entry) wine_cudaLaunch
@ stdcall cudaSetupArgument(void* arg, size_t count, size_t offset) wine_cudaSetupArgument
@ stdcall cudaGLSetGLDevice(int device) wine_cudaGLSetGLDevice
@ stdcall cudaGLRegisterBufferObject( GLuint bufferObj ) wine_cudaGLRegisterBufferObject
@ stdcall cudaGLMapBufferObject( void** devPtr, GLuint bufferObj ) wine_cudaGLMapBufferObject
@ stdcall udaGLUnmapBufferObject( GLuint bufferObj ) wine_udaGLUnmapBufferObject
@ stdcall cudaGLUnregisterBufferObject( GLuint bufferObj ) wine_cudaGLUnregisterBufferObject
#Direct3D functions were skipped, implementation at a later time
@ stdcall cudaGetLastError( void ) wine_cudaGetLastError
@ stdcall const char* cudaGetErrorString(cudaError_t error) wine_cudaGetErrorString
#end of file
Makefile
Description: Binary data
cuda-headers.tar.bz2
Description: BZip2 compressed data
