KisMementoManager Class Reference

#include <kis_memento_manager.h>

Public Member Functions
void	commit ()
KisMementoSP	currentMemento ()
void	debugPrintInfo ()
KisTileSP	getCommittedTile (qint32 col, qint32 row, bool &existingTile)
KisMementoSP	getMemento ()
bool	hasCurrentMemento ()
	KisMementoManager ()
	KisMementoManager (const KisMementoManager &rhs)
void	purgeHistory (KisMementoSP oldestMemento)
void	registerTileChange (KisTile *tile)
void	registerTileDeleted (KisTile *tile)
void	rollback (KisTileHashTable *ht, KisMementoSP memento)
void	rollforward (KisTileHashTable *ht, KisMementoSP memento)
void	setDefaultTileData (KisTileData *defaultTileData)
	~KisMementoManager ()

Protected Member Functions
qint32	findRevisionByMemento (KisMementoSP memento) const
void	resetRevisionHistory (KisMementoItemList list)

Protected Attributes
KisHistoryList	m_cancelledRevisions
KisMementoSP	m_currentMemento
QMutex	m_currentMementoExtentLock
KisMementoItemHashTable	m_headsHashTable
KisMementoItemHashTable	m_index
bool	m_registrationBlocked
KisHistoryList	m_revisions

Detailed Description

Definition at line 45 of file kis_memento_manager.h.

Constructor & Destructor Documentation

KisMementoManager() [1/2]

KisMementoManager::KisMementoManager

(

)

Tile change/delete registration is enabled for all devices by default. It can't be delayed.

Definition at line 64 of file kis_memento_manager.cc.

    : m_index(0),
      m_headsHashTable(0),
      m_registrationBlocked(false)
{
}

KisMementoManager() [2/2]

KisMementoManager::KisMementoManager

(

const KisMementoManager &

rhs

)

Definition at line 75 of file kis_memento_manager.cc.

    : m_index(rhs.m_index, 0),
        m_revisions(rhs.m_revisions),
        m_cancelledRevisions(rhs.m_cancelledRevisions),
        m_headsHashTable(rhs.m_headsHashTable, 0),
        m_currentMemento(rhs.m_currentMemento),
        m_registrationBlocked(rhs.m_registrationBlocked)
{
    Q_ASSERT_X(!m_registrationBlocked,
               "KisMementoManager", "(impossible happened) "
               "The device has been copied while registration was blocked");
}

References m_registrationBlocked.

~KisMementoManager()

KisMementoManager::~KisMementoManager

(

)

Definition at line 88 of file kis_memento_manager.cc.

{
    // Nothing to be done here. Happily...
    // Everything is done by QList and KisSharedPtr...
    DEBUG_LOG_SIMPLE_ACTION("died\n");
}

References DEBUG_LOG_SIMPLE_ACTION.

Member Function Documentation

commit()

void KisMementoManager::commit

(

)

Commits changes, made in INDEX: appends m_index into m_revisions list and owes all modified tileDatas.

We still need to continue commit, because a named transaction may be reverted by the user

Definition at line 166 of file kis_memento_manager.cc.

{
    if (m_index.isEmpty()) {
        if(namedTransactionInProgress()) {
            //warnTiles << "Named Transaction is empty";
        }
        else {
            m_currentMemento = 0;
            return;
        }
    }
 
    KisMementoItemList revisionList;
    KisMementoItemSP mi;
    KisMementoItemSP parentMI;
    bool newTile;
 
    KisMementoItemHashTableIterator iter(&m_index);
    while ((mi = iter.tile())) {
        parentMI = m_headsHashTable.getTileLazy(mi->col(), mi->row(), newTile);
 
        mi->setParent(parentMI);
        mi->commit();
        revisionList.append(mi);
 
        m_headsHashTable.deleteTile(mi->col(), mi->row());
 
        iter.moveCurrentToHashTable(&m_headsHashTable);
        //iter.next(); // previous line does this for us
    }
 
    KisHistoryItem hItem;
    hItem.itemList = revisionList;
    hItem.memento = m_currentMemento.data();
    m_revisions.append(hItem);
 
    m_currentMemento = 0;
    KIS_ASSERT(m_index.isEmpty());
 
    DEBUG_DUMP_MESSAGE("COMMIT_DONE");
 
    // Waking up pooler to prepare copies for us
    KisTileDataStore::instance()->kickPooler();
}

