New nVidia CUDA WINE Wrapper (v2.1) Imminent

Moderators: slegrand, Site Moderators, PandeGroup

New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby shatteredsilicon » Thu Feb 26, 2009 9:14 pm

If you are folding using the GPU client under WINE, you will need an updated wrapper as of Monday, due to arrival of a new project with a new core that requires extra functionality that the original wrapper doesn't provide. If you don't update your wrapper, FahCore_14 will not work.

Update:
Here is the modified source for the wrapper (minimalistic (i.e. no unnecessary functionality implemented) with throttling):

cudart.c:
Code: Select all
#include <windows.h>
#include "cudart.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);

#define QUEUE_MAX       20
#define HALF_QUEUE_MAX  ((QUEUE_MAX)/2)

static unsigned int numQueued = 0;
static BOOL eventInitialized = FALSE;
static cudaEvent_t event;

static const char* cudaErrorString[] = {
    "cudaSuccess",
    "cudaErrorMissingConfiguration",
    "cudaErrorMemoryAllocation",
    "cudaErrorInitializationError",
    "cudaErrorLaunchFailure",
    "cudaErrorPriorLaunchFailure",
    "cudaErrorLaunchTimeout",
    "cudaErrorLaunchOutOfResources",
    "cudaErrorInvalidDeviceFunction",
    "cudaErrorInvalidConfiguration",
    "cudaErrorInvalidDevice",
    "cudaErrorInvalidValue",
    "cudaErrorInvalidPitchValue",
    "cudaErrorInvalidSymbol",
    "cudaErrorMapBufferObjectFailed",
    "cudaErrorUnmapBufferObjectFailed",
    "cudaErrorInvalidHostPointer",
    "cudaErrorInvalidDevicePointer",
    "cudaErrorInvalidTexture",
    "cudaErrorInvalidTextureBinding",
    "cudaErrorInvalidChannelDescriptor",
    "cudaErrorInvalidMemcpyDirection",
    "cudaErrorAddressOfConstant",
    "cudaErrorTextureFetchFailed",
    "cudaErrorTextureNotBound",
    "cudaErrorSynchronizationError",
    "cudaErrorInvalidFilterSetting",
    "cudaErrorInvalidNormSetting",
    "cudaErrorMixedDeviceExecution",
    "cudaErrorCudartUnloading",
    "cudaErrorUnknown",
    "cudaErrorNotYetImplemented",
    "cudaErrorMemoryValueTooLarge",
    "cudaErrorInvalidResourceHandle",
    "cudaErrorNotReady"
};

static const char* debug_cudaError(cudaError_t err) {
    if (cudaErrorStartupFailure == err) {
        return "cudaErrorStartupFailure";
    }

    if (cudaErrorApiFailureBase == err) {
        return "cudaErrorApiFailureBase";
    }

    if (err >= 0 && err < sizeof(cudaErrorString)/sizeof(cudaErrorString[0])) {
        return cudaErrorString[err];
    }

    WINE_TRACE("unknown error %d\n", err);
    return "unknown CUDA error";
}

BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
{
    if (DLL_PROCESS_DETACH == fdwReason)
    {
        /* Cleanup */
        if (eventInitialized) {
            WINE_TRACE("releasing event %d\n", event);

            cudaError_t err = cudaEventDestroy(event);

            if (err) {
                WINE_TRACE("cudaEventDestroy: %s\n", debug_cudaError(err));
            }
        }
    }
}

cudaError_t WINAPI wine_cudaConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem,
                                          cudaStream_t stream) {
    WINE_TRACE("(%d %d %d) (%d %d %d) %d %d\n", gridDim.x, gridDim.y, gridDim.z, blockDim.x,
               blockDim.y, blockDim.z, sharedMem, stream);

    cudaError_t err = cudaConfigureCall(gridDim, blockDim, sharedMem, stream);

    if (err) {
        WINE_TRACE("return %s\n", debug_cudaError(err));
    }

    return err;
}

cudaError_t WINAPI wine_cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device) {
    WINE_TRACE("\n");
    return cudaGetDeviceProperties(prop, device);
}

const char* WINAPI wine_cudaGetErrorString(cudaError_t error) {
    WINE_TRACE("\n");
    return cudaGetErrorString(error);
}

cudaError_t WINAPI wine_cudaGetLastError() {
    WINE_TRACE("\n");

    cudaError_t err = cudaGetLastError();

    WINE_TRACE("return %s\n", debug_cudaError(err));

    return err;
}

