KisSimpleUpdateQueue Class Reference

#include <kis_simple_update_queue.h>

Inheritance diagram for KisSimpleUpdateQueue:

Public Member Functions
void	addFullRefreshJob (KisNodeSP node, const QRect &rc, const QRect &cropRect, int levelOfDetail)
void	addFullRefreshJob (KisNodeSP node, const QVector< QRect > &rects, const QRect &cropRect, int levelOfDetail, KisProjectionUpdateFlags flags)
void	addSpontaneousJob (KisSpontaneousJob *spontaneousJob)
void	addUpdateJob (KisNodeSP node, const QRect &rc, const QRect &cropRect, int levelOfDetail)
void	addUpdateJob (KisNodeSP node, const QVector< QRect > &rects, const QRect &cropRect, int levelOfDetail, KisProjectionUpdateFlags flags)
bool	isEmpty () const
bool	isIdle () const
	KisSimpleUpdateQueue ()
void	optimize ()
int	overrideLevelOfDetail () const
void	processQueue (KisUpdaterContext &updaterContext)
qint32	sizeMetric () const
void	updateSettings ()
virtual	~KisSimpleUpdateQueue ()

Protected Member Functions
void	addJob (KisNodeSP node, const QVector< QRect > &rects, const QRect &cropRect, int levelOfDetail, KisBaseRectsWalker::UpdateType type, bool dontInvalidateFrames)
void	collectJobs (KisBaseRectsWalkerSP &baseWalker, QRect baseRect, const qreal maxAlpha)
bool	joinRects (QRect &baseRect, const QRect &newRect, qreal maxAlpha)
bool	processOneJob (KisUpdaterContext &updaterContext)
bool	tryMergeJob (KisNodeSP node, const QRect &rc, const QRect &cropRect, int levelOfDetail, KisBaseRectsWalker::UpdateType type, bool dontInvalidateFrames)
bool	trySplitJob (KisNodeSP node, const QRect &rc, const QRect &cropRect, int levelOfDetail, KisBaseRectsWalker::UpdateType type, bool dontInvalidateFrames)

Protected Attributes
QMutex	m_lock
qreal	m_maxCollectAlpha
qreal	m_maxMergeAlpha
qreal	m_maxMergeCollectAlpha
int	m_overrideLevelOfDetail
qint32	m_patchHeight
qint32	m_patchWidth
KisSpontaneousJobsList	m_spontaneousJobsList
KisWalkersList	m_updatesList

Detailed Description

Definition at line 23 of file kis_simple_update_queue.h.

Constructor & Destructor Documentation

KisSimpleUpdateQueue()

KisSimpleUpdateQueue::KisSimpleUpdateQueue

(

)

Definition at line 44 of file kis_simple_update_queue.cpp.

    : m_overrideLevelOfDetail(-1)
{
    updateSettings();
}

References updateSettings().

~KisSimpleUpdateQueue()

KisSimpleUpdateQueue::~KisSimpleUpdateQueue ( )

virtual

Definition at line 50 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
 
    while (!m_spontaneousJobsList.isEmpty()) {
        delete m_spontaneousJobsList.takeLast();
    }
}

References m_lock, and m_spontaneousJobsList.

Member Function Documentation

addFullRefreshJob() [1/2]

void KisSimpleUpdateQueue::addFullRefreshJob	(	KisNodeSP	node,
		const QRect &	rc,
		const QRect &	cropRect,
		int	levelOfDetail )

Definition at line 178 of file kis_simple_update_queue.cpp.

{
    addFullRefreshJob(node, {rc}, cropRect, levelOfDetail, KisProjectionUpdateFlag::None);
}

References addFullRefreshJob(), and None.

addFullRefreshJob() [2/2]

void KisSimpleUpdateQueue::addFullRefreshJob	(	KisNodeSP	node,
		const QVector< QRect > &	rects,
		const QRect &	cropRect,
		int	levelOfDetail,
		KisProjectionUpdateFlags	flags )

Definition at line 161 of file kis_simple_update_queue.cpp.

