KisTile Class Reference

#include <kis_tile.h>

Inheritance diagram for KisTile:

Public Member Functions
qint32	col () const
quint8 *	data () const
void	debugDumpTile ()
void	debugPrintInfo ()
QRect	extent () const
	KisTile (const KisTile &rhs)
	KisTile (const KisTile &rhs, KisMementoManager *mm)
	KisTile (const KisTile &rhs, qint32 col, qint32 row, KisMementoManager *mm)
	KisTile (qint32 col, qint32 row, KisTileData *defaultTileData, KisMementoManager *mm)
void	lockForRead () const
void	lockForWrite ()
KisTileSP	next () const
void	notifyAttachedToDataManager (KisMementoManager *mm)
void	notifyDeadWithoutDetaching ()
void	notifyDetachedFromDataManager ()
qint32	pixelSize () const
qint32	row () const
void	setData (const quint8 *data)
void	setNext (KisTileSP next)
KisTileData *	tileData () const
void	unlockForRead () const
void	unlockForWrite ()
	~KisTile ()
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Private Member Functions
void	blockSwapping () const
void	init (qint32 col, qint32 row, KisTileData *defaultTileData, KisMementoManager *mm)
void	safeReleaseOldTileData (KisTileData *td)
void	unblockSwapping () const

Private Attributes
qint32	m_col
QMutex	m_COWMutex
QRect	m_extent
volatile int	m_lockCounter
QAtomicPointer< KisMementoManager >	m_mementoManager
KisTileSP	m_nextTile
QStack< KisTileData * >	m_oldTileData
qint32	m_row
QMutex	m_swapBarrierLock
KisTileData *	m_tileData

Additional Inherited Members
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

Provides abstraction to a tile.

• A tile contains a part of a PaintDevice, but only the individual pixels are accessible and that only via iterators.
• Actual tile data is stored in KisTileData that can be shared between many tiles

Definition at line 40 of file kis_tile.h.

Constructor & Destructor Documentation

KisTile() [1/4]

KisTile::KisTile	(	qint32	col,
		qint32	row,
		KisTileData *	defaultTileData,
		KisMementoManager *	mm )

Definition at line 36 of file kis_tile.cc.

{
    init(col, row, defaultTileData, mm);
}

References col(), init(), and row().

KisTile() [2/4]

KisTile::KisTile	(	const KisTile &	rhs,
		qint32	col,
		qint32	row,
		KisMementoManager *	mm )

Definition at line 42 of file kis_tile.cc.

        : KisShared()
{
    init(col, row, rhs.tileData(), mm);
}

References col(), init(), row(), and tileData().

KisTile() [3/4]

KisTile::KisTile	(	const KisTile &	rhs,
		KisMementoManager *	mm )

Definition at line 48 of file kis_tile.cc.

        : KisShared()
{
    init(rhs.col(), rhs.row(), rhs.tileData(), mm);
}

References col(), init(), row(), and tileData().

KisTile() [4/4]

KisTile::KisTile

(

const KisTile &

rhs

)

Definition at line 54 of file kis_tile.cc.

        : KisShared()
{
    init(rhs.col(), rhs.row(), rhs.tileData(), rhs.m_mementoManager);
}

References col(), init(), m_mementoManager, row(), and tileData().

~KisTile()

KisTile::~KisTile

(

)

Definition at line 60 of file kis_tile.cc.

{
#ifdef DEAD_TILES_SANITY_CHECK
    KIS_ASSERT(!m_lockCounter);
 
    if (m_mementoManager) {
        qDebug() << this << ppVar(m_sanityNumCOWHappened);
        qDebug() << this << ppVar(m_sanityHasBeenDetached);
        qDebug() << this << ppVar(m_sanityMMHasBeenInitializedManually);
        qDebug() << this << ppVar(m_sanityIsDead);
        KIS_ASSERT(0 && "m_mementoManager is still initialized during destruction");
    }
#endif
 
    m_tileData->release();
}

References KIS_ASSERT, m_lockCounter, m_mementoManager, m_tileData, ppVar, and KisTileData::release().

Member Function Documentation

blockSwapping()

void KisTile::blockSwapping ( ) const