References KisMementoItem::col(), KisMementoItem::commit(), KisSharedPtr< T >::data(), DEBUG_DUMP_MESSAGE, KisTileHashTableTraits< T >::deleteTile(), KisTileHashTableTraits< T >::getTileLazy(), KisTileDataStore::instance(), KisTileHashTableTraits< T >::isEmpty(), KisHistoryItem::itemList, KisTileDataStore::kickPooler(), KIS_ASSERT, m_currentMemento, m_headsHashTable, m_index, m_revisions, KisHistoryItem::memento, KisTileHashTableIteratorTraits< T, LockerType >::moveCurrentToHashTable(), namedTransactionInProgress, newTile(), KisMementoItem::row(), KisMementoItem::setParent(), and KisTileHashTableIteratorTraits< T, LockerType >::tile().

currentMemento()

KisMementoSP KisMementoManager::currentMemento

(

)

Definition at line 257 of file kis_memento_manager.cc.

                                               {
    return m_currentMemento;
}

References m_currentMemento.

debugPrintInfo()

void KisMementoManager::debugPrintInfo

(

)

Definition at line 407 of file kis_memento_manager.cc.

{
    printf("KisMementoManager stats:\n");
    printf("Index list\n");
    KisMementoItemSP mi;
    KisMementoItemHashTableIteratorConst iter(&m_index);
 
    while ((mi = iter.tile())) {
        mi->debugPrintInfo();
        iter.next();
    }
 
    printf("Revisions list:\n");
    qint32 i = 0;
    Q_FOREACH (const KisHistoryItem &changeList, m_revisions) {
        printf("--- revision #%d ---\n", i++);
        Q_FOREACH (mi, changeList.itemList) {
            mi->debugPrintInfo();
        }
    }
 
    printf("\nCancelled revisions list:\n");
    i = 0;
    Q_FOREACH (const KisHistoryItem &changeList, m_cancelledRevisions) {
        printf("--- revision #%d ---\n", m_revisions.size() + i++);
        Q_FOREACH (mi, changeList.itemList) {
            mi->debugPrintInfo();
        }
    }
 
    printf("----------------\n");
    m_headsHashTable.debugPrintInfo();
}

References KisMementoItem::debugPrintInfo(), KisTileHashTableTraits< T >::debugPrintInfo(), KisHistoryItem::itemList, m_cancelledRevisions, m_headsHashTable, m_index, m_revisions, KisTileHashTableIteratorTraits< T, LockerType >::next(), and KisTileHashTableIteratorTraits< T, LockerType >::tile().

findRevisionByMemento()

qint32 KisMementoManager::findRevisionByMemento ( KisMementoSP memento ) const

protected

Definition at line 373 of file kis_memento_manager.cc.

{
    qint32 index = -1;
    for(qint32 i = 0; i < m_revisions.size(); i++) {
        if (m_revisions[i].memento == memento) {
            index = i;
            break;
        }
    }
    return index;
}

References m_revisions.

getCommittedTile()

KisTileSP KisMementoManager::getCommittedTile	(	qint32	col,
		qint32	row,
		bool &	existingTile )

Get old tile, whose memento is in the HEAD revision. existingTile returns if the tile is actually an existing non-default tile or it was created on the fly from the default tile data

Our getOldTile mechanism is supposed to return current tile, if the history is disabled. So we return zero if no named transaction is in progress.

Definition at line 215 of file kis_memento_manager.cc.

{
    if(!namedTransactionInProgress())
        return KisTileSP();
 
    KisMementoItemSP mi = m_headsHashTable.getReadOnlyTileLazy(col, row, existingTile);
    return mi->tile(0);
}

References KisTileHashTableTraits< T >::getReadOnlyTileLazy(), m_headsHashTable, namedTransactionInProgress, and KisMementoItem::tile().

getMemento()

KisMementoSP KisMementoManager::getMemento

(

)

We do not allow nested transactions

The following assert is useful for testing if some code creates a transaction on a device with "inconsistent history". We cannot keep this sanity check enabled all the time, because in some places (e.g. projection in KisAsyncMerger) such usecase is considered legit. But in places with "consistent history", e.g. in layer's paint device, such usage will cause undo corruption.

