CAL Wrapper (Ready for Testing)

Moderators: slegrand, Site Moderators, PandeGroup

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Wed Jun 17, 2009 6:52 pm

I also cleaned up the source in amdcalrt.c a bit, and implemented some more of the functions (not sure if it is done correctly though):

amdcalrt.c
Code: Select all
/*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine
*/


#include <windef.h>

#include "cal.h"
#include "cal_ext.h"
#include "cal_ext_counter.h"
#include "calcl.h"

static PFNCALCTXCREATECOUNTER  calCtxCreateCounter;
static PFNCALCTXDESTROYCOUNTER calCtxDestroyCounter;
static PFNCALCTXBEGINCOUNTER   calCtxBeginCounter;
static PFNCALCTXENDCOUNTER     calCtxEndCounter;
static PFNCALCTXGETCOUNTER     calCtxGetCounter;

static PFNCALRESCREATE2D calResCreate2D;
static PFNCALRESCREATE1D calResCreate1D;


//##System Component
CALresult WINAPI wine_calInit() {
       /* CALresult res = calInit();
   if(res==CAL_RESULT_OK)
      printf("CALINIT: Successfully initialized\n");
   else
      printf("CALINIT: An error may have happened.\n");
   return res;*/
   return calInit();
}

CALresult WINAPI wine_calShutdown() {
        return calShutdown();
}

CALresult WINAPI wine_calGetVersion(CALuint* major, CALuint* minor, CALuint* imp) {
        return calGetVersion(major, minor, imp);
}

//##Device Management
CALresult WINAPI wine_calDeviceGetCount(CALuint* count) {
        return calDeviceGetCount(count);
}
CALresult WINAPI wine_calDeviceGetInfo(CALdeviceinfo* info, CALuint ordinal) {
   return calDeviceGetInfo(info, ordinal);
}
CALresult WINAPI wine_calDeviceGetAttribs(CALdeviceattribs* attribs, CALuint ordinal) {
   return calDeviceGetAttribs(attribs, ordinal);
}

CALresult WINAPI wine_calDeviceOpen(CALdevice* dev, CALuint ordinal) {
        return calDeviceOpen(dev, ordinal);
}

CALresult WINAPI wine_calDeviceGetStatus(CALdevicestatus* status, CALdevice dev) {
        return calDeviceGetStatus(status, dev);
}

CALresult WINAPI wine_calDeviceClose(CALdevice dev) {
        return calDeviceClose(dev);
}


//##Memory Management
CALresult WINAPI wine_calResAllocLocal2D(CALresource* res, CALdevice device, CALuint width, CALuint height, CALformat format, CALuint flags) {
        return calResAllocLocal2D(res, device, width, height, format, flags);
}

CALresult WINAPI wine_calResAllocRemote2D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALuint height, CALformat format, CALuint flags) {
        return calResAllocRemote2D(res, sharedDevices, deviceCount, width, height, format, flags);
}

CALresult WINAPI wine_calResAllocLocal1D(CALresource* res, CALdevice device, CALuint width, CALformat format, CALuint flags) {
        return calResAllocLocal1D(res, device, width, format, flags);
}

CALresult WINAPI wine_calResAllocRemote1D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALformat format, CALuint flags) {
        return calResAllocRemote1D(res, sharedDevices, deviceCount, width, format, flags);
}

CALresult WINAPI wine_calResFree(CALresource res) {
        return calResFree(res);
}

CALresult WINAPI wine_calResMap(CALvoid** pPtr, CALuint* pitch, CALresource res, CALuint flags) {
        return calResMap(pPtr, pitch, res, flags);
}

CALresult WINAPI wine_calResUnmap(CALresource res) {
        return calResUnmap(res);
}


//##Context Management
CALresult WINAPI wine_calCtxCreate(CALcontext* ctx, CALdevice dev) {
        return calCtxCreate(ctx, dev);
}

CALresult WINAPI wine_calCtxDestroy(CALcontext ctx) {
        return calCtxDestroy(ctx);
}

CALresult WINAPI wine_calCtxGetMem(CALmem* mem, CALcontext ctx, CALresource res) {
        return calCtxGetMem(mem, ctx, res);
}

CALresult WINAPI wine_calCtxReleaseMem(CALcontext ctx, CALmem mem) {
        return calCtxReleaseMem(ctx, mem);
}

CALresult WINAPI wine_calCtxSetMem(CALcontext ctx, CALname name, CALmem mem) {
        return calCtxSetMem(ctx, name, mem);
}


//##Loader

CALresult WINAPI wine_calModuleLoad(CALmodule* module, CALcontext ctx, CALimage image) {
   return calModuleLoad(module, ctx, image);
}

CALresult WINAPI wine_calModuleUnload(CALcontext ctx, CALmodule module) {
        return calModuleUnload(ctx, module);
}

CALresult WINAPI wine_calModuleGetEntry(CALfunc* func, CALcontext ctx, CALmodule module, const CALchar* procName) {
        return calModuleGetEntry(func, ctx, module, procName);
}

CALresult WINAPI wine_calModuleGetName(CALname* name, CALcontext ctx, CALmodule module, const CALchar* symbolName) {
        return calModuleGetName(name, ctx, module, symbolName);
}

CALresult WINAPI wine_calImageRead(CALimage* image, CALvoid* buffer, CALuint size){
   return calImageRead(image, buffer, size);
}

CALresult WINAPI wine_calImageFree(CALimage image) {
   return calImageFree(image);
}

CALresult WINAPI wine_calclImageWrite(CALvoid* buffer, CALuint size, CALimage image) {
   return calclImageWrite(buffer, size, image);
}


//##Computation
CALresult WINAPI wine_calCtxRunProgram(CALevent* event, CALcontext ctx, CALfunc func, const CALdomain* rect) {
        return calCtxRunProgram(event, ctx, func, rect);
}

CALresult WINAPI wine_calCtxRunProgramGrid(CALevent* event, CALcontext ctx, CALprogramGrid* pProgramGrid) {
        return calCtxRunProgramGrid(event, ctx, pProgramGrid);
}

CALresult WINAPI wine_calCtxRunProgramGridArray(CALevent* event, CALcontext ctx, CALprogramGridArray* pGridArray) {
        return calCtxRunProgramGridArray(event, ctx, pGridArray);
}

CALresult WINAPI wine_calModuleGetFuncInfo(CALfuncInfo* pInfo, CALcontext ctx, CALmodule module, CALfunc func) {
   return calModuleGetFuncInfo(pInfo, ctx, module, func);
}

CALresult WINAPI wine_calMemCopy(CALevent* event, CALcontext ctx, CALmem srcMem, CALmem dstMem, CALuint flags) {
        return calMemCopy(event, ctx, srcMem, dstMem, flags);
}

CALresult WINAPI wine_calCtxIsEventDone(CALcontext ctx, CALevent event) {
        return calCtxIsEventDone(ctx, event);
}

CALresult WINAPI wine_calCtxFlush(CALcontext ctx){
   return calCtxFlush(ctx);
}


//##Error Reporting
const CALchar* WINAPI wine_calGetErrorString() {
   return calGetErrorString();
}


//##Extension Functions
CALresult WINAPI wine_calExtSupported(CALextid extid){
   return calExtSupported(extid);
}

CALresult WINAPI wine_calExtGetVersion(CALuint* major,CALuint* minor, CALextid extid) {
        return calExtGetVersion(major, minor, extid);
}

CALresult WINAPI wine_calExtGetProc(CALextproc* proc, CALextid extid, const CALchar* procname) {
        return calExtGetProc(proc, extid, procname);
}


//##Counters
CALresult WINAPI wine_calCtxCreateCounter(CALcounter* counter, CALcontext ctx, CALcountertype type) {
        return calCtxCreateCounter(counter, ctx, type);
}

