haiku.git

/*
 * Copyright 2015 Julian Harnath <julian.harnath@rwth-aachen.de>
 * All rights reserved. Distributed under the terms of the MIT license.
 */

#include "AlphaMaskCache.h"

#include "AlphaMask.h"
#include "ShapePrivate.h"

#include <AutoLocker.h>


//#define PRINT_ALPHA_MASK_CACHE_STATISTICS
#ifdef PRINT_ALPHA_MASK_CACHE_STATISTICS
static uint32 sAlphaMaskGetCount = 0;
#endif


AlphaMaskCache AlphaMaskCache::sDefaultInstance;


AlphaMaskCache::AlphaMaskCache()
	:
	fLock("AlphaMask cache"),
	fCurrentCacheBytes(0),
	fTooLargeMaskCount(0),
	fMasksReplacedCount(0),
	fHitCount(0),
	fMissCount(0),
	fLowerMaskReferencedCount(0)
{
}


AlphaMaskCache::~AlphaMaskCache()
{
	Clear();
}


/* static */ AlphaMaskCache*
AlphaMaskCache::Default()
{
	return &sDefaultInstance;
}


status_t
AlphaMaskCache::Put(ShapeAlphaMask* mask)
{
	AutoLocker<BLocker> locker(fLock);

	size_t maskStackSize = mask->BitmapSize();
	maskStackSize += _FindUncachedPreviousMasks(mask, true);

	if (maskStackSize > kMaxCacheBytes) {
		_FindUncachedPreviousMasks(mask, false);
		fTooLargeMaskCount++;
		return B_NO_MEMORY;
	}

	if (fCurrentCacheBytes + maskStackSize > kMaxCacheBytes) {
		for (ShapeMaskSet::iterator it = fShapeMasks.begin();
			it != fShapeMasks.end();) {

			if (atomic_get(&it->fMask->fNextMaskCount) > 0) {
				it++;
				continue;
			}

			size_t removedMaskStackSize = it->fMask->BitmapSize();
			removedMaskStackSize += _FindUncachedPreviousMasks(it->fMask,
				false);
			fCurrentCacheBytes -= removedMaskStackSize;

			it->fMask->fInCache = false;
			it->fMask->ReleaseReference();
			fMasksReplacedCount++;
			fShapeMasks.erase(it++);

			if (fCurrentCacheBytes + maskStackSize <= kMaxCacheBytes)
				break;
		}
	}

	if (fCurrentCacheBytes + maskStackSize > kMaxCacheBytes) {
		_FindUncachedPreviousMasks(mask, false);
		fTooLargeMaskCount++;
		return B_NO_MEMORY;
	}

	fCurrentCacheBytes += maskStackSize;

	ShapeMaskElement element(mask->fShape, mask, mask->fPreviousMask.Get(),
		mask->fInverse);
	fShapeMasks.insert(element);
	mask->AcquireReference();
	mask->fInCache = true;
	return B_OK;
}


ShapeAlphaMask*
AlphaMaskCache::Get(const shape_data& shape, AlphaMask* previousMask,
	bool inverse)
{
	AutoLocker<BLocker> locker(fLock);

#ifdef PRINT_ALPHA_MASK_CACHE_STATISTICS
	if (sAlphaMaskGetCount++ > 200) {
		_PrintAndResetStatistics();
		sAlphaMaskGetCount = 0;
	}
#endif

	ShapeMaskElement element(&shape, NULL, previousMask, inverse);
	ShapeMaskSet::iterator it = fShapeMasks.find(element);
 	if (it == fShapeMasks.end()) {
		fMissCount++;
		return NULL;
 	}
	fHitCount++;
	it->fMask->AcquireReference();
	return it->fMask;
}


void
AlphaMaskCache::Clear()
{
	AutoLocker<BLocker> locker(fLock);

	for (ShapeMaskSet::iterator it = fShapeMasks.begin();
		it != fShapeMasks.end(); it++) {
		it->fMask->fInCache = false;
		it->fMask->fIndirectCacheReferences = 0;
		it->fMask->ReleaseReference();
	}
	fShapeMasks.clear();
	fTooLargeMaskCount = 0;
	fMasksReplacedCount = 0;
	fHitCount = 0;
	fMissCount = 0;
	fLowerMaskReferencedCount = 0;
}


size_t
AlphaMaskCache::_FindUncachedPreviousMasks(AlphaMask* mask, bool reference)
{
	const int32 referenceModifier = reference ? 1 : -1;
	size_t addedOrRemovedSize = 0;

	for (AlphaMask* lowerMask = mask->fPreviousMask.Get(); lowerMask != NULL;
		lowerMask = lowerMask->fPreviousMask.Get()) {
		if (lowerMask->fInCache)
			continue;
		uint32 oldReferences = lowerMask->fIndirectCacheReferences;
		lowerMask->fIndirectCacheReferences += referenceModifier;
		if (lowerMask->fIndirectCacheReferences == 0 || oldReferences == 0) {
			// We either newly referenced the mask for the first time, or
			// released the last reference
			addedOrRemovedSize += lowerMask->BitmapSize();
			fLowerMaskReferencedCount += referenceModifier;
		}
	}

	return addedOrRemovedSize;
}


void
AlphaMaskCache::_PrintAndResetStatistics()
{
	debug_printf("AlphaMaskCache statistics: size=%" B_PRIuSIZE " bytes=%"
		B_PRIuSIZE " lower=%4" B_PRIu32 " total=%" B_PRIuSIZE " too_large=%4"
		B_PRIu32 " replaced=%4" B_PRIu32 " hit=%4" B_PRIu32 " miss=%4" B_PRIu32
		"\n", fShapeMasks.size(), fCurrentCacheBytes, fLowerMaskReferencedCount,
		fShapeMasks.size() + fLowerMaskReferencedCount, fTooLargeMaskCount,
		fMasksReplacedCount, fHitCount, fMissCount);
	fTooLargeMaskCount = 0;
	fMasksReplacedCount = 0;
	fHitCount = 0;
	fMissCount = 0;
}