mirror of https://github.com/PCSX2/pcsx2.git
911 lines
33 KiB
C
911 lines
33 KiB
C
/***************************************************************************
|
|
read.c - description
|
|
-------------------
|
|
begin : Sun Nov 16 2003
|
|
copyright : (C) 2003 by Pete Bernert
|
|
email : BlackDove@addcom.de
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. See also the license.txt file for *
|
|
* additional informations. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
//*************************************************************************//
|
|
// History of changes:
|
|
//
|
|
// 2003/11/16 - Pete
|
|
// - generic cleanup for the Peops release
|
|
//
|
|
//*************************************************************************//
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#define _IN_READ
|
|
#include "externals.h"
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
READTRACKFUNC pReadTrackFunc=NULL;
|
|
GETPTRFUNC pGetPtrFunc=NULL;
|
|
|
|
int iUseCaching=0;
|
|
int iTryAsync=0;
|
|
int iBufSel=0;
|
|
|
|
unsigned char * pMainBuffer=0;
|
|
unsigned char * pCurrReadBuf=0;
|
|
unsigned char * pFirstReadBuf=0;
|
|
unsigned char * pAsyncBuffer=0;
|
|
|
|
unsigned long lMaxAddr=0;
|
|
unsigned long lLastAddr = 0xFFFFFFFF;
|
|
unsigned long lLastAsyncAddr = 0xFFFFFFFF;
|
|
unsigned long lNeededAddr = 0xFFFFFFFF;
|
|
unsigned long lLastAccessedAddr = 0xFFFFFFFF;
|
|
int iLastAccessedMode=0;
|
|
|
|
unsigned char * ptrBuffer[2];
|
|
unsigned char * pAsyncFirstReadBuf[2];
|
|
|
|
|
|
#define MAXQSIZE 16
|
|
#define MAXQFETCH 8
|
|
|
|
unsigned long lAddrQ[MAXQSIZE];
|
|
int iQPos=0;
|
|
int iQIdle=0;
|
|
int iQLockPos=-1;
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// thread helper vars
|
|
|
|
HANDLE hReadThread = NULL;
|
|
BOOL bThreadEnded = FALSE;
|
|
HANDLE hThreadEvent[3];
|
|
HANDLE hThreadMutex[2];
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// internal MAXDATACACHE*64KB (4MB) data cache
|
|
|
|
#define MAXDATACACHE 64
|
|
unsigned long lDataCacheAddr[MAXDATACACHE];
|
|
unsigned char * pDataCacheBuf[MAXDATACACHE];
|
|
BOOL bDataCacheHit=FALSE;
|
|
int iUseDataCache=0;
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// main init func
|
|
|
|
void CreateREADBufs(void)
|
|
{
|
|
switch(iUseCaching)
|
|
{
|
|
case 4: iUseDataCache = 2; // use a special data cache on threadex reading
|
|
pReadTrackFunc = DoReadThreadEx;
|
|
pGetPtrFunc = GetREADThreadExPtr; break;
|
|
case 3: pReadTrackFunc = DoReadThread;
|
|
pGetPtrFunc = GetREADThreadPtr; break;
|
|
case 2: pReadTrackFunc = DoReadAsync;
|
|
pGetPtrFunc = NULL; break;
|
|
default: pReadTrackFunc = DoRead;
|
|
pGetPtrFunc = NULL; break;
|
|
}
|
|
|
|
hThreadEvent[0]=NULL; // clear events/mutex
|
|
hThreadEvent[1]=NULL;
|
|
hThreadEvent[2]=NULL;
|
|
hThreadMutex[0]=NULL;
|
|
hThreadMutex[1]=NULL;
|
|
|
|
AllocDataCache(); // build data cache, if wanted
|
|
|
|
lLastAddr = 0xFFFFFFFF;
|
|
lLastAsyncAddr = 0xFFFFFFFF;
|
|
iBufSel = 0;
|
|
|
|
if(iUseCaching) // some caching? need bigger buffer
|
|
pMainBuffer=(unsigned char *)malloc(MAXCDBUFFER);
|
|
else pMainBuffer=(unsigned char *)malloc(CDSECTOR+208+96);
|
|
|
|
pCurrReadBuf=pFirstReadBuf=pMainBuffer+FRAMEBUFEXTRA;
|
|
|
|
if(iUseCaching>=2) // async/thread mode
|
|
{
|
|
pAsyncBuffer=(unsigned char *)malloc(MAXCDBUFFER);
|
|
ptrBuffer[0]=pMainBuffer;
|
|
ptrBuffer[1]=pAsyncBuffer;
|
|
pAsyncFirstReadBuf[0]=pFirstReadBuf;
|
|
pAsyncFirstReadBuf[1]=pAsyncBuffer+FRAMEBUFEXTRA;
|
|
|
|
if(iUseCaching>=3) // thread mode
|
|
{
|
|
DWORD dw;
|
|
bThreadEnded = FALSE;
|
|
|
|
for(dw=0;dw<3;dw++) // -> create events
|
|
{
|
|
hThreadEvent[dw]=CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
ResetEvent(hThreadEvent[dw]);
|
|
}
|
|
for(dw=0;dw<2;dw++) // -> create mutex
|
|
{
|
|
hThreadMutex[dw]=CreateMutex(NULL,FALSE,NULL);
|
|
}
|
|
if(iUseCaching==3) // -> create thread
|
|
hReadThread=CreateThread(NULL,0,READThread,0,0,&dw);
|
|
else
|
|
{
|
|
for(dw=0;dw<MAXQSIZE;dw++) lAddrQ[dw]=0xFFFFFFFF;
|
|
iQPos=0;
|
|
iQLockPos=-1;
|
|
hReadThread=CreateThread(NULL,0,READThreadEx,0,0,&dw);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
pAsyncBuffer=0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
void FreeREADBufs(void)
|
|
{
|
|
if(hReadThread) // thread?
|
|
{
|
|
SetEvent(hThreadEvent[1]); // -> signal: end thread
|
|
while(!bThreadEnded) {Sleep(5L);} // -> wait til ended
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE);
|
|
ReleaseMutex(hThreadMutex[1]);
|
|
hReadThread=NULL; // -> clear handle
|
|
}
|
|
|
|
if(hThreadEvent[0]) CloseHandle(hThreadEvent[0]); // kill events/mutex
|
|
if(hThreadEvent[1]) CloseHandle(hThreadEvent[1]);
|
|
if(hThreadEvent[2]) CloseHandle(hThreadEvent[2]);
|
|
if(hThreadMutex[0]) CloseHandle(hThreadMutex[0]);
|
|
if(hThreadMutex[1]) CloseHandle(hThreadMutex[1]);
|
|
|
|
if(pMainBuffer) free(pMainBuffer); // free main data buf
|
|
pMainBuffer=NULL;
|
|
if(pAsyncBuffer) free(pAsyncBuffer); // free async data buf
|
|
pAsyncBuffer=NULL;
|
|
|
|
FreeDataCache();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// retry on readng error (blocking)
|
|
|
|
BOOL bReadRetry(FRAMEBUF * f)
|
|
{
|
|
int iRetry=0;
|
|
|
|
while (iRetry<iMaxRetry)
|
|
{
|
|
if(pReadFunc(TRUE,f)==SS_COMP) break; // try sync read
|
|
iRetry++;
|
|
}
|
|
|
|
if(iRetry==iMaxRetry) // no success?
|
|
{
|
|
if(iShowReadErr) // -> tell it to user
|
|
{
|
|
char szB[64];
|
|
wsprintf(szB,"Read error on address %08lx!",f->dwFrame);
|
|
MessageBox(NULL,szB,libraryName,MB_OK);
|
|
}
|
|
return FALSE; // -> tell emu: bad
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
// sync modes (caching 0 and 1)
|
|
// just reads one or more blocks, and always waits until
|
|
// reading is done
|
|
/////////////////////////////////////////////////////////
|
|
|
|
BOOL DoRead(unsigned long addr)
|
|
{
|
|
FRAMEBUF * f;
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
if(iUseCaching && // cache block available?
|
|
lLastAddr!=0xFFFFFFFF &&
|
|
addr>=lLastAddr && // and addr in block?
|
|
addr<=(lLastAddr+MAXCACHEBLOCK))
|
|
{
|
|
pCurrReadBuf=pFirstReadBuf+ // -> calc data ptr
|
|
((addr-lLastAddr)*iUsedBlockSize);
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf); // -> apply ppf
|
|
return TRUE; // -> done
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
if(iUseDataCache && CheckDataCache(addr)) // cache used and data is in cache? set read ptr, if yes
|
|
return TRUE; // -> also fine
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
f=(FRAMEBUF *)pMainBuffer; // setup read for one sector
|
|
|
|
f->dwFrameCnt = 1;
|
|
f->dwBufLen = iUsedBlockSize;
|
|
f->dwFrame = addr;
|
|
|
|
pCurrReadBuf=pFirstReadBuf;
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
if(iUseCaching) // cache block?
|
|
{
|
|
if((addr+MAXCACHEBLOCK)<lMaxAddr) // and big read is possible?
|
|
{
|
|
f->dwFrameCnt = MAXCACHEBLOCK+1; // -> set bigger read
|
|
f->dwBufLen = (MAXCACHEBLOCK+1)*iUsedBlockSize;
|
|
lLastAddr = addr; // -> store addr of block
|
|
}
|
|
else
|
|
{
|
|
lLastAddr=0xFFFFFFFF; // no caching, no block addr
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
if(pReadFunc(TRUE,f)!=SS_COMP) // do a waiting read
|
|
{
|
|
if(!bReadRetry(f)) return FALSE; // and retry on error
|
|
}
|
|
|
|
if(iUseDataCache && lLastAddr!=0xFFFFFFFF) // data cache used? and whole 64 k read block?
|
|
AddToDataCache(addr,pFirstReadBuf); // -> add the complete data to cache
|
|
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf); // apply ppf
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
// async mode (caching 2)
|
|
// this mode works fine with ASPI...
|
|
// the first read will be done sync, though, only the
|
|
// additional pre-fetching will be done async...
|
|
// well, with mdecs most reads will be prefetched, so
|
|
// speed is good... with IOCTL this mode is more like
|
|
// a 'double sync' reading, since IOCTL seems always
|
|
// to be blocking (see also notes for caching mode 3)
|
|
/////////////////////////////////////////////////////////
|
|
|
|
BOOL DoReadAsync(unsigned long addr)
|
|
{
|
|
FRAMEBUF * f;
|
|
|
|
////////////////////////////////////////////////////////
|
|
// 1. check if data is in already filled buffer
|
|
|
|
if(lLastAddr!=0xFFFFFFFF &&
|
|
addr>=lLastAddr &&
|
|
addr<=(lLastAddr+MAXCACHEBLOCK))
|
|
{
|
|
pCurrReadBuf=pAsyncFirstReadBuf[iBufSel]+
|
|
((addr-lLastAddr)*iUsedBlockSize);
|
|
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf);
|
|
|
|
iTryAsync=0;
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// check data cache
|
|
|
|
if(iUseDataCache && CheckDataCache(addr)) // cache used and data is in cache? set read ptr, if yes
|
|
return TRUE; // -> also fine
|
|
|
|
////////////////////////////////////////////////////////
|
|
// 2. not in main buffer? wait for async to be finished
|
|
|
|
if(bDoWaiting)
|
|
{
|
|
WaitGenEvent(0xFFFFFFFF);bDoWaiting=FALSE;
|
|
if(sx.SRB_Status!=SS_COMP) lLastAsyncAddr=0xFFFFFFFF;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// 3. check in asyncbuffer. if yes, swap buffers and do next async read
|
|
|
|
if(lLastAsyncAddr!=0xFFFFFFFF &&
|
|
addr>=lLastAsyncAddr &&
|
|
addr<=(lLastAsyncAddr+MAXCACHEBLOCK))
|
|
{
|
|
int iAsyncSel=iBufSel; // store old buf num
|
|
if(iBufSel==0) iBufSel=1; else iBufSel=0; // toggle to new num
|
|
|
|
lLastAddr=lLastAsyncAddr; // set adr of block
|
|
pCurrReadBuf=pAsyncFirstReadBuf[iBufSel]+ // set data ptr
|
|
((addr-lLastAddr)*iUsedBlockSize);
|
|
|
|
if(iUseDataCache) // data cache used?
|
|
AddToDataCache(lLastAddr,pAsyncFirstReadBuf[iBufSel]); // -> add the complete 64k data to cache
|
|
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf); // apply ppf
|
|
|
|
iTryAsync=0; // data was async, reset count
|
|
addr=lLastAddr+MAXCACHEBLOCK+1; // calc adr of next prefetch
|
|
if(!((addr+MAXCACHEBLOCK)<lMaxAddr)) // mmm, no whole block can be done... so we do no prefetch at all
|
|
{lLastAsyncAddr=0xFFFFFFFF;return TRUE;}
|
|
|
|
f=(FRAMEBUF *)ptrBuffer[iAsyncSel]; // setup prefetch addr
|
|
f->dwFrameCnt = MAXCACHEBLOCK+1;
|
|
f->dwBufLen = (MAXCACHEBLOCK+1)*iUsedBlockSize;
|
|
f->dwFrame = addr;
|
|
|
|
lLastAsyncAddr=addr; // store prefetch addr
|
|
|
|
if(pReadFunc(FALSE,f)!=SS_COMP) // start the async read
|
|
lLastAsyncAddr=0xFFFFFFFF; // -> if no success, no async prefetch buf available
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// here we do a sync read
|
|
|
|
iBufSel=0; // read in buf 0
|
|
|
|
f=(FRAMEBUF *)ptrBuffer[0];
|
|
f->dwFrame = addr;
|
|
|
|
pCurrReadBuf=pFirstReadBuf;
|
|
|
|
////////////////////////////////////////////////////////
|
|
// if it's possible, we do a bigger read
|
|
|
|
if((addr+MAXCACHEBLOCK)<lMaxAddr)
|
|
{
|
|
f->dwFrameCnt = MAXCACHEBLOCK+1;
|
|
f->dwBufLen = (MAXCACHEBLOCK+1)*iUsedBlockSize;
|
|
lLastAddr = addr;
|
|
}
|
|
else
|
|
{
|
|
f->dwFrameCnt = 1;
|
|
f->dwBufLen = iUsedBlockSize;
|
|
lLastAddr = 0xFFFFFFFF;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// start read, wait til finished
|
|
|
|
if(pReadFunc(TRUE,f)!=SS_COMP)
|
|
{
|
|
if(!bReadRetry(f)) return FALSE;
|
|
}
|
|
|
|
if(iUseDataCache && lLastAddr!=0xFFFFFFFF) // data cache used? and complete 64k block?
|
|
AddToDataCache(addr,pAsyncFirstReadBuf[0]); // -> add the complete data to cache
|
|
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf);
|
|
|
|
////////////////////////////////////////////////////////
|
|
// start additional async prefetch read, if it's ok
|
|
|
|
iTryAsync++;
|
|
if(iTryAsync>1) {iTryAsync=2;return TRUE;} // prefetches seems to be useless right now, so turn them off until next real read
|
|
|
|
addr+=MAXCACHEBLOCK+1; // prefetch addr
|
|
if(!((addr+MAXCACHEBLOCK)<lMaxAddr)) // not possible? do't do prefetch
|
|
{lLastAsyncAddr=0xFFFFFFFF;return TRUE;}
|
|
|
|
f=(FRAMEBUF *)ptrBuffer[1]; // setup prefetch into buf 1
|
|
f->dwFrameCnt = MAXCACHEBLOCK+1;
|
|
f->dwBufLen = (MAXCACHEBLOCK+1)*iUsedBlockSize;
|
|
f->dwFrame = addr;
|
|
|
|
lLastAsyncAddr= addr;
|
|
|
|
if(pReadFunc(FALSE,f)!=SS_COMP) // start the async prefetch
|
|
lLastAsyncAddr=0xFFFFFFFF;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
// thread mode (caching 3)
|
|
// this mode helps with slower drives using the IOCTL
|
|
// interface (since that one seems to do always blocking
|
|
// reads, even when they are done overlapped).
|
|
// With ASPI, the thread mode performance will be more or less
|
|
// the same as with async caching mode 2...
|
|
// thread reading would be much more powerful, if the main
|
|
// emu would do:
|
|
// ...
|
|
// CDRreadTrack()
|
|
// ... do some other stuff here ...
|
|
// CDRgetBuffer()
|
|
// ...
|
|
// but lazy main emu coders seem to prefer:
|
|
// ...
|
|
// CDRreadTrack()
|
|
// CDRgetBuffer()
|
|
// ...
|
|
// so there is no time between the calls to do a good
|
|
// asynchronous read... sad, sad...
|
|
/////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// reading thread... sleeps until a new read is signaled
|
|
|
|
DWORD WINAPI READThread(LPVOID lpParameter)
|
|
{
|
|
FRAMEBUF * f;
|
|
|
|
while(WaitForMultipleObjects(2,hThreadEvent,FALSE, // wait until event to start (or event to end) get raised
|
|
INFINITE)==WAIT_OBJECT_0)
|
|
{
|
|
WaitForSingleObject(hThreadMutex[0],INFINITE); // read mutex: nobody else is allowed to read now
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE); // variable access mutex: nobody else can change the vars now
|
|
ResetEvent(hThreadEvent[0]); // ok, kick event has been handled
|
|
SetEvent(hThreadEvent[2]); // set flag: we have started the read
|
|
|
|
lLastAsyncAddr = lNeededAddr; // setup read and vars
|
|
f=(FRAMEBUF *)ptrBuffer[!iBufSel]; // !iSel = async buffer
|
|
f->dwFrame = lNeededAddr;
|
|
f->dwFrameCnt = min((lMaxAddr-lNeededAddr+1),(MAXCACHEBLOCK+1));
|
|
f->dwBufLen = f->dwFrameCnt*iUsedBlockSize;
|
|
|
|
ReleaseMutex(hThreadMutex[1]); // ok, vars have been changed, now that vars are again available for all
|
|
|
|
if(pReadFunc(TRUE,f)!=SS_COMP) // do a blocking (sync) read
|
|
{
|
|
bReadRetry(f); // mmm... if reading fails a number of times, we don't have a chance to return 'bad' to emu with tread reading... life is hard :)
|
|
}
|
|
|
|
ReleaseMutex(hThreadMutex[0]); // ok, read has done
|
|
}
|
|
|
|
bThreadEnded=1;
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// emu says: we need data at given addr soon...
|
|
// so, if we don't have it in any buffer, we kick a read
|
|
// ... called on CDRreadTrack()
|
|
|
|
BOOL DoReadThread(unsigned long addr)
|
|
{
|
|
if(!hReadThread) return FALSE; // no thread, no fun
|
|
|
|
bDataCacheHit=FALSE; // init data cache hit flag (even if no cache is used...)
|
|
|
|
if(lLastAddr!=0xFFFFFFFF && // data is in curr data buffer?
|
|
addr>=lLastAddr &&
|
|
addr<=(lLastAddr+MAXCACHEBLOCK))
|
|
return TRUE; // -> fine
|
|
|
|
if(iUseDataCache && CheckDataCache(addr)) // data cache used and data is in cache? set read ptr, if yes
|
|
{bDataCacheHit=TRUE;return TRUE;} // -> and raise 'hit' flag, so we don't need to do anything in 'getbuffer'
|
|
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE); // wait to access 'buffer 1 vars'
|
|
|
|
if(lLastAsyncAddr!=0xFFFFFFFF && // data is (or will be soon if reading is going on in thread now) in async buffer?
|
|
addr>=lLastAsyncAddr &&
|
|
addr<=(lLastAsyncAddr+MAXCACHEBLOCK))
|
|
{
|
|
ReleaseMutex(hThreadMutex[1]); // -> fine
|
|
return TRUE;
|
|
}
|
|
// data is not in buf0 and not in buf1:
|
|
lNeededAddr=addr; // set needed adr (mutex is active, so it's safe to change that)
|
|
ResetEvent(hThreadEvent[2]); // reset "read has started" flag
|
|
SetEvent(hThreadEvent[0]); // set "start read" flag... the read will start reading soon after
|
|
ReleaseMutex(hThreadMutex[1]); // done with var access
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// emu says: gimme ptr to needed data... this will
|
|
// automatically do an async data prefetch read as well
|
|
// ... called on CDRgetBuffer()
|
|
|
|
void GetREADThreadPtr(void)
|
|
{
|
|
unsigned long addr=lLastAccessedAddr;
|
|
|
|
if(bDataCacheHit) return; // if we had a data cache hit, the readbuf ptr is already fine, nothing else to do
|
|
|
|
if(lLastAddr!=0xFFFFFFFF && // data is in buffer 0?
|
|
addr>=lLastAddr &&
|
|
addr<=(lLastAddr+MAXCACHEBLOCK))
|
|
{
|
|
pCurrReadBuf=pAsyncFirstReadBuf[iBufSel]+ // -> ok, return curr data buffer ptr
|
|
((addr-lLastAddr)*iUsedBlockSize);
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf);
|
|
return;
|
|
}
|
|
|
|
WaitForSingleObject(hThreadEvent[2],INFINITE); // wait until reading has started (it will take a small time after the read start kick, so we have to go sure that it has _really_ started)
|
|
WaitForSingleObject(hThreadMutex[0],INFINITE); // wait until reading has finished
|
|
|
|
lLastAddr=lLastAsyncAddr; // move data to from async data to curr data buffer (by toggling iSel)
|
|
iBufSel=!iBufSel;
|
|
lLastAsyncAddr=0xFFFFFFFF; // nothing in async data buffer now
|
|
|
|
lNeededAddr=addr+MAXCACHEBLOCK+1; // prefetch read addr
|
|
ResetEvent(hThreadEvent[2]); // reset "read has started" flag
|
|
SetEvent(hThreadEvent[0]); // signal for start next read
|
|
ReleaseMutex(hThreadMutex[0]); // ok, now reading in buffer 1 can start
|
|
|
|
if(iUseDataCache) // data cache used? can be less then 64 kb with thread reading, but that doesn't matter here... will be either 64 k or (max-addr) sectors
|
|
AddToDataCache(lLastAddr,
|
|
pAsyncFirstReadBuf[iBufSel]); // -> add the complete data to cache
|
|
|
|
pCurrReadBuf=pAsyncFirstReadBuf[iBufSel]+ // -> return the curr data buffer ptr
|
|
((addr-lLastAddr)*iUsedBlockSize);
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
// special thread mode (caching 4)
|
|
// this mode helps with certain drives
|
|
// basically it does the following:
|
|
// It has a queue for n prefetch reads. If the main emu is
|
|
// asking for an addr, the mode will check, if
|
|
// this addr is a) getting read right now, b) already
|
|
// in our 4 MB cache, c) already in the q.
|
|
// If no condition matches, it will add it in q...
|
|
// the same is done with the next n/2 addr blocks, so
|
|
// the q will keep the drive busy... also, if everything
|
|
// is cached (and the q is empty), we will add additional
|
|
// addresses to read, also to keep the drive busy, and to
|
|
// do the needed reading as soon as possible :)
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// reading thread...
|
|
|
|
DWORD WINAPI READThreadEx(LPVOID lpParameter)
|
|
{
|
|
FRAMEBUF * f;
|
|
|
|
while(WaitForMultipleObjects(2,hThreadEvent,FALSE, // wait until event to start (or event to end) get raised
|
|
INFINITE)==WAIT_OBJECT_0)
|
|
{
|
|
while(1)
|
|
{
|
|
//------------------------------------------------//
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE); // variable access mutex: nobody else can change the vars now
|
|
ResetEvent(hThreadEvent[0]); // ok, kick event has been handled
|
|
|
|
if(lAddrQ[iQPos]==0xFFFFFFFF) // nothing to do? strange :)
|
|
{ReleaseMutex(hThreadMutex[1]);break;}
|
|
|
|
f=(FRAMEBUF *)ptrBuffer[0];
|
|
lNeededAddr = lAddrQ[iQPos]; // store it in 'Neededaddr' for checks outside the thread
|
|
f->dwFrame = lNeededAddr;
|
|
f->dwFrameCnt = min((lMaxAddr-f->dwFrame+1),(MAXCACHEBLOCK+1));
|
|
f->dwBufLen = f->dwFrameCnt*iUsedBlockSize;
|
|
|
|
lAddrQ[iQPos++]=0xFFFFFFFF; // set this slot as 'done'
|
|
if(iQPos>=MAXQSIZE) iQPos=0; // amnd inc the head pos
|
|
|
|
ReleaseMutex(hThreadMutex[1]); // ok, vars have been changed, now that vars are again available for all
|
|
//------------------------------------------------//
|
|
WaitForSingleObject(hThreadMutex[0],INFINITE); // read mutex: nobody else is allowed to read now
|
|
if(!iCDROK)
|
|
{
|
|
ReleaseMutex(hThreadMutex[0]);
|
|
break;
|
|
}
|
|
|
|
if(bCDDAPlay) // some cdda security...
|
|
{ // it should just prevent prefetch reads happening in cdda mode, if this one breaks a 'needed' read, we are lost...
|
|
lNeededAddr=0xFFFFFFFF; // so maybe we should remove this check? mmm, we will see
|
|
ReleaseMutex(hThreadMutex[0]);
|
|
break;
|
|
}
|
|
|
|
if(pReadFunc(TRUE,f)!=SS_COMP) // do a blocking (sync) read
|
|
{ // mmm... if reading fails a number of times, we don't have a chance to return 'bad' to emu with thread reading... life is hard :)
|
|
bReadRetry(f); // but at least our 'wait for data in cache' getptr will not wait forever (just returning wrong data, ehehe)
|
|
}
|
|
|
|
ReleaseMutex(hThreadMutex[0]); // ok, read has done
|
|
//------------------------------------------------//
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE); // variable access mutex: nobody else can change the vars now
|
|
lNeededAddr=0xFFFFFFFF; // no read is now active
|
|
AddToDataCache(f->dwFrame,pFirstReadBuf); // add the complete data to cache
|
|
ReleaseMutex(hThreadMutex[1]); // ok, vars have been changed, now that vars are again available for all
|
|
//------------------------------------------------//
|
|
if(WaitForSingleObject(hThreadEvent[0],0)!=WAIT_OBJECT_0)
|
|
Sleep(1); // if nobody has started a new kick, let's sleep awhile to give Windows more room to breath
|
|
}
|
|
}
|
|
|
|
bThreadEnded=1;
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// emu says: we need data at given addr soon...
|
|
// so, if we don't have it in any buffer, we kick a read
|
|
// ... called on CDRreadTrack()
|
|
|
|
//#define THREADEX_STRAIGHT
|
|
|
|
BOOL DoReadThreadEx(unsigned long addr)
|
|
{
|
|
int i,k,j=0;
|
|
|
|
if(!hReadThread) return FALSE; // no thread, no fun
|
|
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE); // wait for data access
|
|
|
|
//-----------------------------------------------------//
|
|
// straight reading try... should have been faster, but
|
|
// in 'real life' this approach keeps the cdrom drive
|
|
// spinning too much, giving other pc resources no room
|
|
// to breath... by increasing the thread 'Sleep' value
|
|
// the performance can get better, but then the annoying
|
|
// breaks we wanted to fight will show up again...
|
|
// so this type is disabled as long as nobody enables the
|
|
// define again :)
|
|
|
|
#ifdef THREADEX_STRAIGHT
|
|
|
|
if(addr>=lNeededAddr &&
|
|
addr<=(lNeededAddr+MAXCACHEBLOCK))
|
|
{
|
|
ReleaseMutex(hThreadMutex[1]);
|
|
return TRUE;
|
|
}
|
|
|
|
for(k=0;k<MAXQSIZE;k++) // loop max of prefetch blocks
|
|
{
|
|
for(i=0;i<MAXDATACACHE;i++) // loop whole cache
|
|
{
|
|
if(addr>=lDataCacheAddr[i] && // -> addr found?
|
|
addr<=(lDataCacheAddr[i]+MAXCACHEBLOCK))
|
|
{
|
|
if(k==0) iQLockPos=i; // -> if it's the current main addr, lock it, so no prefetch read overwrites its content
|
|
break;
|
|
}
|
|
}
|
|
if(i!=MAXDATACACHE) // found in data cache?
|
|
{addr=addr+MAXCACHEBLOCK+1;continue;} // -> do nothing with this addr, we have its content
|
|
else break; // here is the first unknown addr
|
|
}
|
|
|
|
if(addr>=lMaxAddr) // check, if addr too big
|
|
{
|
|
ReleaseMutex(hThreadMutex[1]);
|
|
if(k==0) return FALSE; // -> if it's the main addr, there is an error
|
|
return TRUE; // -> otherwise we can't simply cache that addr
|
|
}
|
|
|
|
for(i=0;i<MAXQSIZE;i++) // loop q list
|
|
{
|
|
if(addr>=lAddrQ[i] && // -> addr will be read soon?
|
|
addr<=(lAddrQ[i]+MAXCACHEBLOCK))
|
|
{
|
|
addr=lAddrQ[i]; // --> take this aligned addr for new header
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(i=0;i<MAXQSIZE;i++) // loop q list
|
|
{
|
|
lAddrQ[i]=addr;
|
|
addr=addr+MAXCACHEBLOCK+1;
|
|
if(addr>=lMaxAddr) break;
|
|
}
|
|
|
|
for(;i<MAXQSIZE;i++) // loop q list
|
|
{
|
|
lAddrQ[i]=0xFFFFFFFF;
|
|
}
|
|
|
|
iQPos=0;
|
|
|
|
SetEvent(hThreadEvent[0]); // kick a read, if neccessary
|
|
|
|
#else
|
|
|
|
//-----------------------------------------------------//
|
|
// ok, here is the current ReadThreadEx mode: more
|
|
// complex, and it doesn't arrange the prefetch sectors
|
|
// as straight as the type above, but the final result is
|
|
// still smoother (no more pauses on the tested LG drive)
|
|
|
|
for(k=0;k<MAXQFETCH;k++) // loop max of prefetch blocks
|
|
{
|
|
if(addr>=lNeededAddr && // addr is getting read right now?
|
|
addr<=(lNeededAddr+MAXCACHEBLOCK)) // -> ok, we do nothing with it
|
|
{addr=addr+MAXCACHEBLOCK+1;continue;}
|
|
|
|
for(i=0;i<MAXDATACACHE;i++) // loop whole cache
|
|
{
|
|
if(addr>=lDataCacheAddr[i] && // -> addr found?
|
|
addr<=(lDataCacheAddr[i]+MAXCACHEBLOCK))
|
|
{
|
|
if(k==0) iQLockPos=i; // -> if it's the current main addr, lock it, so no other prefetch read overwrites its content
|
|
break;
|
|
}
|
|
}
|
|
if(i!=MAXDATACACHE) // found in data cache?
|
|
{addr=addr+MAXCACHEBLOCK+1;continue;} // -> do nothing with this addr, we have its content
|
|
|
|
for(i=0;i<MAXQSIZE;i++) // loop prefetch q list
|
|
{
|
|
if(addr>=lAddrQ[i] && // -> addr will be read soon?
|
|
addr<=(lAddrQ[i]+MAXCACHEBLOCK))
|
|
{
|
|
if(k==0 && i!=iQPos) // curr needed addr is not on top of the q?
|
|
{
|
|
addr=lAddrQ[i]; // -> get the addr (our main addr is in it, but that one is more aligned to prev reads)
|
|
for(i=0;i<MAXQSIZE;i++) lAddrQ[i]=0xFFFFFFFF; // -> clear whole q (we will fill the slots in that loop again)
|
|
i=MAXQSIZE; // -> sign for storing the addr in q
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if(i!=MAXQSIZE) // found in q?
|
|
{addr=addr+MAXCACHEBLOCK+1;continue;} // -> do nothing with this addr, we will have its content soon
|
|
|
|
// not in q or data cache?
|
|
if(k==0) lAddrQ[iQPos]=addr; // -> if it's the main addr, store it on top of list
|
|
else // -> if it's a prefetch addr, try to store it elsewhere at the end of the q
|
|
{
|
|
j=iQPos;
|
|
for(i=0;i<MAXQSIZE;i++)
|
|
{
|
|
if(lAddrQ[j]==0xFFFFFFFF) {lAddrQ[j]=addr;break;}
|
|
j++;if(j>=MAXQSIZE) j=0;
|
|
}
|
|
}
|
|
|
|
SetEvent(hThreadEvent[0]); // kick a read, if neccessary
|
|
addr=addr+MAXCACHEBLOCK+1; // next prefetch addr
|
|
if(addr>=lMaxAddr) break; // security, for detecting if we are at the end of cd
|
|
}
|
|
|
|
//----------------------------------------------------// ok, and here's something to keep the drive busy...
|
|
|
|
if(lAddrQ[iQPos]==0xFFFFFFFF && addr<lMaxAddr) // nothing in prefetch q?
|
|
{
|
|
iQIdle++; // count how many empty q's in-a-row are happening
|
|
if(iQIdle>10) // more then x times?
|
|
{
|
|
iQIdle=0;
|
|
lAddrQ[iQPos]=addr; // we add the farest prefetch addr
|
|
SetEvent(hThreadEvent[0]); // and do an additional kick
|
|
}
|
|
}
|
|
else iQIdle=0; // not idling? ok
|
|
|
|
//----------------------------------------------------//
|
|
|
|
#endif
|
|
|
|
ReleaseMutex(hThreadMutex[1]);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// emu says: gimme ptr to needed data... this will
|
|
// automatically do an async data prefetch read as well
|
|
// ... called on CDRgetBuffer()
|
|
|
|
void GetREADThreadExPtr(void)
|
|
{
|
|
unsigned long addr=lLastAccessedAddr;
|
|
|
|
while(1)
|
|
{
|
|
if(bThreadEnded) return; // main emu is already closing (thread is down)? bye
|
|
WaitForSingleObject(hThreadMutex[1],INFINITE); // wait for data access
|
|
if(CheckDataCache(addr)) // data now in cache?
|
|
{
|
|
ReleaseMutex(hThreadMutex[1]); // -> ok, done
|
|
return;
|
|
}
|
|
ReleaseMutex(hThreadMutex[1]); // else try again (no sleep here, we are blocking everything anyway)
|
|
}
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// simple data cache
|
|
|
|
void AllocDataCache(void)
|
|
{
|
|
bDataCacheHit=FALSE; // init thread cache hit flag
|
|
if(!iUseCaching) iUseDataCache=0; // security: no additinal data cache, if no caching active
|
|
if(iUseDataCache)
|
|
{
|
|
int i;
|
|
for(i=0;i<MAXDATACACHE;i++) // init all cache slots
|
|
{
|
|
lDataCacheAddr[i] = 0xFFFFFFFF;
|
|
pDataCacheBuf[i] = malloc(MAXCDBUFFER-FRAMEBUFEXTRA);
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
void FreeDataCache(void)
|
|
{
|
|
if(iUseDataCache)
|
|
{
|
|
int i;
|
|
for(i=0;i<MAXDATACACHE;i++)
|
|
{
|
|
free(pDataCacheBuf[i]);
|
|
pDataCacheBuf[i]=NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// easy data cache: stores data blocks
|
|
|
|
void AddToDataCache(unsigned long addr,unsigned char * pB)
|
|
{
|
|
static int iPos=0;
|
|
if(iPos==iQLockPos) // special thread mode lock?
|
|
{iPos++;if(iPos>=MAXDATACACHE) iPos=0;} // -> don't use that pos, use next one
|
|
lDataCacheAddr[iPos]=addr;
|
|
memcpy(pDataCacheBuf[iPos],pB,
|
|
MAXCDBUFFER-FRAMEBUFEXTRA);
|
|
iPos++; if(iPos>=MAXDATACACHE) iPos=0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// easy data cache check: loop MAXDATACACHE blocks, set ptr if addr found
|
|
|
|
BOOL CheckDataCache(unsigned long addr)
|
|
{
|
|
int i;
|
|
|
|
for(i=0;i<MAXDATACACHE;i++)
|
|
{
|
|
if(addr>=lDataCacheAddr[i] &&
|
|
addr<=(lDataCacheAddr[i]+MAXCACHEBLOCK))
|
|
{
|
|
pCurrReadBuf=pDataCacheBuf[i]+
|
|
((addr-lDataCacheAddr[i])*iUsedBlockSize);
|
|
if(ppfHead) CheckPPFCache(addr,pCurrReadBuf);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|