CALresult WINAPI wine_calCtxDestroyCounter(CALcontext ctx, CALcounter counter) {
        return calCtxDestroyCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxBeginCounter(CALcontext ctx, CALcounter counter) {
        return calCtxBeginCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxEndCounter(CALcontext ctx, CALcounter counter) {
        return calCtxEndCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxGetCounter(CALfloat* result, CALcontext ctx, CALcounter counter) {
        return calCtxGetCounter(result, ctx, counter);
}


//##User Resource Extensions
CALresult WINAPI wine_calResCreate2D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALuint height, CALformat format, CALuint size, CALuint flags) {
        return calResCreate2D(res, dev, mem, width, height, format, size, flags);
}

CALresult WINAPI wine_calResCreate1D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALformat format, CALuint size, CALuint flags) {
        return calResCreate1D(res, dev, mem, width, format, size, flags);
}

amdcalrt.dll.spec
Code: Select all
#*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine


##System Component
@  stdcall calInit() wine_calInit
@  stdcall calShutdown() wine_calShutdown
@  stdcall calGetVersion(ptr ptr ptr) wine_calGetVersion

##Device Management
@  stdcall calDeviceGetCount(ptr) wine_calDeviceGetCount
@  stdcall calDeviceGetInfo(ptr long) wine_calDeviceGetInfo      #Not in the Platform API doc
@  stdcall calDeviceGetAttribs(ptr long) wine_calDeviceGetAttribs
@  stdcall calDeviceOpen(ptr long) wine_calDeviceOpen
@  stdcall calDeviceGetStatus(ptr long) wine_calDeviceGetStatus
@  stdcall calDeviceClose(long) wine_calDeviceClose

##Memory Management
@  stdcall calResAllocLocal2D(ptr long long long long long) wine_calResAllocLocal2D
@  stdcall calResAllocRemote2D(ptr ptr long long long long long) wine_calResAllocRemote2D
@  stdcall calResAllocLocal1D(ptr long long long long) wine_calResAllocLocal1D
@  stdcall calResAllocRemote1D(ptr ptr long long long long) wine_calResAllocRemote1D
@  stdcall calResFree(long) wine_calResFree
@  stdcall calResMap(ptr ptr long long) wine_calResMap
@  stdcall calResUnmap(long) wine_calResUnmap

##Context Management
@  stdcall calCtxCreate(ptr long) wine_calCtxCreate
@  stdcall calCtxDestroy(long) wine_calCtxDestroy
@  stdcall calCtxGetMem(ptr long long) wine_calCtxGetMem
@  stdcall calCtxReleaseMem(long long) wine_calCtxReleaseMem
@  stdcall calCtxSetMem(long long long) wine_calCtxSetMem

##Loader
@  stdcall calModuleLoad(ptr long long) wine_calModuleLoad
@  stdcall calModuleUnload(long long) wine_calModuleUnload
@  stdcall calModuleGetEntry(ptr long long ptr) wine_calModuleGetEntry
@  stdcall calModuleGetName(ptr long long ptr) wine_calModuleGetName
@  stdcall calImageRead(ptr ptr long) wine_calImageRead
@  stdcall calImageFree(long) wine_calImageFree      #Not in the Platform API doc
@  stdcall calclImageWrite(ptr ptr long) wine_calclImageWrite

##Computation
@  stdcall calCtxRunProgram(ptr long long ptr) wine_calCtxRunProgram
@  stdcall calCtxRunProgramGrid(ptr long ptr) wine_calCtxRunProgramGrid
@  stdcall calCtxRunProgramGridArray(ptr long ptr) wine_calCtxRunProgramGridArray
@  stdcall calModuleGetFuncInfo(ptr long long long) wine_calModuleGetFuncInfo
@  stdcall calMemCopy(ptr long long long long) wine_calMemCopy
@  stdcall calCtxIsEventDone(long long) wine_calCtxIsEventDone
@  stdcall calCtxFlush(long) wine_calCtxFlush

##Error Reporting
@  stdcall calGetErrorString() wine_calGetErrorString


##Extension Functions
@  stdcall calExtSupported(long) wine_calExtSupported
@  stdcall calExtGetVersion(ptr ptr long) wine_calExtGetVersion
@  stdcall calExtGetProc(ptr long ptr) wine_calExtGetProc


##Counters
@  stdcall calCtxCreateCounter(ptr long long) wine_calCtxCreateCounter
@  stdcall calCtxDestroyCounter(long long) wine_calCtxDestroyCounter
@  stdcall calCtxBeginCounter(long long) wine_calCtxBeginCounter
@  stdcall calCtxEndCounter(long long) wine_calCtxEndCounter
@  stdcall calCtxGetCounter(ptr long long) wine_calCtxGetCounter

##User Resource Extensions
@  stdcall calResCreate2D(ptr long ptr long long long long long) wine_calResCreate2D
@  stdcall calResCreate1D(ptr long ptr long long long long) wine_calResCreate1D


##Not in the Platform API doc
#@  stub    calCtxRunProgramParams   
#@  stub    calLoadBinary
#@  stub    calLoadLibrary


Hmm, just spotted an error in the spec file: The counters and calResCreate1D/2D were commented out. I'll correct that and update if it makes any difference.

EDIT: Yeah, it made no difference. :(
Time flies like an arrow; fruit flies like a banana
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby Shelnutt2 » Wed Jun 17, 2009 9:25 pm

I've updated my code to match yours, however I can't get amdcalrt to compile. It says it
Code: Select all
amdcalrt.o: In function `wine_calclImageWrite':
amdcalrt.c:(.text+0x572): undefined reference to `calclImageWrite'


How were you able to compile it? Did you modify the make file? I have it linking to the headers in the /usr/local/atical/include folder. Is there another header to include? I'm about to post this up on the wine dev list and see if they can help us shed some light on the issue, but I need to make sure it compiles first.
OCforums, T32

Linux Lober!
Shelnutt2
 
Posts: 150
Joined: Sun Dec 02, 2007 5:37 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Thu Jun 18, 2009 1:03 pm

Yes, I forgot about that. I changed the makefile. The last option under "Common settings" now says
Code: Select all
LIBRARIES             = -laticalrt -laticalcl

because calclImageWrite is in libaticalcl.so.
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Thu Jun 18, 2009 7:46 pm

Actually, most of the sample binaries for windows work now. The compute shader ones don't (for example bursting_CS.exe).

I added some tracing. Clearly an error happened here (near the end):
Code: Select all
anachron@supercomputer ~/.wine/drive_c/Program Files/folding-gpu $ WINEDEBUG=trace+cal wine fah6-gpu.exe

Note: Please read the license agreement (fah6-gpu.exe -license). Further
use of this software requires that you have read and accepted this agreement.



--- Opening Log file [June 18 19:29:35 UTC]


# Windows GPU Console Edition #################################################
###############################################################################

                       Folding@Home Client Version 6.23

                          http://folding.stanford.edu

###############################################################################
###############################################################################

Launch directory: C:\Program Files\folding-gpu
Executable: C:\Program Files\folding-gpu\fah6-gpu.exe
Arguments: -oneunit -verbosity 9 -forcegpu ati_r700

[19:29:35] - Ask before connecting: Yes
[19:29:35] - User name: Bjornar (Team 31574)
[19:29:35] - User ID: 2EC0534E5D7AA47F
[19:29:35] - Machine ID: 2
[19:29:35]
[19:29:35] Loaded queue successfully.
[19:29:35] - Autosending finished units... [June 18 19:29:35 UTC]
[19:29:35] Trying to send all finished work units
[19:29:35] + No unsent completed units remaining.
[19:29:35] - Autosend completed
[19:29:35]
[19:29:35] + Processing work unit
[19:29:35] Core required: FahCore_11.exe
[19:29:35] Core found.
[19:29:35] Working on queue slot 02 [June 18 19:29:35 UTC]
[19:29:35] + Working ...
[19:29:35] - Calling '.\FahCore_11.exe -dir work/ -suffix 02 -checkpoint 15 -verbose -lifeline 8 -version 623'

[19:29:35]
[19:29:35] *------------------------------*
[19:29:35] Folding@Home GPU Core - Beta
[19:29:35] Version 1.24 (Mon Feb 9 11:00:12 PST 2009)
[19:29:35]
[19:29:35] Compiler  : Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.762 for 80x86
[19:29:35] Build host: amoeba
[19:29:35] Board Type: AMD
[19:29:35] Core      :
[19:29:35] Preparing to commence simulation
[19:29:35] - Looking at optimizations...
[19:29:35] - Files status OK
[19:29:35] - Expanded 68563 -> 357580 (decompressed 521.5 percent)
[19:29:35] Called DecompressByteArray: compressed_data_size=68563 data_size=357580, decompressed_data_size=357580 diff=0
[19:29:35] - Digital signature verified
[19:29:35]
[19:29:35] Project: 5746 (Run 4, Clone 20, Gen 256)
[19:29:35]
[19:29:35] Assembly optimizations on if available.
[19:29:35] Entering M.D.
Reading file work/wudata_02.tpr, VERSION 3.1.4 (single precision)
Reading file work/wudata_02.tpr, VERSION 3.1.4 (single precision)
Reading sasa-enabled ir 0 0
Issues between syncs set at 16
In override calInit
calLoadBinary
trace:cal:wine_calGetVersion 1, 2076394815, 8716308
CAL version: 1.4.283
trace:cal:wine_calDeviceGetCount 0
CAL: 1 devices found
trace:cal:wine_calDeviceGetInfo 0x8d1848, 0
ASIC = RV770
Available board memory to CAL: 512MB
Available cached memory to CAL: 60MB
Available uncached memory to CAL: 1886MB
Engine clock: 0 (0.000000)
Natural vector width: 64
Recommended minimum thread count: 2560
Brook yield: 0
Don't flush kernels: 0
Pre flush command buffers: 0
Flush interval: 16
[19:29:41] Will resume from checkpoint file
[19:29:41] Tpr hash work/wudata_02.tpr:  2639730865 4031526054 2357533253 3358095351 301830008
starting mdrun 'Protein'
10000000 steps,  20000.0 ps.

trace:cal:wine_calCtxIsEventDone 536870912, 2684354560
trace:cal:wine_calCtxIsEventDone 8, An asynchronous operation is still pending
trace:cal:wine_calCtxIsEventDone 536870912, 2684354560
trace:cal:wine_calCtxIsEventDone 536870912, 2684354560
trace:cal:wine_calCtxIsEventDone 536870912, 2684354561
trace:cal:wine_calCtxIsEventDone 8, An asynchronous operation is still pending
trace:cal:wine_calCtxIsEventDone 536870912, 2684354561
trace:cal:wine_calCtxIsEventDone 536870912, 2684354561
trace:cal:wine_calCtxIsEventDone 536870912, 2684354562
trace:cal:wine_calCtxIsEventDone 8, An asynchronous operation is still pending
trace:cal:wine_calCtxIsEventDone 536870912, 2684354562
trace:cal:wine_calCtxIsEventDone 536870912, 2684354562
trace:cal:wine_calCtxIsEventDone 536870912, 2684354563
trace:cal:wine_calCtxIsEventDone 8, An asynchronous operation is still pending
trace:cal:wine_calCtxIsEventDone 536870912, 2684354563
trace:cal:wine_calCtxIsEventDone 536870912, 2684354563
Calculated RepFac: 12 minSuggestedThreads=2560
Setting RepFac: 12
nbp->PForceStrWidth: 64, gpu->AtomStrSize: 992 nbp->RepFac: 12 gpu->iUnroll: 4, nbp->PForceStrSize: 2976, nbp->PForceStrHeight: 47
trace:cal:wine_calCtxIsEventDone 536870912, 2684354564
(...)
trace:cal:wine_calCtxIsEventDone 536870912, 2684354600
trace:cal:wine_calCtxIsEventDone 8, An asynchronous operation is still pending
trace:cal:wine_calCtxIsEventDone 536870912, 2684354600
trace:cal:wine_calCtxIsEventDone 8, An asynchronous operation is still pending
trace:cal:wine_calCtxIsEventDone 536870912, 2684354600
trace:cal:wine_calCtxIsEventDone 536870912, 2684354600
trace:cal:wine_calModuleGetName 0xc5a2b8, 536870912, 2147483650, cb0
trace:cal:wine_calModuleGetName 0xc5a2b8, 536870912, 2147483650, o0
trace:cal:wine_calModuleGetName 0xc5a2b8, 536870912, 2147483650, o1
trace:cal:wine_calModuleGetName 0xc5a2b8, 536870912, 2147483650, o2
trace:cal:wine_calModuleGetName 0xc5a2b8, 536870912, 2147483650, o3
trace:cal:wine_calModuleGetName 0xc5a2d0, 536870912, 2147483650, i0
trace:cal:wine_calModuleGetName 0xc5a2d0, 536870912, 2147483650, i1
trace:cal:wine_calModuleGetName 0xc5a2d0, 536870912, 2147483650, i2
trace:cal:wine_calModuleGetName 0xc5a2d0, 536870912, 2147483650, i3
trace:cal:wine_calModuleGetName 0xc5a2d0, 536870912, 2147483650, i4
trace:cal:wine_calModuleGetEntry 0xc5a2b0, 536870912, 2147483650, main
trace:cal:wine_calCtxIsEventDone 14650824, 1342177282
trace:cal:wine_calCtxIsEventDone 6, A handle parameter is invalid
Run: exception thrown during GuardedRun
[19:29:42] Working on Protein
[19:29:42] Client config found, loading data.
[19:29:42] Starting GUI Server
[19:29:42] Run: exception thrown during GuardedRun
[19:29:42] Run: exception thrown in GuardedRun -- Gromacs cannot continue further.
[19:29:42] Going to send back what have done -- stepsTotalG=10000000
[19:29:42] Work fraction=0.0000 steps=10000000.

It may be necessary to add more tracing to pinpoint it exactly.
Also, I don't understand how the handle parameter broke.

amdcalrt.c:
Code: Select all
/*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine
*/


#include <windef.h>
#include <stdio.h> 

#include "cal.h"
#include "cal_ext.h"
#include "cal_ext_counter.h"
#include "calcl.h"

#include "wine/debug.h"

static PFNCALCTXCREATECOUNTER  calCtxCreateCounter;
static PFNCALCTXDESTROYCOUNTER calCtxDestroyCounter;
static PFNCALCTXBEGINCOUNTER   calCtxBeginCounter;
static PFNCALCTXENDCOUNTER     calCtxEndCounter;
static PFNCALCTXGETCOUNTER     calCtxGetCounter;

static PFNCALRESCREATE2D calResCreate2D;
static PFNCALRESCREATE1D calResCreate1D;


WINE_DEFAULT_DEBUG_CHANNEL(cal);



//##System Component
CALresult WINAPI wine_calInit() {
   //WINE_TRACE("(%d, %s)\n");
   return calInit();
}

CALresult WINAPI wine_calShutdown() {
   //WINE_TRACE("(%d, %s)\n");
        return calShutdown();
}

CALresult WINAPI wine_calGetVersion(CALuint* major, CALuint* minor, CALuint* imp) {
   WINE_TRACE("%u, %u, %u\n", *major, *minor, *imp);
        return calGetVersion(major, minor, imp);
}

//##Device Management
CALresult WINAPI wine_calDeviceGetCount(CALuint* count) {
   WINE_TRACE("%u\n", *count);
        return calDeviceGetCount(count);
}
CALresult WINAPI wine_calDeviceGetInfo(CALdeviceinfo* info, CALuint ordinal) {
   WINE_TRACE("%p, %d\n", info, ordinal);
   return calDeviceGetInfo(info, ordinal);
}
CALresult WINAPI wine_calDeviceGetAttribs(CALdeviceattribs* attribs, CALuint ordinal) {
   //WINE_TRACE("(%d, %s)\n", attribs, ordinal);
   return calDeviceGetAttribs(attribs, ordinal);
}

CALresult WINAPI wine_calDeviceOpen(CALdevice* dev, CALuint ordinal) {
   //WINE_TRACE("(%d, %s)\n",dev,ordinal);
        return calDeviceOpen(dev, ordinal);
}

CALresult WINAPI wine_calDeviceGetStatus(CALdevicestatus* status, CALdevice dev) {
   //WINE_TRACE("(%d, %s)\n",status,dev);
        return calDeviceGetStatus(status, dev);
}

CALresult WINAPI wine_calDeviceClose(CALdevice dev) {
   //WINE_TRACE("(%d, %s)\n",dev);
        return calDeviceClose(dev);
}


//##Memory Management
CALresult WINAPI wine_calResAllocLocal2D(CALresource* res, CALdevice device, CALuint width, CALuint height, CALformat format, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n",res, device, width, height, format, flags);
        return calResAllocLocal2D(res, device, width, height, format, flags);
}

CALresult WINAPI wine_calResAllocRemote2D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALuint height, CALformat format, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n",res, sharedDevices, deviceCount, width, height, format, flags);
        return calResAllocRemote2D(res, sharedDevices, deviceCount, width, height, format, flags);
}

CALresult WINAPI wine_calResAllocLocal1D(CALresource* res, CALdevice device, CALuint width, CALformat format, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n",res, device, width, format, flags);
        return calResAllocLocal1D(res, device, width, format, flags);
}

CALresult WINAPI wine_calResAllocRemote1D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALformat format, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n",res, sharedDevices, deviceCount, width, format, flags);
        return calResAllocRemote1D(res, sharedDevices, deviceCount, width, format, flags);
}

CALresult WINAPI wine_calResFree(CALresource res) {
   //WINE_TRACE("(%d, %s)\n",res);
        return calResFree(res);
}

CALresult WINAPI wine_calResMap(CALvoid** pPtr, CALuint* pitch, CALresource res, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n",pPtr, pitch, res, flags);
        return calResMap(pPtr, pitch, res, flags);
}

CALresult WINAPI wine_calResUnmap(CALresource res) {
   //WINE_TRACE("(%d, %s)\n",res);
         return calResUnmap(res);
}


//##Context Management
CALresult WINAPI wine_calCtxCreate(CALcontext* ctx, CALdevice dev) {
   //WINE_TRACE("(%d, %s)\n"/*,ctx, dev*/);
        return calCtxCreate(ctx, dev);
}

CALresult WINAPI wine_calCtxDestroy(CALcontext ctx) {
   //WINE_TRACE("(%d, %s)\n",ctx);
        return calCtxDestroy(ctx);
}

CALresult WINAPI wine_calCtxGetMem(CALmem* mem, CALcontext ctx, CALresource res) {
   //WINE_TRACE("(%d, %s)\n",mem,ctx,res);
        return calCtxGetMem(mem, ctx, res);
}

CALresult WINAPI wine_calCtxReleaseMem(CALcontext ctx, CALmem mem) {
   //WINE_TRACE("(%d, %s)\n",ctx, mem);
        return calCtxReleaseMem(ctx, mem);
}

CALresult WINAPI wine_calCtxSetMem(CALcontext ctx, CALname name, CALmem mem) {
   //WINE_TRACE("(%d, %s)\n",ctx, name, mem);
        return calCtxSetMem(ctx, name, mem);
}


//##Loader

CALresult WINAPI wine_calModuleLoad(CALmodule* module, CALcontext ctx, CALimage image) {
   //WINE_TRACE("(%d, %s)\n",module, ctx, image);
   return calModuleLoad(module, ctx, image);
}

CALresult WINAPI wine_calModuleUnload(CALcontext ctx, CALmodule module) {
   //WINE_TRACE("(%d, %s)\n",ctx,module);
        return calModuleUnload(ctx, module);
}

CALresult WINAPI wine_calModuleGetEntry(CALfunc* func, CALcontext ctx, CALmodule module, const CALchar* procName) {
   WINE_TRACE("%p, %u, %u, %s\n", func, ctx, module, procName);   
   CALresult res = calModuleGetEntry(func, ctx, module, procName);
   if (res != CAL_RESULT_OK){
      WINE_TRACE("%d, %s\n", res, calGetErrorString());
   }
        return res;
}

CALresult WINAPI wine_calModuleGetName(CALname* name, CALcontext ctx, CALmodule module, const CALchar* symbolName) {
   WINE_TRACE("%p, %u, %u, %s\n", name, ctx, module, symbolName);
   CALresult res = calModuleGetName(name, ctx, module, symbolName);
   if (res != CAL_RESULT_OK){
      WINE_TRACE("%d, %s\n", res, calGetErrorString());
   }
        return res;
}

CALresult WINAPI wine_calImageRead(CALimage* image, CALvoid* buffer, CALuint size){
   //WINE_TRACE("(%d, %s)\n",image, buffer, size);
   return calImageRead(image, buffer, size);
}

CALresult WINAPI wine_calImageFree(CALimage image) {
   //WINE_TRACE("(%d, %s)\n",image);
   return calImageFree(image);
}

CALresult WINAPI wine_calclImageWrite(CALvoid* buffer, CALuint size, CALimage image) {
   //WINE_TRACE("(%d, %s)\n",buffer, size, image);
   return calclImageWrite(buffer, size, image);
}


//##Computation
CALresult WINAPI wine_calCtxRunProgram(CALevent* event, CALcontext ctx, CALfunc func, const CALdomain* rect) {
   //WINE_TRACE("(%d, %s)\n",event, ctx, func, rect);
        return calCtxRunProgram(event, ctx, func, rect);
}

CALresult WINAPI wine_calCtxRunProgramGrid(CALevent* event, CALcontext ctx, CALprogramGrid* pProgramGrid) {
   //WINE_TRACE("(%d, %s)\n",event, ctx, pProgramGrid);
        return calCtxRunProgramGrid(event, ctx, pProgramGrid);
}

