KisUpdateJobItem Class Reference

#include <kis_update_job_item.h>

Inheritance diagram for KisUpdateJobItem:

Public Types
enum class	Type : int {   EMPTY = 0 , WAITING , MERGE , STROKE ,   SPONTANEOUS }

Public Member Functions
const QRect &	accessRect () const
const QRect &	changeRect () const
bool	isRunning () const
	KisUpdateJobItem (KisUpdaterContext *updaterContext)
void	run () override
void	runMergeJob ()
void	setDone ()
bool	setSpontaneousJob (KisSpontaneousJob *spontaneousJob)
bool	setStrokeJob (KisStrokeJob *strokeJob)
bool	setWalker (KisBaseRectsWalkerSP walker)
KisStrokeJobData::Sequentiality	strokeJobSequentiality () const
Type	type () const
	~KisUpdateJobItem () override

Private Member Functions
ALWAYS_INLINE void	runImpl ()
KisStrokeJob *	strokeJob () const
void	testingSetDone ()
KisBaseRectsWalkerSP	walker () const

Private Attributes
QRect	m_accessRect
std::atomic< Type >	m_atomicType {Type::EMPTY}
QRect	m_changeRect
bool	m_exclusive {false}
KisAsyncMerger	m_merger
KisRunnableWithDebugName *	m_runnableJob {0}
volatile KisStrokeJobData::Sequentiality	m_strokeJobSequentiality {KisStrokeJobData::SEQUENTIAL}
KisUpdaterContext *	m_updaterContext {0}
KisBaseRectsWalkerSP	m_walker

Friends
class	KisSimpleUpdateQueueTest
class	KisStrokesQueueTest
class	KisTestableUpdaterContext
class	KisUpdaterContext
class	KisUpdateSchedulerTest

Detailed Description

Definition at line 24 of file kis_update_job_item.h.

Member Enumeration Documentation

Type

enum class KisUpdateJobItem::Type : int

strong

Enumerator
EMPTY
WAITING
MERGE
STROKE
SPONTANEOUS

Definition at line 28 of file kis_update_job_item.h.

                    : int {
        EMPTY = 0,
        WAITING,
        MERGE,
        STROKE,
        SPONTANEOUS
    };

Constructor & Destructor Documentation

KisUpdateJobItem()

KisUpdateJobItem::KisUpdateJobItem ( KisUpdaterContext * updaterContext )

inline

Definition at line 37 of file kis_update_job_item.h.

        : m_updaterContext(updaterContext)
    {
        setAutoDelete(false);
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_atomicType.is_lock_free());
    }

References KIS_SAFE_ASSERT_RECOVER_NOOP.

~KisUpdateJobItem()

KisUpdateJobItem::~KisUpdateJobItem ( )

inlineoverride

Definition at line 43 of file kis_update_job_item.h.

    {
        delete m_runnableJob;
    }

Member Function Documentation

accessRect()

const QRect & KisUpdateJobItem::accessRect ( ) const

inline

Definition at line 200 of file kis_update_job_item.h.

                                           {
        return m_accessRect;
    }

changeRect()

const QRect & KisUpdateJobItem::changeRect ( ) const

inline

Definition at line 204 of file kis_update_job_item.h.

                                           {
        return m_changeRect;
    }

isRunning()

bool KisUpdateJobItem::isRunning ( ) const

inline

Definition at line 192 of file kis_update_job_item.h.

                                  {
        return m_atomicType >= Type::MERGE;
    }

run()

void KisUpdateJobItem::run ( )

inlineoverride

Definition at line 48 of file kis_update_job_item.h.

                        {
        runImpl();
 
        // notify that the job is exiting and wake everybody
        // waiting on wakeForDone()
        m_updaterContext->jobThreadExited();
    }

runImpl()

ALWAYS_INLINE void KisUpdateJobItem::runImpl ( )

inlineprivate

Here we break the idea of QThreadPool a bit. Ideally, we should split the jobs into distinct QRunnable objects and pass all of them to QThreadPool. That is a nice idea, but it doesn't work well when the jobs are small enough and the number of available cores is high (>4 cores). It this case the threads just tend to execute the job very quickly and go to sleep, which is an expensive operation.

To overcome this problem we try to bulk-process the jobs. In sigJobFinished() signal (which is DirectConnection), the context may add the job to ourselves(!!!), so we switch from "done" state into "running" again.