{
    KisBaseRectsWalker::UpdateType type =
        !flags.testFlag(KisProjectionUpdateFlag::NoFilthy) ?
        KisBaseRectsWalker::FULL_REFRESH :
        KisBaseRectsWalker::FULL_REFRESH_NO_FILTHY;
 
    addJob(node, rects, cropRect, levelOfDetail,
           type,
           flags.testFlag(KisProjectionUpdateFlag::DontInvalidateFrames));
}

References addJob(), DontInvalidateFrames, KisBaseRectsWalker::FULL_REFRESH, KisBaseRectsWalker::FULL_REFRESH_NO_FILTHY, and NoFilthy.

addJob()

void KisSimpleUpdateQueue::addJob ( KisNodeSP node, const QVector< QRect > & rects, const QRect & cropRect, int levelOfDetail, KisBaseRectsWalker::UpdateType type, bool dontInvalidateFrames )

protected

Definition at line 183 of file kis_simple_update_queue.cpp.

{
    QList<KisBaseRectsWalkerSP> walkers;
 
    Q_FOREACH (const QRect &rc, rects) {
        if (rc.isEmpty()) continue;
 
        KisBaseRectsWalkerSP walker;
 
        if(trySplitJob(node, rc, cropRect, levelOfDetail, type, dontInvalidateFrames)) continue;
        if(tryMergeJob(node, rc, cropRect, levelOfDetail, type, dontInvalidateFrames)) continue;
 
        if (type == KisBaseRectsWalker::UPDATE) {
            KisMergeWalker::Flags flags = KisMergeWalker::DEFAULT;
            if (dontInvalidateFrames) {
                flags |= KisMergeWalker::CLONES_DONT_INVALIDATE_FRAMES;
            }
 
            walker = new KisMergeWalker(cropRect, flags);
        }
        else if (type == KisBaseRectsWalker::FULL_REFRESH)  {
            KisFullRefreshWalker::Flags flags = KisFullRefreshWalker::None;
            if (dontInvalidateFrames) {
                flags |= KisFullRefreshWalker::ClonesDontInvalidateFrames;
            }
 
            walker = new KisFullRefreshWalker(cropRect, flags);
        }
        else if (type == KisBaseRectsWalker::UPDATE_NO_FILTHY) {
            KisMergeWalker::Flags flags = KisMergeWalker::NO_FILTHY;
            if (dontInvalidateFrames) {
                flags |= KisMergeWalker::CLONES_DONT_INVALIDATE_FRAMES;
            }
 
            walker = new KisMergeWalker(cropRect, flags);
        }
        else if (type == KisBaseRectsWalker::FULL_REFRESH_NO_FILTHY)  {
            KisFullRefreshWalker::Flags flags = KisFullRefreshWalker::NoFilthyMode;
            if (dontInvalidateFrames) {
                flags |= KisFullRefreshWalker::ClonesDontInvalidateFrames;
            }
 
            walker = new KisFullRefreshWalker(cropRect, KisFullRefreshWalker::NoFilthyMode);
        }
        /* else if(type == KisBaseRectsWalker::UNSUPPORTED) fatalKrita; */
 
        walker->collectRects(node, rc);
        if (!walker->isEmpty()) {
            walkers.append(walker);
        }
    }
 
    if (!walkers.isEmpty()) {
        m_lock.lock();
        m_updatesList.append(walkers);
        m_lock.unlock();
    }
}

References KisMergeWalker::CLONES_DONT_INVALIDATE_FRAMES, KisRefreshSubtreeWalker::ClonesDontInvalidateFrames, KisBaseRectsWalker::collectRects(), KisMergeWalker::DEFAULT, KisBaseRectsWalker::FULL_REFRESH, KisBaseRectsWalker::FULL_REFRESH_NO_FILTHY, KisBaseRectsWalker::isEmpty(), m_lock, m_updatesList, KisMergeWalker::NO_FILTHY, KisBaseRectsWalker::NoFilthyMode, KisBaseRectsWalker::None, tryMergeJob(), trySplitJob(), KisBaseRectsWalker::UPDATE, and KisBaseRectsWalker::UPDATE_NO_FILTHY.

