The source code can be found here , or below. I’m updating the wrapper we use for folding at home, and for some reason I am getting some undefined reference errors. I have correctly linked -lcudart , so I’m not sure what I am missing. Any help would be greatly appreciated.
s.shelnutt@funtoo-64 ~/gpu3/wrapper/cudart $ make
winegcc -c -mno-cygwin -I/usr/local/cuda/include/ -o cudart.o cudart.c
In file included from /usr/local/cuda/include/cuda_runtime_api.h:53,
from /usr/local/cuda/include/crt/host_runtime.h:108,
from cudart.c:7:
/usr/local/cuda/include/host_defines.h:57:1: warning: "__cdecl" redefined
<command-line>: warning: this is the location of the previous definition
In file included from cudart.c:8:
/usr/local/cuda/include/device_functions.h: In function '__sinf':
/usr/local/cuda/include/device_functions.h:4437: warning: incompatible implicit declaration of built-in function 'sinf'
/usr/local/cuda/include/device_functions.h: In function '__cosf':
/usr/local/cuda/include/device_functions.h:4447: warning: incompatible implicit declaration of built-in function 'cosf'
/usr/local/cuda/include/device_functions.h: In function '__log2f':
/usr/local/cuda/include/device_functions.h:4452: warning: incompatible implicit declaration of built-in function 'log2f'
cudart.c: In function 'wine_cudaGetTextureReference':
cudart.c:296: warning: passing argument 1 of 'cudaGetTextureReference' from incompatible pointer type
/usr/local/cuda/include/cuda_runtime_api.h:189: note: expected 'const struct textureReference **' but argument is of type 'struct textureReference **'
cudart.c: In function 'wine_cudaRegisterFatBinary':
cudart.c:549: warning: return makes pointer from integer without a cast
cudart.c: In function 'wine_cudaUnregisterFatBinary':
cudart.c:553: warning: 'return' with a value, in function returning void
cudart.c: In function 'wine_cudaRegisterVar':
cudart.c:557: warning: 'return' with a value, in function returning void
cudart.c: In function 'wine_cudaRegisterTexture':
cudart.c:561: warning: 'return' with a value, in function returning void
cudart.c: In function 'wine_cudaRegisterShared':
cudart.c:565: warning: 'return' with a value, in function returning void
cudart.c: In function 'wine_cudaRegisterSharedVar':
cudart.c:569: warning: 'return' with a value, in function returning void
cudart.c: In function 'wine_cudaRegisterFunction':
cudart.c:574: warning: 'return' with a value, in function returning void
cudart.c: At top level:
/usr/local/cuda/include/device_functions.h:3768: warning: '__cuda___isnan' used but never defined
/usr/local/cuda/include/device_functions.h:3769: warning: '__cuda___isnanf' used but never defined
winegcc -shared cudart.dll.spec -mno-cygwin -o cudart.dll.so cudart.o -L/usr/local/cuda/lib/ -lcudart -lodbc32 -lole32 -loleaut32 -lwinspool -lodbccp32 -luuid
cudart.o: In function `__saturatef':
cudart.c:(.text+0x3b6c): undefined reference to `__cuda___isnanf'
cudart.o: In function `__sad':
cudart.c:(.text+0x3bfc): undefined reference to `__cuda_llabs'
cudart.o: In function `__usad':
cudart.c:(.text+0x3c47): undefined reference to `__cuda_llabs'
cudart.o: In function `__internal_float2ll_kernel':
cudart.c:(.text+0x3d2b): undefined reference to `__cuda___isnanf'
cudart.o: In function `__internal_float2ull_kernel':
cudart.c:(.text+0x4082): undefined reference to `__cuda___isnanf'
cudart.o: In function `__fdividef':
cudart.c:(.text+0x4eaa): undefined reference to `__cuda_fabsf'
cudart.c:(.text+0x4ecf): undefined reference to `__cuda_fabsf'
cudart.o: In function `__expf':
cudart.c:(.text+0x5085): undefined reference to `__cuda_exp2f'
cudart.o: In function `__exp10f':
cudart.c:(.text+0x50b6): undefined reference to `__cuda_exp2f'
cudart.o: In function `__powf':
cudart.c:(.text+0x5140): undefined reference to `__cuda_exp2f'
cudart.o: In function `__internal_double2ll_kernel':
cudart.c:(.text+0x6130): undefined reference to `__cuda___isnan'
cudart.o: In function `__internal_double2ull_kernel':
cudart.c:(.text+0x6383): undefined reference to `__cuda___isnan'
cudart.o: In function `clock64':
cudart.c:(.text+0x7f61): undefined reference to `__cuda_clock'
/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/../../../../x86_64-pc-linux-gnu/bin/ld: warning: creating a DT_TEXTREL in object.
collect2: ld returned 1 exit status
winegcc: x86_64-pc-linux-gnu-gcc failed
make: *** [cudart.dll.so] Error 2
s.shelnutt@funtoo-64 ~/gpu3/wrapper/cudart $
cudart.c
/*This is a wrapper for cudart32_30_14.dll and libcudart.so.3.0.14
Copyrighted by Seth Shelnutt under the LGPL v2.1 or later
*/
#include <windows.h>
#include "crt/host_runtime.h"
#include "device_functions.h"
#include "sm_20_atomic_functions.h"
#include "texture_fetch_functions.h"
#include "cuda_runtime_api.h"
#include "cuda_gl_interop.h"
#include "driver_functions.h"
#include "driver_types.h"
//#include "math_functions.h"
#include <stdlib.h>
#include <GL/gl.h>
#include <string.h>
#include "wine/debug.h"
/* #if 0
#define __CUDA_INTERNAL_COMPILATION__
#include "crt/host_runtime.h"
#endif
#ifdef USE_SLEEPWAIT
#include <time.h>
static struct timespec sleepTime = { 0, USE_SLEEPWAIT };
#endif /* USE_SLEEPWAIT */
WINE_DEFAULT_DEBUG_CHANNEL(cuda);
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
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 pitchedDevPtr, int value, struct cudaExtent extent ){
return cudaMemset3D( pitchedDevPtr, 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 );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaMalloc(void **devPtr, size_t size) {
return cudaMalloc(devPtr, size);
}
cudaError_t WINAPI wine_cudaMallocHost( void** hostPtr, size_t size ){
return cudaMallocHost( hostPtr, size);
}
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_cudaMallocArray( struct cudaArray** array, const struct cudaChannelFormatDesc* desc, size_t width, size_t height ){
return cudaMallocArray( array, desc, width, height);
}
cudaError_t WINAPI wine_cudaFree(void *devPtr) {
return cudaFree(devPtr);
}
cudaError_t WINAPI wine_cudaFreeHost( void* hostPtr ){
return cudaFreeHost( hostPtr);
}
cudaError_t WINAPI wine_cudaFreeArray( struct cudaArray* array ){
return cudaFreeArray( array );
}
cudaError_t WINAPI wine_cudaHostAlloc(void **pHost, size_t bytes, unsigned int flags){
return cudaHostAlloc( pHost, bytes, flags );
}
cudaError_t WINAPI wine_cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags){
return cudaHostGetDevicePointer( pDevice, pHost, flags );
}
cudaError_t WINAPI wine_cudaHostGetFlags(unsigned int *pFlags, void *pHost){
return cudaHostGetFlags( pFlags, pHost );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaMemGetInfo(size_t *free, size_t *total){
return cudaMemGetInfo( free, total );
}
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_cudaMemcpyToArray( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpyToArray( dst, wOffset, hOffset, src, count, kind );
}
cudaError_t WINAPI wine_cudaMemcpyFromArray( void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpyFromArray( dst, src, wOffset, hOffset, count, kind );
}
cudaError_t WINAPI wine_cudaMemcpyArrayToArray( struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind ){
return cudaMemcpyArrayToArray( dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind );
}
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_cudaMemcpy2DToArray( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2DToArray( dst, wOffset, hOffset, src, spitch, width, height, kind );
}
cudaError_t WINAPI wine_cudaMemcpy2DFromArray( void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2DFromArray( dst, dpitch, src, wOffset, hOffset, width, height, kind );
}
cudaError_t WINAPI wine_cudaMemcpy2DArrayToArray( struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind ){
return cudaMemcpy2DArrayToArray( dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind );
}
cudaError_t WINAPI wine_cudaMemcpyToSymbol( const char *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 char *symbol, size_t count, size_t offset , enum cudaMemcpyKind kind ) {
return cudaMemcpyFromSymbol( dst, symbol, count, offset, kind );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
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_cudaMemcpyToArrayAsync( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyToArrayAsync( dst, wOffset, hOffset, src, count, kind, stream );\
}
cudaError_t WINAPI wine_cudaMemcpyFromArrayAsync( void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyFromArrayAsync( dst, src, wOffset, hOffset, count, kind, stream );
}
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_cudaMemcpy2DToArrayAsync( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpy2DToArrayAsync( dst, wOffset, hOffset, src, spitch, width, height, kind, stream );
}
cudaError_t WINAPI wine_cudaMemcpy2DFromArrayAsync( void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpy2DFromArrayAsync( dst, dpitch, src, wOffset, hOffset, width, height, kind, stream );
}
/*cudaError_t WINAPI cudaMemcpyToSymbolAsync( const char *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyToSymbolAsync( symbol, src, count, offset, kind, stream );
}
cudaError_t WINAPI cudaMemcpyFromSymbolAsync( void *dst, const char *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream ){
return cudaMemcpyFromSymbolAsync( dst, symbol, count, offset, kind, stream);
}*/
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaMemset( void *devPtr, int value, size_t count ){
return cudaMemset( devPtr, value, count );
}
cudaError_t WINAPI wine_cudaMemset2D( void *devPtr, size_t pitch, int value, size_t width, size_t height ){
return cudaMemset2D( devPtr, pitch, value, width, height );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGetSymbolAddress( void **devPtr, const char *symbol ){
return cudaGetSymbolAddress( devPtr, symbol );
}
cudaError_t WINAPI wine_cudaGetSymbolSize( size_t *size, const char *symbol ){
return cudaGetSymbolSize( size, symbol );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGetDeviceCount( int* count ){
return cudaGetDeviceCount( count );
}
cudaError_t WINAPI wine_cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device) {
return cudaGetDeviceProperties(prop, device);
}
cudaError_t WINAPI wine_cudaChooseDevice( int *device, const struct cudaDeviceProp *prop ){
return cudaChooseDevice( device, prop );
}
cudaError_t WINAPI wine_cudaSetDevice( int device ) {
return cudaSetDevice( device );
}
cudaError_t WINAPI wine_cudaGetDevice( int* device ){
return cudaGetDevice( device );
}
/*cudaError_t WINAPI cudaSetValidDevices( int *device_arr, int len ){
return cudaSetValidDevices( device_arr, len);
}
cudaError_t WINAPI cudaSetDeviceFlags( int flags ){
return cudaSetDeviceFlags( flags );
}*/
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaBindTexture( size_t *offset, const struct textureReference *texref, const void *devPtr, const struct cudaChannelFormatDesc *desc, size_t size ){
return cudaBindTexture( offset, texref, devPtr, desc, size );
}
/*cudaError_t WINAPI cudaBindTexture2D( size_t *offset,const struct textureReference *texref,const void *devPtr, const struct cudaChannelFormatDesc *desc,size_t width, size_t height, size_t pitch ){
return cudaBindTexture2D( offset, texref, devPtr, desc, width, height, pitch );
}*/
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 );
}
cudaError_t WINAPI wine_cudaGetTextureReference( struct textureReference **texRef, const char* symbol){
return cudaGetTextureReference( texRef, symbol );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGetChannelDesc( struct cudaChannelFormatDesc *desc, const struct cudaArray *array ){
return cudaGetChannelDesc( desc, array );
}
struct cudaChannelFormatDesc WINAPI wine_cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f){
return cudaCreateChannelDesc(x, y, z, w, f);
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGetLastError() {
return cudaGetLastError();
}
const char* WINAPI wine_cudaGetErrorString(cudaError_t error) {
return cudaGetErrorString(error);
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaConfigureCall( dim3 gridDim, dim3 blockDim, size_t sharedMem, cudaStream_t stream ) {
return cudaConfigureCall( gridDim, blockDim, sharedMem, stream );
}
cudaError_t WINAPI wine_cudaSetupArgument( const void *arg, size_t size, size_t offset ){
return cudaSetupArgument( arg, size, offset );
}
cudaError_t WINAPI wine_cudaFuncSetCacheConfig( const char *func, enum cudaFuncCache cacheConfig ){
return cudaFuncSetCacheConfig( func, cacheConfig );
}
cudaError_t WINAPI wine_cudaLaunch(const char *entry) {
return cudaLaunch(entry);
}
cudaError_t WINAPI wine_cudaFuncGetAttributes( struct cudaFuncAttributes *attr, const char *func ){
return cudaFuncGetAttributes( attr, func );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaStreamCreate( cudaStream_t *pStream ){
return cudaStreamCreate( pStream );
}
cudaError_t WINAPI wine_cudaStreamDestroy( cudaStream_t stream ){
return cudaStreamDestroy( stream );
}
cudaError_t WINAPI wine_cudaStreamSynchronize( cudaStream_t stream ){
return cudaStreamSynchronize( stream );
}
cudaError_t WINAPI wine_cudaStreamQuery(cudaStream_t stream){
return cudaStreamQuery( stream );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaEventCreate( cudaEvent_t *event ){
return cudaEventCreate( event );
}
cudaError_t WINAPI wine_cudaEventCreateWithFlags( cudaEvent_t *event, int flags ){
return cudaEventCreateWithFlags( event, flags );
}
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 *ms, cudaEvent_t start, cudaEvent_t end ){
return cudaEventElapsedTime( ms, start, end );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaSetDoubleForDevice( double *d ){
return cudaSetDoubleForDevice( d );
}
cudaError_t WINAPI wine_cudaSetDoubleForHost( double *d ){
return cudaSetDoubleForHost( d );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaThreadExit( void ){
return cudaThreadExit( );
}
cudaError_t WINAPI wine_cudaThreadSynchronize( void ){
return cudaThreadSynchronize( );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaDriverGetVersion( int *driverVersion ){
return cudaDriverGetVersion( driverVersion );
}
cudaError_t WINAPI wine_cudaRuntimeGetVersion( int *runtimeVersion ){
return cudaRuntimeGetVersion( runtimeVersion );
}
/************************************************************
*******************
* *
* cuda_runtime_api.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGraphicsUnregisterResource( struct cudaGraphicsResource *resource ){
return cudaGraphicsUnregisterResource( resource );
}
cudaError_t WINAPI wine_cudaGraphicsResourceSetMapFlags( struct cudaGraphicsResource *resource, unsigned int flags ){
return cudaGraphicsResourceSetMapFlags( resource, flags );
}
cudaError_t WINAPI wine_cudaGraphicsMapResources( int count, struct cudaGraphicsResource **resources, cudaStream_t stream ){
return cudaGraphicsMapResources( count, resources, stream );
}
cudaError_t WINAPI wine_cudaGraphicsUnmapResources( int count, struct cudaGraphicsResource **resources, cudaStream_t stream ){
return cudaGraphicsUnmapResources( count, resources, stream );
}
cudaError_t WINAPI wine_cudaGraphicsResourceGetMappedPointer( void **devPtr, size_t *size, struct cudaGraphicsResource *resource){
return cudaGraphicsResourceGetMappedPointer( devPtr, size, resource );
}
cudaError_t WINAPI wine_cudaGraphicsSubResourceGetMappedArray( struct cudaArray **arrayPtr, struct cudaGraphicsResource *resource, unsigned int arrayIndex, unsigned int mipLevel){
return cudaGraphicsSubResourceGetMappedArray( arrayPtr, resource, arrayIndex, mipLevel );
}
/************************************************************
*******************
* *
* cuda_gl_interop.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGLSetGLDevice(int device){
return cudaGLSetGLDevice( device );
}
cudaError_t WINAPI wine_cudaGraphicsGLRegisterImage( struct cudaGraphicsResource **resource, GLuint image, GLenum target, unsigned int Flags ){
return cudaGraphicsGLRegisterImage( resource, image, target, Flags );
}
cudaError_t WINAPI wine_cudaGraphicsGLRegisterBuffer( struct cudaGraphicsResource **resource, GLuint buffer, unsigned int Flags ){
return cudaGraphicsGLRegisterBuffer( resource, buffer, Flags );
}
/*cudaError_t WINAPI wine_cudaWGLGetDevice( int *device, HGPUNV hGpu ){
return cudaWGLGetDevice( device, hGpu );
}*/
/************************************************************
*******************
* *
* cuda_gl_interop.h *
* *
************************************************************
*******************/
cudaError_t WINAPI wine_cudaGLRegisterBufferObject( GLuint bufObj ){
return cudaGLRegisterBufferObject( bufObj );
}
cudaError_t WINAPI wine_cudaGLMapBufferObject( void** devPtr, GLuint bufObj ){
return cudaGLMapBufferObject( devPtr, bufObj );
}
cudaError_t WINAPI wine_cudaGLUnmapBufferObject( GLuint bufObj ){
return cudaGLUnmapBufferObject( bufObj );
}
cudaError_t WINAPI wine_cudaGLUnregisterBufferObject( GLuint bufObj ){
return cudaGLUnregisterBufferObject( bufObj );
}
cudaError_t WINAPI wine_cudaGLSetBufferObjectMapFlags( GLuint bufObj, unsigned int flags ){
return cudaGLSetBufferObjectMapFlags( bufObj, flags );
}
cudaError_t WINAPI wine_cudaGLMapBufferObjectAsync( void **devPtr, GLuint bufObj, cudaStream_t stream ){
return cudaGLMapBufferObjectAsync( devPtr, bufObj, stream );
}
cudaError_t WINAPI wine_cudaGLUnmapBufferObjectAsync( GLuint bufObj, cudaStream_t stream){
return cudaGLUnmapBufferObjectAsync( bufObj, stream );
}
/************************************************************
*******************
* *
* host_runtime.h *
* *
************************************************************
*******************/
void** WINAPI wine_cudaRegisterFatBinary( void *fatCubin ) {
return __cudaRegisterFatBinary( fatCubin );
}
void WINAPI wine_cudaUnregisterFatBinary( void **fatCubinHandle ) {
return __cudaUnregisterFatBinary( fatCubinHandle );
}
void WINAPI wine_cudaRegisterVar( void **fatCubinHandle, char *hostVar, char *deviceAddress, const char *deviceName, int ext, int size, int constant, int global ){
return __cudaRegisterVar( fatCubinHandle, hostVar, deviceAddress, deviceName, ext, size, constant, global );
}
void WINAPI wine_cudaRegisterTexture( void **fatCubinHandle, const struct textureReference *hostVar, const void **deviceAddress, const char *deviceName, int dim, int norm, int ext ){
return __cudaRegisterTexture( fatCubinHandle, hostVar, deviceAddress, deviceName, dim, norm, ext );
}
void WINAPI wine_cudaRegisterShared( void **fatCubinHandle, void **devicePtr ) {
return __cudaRegisterShared( fatCubinHandle, devicePtr );
}
void WINAPI wine_cudaRegisterSharedVar(void **fatCubinHandle, void **devicePtr, size_t size, size_t alignment, int storage) {
return __cudaRegisterSharedVar( fatCubinHandle, devicePtr, size, alignment, storage);
}
void WINAPI wine_cudaRegisterFunction( void **fatCubinHandle, const char *hostFun, char *deviceFun, const char *deviceName, int thread_limit, uint3 *tid, uint3 *bid, dim3 *bDim, dim3 *gDim, int *wSize ) {
return __cudaRegisterFunction( fatCubinHandle, hostFun, deviceFun, deviceName, thread_limit, tid, bid, bDim, gDim, wSize );
}
/************************************************************
*******************
* *
* device_functions.h *
* *
************************************************************
*******************/
int WINAPI wine_cudaSynchronizeThreads( void **one, void *two ){
return __cudaSynchronizeThreads( one, two );
}
/************************************************************
*******************
* *
* texture_fetch_functions.h *
* *
************************************************************
*******************/
void WINAPI wine_cudaTextureFetch( const void *tex, void *index, int integer, void *val ){
return __cudaTextureFetch( tex, index, integer, val );
}
/************************************************************
*******************
* *
* sm_20_atomic_functions.h *
* *
************************************************************
*******************/
void WINAPI wine_cudaMutexOperation( int lock ){
return __cudaMutexOperation( lock );
}
cudart.dll.spec
#
# 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( ptr ) wine_cudaGetDeviceCount
@ stdcall cudaSetDevice( long ) wine_cudaSetDevice
@ stdcall cudaGetDevice( ptr ) wine_cudaGetDevice
@ stdcall cudaGetDeviceProperties( ptr long ) wine_cudaGetDeviceProperties
@ stdcall cudaChooseDevice( ptr ptr ) wine_cudaChooseDevice
@ stdcall cudaThreadSynchronize( ) wine_cudaThreadSynchronize
@ stdcall cudaThreadExit( ) wine_cudaThreadExit
@ stdcall cudaStreamCreate( ptr ) wine_cudaStreamCreate
@ stdcall cudaStreamQuery( long ) wine_cudaStreamQuery
@ stdcall cudaStreamSynchronize( long ) wine_cudaStreamSynchronize
@ stdcall cudaStreamDestroy( long ) wine_cudaStreamDestroy
@ stdcall cudaEventCreate( ptr ) wine_cudaEventCreate
@ stdcall cudaEventRecord( long long ) wine_cudaEventRecord
@ stdcall cudaEventQuery( long ) wine_cudaEventQuery
@ stdcall cudaEventSynchronize( long ) wine_cudaEventSynchronize
@ stdcall cudaEventDestroy( long ) wine_cudaEventDestroy
@ stdcall cudaEventElapsedTime( ptr long long ) wine_cudaEventElapsedTime
@ stdcall cudaConfigureCall( long long long long) wine_cudaConfigureCall
@ stdcall cudaLaunch( ptr ) wine_cudaLaunch
@ stdcall cudaSetupArgument( ptr long long ) wine_cudaSetupArgument
@ stdcall cudaMalloc( ptr long ) wine_cudaMalloc
@ stdcall cudaMallocPitch( ptr ptr long long ) wine_cudaMallocPitch
@ stdcall cudaFree( ptr ) wine_cudaFree
@ stdcall cudaMallocArray( ptr ptr long long ) wine_cudaMallocArray
@ stdcall cudaFreeArray( ptr ) wine_cudaFreeArray
@ stdcall cudaMallocHost( ptr long ) wine_cudaMallocHost
@ stdcall cudaFreeHost( ptr ) wine_cudaFreeHost
@ stdcall cudaMemset( ptr long long ) wine_cudaMemset
@ stdcall cudaMemset2D( ptr long long long long ) wine_cudaMemset2D
@ stdcall cudaMemcpy( ptr ptr long long ) wine_cudaMemcpy
@ stdcall cudaMemcpyAsync( ptr ptr long long long ) wine_cudaMemcpyAsync
@ stdcall cudaMemcpy2D( ptr long ptr long long long long ) wine_cudaMemcpy2D
@ stdcall cudaMemcpy2DAsync( ptr long ptr long long long long long ) wine_cudaMemcpy2DAsync
@ stdcall cudaMemcpyToArray( ptr long long ptr long long ) wine_cudaMemcpyToArray
@ stdcall cudaMemcpyToArrayAsync( ptr long long ptr long long long ) wine_cudaMemcpyToArrayAsync
@ stdcall cudaMemcpy2DToArray( ptr long long ptr long long long long ) wine_cudaMemcpy2DToArray
@ stdcall cudaMemcpy2DToArrayAsync( ptr long long ptr long long long long long ) wine_cudaMemcpy2DToArrayAsync
@ stdcall cudaMemcpyFromArray( ptr ptr long long long long ) wine_cudaMemcpyFromArray
@ stdcall cudaMemcpyFromArrayAsync( ptr ptr long long long long long ) wine_cudaMemcpyFromArrayAsync
@ stdcall cudaMemcpy2DFromArray( ptr long ptr long long long long long ) wine_cudaMemcpy2DFromArray
@ stdcall cudaMemcpy2DFromArrayAsync( ptr long ptr long long long long long long ) wine_cudaMemcpy2DFromArrayAsync
@ stdcall cudaMemcpyArrayToArray( ptr long long ptr long long long long ) wine_cudaMemcpyArrayToArray
@ stdcall cudaMemcpy2DArrayToArray( ptr long long ptr long long long long long ) wine_cudaMemcpy2DArrayToArray
@ stdcall cudaMemcpyToSymbol( long ptr long long long ) wine_cudaMemcpyToSymbol
@ stdcall cudaMemcpyFromSymbol( ptr long long long long ) wine_cudaMemcpyFromSymbol
@ stdcall cudaGetSymbolAddress( ptr ptr ) wine_cudaGetSymbolAddress
@ stdcall cudaGetSymbolSize( ptr ptr ) wine_cudaGetSymbolSize
@ stdcall cudaMalloc3D( ptr long ) wine_cudaMalloc3D
@ stdcall cudaMalloc3DArray( ptr ptr long ) wine_cudaMalloc3DArray
@ stdcall cudaMemset3D( long long long ) wine_cudaMemset3D
@ stdcall cudaMemcpy3D( long ) wine_cudaMemcpy3D
@ stdcall cudaMemcpy3DAsync( long long ) wine_cudaMemcpy3DAsync
@ stdcall cudaBindTexture( ptr ptr ptr ptr long ) wine_cudaBindTexture
@ stdcall cudaBindTextureToArray( ptr ptr ptr ) wine_cudaBindTextureToArray
@ stdcall cudaUnbindTexture( ptr ) wine_cudaUnbindTexture
@ stdcall cudaGetChannelDesc( ptr ptr ) wine_cudaGetChannelDesc
@ stdcall cudaGetTextureReference( ptr long) wine_cudaGetTextureReference
@ stdcall cudaGetTextureAlignmentOffset( ptr ptr ) wine_cudaGetTextureAlignmentOffset
@ stdcall cudaGLSetGLDevice( long ) wine_cudaGLSetGLDevice
@ stdcall cudaGLRegisterBufferObject( long ) wine_cudaGLRegisterBufferObject
@ stdcall cudaGLMapBufferObject( ptr long ) wine_cudaGLMapBufferObject
@ stdcall cudaGLUnmapBufferObject( long ) wine_cudaGLUnmapBufferObject
@ stdcall cudaGLUnregisterBufferObject( long ) wine_cudaGLUnregisterBufferObject
#Direct3D functions were skipped, implementation at a later time
@ stdcall cudaGetLastError( ) wine_cudaGetLastError
@ stdcall cudaGetErrorString( long ) wine_cudaGetErrorString
@ stdcall __cudaRegisterFatBinary( ptr ) wine_cudaRegisterFatBinary
@ stdcall __cudaRegisterFunction( ptr ptr ptr ptr long ptr ptr ptr ptr ptr ) wine_cudaRegisterFunction
@ stdcall __cudaRegisterVar( ptr ptr ptr ptr long long long long ) wine_cudaRegisterVar
@ stdcall __cudaRegisterShared( ptr ptr ) wine_cudaRegisterShared
@ stdcall __cudaRegisterSharedVar( ptr ptr long long long ) wine_cudaRegisterSharedVar
@ stdcall __cudaUnregisterFatBinary( ptr ) wine_cudaUnregisterFatBinary
#New to cuda 3.0
@ stdcall __cudaMutexOperation( long ) wine_cudaMutexOperation
@ stdcall __cudaRegisterTexture( ptr ptr ptr ptr long long long ) wine_cudaRegisterTexture
@ stdcall __cudaSynchronizeThreads( ) wine_cudaSynchronizeThreads
@ stdcall __cudaTextureFetch( ptr ptr long ptr) wine_cudaTextureFetch
#@ stdcall cudaBindTexture2D( ptr ptr ptr ptr long long long ) wine_cudaBindTexture2D
@ stdcall cudaCreateChannelDesc( long long long long long ) wine_cudaCreateChannelDesc
@ stdcall cudaDriverGetVersion( long ) wine_cudaDriverGetVersion
@ stdcall cudaEventCreateWithFlags( ptr long) wine_cudaEventCreateWithFlags
@ stdcall cudaFuncGetAttributes( ptr ptr ) wine_cudaFuncGetAttributes
@ stdcall cudaFuncSetCacheConfig( ptr long ) wine_cudaFuncSetCacheConfig
@ stdcall cudaGLMapBufferObjectAsync( ptr long long ) wine_cudaGLMapBufferObjectAsync
@ stdcall cudaGLSetBufferObjectMapFlags( long long ) wine_cudaGLSetBufferObjectMapFlags
@ stdcall cudaGLUnmapBufferObjectAsync( long long ) wine_cudaGLUnmapBufferObjectAsync
@ stdcall cudaGraphicsGLRegisterBuffer( ptr long long ) wine_cudaGraphicsGLRegisterBuffer
@ stdcall cudaGraphicsGLRegisterImage( ptr long long long ) wine_cudaGraphicsGLRegisterImage
@ stdcall cudaGraphicsMapResources( long ptr long ) wine_cudaGraphicsMapResources
@ stdcall cudaGraphicsResourceGetMappedPointer( ptr ptr ptr ) wine_cudaGraphicsResourceGetMappedPointer
@ stdcall cudaGraphicsResourceSetMapFlags( ptr long ) wine_cudaGraphicsResourceSetMapFlags
@ stdcall cudaGraphicsSubResourceGetMappedArray( ptr ptr long long ) wine_cudaGraphicsSubResourceGetMappedArray
@ stdcall cudaGraphicsUnmapResources( long ptr long ) wine_cudaGraphicsUnmapResources
@ stdcall cudaGraphicsUnregisterResource( ptr ) wine_cudaGraphicsUnregisterResource
@ stdcall cudaHostAlloc( ptr long long ) wine_cudaHostAlloc
@ stdcall cudaHostGetDevicePointer( ptr ptr long ) wine_cudaHostGetDevicePointer
@ stdcall cudaHostGetFlags( ptr ptr ) wine_cudaHostGetFlags
@ stdcall cudaMemGetInfo( ptr ptr ) wine_cudaMemGetInfo
#@ stdcall cudaMemcpyFromSymbolAsync( ptr ptr long long long long ) wine_cudaMemcpyFromSymbolAsync
#@ stdcall cudaMemcpyToSymbolAsync( ptr ptr long long long long ) wine_cudaMemcpyToSymbolAsync
@ stdcall cudaRuntimeGetVersion( long ) wine_cudaRuntimeGetVersion
#@ stdcall cudaSetDeviceFlags( long ) wine_cudaSetDeviceFlags
@ stdcall cudaSetDoubleForDevice( ptr ) wine_cudaSetDoubleForDevice
@ stdcall cudaSetDoubleForHost( ptr ) wine_cudaSetDoubleForHost
#@ stdcall cudaSetValidDevices( ptr long ) wine_cudaSetValidDevices
#@ stdcall cudaWGLGetDevice( ptr long ) wine_cudaWGLGetDevice
makefile
### Generated by Winemaker 0.7.4
SRCDIR = .
SUBDIRS =
DLLS = cudart.dll
EXES =
### Common settings
CEXTRA = -mno-cygwin
CXXEXTRA = -mno-cygwin
RCEXTRA =
DEFINES =
INCLUDE_PATH = -I/usr/local/cuda/include/
DLL_PATH =
DLL_IMPORTS =
LIBRARY_PATH = -L/usr/local/cuda/lib/
LIBRARIES = -lcudart
### cudart.dll sources and settings
cudart_dll_MODULE = cudart.dll
cudart_dll_C_SRCS = cudart.c
cudart_dll_CXX_SRCS =
cudart_dll_RC_SRCS =
cudart_dll_LDFLAGS = -shared \
$(cudart_dll_MODULE:%=%.spec) \
-mno-cygwin
cudart_dll_DLL_PATH =
cudart_dll_DLLS = odbc32 \
ole32 \
oleaut32 \
winspool \
odbccp32
cudart_dll_LIBRARY_PATH=
cudart_dll_LIBRARIES = uuid
cudart_dll_OBJS = $(cudart_dll_C_SRCS:.c=.o) \
$(cudart_dll_CXX_SRCS:.cpp=.o) \
$(cudart_dll_RC_SRCS:.rc=.res)
### Global source lists
C_SRCS = $(cudart_dll_C_SRCS)
CXX_SRCS = $(cudart_dll_CXX_SRCS)
RC_SRCS = $(cudart_dll_RC_SRCS)
### Tools
CC = winegcc
CXX = wineg++
RC = wrc
### Generic targets
all: $(SUBDIRS) $(DLLS:%=%.so) $(EXES:%=%.so)
### Build rules
.PHONY: all clean dummy
$(SUBDIRS): dummy
@cd $@ && $(MAKE)
# Implicit rules
.SUFFIXES: .cpp .rc .res
DEFINCL = $(INCLUDE_PATH) $(DEFINES) $(OPTIONS)
.c.o:
$(CC) -c $(CFLAGS) $(CEXTRA) $(DEFINCL) -o $@ $<
.cpp.o:
$(CXX) -c $(CXXFLAGS) $(CXXEXTRA) $(DEFINCL) -o $@ $<
.cxx.o:
$(CXX) -c $(CXXFLAGS) $(CXXEXTRA) $(DEFINCL) -o $@ $<
.rc.res:
$(RC) $(RCFLAGS) $(RCEXTRA) $(DEFINCL) -fo$@ $<
# Rules for cleaning
CLEAN_FILES = y.tab.c y.tab.h lex.yy.c core *.orig *.rej \
\\#*\\# *~ *% .\\#*
clean:: $(SUBDIRS:%=%/__clean__) $(EXTRASUBDIRS:%=%/__clean__)
$(RM) $(CLEAN_FILES) $(RC_SRCS:.rc=.res) $(C_SRCS:.c=.o) $(CXX_SRCS:.cpp=.o)
$(RM) $(DLLS:%=%.so) $(EXES:%=%.so) $(EXES:%.exe=%)
$(SUBDIRS:%=%/__clean__): dummy
cd `dirname $@` && $(MAKE) clean
$(EXTRASUBDIRS:%=%/__clean__): dummy
-cd `dirname $@` && $(RM) $(CLEAN_FILES)
### Target specific build rules
DEFLIB = $(LIBRARY_PATH) $(LIBRARIES) $(DLL_PATH) $(DLL_IMPORTS:%=-l%)
$(cudart_dll_MODULE).so: $(cudart_dll_OBJS)
$(CC) $(cudart_dll_LDFLAGS) -o $@ $(cudart_dll_OBJS) $(cudart_dll_LIBRARY_PATH) $(DEFLIB) $(cudart_dll_DLLS:%=-l%) $(cudart_dll_LIBRARIES:%=-l%)