Definition at line 58 of file kis_update_job_item.h.

                                 {
        if (!isRunning()) return;
 
        while (1) {
            KIS_SAFE_ASSERT_RECOVER_RETURN(isRunning());
 
            if(m_exclusive) {
                m_updaterContext->m_exclusiveJobLock.lockForWrite();
            } else {
                m_updaterContext->m_exclusiveJobLock.lockForRead();
            }
 
            if(m_atomicType == Type::MERGE) {
                runMergeJob();
            } else {
                KIS_ASSERT(m_atomicType == Type::STROKE ||
                           m_atomicType == Type::SPONTANEOUS);
 
                if (m_runnableJob) {
#ifdef DEBUG_JOBS_SEQUENCE
                    if (m_atomicType == Type::STROKE) {
                        qDebug() << "running: stroke" << m_runnableJob->debugName();
                    } else if (m_atomicType == Type::SPONTANEOUS) {
                        qDebug() << "running: spont " << m_runnableJob->debugName();
                    } else {
                        qDebug() << "running: unkn. " << m_runnableJob->debugName();
                    }
#endif
 
                    m_runnableJob->run();
                }
            }
 
            setDone();
 
            m_updaterContext->doSomeUsefulWork();
 
            // may flip the current state from Waiting -> Running again
            m_updaterContext->jobFinished();
 
            m_updaterContext->m_exclusiveJobLock.unlock();
 
            // try to exit the loop. Please note, that no one can flip the state from
            // WAITING to EMPTY except ourselves!
            Type expectedValue = Type::WAITING;
            if (m_atomicType.compare_exchange_strong(expectedValue, Type::EMPTY)) {
                break;
            }
        }
    }

References KIS_ASSERT, and KIS_SAFE_ASSERT_RECOVER_RETURN.

runMergeJob()

void KisUpdateJobItem::runMergeJob ( )

inline

Definition at line 124 of file kis_update_job_item.h.

                              {
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_atomicType == Type::MERGE);
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_walker);
        // dbgKrita << "Executing merge job" << m_walker->changeRect()
        //          << "on thread" << QThread::currentThreadId();
 
#ifdef DEBUG_JOBS_SEQUENCE
        qDebug() << "running: merge " << m_walker->startNode() << m_walker->changeRect();
 
#endif
 
        m_merger.startMerge(*m_walker);
 
        QRect changeRect = m_walker->changeRect();
        m_updaterContext->continueUpdate(changeRect);
    }

References KIS_SAFE_ASSERT_RECOVER_RETURN.

setDone()

void KisUpdateJobItem::setDone ( )

inline

Definition at line 185 of file kis_update_job_item.h.

                          {
        m_walker = 0;
        delete m_runnableJob;
        m_runnableJob = 0;
        m_atomicType = Type::WAITING;
    }

setSpontaneousJob()

bool KisUpdateJobItem::setSpontaneousJob ( KisSpontaneousJob * spontaneousJob )

inline

Definition at line 172 of file kis_update_job_item.h.

                                                                     {
        KIS_ASSERT(m_atomicType <= Type::WAITING);
 
        m_runnableJob = spontaneousJob;
 
        m_exclusive = spontaneousJob->isExclusive();
        m_walker = 0;
        m_accessRect = m_changeRect = QRect();
 
        const Type oldState = m_atomicType.exchange(Type::SPONTANEOUS);
        return oldState == Type::EMPTY;
    }

References KisSpontaneousJob::isExclusive(), and KIS_ASSERT.

setStrokeJob()

bool KisUpdateJobItem::setStrokeJob ( KisStrokeJob * strokeJob )

inline

Definition at line 157 of file kis_update_job_item.h.

                                                      {
        KIS_ASSERT(m_atomicType <= Type::WAITING);
 
        m_runnableJob = strokeJob;
        m_strokeJobSequentiality = strokeJob->sequentiality();
 
        m_exclusive = strokeJob->isExclusive();
        m_walker = 0;
        m_accessRect = m_changeRect = QRect();
 
        const Type oldState = m_atomicType.exchange(Type::STROKE);
        return oldState == Type::EMPTY;
    }

References KisStrokeJob::isExclusive(), KIS_ASSERT, and KisStrokeJob::sequentiality().

setWalker()

bool KisUpdateJobItem::setWalker ( KisBaseRectsWalkerSP walker )