CALresult WINAPI wine_calCtxRunProgramGridArray(CALevent* event, CALcontext ctx, CALprogramGridArray* pGridArray) {
   //WINE_TRACE("(%d, %s)\n",event, ctx, pGridArray);
        return calCtxRunProgramGridArray(event, ctx, pGridArray);
}

CALresult WINAPI wine_calModuleGetFuncInfo(CALfuncInfo* pInfo, CALcontext ctx, CALmodule module, CALfunc func) {
   //WINE_TRACE("(%d, %s)\n",pInfo, ctx, module, func);
   return calModuleGetFuncInfo(pInfo, ctx, module, func);
}

CALresult WINAPI wine_calMemCopy(CALevent* event, CALcontext ctx, CALmem srcMem, CALmem dstMem, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n", event, ctx, srcMem, dstMem, flags);
        return calMemCopy(event, ctx, srcMem, dstMem, flags);
}

CALresult WINAPI wine_calCtxIsEventDone(CALcontext ctx, CALevent event) {
   WINE_TRACE("%u, %u\n", ctx, event);
   CALresult res = calCtxIsEventDone(ctx, event);
   if (res != CAL_RESULT_OK){
      WINE_TRACE("%d, %s\n", res, calGetErrorString());
   }
        return res;
}

CALresult WINAPI wine_calCtxFlush(CALcontext ctx){
   //WINE_TRACE("(%d, %s)\n", ctx);
   return calCtxFlush(ctx);
}


//##Error Reporting
const CALchar* WINAPI wine_calGetErrorString() {
   //WINE_TRACE("(%d, %s)\n\n");
   return calGetErrorString();
}


//##Extension Functions
CALresult WINAPI wine_calExtSupported(CALextid extid){
   //WINE_TRACE("(%d, %s)\n",extid);
   return calExtSupported(extid);
}

CALresult WINAPI wine_calExtGetVersion(CALuint* major,CALuint* minor, CALextid extid) {
   //WINE_TRACE("(%d, %s)\n",major, minor, extid);
        return calExtGetVersion(major, minor, extid);
}

CALresult WINAPI wine_calExtGetProc(CALextproc* proc, CALextid extid, const CALchar* procname) {
   //WINE_TRACE("(%d, %s)\n", proc, extid, procname);
   return calExtGetProc(proc, extid, procname);
}


//##Counters
CALresult WINAPI wine_calCtxCreateCounter(CALcounter* counter, CALcontext ctx, CALcountertype type) {
   //WINE_TRACE("(%d, %s)\n", counter, ctx, type);
   return calCtxCreateCounter(counter, ctx, type);
}

CALresult WINAPI wine_calCtxDestroyCounter(CALcontext ctx, CALcounter counter) {
   //WINE_TRACE("(%d, %s)\n", ctx, counter);;
        return calCtxDestroyCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxBeginCounter(CALcontext ctx, CALcounter counter) {
   //WINE_TRACE("(%d, %s)\n", ctx, counter);
        return calCtxBeginCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxEndCounter(CALcontext ctx, CALcounter counter) {
   //WINE_TRACE("(%d, %s)\n", ctx, counter);
        return calCtxEndCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxGetCounter(CALfloat* result, CALcontext ctx, CALcounter counter) {
    //WINE_TRACE("(%d, %s)\n", result, ctx, counter);
   return calCtxGetCounter(result, ctx, counter);
}


//##User Resource Extensions
CALresult WINAPI wine_calResCreate2D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALuint height, CALformat format, CALuint size, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n", res, dev, mem, width, height, format, size, flags);
        return calResCreate2D(res, dev, mem, width, height, format, size, flags);
}

CALresult WINAPI wine_calResCreate1D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALformat format, CALuint size, CALuint flags) {
   //WINE_TRACE("(%d, %s)\n", res, dev, mem, width, format, size, flags);

        return calResCreate1D(res, dev, mem, width, format, size, flags);
}
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby toTOW » Thu Jun 18, 2009 10:30 pm

I've been wondering : is fahcore using aticaldd.dll ? In windows/system32, there are 3 "cal" DLLs :

aticaldd.dll
aticalcl.dll
aticalrt.dll

We're always talking about RT and CL ... but as you can see in "Experimental package" I provided to solve VPU Recover, the 3 DLLs are included : viewtopic.php?f=51&t=9737 ...
Folding@Home beta tester since 2002. Folding Forum moderator since July 2008.

FAH-Addict : latest news, tests and reviews about Folding@Home project.

Image
User avatar
toTOW
Site Moderator
 
Posts: 8859
Joined: Sun Dec 02, 2007 10:38 am
Location: Bordeaux, France

Re: CAL Wrapper (Ready for Testing)

Postby mhouston » Thu Jun 18, 2009 10:34 pm

Ah, the folding@home code uses some extensions, so the extension access calls will need to work... It could be the extension loading is failing for some reason...
mhouston
 
Posts: 915
Joined: Sun Dec 02, 2007 8:19 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Thu Jun 18, 2009 10:51 pm

toTow:
I think a combination of aticaldd.dll, aticalcl.dll and aticalrt.dll is just one way they have compiled the libraries. They can also compile them so they only get aticalcl.dll and aticalrt.dll.

If you look at the file sizes, the pair of dll's that come with the client as standard is about the same size as the three dll's in your experimental package.

They just distribute the functions differently in the dll's.

However, I have almost no knowledge of how libraries work, so I could be completely off track here ;)
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Fri Jun 19, 2009 7:45 pm

I'm going away on holiday for the next two weeks, and I won't be able to test anything during this time.
Edit: I'm back.

I've added tracing on all functions in amdcalrt.c.
Code: Select all
/*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine
*/

#include <windef.h>
#include <stdio.h> 

#include "cal.h"
#include "cal_ext.h"
#include "cal_ext_counter.h"
#include "calcl.h"

#include "wine/debug.h"

static PFNCALCTXCREATECOUNTER  calCtxCreateCounter;
static PFNCALCTXDESTROYCOUNTER calCtxDestroyCounter;
static PFNCALCTXBEGINCOUNTER   calCtxBeginCounter;
static PFNCALCTXENDCOUNTER     calCtxEndCounter;
static PFNCALCTXGETCOUNTER     calCtxGetCounter;

static PFNCALRESCREATE2D calResCreate2D;
static PFNCALRESCREATE1D calResCreate1D;

static PFNCALCTXRUNPROGRAMPARAMS calCtxRunProgramParams;

WINE_DEFAULT_DEBUG_CHANNEL(cal);


//##System Component
CALresult WINAPI wine_calInit() {
   CALresult result = calInit();
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%d, %s\n", result, calGetErrorString());
   }
   else {
      WINE_TRACE("%s\n", "OK");   
   }
        return result;

}

CALresult WINAPI wine_calShutdown() {
   CALresult result = calShutdown();
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%d, %s\n", result, calGetErrorString());
   }
   else {
      WINE_TRACE("%s\n", "OK");   
   }
        return result;
}

CALresult WINAPI wine_calGetVersion(CALuint* major, CALuint* minor, CALuint* imp) {
   CALresult result = calGetVersion(major, minor, imp);
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %u, %d, %s\n", *major, *minor, *imp, result, calGetErrorString());
   }
   else {
      WINE_TRACE("%u, %u, %u\n", *major, *minor, *imp);   
   }
        return result;
}

//##Device Management
CALresult WINAPI wine_calDeviceGetCount(CALuint* count) {

   CALresult result = calDeviceGetCount(count);
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%u, %d, %s\n", *count, result, calGetErrorString());
   }
   else {
      WINE_TRACE("%u\n", *count);   
   }
        return result;

}
CALresult WINAPI wine_calDeviceGetInfo(CALdeviceinfo* info, CALuint ordinal) {
   WINE_TRACE("%p, %d\n", info, ordinal);
   return calDeviceGetInfo(info, ordinal);
}
CALresult WINAPI wine_calDeviceGetAttribs(CALdeviceattribs* attribs, CALuint ordinal) {
   WINE_TRACE("%p, %u\n", attribs, ordinal);
   return calDeviceGetAttribs(attribs, ordinal);
}

CALresult WINAPI wine_calDeviceOpen(CALdevice* dev, CALuint ordinal) {
   WINE_TRACE("%u, %u\n",*dev,ordinal);
        return calDeviceOpen(dev, ordinal);
}

CALresult WINAPI wine_calDeviceGetStatus(CALdevicestatus* status, CALdevice dev) {
   WINE_TRACE("%p, %u\n",status,dev);
        return calDeviceGetStatus(status, dev);
}

CALresult WINAPI wine_calDeviceClose(CALdevice dev) {
   WINE_TRACE("%u\n",dev);
        return calDeviceClose(dev);
}


//##Memory Management
CALresult WINAPI wine_calResAllocLocal2D(CALresource* res, CALdevice device, CALuint width, CALuint height, CALformat format, CALuint flags) {
   CALresult result = calResAllocLocal2D(res, device, width, height, format, flags);
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %u, %u, %u, %u, %d, %s\n", *res, device, width, height, format, flags, result, calGetErrorString());
   }
   else {
      WINE_TRACE("%u, %u, %u, %u, %u, %u\n", *res, device, width, height, format, flags);   
   }
        return result;

}

CALresult WINAPI wine_calResAllocRemote2D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALuint height, CALformat format, CALuint flags) {
   WINE_TRACE("%u, %u, %u, %u, %u, %u, %u\n", *res, *sharedDevices, deviceCount, width, height, format, flags);
        return calResAllocRemote2D(res, sharedDevices, deviceCount, width, height, format, flags);
}

CALresult WINAPI wine_calResAllocLocal1D(CALresource* res, CALdevice device, CALuint width, CALformat format, CALuint flags) {
   WINE_TRACE("%u, %u, %u, %u, %u\n",*res, device, width, format, flags);
        return calResAllocLocal1D(res, device, width, format, flags);
}

CALresult WINAPI wine_calResAllocRemote1D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALformat format, CALuint flags) {
   WINE_TRACE("%u, %u, %u, %u, %u, %u\n",*res, *sharedDevices, deviceCount, width, format, flags);
        return calResAllocRemote1D(res, sharedDevices, deviceCount, width, format, flags);
}

CALresult WINAPI wine_calResFree(CALresource res) {
   WINE_TRACE("%u\n",res);
        return calResFree(res);
}

CALresult WINAPI wine_calResMap(CALvoid** pPtr, CALuint* pitch, CALresource res, CALuint flags) {
   WINE_TRACE("%p, %u, %u ,%u\n",*pPtr, *pitch, res, flags);
        return calResMap(pPtr, pitch, res, flags);
}

CALresult WINAPI wine_calResUnmap(CALresource res) {
   WINE_TRACE("%u\n",res);
         return calResUnmap(res);
}


//##Context Management
CALresult WINAPI wine_calCtxCreate(CALcontext* ctx, CALdevice dev) {
   CALresult result = calCtxCreate(ctx, dev);
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %u, %s\n", *ctx, dev, result, calGetErrorString());
   }
   else {
      WINE_TRACE("%u, %u\n", *ctx, dev);
   }
        return result;
}

CALresult WINAPI wine_calCtxDestroy(CALcontext ctx) {
   CALresult result = calCtxDestroy(ctx);
   if (result != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %s\n", ctx, result, calGetErrorString());
   }
   else {
      WINE_TRACE("%u\n", ctx);
   }
        return result;
}

CALresult WINAPI wine_calCtxGetMem(CALmem* mem, CALcontext ctx, CALresource res) {
   WINE_TRACE("%u, %u, %u\n", *mem, ctx, res);
        return calCtxGetMem(mem, ctx, res);
}

CALresult WINAPI wine_calCtxReleaseMem(CALcontext ctx, CALmem mem) {
   WINE_TRACE("%u, %u\n",ctx, mem);
        return calCtxReleaseMem(ctx, mem);
}

CALresult WINAPI wine_calCtxSetMem(CALcontext ctx, CALname name, CALmem mem) {
   WINE_TRACE("%u, %u, %u\n",ctx, name, mem);
        return calCtxSetMem(ctx, name, mem);
}


//##Loader

CALresult WINAPI wine_calModuleLoad(CALmodule* module, CALcontext ctx, CALimage image) {
   WINE_TRACE("%u, %u, %p\n", *module, ctx, image);
   return calModuleLoad(module, ctx, image);
}

CALresult WINAPI wine_calModuleUnload(CALcontext ctx, CALmodule module) {
   WINE_TRACE("%u, %u\n", ctx, module);
        return calModuleUnload(ctx, module);
}

CALresult WINAPI wine_calModuleGetEntry(CALfunc* func, CALcontext ctx, CALmodule module, const CALchar* procName) {
   CALresult res = calModuleGetEntry(func, ctx, module, procName);
   if (res != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %u, %s, %d, %s\n", *func, ctx, module, procName, res, calGetErrorString());
   }
   else {
      WINE_TRACE("%u, %u, %u, %s\n", *func, ctx, module, procName);   
   }
        return res;
}

CALresult WINAPI wine_calModuleGetName(CALname* name, CALcontext ctx, CALmodule module, const CALchar* symbolName) {
   CALresult res = calModuleGetName(name, ctx, module, symbolName);
   if (res != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %u, %s, %d, %s\n", *name, ctx, module, symbolName, res, calGetErrorString());
   }
   else {
      WINE_TRACE("%u, %u, %u, %s\n", *name, ctx, module, symbolName);
   }
        return res;
}

CALresult WINAPI wine_calImageRead(CALimage* image, CALvoid* buffer, CALuint size){
   WINE_TRACE("%p, %p, %u\n",image, buffer, size);
   return calImageRead(image, buffer, size);
}

CALresult WINAPI wine_calImageFree(CALimage image) {
   WINE_TRACE("%p\n",image);
   return calImageFree(image);
}

CALresult WINAPI wine_calclImageWrite(CALvoid* buffer, CALuint size, CALimage image) {
   WINE_TRACE("%p, %u, %p\n", buffer, size, image);
   return calclImageWrite(buffer, size, image);
}


//##Computation
CALresult WINAPI wine_calCtxRunProgram(CALevent* event, CALcontext ctx, CALfunc func, const CALdomain* rect) {
   WINE_TRACE("%u, %u, %u, %p\n",*event, ctx, func, rect);
        return calCtxRunProgram(event, ctx, func, rect);
}

CALresult WINAPI wine_calCtxRunProgramGrid(CALevent* event, CALcontext ctx, CALprogramGrid* pProgramGrid) {
   WINE_TRACE("%u, %u, %p\n", *event, ctx, pProgramGrid);
        return calCtxRunProgramGrid(event, ctx, pProgramGrid);
}

