ole32: Cache data and block locations in BigBlockStream objects.

This commit is contained in:
Vincent Povirk 2010-04-16 17:38:14 -05:00 committed by Alexandre Julliard
parent 101de22a1a
commit 89646084ba
2 changed files with 196 additions and 46 deletions

View File

@ -2857,7 +2857,10 @@ end:
*result = NULL;
}
else
{
StorageImpl_Flush((StorageBaseImpl*)This);
*result = This;
}
return hr;
}
@ -2896,8 +2899,26 @@ static void StorageImpl_Destroy(StorageBaseImpl* iface)
static HRESULT StorageImpl_Flush(StorageBaseImpl* iface)
{
StorageImpl *This = (StorageImpl*) iface;
int i;
HRESULT hr;
TRACE("(%p)\n", This);
return ILockBytes_Flush(This->lockBytes);
hr = BlockChainStream_Flush(This->smallBlockRootChain);
if (SUCCEEDED(hr))
hr = BlockChainStream_Flush(This->rootBlockChain);
if (SUCCEEDED(hr))
hr = BlockChainStream_Flush(This->smallBlockDepotChain);
for (i=0; SUCCEEDED(hr) && i<BLOCKCHAIN_CACHE_SIZE; i++)
if (This->blockChainCache[i])
hr = BlockChainStream_Flush(This->blockChainCache[i]);
if (SUCCEEDED(hr))
hr = ILockBytes_Flush(This->lockBytes);
return hr;
}
/******************************************************************************
@ -5820,6 +5841,53 @@ ULONG BlockChainStream_GetSectorOfOffset(BlockChainStream *This, ULONG offset)
return This->indexCache[min_run].firstSector + offset - This->indexCache[min_run].firstOffset;
}
HRESULT BlockChainStream_GetBlockAtOffset(BlockChainStream *This,
ULONG index, BlockChainBlock **block, ULONG *sector, BOOL create)
{
BlockChainBlock *result=NULL;
int i;
for (i=0; i<2; i++)
if (This->cachedBlocks[i].index == index)
{
*sector = This->cachedBlocks[i].sector;
*block = &This->cachedBlocks[i];
return S_OK;
}
*sector = BlockChainStream_GetSectorOfOffset(This, index);
if (*sector == BLOCK_END_OF_CHAIN)
return STG_E_DOCFILECORRUPT;
if (create)
{
if (This->cachedBlocks[0].index == 0xffffffff)
result = &This->cachedBlocks[0];
else if (This->cachedBlocks[1].index == 0xffffffff)
result = &This->cachedBlocks[1];
else
{
result = &This->cachedBlocks[This->blockToEvict++];
if (This->blockToEvict == 2)
This->blockToEvict = 0;
}
if (result->dirty)
{
if (!StorageImpl_WriteBigBlock(This->parentStorage, result->sector, result->data))
return STG_E_WRITEFAULT;
result->dirty = 0;
}
result->read = 0;
result->index = index;
result->sector = *sector;
}
*block = result;
return S_OK;
}
BlockChainStream* BlockChainStream_Construct(
StorageImpl* parentStorage,
ULONG* headOfStreamPlaceHolder,
@ -5835,6 +5903,11 @@ BlockChainStream* BlockChainStream_Construct(
newStream->indexCache = NULL;
newStream->indexCacheLen = 0;
newStream->indexCacheSize = 0;
newStream->cachedBlocks[0].index = 0xffffffff;
newStream->cachedBlocks[0].dirty = 0;
newStream->cachedBlocks[1].index = 0xffffffff;
newStream->cachedBlocks[1].dirty = 0;
newStream->blockToEvict = 0;
if (FAILED(BlockChainStream_UpdateIndexCache(newStream)))
{
@ -5846,10 +5919,30 @@ BlockChainStream* BlockChainStream_Construct(
return newStream;
}
HRESULT BlockChainStream_Flush(BlockChainStream* This)
{
int i;
if (!This) return S_OK;
for (i=0; i<2; i++)
{
if (This->cachedBlocks[i].dirty)
{
if (StorageImpl_WriteBigBlock(This->parentStorage, This->cachedBlocks[i].sector, This->cachedBlocks[i].data))
This->cachedBlocks[i].dirty = 0;
else
return STG_E_WRITEFAULT;
}
}
return S_OK;
}
void BlockChainStream_Destroy(BlockChainStream* This)
{
if (This)
{
BlockChainStream_Flush(This);
HeapFree(GetProcessHeap(), 0, This->indexCache);
}
HeapFree(GetProcessHeap(), 0, This);
}
@ -5915,6 +6008,8 @@ HRESULT BlockChainStream_ReadAt(BlockChainStream* This,
ULONG blockIndex;
BYTE* bufferWalker;
ULARGE_INTEGER stream_size;
HRESULT hr;
BlockChainBlock *cachedBlock;
TRACE("(%p)-> %i %p %i %p\n",This, offset.u.LowPart, buffer, size, bytesRead);
@ -5936,17 +6031,25 @@ HRESULT BlockChainStream_ReadAt(BlockChainStream* This,
*/
bufferWalker = buffer;
while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
while (size > 0)
{
ULARGE_INTEGER ulOffset;
DWORD bytesReadAt;
/*
* Calculate how many bytes we can copy from this big block.
*/
bytesToReadInBuffer =
min(This->parentStorage->bigBlockSize - offsetInBlock, size);
TRACE("block %i\n",blockIndex);
hr = BlockChainStream_GetBlockAtOffset(This, blockNoInSequence, &cachedBlock, &blockIndex, size == bytesToReadInBuffer);
if (FAILED(hr))
return hr;
if (!cachedBlock)
{
/* Not in cache, and we're going to read past the end of the block. */
ulOffset.u.HighPart = 0;
ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This->parentStorage, blockIndex) +
offsetInBlock;
@ -5956,12 +6059,22 @@ HRESULT BlockChainStream_ReadAt(BlockChainStream* This,
bufferWalker,
bytesToReadInBuffer,
&bytesReadAt);
/*
* Step to the next big block.
*/
if( size > bytesReadAt && FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex, &blockIndex)))
return STG_E_DOCFILECORRUPT;
}
else
{
if (!cachedBlock->read)
{
if (!StorageImpl_ReadBigBlock(This->parentStorage, cachedBlock->sector, cachedBlock->data))
return STG_E_READFAULT;
cachedBlock->read = 1;
}
memcpy(bufferWalker, cachedBlock->data+offsetInBlock, bytesToReadInBuffer);
bytesReadAt = bytesToReadInBuffer;
}
blockNoInSequence++;
bufferWalker += bytesReadAt;
size -= bytesReadAt;
*bytesRead += bytesReadAt;
@ -5991,34 +6104,36 @@ HRESULT BlockChainStream_WriteAt(BlockChainStream* This,
ULONG bytesToWrite;
ULONG blockIndex;
const BYTE* bufferWalker;
/*
* Find the first block in the stream that contains part of the buffer.
*/
blockIndex = BlockChainStream_GetSectorOfOffset(This, blockNoInSequence);
/* BlockChainStream_SetSize should have already been called to ensure we have
* enough blocks in the chain to write into */
if (blockIndex == BLOCK_END_OF_CHAIN)
{
ERR("not enough blocks in chain to write data\n");
return STG_E_DOCFILECORRUPT;
}
HRESULT hr;
BlockChainBlock *cachedBlock;
*bytesWritten = 0;
bufferWalker = buffer;
while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
while (size > 0)
{
ULARGE_INTEGER ulOffset;
DWORD bytesWrittenAt;
/*
* Calculate how many bytes we can copy from this big block.
* Calculate how many bytes we can copy to this big block.
*/
bytesToWrite =
min(This->parentStorage->bigBlockSize - offsetInBlock, size);
TRACE("block %i\n",blockIndex);
hr = BlockChainStream_GetBlockAtOffset(This, blockNoInSequence, &cachedBlock, &blockIndex, size == bytesToWrite);
/* BlockChainStream_SetSize should have already been called to ensure we have
* enough blocks in the chain to write into */
if (FAILED(hr))
{
ERR("not enough blocks in chain to write data\n");
return hr;
}
if (!cachedBlock)
{
/* Not in cache, and we're going to write past the end of the block. */
ulOffset.u.HighPart = 0;
ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This->parentStorage, blockIndex) +
offsetInBlock;
@ -6028,14 +6143,22 @@ HRESULT BlockChainStream_WriteAt(BlockChainStream* This,
bufferWalker,
bytesToWrite,
&bytesWrittenAt);
}
else
{
if (!cachedBlock->read && bytesToWrite != This->parentStorage->bigBlockSize)
{
if (!StorageImpl_ReadBigBlock(This->parentStorage, cachedBlock->sector, cachedBlock->data))
return STG_E_READFAULT;
}
/*
* Step to the next big block.
*/
if(size > bytesWrittenAt && FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
&blockIndex)))
return STG_E_DOCFILECORRUPT;
memcpy(cachedBlock->data+offsetInBlock, bufferWalker, bytesToWrite);
bytesWrittenAt = bytesToWrite;
cachedBlock->read = 1;
cachedBlock->dirty = 1;
}
blockNoInSequence++;
bufferWalker += bytesWrittenAt;
size -= bytesWrittenAt;
*bytesWritten += bytesWrittenAt;
@ -6058,6 +6181,7 @@ static BOOL BlockChainStream_Shrink(BlockChainStream* This,
{
ULONG blockIndex;
ULONG numBlocks;
int i;
/*
* Figure out how many blocks are needed to contain the new size
@ -6125,6 +6249,18 @@ static BOOL BlockChainStream_Shrink(BlockChainStream* This,
last_run->lastOffset--;
}
/*
* Reset the last accessed block cache.
*/
for (i=0; i<2; i++)
{
if (This->cachedBlocks[i].index >= numBlocks)
{
This->cachedBlocks[i].index = 0xffffffff;
This->cachedBlocks[i].dirty = 0;
}
}
return TRUE;
}

View File

@ -512,6 +512,15 @@ struct BlockChainRun
ULONG lastOffset;
};
typedef struct BlockChainBlock
{
ULONG index;
ULONG sector;
int read;
int dirty;
BYTE data[MAX_BIG_BLOCK_SIZE];
} BlockChainBlock;
struct BlockChainStream
{
StorageImpl* parentStorage;
@ -520,6 +529,8 @@ struct BlockChainStream
struct BlockChainRun* indexCache;
ULONG indexCacheLen;
ULONG indexCacheSize;
BlockChainBlock cachedBlocks[2];
ULONG blockToEvict;
ULONG tailIndex;
ULONG numBlocks;
};
@ -553,6 +564,9 @@ BOOL BlockChainStream_SetSize(
BlockChainStream* This,
ULARGE_INTEGER newSize);
HRESULT BlockChainStream_Flush(
BlockChainStream* This);
/****************************************************************************
* SmallBlockChainStream definitions.
*