bool LargeObjectCache::CacheBin::cleanAll(ExtMemoryPool *extMemPool)
{
LargeMemoryBlock *toRelease = NULL;
bool released = false;
if (last) {
MallocMutex::scoped_lock scoped_cs(lock);
// double check
if (last) {
toRelease = first;
last = NULL;
first = NULL;
oldest = 0;
}
else
return false;
}
released = toRelease;
while ( toRelease ) {
LargeMemoryBlock *helper = toRelease->next;
removeBackRef(toRelease->backRefIdx);
extMemPool->backend.putLargeBlock(toRelease);
toRelease = helper;
}
return released;
}
LargeMemoryBlock *ExtMemoryPool::mallocLargeObject(size_t allocationSize)
{
#if __TBB_MALLOC_LOCACHE_STAT
AtomicIncrement(mallocCalls);
AtomicAdd(memAllocKB, allocationSize/1024);
#endif
LargeMemoryBlock* lmb = loc.get(allocationSize);
if (!lmb) {
BackRefIdx backRefIdx = BackRefIdx::newBackRef(/*largeObj=*/true);
if (backRefIdx.isInvalid())
return NULL;
// unalignedSize is set in getLargeBlock
lmb = backend.getLargeBlock(allocationSize);
if (!lmb) {
removeBackRef(backRefIdx);
loc.rollbackCacheState(allocationSize);
return NULL;
}
lmb->backRefIdx = backRefIdx;
STAT_increment(getThreadId(), ThreadCommonCounters, allocNewLargeObj);
} else {
#if __TBB_MALLOC_LOCACHE_STAT
AtomicIncrement(cacheHits);
AtomicAdd(memHitKB, allocationSize/1024);
#endif
}
return lmb;
}
void operator()(int) const {
TestBlock blocks[ITERS];
for (int i=0; i<ITERS; i++) {
blocks[i].idx = BackRefIdx::newBackRef(/*largeObj=*/false);
setBackRef(blocks[i].idx, &blocks[i].data);
}
for (int i=0; i<ITERS; i++)
ASSERT((Block*)&blocks[i].data == getBackRef(blocks[i].idx), NULL);
for (int i=ITERS-1; i>=0; i--)
removeBackRef(blocks[i].idx);
}
void ExtMemoryPool::freeLargeObject(void *object)
{
LargeObjectHdr *header = (LargeObjectHdr*)object - 1;
// overwrite backRefIdx to simplify double free detection
header->backRefIdx = BackRefIdx();
if (!loc.put(this, header->memoryBlock)) {
removeBackRef(header->memoryBlock->backRefIdx);
backend.putLargeBlock(header->memoryBlock);
STAT_increment(getThreadId(), ThreadCommonCounters, freeLargeObj);
}
}
void Mpdf::loadPdf(QString path)
{
currentPath = removeBackRef(path);
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
doc = fz_open_document(ctx, currentPath.toStdString().c_str());
pageCount = fz_count_pages(doc);
currentPage = 1;
currentZoom = 60;
enablePageNumber();
showPage();
hideTop();
}
bool LargeObjectCache::CacheBin::cleanToThreshold(ExtMemoryPool *extMemPool,
uintptr_t currAge)
{
LargeMemoryBlock *toRelease = NULL;
bool released = false;
/* oldest may be more recent then age, that's why cast to signed type
was used. age overflow is also processed correctly. */
if (last && (intptr_t)(currAge - oldest) > ageThreshold) {
MallocMutex::scoped_lock scoped_cs(lock);
// double check
if (last && (intptr_t)(currAge - last->age) > ageThreshold) {
do {
last = last->prev;
} while (last && (intptr_t)(currAge - last->age) > ageThreshold);
if (last) {
toRelease = last->next;
oldest = last->age;
last->next = NULL;
} else {
toRelease = first;
first = NULL;
oldest = 0;
}
MALLOC_ASSERT( toRelease, ASSERT_TEXT );
lastCleanedAge = toRelease->age;
}
else
return false;
}
released = toRelease;
while ( toRelease ) {
LargeMemoryBlock *helper = toRelease->next;
removeBackRef(toRelease->backRefIdx);
extMemPool->backend.putLargeBlock(toRelease);
toRelease = helper;
}
return released;
}
void *ExtMemoryPool::mallocLargeObject(size_t size, size_t alignment)
{
size_t headersSize = sizeof(LargeMemoryBlock)+sizeof(LargeObjectHdr);
// TODO: take into account that they are already largeObjectAlignment-aligned
size_t allocationSize = alignUp(size+headersSize+alignment, largeBlockCacheStep);
if (allocationSize < size) // allocationSize is wrapped around after alignUp
return NULL;
LargeMemoryBlock* lmb = loc.get(this, allocationSize);
if (!lmb) {
BackRefIdx backRefIdx = BackRefIdx::newBackRef(/*largeObj=*/true);
if (backRefIdx.isInvalid())
return NULL;
// unalignedSize is set in getLargeBlock
lmb = backend.getLargeBlock(allocationSize);
if (!lmb) {
removeBackRef(backRefIdx);
return NULL;
}
lmb->backRefIdx = backRefIdx;
STAT_increment(getThreadId(), ThreadCommonCounters, allocNewLargeObj);
}
void *alignedArea = (void*)alignUp((uintptr_t)lmb+headersSize, alignment);
LargeObjectHdr *header = (LargeObjectHdr*)alignedArea-1;
header->memoryBlock = lmb;
header->backRefIdx = lmb->backRefIdx;
setBackRef(header->backRefIdx, header);
lmb->objectSize = size;
MALLOC_ASSERT( isLargeObject(alignedArea), ASSERT_TEXT );
return alignedArea;
}
void TestObjectRecognition() {
size_t headersSize = sizeof(LargeMemoryBlock)+sizeof(LargeObjectHdr);
unsigned falseObjectSize = 113; // unsigned is the type expected by getObjectSize
size_t obtainedSize;
ASSERT(sizeof(BackRefIdx)==4, "Unexpected size of BackRefIdx");
ASSERT(getObjectSize(falseObjectSize)!=falseObjectSize, "Error in test: bad choice for false object size");
void* mem = scalable_malloc(2*slabSize);
ASSERT(mem, "Memory was not allocated");
Block* falseBlock = (Block*)alignUp((uintptr_t)mem, slabSize);
falseBlock->objectSize = falseObjectSize;
char* falseSO = (char*)falseBlock + falseObjectSize*7;
ASSERT(alignDown(falseSO, slabSize)==(void*)falseBlock, "Error in test: false object offset is too big");
void* bufferLOH = scalable_malloc(2*slabSize + headersSize);
ASSERT(bufferLOH, "Memory was not allocated");
LargeObjectHdr* falseLO =
(LargeObjectHdr*)alignUp((uintptr_t)bufferLOH + headersSize, slabSize);
LargeObjectHdr* headerLO = (LargeObjectHdr*)falseLO-1;
headerLO->memoryBlock = (LargeMemoryBlock*)bufferLOH;
headerLO->memoryBlock->unalignedSize = 2*slabSize + headersSize;
headerLO->memoryBlock->objectSize = slabSize + headersSize;
headerLO->backRefIdx = BackRefIdx::newBackRef(/*largeObj=*/true);
setBackRef(headerLO->backRefIdx, headerLO);
ASSERT(scalable_msize(falseLO) == slabSize + headersSize,
"Error in test: LOH falsification failed");
removeBackRef(headerLO->backRefIdx);
const int NUM_OF_IDX = BR_MAX_CNT+2;
BackRefIdx idxs[NUM_OF_IDX];
for (int cnt=0; cnt<2; cnt++) {
for (int master = -10; master<10; master++) {
falseBlock->backRefIdx.master = (uint16_t)master;
headerLO->backRefIdx.master = (uint16_t)master;
for (int bl = -10; bl<BR_MAX_CNT+10; bl++) {
falseBlock->backRefIdx.offset = (uint16_t)bl;
headerLO->backRefIdx.offset = (uint16_t)bl;
for (int largeObj = 0; largeObj<2; largeObj++) {
falseBlock->backRefIdx.largeObj = largeObj;
headerLO->backRefIdx.largeObj = largeObj;
obtainedSize = safer_scalable_msize(falseSO, NULL);
ASSERT(obtainedSize==0, "Incorrect pointer accepted");
obtainedSize = safer_scalable_msize(falseLO, NULL);
ASSERT(obtainedSize==0, "Incorrect pointer accepted");
}
}
}
if (cnt == 1) {
for (int i=0; i<NUM_OF_IDX; i++)
removeBackRef(idxs[i]);
break;
}
for (int i=0; i<NUM_OF_IDX; i++) {
idxs[i] = BackRefIdx::newBackRef(/*largeObj=*/false);
setBackRef(idxs[i], NULL);
}
}
char *smallPtr = (char*)scalable_malloc(falseObjectSize);
obtainedSize = safer_scalable_msize(smallPtr, NULL);
ASSERT(obtainedSize==getObjectSize(falseObjectSize), "Correct pointer not accepted?");
scalable_free(smallPtr);
obtainedSize = safer_scalable_msize(mem, NULL);
ASSERT(obtainedSize>=2*slabSize, "Correct pointer not accepted?");
scalable_free(mem);
scalable_free(bufferLOH);
}
