KisTileDataPooler Class Reference

#include <kis_tile_data_pooler.h>

Inheritance diagram for KisTileDataPooler:

Public Member Functions
void	forceUpdateMemoryStats ()
void	kick ()
	KisTileDataPooler (KisTileDataStore *store, qint32 memoryLimit=-1)
qint64	lastHistoricalMemoryMetric () const
qint64	lastPoolMemoryMetric () const
qint64	lastRealMemoryMetric () const
void	terminatePooler ()
void	testingRereadConfig ()
	~KisTileDataPooler () override

Protected Member Functions
qint32	canDonorMemory (KisTileData *td)
int	clonesMetric (KisTileData *td)
int	clonesMetric (KisTileData *td, int numClones)
void	cloneTileData (KisTileData *td, qint32 numClones) const
template<class Iter >
void	getLists (Iter *iter, QList< KisTileData * > &beggars, QList< KisTileData * > &donors, qint32 &memoryOccupied, qint32 &statRealMemory, qint32 &statHistoricalMemory)
qint32	needMemory (KisTileData *td)
qint32	numClonesNeeded (KisTileData *td) const
bool	processLists (QList< KisTileData * > &beggars, QList< KisTileData * > &donors, qint32 &memoryOccupied)
void	run () override
void	tryFreeOrphanedClones (KisTileData *td)
qint32	tryGetMemory (QList< KisTileData * > &donors, qint32 memoryMetric)
void	waitForWork ()

Protected Attributes
bool	m_lastCycleHadWork
qint32	m_lastHistoricalMemoryMetric
qint32	m_lastPoolMemoryMetric
qint32	m_lastRealMemoryMetric
qint32	m_memoryLimit
QSemaphore	m_semaphore
QAtomicInt	m_shouldExitFlag
KisTileDataStore *	m_store
qint32	m_timeout

Static Protected Attributes
static const qint32	MAX_NUM_CLONES = 16
static const qint32	MAX_TIMEOUT = 60000
static const qint32	MIN_TIMEOUT = 100
static const qint32	TIMEOUT_FACTOR = 2

Private Member Functions
void	debugTileStatistics ()

Detailed Description

Definition at line 19 of file kis_tile_data_pooler.h.

Constructor & Destructor Documentation

KisTileDataPooler()

KisTileDataPooler::KisTileDataPooler	(	KisTileDataStore *	store,
		qint32	memoryLimit = -1 )

Definition at line 80 of file kis_tile_data_pooler.cc.

    : QThread()
{
    m_shouldExitFlag = 0;
    m_store = store;
    m_timeout = MIN_TIMEOUT;
    m_lastCycleHadWork = false;
    m_lastPoolMemoryMetric = 0;
    m_lastRealMemoryMetric = 0;
    m_lastHistoricalMemoryMetric = 0;
 
    if(memoryLimit >= 0) {
        m_memoryLimit = memoryLimit;
    }
    else {
        m_memoryLimit = MiB_TO_METRIC(KisImageConfig(true).poolLimit());
    }
}

References m_lastCycleHadWork, m_lastHistoricalMemoryMetric, m_lastPoolMemoryMetric, m_lastRealMemoryMetric, m_memoryLimit, m_shouldExitFlag, m_store, m_timeout, MiB_TO_METRIC(), and MIN_TIMEOUT.

~KisTileDataPooler()

KisTileDataPooler::~KisTileDataPooler ( )

override

Definition at line 99 of file kis_tile_data_pooler.cc.

{
}

Member Function Documentation

canDonorMemory()

qint32 KisTileDataPooler::canDonorMemory ( KisTileData * td )

inlineprotected

Definition at line 279 of file kis_tile_data_pooler.cc.

{
    return td->age() && clonesMetric(td);
}

References KisTileData::age(), and clonesMetric().

clonesMetric() [1/2]

int KisTileDataPooler::clonesMetric ( KisTileData * td )

inlineprotected