CALresult WINAPI wine_calCtxRunProgramGridArray(CALevent* event, CALcontext ctx, CALprogramGridArray* pGridArray) {
   WINE_TRACE("%u, %u, %p\n", *event, ctx, pGridArray);
        return calCtxRunProgramGridArray(event, ctx, pGridArray);
}

CALresult WINAPI wine_calModuleGetFuncInfo(CALfuncInfo* pInfo, CALcontext ctx, CALmodule module, CALfunc func) {
   WINE_TRACE("%p, %u, %u, %u\n", pInfo, ctx, module, func);
   return calModuleGetFuncInfo(pInfo, ctx, module, func);
}

CALresult WINAPI wine_calMemCopy(CALevent* event, CALcontext ctx, CALmem srcMem, CALmem dstMem, CALuint flags) {
   WINE_TRACE("%u, %u, %u, %u, %u\n", *event, ctx, srcMem, dstMem, flags);
        return calMemCopy(event, ctx, srcMem, dstMem, flags);
}

CALresult WINAPI wine_calCtxIsEventDone(CALcontext ctx, CALevent event) {
   CALresult res = calCtxIsEventDone(ctx, event);
   if (res != CAL_RESULT_OK){
      WINE_TRACE("%u, %u, %d, %s\n", ctx, event, res, calGetErrorString());
   }
   else {
      WINE_TRACE("%u, %u\n", ctx, event);
   }
   return res;
   
}

CALresult WINAPI wine_calCtxFlush(CALcontext ctx){
   WINE_TRACE("%d\n", ctx);
   return calCtxFlush(ctx);
}


//##Error Reporting
const CALchar* WINAPI wine_calGetErrorString() {
   WINE_TRACE("%s\n", "Fetching error string...");
   return calGetErrorString();
}


//##Extension Functions
CALresult WINAPI wine_calExtSupported(CALextid extid){
   WINE_TRACE("%x\n",extid);
   return calExtSupported(extid);
   
}

CALresult WINAPI wine_calExtGetVersion(CALuint* major,CALuint* minor, CALextid extid) {
   WINE_TRACE("%u, %u, %x\n", *major, *minor, extid);
        return calExtGetVersion(major, minor, extid);
}

CALresult WINAPI wine_calExtGetProc(CALextproc* proc, CALextid extid, const CALchar* procname) {
   WINE_TRACE("%p, %x, %s,\n", proc, extid, procname);
   return calExtGetProc(proc, extid, procname);
}


//##Counters
CALresult WINAPI wine_calCtxCreateCounter(CALcounter* counter, CALcontext ctx, CALcountertype type) {
   WINE_TRACE("%u, %u, %u\n", *counter, ctx, type);
   return calCtxCreateCounter(counter, ctx, type);
}