cudaError_t WINAPI wine_cudaLaunch(const char *symbol) {
    WINE_TRACE("%p\n", symbol);

    if (QUEUE_MAX == numQueued) {
        cudaError_t evtErr;

        if (WINE_TRACE_ON(cuda)) {
            /* print out if event was recorded or not */
            WINE_TRACE("check event recorded %s\n", debug_cudaError(cudaEventQuery(event)));
        }

        /* wait for event */
#ifdef USE_SLEEPWAIT
        unsigned int sleepCount = 0;

        while (cudaEventQuery(event) != cudaSuccess) {
            nanosleep(&sleepTime, NULL);
            sleepCount++;
        }

        WINE_TRACE("slept %u times\n", sleepCount);
#else
        evtErr = cudaEventSynchronize(event);

        if (evtErr) {
            WINE_ERR("cudaEventSynchronize: %s\n", debug_cudaError(evtErr));
        }
#endif

        WINE_TRACE("event recorded, continuing\n");

        /* record a new event and subtract HALF_QUEUE_MAX from numQueued */
        numQueued = HALF_QUEUE_MAX;
        evtErr = cudaEventRecord(event, 0);

        if (evtErr) {
            WINE_ERR("cudaEventRecord: %s\n", debug_cudaError(evtErr));
        }
    }

    cudaError_t err = cudaLaunch(symbol);

    if (!eventInitialized) {
        /* Create an event on the first cudaLaunch call.  This is done here so the calling program
         * has a chance to select the GPU device with cudaSetDevice if desired. */
        cudaError_t evtErr = cudaEventCreate(&event);

        if (evtErr) {
            WINE_ERR("cudaEventCreate: %s\n", debug_cudaError(evtErr));
        }

        /* cudaEventCreate can return errors from previous asynchronous calls, so an error here does
         * not necessarily mean the event wasn't created.  Assume it was created for now. */
        eventInitialized = TRUE;
        WINE_TRACE("created event %d\n", event);
    }

    /* record an event at HALF_QUEUE_MAX */
    if (HALF_QUEUE_MAX == ++numQueued) {
        cudaError_t evtErr = cudaEventRecord(event, 0);  /* Assuming everything using stream 0 */

        if (evtErr) {
            WINE_ERR("cudaEventRecord: %s\n", debug_cudaError(evtErr));
        }
    }

    if (err) {
        WINE_TRACE("return %s\n", debug_cudaError(err));
    }

    return err;
}

cudaError_t WINAPI wine_cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind) {
    WINE_TRACE("%p, %p, %d, %d\n", dst, src, count, kind);

    cudaError_t err = cudaMemcpy(dst, src, count, kind);

    if (err) {
        WINE_TRACE("return %s\n", debug_cudaError(err));
    }

    return err;
}

cudaError_t WINAPI wine_cudaMemcpyFromSymbol(void *dst, const char *symbol, size_t count, size_t offset,
                                             enum cudaMemcpyKind kind) {
    WINE_TRACE("\n");
    return cudaMemcpyFromSymbol(dst, symbol, count, offset, kind);
}

cudaError_t WINAPI wine_cudaMemcpyToSymbol(const char *symbol, const void *src, size_t count, size_t offset,
                                           enum cudaMemcpyKind kind) {
    WINE_TRACE("\n");
    return cudaMemcpyToSymbol(symbol, src, count, offset, kind);
}

void** WINAPI wine_cudaRegisterFatBinary(void *fatCubin) {
    WINE_TRACE("\n");
    return __cudaRegisterFatBinary(fatCubin);
}

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) {
    WINE_TRACE("\n");
    __cudaRegisterFunction(fatCubinHandle, hostFun, deviceFun, deviceName, thread_limit, tid, bid,
                           bDim, gDim, wSize);
}

void WINAPI wine_cudaRegisterVar(void **fatCubinHandle, char *hostVar, char *deviceAddress,
                                 const char  *deviceName, int ext, int size, int constant,
                                 int global) {
    WINE_TRACE("\n");
    __cudaRegisterVar(fatCubinHandle, hostVar, deviceAddress, deviceName, ext, size, constant, global);
}

void WINAPI wine_cudaRegisterShared(void **fatCubinHandle, void **devicePtr) {
    WINE_TRACE("\n");
    __cudaRegisterShared(fatCubinHandle, devicePtr);
}

void WINAPI wine_cudaRegisterSharedVar(void **fatCubinHandle, void **devicePtr, size_t size,
                                    size_t alignment, int storage) {
    WINE_TRACE("\n");
    __cudaRegisterSharedVar(fatCubinHandle, devicePtr, size, alignment, storage);
}

cudaError_t WINAPI wine_cudaSetDevice(int device) {
    WINE_TRACE("\n");
    return cudaSetDevice(device);
}

