mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
389 lines
8.6 KiB
389 lines
8.6 KiB
/*****************************************************************************
|
|
* *
|
|
* CSTREAM.CPP *
|
|
* *
|
|
* Copyright (C) Microsoft Corporation 1990-1997 *
|
|
* All Rights reserved. *
|
|
* *
|
|
*****************************************************************************/
|
|
|
|
#include "header.h"
|
|
|
|
#include "cstream.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
static LONG hsemReadCount;
|
|
static LONG hsemStartCount;
|
|
#define PTR_SEM_READ_COUNT &hsemReadCount
|
|
#define PTR_SEM_START_COUNT &hsemStartCount
|
|
#else
|
|
#define PTR_SEM_READ_COUNT NULL
|
|
#define PTR_SEM_START_COUNT NULL
|
|
#endif
|
|
|
|
#ifndef SEEK_CUR
|
|
#define SEEK_CUR 1
|
|
#define SEEK_END 2
|
|
#define SEEK_SET 0
|
|
#endif
|
|
|
|
static HANDLE hsemRead; // semaphore used for dual-cpu processing
|
|
static HANDLE hsemStart; // semaphore used for dual-cpu processing
|
|
static CStream *pThis;
|
|
static BOOL fReadAheadStarted;
|
|
static BOOL fExitThread;
|
|
static PBYTE pbuf1; // first buffer for dual-cpu processing
|
|
static PBYTE pbuf2; // second buffer for dual-cpu processing
|
|
|
|
/////////////////////// CStream implementation ////////////////////////////
|
|
|
|
// We use our own stream class instead of using the C runtime, because this
|
|
// change alone doubled the speed of the help compiler. I.e., the C runtime
|
|
// implementation of stream io is horribly slow. 26-Feb-1994 [ralphw]
|
|
// Also, this CStream will take advantage of a dual-CPU and will do
|
|
// read-aheads in a thread.
|
|
|
|
CStream::CStream(PCSTR pszFileName)
|
|
{
|
|
// Only one CStream can use the read-ahead thread
|
|
|
|
if (!pThis) {
|
|
fDualCPU = g_fDualCPU==-1?FALSE:g_fDualCPU;
|
|
pThis = this;
|
|
}
|
|
else
|
|
fDualCPU = FALSE;
|
|
|
|
if ((hfile = _lopen(pszFileName, OF_READ)) == HFILE_ERROR) {
|
|
fInitialized = FALSE;
|
|
if (fDualCPU)
|
|
pThis = NULL;
|
|
return;
|
|
}
|
|
if (fDualCPU) {
|
|
cbBuf = DUAL_CSTREAM_BUF_SIZE;
|
|
if (!hsemRead) {
|
|
hsemRead = CreateSemaphore(NULL, 1, 1, NULL);
|
|
hsemStart = CreateSemaphore(NULL, 1, 1, NULL);
|
|
pbuf2 = (PBYTE) lcMalloc(DUAL_CSTREAM_BUF_SIZE + 2);
|
|
pbuf1 = (PBYTE) lcMalloc(DUAL_CSTREAM_BUF_SIZE + 2);
|
|
}
|
|
pbuf = pbuf1;
|
|
}
|
|
else {
|
|
cbBuf = CSTREAM_BUF_SIZE;
|
|
|
|
// +2 because we add a zero just past the buffer in case anyone expects strings
|
|
|
|
pbuf = (PBYTE) lcMalloc(CSTREAM_BUF_SIZE + 2);
|
|
}
|
|
|
|
ASSERT(pbuf);
|
|
fInitialized = TRUE;
|
|
|
|
int cread = _lread(hfile, pbuf, cbBuf);
|
|
if (cread == HFILE_ERROR) {
|
|
_lclose(hfile);
|
|
fInitialized = FALSE;
|
|
if (fDualCPU)
|
|
pThis = NULL;
|
|
return;
|
|
}
|
|
|
|
if (fDualCPU) {
|
|
// Start reading the next buffer
|
|
|
|
cThrdRead = HFILE_NOTREAD;
|
|
if (!fReadAheadStarted) {
|
|
hthrd = CreateThread(NULL, 0,
|
|
(LPTHREAD_START_ROUTINE) &ReadAhead, NULL,
|
|
0, &idThrd);
|
|
ASSERT(hthrd);
|
|
if (!hthrd)
|
|
fDualCPU = FALSE;
|
|
else
|
|
fReadAheadStarted = TRUE;
|
|
}
|
|
else {
|
|
ReleaseSemaphore(hsemRead, 1, PTR_SEM_READ_COUNT);
|
|
ReleaseSemaphore(hsemStart, 1, PTR_SEM_START_COUNT); // start read-ahead thread
|
|
}
|
|
}
|
|
|
|
pCurBuf = pbuf;
|
|
pEndBuf = pbuf + cread;
|
|
pEndBuf[1] = '\0';
|
|
lFilePos = cread;
|
|
lFileBuf = 0;
|
|
pszFile = lcStrDup(pszFileName);
|
|
fInitialized = TRUE;
|
|
m_fEndOfFile = FALSE;
|
|
}
|
|
|
|
CStream::~CStream()
|
|
{
|
|
if (fInitialized) {
|
|
if (fDualCPU) {
|
|
Cleanup();
|
|
WaitForReadAhead();
|
|
pThis = NULL;
|
|
}
|
|
else
|
|
{
|
|
lcFree(pbuf);
|
|
}
|
|
lcFree(pszFile);
|
|
_lclose(hfile);
|
|
}
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: CStream::ReadBuf
|
|
|
|
PURPOSE: Read the next block into buffer
|
|
|
|
PARAMETERS:
|
|
void
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
Zero-terminates the buffer
|
|
|
|
MODIFICATION DATES:
|
|
13-Nov-1994 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
char CStream::ReadBuf(void)
|
|
{
|
|
int cread;
|
|
|
|
if (fDualCPU) {
|
|
ASSERT(fReadAheadStarted);
|
|
WaitForReadAhead();
|
|
if (pbuf == pbuf1)
|
|
pbuf = pbuf2;
|
|
else
|
|
pbuf = pbuf1;
|
|
|
|
cread = cThrdRead;
|
|
cThrdRead = HFILE_NOTREAD;
|
|
ReleaseSemaphore(hsemRead, 1, PTR_SEM_READ_COUNT);
|
|
|
|
// Error-checking must occur AFTER we release the read semaphore
|
|
|
|
if (cread == HFILE_ERROR) {
|
|
return chEOF;
|
|
}
|
|
ReleaseSemaphore(hsemStart, 1, PTR_SEM_START_COUNT); // start read-ahead thread
|
|
}
|
|
else {
|
|
cread = _lread(hfile, pbuf, cbBuf);
|
|
if (cread == HFILE_ERROR) {
|
|
return chEOF;
|
|
}
|
|
}
|
|
|
|
lFileBuf = lFilePos;
|
|
lFilePos += cread;
|
|
|
|
pCurBuf = pbuf;
|
|
pEndBuf = pbuf + cread;
|
|
pEndBuf[1] = '\0';
|
|
|
|
if (!cread) {
|
|
m_fEndOfFile = TRUE;
|
|
return chEOF;
|
|
}
|
|
return (char) *pCurBuf++;
|
|
}
|
|
|
|
UINT STDCALL CStream::read(void* pbDest, int cbBytes)
|
|
{
|
|
if (pEndBuf - pbuf < cbBuf)
|
|
if (pEndBuf - pCurBuf < cbBytes)
|
|
cbBytes = (int)(pEndBuf - pCurBuf);
|
|
|
|
if (pCurBuf + cbBytes < pEndBuf) {
|
|
memcpy(pbDest, pCurBuf, cbBytes);
|
|
pCurBuf += cbBytes;
|
|
return cbBytes;
|
|
}
|
|
PBYTE pbDst = (PBYTE) pbDest;
|
|
|
|
// If destination buffer is larger then our internal buffer, then
|
|
// recursively call until we have filled up the destination.
|
|
|
|
int cbRead = (int)(pEndBuf - pCurBuf);
|
|
memcpy(pbDest, pCurBuf, cbRead);
|
|
pbDst += cbRead;
|
|
ReadBuf();
|
|
if (m_fEndOfFile)
|
|
return cbRead;
|
|
else
|
|
pCurBuf--; // since ReadBuf incremented it
|
|
|
|
return read(pbDst, cbBytes - cbRead) + cbRead;
|
|
}
|
|
|
|
int STDCALL CStream::seek(int pos, SEEK_TYPE seek)
|
|
{
|
|
ASSERT(seek != SK_END); // we don't support this one
|
|
|
|
if (seek == SK_CUR)
|
|
pos = lFileBuf + (int)(pCurBuf - pbuf) + pos;
|
|
|
|
if (pos >= lFileBuf && pos < lFilePos) {
|
|
pCurBuf = pbuf + (pos - lFileBuf);
|
|
if (pCurBuf >= pEndBuf && pEndBuf < pbuf + cbBuf)
|
|
m_fEndOfFile = TRUE;
|
|
return lFileBuf + (int)(pCurBuf - pbuf);
|
|
}
|
|
else {
|
|
if (fDualCPU) {
|
|
WaitForReadAhead();
|
|
}
|
|
lFileBuf = _llseek(hfile, pos, SEEK_SET);
|
|
int cread = _lread(hfile, pbuf, cbBuf);
|
|
if (cread == HFILE_ERROR) {
|
|
m_fEndOfFile = TRUE;
|
|
return chEOF;
|
|
}
|
|
lFilePos = lFileBuf + cread;
|
|
pCurBuf = pbuf;
|
|
pEndBuf = pbuf + cread;
|
|
if (fDualCPU) {
|
|
cThrdRead = HFILE_NOTREAD;
|
|
ReleaseSemaphore(hsemRead, 1, PTR_SEM_READ_COUNT);
|
|
if (fReadAheadStarted)
|
|
ReleaseSemaphore(hsemStart, 1, PTR_SEM_START_COUNT); // start read-ahead thread
|
|
}
|
|
if (cread == 0)
|
|
m_fEndOfFile = TRUE;
|
|
|
|
return lFilePos;
|
|
}
|
|
}
|
|
|
|
void CStream::WaitForReadAhead(void)
|
|
{
|
|
for(;;) {
|
|
WaitForSingleObject(hsemRead, INFINITE);
|
|
if (cThrdRead == HFILE_NOTREAD) {
|
|
ReleaseSemaphore(hsemRead, 1, PTR_SEM_READ_COUNT);
|
|
Sleep(1); // give read-ahead thread a chance to run
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: ReadAhead
|
|
|
|
PURPOSE: Reads the next block of data from a file
|
|
|
|
PARAMETERS:
|
|
pthis
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
Two semaphores control this thread:
|
|
hsemStart: keeps the thread suspended while waiting for the
|
|
caller to finish reading one of its blocks.
|
|
hsemRead: used as a signal between the main thread and this
|
|
thread as to when this thread has completed.
|
|
|
|
Because it is theoretically possible for a thread switch to occur
|
|
between the time the hsemStart thread starts this thread and this
|
|
thread's call to WaitForSingleObject(hsemRead), the caller also sets
|
|
the read return value to HFILE_NOTREAD to ensure that it does not
|
|
attempt to use this buffer until in fact the read has completed.
|
|
|
|
NOTE: this thread approach only makes sense on a system with more
|
|
then one CPU.
|
|
|
|
MODIFICATION DATES:
|
|
05-Feb-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
DWORD WINAPI ReadAhead(LPVOID pv)
|
|
{
|
|
/*
|
|
* Each time through the loop, we block on hsemStart, waiting for our
|
|
* caller to release it. The hsemRead is used to block the caller until
|
|
* we have completed our read.
|
|
*/
|
|
|
|
for (;;) {
|
|
PBYTE pbReadBuf;
|
|
WaitForSingleObject(hsemStart, INFINITE);
|
|
if (fExitThread)
|
|
break;
|
|
WaitForSingleObject(hsemRead, INFINITE);
|
|
pbReadBuf = (pThis->pbuf == pbuf1) ? pbuf2 : pbuf1;
|
|
pThis->cThrdRead = _lread(pThis->hfile, pbReadBuf, pThis->cbBuf);
|
|
ReleaseSemaphore(hsemRead, 1, PTR_SEM_READ_COUNT);
|
|
}
|
|
ExitThread(0);
|
|
return 0;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: CStream::Cleanup
|
|
|
|
PURPOSE: Cleanup global variables
|
|
|
|
PARAMETERS:
|
|
void
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
05-Feb-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
void CStream::Cleanup(void)
|
|
{
|
|
if (fReadAheadStarted) {
|
|
fExitThread = TRUE;
|
|
ReleaseSemaphore(hsemStart, 1, PTR_SEM_START_COUNT); // start read-ahead thread
|
|
Sleep(1); // Let the other thread run
|
|
CloseHandle(hsemStart);
|
|
CloseHandle(hsemRead);
|
|
lcFree(pbuf1);
|
|
lcFree(pbuf2);
|
|
hsemStart = hsemRead = pbuf1 = pbuf2 = NULL;
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
|
|
char CStream::cget()
|
|
{
|
|
if (pCurBuf < pEndBuf)
|
|
return (char) *pCurBuf++;
|
|
else if (pEndBuf < pbuf + cbBuf) {
|
|
m_fEndOfFile = TRUE;
|
|
return chEOF;
|
|
}
|
|
else
|
|
return ReadBuf();
|
|
}
|
|
|
|
#endif
|