inlineprivate

We need to hold a special barrier lock here to ensure m_tileData->blockSwapping() has finished executing before anyone started reading the tile data. That is why we can not use atomic operations here.

Definition at line 158 of file kis_tile.cc.

{
    QMutexLocker locker(&m_swapBarrierLock);
    Q_ASSERT(m_lockCounter >= 0);
 
    if(!m_lockCounter++)
        m_tileData->blockSwapping();
 
    Q_ASSERT(data());
}

References KisTileData::blockSwapping(), data(), m_lockCounter, m_swapBarrierLock, and m_tileData.

col()

qint32 KisTile::col ( ) const

inline

Definition at line 95 of file kis_tile.h.

                              {
        return m_col;
    }

data()

quint8 * KisTile::data ( ) const

inline

Definition at line 85 of file kis_tile.h.

                                {
        return m_tileData->data();
    }

debugDumpTile()

void KisTile::debugDumpTile

(

)

Definition at line 297 of file kis_tile.cc.

{
    lockForRead();
    quint8 *data = this->data();
 
    for (int i = 0; i < KisTileData::HEIGHT; i++) {
        for (int j = 0; j < KisTileData::WIDTH; j++) {
            dbgTiles << data[(i*KisTileData::WIDTH+j)*pixelSize()];
        }
    }
    unlockForRead();
}

References data(), dbgTiles, KisTileData::HEIGHT, lockForRead(), pixelSize(), unlockForRead(), and KisTileData::WIDTH.

debugPrintInfo()

void KisTile::debugPrintInfo

(

)

Definition at line 288 of file kis_tile.cc.

{
    dbgTiles << "------\n"
                "Tile:\t\t\t" << this
                << "\n   data:\t" << m_tileData
                << "\n   next:\t" <<  m_nextTile.data();
 
}

References KisSharedPtr< T >::data(), dbgTiles, m_nextTile, and m_tileData.

extent()

QRect KisTile::extent ( ) const

inline

Definition at line 99 of file kis_tile.h.

                                {
        return m_extent;
//QRect(m_col * KisTileData::WIDTH, m_row * KisTileData::HEIGHT,
//                     KisTileData::WIDTH, KisTileData::HEIGHT);
    }

init()

void KisTile::init ( qint32 col, qint32 row, KisTileData * defaultTileData, KisMementoManager * mm )

private

Definition at line 17 of file kis_tile.cc.

{
    m_col = col;
    m_row = row;
    m_lockCounter = 0;
 
    m_extent = QRect(m_col * KisTileData::WIDTH, m_row * KisTileData::HEIGHT,
                     KisTileData::WIDTH, KisTileData::HEIGHT);
 
    m_tileData = defaultTileData;
    m_tileData->acquire();
 
    if (mm) {
        mm->registerTileChange(this);
    }
    m_mementoManager.storeRelease(mm);
}

References KisTileData::acquire(), col(), KisTileData::HEIGHT, m_col, m_extent, m_lockCounter, m_mementoManager, m_row, m_tileData, KisMementoManager::registerTileChange(), row(), and KisTileData::WIDTH.

lockForRead()

void KisTile::lockForRead

(

)

const

Definition at line 208 of file kis_tile.cc.

{
#ifdef DEAD_TILES_SANITY_CHECK
    m_sanityLockedForRead.ref();
#endif
 
    DEBUG_LOG_ACTION("lock [R]");
    blockSwapping();
}

References blockSwapping(), and DEBUG_LOG_ACTION.

lockForWrite()

void KisTile::lockForWrite

(

)

Everything could have happened before we took the mutex, so let's check again...

Definition at line 221 of file kis_tile.cc.

{
#ifdef DEAD_TILES_SANITY_CHECK
    m_sanityLockedForWrite.ref();
#endif
 
    blockSwapping();
 
    /* We are doing COW here */
    if (lazyCopying()) {
        m_COWMutex.lock();
 
        if (lazyCopying()) {
 
            KisTileData *tileData = m_tileData->clone();
            tileData->acquire();
            tileData->blockSwapping();
            KisTileData *oldTileData = m_tileData;
            m_tileData = tileData;
            safeReleaseOldTileData(oldTileData);
 
            DEBUG_COWING(tileData);
 
            KisMementoManager *mm = m_mementoManager.loadRelaxed();
            if (mm) {
                mm->registerTileChange(this);
            }
        }
        m_COWMutex.unlock();
 
#ifdef DEAD_TILES_SANITY_CHECK
        m_sanityNumCOWHappened.ref();
#endif
    }
 
    DEBUG_LOG_ACTION("lock [W]");
}