cudaError_t WINAPI wine_cudaSetupArgument(void* arg, size_t count, size_t offset){
    WINE_TRACE("\n");
    return cudaSetupArgument(arg, count, offset);
}

cudaError_t WINAPI wine_cudaStreamQuery(cudaStream_t stream){
    WINE_TRACE("\n");
    return cudaStreamQuery(stream);
}

cudaError_t WINAPI wine_cudaThreadSynchronize(void){
    WINE_TRACE("\n");
    return cudaThreadSynchronize();
}

void WINAPI wine_cudaUnregisterFatBinary(void **fatCubinHandle) {
    WINE_TRACE("\n");
    __cudaUnregisterFatBinary(fatCubinHandle);
}

cudaError_t WINAPI wine_cudaFree(void *devPtr) {
    WINE_TRACE("\n");
    return cudaFree(devPtr);
}

cudaError_t WINAPI wine_cudaMalloc(void **devPtr, size_t size) {
    WINE_TRACE("\n");
    return cudaMalloc(devPtr, size);
}


cudart.h:
Code: Select all
#include "cuda_runtime_api.h"

void** __cudaRegisterFatBinary(void *fatCubin);
void __cudaUnregisterFatBinary(void **fatCubinHandle);

void __cudaRegisterFunction(void **fatCubinHandle, const char *hostFun, char *deviceFun,
                            const char *deviceName, int thread_limit, uint3 *tid,
                            uint3 *bid, dim3 *bDim, dim3 *gDim, int *wSize);

void __cudaRegisterVar(void **fatCubinHandle, char *hostVar, char *deviceAddress,
                       const char  *deviceName, int ext, int size, int constant,
                       int global);

void __cudaRegisterShared(void **fatCubinHandle, void **devicePtr);

void __cudaRegisterSharedVar(void **fatCubinHandle, void **devicePtr, size_t size,
                             size_t alignment, int storage);


cudart.dll.spec:
Code: Select all
@ 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
@ stub cudaBindTexture
@ stub cudaBindTextureToArray
@ stub cudaChooseDevice
@ stdcall cudaConfigureCall(ptr ptr long long) wine_cudaConfigureCall
@ stub cudaCreateChannelDesc
@ stub cudaD3D9Begin
@ stub cudaD3D9End
@ stub cudaD3D9GetDevice
@ stub cudaD3D9GetDirect3DDevice
@ stub cudaD3D9MapResources
@ stub cudaD3D9MapVertexBuffer
@ stub cudaD3D9RegisterResource
@ stub cudaD3D9RegisterVertexBuffer
@ stub cudaD3D9ResourceGetMappedPitch
@ stub cudaD3D9ResourceGetMappedPointer
@ stub cudaD3D9ResourceGetMappedSize
@ stub cudaD3D9ResourceGetSurfaceDimensions
@ stub cudaD3D9ResourceSetMapFlags
@ stub cudaD3D9SetDirect3DDevice
@ stub cudaD3D9UnmapResources
@ stub cudaD3D9UnmapVertexBuffer
@ stub cudaD3D9UnregisterResource
@ stub cudaD3D9UnregisterVertexBuffer
@ stub cudaEventCreate
@ stub cudaEventDestroy
@ stub cudaEventElapsedTime
@ stub cudaEventQuery
@ stub cudaEventRecord
@ stub cudaEventSynchronize
@ stdcall cudaFree(ptr) wine_cudaFree
@ stub cudaFreeArray
@ stub cudaFreeHost
@ stub cudaGetChannelDesc
@ stub cudaGetDevice
@ stub cudaGetDeviceCount
@ stdcall cudaGetDeviceProperties(ptr long) wine_cudaGetDeviceProperties
@ stdcall cudaGetErrorString(long) wine_cudaGetErrorString
@ stdcall cudaGetLastError() wine_cudaGetLastError
@ stub cudaGetSymbolAddress
@ stub cudaGetSymbolSize
@ stub cudaGetTextureAlignmentOffset
@ stub cudaGetTextureReference
@ stub cudaGLMapBufferObject
@ stub cudaGLRegisterBufferObject
@ stub cudaGLSetGLDevice
@ stub cudaGLUnmapBufferObject
@ stub cudaGLUnregisterBufferObject
@ stdcall cudaLaunch(ptr) wine_cudaLaunch
@ stdcall cudaMalloc(ptr long) wine_cudaMalloc
@ stub cudaMalloc3D
@ stub cudaMalloc3DArray
@ stub cudaMallocArray
@ stub cudaMallocHost
@ stub cudaMallocPitch
@ stdcall cudaMemcpy(ptr ptr long long) wine_cudaMemcpy
@ stub cudaMemcpy2D
@ stub cudaMemcpy2DArrayToArray
@ stub cudaMemcpy2DFromArray
@ stub cudaMemcpy2DToArray
@ stub cudaMemcpy3D
@ stub cudaMemcpyArrayToArray
@ stub cudaMemcpyFromArray
@ stdcall cudaMemcpyFromSymbol(ptr ptr long long long) wine_cudaMemcpyFromSymbol
@ stub cudaMemcpyToArray
@ stdcall cudaMemcpyToSymbol(ptr ptr long long long) wine_cudaMemcpyToSymbol
@ stub cudaMemset
@ stub cudaMemset2D
@ stub cudaMemset3D
@ stub cudaRegisterFatBinary
@ stdcall cudaSetDevice(long) wine_cudaSetDevice
@ stdcall cudaSetupArgument(ptr long long) wine_cudaSetupArgument
@ stub cudaStreamCreate
@ stub cudaStreamDestroy
@ stdcall cudaStreamQuery(ptr) wine_cudaStreamQuery
@ stub cudaStreamSynchronize
@ stub cudaThreadExit
@ stdcall cudaThreadSynchronize() wine_cudaThreadSynchronize
@ stub cudaUnbindTexture