Definition at line 229 of file kis_memento_manager.cc.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(!namedTransactionInProgress());
 
    // KIS_SAFE_ASSERT_RECOVER_NOOP(m_index.isEmpty());
 
    // Clear redo() information
    m_cancelledRevisions.clear();
 
    commit();
    m_currentMemento = new KisMemento(this);
 
    DEBUG_LOG_SIMPLE_ACTION("GET_MEMENTO_DONE");
 
    return m_currentMemento;
}

References commit(), DEBUG_LOG_SIMPLE_ACTION, KIS_SAFE_ASSERT_RECOVER_NOOP, m_cancelledRevisions, m_currentMemento, and namedTransactionInProgress.

hasCurrentMemento()

bool KisMementoManager::hasCurrentMemento ( )

inline

Definition at line 98 of file kis_memento_manager.h.

                             {
        return m_currentMemento;
    }

purgeHistory()

void KisMementoManager::purgeHistory

(

KisMementoSP

oldestMemento

)

Removes all the history that precedes the revision pointed by oldestMemento. That is after calling to purgeHistory(someMemento) you won't be able to do rollback(someMemento) anymore.

Definition at line 353 of file kis_memento_manager.cc.

{
    if (m_currentMemento == oldestMemento) {
        commit();
    }
 
    qint32 revisionIndex = findRevisionByMemento(oldestMemento);
    if (revisionIndex < 0) return;
 
    for(; revisionIndex > 0; revisionIndex--) {
        resetRevisionHistory(m_revisions.first().itemList);
        m_revisions.removeFirst();
    }
 
    KIS_ASSERT(m_revisions.first().memento == oldestMemento);
    resetRevisionHistory(m_revisions.first().itemList);
 
    DEBUG_DUMP_MESSAGE("PURGE_HISTORY");
}

References commit(), DEBUG_DUMP_MESSAGE, findRevisionByMemento(), KIS_ASSERT, m_currentMemento, m_revisions, and resetRevisionHistory().

registerTileChange()

void KisMementoManager::registerTileChange

(

KisTile *

tile

)

Most tricky part. This function is called by a tile, when it gets new tile-data through COW. The Memento Manager wraps this tile-data into KisMementoItem class and waits until commit() order given. By this time KisMementoItem doesn't take part in COW mechanism. It only holds tileData->m_refCount counter to ensure tile isn't deleted from memory. When commit() comes, KisMementoItem grabs tileData->m_usersCount and since that moment it is a rightful co-owner of the tileData and COW participant. It means that tileData won't be ever changed since then. Every write request to the original tile will lead to duplicating tileData and registering it here again...

NOTE: We don't assume that the registerTileChange/Delete can be called once a commit only. Reverse can happen when we do sequential clears of the device. In such a case the tiles will be removed and added several times during a commit.

TODO: There is an 'uncomfortable' state for the tile possible 1) Imagine we have a clear device 2) Then we painted something in a tile 3) It registered itself using registerTileChange() 4) Then we called clear() and getMemento() [==commit()] 5) The tile will be registered as deleted and successfully committed to a revision. That means the states of the memento manager at stages 1 and 5 do not coincide. This will not lead to any memory leaks or bugs seen, it just not good from a theoretical perspective.

Definition at line 113 of file kis_memento_manager.cc.

{
    if (registrationBlocked()) return;
 
    DEBUG_LOG_TILE_ACTION("reg. [C]", tile, tile->col(), tile->row());
 
    KisMementoItemSP mi = m_index.getExistingTile(tile->col(), tile->row());
 
    if(!mi) {
        mi = new KisMementoItem();
        mi->changeTile(tile);
        m_index.addTile(mi);
 
        if(namedTransactionInProgress()) {
            m_currentMemento->updateExtent(mi->col(), mi->row(), &m_currentMementoExtentLock);
        }
    }
    else {
        mi->reset();
        mi->changeTile(tile);
    }
}

References KisTileHashTableTraits< T >::addTile(), KisMementoItem::changeTile(), KisMementoItem::col(), KisTile::col(), DEBUG_LOG_TILE_ACTION, KisTileHashTableTraits< T >::getExistingTile(), m_currentMemento, m_currentMementoExtentLock, m_index, namedTransactionInProgress, registrationBlocked, KisMementoItem::reset(), KisMementoItem::row(), KisTile::row(), and KisMemento::updateExtent().

registerTileDeleted()