References KisTileData::acquire(), KisTileData::blockSwapping(), blockSwapping(), KisTileData::clone(), DEBUG_COWING, DEBUG_LOG_ACTION, lazyCopying, m_COWMutex, m_mementoManager, m_tileData, KisMementoManager::registerTileChange(), safeReleaseOldTileData(), and tileData().

next()

KisTileSP KisTile::next ( ) const

inline

Definition at line 105 of file kis_tile.h.

                                  {
        return m_nextTile;
    }

notifyAttachedToDataManager()

void KisTile::notifyAttachedToDataManager

(

KisMementoManager *

mm

)

Called by the hash table to notify that the tile has been attached to the data manager.

Definition at line 113 of file kis_tile.cc.

{
#ifdef DEAD_TILES_SANITY_CHECK
    sanityCheckIsNotDestroyedYet();
#endif
 
    // TODO: check if we really need locking here
    if (!m_mementoManager.loadAcquire()) {
        QMutexLocker locker(&m_COWMutex);
 
        if (!m_mementoManager.loadAcquire()) {
 
            if (mm) {
                mm->registerTileChange(this);
            }
            m_mementoManager.storeRelease(mm);
 
#ifdef DEAD_TILES_SANITY_CHECK
            m_sanityMMHasBeenInitializedManually.ref();
#endif
        }
    }
 
#ifdef DEAD_TILES_SANITY_CHECK
    sanityCheckIsNotDestroyedYet();
#endif
}

References m_COWMutex, m_mementoManager, and KisMementoManager::registerTileChange().

notifyDeadWithoutDetaching()

void KisTile::notifyDeadWithoutDetaching

(

)

Sometimes the tile gets replaced with another tile. In this case we shouldn't notify memento manager that the tile has died. Just forget the link to the manager and bury it in peace.

Definition at line 100 of file kis_tile.cc.

{
#ifdef DEAD_TILES_SANITY_CHECK
    sanityCheckIsNotLockedForWrite();
#endif
 
    m_mementoManager.storeRelease(0);
 
#ifdef DEAD_TILES_SANITY_CHECK
    m_sanityIsDead.ref();
#endif
}

References m_mementoManager.

notifyDetachedFromDataManager()

void KisTile::notifyDetachedFromDataManager

(

)

This method is called by the hash table when the tile is disconnected from it. It means that from now on the tile is not associated with any particular datamanager. All the users of the tile (via shared pointers) may silently finish they work on this tile and leave it. No result will be saved. Used for threading purposes

Definition at line 83 of file kis_tile.cc.

{
#ifdef DEAD_TILES_SANITY_CHECK
    sanityCheckIsNotLockedForWrite();
#endif
 
    if (m_mementoManager.loadAcquire()) {
        KisMementoManager *manager = m_mementoManager;
        m_mementoManager.storeRelease(0);
        manager->registerTileDeleted(this);
    }
 
#ifdef DEAD_TILES_SANITY_CHECK
    m_sanityHasBeenDetached.ref();
#endif
}

References m_mementoManager, and KisMementoManager::registerTileDeleted().

pixelSize()

qint32 KisTile::pixelSize ( ) const

inline

Definition at line 113 of file kis_tile.h.

                                    {
        /* don't lock here as pixelSize is constant */
        return m_tileData->pixelSize();
    }

row()

qint32 KisTile::row ( ) const

inline

Definition at line 92 of file kis_tile.h.

                              {
        return m_row;
    }

safeReleaseOldTileData()

void KisTile::safeReleaseOldTileData ( KisTileData * td )

inlineprivate

Definition at line 194 of file kis_tile.cc.