addSpontaneousJob()

void KisSimpleUpdateQueue::addSpontaneousJob

(

KisSpontaneousJob *

spontaneousJob

)

Definition at line 246 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
 
    KisSpontaneousJob *item;
    KisMutableSpontaneousJobsListIterator iter(m_spontaneousJobsList);
 
    iter.toBack();
 
    while(iter.hasPrevious()) {
        item = iter.previous();
 
        if (spontaneousJob->overrides(item)) {
            iter.remove();
            delete item;
        }
    }
 
    m_spontaneousJobsList.append(spontaneousJob);
}

References m_lock, m_spontaneousJobsList, and KisSpontaneousJob::overrides().

addUpdateJob() [1/2]

void KisSimpleUpdateQueue::addUpdateJob	(	KisNodeSP	node,
		const QRect &	rc,
		const QRect &	cropRect,
		int	levelOfDetail )

Definition at line 173 of file kis_simple_update_queue.cpp.

{
    addUpdateJob(node, {rc}, cropRect, levelOfDetail, KisProjectionUpdateFlag::None);
}

References addUpdateJob(), and None.

addUpdateJob() [2/2]

void KisSimpleUpdateQueue::addUpdateJob	(	KisNodeSP	node,
		const QVector< QRect > &	rects,
		const QRect &	cropRect,
		int	levelOfDetail,
		KisProjectionUpdateFlags	flags )

Definition at line 149 of file kis_simple_update_queue.cpp.

{
    KisBaseRectsWalker::UpdateType type =
        !flags.testFlag(KisProjectionUpdateFlag::NoFilthy) ?
        KisBaseRectsWalker::UPDATE :
        KisBaseRectsWalker::UPDATE_NO_FILTHY;
 
    addJob(node, rects, cropRect, levelOfDetail,
           type,
           flags.testFlag(KisProjectionUpdateFlag::DontInvalidateFrames));
}

References addJob(), DontInvalidateFrames, NoFilthy, KisBaseRectsWalker::UPDATE, and KisBaseRectsWalker::UPDATE_NO_FILTHY.

collectJobs()

void KisSimpleUpdateQueue::collectJobs ( KisBaseRectsWalkerSP & baseWalker, QRect baseRect, const qreal maxAlpha )

protected

Definition at line 374 of file kis_simple_update_queue.cpp.

{
    KisBaseRectsWalkerSP item;
    KisMutableWalkersListIterator iter(m_updatesList);
 
    while(iter.hasNext()) {
        item = iter.next();
 
        if(item == baseWalker) continue;
        if(item->type() != baseWalker->type()) continue;
        if(item->startNode() != baseWalker->startNode()) continue;
        if(item->clonesDontInvalidateFrames() != baseWalker->clonesDontInvalidateFrames()) continue;
        if(item->cropRect() != baseWalker->cropRect()) continue;
        if(item->levelOfDetail() != baseWalker->levelOfDetail()) continue;
 
        if(joinRects(baseRect, item->requestedRect(), maxAlpha)) {
            iter.remove();
        }
    }
 
    if(baseWalker->requestedRect() != baseRect) {
        baseWalker->collectRects(baseWalker->startNode(), baseRect);
    }
}

References KisBaseRectsWalker::clonesDontInvalidateFrames(), KisBaseRectsWalker::collectRects(), KisBaseRectsWalker::cropRect(), joinRects(), KisBaseRectsWalker::levelOfDetail(), m_updatesList, KisBaseRectsWalker::requestedRect(), KisBaseRectsWalker::startNode(), and KisBaseRectsWalker::type().

isEmpty()

bool KisSimpleUpdateQueue::isEmpty

(

)

const

Returns true if the update queue is empty, i.e. there are no update or spontaneous jobs pending

Definition at line 267 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
    return m_updatesList.isEmpty() && m_spontaneousJobsList.isEmpty();
}