Makefile:
Code: Select all
### Generated by Winemaker


SRCDIR                = .
SUBDIRS               =
DLLS                  = cudart.dll
EXES                  =



### Common settings

CEXTRA                =
CXXEXTRA              =
RCEXTRA               =
INCLUDE_PATH          = -I/usr/local/cuda/include
DLL_PATH              =
LIBRARY_PATH          = -L/usr/local/cuda/lib
LIBRARIES             = -lcudart
DEFINES               = -DUSE_SLEEPWAIT=300000    # 300 usecs seems to give reasonable results


### 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)
cudart_dll_DLL_PATH   =
cudart_dll_DLLS       = odbc32 \
        ole32 \
        oleaut32 \
        winspool
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 -m32
CXX = wineg++ -m32
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)

$(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%)
Last edited by shatteredsilicon on Tue Mar 03, 2009 12:14 am, edited 3 times in total.
Image
1x Q6600 @ 3.2GHz, 4GB DDR3-1333
1x Phenom X4 9950 @ 2.6GHz, 4GB DDR2-1066
3x GeForce 9800GX2
1x GeForce 8800GT
CentOS 5 x86-64, WINE 1.x with CUDA wrappers
shatteredsilicon
 
Posts: 699
Joined: Tue Jul 08, 2008 2:27 pm

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby dmearns » Mon Mar 02, 2009 9:53 pm

One of my Windows boxes just got a unit that requires Core 14 -- Project: 5900 (Run 8, Clone 21, Gen 1). I have a couple folders running under Linux, so I am getting a little anxious about finding the updated CUDA wrapper. Is it available for download anywhere yet? Has the delay been removed so that it requires the latest drivers? (I am still using rather old drivers since they seem to be working OK.) I started running GPU on Linux when the only option was to compile your own wrapper, so I would be very happy to see the source.

Thanks

- Dave
dmearns
 
Posts: 21
Joined: Tue Dec 04, 2007 5:29 pm
Location: Columbia MD USA

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby MtM » Mon Mar 02, 2009 9:59 pm

dmearns wrote:One of my Windows boxes just got a unit that requires Core 14 -- Project: 5900 (Run 8, Clone 21, Gen 1). I have a couple folders running under Linux, so I am getting a little anxious about finding the updated CUDA wrapper. Is it available for download anywhere yet? Has the delay been removed so that it requires the latest drivers? (I am still using rather old drivers since they seem to be working OK.) I started running GPU on Linux when the only option was to compile your own wrapper, so I would be very happy to see the source.

Thanks

- Dave


It should be posted here it seems :)

The beta testers reported no issues so I think it will show up soon, and when they do post the link you can ask them directly. I can't answer, as I didn't test it personally.
MtM
 
Posts: 3233
Joined: Fri Jun 27, 2008 2:20 pm
Location: The Netherlands

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby Hyperlife » Mon Mar 02, 2009 10:01 pm

Here it is. Sorry for the delay in getting this up.

If you use the second-generation wrapper with the delay:

http://www.hyperchronos.org/cudart.dll.so

If you use the first-generation wrapper without the delay:

http://www.hyperchronos.org/nodelay/cudart.dll.so

We now recommend that you install the wrapper directly in your WINE windows/system32 directory. Rename cudart.dll.so to cudart.dll and create a symlink to nvcuda.dll in the same directory.