inline

Definition at line 142 of file kis_update_job_item.h.

                                                       {
        KIS_ASSERT(m_atomicType <= Type::WAITING);
 
        m_accessRect = walker->accessRect();
        m_changeRect = walker->changeRect();
        m_walker = walker;
 
        m_exclusive = false;
        m_runnableJob = 0;
 
        const Type oldState = m_atomicType.exchange(Type::MERGE);
        return oldState == Type::EMPTY;
    }

References KisBaseRectsWalker::accessRect(), KisBaseRectsWalker::changeRect(), and KIS_ASSERT.

strokeJob()

KisStrokeJob * KisUpdateJobItem::strokeJob ( ) const

inlineprivate

Definition at line 227 of file kis_update_job_item.h.

                                           {
        KisStrokeJob *job = dynamic_cast<KisStrokeJob*>(m_runnableJob);
        Q_ASSERT(job);
 
        return job;
    }

strokeJobSequentiality()

KisStrokeJobData::Sequentiality KisUpdateJobItem::strokeJobSequentiality ( ) const

inline

Definition at line 208 of file kis_update_job_item.h.

                                                                        {
        return m_strokeJobSequentiality;
    }

testingSetDone()

void KisUpdateJobItem::testingSetDone ( )

inlineprivate

Definition at line 234 of file kis_update_job_item.h.

                                 {
        setDone();
    }

type()

Type KisUpdateJobItem::type ( ) const

inline

Definition at line 196 of file kis_update_job_item.h.

                             {
        return m_atomicType;
    }

walker()

KisBaseRectsWalkerSP KisUpdateJobItem::walker ( ) const

inlineprivate

Definition at line 223 of file kis_update_job_item.h.

                                               {
        return m_walker;
    }

Friends And Related Symbol Documentation

KisSimpleUpdateQueueTest

friend class KisSimpleUpdateQueueTest

friend

Definition at line 218 of file kis_update_job_item.h.

KisStrokesQueueTest

friend class KisStrokesQueueTest

friend

Definition at line 219 of file kis_update_job_item.h.

KisTestableUpdaterContext

friend class KisTestableUpdaterContext

friend

Open walker and stroke job for the testing suite. Please, do not use it in production code.

Definition at line 217 of file kis_update_job_item.h.

KisUpdaterContext

friend class KisUpdaterContext

friend

Definition at line 221 of file kis_update_job_item.h.

KisUpdateSchedulerTest

friend class KisUpdateSchedulerTest

friend

Definition at line 220 of file kis_update_job_item.h.

Member Data Documentation

m_accessRect

QRect KisUpdateJobItem::m_accessRect

private

These rects cache actual values from the walker to eliminate concurrent access to a walker structure

Definition at line 260 of file kis_update_job_item.h.

m_atomicType

std::atomic<Type> KisUpdateJobItem::m_atomicType {Type::EMPTY}

private

Definition at line 241 of file kis_update_job_item.h.

{Type::EMPTY};

m_changeRect

QRect KisUpdateJobItem::m_changeRect

private

Definition at line 261 of file kis_update_job_item.h.

m_exclusive

bool KisUpdateJobItem::m_exclusive {false}

private

Definition at line 240 of file kis_update_job_item.h.

{false};

m_merger

KisAsyncMerger KisUpdateJobItem::m_merger

private

Definition at line 254 of file kis_update_job_item.h.

m_runnableJob

KisRunnableWithDebugName* KisUpdateJobItem::m_runnableJob {0}

private

Runnable jobs part The job is owned by the context and deleted after completion

Definition at line 248 of file kis_update_job_item.h.

{0};

m_strokeJobSequentiality

volatile KisStrokeJobData::Sequentiality KisUpdateJobItem::m_strokeJobSequentiality {KisStrokeJobData::SEQUENTIAL}

private

Definition at line 242 of file kis_update_job_item.h.

{KisStrokeJobData::SEQUENTIAL};

m_updaterContext

KisUpdaterContext* KisUpdateJobItem::m_updaterContext {0}

private

Definition at line 239 of file kis_update_job_item.h.

{0};

m_walker

KisBaseRectsWalkerSP KisUpdateJobItem::m_walker

private

Merge jobs part

Definition at line 253 of file kis_update_job_item.h.

---

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

• libs/image/kis_update_job_item.h