{
    QMutexLocker locker(&m_swapBarrierLock);
    Q_ASSERT(m_lockCounter >= 0);
 
    if(m_lockCounter > 0) {
        m_oldTileData.push(td);
    }
    else {
        td->unblockSwapping();
        td->release();
    }
}

References m_lockCounter, m_oldTileData, m_swapBarrierLock, KisTileData::release(), and KisTileData::unblockSwapping().

setData()

void KisTile::setData ( const quint8 * data )

inline

Definition at line 88 of file kis_tile.h.

                                            {
        m_tileData->setData(data);
    }

setNext()

void KisTile::setNext ( KisTileSP next )

inline

Definition at line 109 of file kis_tile.h.

                                 {
        m_nextTile = next;
    }

tileData()

KisTileData * KisTile::tileData ( ) const

inline

Definition at line 118 of file kis_tile.h.

                                          {
        return m_tileData;
    }

unblockSwapping()

void KisTile::unblockSwapping ( ) const

inlineprivate

Definition at line 176 of file kis_tile.cc.

{
    QMutexLocker locker(&m_swapBarrierLock);
    Q_ASSERT(m_lockCounter > 0);
 
    if(--m_lockCounter == 0) {
        m_tileData->unblockSwapping();
 
        if(!m_oldTileData.isEmpty()) {
            Q_FOREACH (KisTileData *td, m_oldTileData) {
                td->unblockSwapping();
                td->release();
            }
            m_oldTileData.clear();
        }
    }
}

References m_lockCounter, m_oldTileData, m_swapBarrierLock, m_tileData, KisTileData::release(), and KisTileData::unblockSwapping().

unlockForRead()

void KisTile::unlockForRead

(

)

const

Definition at line 275 of file kis_tile.cc.

{
    unblockSwapping();
    DEBUG_LOG_ACTION("unlock [R]");
 
#ifdef DEAD_TILES_SANITY_CHECK
    m_sanityLockedForRead.deref();
    KIS_ASSERT(m_sanityLockedForRead.loadAcquire() >= 0);
#endif
}

References DEBUG_LOG_ACTION, KIS_ASSERT, and unblockSwapping().

unlockForWrite()

void KisTile::unlockForWrite

(

)

Definition at line 264 of file kis_tile.cc.

{
    unblockSwapping();
    DEBUG_LOG_ACTION("unlock [W]");
 
#ifdef DEAD_TILES_SANITY_CHECK
    m_sanityLockedForWrite.deref();
    KIS_ASSERT(m_sanityLockedForWrite.loadAcquire() >= 0);
#endif
}

References DEBUG_LOG_ACTION, KIS_ASSERT, and unblockSwapping().

Member Data Documentation

m_col

qint32 KisTile::m_col

private

Definition at line 136 of file kis_tile.h.

m_COWMutex

QMutex KisTile::m_COWMutex

private

This is a special mutex for guarding copy-on-write operations. We do not use lockless way here as it'll create too much overhead for the most common operations like "read the pointer of m_tileData".

Definition at line 157 of file kis_tile.h.

m_extent

QRect KisTile::m_extent

private

Added for faster retrieving by processors

Definition at line 142 of file kis_tile.h.

m_lockCounter

volatile int KisTile::m_lockCounter

mutableprivate

Definition at line 134 of file kis_tile.h.

m_mementoManager

QAtomicPointer<KisMementoManager> KisTile::m_mementoManager

private

Definition at line 149 of file kis_tile.h.

m_nextTile

KisTileSP KisTile::m_nextTile

private

For KisTiledDataManager's hash table

Definition at line 147 of file kis_tile.h.

m_oldTileData

QStack<KisTileData*> KisTile::m_oldTileData

mutableprivate

Definition at line 133 of file kis_tile.h.

m_row

qint32 KisTile::m_row

private

Definition at line 137 of file kis_tile.h.

m_swapBarrierLock

QMutex KisTile::m_swapBarrierLock

mutableprivate

This lock is used to ensure no one will read the tile data before it has been loaded from to the memory.

Definition at line 163 of file kis_tile.h.

m_tileData

KisTileData* KisTile::m_tileData

private

Definition at line 132 of file kis_tile.h.

---

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

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