CALresult WINAPI wine_calCtxDestroyCounter(CALcontext ctx, CALcounter counter) {
   WINE_TRACE("%u, %u\n", ctx, counter);;
        return calCtxDestroyCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxBeginCounter(CALcontext ctx, CALcounter counter) {
   WINE_TRACE("%u, %u\n", ctx, counter);
        return calCtxBeginCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxEndCounter(CALcontext ctx, CALcounter counter) {
   WINE_TRACE("%u, %u\n", ctx, counter);
        return calCtxEndCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxGetCounter(CALfloat* result, CALcontext ctx, CALcounter counter) {
    WINE_TRACE("%f, %u, %u\n", *result, ctx, counter);
   return calCtxGetCounter(result, ctx, counter);
}


//##User Resource Extensions
CALresult WINAPI wine_calResCreate2D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALuint height, CALformat format, CALuint size, CALuint flags) {
   WINE_TRACE("%u, %u, %p, %u, %u, %u, %u, %u\n", *res, dev, mem, width, height, format, size, flags);
        return calResCreate2D(res, dev, mem, width, height, format, size, flags);
}

CALresult WINAPI wine_calResCreate1D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALformat format, CALuint size, CALuint flags) {
   WINE_TRACE("%u, %u, %p, %u, %u, %u, %u\n", *res, dev, mem, width, format, size, flags);

        return calResCreate1D(res, dev, mem, width, format, size, flags);
}


//##Extension

CALresult WINAPI wine_calCtxRunProgramParams(CALevent *event, CALcontext ctx, CALfunc func, const CALdomain* domain, const CALdomainparam* params){
   WINE_TRACE("%u, %u, %u, %p, ,%p \n", *event, ctx, func, domain, params);
   return calCtxRunProgramParams(event, ctx, func, domain, params);
}


//##Private extensions?
/*
CALresult WINAPI wine_calCtxGetPrivateCounter() {

   return NULL;
}

CALresult WINAPI wine_calCtxConfigPrivateCounter() {

   return NULL;
}

CALresult WINAPI wine_calCtxCreatePrivateCounter() {

   return NULL;
}

*/


And the makefile (I'm on 64 bit, so you may have to change lib32 to just lib.)
Code: Select all
#*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine
### Generated by Winemaker 0.7.1


SRCDIR                = .
SUBDIRS               =
DLLS                  = amdcalrt.dll
EXES                  =



### Common settings

CEXTRA                = -mno-cygwin
CXXEXTRA              = -mno-cygwin
RCEXTRA               =
DEFINES               =
INCLUDE_PATH          = -I/usr/local/atical/include
DLL_PATH              =
DLL_IMPORTS           =
LIBRARY_PATH          = -L/usr/lib32
LIBRARIES             = -laticalrt -laticalcl


### amdcalrt.dll sources and settings

amdcalrt_dll_MODULE   = amdcalrt.dll
amdcalrt_dll_C_SRCS   = amdcalrt.c
amdcalrt_dll_CXX_SRCS =
amdcalrt_dll_RC_SRCS  =
amdcalrt_dll_LDFLAGS  = -shared \
         $(amdcalrt_dll_MODULE:%=%.spec) \
         -mno-cygwin \
         -m32
amdcalrt_dll_DLL_PATH =
amdcalrt_dll_DLLS     = odbc32 \
         ole32 \
         oleaut32 \
         winspool \
         odbccp32
amdcalrt_dll_LIBRARY_PATH=
amdcalrt_dll_LIBRARIES= uuid

amdcalrt_dll_OBJS     = $(amdcalrt_dll_C_SRCS:.c=.o) \
         $(amdcalrt_dll_CXX_SRCS:.cpp=.o) \
         $(amdcalrt_dll_RC_SRCS:.rc=.res)



### Global source lists

C_SRCS                = $(amdcalrt_dll_C_SRCS)
CXX_SRCS              = $(amdcalrt_dll_CXX_SRCS)
RC_SRCS               = $(amdcalrt_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%)

$(amdcalrt_dll_MODULE).so: $(amdcalrt_dll_OBJS)
   $(CC) $(amdcalrt_dll_LDFLAGS) -o $@ $(amdcalrt_dll_OBJS) $(amdcalrt_dll_LIBRARY_PATH) $(DEFLIB) $(amdcalrt_dll_DLLS:%=-l%) $(amdcalrt_dll_LIBRARIES:%=-l%)




spec file:
Code: Select all
#*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine


##System Component
@  stdcall calInit() wine_calInit
@  stdcall calShutdown() wine_calShutdown
@  stdcall calGetVersion(ptr ptr ptr) wine_calGetVersion

##Device Management
@  stdcall calDeviceGetCount(ptr) wine_calDeviceGetCount
@  stdcall calDeviceGetInfo(ptr long) wine_calDeviceGetInfo      #Not in the Platform API doc
@  stdcall calDeviceGetAttribs(ptr long) wine_calDeviceGetAttribs
@  stdcall calDeviceOpen(ptr long) wine_calDeviceOpen
@  stdcall calDeviceGetStatus(ptr long) wine_calDeviceGetStatus
@  stdcall calDeviceClose(long) wine_calDeviceClose

##Memory Management
@  stdcall calResAllocLocal2D(ptr long long long long long) wine_calResAllocLocal2D
@  stdcall calResAllocRemote2D(ptr ptr long long long long long) wine_calResAllocRemote2D
@  stdcall calResAllocLocal1D(ptr long long long long) wine_calResAllocLocal1D
@  stdcall calResAllocRemote1D(ptr ptr long long long long) wine_calResAllocRemote1D
@  stdcall calResFree(long) wine_calResFree
@  stdcall calResMap(ptr ptr long long) wine_calResMap
@  stdcall calResUnmap(long) wine_calResUnmap

##Context Management
@  stdcall calCtxCreate(ptr long) wine_calCtxCreate
@  stdcall calCtxDestroy(long) wine_calCtxDestroy
@  stdcall calCtxGetMem(ptr long long) wine_calCtxGetMem
@  stdcall calCtxReleaseMem(long long) wine_calCtxReleaseMem
@  stdcall calCtxSetMem(long long long) wine_calCtxSetMem

##Loader
@  stdcall calModuleLoad(ptr long long) wine_calModuleLoad
@  stdcall calModuleUnload(long long) wine_calModuleUnload
@  stdcall calModuleGetEntry(ptr long long ptr) wine_calModuleGetEntry
@  stdcall calModuleGetName(ptr long long ptr) wine_calModuleGetName
@  stdcall calImageRead(ptr ptr long) wine_calImageRead
@  stdcall calImageFree(long) wine_calImageFree      #Not in the Platform API doc
@  stdcall calclImageWrite(ptr ptr long) wine_calclImageWrite

##Computation
@  stdcall calCtxRunProgram(ptr long long ptr) wine_calCtxRunProgram
@  stdcall calCtxRunProgramGrid(ptr long ptr) wine_calCtxRunProgramGrid
@  stdcall calCtxRunProgramGridArray(ptr long ptr) wine_calCtxRunProgramGridArray
@  stdcall calModuleGetFuncInfo(ptr long long long) wine_calModuleGetFuncInfo
@  stdcall calMemCopy(ptr long long long long) wine_calMemCopy
@  stdcall calCtxIsEventDone(long long) wine_calCtxIsEventDone
@  stdcall calCtxFlush(long) wine_calCtxFlush

##Error Reporting
@  stdcall calGetErrorString() wine_calGetErrorString


##Extension Functions
@  stdcall calExtSupported(long) wine_calExtSupported
@  stdcall calExtGetVersion(ptr ptr long) wine_calExtGetVersion
@  stdcall calExtGetProc(ptr long ptr) wine_calExtGetProc


##Counters
@  stdcall calCtxCreateCounter(ptr long long) wine_calCtxCreateCounter
@  stdcall calCtxDestroyCounter(long long) wine_calCtxDestroyCounter
@  stdcall calCtxBeginCounter(long long) wine_calCtxBeginCounter
@  stdcall calCtxEndCounter(long long) wine_calCtxEndCounter
@  stdcall calCtxGetCounter(ptr long long) wine_calCtxGetCounter

##User Resource Extensions
@  stdcall calResCreate2D(ptr long ptr long long long long long) wine_calResCreate2D
@  stdcall calResCreate1D(ptr long ptr long long long long) wine_calResCreate1D


@  stdcall calCtxRunProgramParams() wine_calCtxRunProgramParams   #Not in the Platform API doc

##Private extensions

@  stub   calCtxGetPrivateCounter
@  stub   calCtxConfigPrivateCounter
@  stub   calCtxCreatePrivateCounter


##Not in the Platform API doc   
#@  stub    calLoadBinary
#@  stub    calLoadLibrary
Last edited by Anachron on Thu Jul 09, 2009 12:16 pm, edited 1 time in total.
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Sun Jul 05, 2009 7:24 pm

Code: Select all
trace:cal:wine_calCtxSetMem 536870912, 1610612744, 1073741872
trace:cal:wine_calModuleGetName 1610612743, 536870912, 2147483650, i4
trace:cal:wine_calCtxSetMem 536870912, 1610612743, 1073741870
trace:cal:wine_calModuleGetEntry 1342177282, 536870912, 2147483650, main
trace:cal:wine_calCtxIsEventDone 15765176, 1342177282, (6, A handle parameter is invalid)
Run: exception thrown during GuardedRun
[11:53:26] Run: exception thrown during GuardedRun


The function calCtxIsEventDone(CALcontext ctx, CALevent event) here seems to be passed an erroneous CALevent.
As you can see from calModuleGetEntry(CALfunc* func, ...) the first parameter is a pointer to a CALfunc. This handle is passed as a CALevent to calCtxIsEventDone. This has to be wrong, or what?

Also, compare to the output from one of the samples that works:
Code: Select all
trace:cal:wine_calCtxSetMem 536870912, 1610612737, 1073741825
trace:cal:wine_calModuleGetName 1610612736, 536870912, 2147483648, o0
trace:cal:wine_calCtxSetMem 536870912, 1610612736, 1073741824
trace:cal:wine_calResMap 0x32fe40, 1, 805306369, 0
trace:cal:wine_calResUnmap 805306369
trace:cal:wine_calModuleGetEntry 1342177280, 536870912, 2147483648, main
trace:cal:wine_calCtxRunProgram 0, 536870912, 1342177280, 0x32fe30
trace:cal:wine_calCtxIsEventDone 536870912, 2684354560, (8, An asynchronous operation is still pending)
trace:cal:wine_calCtxIsEventDone 536870912, 2684354560

calCtxRunProgram is missing in the output from the wrapper, and calCtxIsEventDone is passed a valid CALevent in the sample.
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Tue Aug 04, 2009 10:32 pm

I'm stuck. Hope someone else can solve this problem.

I've changed the tracing in calrt to be standardized, and added the same kind of tracing to calcl.
The makefile for rt no longer links with aticalcl library.

amdcalrt.c:
Code: Select all
/*Code by Seth Shelnutt and Bjørnar Hansen, with help from Mike Houston. Released under the LGPL v2.1 or later in order to be compatiable with Wine
*/


#include <windef.h>
#include <stdio.h> 

#include "cal.h"
#include "cal_ext.h"
//#include "cal_ext_counter.h"

#include "wine/debug.h"


/*
static PFNCALCTXCREATECOUNTER  calCtxCreateCounter;
static PFNCALCTXDESTROYCOUNTER calCtxDestroyCounter;
static PFNCALCTXBEGINCOUNTER   calCtxBeginCounter;
static PFNCALCTXENDCOUNTER     calCtxEndCounter;
static PFNCALCTXGETCOUNTER     calCtxGetCounter;
*/

//static PFNCALRESCREATE2D calResCreate2D = 0;
//static PFNCALRESCREATE1D calResCreate1D = 0;

//static PFNCALCTXRUNPROGRAMPARAMS calCtxRunProgramParams = 0;



WINE_DEFAULT_DEBUG_CHANNEL(cal);


CALresult WINAPI wine_calInit(void) {

   CALresult result = calInit();

   WINE_TRACE("calInit() => 0x%08x\n", result);

   return result;

}



CALresult WINAPI wine_calShutdown() {
   CALresult result = calShutdown();
   WINE_TRACE("calShutdown() => 0x%08x\n", result);
        return result;
}

CALresult WINAPI wine_calGetVersion(CALuint* major, CALuint* minor, CALuint* imp) {
   CALresult result = calGetVersion(major, minor, imp);
   WINE_TRACE("calGetVersion(&(%d),&(%d),&(%d)) => 0x%08x\n", *major, *minor, *imp, result);
        return result;
}

//##Device Management
CALresult WINAPI wine_calDeviceGetCount(CALuint* count) {
   CALresult result = calDeviceGetCount(count);
   WINE_TRACE("calDeviceGetCount(&(%d)) => 0x%08x\n", *count, result);
        return result;

}
CALresult WINAPI wine_calDeviceGetInfo(CALdeviceinfo* info, CALuint ordinal) {
   CALresult result = calDeviceGetInfo(info, ordinal);
   WINE_TRACE("calDeviceGetInfo(*,%d) => 0x%08x\n", ordinal, result);
   return result;
}
CALresult WINAPI wine_calDeviceGetAttribs(CALdeviceattribs* attribs, CALuint ordinal) {
   CALresult result = calDeviceGetAttribs(attribs, ordinal);
   WINE_TRACE("calDeviceGetAttribs(*,%d) => 0x%08x\n", ordinal, result);

   return result;
}

CALresult WINAPI wine_calDeviceOpen(CALdevice* dev, CALuint ordinal) {
   CALresult result = calDeviceOpen(dev, ordinal);
   WINE_TRACE("calDeviceOpen(&(Dx%08x),%d) => 0x%08x\n", *dev, ordinal, result);

   return result;
}

CALresult WINAPI wine_calDeviceGetStatus(CALdevicestatus* status, CALdevice dev) {
   CALresult result = calDeviceGetStatus(status, dev);
   WINE_TRACE("calDeviceGetStatus(*,Dx%08x) => 0x%08x\n", dev, result);

        return result;
}

CALresult WINAPI wine_calDeviceClose(CALdevice dev) {
   CALresult result = calDeviceClose(dev);
   WINE_TRACE("calDeviceClose(Dx%08x) => 0x%08x\n", dev, result);

   return result;
}


//##Memory Management
CALresult WINAPI wine_calResAllocLocal2D(CALresource* res, CALdevice device, CALuint width, CALuint height, CALformat format, CALuint flags) {
   CALresult result = calResAllocLocal2D(res, device, width, height, format, flags);
   WINE_TRACE("calResAllocLocal2D(&(Rx%08x),Dx%08x,%d,%d,%d,0x%x) => 0x%08x\n", *res, device, width, height, format, flags, result);

   return result;

}

CALresult WINAPI wine_calResAllocRemote2D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALuint height, CALformat format, CALuint flags) {
   CALresult result = calResAllocRemote2D(res, sharedDevices, deviceCount, width, height, format, flags);
   WINE_TRACE("calResAllocRemote2D(&(Rx%08x),{Dx%08x},%d,%d,%d,%d,0x%x) => 0x%08x\n", *res, *sharedDevices, deviceCount, width, height, format, flags, result);

   return result;
}

CALresult WINAPI wine_calResAllocLocal1D(CALresource* res, CALdevice device, CALuint width, CALformat format, CALuint flags) {
   CALresult result = calResAllocLocal1D(res, device, width, format, flags);
   WINE_TRACE("calResAllocLocal1D(&(Rx%08x),Dx%08x,%d,%d,0x%x) => 0x%08x\n", *res, device, width, format, flags, result);

   return result;
}

CALresult WINAPI wine_calResAllocRemote1D(CALresource* res, CALdevice* sharedDevices, CALuint deviceCount, CALuint width, CALformat format, CALuint flags) {
   CALresult result = calResAllocRemote1D(res, sharedDevices, deviceCount, width, format, flags);
   WINE_TRACE("calResAllocRemote1D(&(Rx%08x),{Dx%08x},%d,%d,%d,0x%x) => 0x%08x\n", *res, *sharedDevices, deviceCount, width, format, flags, result);

   return result;
}

CALresult WINAPI wine_calResFree(CALresource res) {
   CALresult result = calResFree(res);
   WINE_TRACE("calResFree(Rx%08x) => 0x%08x\n", res, result);

   return result;
}

CALresult WINAPI wine_calResMap(CALvoid** pPtr, CALuint* pitch, CALresource res, CALuint flags) {
   CALresult result = calResMap(pPtr, pitch, res, flags);
   WINE_TRACE("calResMap(&(*x%p),&(%d),Rx%08x,0x%x) => 0x%08x\n", *pPtr, *pitch, res, flags, result);

   return result;
}

CALresult WINAPI wine_calResUnmap(CALresource res) {
   CALresult result = calResUnmap(res);
   WINE_TRACE("calResUnmap(Rx%08x) => 0x%08x\n", res, result);

   return result;
}


//##Context Management
CALresult WINAPI wine_calCtxCreate(CALcontext* ctx, CALdevice dev) {
   CALresult result = calCtxCreate(ctx, dev);
   WINE_TRACE("calCtxCreate(&(Cx%08x),Dx%08x) => 0x%08x\n", *ctx, dev, result);

   return result;
}

CALresult WINAPI wine_calCtxDestroy(CALcontext ctx) {
   CALresult result = calCtxDestroy(ctx);
   WINE_TRACE("calCtxDestroy(Cx%08x) => 0x%08x\n", ctx, result);

   return result;
}

CALresult WINAPI wine_calCtxGetMem(CALmem* mem, CALcontext ctx, CALresource res) {
   CALresult result = calCtxGetMem(mem, ctx, res);
   WINE_TRACE("calCtxGetMem(&(Mx%08x),Cx%08x,Rx%08x) => 0x%08x\n", *mem, ctx, res, result);

   return result;
}

CALresult WINAPI wine_calCtxReleaseMem(CALcontext ctx, CALmem mem) {
   CALresult result = calCtxReleaseMem(ctx, mem);
   WINE_TRACE("calCtxReleaseMem(Cx%08x,Mx%08x) => 0x%08x\n", ctx, mem, result);

   return result;
}

CALresult WINAPI wine_calCtxSetMem(CALcontext ctx, CALname name, CALmem mem) {
   CALresult result = calCtxSetMem(ctx, name, mem);
   WINE_TRACE("calCtxSetMem(Cx%08x,Nx%08x,Mx%08x) => 0x%08x\n", ctx, name, mem, result);

   return result;
}



//##Loader

CALresult WINAPI wine_calModuleLoad(CALmodule* module, CALcontext ctx, CALimage image) {
   CALresult result = calModuleLoad(module, ctx, image);
   WINE_TRACE("calModuleLoad(&(Mx%08x),Cx%08x,Ix%p) => 0x%08x\n", *module, ctx, image, result);

return result;
}

CALresult WINAPI wine_calModuleUnload(CALcontext ctx, CALmodule module) {
   CALresult result = calModuleUnload(ctx, module);
   WINE_TRACE("calModuleUnload(Cx%08x,Mx%08x) => 0x%08x\n", ctx, module, result);

   return result;
}

CALresult WINAPI wine_calModuleGetEntry(CALfunc* func, CALcontext ctx, CALmodule module, const CALchar* procName) {
   CALresult result = calModuleGetEntry(func, ctx, module, procName);
   WINE_TRACE("calModuleGetEntry(&(Fx%08x),Cx%08x,Mx%08x,\"%s\") => 0x%08x\n", *func, ctx, module, procName, result);
        return result;
}

CALresult WINAPI wine_calModuleGetName(CALname* name, CALcontext ctx, CALmodule module, const CALchar* varName) {
   CALresult result = calModuleGetName(name, ctx, module, varName);
   WINE_TRACE("calModuleGetName(&(Nx%08x),Cx%08x,Mx%08x,\"%s\") => 0x%08x\n", *name, ctx, module, varName, result);

   return result;
}

CALresult WINAPI wine_calImageRead(CALimage* image, const CALvoid* buffer, CALuint size){
   CALresult result = calImageRead(image, buffer, size);
   WINE_TRACE("calImageRead(&(Ix%p),*x%p,%d) => 0x%08x\n", *image, buffer, size, result);

   return result;
}

CALresult WINAPI wine_calImageFree(CALimage image) {
   CALresult result = calImageFree(image);
   WINE_TRACE("calImageFree(Ix%p) => 0x%08x\n", image, result);

   return result;
}



//##Computation
CALresult WINAPI wine_calCtxRunProgram(CALevent* event, CALcontext ctx, CALfunc func, const CALdomain* domain) {
   CALresult result = calCtxRunProgram(event, ctx, func, domain);
   WINE_TRACE("calCtxRunProgram(&(Ex%08x),Cx%08x,Fx%08x,{XY(%d,%d),WH(%dx%d)}) => 0x%08x\n", *event, ctx, func, domain->x, domain->y, domain->width, domain->height, result);

   return result;
}


CALresult WINAPI wine_calCtxRunProgramGrid(CALevent* event, CALcontext ctx, CALprogramGrid* pProgramGrid) {
   CALresult result = calCtxRunProgramGrid(event, ctx, pProgramGrid);
   WINE_TRACE("calCtxRunProgramGrid(&(Ex%08x),Cx%08x,{Fx%08x,Blk(%dx%dx%x),Size(%dx%dx%x),0x%x}) => 0x%08x\n", *event, ctx, pProgramGrid->func, pProgramGrid->gridBlock.width, pProgramGrid->gridBlock.height, pProgramGrid->gridBlock.depth, pProgramGrid->gridSize.width, pProgramGrid->gridSize.height, pProgramGrid->gridSize.depth, pProgramGrid->flags, result);

   return result;
}


CALresult WINAPI wine_calCtxRunProgramGridArray(CALevent* event, CALcontext ctx, CALprogramGridArray* pGridArray) {
   CALresult result = calCtxRunProgramGridArray(event, ctx, pGridArray);
   WINE_TRACE("calCtxRunProgramGridArray(&(Ex%08x),Cx%08x,{*x%p,%d,0x%x}) => 0x%08x\n", *event, ctx, pGridArray->gridArray, pGridArray->num, pGridArray->flags, result);

   return result;
}

CALresult WINAPI wine_calModuleGetFuncInfo(CALfuncInfo* pInfo, CALcontext ctx, CALmodule module, CALfunc func) {
   CALresult result = calModuleGetFuncInfo(pInfo, ctx, module, func);
   WINE_TRACE("calModuleGetFuncInfo(*,Cx%08x,Mx%08x,Fx%08x}) => 0x%08x\n", ctx, module, func, result);

   return result;
}

CALresult WINAPI wine_calMemCopy(CALevent* event, CALcontext ctx, CALmem srcMem, CALmem dstMem, CALuint flags) {
   CALresult result = calMemCopy(event, ctx, srcMem, dstMem, flags);   
   WINE_TRACE("calMemCopy(&(Ex%08x),Cx%08x,Mx%08x,Mx%08x,0x%x) => 0x%08x\n", *event, ctx, srcMem, dstMem, flags, result);

   return result;
}

CALresult WINAPI wine_calCtxIsEventDone(CALcontext ctx, CALevent event) {
   CALresult result = calCtxIsEventDone(ctx, event);
   WINE_TRACE("calCtxIsEventDone(Cx%08x,Ex%08x) => 0x%08x\n", ctx, event, result);
   return result;
   
}

CALresult WINAPI wine_calCtxFlush(CALcontext ctx){
   CALresult result = calCtxFlush(ctx);
   WINE_TRACE("calCtxFlush(Cx%08x) => 0x%08x\n", ctx, result);

   return result;
}


//##Error Reporting
const CALchar* WINAPI wine_calGetErrorString() {
   const CALchar*result = calGetErrorString();
   WINE_TRACE("calGetErrorString() => \"%s\"\n", result);
   return result;
}


//##Extension Functions
CALresult WINAPI wine_calExtSupported(CALextid extid){
   CALresult result = calExtSupported(extid);
   WINE_TRACE("calExtSupported(0x%x}) => 0x%08x\n", extid, result);

   return result;
   
}

CALresult WINAPI wine_calExtGetVersion(CALuint* major,CALuint* minor, CALextid extid) {
   CALresult result = calExtGetVersion(major, minor, extid);
   WINE_TRACE("calExtGetVersion(&(%d),&(%d),%d) => 0x%08x\n", *major, *minor, extid, result);

   return result;
}

CALresult WINAPI wine_calExtGetProc(CALextproc* proc, CALextid extid, const CALchar* procname) {
   CALresult result = calExtGetProc(proc, extid, procname);
   WINE_TRACE("calExtGetProc(&(*x%p),0x%x,\"%s\") => 0x%08x\n", *proc, extid, procname, result);

   return result;
}

/*
//##Counters
CALresult WINAPI wine_calCtxCreateCounter(CALcounter* counter, CALcontext ctx, CALcountertype type) {
   WINE_TRACE("%u, %u, %u\n", *counter, ctx, type);
   return calCtxCreateCounter(counter, ctx, type);
}

CALresult WINAPI wine_calCtxDestroyCounter(CALcontext ctx, CALcounter counter) {
   WINE_TRACE("%u, %u\n", ctx, counter);;
        return calCtxDestroyCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxBeginCounter(CALcontext ctx, CALcounter counter) {
   WINE_TRACE("%u, %u\n", ctx, counter);
        return calCtxBeginCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxEndCounter(CALcontext ctx, CALcounter counter) {
   WINE_TRACE("%u, %u\n", ctx, counter);
        return calCtxEndCounter(ctx, counter);
}

CALresult WINAPI wine_calCtxGetCounter(CALfloat* result, CALcontext ctx, CALcounter counter) {
    WINE_TRACE("%f, %u, %u\n", *result, ctx, counter);
   return calCtxGetCounter(result, ctx, counter);
}
*/
/*
//##User Resource Extensions

CALresult WINAPI wine_calResCreate2D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALuint height, CALformat format, CALuint size, CALuint flags) {
   CALresult result = calResCreate2D(res, dev, mem, width, height, format, size, flags);
   WINE_TRACE("calResCreate2D(&(Rx%08x),Dx%08x,*x%p,%d,%d,%d,%d,0x%x) => 0x%08x\n", *res, dev, mem, width, height, format, size, flags, result);

   return result;
}

CALresult WINAPI wine_calResCreate1D(CALresource* res, CALdevice dev, CALvoid* mem, CALuint width, CALformat format, CALuint size, CALuint flags) {
   CALresult result = calResCreate1D(res, dev, mem, width, format, size, flags);
   WINE_TRACE("calResCreate1D(&(Rx%08x),Dx%08x,*x%p,%d,%d,%d,0x%x) => 0x%08x\n", *res, dev, mem, width, format, size, flags, result);

   return result;
}

*/
/*
//##Extension

CALresult WINAPI wine_calCtxRunProgramParams(CALevent *event, CALcontext ctx, CALfunc func, const CALdomain* domain, const CALdomainparam* params){
   CALresult result = calCtxRunProgramParams(event, ctx, func, domain, params);
   WINE_TRACE("%u, %u, %u, %p, ,%p \n", *event, ctx, func, domain, params);
   return result;
}*/



//##Private extensions?
/*
CALresult WINAPI wine_calCtxGetPrivateCounter() {

   return NULL;
}

CALresult WINAPI wine_calCtxConfigPrivateCounter() {

   return NULL;
}

CALresult WINAPI wine_calCtxCreatePrivateCounter() {

   return NULL;
}


*/

amdcalrt.dll.spec:
Code: Select all
#Code by Seth Shelnutt and Bjørnar Hansen, with help from Mike Houston. Released under the LGPL v2.1 or later in order to be compatiable with Wine


##System Component
@  stdcall calInit() wine_calInit
@  stdcall calShutdown() wine_calShutdown
@  stdcall calGetVersion(ptr ptr ptr) wine_calGetVersion

##Device Management
@  stdcall calDeviceGetCount(ptr) wine_calDeviceGetCount
@  stdcall calDeviceGetInfo(ptr long) wine_calDeviceGetInfo      #Not in the Platform API doc
@  stdcall calDeviceGetAttribs(ptr long) wine_calDeviceGetAttribs
@  stdcall calDeviceOpen(ptr long) wine_calDeviceOpen
@  stdcall calDeviceGetStatus(ptr long) wine_calDeviceGetStatus
@  stdcall calDeviceClose(long) wine_calDeviceClose

##Memory Management
@  stdcall calResAllocLocal2D(ptr long long long long long) wine_calResAllocLocal2D
@  stdcall calResAllocRemote2D(ptr ptr long long long long long) wine_calResAllocRemote2D
@  stdcall calResAllocLocal1D(ptr long long long long) wine_calResAllocLocal1D
@  stdcall calResAllocRemote1D(ptr ptr long long long long) wine_calResAllocRemote1D
@  stdcall calResFree(long) wine_calResFree
@  stdcall calResMap(ptr ptr long long) wine_calResMap
@  stdcall calResUnmap(long) wine_calResUnmap

##Context Management
@  stdcall calCtxCreate(ptr long) wine_calCtxCreate
@  stdcall calCtxDestroy(long) wine_calCtxDestroy
@  stdcall calCtxGetMem(ptr long long) wine_calCtxGetMem
@  stdcall calCtxReleaseMem(long long) wine_calCtxReleaseMem
@  stdcall calCtxSetMem(long long long) wine_calCtxSetMem

##Loader
@  stdcall calModuleLoad(ptr long long) wine_calModuleLoad
@  stdcall calModuleUnload(long long) wine_calModuleUnload
@  stdcall calModuleGetEntry(ptr long long ptr) wine_calModuleGetEntry
@  stdcall calModuleGetName(ptr long long ptr) wine_calModuleGetName
@  stdcall calImageRead(ptr ptr long) wine_calImageRead
@  stdcall calImageFree(long) wine_calImageFree      #Not in the Platform API doc

##Computation
@  stdcall calCtxRunProgram(ptr long long ptr) wine_calCtxRunProgram
@  stdcall calCtxRunProgramGrid(ptr long ptr) wine_calCtxRunProgramGrid
@  stdcall calCtxRunProgramGridArray(ptr long ptr) wine_calCtxRunProgramGridArray

#@  stub calCtxRunProgram
#@  stub calCtxRunProgramGrid
#@  stub calCtxRunProgramGridArray

@  stdcall calModuleGetFuncInfo(ptr long long long) wine_calModuleGetFuncInfo
@  stdcall calMemCopy(ptr long long long long) wine_calMemCopy
@  stdcall calCtxIsEventDone(long long) wine_calCtxIsEventDone
@  stdcall calCtxFlush(long) wine_calCtxFlush

##Error Reporting
@  stdcall calGetErrorString() wine_calGetErrorString


##Extension Functions
@  stdcall calExtSupported(long) wine_calExtSupported
@  stdcall calExtGetVersion(ptr ptr long) wine_calExtGetVersion
@  stdcall calExtGetProc(ptr long ptr) wine_calExtGetProc


##Counters
#@  stdcall calCtxCreateCounter(ptr long long) wine_calCtxCreateCounter
#@  stdcall calCtxDestroyCounter(long long) wine_calCtxDestroyCounter
#@  stdcall calCtxBeginCounter(long long) wine_calCtxBeginCounter
#@  stdcall calCtxEndCounter(long long) wine_calCtxEndCounter
#@  stdcall calCtxGetCounter(ptr long long) wine_calCtxGetCounter

#@  stub calCtxCreateCounter
#@  stub calCtxDestroyCounter
#@  stub calCtxBeginCounter
#@  stub calCtxEndCounter
#@  stub calCtxGetCounter

#@  stub calCtxCreateCounterExt
#@  stub calCtxDestroyCounterExt
#@  stub calCtxBeginCounterExt
#@  stub calCtxEndCounterExt
#@  stub calCtxGetCounterExt



##User Resource Extensions
#@  stdcall calResCreate2D(ptr long ptr long long long long long) wine_calResCreate2D
#@  stdcall calResCreate1D(ptr long ptr long long long long) wine_calResCreate1D
#@  extern calResCreate2D
#@  extern calResCreate1D


#@  stdcall calCtxRunProgramParams() wine_calCtxRunProgramParams   #Not in the Platform API doc

#@  stub calCtxRunProgramParams

##Private extensions

#@  stub   calCtxGetPrivateCounter
#@  stub   calCtxConfigPrivateCounter
#@  stub   calCtxCreatePrivateCounter


##Not in the Platform API doc   
#@  stub    calLoadBinary
#@  stub    calLoadLibrary

makefile:
Code: Select all
#*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine
### Generated by Winemaker 0.7.1


SRCDIR                = .
SUBDIRS               =
DLLS                  = amdcalrt.dll
EXES                  =



### Common settings

CEXTRA                = -mno-cygwin
CXXEXTRA              = -mno-cygwin
RCEXTRA               =
DEFINES               =
INCLUDE_PATH          = -I/usr/local/atical/include
DLL_PATH              =
DLL_IMPORTS           =
LIBRARY_PATH          = -L/usr/lib32
LIBRARIES             = -laticalrt


### amdcalrt.dll sources and settings

amdcalrt_dll_MODULE   = amdcalrt.dll
amdcalrt_dll_C_SRCS   = amdcalrt.c
amdcalrt_dll_CXX_SRCS =
amdcalrt_dll_RC_SRCS  =
amdcalrt_dll_LDFLAGS  = -shared \
         $(amdcalrt_dll_MODULE:%=%.spec) \
         -mno-cygwin \
         -m32
amdcalrt_dll_DLL_PATH =
amdcalrt_dll_DLLS     = odbc32 \
         ole32 \
         oleaut32 \
         winspool \
         odbccp32
amdcalrt_dll_LIBRARY_PATH=
amdcalrt_dll_LIBRARIES= uuid

amdcalrt_dll_OBJS     = $(amdcalrt_dll_C_SRCS:.c=.o) \
         $(amdcalrt_dll_CXX_SRCS:.cpp=.o) \
         $(amdcalrt_dll_RC_SRCS:.rc=.res)



### Global source lists

C_SRCS                = $(amdcalrt_dll_C_SRCS)
CXX_SRCS              = $(amdcalrt_dll_CXX_SRCS)
RC_SRCS               = $(amdcalrt_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%)

$(amdcalrt_dll_MODULE).so: $(amdcalrt_dll_OBJS)
   $(CC) $(amdcalrt_dll_LDFLAGS) -o $@ $(amdcalrt_dll_OBJS) $(amdcalrt_dll_LIBRARY_PATH) $(DEFLIB) $(amdcalrt_dll_DLLS:%=-l%) $(amdcalrt_dll_LIBRARIES:%=-l%)




amdcalcl.c:
Code: Select all
/*Code by Seth Shelnutt and Bjørnar Hansen, with help from Mike Houston. Released under the LGPL v2.1 or later in order to be compatiable with Wine
*/
#include <windef.h>

#include "calcl.h"

#include "wine/debug.h"


WINE_DEFAULT_DEBUG_CHANNEL(cal);


CALresult WINAPI wine_calclLink(CALimage* image, CALobject* obj, CALuint objCount) {
   CALresult result = calclLink(image, obj, objCount);
        WINE_TRACE("calclLink(&(Ix%p),{Ox%p},%d) => 0x%08x\n", *image, *obj, objCount, result);

   return result;
}

const CALchar* WINAPI wine_calclGetErrorString() {
   const CALchar* result = calclGetErrorString();
        WINE_TRACE("calclGetErrorString() => \"%s\"\n", result);

   return result;
}

CALresult WINAPI wine_calclCompile(CALobject* obj, CALlanguage language, const CALchar* source, CALtarget target) {
   CALresult result = calclCompile(obj, language, source, target);
        WINE_TRACE("calclCompile(&(Ox%p),%d,*x%p,%d) => 0x%08x\n", *obj, language, source, target, result);

   return result;
}


CALresult WINAPI wine_calclGetVersion(CALuint* major, CALuint* minor, CALuint* imp) {
   CALresult result = calclGetVersion(major, minor, imp);

   WINE_TRACE("calclGetVersion(&(%d),&(%d),&(%d)) => 0x%08x\n", *major, *minor, *imp, result);
   return result;
}

CALresult WINAPI wine_calclFreeObject(CALobject obj) {
   CALresult result = calclFreeObject(obj);
   WINE_TRACE("calclFreeObject(Ox%p) => 0x%08x\n", obj, result);

   return result;
}

CALresult WINAPI wine_calclFreeImage(CALimage image) {
   CALresult result = calclFreeImage(image);
   WINE_TRACE("calclFreeImage(Ix%p) => 0x%08x\n", image, result);

   return result;
}

void WINAPI wine_calclDisassembleImage(const CALimage image, CALLogFunction logfunc) {
   calclDisassembleImage(image, logfunc);
   WINE_TRACE("calclDisassembleImage(Ix%p,*)\n", image);
}

CALresult WINAPI wine_calclAssembleObject(CALobject* obj, CALCLprogramType type, const CALchar* source, CALtarget target) {
   CALresult result = calclAssembleObject(obj, type, source, target);
   WINE_TRACE("calclAssembleObject(&(Ox%p),%d,*x%p,%d) => 0x%08x\n", *obj, type, source, target, result);

   return result;
}

void WINAPI wine_calclDisassembleObject(const CALobject* obj, CALLogFunction logfunc){
   calclDisassembleObject(obj, logfunc);
   WINE_TRACE("calclDisassembleObject(Ox%p,*)\n", obj);


}
CALresult WINAPI wine_calclImageGetSize (CALuint* size, CALimage image) {
   CALresult result = calclImageGetSize (size, image);
   WINE_TRACE("calclImageGetSize(&(%d),Ix%p) => 0x%08x\n", *size, image, result);

   return result;
}

CALresult WINAPI wine_calclImageWrite(CALvoid* buffer, CALuint size, CALimage image) {
   CALresult result = calclImageWrite(buffer, size, image);
   WINE_TRACE("calclImageWrite(*x%p,%d,Ix%p) => 0x%08x\n", buffer, size, image, result);

   return result;
}

amdcalcl.dll.spec:
Code: Select all
#*Code by Seth Shelnutt and Bjørnar Hansen, with help from Mike Houston. Released under the LGPL v2.1 or later in order to be compatiable with Wine



@  stdcall calclLink(ptr ptr long) wine_calclLink
@  stdcall calclGetErrorString() wine_calclGetErrorString
@  stdcall calclCompile(ptr long ptr long) wine_calclCompile




@  stdcall calclGetVersion(ptr ptr ptr) wine_calclGetVersion
@  stdcall calclFreeObject(long) wine_calclFreeObject
@  stdcall calclFreeImage(long) wine_calclFreeImage
@  stdcall calclDisassembleImage(long long) wine_calclDisassembleImage
@  stdcall calclAssembleObject(ptr long ptr long) wine_calclAssembleObject
@  stdcall calclDisassembleObject(ptr long) wine_calclDisassembleObject
@  stdcall calclImageGetSize (ptr long) wine_calclImageGetSize
@  stdcall calclImageWrite(ptr long long) wine_calclImageWrite

makefile:
Code: Select all
#*Code by Seth Shelnutt, released under the LGPL v2.1 or later in order to be compatiable with Wine
### Generated by Winemaker 0.7.1


SRCDIR                = .
SUBDIRS               =
DLLS                  = amdcalcl.dll
EXES                  =



### Common settings

CEXTRA                = -mno-cygwin
CXXEXTRA              = -mno-cygwin
RCEXTRA               =
DEFINES               =
INCLUDE_PATH          = -I/usr/local/atical/include
DLL_PATH              =
DLL_IMPORTS           =
LIBRARY_PATH          = -L/usr/lib32
LIBRARIES             = -laticalcl


### amdcalcl.dll sources and settings

amdcalcl_dll_MODULE   = amdcalcl.dll
amdcalcl_dll_C_SRCS   = amdcalcl.c
amdcalcl_dll_CXX_SRCS =
amdcalcl_dll_RC_SRCS  =
amdcalcl_dll_LDFLAGS  = -shared \
         $(amdcalcl_dll_MODULE:%=%.spec) \
         -mno-cygwin \
         -m32
amdcalcl_dll_DLL_PATH =
amdcalcl_dll_DLLS     = odbc32 \
         ole32 \
         oleaut32 \
         winspool \
         odbccp32
amdcalcl_dll_LIBRARY_PATH=
amdcalcl_dll_LIBRARIES= uuid

amdcalcl_dll_OBJS     = $(amdcalcl_dll_C_SRCS:.c=.o) \
         $(amdcalcl_dll_CXX_SRCS:.cpp=.o) \
         $(amdcalcl_dll_RC_SRCS:.rc=.res)



### Global source lists

C_SRCS                = $(amdcalcl_dll_C_SRCS)
CXX_SRCS              = $(amdcalcl_dll_CXX_SRCS)
RC_SRCS               = $(amdcalcl_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%)

$(amdcalcl_dll_MODULE).so: $(amdcalcl_dll_OBJS)
   $(CC) $(amdcalcl_dll_LDFLAGS) -o $@ $(amdcalcl_dll_OBJS) $(amdcalcl_dll_LIBRARY_PATH) $(DEFLIB) $(amdcalcl_dll_DLLS:%=-l%) $(amdcalcl_dll_LIBRARIES:%=-l%)

Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby Anachron » Tue Aug 04, 2009 10:36 pm

And lastly, the terminal output from running it (shortened a bit to fit in one post):
Code: Select all
$ WINEDEBUG=trace+cal wine fah6-gpu.exe

Note: Please read the license agreement (fah6-gpu.exe -license). Further
use of this software requires that you have read and accepted this agreement.



--- Opening Log file [August 4 22:03:05 UTC]


# Windows GPU Console Edition #################################################
###############################################################################

                       Folding@Home Client Version 6.23

                          http://folding.stanford.edu

###############################################################################
###############################################################################

Launch directory: C:\Program Files\folding-gpu
Executable: C:\Program Files\folding-gpu\fah6-gpu.exe
Arguments: -oneunit -verbosity 9 -forcegpu ati_r700

[22:03:05] - Ask before connecting: Yes
[22:03:05] - User name: Bjornar (Team 31574)
[22:03:05] - User ID: XXXXXXXXXXXXXXXX
[22:03:05] - Machine ID: 2
[22:03:05]
[22:03:05] Loaded queue successfully.
[22:03:05] Unit 2's deadline (June 19 09:41) has passed.
[22:03:05]
[22:03:05] + Processing work unit
[22:03:05] Core required: FahCore_11.exe
[22:03:05] - Autosending finished units... [August 4 22:03:05 UTC]
[22:03:05] Core found.
[22:03:05] Working on queue slot 02 [August 4 22:03:05 UTC]
[22:03:05] + Working ...
[22:03:05] - Calling '.\FahCore_11.exe -dir work/ -suffix 02 -checkpoint 15 -verbose -lifeline 8 -version 623'

[22:03:05] Trying to send all finished work units
[22:03:05] + No unsent completed units remaining.
[22:03:05] - Autosend completed
[22:03:05]
[22:03:05] *------------------------------*
[22:03:05] Folding@Home GPU Core - Beta
[22:03:05] Version 1.24 (Mon Feb 9 11:00:12 PST 2009)
[22:03:05]
[22:03:05] Compiler  : Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.762 for 80x86
[22:03:05] Build host: amoeba
[22:03:05] Board Type: AMD
[22:03:05] Core      :
[22:03:05] Preparing to commence simulation
[22:03:05] - Looking at optimizations...
[22:03:05] - Files status OK
[22:03:05] - Expanded 68563 -> 357580 (decompressed 521.5 percent)
[22:03:05] Called DecompressByteArray: compressed_data_size=68563 data_size=357580, decompressed_data_size=357580 diff=0
[22:03:05] - Digital signature verified
[22:03:05]
[22:03:05] Project: 5746 (Run 4, Clone 20, Gen 256)
[22:03:05]
[22:03:05] Assembly optimizations on if available.
[22:03:05] Entering M.D.
Reading file work/wudata_02.tpr, VERSION 3.1.4 (single precision)
Reading file work/wudata_02.tpr, VERSION 3.1.4 (single precision)
Reading sasa-enabled ir 0 0
[22:03:11] Will resume from checkpoint file
[22:03:11] Tpr hash work/wudata_02.tpr:  2639730865 4031526054 2357533253 3358095351 301830008
Issues between syncs set at 16
In override calInit
calLoadBinary
trace:cal:wine_calInit calInit() => 0x00000000
trace:cal:wine_calExtGetProc calExtGetProc(&(*x0x7e7f02e0),0x1006,"calResCreate2D") => 0x00000000
trace:cal:wine_calExtGetProc calExtGetProc(&(*x0x7e7f00d0),0x1006,"calResCreate1D") => 0x00000000
trace:cal:wine_calGetVersion calGetVersion(&(1),&(4),&(317)) => 0x00000000
CAL version: 1.4.317
trace:cal:wine_calDeviceGetCount calDeviceGetCount(&(1)) => 0x00000000
CAL: 1 devices found
trace:cal:wine_calDeviceOpen calDeviceOpen(&(Dx10000000),0) => 0x00000000
trace:cal:wine_calDeviceGetInfo calDeviceGetInfo(*,0) => 0x00000000
trace:cal:wine_calDeviceGetAttribs calDeviceGetAttribs(*,0) => 0x00000000
ASIC = RV770
Available board memory to CAL: 512MB
Available cached memory to CAL: 483MB
Available uncached memory to CAL: 1217MB
Engine clock: 800 (0.000000)
Natural vector width: 64
Recommended minimum thread count: 2560
Brook yield: 0
Don't flush kernels: 0
Pre flush command buffers: 0
Flush interval: 16
trace:cal:wine_calCtxCreate calCtxCreate(&(Cx20000000),Dx10000000) => 0x00000000
trace:cal:wine_calResAllocRemote1D calResAllocRemote1D(&(Rx30000000),{Dx10000000},1,128,6,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000000),Cx20000000,Rx30000000) => 0x00000000
trace:cal:wine_calResAllocRemote1D calResAllocRemote1D(&(Rx30000001),{Dx10000000},1,128,6,0x0) => 0x00000000
(...)
trace:cal:wine_calResAllocRemote1D calResAllocRemote1D(&(Rx3000001f),{Dx10000000},1,128,6,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000001f),Cx20000000,Rx3000001f) => 0x00000000
trace:cal:wine_calResAllocRemote1D calResAllocRemote1D(&(Rx30000020),{Dx10000000},1,128,6,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000020),Cx20000000,Rx30000020) => 0x00000000
trace:cal:wine_calclCompile calclCompile(&(Ox0x7d4de6c0),1,*x0x684be8,5) => 0x00000000
trace:cal:wine_calclGetErrorString calclGetErrorString() => "No error"
trace:cal:wine_calclLink calclLink(&(Ix0x7d4da078),{Ox0x7d4de6c0},1) => 0x00000000
trace:cal:wine_calModuleLoad calModuleLoad(&(Mx80000000),Cx20000000,Ix0x7d4da078) => 0x00000000
trace:cal:wine_calclCompile calclCompile(&(Ox0x7d4e1410),1,*x0x684cd8,5) => 0x00000000
trace:cal:wine_calclGetErrorString calclGetErrorString() => "No error"
trace:cal:wine_calclLink calclLink(&(Ix0x7d4e42c0),{Ox0x7d4e1410},1) => 0x00000000
trace:cal:wine_calModuleLoad calModuleLoad(&(Mx80000001),Cx20000000,Ix0x7d4e42c0) => 0x00000000
trace:cal:wine_calExtSupported calExtSupported(0x1005}) => 0x00000000
trace:cal:wine_calExtGetProc calExtGetProc(&(*x0x7e7f40d0),0x1005,"calCtxRunProgramParams") => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000021),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000021),Cx20000000,Rx30000021) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000022),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000022),Cx20000000,Rx30000022) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000023),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000023),Cx20000000,Rx30000023) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000024),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000024),Cx20000000,Rx30000024) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000025),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000025),Cx20000000,Rx30000025) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000026),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000026),Cx20000000,Rx30000026) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000027),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000027),Cx20000000,Rx30000027) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000028),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000028),Cx20000000,Rx30000028) => 0x00000000
starting mdrun 'Protein'
10000000 steps,  20000.0 ps.

trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000029),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000029),Cx20000000,Rx30000029) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000029,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000029) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000000),Cx20000000,Mx40000029,Mx40000021,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000000) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000000) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000000) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000029) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000029) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000029),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000029),Cx20000000,Rx30000029) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000029,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000029) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000001),Cx20000000,Mx40000029,Mx40000022,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000001) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000001) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000001) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000029) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000029) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000029),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000029),Cx20000000,Rx30000029) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx30000029,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000029) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000002),Cx20000000,Mx40000029,Mx40000025,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000002) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000002) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000002) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000029) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000029) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000029),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000029),Cx20000000,Rx30000029) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx30000029,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000029) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000003),Cx20000000,Mx40000029,Mx40000026,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000003) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000003) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000003) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000029) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000029) => 0x00000000
Calculated RepFac: 12 minSuggestedThreads=2560
Setting RepFac: 12
nbp->PForceStrWidth: 64, gpu->AtomStrSize: 992 nbp->RepFac: 12 gpu->iUnroll: 4, nbp->PForceStrSize: 2976, nbp->PForceStrHeight: 47
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000029),Dx10000000,32,31,12,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000029),Cx20000000,Rx30000029) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000002a),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000002a),Cx20000000,Rx3000002a) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000002b),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000002b),Cx20000000,Rx3000002b) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000002c),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000002c),Cx20000000,Rx3000002c) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000002d),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000002d),Cx20000000,Rx3000002d) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000002e),Dx10000000,992,248,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000002e),Cx20000000,Rx3000002e) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000002f),Dx10000000,16,16,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000002f),Cx20000000,Rx3000002f) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000030),Dx10000000,16,16,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000030),Cx20000000,Rx30000030) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000031),{Dx10000000},1,992,248,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000031),Cx20000000,Rx30000031) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dc89000),&(1024),Rx30000031,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000031) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000004),Cx20000000,Mx40000031,Mx4000002e,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000004) => 0x00000008
(...)
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000004) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000004) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000004) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000031) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000031) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000031),{Dx10000000},1,32,31,12,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000031),Cx20000000,Rx30000031) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7d000),&(64),Rx30000031,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000031) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000005),Cx20000000,Mx40000031,Mx40000029,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000005) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000005) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000005) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000031) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000031) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000031),{Dx10000000},1,16,16,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000031),Cx20000000,Rx30000031) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7d000),&(64),Rx30000031,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000031) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000006),Cx20000000,Mx40000031,Mx4000002f,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000006) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000006) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000006) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000031) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000031) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000031),{Dx10000000},1,16,16,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000031),Cx20000000,Rx30000031) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7d000),&(64),Rx30000031,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000031) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000007),Cx20000000,Mx40000031,Mx40000030,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000007) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000007) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000031) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000031) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000031),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000031),Cx20000000,Rx30000031) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000032),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000032),Cx20000000,Rx30000032) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000033),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000033),Cx20000000,Rx30000033) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000034),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000034),Cx20000000,Rx30000034) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000035),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000035),Cx20000000,Rx30000035) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000036),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000036),Cx20000000,Rx30000036) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000037),Dx10000000,32,31,11,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000037),Cx20000000,Rx30000037) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000038),Dx10000000,64,93,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000038),Cx20000000,Rx30000038) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000039),Dx10000000,64,93,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000039),Cx20000000,Rx30000039) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000003a),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003a),Cx20000000,Rx3000003a) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000003b),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003b),Cx20000000,Rx3000003b) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000003c),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003c),Cx20000000,Rx3000003c) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000003d),Dx10000000,64,47,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003d),Cx20000000,Rx3000003d) => 0x00000000
[22:03:12] Working on Protein
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000008),Cx20000000,Mx4000003e,Mx40000031,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000008) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000008) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000008) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000009),Cx20000000,Mx4000003e,Mx40000032,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000009) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000009) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000000a),Cx20000000,Mx4000003e,Mx40000033,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000a) => 0x00000008
(...)
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000a) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000a) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000a) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000000b),Cx20000000,Mx4000003e,Mx40000034,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000b) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000b) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000b) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000000c),Cx20000000,Mx4000003e,Mx40000035,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000c) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000c) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000c) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000000d),Cx20000000,Mx4000003e,Mx40000036,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000d) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000d) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000d) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,32,31,11,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd7f000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000000e),Cx20000000,Mx4000003e,Mx40000037,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000e) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000e) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000e) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,64,93,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd69000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000000f),Cx20000000,Mx4000003e,Mx40000038,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000f) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000f) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000f) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000f) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000000f) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,64,93,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd69000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000010),Cx20000000,Mx4000003e,Mx40000039,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000010) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000010) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000010) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000010) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000010) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,64,47,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd75000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000011),Cx20000000,Mx4000003e,Mx4000003a,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000011) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000011) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000011) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000011) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000011) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,64,47,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd75000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000012),Cx20000000,Mx4000003e,Mx4000003b,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000012) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000012) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000012) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,64,47,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd75000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000013),Cx20000000,Mx4000003e,Mx4000003c,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000013) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000013) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000013) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003e),{Dx10000000},1,64,47,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd75000),&(64),Rx3000003e,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003e) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000014),Cx20000000,Mx4000003e,Mx4000003d,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000014) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000014) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000014) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000014) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003e) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000003e),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003e),Cx20000000,Rx3000003e) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx3000003f),{Dx10000000},1,48,62,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003f),Cx20000000,Rx3000003f) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd71000),&(64),Rx3000003f,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx3000003f) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000015),Cx20000000,Mx4000003f,Mx4000003e,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000015) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx4000003f) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx3000003f) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx3000003f),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx4000003f),Cx20000000,Rx3000003f) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000040),{Dx10000000},1,48,62,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000040),Cx20000000,Rx30000040) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd71000),&(64),Rx30000040,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000040) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000016),Cx20000000,Mx40000040,Mx4000003f,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000016) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000016) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000016) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000016) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000040) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000040) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000040),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000040),Cx20000000,Rx30000040) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000041),{Dx10000000},1,48,62,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000041),Cx20000000,Rx30000041) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd71000),&(64),Rx30000041,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000041) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000017),Cx20000000,Mx40000041,Mx40000040,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000017) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000017) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000017) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000041) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000041) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000041),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000041),Cx20000000,Rx30000041) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000042),{Dx10000000},1,48,62,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000042),Cx20000000,Rx30000042) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd71000),&(64),Rx30000042,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000042) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000018),Cx20000000,Mx40000042,Mx40000041,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000018) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000042) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000042) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000042),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000042),Cx20000000,Rx30000042) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000043),{Dx10000000},1,48,62,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000043),Cx20000000,Rx30000043) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd71000),&(64),Rx30000043,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000043) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000019),Cx20000000,Mx40000043,Mx40000042,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000019) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000019) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000019) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000019) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000043) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000043) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000043),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000043),Cx20000000,Rx30000043) => 0x00000000
(...)
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000060),Dx10000000,32,31,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000060),Cx20000000,Rx30000060) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000001a),Cx20000000,Mx40000061,Mx40000043,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001a) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001a) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001a) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000001b),Cx20000000,Mx40000061,Mx40000044,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001b) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001b) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001b) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000001c),Cx20000000,Mx40000061,Mx40000045,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001c) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001c) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001c) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000001d),Cx20000000,Mx40000061,Mx4000004c,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001d) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001d) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001d) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000001e),Cx20000000,Mx40000061,Mx4000004d,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001e) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001e) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001e) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex9000001f),Cx20000000,Mx40000061,Mx4000004e,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001f) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001f) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex9000001f) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000020),Cx20000000,Mx40000061,Mx4000004f,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000020) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000020) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000020) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000021),Cx20000000,Mx40000061,Mx40000050,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000021) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000021) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000021) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000022),Cx20000000,Mx40000061,Mx40000052,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000022) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000022) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000022) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000023),Cx20000000,Mx40000061,Mx40000053,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000023) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000023) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000023) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000024),Cx20000000,Mx40000061,Mx40000054,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000024) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000024) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000024) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000025),Cx20000000,Mx40000061,Mx40000055,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000025) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000025) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000025) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000026),Cx20000000,Mx40000061,Mx40000058,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000026) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000026) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000026) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000061),{Dx10000000},1,32,31,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd79000),&(64),Rx30000061,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000061) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000027),Cx20000000,Mx40000061,Mx40000059,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000027) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000027) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000027) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000061) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000061) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000061),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000061),Cx20000000,Rx30000061) => 0x00000000
trace:cal:wine_calResAllocRemote2D calResAllocRemote2D(&(Rx30000062),{Dx10000000},1,48,62,13,0x2) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000062),Cx20000000,Rx30000062) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd71000),&(64),Rx30000062,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000062) => 0x00000000
trace:cal:wine_calMemCopy calMemCopy(&(Ex90000028),Cx20000000,Mx40000062,Mx40000061,0x0) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000028) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000028) => 0x00000008
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000028) => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx20000000,Ex90000028) => 0x00000000
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000062) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000062) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000062),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000062),Cx20000000,Rx30000062) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000063),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000063),Cx20000000,Rx30000063) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000064),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000064),Cx20000000,Rx30000064) => 0x00000000
trace:cal:wine_calResAllocLocal2D calResAllocLocal2D(&(Rx30000065),Dx10000000,48,62,13,0x0) => 0x00000000
trace:cal:wine_calCtxGetMem calCtxGetMem(&(Mx40000065),Cx20000000,Rx30000065) => 0x00000000
trace:cal:wine_calclCompile calclCompile(&(Ox0x7d518028),1,*x0x60d010,5) => 0x00000000
trace:cal:wine_calclGetErrorString calclGetErrorString() => "No error"
trace:cal:wine_calclLink calclLink(&(Ix0x7d51ff40),{Ox0x7d518028},1) => 0x00000000
trace:cal:wine_calModuleLoad calModuleLoad(&(Mx80000002),Cx20000000,Ix0x7d51ff40) => 0x00000000
trace:cal:wine_calResMap calResMap(&(*x0x7dd80000),&(128),Rx30000001,0x0) => 0x00000000
trace:cal:wine_calResUnmap calResUnmap(Rx30000001) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000015),Cx20000000,Mx80000002,"cb0") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000015,Mx40000001) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000014),Cx20000000,Mx80000002,"o0") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000014,Mx4000002a) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000013),Cx20000000,Mx80000002,"o1") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000013,Mx4000002b) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000012),Cx20000000,Mx80000002,"o2") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000012,Mx4000002c) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000011),Cx20000000,Mx80000002,"o3") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000011,Mx4000002d) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx6000000b),Cx20000000,Mx80000002,"i0") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx6000000b,Mx40000021) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx6000000a),Cx20000000,Mx80000002,"i1") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx6000000a,Mx40000029) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000009),Cx20000000,Mx80000002,"i2") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000009,Mx4000002f) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000008),Cx20000000,Mx80000002,"i3") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000008,Mx40000030) => 0x00000000
trace:cal:wine_calModuleGetName calModuleGetName(&(Nx60000007),Cx20000000,Mx80000002,"i4") => 0x00000000
trace:cal:wine_calCtxSetMem calCtxSetMem(Cx20000000,Nx60000007,Mx4000002e) => 0x00000000
trace:cal:wine_calModuleGetEntry calModuleGetEntry(&(Fx50000002),Cx20000000,Mx80000002,"main") => 0x00000000
trace:cal:wine_calCtxIsEventDone calCtxIsEventDone(Cx00df8e20,Ex50000002) => 0x00000006
Run: exception thrown during GuardedRun
[22:03:13] Client config found, loading data.
[22:03:13] Starting GUI Server
[22:03:13] Run: exception thrown during GuardedRun
[22:03:13] Run: exception thrown in GuardedRun -- Gromacs cannot continue further.
[22:03:13] Going to send back what have done -- stepsTotalG=10000000
[22:03:13] Work fraction=0.0000 steps=10000000.
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000000) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000000) => 0x00000000
(...)
trace:cal:wine_calCtxReleaseMem calCtxReleaseMem(Cx20000000,Mx40000020) => 0x00000000
trace:cal:wine_calResFree calResFree(Rx30000020) => 0x00000000
trace:cal:wine_calModuleUnload calModuleUnload(Cx20000000,Mx80000000) => 0x00000000
trace:cal:wine_calModuleUnload calModuleUnload(Cx20000000,Mx80000001) => 0x00000000
trace:cal:wine_calCtxDestroy calCtxDestroy(Cx20000000) => 0x00000000
trace:cal:wine_calDeviceClose calDeviceClose(Dx10000000) => 0x00000000
trace:cal:wine_calShutdown calShutdown() => 0x00000000
[22:03:17] logfile size=16714 infoLength=16714 edr=0 trr=23
[22:03:17] - Writing 17250 bytes of core data to disk...
[22:03:17] Done: 16738 -> 5547 (compressed to 33.1 percent)
[22:03:17]   ... Done.
[22:03:17]
[22:03:17] Folding@home Core Shutdown: EARLY_UNIT_END
[22:03:20] CoreStatus = 72 (114)
[22:03:20] Sending work to server
[22:03:20] Project: 5746 (Run 4, Clone 20, Gen 256)


