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.
690 lines
17 KiB
690 lines
17 KiB
//+------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1994.
|
|
//
|
|
// File: bm_filio.cxx
|
|
//
|
|
// Contents: Basic File IO test
|
|
//
|
|
// Classes: CFileIOTest
|
|
//
|
|
// History: 04-Aug-94 t-vadims Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#include <headers.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include <bm_filio.hxx>
|
|
#include <memory.h>
|
|
|
|
#define DEF_DATASIZE 16384
|
|
|
|
TCHAR *CFileIOTest::Name ()
|
|
{
|
|
return TEXT("FileIOTest");
|
|
}
|
|
|
|
SCODE CFileIOTest::Setup (CTestInput *pInput)
|
|
{
|
|
SCODE sc;
|
|
TCHAR pszValue[16];
|
|
ULONG i;
|
|
|
|
CTestBase::Setup(pInput);
|
|
|
|
// get iteration count
|
|
m_ulIterations = pInput->GetIterations(Name());
|
|
|
|
sc = InitCOM();
|
|
if (FAILED(sc))
|
|
{
|
|
Log (TEXT("Setup - CoInitialize failed."), sc);
|
|
return sc;
|
|
}
|
|
|
|
// get malloc interface for this task
|
|
m_piMalloc = NULL;
|
|
sc = CoGetMalloc(MEMCTX_TASK, &m_piMalloc);
|
|
if (FAILED(sc))
|
|
{
|
|
Log (TEXT("Setup - CoGetMalloc"), sc);
|
|
Cleanup();
|
|
return sc;
|
|
}
|
|
|
|
// get values of various paremeters from ini file
|
|
|
|
m_iStartSize = pInput->GetConfigInt(Name(), TEXT("StartSize"), 16);
|
|
if(m_iStartSize <= 0)
|
|
m_iStartSize = 16;
|
|
|
|
m_iEndSize = pInput->GetConfigInt(Name(), TEXT("EndSize"), DEF_DATASIZE);
|
|
|
|
// initialize array to be written to the file.
|
|
m_pbData = (BYTE *)m_piMalloc->Alloc(m_iEndSize);
|
|
if(m_pbData == NULL)
|
|
{
|
|
Log (TEXT("Setup - Cannot allocate memory"), E_OUTOFMEMORY);
|
|
Cleanup();
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
for (i=0; i < m_iEndSize; i++)
|
|
m_pbData[i] = (BYTE)i;
|
|
|
|
|
|
m_iRepeatFactor = pInput->GetConfigInt(Name(), TEXT("RepeatFactor"), 1);
|
|
|
|
if (m_iRepeatFactor > MAX_REPS)
|
|
m_iRepeatFactor = MAX_REPS;
|
|
|
|
// Figure out how many different sizes we're going to write.
|
|
// and the size of the final file.
|
|
m_ulTotalSize = 0;
|
|
for(m_ulNumSizes = 0, i = m_iStartSize; i <= m_iEndSize; i *=2, m_ulNumSizes++)
|
|
m_ulTotalSize += i * m_iRepeatFactor;
|
|
|
|
|
|
if (m_iRepeatFactor * m_ulNumSizes > MAX_READS)
|
|
{
|
|
Log(TEXT("Too many different sizes and/or repeat factor is too big"), E_FAIL);
|
|
Cleanup();
|
|
return E_FAIL;
|
|
}
|
|
|
|
m_flStandardCreateFlags = 0;
|
|
// get file name to be used and values of other parameters
|
|
pInput->GetConfigString(Name(), TEXT("FileName"), TEXT("stgtest.bm"),
|
|
m_pszFile, MAX_PATH);
|
|
|
|
pInput->GetConfigString(Name(), TEXT("WriteThrough"), TEXT("OFF"), pszValue, 15);
|
|
|
|
if (lstrcmpi(pszValue, TEXT("ON")) == 0)
|
|
m_flStandardCreateFlags |= FILE_FLAG_WRITE_THROUGH;
|
|
|
|
pInput->GetConfigString(Name(), TEXT("AccessMode"), TEXT("NORMAL"), m_pszAccessMode, 15);
|
|
|
|
if (lstrcmpi(m_pszAccessMode, TEXT("ASYNC")) == 0)
|
|
{
|
|
m_flAccessMode = AM_ASYNC;
|
|
m_flStandardCreateFlags |= FILE_FLAG_OVERLAPPED;
|
|
}
|
|
else if (lstrcmpi(m_pszAccessMode, TEXT("MAPPED")) == 0)
|
|
{
|
|
m_flAccessMode = AM_MAPPED;
|
|
}
|
|
else
|
|
m_flAccessMode = AM_NORMAL;
|
|
|
|
pInput->GetConfigString(Name(), TEXT("Flush"), TEXT("OFF"), pszValue, 15);
|
|
|
|
if (lstrcmpi(pszValue, TEXT("ON")) == 0)
|
|
m_bFlush = TRUE;
|
|
else
|
|
m_bFlush = FALSE;
|
|
|
|
pInput->GetConfigString(Name(), TEXT("ReadMode"), TEXT("SEQUENTIAL"),
|
|
m_pszReadMode, 15);
|
|
|
|
if(lstrcmpi(m_pszReadMode, TEXT("SEQUENTIAL")) == 0)
|
|
m_bSequentialRead = TRUE;
|
|
else
|
|
m_bSequentialRead = FALSE;
|
|
|
|
|
|
InitTimings();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
void CFileIOTest::InitTimings()
|
|
{
|
|
ULONG i;
|
|
|
|
// initialize timing arrays
|
|
|
|
INIT_RESULTS(m_ulOpenFileW);
|
|
INIT_RESULTS(m_ulClose1);
|
|
INIT_RESULTS(m_ulOpenFileR);
|
|
INIT_RESULTS(m_ulClose2);
|
|
|
|
ZERO_RESULTS(m_ulWriteTotal);
|
|
ZERO_RESULTS(m_ulReadTotal);
|
|
ZERO_RESULTS(m_ulSeekTotal);
|
|
|
|
INIT_RESULTS(m_ulCreateFileMappingW);
|
|
INIT_RESULTS(m_ulMapViewW);
|
|
INIT_RESULTS(m_ulCloseMap1);
|
|
INIT_RESULTS(m_ulUnmapView1);
|
|
ZERO_RESULTS(m_ulFlush1);
|
|
|
|
INIT_RESULTS(m_ulCreateFileMappingR);
|
|
INIT_RESULTS(m_ulMapViewR);
|
|
INIT_RESULTS(m_ulCloseMap2);
|
|
INIT_RESULTS(m_ulUnmapView2);
|
|
ZERO_RESULTS(m_ulFlush2);
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_READS; i++)
|
|
{
|
|
INIT_RESULTS(m_ulWrite[i]);
|
|
INIT_RESULTS(m_ulRead[i]);
|
|
INIT_RESULTS(m_ulSeek[i]);
|
|
}
|
|
|
|
for (i = 0; i < 2; i++ )
|
|
ZERO_RESULTS(m_ulTotal[i]);
|
|
|
|
}
|
|
|
|
|
|
SCODE CFileIOTest::Cleanup ()
|
|
{
|
|
// delete the file
|
|
DeleteFile (m_pszFile);
|
|
if(m_piMalloc)
|
|
{
|
|
if (m_pbData)
|
|
m_piMalloc->Free(m_pbData);
|
|
|
|
m_pbData = NULL;
|
|
|
|
m_piMalloc->Release();
|
|
m_piMalloc = NULL;
|
|
|
|
}
|
|
|
|
UninitCOM();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
SCODE CFileIOTest::Run ()
|
|
{
|
|
CStopWatch sw;
|
|
ULONG iIter;
|
|
HANDLE hFile;
|
|
ULONG cb;
|
|
ULONG iSize;
|
|
ULONG i, iCount;
|
|
ULONG cbCurOffset;
|
|
|
|
// Async mode variables
|
|
OVERLAPPED ov;
|
|
LPOVERLAPPED lpov;
|
|
BOOL fRes;
|
|
|
|
// file-mapped mode variables
|
|
LPBYTE lpbFileData;
|
|
HANDLE hMap;
|
|
|
|
|
|
ov.Offset = 0;
|
|
ov.OffsetHigh = 0;
|
|
ov.hEvent = NULL;
|
|
|
|
if (IsAsyncMode())
|
|
lpov = &ov;
|
|
else
|
|
lpov = NULL;
|
|
|
|
|
|
// create normal file and write some data to it
|
|
for (iIter = 0; iIter < m_ulIterations; iIter++)
|
|
{
|
|
sw.Reset();
|
|
hFile = CreateFile(m_pszFile, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
|
|
m_flStandardCreateFlags | FILE_ATTRIBUTE_NORMAL, NULL);
|
|
m_ulOpenFileW[iIter] = sw.Read();
|
|
Log(TEXT("CreateFile for writing"),
|
|
(hFile != INVALID_HANDLE_VALUE) ? S_OK : E_FAIL);
|
|
if(hFile == INVALID_HANDLE_VALUE)
|
|
return E_FAIL;
|
|
|
|
if (IsMappedMode()) // create file mapping
|
|
{
|
|
|
|
sw.Reset();
|
|
hMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, m_ulTotalSize, NULL);
|
|
m_ulCreateFileMappingW[iIter] = sw.Read();
|
|
|
|
Log(TEXT("CreateFileMapping"), (hMap != NULL) ? S_OK : E_FAIL);
|
|
if(hMap == NULL)
|
|
{
|
|
TCHAR szBuf[80];
|
|
wsprintf(szBuf, TEXT("GetLastError = %ld , FileSize = %ld"), GetLastError(), m_ulTotalSize);
|
|
Log(szBuf, E_FAIL);
|
|
CloseHandle(hFile);
|
|
return E_FAIL;
|
|
}
|
|
|
|
sw.Reset();
|
|
lpbFileData = (LPBYTE)MapViewOfFile(hMap, FILE_MAP_WRITE, 0, 0, 0);
|
|
m_ulMapViewW[iIter] = sw.Read();
|
|
|
|
Log(TEXT("MapViewOfFile"), (lpbFileData != NULL) ? S_OK : E_FAIL);
|
|
if(lpbFileData == NULL)
|
|
{
|
|
TCHAR szBuf[80];
|
|
wsprintf(szBuf, TEXT("GetLastError = %ld"), GetLastError());
|
|
Log(szBuf, E_FAIL);
|
|
CloseHandle(hMap);
|
|
CloseHandle(hFile);
|
|
return E_FAIL;
|
|
}
|
|
|
|
}
|
|
|
|
cbCurOffset = 0;
|
|
iCount = 0;
|
|
for (iSize = m_iStartSize ; iSize <= m_iEndSize ; iSize *= 2)
|
|
{
|
|
|
|
for (i = 0; i < m_iRepeatFactor; i++)
|
|
{
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
sw.Reset();
|
|
memcpy(lpbFileData + cbCurOffset, m_pbData, iSize);
|
|
m_ulWrite[iCount][iIter] = sw.Read();
|
|
cb = iSize; // force correct cb for error check
|
|
}
|
|
else
|
|
{
|
|
ov.Offset = cbCurOffset;
|
|
sw.Reset();
|
|
fRes = WriteFile(hFile, (LPSTR)m_pbData, iSize, &cb, lpov);
|
|
m_ulWrite[iCount][iIter] = sw.Read();
|
|
}
|
|
m_ulWriteTotal[iIter] += m_ulWrite[iCount][iIter];
|
|
|
|
if (IsAsyncMode()) // if in async mode wait for result
|
|
{
|
|
if(!fRes)
|
|
{
|
|
Log(TEXT("Doing Actual Async call"), S_OK);
|
|
GetOverlappedResult(hFile, lpov, &cb, TRUE);
|
|
}
|
|
|
|
}
|
|
|
|
Log(TEXT("Writing data"), cb == iSize ? S_OK : E_FAIL);
|
|
|
|
cbCurOffset += iSize;
|
|
iCount++;
|
|
}
|
|
}
|
|
Log(TEXT("WriteFile X bytes"), S_OK );
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
if (m_bFlush)
|
|
{
|
|
sw.Reset();
|
|
fRes = FlushViewOfFile((LPVOID) lpbFileData, 0);
|
|
m_ulFlush1[iIter] = sw.Read();
|
|
Log(TEXT("FlushViewOfFile"), fRes ? S_OK : E_FAIL);
|
|
}
|
|
|
|
sw.Reset();
|
|
fRes = UnmapViewOfFile((LPVOID) lpbFileData);
|
|
m_ulUnmapView1[iIter] = sw.Read();
|
|
Log(TEXT("UnmapViewOfFile"), fRes ? S_OK : E_FAIL);
|
|
|
|
sw.Reset();
|
|
CloseHandle(hMap);
|
|
m_ulCloseMap1[iIter] = sw.Read();
|
|
Log(TEXT("CloseHandle of file-mapping"), S_OK);
|
|
}
|
|
else if (m_bFlush)
|
|
{
|
|
sw.Reset();
|
|
fRes = FlushFileBuffers(hFile);
|
|
m_ulFlush1[iIter] = sw.Read();
|
|
Log(TEXT("FlushFileBuffers"), fRes ? S_OK : E_FAIL);
|
|
}
|
|
|
|
sw.Reset();
|
|
CloseHandle(hFile);
|
|
m_ulClose1[iIter] = sw.Read();
|
|
|
|
m_ulTotal[0][iIter] = m_ulOpenFileW[iIter] +
|
|
m_ulWriteTotal[iIter] +
|
|
m_ulFlush1[iIter] +
|
|
m_ulClose1[iIter];
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
m_ulTotal[0][iIter] += m_ulCreateFileMappingW[iIter] +
|
|
m_ulMapViewW[iIter] +
|
|
m_ulUnmapView1[iIter] +
|
|
m_ulCloseMap1[iIter];
|
|
}
|
|
|
|
}
|
|
|
|
// try to read from that file
|
|
for (iIter = 0; iIter < m_ulIterations; iIter++)
|
|
{
|
|
sw.Reset();
|
|
hFile = CreateFile(m_pszFile, GENERIC_READ, 0, NULL, OPEN_EXISTING,
|
|
m_flStandardCreateFlags | FILE_ATTRIBUTE_NORMAL, NULL);
|
|
m_ulOpenFileR[iIter] = sw.Read();
|
|
Log(TEXT("CreateFile for reading"),
|
|
(hFile != INVALID_HANDLE_VALUE) ? S_OK : E_FAIL);
|
|
if(hFile == INVALID_HANDLE_VALUE)
|
|
return E_FAIL;
|
|
|
|
if (IsMappedMode()) // create file mapping
|
|
{
|
|
sw.Reset();
|
|
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
|
|
m_ulCreateFileMappingR[iIter] = sw.Read();
|
|
|
|
Log(TEXT("CreateFileMapping"), (hMap != NULL) ? S_OK : E_FAIL);
|
|
if(hMap == NULL)
|
|
{
|
|
CloseHandle(hFile);
|
|
return E_FAIL;
|
|
}
|
|
|
|
sw.Reset();
|
|
lpbFileData = (LPBYTE)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
|
|
m_ulMapViewR[iIter] = sw.Read();
|
|
|
|
Log(TEXT("MapViewOfFile"), (lpbFileData != NULL) ? S_OK : E_FAIL);
|
|
if(lpbFileData == NULL)
|
|
{
|
|
CloseHandle(hMap);
|
|
CloseHandle(hFile);
|
|
return E_FAIL;
|
|
}
|
|
|
|
}
|
|
|
|
cbCurOffset = 0;
|
|
iCount = 0;
|
|
|
|
if (m_bSequentialRead)
|
|
{
|
|
for (iSize = m_iStartSize ; iSize <= m_iEndSize ; iSize *= 2)
|
|
{
|
|
for (i =0; i < m_iRepeatFactor; i++)
|
|
{
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
sw.Reset();
|
|
memcpy(m_pbData, lpbFileData + cbCurOffset, iSize);
|
|
m_ulRead[iCount][iIter] = sw.Read();
|
|
cb = iSize; // force correct cb for error check
|
|
}
|
|
else
|
|
{
|
|
ov.Offset = cbCurOffset;
|
|
sw.Reset();
|
|
fRes = ReadFile(hFile, (LPSTR)m_pbData, iSize, &cb, lpov);
|
|
m_ulRead[iCount][iIter] = sw.Read();
|
|
}
|
|
m_ulReadTotal[iIter] += m_ulRead[iCount][iIter];
|
|
|
|
if (IsAsyncMode()) // in async mode wait for result
|
|
{
|
|
if(!fRes)
|
|
{
|
|
Log(TEXT("Doing Actual Async call"), S_OK);
|
|
GetOverlappedResult(hFile, lpov, &cb, TRUE);
|
|
}
|
|
|
|
}
|
|
|
|
Log(TEXT("Reading data"), cb == iSize ? S_OK : E_FAIL);
|
|
|
|
cbCurOffset += iSize;
|
|
iCount++;
|
|
}
|
|
}
|
|
|
|
Log(TEXT("ReadFile Sequential"), S_OK);
|
|
}
|
|
else
|
|
{
|
|
cbCurOffset = m_ulTotalSize;
|
|
for (iSize = m_iStartSize ; iSize <= m_iEndSize ; iSize *= 2)
|
|
{
|
|
for ( i =0; i< m_iRepeatFactor; i++)
|
|
{
|
|
cbCurOffset -= iSize;
|
|
ov.Offset = cbCurOffset;
|
|
|
|
if (IsNormalMode())
|
|
{
|
|
sw.Reset();
|
|
SetFilePointer(hFile, cbCurOffset, NULL, FILE_BEGIN);
|
|
m_ulSeek[iCount][iIter] = sw.Read();
|
|
m_ulSeekTotal[iIter] += m_ulSeek[iCount][iIter];
|
|
}
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
sw.Reset();
|
|
memcpy(m_pbData, lpbFileData + cbCurOffset, iSize);
|
|
m_ulRead[iCount][iIter] = sw.Read();
|
|
cb = iSize; // force correct cb for error check.
|
|
}
|
|
else
|
|
{
|
|
sw.Reset();
|
|
fRes = ReadFile(hFile, (LPSTR)m_pbData, iSize, &cb, lpov);
|
|
m_ulRead[iCount][iIter] = sw.Read();
|
|
}
|
|
m_ulReadTotal[iIter] = m_ulRead[iCount][iIter];
|
|
|
|
if (IsAsyncMode())
|
|
{
|
|
if(!fRes)
|
|
{
|
|
Log(TEXT("Doing Actual Async call"), S_OK);
|
|
GetOverlappedResult(hFile, lpov, &cb, TRUE);
|
|
}
|
|
}
|
|
Log(TEXT("Reading data"), cb == iSize ? S_OK : E_FAIL);
|
|
iCount++;
|
|
}
|
|
}
|
|
Log(TEXT("ReadFile Random"), S_OK);
|
|
}
|
|
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
if (m_bFlush)
|
|
{
|
|
sw.Reset();
|
|
fRes = FlushViewOfFile((LPVOID) lpbFileData, 0);
|
|
m_ulFlush2[iIter] = sw.Read();
|
|
Log(TEXT("FlushViewOfFile"), fRes ? S_OK : E_FAIL);
|
|
}
|
|
|
|
sw.Reset();
|
|
fRes = UnmapViewOfFile((LPVOID) lpbFileData);
|
|
m_ulUnmapView2[iIter] = sw.Read();
|
|
Log(TEXT("UnmapViewOfFile"), fRes ? S_OK : E_FAIL);
|
|
|
|
sw.Reset();
|
|
CloseHandle(hMap);
|
|
m_ulCloseMap2[iIter] = sw.Read();
|
|
Log(TEXT("CloseHandle of file-mapping"), S_OK);
|
|
}
|
|
else if ( m_bFlush)
|
|
{
|
|
sw.Reset();
|
|
fRes = FlushFileBuffers(hFile);
|
|
m_ulFlush2[iIter] = sw.Read();
|
|
Log(TEXT("FlushFileBuffers"), fRes ? S_OK : E_FAIL);
|
|
}
|
|
|
|
sw.Reset();
|
|
CloseHandle(hFile);
|
|
m_ulClose2[iIter] = sw.Read();
|
|
Log(TEXT("CloseHandle of File"), S_OK);
|
|
|
|
m_ulTotal[1][iIter] = m_ulOpenFileR[iIter] +
|
|
m_ulSeekTotal[iIter] +
|
|
m_ulReadTotal[iIter] +
|
|
m_ulFlush2[iIter] +
|
|
m_ulClose2[iIter];
|
|
if (IsMappedMode())
|
|
{
|
|
m_ulTotal[1][iIter] += m_ulCreateFileMappingR[iIter] +
|
|
m_ulMapViewR[iIter] +
|
|
m_ulUnmapView2[iIter] +
|
|
m_ulCloseMap2[iIter];
|
|
}
|
|
}
|
|
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
SCODE CFileIOTest::Report (CTestOutput &output)
|
|
{
|
|
TCHAR pszBuf[80];
|
|
ULONG i, iSize, iCount;
|
|
|
|
wsprintf(pszBuf, TEXT("File IO in %s Mode with %s Read/Writes"),
|
|
m_pszAccessMode, m_pszReadMode);
|
|
output.WriteSectionHeader (Name(), pszBuf, *m_pInput);
|
|
|
|
wsprintf(pszBuf, TEXT("WriteThrough is %s\n"),
|
|
(m_flStandardCreateFlags & FILE_FLAG_WRITE_THROUGH) ? TEXT("ON") : TEXT("OFF"));
|
|
output.WriteString (pszBuf);
|
|
|
|
wsprintf(pszBuf, TEXT("Flush is %s\n\n"), m_bFlush ? TEXT("ON") : TEXT("OFF"));
|
|
output.WriteString (pszBuf);
|
|
|
|
|
|
output.WriteResults (TEXT("CreateFile WRITE "), m_ulIterations,
|
|
m_ulOpenFileW);
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
output.WriteResults(TEXT("CreateFileMapping"), m_ulIterations,
|
|
m_ulCreateFileMappingW);
|
|
|
|
output.WriteResults(TEXT("MapViewOfFile "), m_ulIterations,
|
|
m_ulMapViewW);
|
|
}
|
|
|
|
output.WriteString (TEXT("\n"));
|
|
|
|
iCount = 0;
|
|
for (iSize = m_iStartSize ; iSize <= m_iEndSize ; iSize *= 2)
|
|
{
|
|
for (i = 0; i < m_iRepeatFactor; i++)
|
|
{
|
|
|
|
wsprintf(pszBuf, TEXT("WriteFile %-9d"), iSize);
|
|
|
|
output.WriteResults (pszBuf, m_ulIterations, m_ulWrite[iCount]);
|
|
iCount++;
|
|
}
|
|
}
|
|
|
|
output.WriteResults (TEXT("Write Total "), m_ulIterations, m_ulWriteTotal);
|
|
|
|
output.WriteString (TEXT("\n"));
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
if (m_bFlush)
|
|
output.WriteResults(TEXT("FlushViewOfFile "), m_ulIterations,
|
|
m_ulFlush1);
|
|
|
|
output.WriteResults(TEXT("UnmapViewOfFile "), m_ulIterations,
|
|
m_ulUnmapView1);
|
|
|
|
output.WriteResults(TEXT("CloseMapping "), m_ulIterations,
|
|
m_ulCloseMap1);
|
|
}
|
|
|
|
else if (m_bFlush)
|
|
output.WriteResults(TEXT("FlushFileBuffers "), m_ulIterations,
|
|
m_ulFlush1);
|
|
|
|
output.WriteResults (TEXT("CloseHandle "), m_ulIterations,
|
|
m_ulClose1);
|
|
|
|
output.WriteResults (TEXT("Total "), m_ulIterations,
|
|
m_ulTotal[0]);
|
|
output.WriteString (TEXT("\n\n"));
|
|
|
|
output.WriteResults (TEXT("CreateFile READ "), m_ulIterations,
|
|
m_ulOpenFileR);
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
output.WriteResults(TEXT("CreateFileMapping"), m_ulIterations,
|
|
m_ulCreateFileMappingR);
|
|
|
|
output.WriteResults(TEXT("MapViewOfFile "), m_ulIterations,
|
|
m_ulMapViewR);
|
|
}
|
|
|
|
output.WriteString (TEXT("\n"));
|
|
|
|
iCount =0;
|
|
for (iSize = m_iStartSize ; iSize <= m_iEndSize ; iSize *= 2)
|
|
{
|
|
for (i=0; i < m_iRepeatFactor; i++)
|
|
{
|
|
if (!m_bSequentialRead && IsNormalMode())
|
|
{
|
|
wsprintf(pszBuf, TEXT("SetFilePosition %-9d"), m_iEndSize - iSize);
|
|
output.WriteResults (pszBuf, m_ulIterations, m_ulSeek[iCount]);
|
|
}
|
|
wsprintf(pszBuf, TEXT("ReadFile %-9d"), iSize);
|
|
output.WriteResults (pszBuf, m_ulIterations, m_ulRead[iCount]);
|
|
iCount++;
|
|
}
|
|
}
|
|
|
|
if (!m_bSequentialRead && IsNormalMode())
|
|
output.WriteResults (TEXT("Seek Total "), m_ulIterations, m_ulSeekTotal);
|
|
|
|
output.WriteResults (TEXT("Read Total "), m_ulIterations, m_ulReadTotal);
|
|
|
|
output.WriteString (TEXT("\n"));
|
|
|
|
if (IsMappedMode())
|
|
{
|
|
if (m_bFlush)
|
|
output.WriteResults(TEXT("FlushViewOfFile "), m_ulIterations,
|
|
m_ulFlush2);
|
|
|
|
output.WriteResults(TEXT("UnmapViewOfFile "), m_ulIterations,
|
|
m_ulUnmapView2);
|
|
|
|
output.WriteResults(TEXT("CloseMapping "), m_ulIterations,
|
|
m_ulCloseMap2);
|
|
|
|
}
|
|
else if ( m_bFlush)
|
|
output.WriteResults(TEXT("FlushFileBuffers "), m_ulIterations,
|
|
m_ulFlush2);
|
|
|
|
output.WriteResults (TEXT("CloseHandle "), m_ulIterations,
|
|
m_ulClose2);
|
|
|
|
output.WriteResults (TEXT("Total "), m_ulIterations,
|
|
m_ulTotal[1]);
|
|
|
|
output.WriteString (TEXT("\n"));
|
|
|
|
return S_OK;
|
|
}
|