References m_lock, m_spontaneousJobsList, and m_updatesList.

isIdle()

bool KisSimpleUpdateQueue::isIdle

(

)

const

Works in the same way as isEmpty(), except that it will not wait on the mutex in case there is any contestion on the queue.

If some other threads are contending on the queue, it will just return false, whatever the state of the queue is.

Definition at line 273 of file kis_simple_update_queue.cpp.

{
    std::unique_lock<QMutex> locker(m_lock, std::try_to_lock);
    if (!locker.owns_lock()) return false;
    return m_updatesList.isEmpty() && m_spontaneousJobsList.isEmpty();
}

References m_lock, m_spontaneousJobsList, and m_updatesList.

joinRects()

bool KisSimpleUpdateQueue::joinRects ( QRect & baseRect, const QRect & newRect, qreal maxAlpha )

protected

Definition at line 401 of file kis_simple_update_queue.cpp.

{
    QRect unitedRect = baseRect | newRect;
    if(unitedRect.width() > m_patchWidth || unitedRect.height() > m_patchHeight)
        return false;
 
    bool result = false;
    qint64 baseWork = qint64(baseRect.width()) * baseRect.height() +
        qint64(newRect.width()) * newRect.height();
 
    qint64 newWork = qint64(unitedRect.width()) * unitedRect.height();
 
    qreal alpha = qreal(newWork) / baseWork;
 
    if(alpha < maxAlpha) {
        DEBUG_JOIN(baseRect, newRect, alpha);
 
        DECLARE_ACCUMULATOR();
        ACCUMULATOR_ADD(baseWork, newWork);
        ACCUMULATOR_DEBUG();
 
        baseRect = unitedRect;
        result = true;
    }
 
    return result;
}

References ACCUMULATOR_ADD, ACCUMULATOR_DEBUG, DEBUG_JOIN, DECLARE_ACCUMULATOR, m_patchHeight, and m_patchWidth.

optimize()

void KisSimpleUpdateQueue::optimize

(

)

Definition at line 362 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
 
    if(m_updatesList.size() <= 1) return;
 
    KisBaseRectsWalkerSP baseWalker = m_updatesList.first();
    QRect baseRect = baseWalker->requestedRect();
 
    collectJobs(baseWalker, baseRect, m_maxCollectAlpha);
}

References collectJobs(), m_lock, m_maxCollectAlpha, m_updatesList, and KisBaseRectsWalker::requestedRect().

overrideLevelOfDetail()

int KisSimpleUpdateQueue::overrideLevelOfDetail

(

)

const

Definition at line 73 of file kis_simple_update_queue.cpp.

{
    return m_overrideLevelOfDetail;
}

References m_overrideLevelOfDetail.

processOneJob()

bool KisSimpleUpdateQueue::processOneJob ( KisUpdaterContext & updaterContext )

protected

WARNING: Please note that this still doesn't guarantee that the spontaneous jobs are exclusive, since updates and/or strokes can be added after them. The only thing it guarantees that two spontaneous jobs will not be executed in parallel.

Right now it works as it is. Probably will need to be fixed in the future.

Definition at line 88 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
 
    KisBaseRectsWalkerSP item;
    KisMutableWalkersListIterator iter(m_updatesList);
    bool jobAdded = false;
 
    int currentLevelOfDetail = updaterContext.currentLevelOfDetail();
 
    while(iter.hasNext()) {
        item = iter.next();
 
        if ((currentLevelOfDetail < 0 || currentLevelOfDetail == item->levelOfDetail()) &&
            !item->checksumValid()) {
 
            m_overrideLevelOfDetail = item->levelOfDetail();
            item->recalculate(item->requestedRect());
            m_overrideLevelOfDetail = -1;
        }
 
        if ((currentLevelOfDetail < 0 || currentLevelOfDetail == item->levelOfDetail()) &&
            updaterContext.isJobAllowed(item)) {
 
            updaterContext.addMergeJob(item);
            iter.remove();
            jobAdded = true;
            break;
        }
    }
 
    if (jobAdded) return true;
 
    if (!m_spontaneousJobsList.isEmpty()) {
        qint32 numMergeJobs;
        qint32 numStrokeJobs;
        updaterContext.getJobsSnapshot(numMergeJobs, numStrokeJobs);
 
        KisSpontaneousJob *job = m_spontaneousJobsList.first();
        if (!numMergeJobs && !numStrokeJobs &&
            (currentLevelOfDetail < 0 || currentLevelOfDetail == job->levelOfDetail())) {
 
            updaterContext.addSpontaneousJob(job);
            m_spontaneousJobsList.removeFirst();
            jobAdded = true;
        }
    }
 
    return jobAdded;
}