[22:03:20] + Attempting to send results [August 4 22:03:20 UTC]
[22:03:20] - Reading file work/wuresults_02.dat from core
[22:03:20]   (Read 6059 bytes from disk)
[22:03:20] - Presenting message box asking to network.
Anachron
 
Posts: 50
Joined: Fri Mar 14, 2008 12:10 pm

Re: CAL Wrapper (Ready for Testing)

Postby herbak » Sat Mar 27, 2010 12:04 pm

FWIW: I just tried re-building the wrapper here on a 32-bit Linux system (P3 CPU, 384 MB RAM, Xubuntu 9.10).

Wrapper built fine but the folding GPU stuff didn't run.
Here are some details anyway:

ATI Radeon HD 4350 card (old PCI connect).
Latest ATI drivers installed (as of 2010-03-26), all graphics/video seems fine.
ATI Stream SDK v2.01 installed and all code compiles and links; wrappers placed in /usr/lib/wine.
Wine is v 1.0.1.

FAH windows GPU client invoked via:
Code: Select all
wine Folding@home-Win32-GPU.exe -forcegpu ati_r700


Log of run:
Code: Select all
. . .
[11:34:24] + 1091180 bytes downloaded
[11:34:24] Verifying core Core_11.fah...
[11:34:24] Signature is VALID
[11:34:24]
[11:34:24] Trying to unzip core FahCore_11.exe
[11:34:26] Decompressed FahCore_11.exe (3203072 bytes) successfully
[11:34:31] + Core successfully engaged
[11:34:36]
[11:34:36] + Processing work unit
[11:34:36] Core required: FahCore_11.exe
[11:34:36] Core found.
[11:34:36] Working on queue slot 01 [March 27 11:34:36 UTC]
[11:34:36] + Working ...
[11:34:36]
[11:34:36] *------------------------------*
[11:34:36] Folding@Home GPU Core - Beta
[11:34:36] Version 1.24 (Mon Feb 9 11:00:12 PST 2009)
[11:34:36]
[11:34:36] Compiler  : Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.762 for 80x86
[11:34:36] Build host: amoeba
[11:34:36] Board Type: AMD
[11:34:36] Core      :
[11:34:36] Preparing to commence simulation
[11:34:36] - Looking at optimizations...
[11:34:36] - Created dyn
[11:34:36] - Files status OK
[11:34:37] - Expanded 96498 -> 489152 (decompressed 506.9 percent)
[11:34:37] Called DecompressByteArray: compressed_data_size=96498 data_size=489152, decompressed_data_size=489152 diff=0
[11:34:37] - Digital signature verified
[11:34:37]
[11:34:37] Project: 5737 (Run 2, Clone 35, Gen 758)
[11:34:37]
[11:34:37] Assembly optimizations on if available.
[11:34:37] Entering M.D.
Reading file work/wudata_01.tpr, VERSION 3.1.4 (single precision)
Reading file work/wudata_01.tpr, VERSION 3.1.4 (single precision)
Reading sasa-enabled ir 0 0
[11:34:43] Tpr hash work/wudata_01.tpr:  2893852549 2103173867 294454491 1669875986 372063438
Issues between syncs set at 16
In override calInit
calLoadBinary
Run: exception thrown during GuardedRun
[11:34:44] Run: exception thrown during GuardedRun
[11:34:44] Run: exception thrown in GuardedRun -- Gromacs cannot continue further.
[11:34:44] Going to send back what have done -- stepsTotalG=0
[11:34:44] Work fraction=0.0000 steps=0.
[11:34:48] logfile size=5062 infoLength=5062 edr=0 trr=23
[11:34:48] - Writing 5598 bytes of core data to disk...
[11:34:48] Done: 5086 -> 1902 (compressed to 37.3 percent)
[11:34:48]   ... Done.
[11:34:48]
[11:34:48] Folding@home Core Shutdown: UNSTABLE_MACHINE
[11:34:50] CoreStatus = 7A (122)
[11:34:50] Sending work to server
herbak
 