Definition at line 260 of file kis_tile_data_pooler.cc.

                                                          {
    return td->m_clonesStack.size() * td->pixelSize();
}

References KisTileData::m_clonesStack, KisTileData::pixelSize(), and KisLocklessStack< T >::size().

clonesMetric() [2/2]

int KisTileDataPooler::clonesMetric ( KisTileData * td, int numClones )

inlineprotected

Definition at line 256 of file kis_tile_data_pooler.cc.

                                                                         {
    return numClones * td->pixelSize();
}

References KisTileData::pixelSize().

cloneTileData()

void KisTileDataPooler::cloneTileData ( KisTileData * td, qint32 numClones ) const

protected

Definition at line 127 of file kis_tile_data_pooler.cc.

{
    if (numClones > 0) {
        td->blockSwapping();
        for (qint32 i = 0; i < numClones; i++) {
            td->m_clonesStack.push(new KisTileData(*td, false));
        }
        td->unblockSwapping();
    } else {
        qint32 numUnneededClones = qAbs(numClones);
        for (qint32 i = 0; i < numUnneededClones; i++) {
            KisTileData *clone = 0;
 
            bool result = td->m_clonesStack.pop(clone);
            if(!result) break;
 
            delete clone;
        }
    }
 
    DEBUG_CLONE_ACTION(td, numClones);
}

References KisTileData::blockSwapping(), DEBUG_CLONE_ACTION, KisTileData::m_clonesStack, KisLocklessStack< T >::pop(), KisLocklessStack< T >::push(), and KisTileData::unblockSwapping().

debugTileStatistics()

void KisTileDataPooler::debugTileStatistics ( )

private

Assume we are called from the inside of the loop. This means m_store is already locked

Definition at line 388 of file kis_tile_data_pooler.cc.

{
    qint64 preallocatedTiles=0;
 
    KisTileDataStoreIterator *iter = m_store->beginIteration();
    KisTileData *item;
 
    while(iter->hasNext()) {
        item = iter->next();
        preallocatedTiles += item->m_clonesStack.size();
    }
 
    m_store->endIteration(iter);
 
    dbgKrita << "Tiles statistics:\t total:" << m_store->numTiles() << "\t preallocated:"<< preallocatedTiles;
}

References KisTileDataStore::beginIteration(), dbgKrita, KisTileDataStore::endIteration(), KisTileDataStoreIterator::hasNext(), KisTileData::m_clonesStack, m_store, KisTileDataStoreIterator::next(), KisTileDataStore::numTiles(), and KisLocklessStack< T >::size().

forceUpdateMemoryStats()

void KisTileDataPooler::forceUpdateMemoryStats

(

)

Is case the pooler thread is not running, the user might force recalculation of the memory statistics explicitly.

Definition at line 216 of file kis_tile_data_pooler.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!isRunning());
 
    KisTileDataStoreReverseIterator *iter = m_store->beginReverseIteration();
    QList<KisTileData*> beggars;
    QList<KisTileData*> donors;
    qint32 memoryOccupied;
 
    qint32 statRealMemory;
    qint32 statHistoricalMemory;
 
 
    getLists(iter, beggars, donors,
             memoryOccupied,
             statRealMemory,
             statHistoricalMemory);
 
    m_lastPoolMemoryMetric = memoryOccupied;
    m_lastRealMemoryMetric = statRealMemory;
    m_lastHistoricalMemoryMetric = statHistoricalMemory;
 
    m_store->endIteration(iter);
}