References KisUpdaterContext::addMergeJob(), KisUpdaterContext::addSpontaneousJob(), KisBaseRectsWalker::checksumValid(), KisUpdaterContext::currentLevelOfDetail(), KisUpdaterContext::getJobsSnapshot(), KisUpdaterContext::isJobAllowed(), KisBaseRectsWalker::levelOfDetail(), m_lock, m_overrideLevelOfDetail, m_spontaneousJobsList, m_updatesList, KisBaseRectsWalker::recalculate(), and KisBaseRectsWalker::requestedRect().

processQueue()

void KisSimpleUpdateQueue::processQueue

(

KisUpdaterContext &

updaterContext

)

Definition at line 78 of file kis_simple_update_queue.cpp.

{
    updaterContext.lock();
 
    while(updaterContext.hasSpareThread() &&
          processOneJob(updaterContext));
 
    updaterContext.unlock();
}

References KisUpdaterContext::hasSpareThread(), KisUpdaterContext::lock(), processOneJob(), and KisUpdaterContext::unlock().

sizeMetric()

qint32 KisSimpleUpdateQueue::sizeMetric

(

)

const

Definition at line 280 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
    return m_updatesList.size() + m_spontaneousJobsList.size();
}

References m_lock, m_spontaneousJobsList, and m_updatesList.

tryMergeJob()

bool KisSimpleUpdateQueue::tryMergeJob ( KisNodeSP node, const QRect & rc, const QRect & cropRect, int levelOfDetail, KisBaseRectsWalker::UpdateType type, bool dontInvalidateFrames )

protected

We add new jobs to the tail of the list, so it's more probable to find a good candidate here.

Definition at line 320 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
 
    QRect baseRect = rc;
 
    KisBaseRectsWalkerSP goodCandidate;
    KisBaseRectsWalkerSP item;
    KisWalkersListIterator iter(m_updatesList);
 
    iter.toBack();
 
    while(iter.hasPrevious()) {
        item = iter.previous();
 
        if(item->startNode() != node) continue;
        if(item->type() != type) continue;
        if(item->clonesDontInvalidateFrames() != dontInvalidateFrames) continue;
        if(item->cropRect() != cropRect) continue;
        if(item->levelOfDetail() != levelOfDetail) continue;
 
        if(joinRects(baseRect, item->requestedRect(), m_maxMergeAlpha)) {
            goodCandidate = item;
            break;
        }
    }
 
    if(goodCandidate)
        collectJobs(goodCandidate, baseRect, m_maxMergeCollectAlpha);
 
    return (bool)goodCandidate;
}

References KisBaseRectsWalker::clonesDontInvalidateFrames(), collectJobs(), KisBaseRectsWalker::cropRect(), joinRects(), KisBaseRectsWalker::levelOfDetail(), m_lock, m_maxMergeAlpha, m_maxMergeCollectAlpha, m_updatesList, KisBaseRectsWalker::requestedRect(), KisBaseRectsWalker::startNode(), and KisBaseRectsWalker::type().

trySplitJob()

bool KisSimpleUpdateQueue::trySplitJob ( KisNodeSP node, const QRect & rc, const QRect & cropRect, int levelOfDetail, KisBaseRectsWalker::UpdateType type, bool dontInvalidateFrames )

protected

Definition at line 286 of file kis_simple_update_queue.cpp.