void KisMementoManager::registerTileDeleted

(

KisTile *

tile

)

Called when a tile deleted. Creates empty KisMementoItem showing that there was a tile one day

Definition at line 136 of file kis_memento_manager.cc.

{
    if (registrationBlocked()) return;
 
    DEBUG_LOG_TILE_ACTION("reg. [D]", tile, tile->col(), tile->row());
 
    KisMementoItemSP mi = m_index.getExistingTile(tile->col(), tile->row());
 
    if(!mi) {
        mi = new KisMementoItem();
 
        KisTileData *defaultTileData = m_headsHashTable.refAndFetchDefaultTileData();
        mi->deleteTile(tile, defaultTileData);
        defaultTileData->deref();
 
        m_index.addTile(mi);
 
        if(namedTransactionInProgress()) {
            m_currentMemento->updateExtent(mi->col(), mi->row(), &m_currentMementoExtentLock);
        }
    }
    else {
        mi->reset();
 
        KisTileData *defaultTileData = m_headsHashTable.refAndFetchDefaultTileData();
        mi->deleteTile(tile, defaultTileData);
        defaultTileData->deref();
    }
}

References KisTileHashTableTraits< T >::addTile(), KisMementoItem::col(), KisTile::col(), DEBUG_LOG_TILE_ACTION, KisMementoItem::deleteTile(), KisTileData::deref(), KisTileHashTableTraits< T >::getExistingTile(), m_currentMemento, m_currentMementoExtentLock, m_headsHashTable, m_index, namedTransactionInProgress, KisTileHashTableTraits< T >::refAndFetchDefaultTileData(), registrationBlocked, KisMementoItem::reset(), KisMementoItem::row(), KisTile::row(), and KisMemento::updateExtent().

resetRevisionHistory()

void KisMementoManager::resetRevisionHistory ( KisMementoItemList list )

protected

Definition at line 385 of file kis_memento_manager.cc.

{
    KisMementoItemSP parentMI;
    KisMementoItemSP mi;
 
    Q_FOREACH (mi, list) {
        parentMI = mi->parent();
        if(!parentMI) continue;
 
        while (parentMI->parent()) {
            parentMI = parentMI->parent();
        }
        mi->setParent(parentMI);
    }
}

References KisMementoItem::parent(), and KisMementoItem::setParent().

rollback()

void KisMementoManager::rollback	(	KisTileHashTable *	ht,
		KisMementoSP	memento )

Undo and Redo stuff respectively.

When calling them, INDEX list should be empty, so to say, "working copy should be clean".

NOTE: tricky hack alert. We have just deleted some tiles from the original hash table. And they accurately reported to us about their death. Should have reported... But we have prevented their registration with explicitly blocking the process. So all the dead tiles are going to /dev/null :)

PS: It could cause some race condition... But we insist on serialization of rollback()/rollforward() requests. There is not much sense in calling rollback() concurrently.

Definition at line 265 of file kis_memento_manager.cc.

{
    commit();
 
    if (! m_revisions.size()) return;
 
    KisHistoryItem changeList = m_revisions.takeLast();
 
    // SANITY CHECK: the transaction's memento must be in sync with
    //               the revisions list we have locally
    KIS_SAFE_ASSERT_RECOVER_NOOP(changeList.memento == memento);
 
    KisMementoItemSP mi;
    KisMementoItemSP parentMI;
    KisMementoItemList::iterator iter;
 
    blockRegistration();
    forEachReversed(iter, changeList.itemList) {
        mi=*iter;
        parentMI = mi->parent();
 
        if (mi->type() == KisMementoItem::CHANGED)
            ht->deleteTile(mi->col(), mi->row());
        if (parentMI->type() == KisMementoItem::CHANGED)
            ht->addTile(parentMI->tile(this));
 
        m_headsHashTable.deleteTile(parentMI->col(), parentMI->row());
        m_headsHashTable.addTile(parentMI);
 
        // This is not necessary
        //mi->setParent(0);
    }
    unblockRegistration();
 
    // We have just emulated a commit so:
    m_currentMemento = 0;
    KIS_ASSERT(!namedTransactionInProgress());
 
    m_cancelledRevisions.prepend(changeList);
    DEBUG_DUMP_MESSAGE("UNDONE");
 
    // Waking up pooler to prepare copies for us
    KisTileDataStore::instance()->kickPooler();
}