References KisTileDataStore::beginReverseIteration(), KisTileDataStore::endIteration(), getLists(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_lastHistoricalMemoryMetric, m_lastPoolMemoryMetric, m_lastRealMemoryMetric, and m_store.

getLists()

template<class Iter >

void KisTileDataPooler::getLists ( Iter * iter, QList< KisTileData * > & beggars, QList< KisTileData * > & donors, qint32 & memoryOccupied, qint32 & statRealMemory, qint32 & statHistoricalMemory )

protected

Definition at line 285 of file kis_tile_data_pooler.cc.

{
    memoryOccupied = 0;
    statRealMemory = 0;
    statHistoricalMemory = 0;
 
    qint32 needMemoryTotal = 0;
    qint32 canDonorMemoryTotal = 0;
 
    qint32 neededMemory;
    qint32 donoredMemory;
 
    KisTileData *item;
 
    while(iter->hasNext()) {
        item = iter->next();
 
        tryFreeOrphanedClones(item);
 
        if((neededMemory = needMemory(item))) {
            needMemoryTotal += neededMemory;
            beggars.append(item);
        }
        else if((donoredMemory = canDonorMemory(item))) {
            canDonorMemoryTotal += donoredMemory;
            donors.append(item);
        }
 
        memoryOccupied += clonesMetric(item);
 
        // statistics gathering
        if (item->historical()) {
            statHistoricalMemory += item->pixelSize();
        } else {
            statRealMemory += item->pixelSize();
        }
    }
 
    DEBUG_LISTS(memoryOccupied,
                beggars, needMemoryTotal,
                donors, canDonorMemoryTotal);
}

References canDonorMemory(), clonesMetric(), DEBUG_LISTS, KisTileData::historical(), needMemory(), KisTileData::pixelSize(), and tryFreeOrphanedClones().

kick()

void KisTileDataPooler::kick

(

)

Definition at line 103 of file kis_tile_data_pooler.cc.

{
    m_semaphore.release();
}

References m_semaphore.

lastHistoricalMemoryMetric()

qint64 KisTileDataPooler::lastHistoricalMemoryMetric

(

)

const

Definition at line 251 of file kis_tile_data_pooler.cc.

{
    return m_lastHistoricalMemoryMetric;
}

References m_lastHistoricalMemoryMetric.

lastPoolMemoryMetric()

qint64 KisTileDataPooler::lastPoolMemoryMetric

(

)

const

Definition at line 241 of file kis_tile_data_pooler.cc.

{
    return m_lastPoolMemoryMetric;
}

References m_lastPoolMemoryMetric.

lastRealMemoryMetric()

qint64 KisTileDataPooler::lastRealMemoryMetric

(

)

const

Definition at line 246 of file kis_tile_data_pooler.cc.

{
    return m_lastRealMemoryMetric;
}

References m_lastRealMemoryMetric.

needMemory()

qint32 KisTileDataPooler::needMemory ( KisTileData * td )

inlineprotected

Definition at line 273 of file kis_tile_data_pooler.cc.

{
    qint32 clonesNeeded = !td->age() ? qMax(0, numClonesNeeded(td)) : 0;
    return clonesMetric(td, clonesNeeded);
}

References KisTileData::age(), clonesMetric(), and numClonesNeeded().

numClonesNeeded()

qint32 KisTileDataPooler::numClonesNeeded ( KisTileData * td ) const

protected

Definition at line 117 of file kis_tile_data_pooler.cc.

{
    RUNTIME_SANITY_CHECK(td);
    qint32 numUsers = td->m_usersCount;
    qint32 numPresentClones = td->m_clonesStack.size();
    qint32 totalClones = qMin(numUsers - 1, MAX_NUM_CLONES);
 
    return totalClones - numPresentClones;
}

References KisTileData::m_clonesStack, KisTileData::m_usersCount, MAX_NUM_CLONES, RUNTIME_SANITY_CHECK, and KisLocklessStack< T >::size().

processLists()

bool KisTileDataPooler::processLists ( QList< KisTileData * > & beggars, QList< KisTileData * > & donors, qint32 & memoryOccupied )

protected

Definition at line 354 of file kis_tile_data_pooler.cc.

{
    bool hadWork = false;
 
 
    Q_FOREACH (KisTileData *item, beggars) {
        qint32 clonesNeeded = numClonesNeeded(item);
        qint32 clonesMemory = clonesMetric(item, clonesNeeded);
 
        qint32 memoryLeft =
            m_memoryLimit - (memoryOccupied + clonesMemory);
 
        if(memoryLeft < 0) {
            qint32 freedMemory = tryGetMemory(donors, -memoryLeft);
            memoryOccupied -= freedMemory;
 
            DEBUG_FREE_CLONE(freedMemory, memoryLeft);
 
            if(m_memoryLimit < memoryOccupied + clonesMemory)
                break;
        }
 
        cloneTileData(item, clonesNeeded);
        DEBUG_ALLOC_CLONE(clonesMemory, memoryOccupied);
 
        memoryOccupied += clonesMemory;
        hadWork = true;
    }
 
    return hadWork;
}

References clonesMetric(), cloneTileData(), DEBUG_ALLOC_CLONE, DEBUG_FREE_CLONE, m_memoryLimit, numClonesNeeded(), and tryGetMemory().

run()

void KisTileDataPooler::run ( )

overrideprotected

Definition at line 170 of file kis_tile_data_pooler.cc.

{
    if(!m_memoryLimit) return;
 
    m_shouldExitFlag = false;
 
    while (1) {
        DEBUG_SIMPLE_ACTION("went to bed... Zzz...");
 
        waitForWork();
 
        if (m_shouldExitFlag)
            break;
 
        QThread::msleep(0);
        DEBUG_SIMPLE_ACTION("cycle started");
 
 
        KisTileDataStoreReverseIterator *iter = m_store->beginReverseIteration();
        QList<KisTileData*> beggars;
        QList<KisTileData*> donors;
        qint32 memoryOccupied;
 
        qint32 statRealMemory;
        qint32 statHistoricalMemory;
 
 
        getLists(iter, beggars, donors,
                 memoryOccupied,
                 statRealMemory,
                 statHistoricalMemory);
 
        m_lastCycleHadWork =
            processLists(beggars, donors, memoryOccupied);
 
        m_lastPoolMemoryMetric = memoryOccupied;
        m_lastRealMemoryMetric = statRealMemory;
        m_lastHistoricalMemoryMetric = statHistoricalMemory;
 
        m_store->endIteration(iter);
 
        DEBUG_TILE_STATISTICS();
        DEBUG_SIMPLE_ACTION("cycle finished");
    }
}

References KisTileDataStore::beginReverseIteration(), DEBUG_SIMPLE_ACTION, DEBUG_TILE_STATISTICS, KisTileDataStore::endIteration(), getLists(), m_lastCycleHadWork, m_lastHistoricalMemoryMetric, m_lastPoolMemoryMetric, m_lastRealMemoryMetric, m_memoryLimit, m_shouldExitFlag, m_store, processLists(), and waitForWork().

terminatePooler()

void KisTileDataPooler::terminatePooler

(

)

Definition at line 108 of file kis_tile_data_pooler.cc.

{
    unsigned long exitTimeout = 100;
    do {
        m_shouldExitFlag = true;
        kick();
    } while(!wait(exitTimeout));
}

References kick(), and m_shouldExitFlag.

testingRereadConfig()

void KisTileDataPooler::testingRereadConfig

(

)

Definition at line 410 of file kis_tile_data_pooler.cc.

{
    m_memoryLimit = MiB_TO_METRIC(KisImageConfig(true).poolLimit());
}

References m_memoryLimit, and MiB_TO_METRIC().

tryFreeOrphanedClones()

void KisTileDataPooler::tryFreeOrphanedClones ( KisTileData * td )

inlineprotected

Definition at line 264 of file kis_tile_data_pooler.cc.

{
    qint32 extraClones = -numClonesNeeded(td);
 
    if(extraClones > 0) {
        cloneTileData(td, -extraClones);
    }
}

References cloneTileData(), and numClonesNeeded().

tryGetMemory()

qint32 KisTileDataPooler::tryGetMemory ( QList< KisTileData * > & donors, qint32 memoryMetric )

protected

Definition at line 333 of file kis_tile_data_pooler.cc.

{
    qint32 memoryFreed = 0;
 
    QMutableListIterator<KisTileData*> iter(donors);
    iter.toBack();
 
    while(iter.hasPrevious() && memoryFreed < memoryMetric) {
        KisTileData *item = iter.previous();
 
        qint32 numClones = item->m_clonesStack.size();
        cloneTileData(item, -numClones);
        memoryFreed += clonesMetric(item, numClones);
 
        iter.remove();
    }
 
    return memoryFreed;
}

References clonesMetric(), cloneTileData(), KisTileData::m_clonesStack, and KisLocklessStack< T >::size().

waitForWork()

void KisTileDataPooler::waitForWork ( )

protected

Definition at line 150 of file kis_tile_data_pooler.cc.

{
    bool success;
 
    if (m_lastCycleHadWork)
        success = m_semaphore.tryAcquire(1, m_timeout);
    else {
        m_semaphore.acquire();
        success = true;
    }
 
    m_lastCycleHadWork = false;
    if (success) {
        m_timeout = MIN_TIMEOUT;
    } else {
        m_timeout *= TIMEOUT_FACTOR;
        m_timeout = qMin(m_timeout, MAX_TIMEOUT);
    }
}

References m_lastCycleHadWork, m_semaphore, m_timeout, MAX_TIMEOUT, MIN_TIMEOUT, and TIMEOUT_FACTOR.

Member Data Documentation

m_lastCycleHadWork

bool KisTileDataPooler::m_lastCycleHadWork

protected

Definition at line 81 of file kis_tile_data_pooler.h.

m_lastHistoricalMemoryMetric

qint32 KisTileDataPooler::m_lastHistoricalMemoryMetric

protected

Definition at line 85 of file kis_tile_data_pooler.h.

m_lastPoolMemoryMetric

qint32 KisTileDataPooler::m_lastPoolMemoryMetric

protected

Definition at line 83 of file kis_tile_data_pooler.h.

m_lastRealMemoryMetric

qint32 KisTileDataPooler::m_lastRealMemoryMetric

protected

Definition at line 84 of file kis_tile_data_pooler.h.

m_memoryLimit

qint32 KisTileDataPooler::m_memoryLimit

protected

Definition at line 82 of file kis_tile_data_pooler.h.

m_semaphore

QSemaphore KisTileDataPooler::m_semaphore

protected

Definition at line 77 of file kis_tile_data_pooler.h.

m_shouldExitFlag

QAtomicInt KisTileDataPooler::m_shouldExitFlag

protected

Definition at line 78 of file kis_tile_data_pooler.h.

m_store

KisTileDataStore* KisTileDataPooler::m_store

protected

Definition at line 79 of file kis_tile_data_pooler.h.

m_timeout

qint32 KisTileDataPooler::m_timeout

protected

Definition at line 80 of file kis_tile_data_pooler.h.

MAX_NUM_CLONES

const qint32 KisTileDataPooler::MAX_NUM_CLONES = 16

staticprotected

Definition at line 45 of file kis_tile_data_pooler.h.

MAX_TIMEOUT

const qint32 KisTileDataPooler::MAX_TIMEOUT = 60000

staticprotected

Definition at line 46 of file kis_tile_data_pooler.h.

MIN_TIMEOUT

const qint32 KisTileDataPooler::MIN_TIMEOUT = 100

staticprotected

Definition at line 47 of file kis_tile_data_pooler.h.

TIMEOUT_FACTOR

const qint32 KisTileDataPooler::TIMEOUT_FACTOR = 2

staticprotected

Definition at line 48 of file kis_tile_data_pooler.h.

---

The documentation for this class was generated from the following files:

• libs/image/tiles3/kis_tile_data_pooler.h
• libs/image/tiles3/kis_tile_data_pooler.cc