I don't have the source here in front of me at the moment -- we should be able to post a link to it soon.

Remember to delete all previous wrappers and their symlinks from your system; they may be hiding in /usr/local/lib/wine if you followed the installation instructions on the GPU2 WINE wiki.

Edit: Source is now in the first post.
Last edited by Hyperlife on Tue Mar 03, 2009 5:10 pm, edited 1 time in total.
Image
User avatar
Hyperlife
 
Posts: 439
Joined: Sun Dec 02, 2007 7:38 am

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby dmearns » Mon Mar 02, 2009 10:20 pm

Thanks for the quick reply. I did have one LInux GPU folder go down because it got a new unit. I was able to get it going again by removing the advmethods option. I will be pushing out the new wrapper to the other folders.

- Dave
dmearns
 
Posts: 21
Joined: Tue Dec 04, 2007 5:29 pm
Location: Columbia MD USA

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby sydney » Mon Mar 16, 2009 7:59 pm

Can't get this to work, my friend suggested it was because I'm using 177 drivers instead of 180 drivers, but the problem is that 180 drivers don't work for me, probably because I'm running dual GPUs (same reason I'm still on 8.04 instead of 8.10).

Is there any way of avoiding fahcore_14? Or do I have to figure out a way to put 180 on my system?
Image
E8500 @ 4.0 GHz, 8800GTX @ 1500 shader, 8800GTS (G92) @ 1800 shader
Debian 5.0 Lenny with wine CUDA wrapper.
sydney
 
Posts: 17
Joined: Mon Mar 16, 2009 7:56 pm

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby shatteredsilicon » Tue Mar 17, 2009 9:02 am

I'm running 2x2+1 GPUs (2x9800GX2 + 8800GT) and 180.29 drivers work just fine.
shatteredsilicon
 
Posts: 699
Joined: Tue Jul 08, 2008 2:27 pm

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby sydney » Tue Mar 17, 2009 3:51 pm

shatteredsilicon wrote:I'm running 2x2+1 GPUs (2x9800GX2 + 8800GT) and 180.29 drivers work just fine.

Hmm, I wonder what's causing it then, I'll try doing a clean ubuntu install on another partition and see if that works.
sydney
 
Posts: 17
Joined: Mon Mar 16, 2009 7:56 pm

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby agauthier51 » Thu Apr 22, 2010 1:47 pm

Hello,

I just tried to compile this source in order to have a nvcuda.dll linked to cudart.so.3 rather than the current cudart.so.2 (current one works using a symlink to cudart.so.3). It compiles fine, ldd reports a correct use of cudart.so.3, but this new dll refuses to work.

I don't really know what I missed. Here are the compilation logs:

winegcc -m32 -c -I/usr/cuda/include -DUSE_SLEEPWAIT=300000 -o cudart.o cudart.c
In file included from /usr/cuda/include/cuda_runtime_api.h:53,
from cudart.h:1,
from cudart.c:2:
/usr/cuda/include/host_defines.h:57:1: warning: "__cdecl" redefined
<command-line>: warning: this is the location of the previous definition
winegcc -m32 -shared cudart.dll.spec -o cudart.dll.so cudart.o -L/usr/cuda/lib -lcudart -lodbc32 -lole32 -loleaut32 -lwinspool -luuid

Does anybody already tried to re-compile the wrapper for Cuda 3.0 ?

Regards,
Arnaud
agauthier51
 
Posts: 1
Joined: Thu Apr 22, 2010 1:36 pm

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby l12436 » Thu Aug 08, 2013 2:17 am

is there any update for the cuda wrapper?
l12436
 
Posts: 1
Joined: Thu Aug 08, 2013 2:11 am

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby Ivoshiee » Thu Aug 08, 2013 4:19 pm

Are there any greater need for it? There should be native support for that.
Ivoshiee
Site Moderator
 
Posts: 1384
Joined: Sun Dec 02, 2007 12:05 am
Location: Estonia

Re: New nVidia CUDA WINE Wrapper (v2.1) Imminent

Postby 7im » Thu Aug 08, 2013 4:37 pm

Folding on Fermi and Kepler GPUs is available in the latest V7.3.6 client in native Linux.
Please do not mistake my brevity as dispassion or condescension. I recognize the time you spend reading the forum is time you could use elsewhere, so my short responses save you time. Please do not hesitate to ask for clarification if I was too terse.
User avatar
7im
 
Posts: 13286
Joined: Thu Nov 29, 2007 4:30 pm
Location: Arizona


Return to unOfficial Linux GPU (WINE wrapper) (3rd party support)

Who is online

Users browsing this forum: No registered users and 0 guests