Posts: 23
Joined: Fri Mar 12, 2010 10:09 am

Re: CAL Wrapper (Ready for Testing)

Postby herbak » Thu Apr 01, 2010 2:01 pm

Anachron wrote:The function calCtxIsEventDone(CALcontext ctx, CALevent event) here seems to be passed an erroneous CALevent.
As you can see from calModuleGetEntry(CALfunc* func, ...) the first parameter is a pointer to a CALfunc. This handle is passed as a CALevent to calCtxIsEventDone. This has to be wrong, or what?


I get to the same point.
I tweaked the makefiles a little, cleaned up some code, added a little extra tracing and re-built against the latest and greatest ATI Stream SDK v2.01 on a 32-bit Pentium3 box running Xubuntu 9.04.

FAH GPU client output, together with some Wine debug trace:
Code: Select all
[10:55:05] Client config found, loading data.
[10:55:05] Starting GUI Server
. . .
trace:amdcalrt:wine_calModuleGetEntry calModuleGetEntry(&(Fx50000002),Cx20000000,Mx80000002,"main") => 0x00000000
trace:amdcalrt:wine_calCtxIsEventDone calCtxIsEventDone(Cx00a6e370,Ex50000002) => 0x00000006
trace:amdcalrt:wine_calCtxIsEventDone calCtxIsEventDone - ErrString: A handle parameter is invalid
Run: exception thrown during GuardedRun
[10:55:06] Run: exception thrown during GuardedRun
[10:55:06] Run: exception thrown in GuardedRun -- Gromacs cannot continue further.
. . .
[10:55:15] CoreStatus = 72 (114)


calModuleGetEntry succeeds, calCtxIsEventDone returns with CAL_RESULT_BAD_HANDLE (6, as defined in cal.h) and a call immediately following this to calGetErrorString() (in the Wine shim) confirms this with the text "A handle parameter is invalid".

Without seeing at least this part of the client code, difficult to say why an invalid parameter would be passed here. Could also be a threading/timing thing, but I don't know / can't say for sure sitting this end of the calNNN() calls.
herbak
 
Posts: 23
Joined: Fri Mar 12, 2010 10:09 am

Re: CAL Wrapper (Ready for Testing)

Postby MtM » Thu Oct 28, 2010 2:08 am

Hey there wrapper authors!

I need some help. I'm writing an app which does environment checks/reads and based on that it run's folding clients. It also monitors sensors ( load, temp, gpu core load, memory load, memory controller load ect ect ). I'm doing this in .net so I'm using wrappers for opencl/cuda/cal detection. But, the cal wrapper I'm using doesn't work, my app is x86 but when run on an x64 os the cal.net.dll only runs with x86 amdcalcl.dll, and then it can only do cal.init and cal.runtime.getruntimeversion. I can get device count, but when I try to get device attributes it fails because the value supplied is wrong ( it's trying to pass a structure defined for x64 to an dll which expects it to be diffrent.

Not sure what to do, it's also very late and I don't have a fresh mind atm but I do wonder if you had an idea on how to fix this.

the test app is on the google code page downloads tab, the source hasn't been updated yet but the one on the svn has the same cal functions.

I would really appriciate any help you could give me.
MtM
 
Posts: 3233
Joined: Fri Jun 27, 2008 2:20 pm
Location: The Netherlands

Re: CAL Wrapper (Ready for Testing)

Postby herbak » Thu Nov 11, 2010 7:18 pm

MtM wrote: I'm doing this in .net so I'm using wrappers for opencl/cuda/cal detection. But, the cal wrapper I'm using doesn't work,

Which wrapper(s)? You mean what you have written yourself using P/Invoke or do you mean something else?

MtM wrote:my app is x86 but when run on an x64 os

Ummm why? If you got a x64 OS then build a 64-bit app :-)
Not sure if this is relevant here but anyhow: .Net -> Windows -> thus a 64-bit version of the Windows OS is required, it's not enough to have "just" a 64-bit CPU.

MtM wrote:the cal.net.dll

which cal.net.dll? Your own?

MtM wrote:but when I try to get device attributes it fails because the value supplied is wrong ( it's trying to pass a structure defined for x64 to an dll which expects it to be diffrent.

Square pegs, round holes... not much more to say here.

MtM wrote:the test app is on the google code page downloads tab

Might have been useful to supply a URL...

MtM wrote:the source hasn't been updated yet

So update it and maybe I'll take a look...

MtM wrote:but the one on the svn has the same cal functions.

Could you be more specific? Which svn? Which cal functions (if you mean only cal.init and cal.runtime.getruntimeversion then you're rather limited!)
herbak
 
Posts: 23
Joined: Fri Mar 12, 2010 10:09 am

PreviousNext

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

Who is online

Users browsing this forum: No registered users and 1 guest

cron