References KisTileHashTableTraits< T >::addTile(), blockRegistration, KisMementoItem::CHANGED, KisMementoItem::col(), commit(), DEBUG_DUMP_MESSAGE, KisTileHashTableTraits< T >::deleteTile(), forEachReversed, KisTileDataStore::instance(), KisHistoryItem::itemList, KisTileDataStore::kickPooler(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, m_cancelledRevisions, m_currentMemento, m_headsHashTable, m_revisions, KisHistoryItem::memento, namedTransactionInProgress, KisMementoItem::parent(), KisMementoItem::row(), KisMementoItem::tile(), KisMementoItem::type(), and unblockRegistration.

rollforward()

void KisMementoManager::rollforward	(	KisTileHashTable *	ht,
		KisMementoSP	memento )

Definition at line 322 of file kis_memento_manager.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_index.isEmpty());
 
    if (!m_cancelledRevisions.size()) return;
 
    KisHistoryItem changeList = m_cancelledRevisions.takeFirst();
 
    // SANITY CHECK: the transaction's memento must be in sync with
    //               the revisions list we have locally
    KIS_SAFE_ASSERT_RECOVER_NOOP(changeList.memento == memento);
 
    KisMementoItemSP mi;
 
    blockRegistration();
    Q_FOREACH (mi, changeList.itemList) {
        if (mi->parent()->type() == KisMementoItem::CHANGED)
            ht->deleteTile(mi->col(), mi->row());
        if (mi->type() == KisMementoItem::CHANGED)
            ht->addTile(mi->tile(this));
 
        m_index.addTile(mi);
    }
    // see comment in rollback()
 
    m_currentMemento = changeList.memento;
    commit();
    unblockRegistration();
    DEBUG_DUMP_MESSAGE("REDONE");
}

References KisTileHashTableTraits< T >::addTile(), blockRegistration, KisMementoItem::CHANGED, KisMementoItem::col(), commit(), DEBUG_DUMP_MESSAGE, KisTileHashTableTraits< T >::deleteTile(), KisTileHashTableTraits< T >::isEmpty(), KisHistoryItem::itemList, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, m_cancelledRevisions, m_currentMemento, m_index, KisHistoryItem::memento, KisMementoItem::parent(), KisMementoItem::row(), KisMementoItem::tile(), KisMementoItem::type(), and unblockRegistration.

setDefaultTileData()

void KisMementoManager::setDefaultTileData

(

KisTileData *

defaultTileData

)

Definition at line 401 of file kis_memento_manager.cc.

{
    m_headsHashTable.setDefaultTileData(defaultTileData);
    m_index.setDefaultTileData(defaultTileData);
}

References m_headsHashTable, m_index, and KisTileHashTableTraits< T >::setDefaultTileData().

Member Data Documentation

m_cancelledRevisions

KisHistoryList KisMementoManager::m_cancelledRevisions

protected

List of revisions temporarily undone while rollback()

Definition at line 138 of file kis_memento_manager.h.

m_currentMemento

KisMementoSP KisMementoManager::m_currentMemento

protected

Stores extent of current INDEX. It is the "name" of current named transaction

Definition at line 150 of file kis_memento_manager.h.

m_currentMementoExtentLock

QMutex KisMementoManager::m_currentMementoExtentLock

protected

Definition at line 151 of file kis_memento_manager.h.

m_headsHashTable

KisMementoItemHashTable KisMementoManager::m_headsHashTable

protected

A hash table, that stores the most recently updated versions of tiles. Say, HEAD revision :)

Definition at line 144 of file kis_memento_manager.h.

m_index

KisMementoItemHashTable KisMementoManager::m_index

protected

INDEX of tiles to be committed with next commit() We use a hash table to be able to check that we have the only memento item for a tile per commit efficiently

Definition at line 128 of file kis_memento_manager.h.

m_registrationBlocked

bool KisMementoManager::m_registrationBlocked

protected

The flag that blocks registration of changes on tiles. This is a temporary state of the memento manager, that is used for traveling in history

See also

rollback()

rollforward()

Definition at line 161 of file kis_memento_manager.h.

m_revisions

KisHistoryList KisMementoManager::m_revisions

protected

Main list that stores every commit ever done

Definition at line 133 of file kis_memento_manager.h.

---

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

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