{
    if(rc.width() <= m_patchWidth || rc.height() <= m_patchHeight)
        return false;
 
    // a bit of recursive splitting...
 
    qint32 firstCol = rc.x() / m_patchWidth;
    qint32 firstRow = rc.y() / m_patchHeight;
 
    qint32 lastCol = (rc.x() + rc.width()) / m_patchWidth;
    qint32 lastRow = (rc.y() + rc.height()) / m_patchHeight;
 
    QVector<QRect> splitRects;
 
    for(qint32 i = firstRow; i <= lastRow; i++) {
        for(qint32 j = firstCol; j <= lastCol; j++) {
            QRect maxPatchRect(j * m_patchWidth, i * m_patchHeight,
                               m_patchWidth, m_patchHeight);
            QRect patchRect = rc & maxPatchRect;
            splitRects.append(patchRect);
        }
    }
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(!splitRects.isEmpty());
    addJob(node, splitRects, cropRect, levelOfDetail, type, dontInvalidateFrames);
 
    return true;
}

References addJob(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_patchHeight, and m_patchWidth.

updateSettings()

void KisSimpleUpdateQueue::updateSettings

(

)

Definition at line 59 of file kis_simple_update_queue.cpp.

{
    QMutexLocker locker(&m_lock);
 
    KisImageConfig config(true);
 
    m_patchWidth = config.updatePatchWidth();
    m_patchHeight = config.updatePatchHeight();
 
    m_maxCollectAlpha = config.maxCollectAlpha();
    m_maxMergeAlpha = config.maxMergeAlpha();
    m_maxMergeCollectAlpha = config.maxMergeCollectAlpha();
}

References m_lock, m_maxCollectAlpha, m_maxMergeAlpha, m_maxMergeCollectAlpha, m_patchHeight, m_patchWidth, KisImageConfig::maxCollectAlpha(), KisImageConfig::maxMergeAlpha(), KisImageConfig::maxMergeCollectAlpha(), KisImageConfig::updatePatchHeight(), and KisImageConfig::updatePatchWidth().

Member Data Documentation

m_lock

QMutex KisSimpleUpdateQueue::m_lock

mutableprotected

Definition at line 80 of file kis_simple_update_queue.h.

m_maxCollectAlpha

qreal KisSimpleUpdateQueue::m_maxCollectAlpha

protected

Maximum coefficient of work while regular optimization()

Definition at line 100 of file kis_simple_update_queue.h.

m_maxMergeAlpha

qreal KisSimpleUpdateQueue::m_maxMergeAlpha

protected

Maximum coefficient of work when to rects are considered similar and are merged in tryMergeJob()

Definition at line 106 of file kis_simple_update_queue.h.

m_maxMergeCollectAlpha

qreal KisSimpleUpdateQueue::m_maxMergeCollectAlpha

protected

The coefficient of work used while collecting phase of tryToMerge()

Definition at line 111 of file kis_simple_update_queue.h.

m_overrideLevelOfDetail

int KisSimpleUpdateQueue::m_overrideLevelOfDetail

protected

Definition at line 113 of file kis_simple_update_queue.h.

m_patchHeight

qint32 KisSimpleUpdateQueue::m_patchHeight

protected

Definition at line 95 of file kis_simple_update_queue.h.

m_patchWidth

qint32 KisSimpleUpdateQueue::m_patchWidth

protected

Parameters of optimization (loaded from a configuration file) Big update areas are split into a set of smaller ones, m_patchWidth and m_patchHeight represent the size of these areas.

Definition at line 94 of file kis_simple_update_queue.h.

m_spontaneousJobsList

KisSpontaneousJobsList KisSimpleUpdateQueue::m_spontaneousJobsList

protected

Definition at line 82 of file kis_simple_update_queue.h.

m_updatesList

KisWalkersList KisSimpleUpdateQueue::m_updatesList

protected

Definition at line 81 of file kis_simple_update_queue.h.

---

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

• libs/image/kis_simple_update_queue.h
• libs/image/kis_simple_update_queue.cpp