KisChunkAllocator Class Reference

#include <kis_chunk_allocator.h>

Public Member Functions
void	debugChunks ()
qreal	debugFragmentation (bool toStderr=true)
void	freeChunk (KisChunk chunk)
KisChunk	getChunk (quint64 size)
	KisChunkAllocator (quint64 slabSize=DEFAULT_SLAB_SIZE, quint64 storeSize=DEFAULT_STORE_SIZE)
quint64	numChunks () const
bool	sanityCheck (bool pleaseCrash=true)
	~KisChunkAllocator ()

Private Member Functions
bool	tryInsertChunk (KisChunkDataList &list, KisChunkDataListIterator &iterator, quint64 size)

Private Attributes
KisChunkDataListIterator	m_iterator
KisChunkDataList	m_list
quint64	m_storeMaxSize
quint64	m_storeSize
quint64	m_storeSlabSize

Detailed Description

Definition at line 116 of file kis_chunk_allocator.h.

Constructor & Destructor Documentation

KisChunkAllocator()

KisChunkAllocator::KisChunkAllocator	(	quint64	slabSize = DEFAULT_SLAB_SIZE,
		quint64	storeSize = DEFAULT_STORE_SIZE )

Definition at line 21 of file kis_chunk_allocator.cpp.

{
    m_storeMaxSize = storeSize;
    m_storeSlabSize = slabSize;
 
    m_iterator = m_list.begin();
    m_storeSize = m_storeSlabSize;
    INIT_FAIL_COUNTER();
}

References INIT_FAIL_COUNTER, m_iterator, m_list, m_storeMaxSize, m_storeSize, and m_storeSlabSize.

~KisChunkAllocator()

KisChunkAllocator::~KisChunkAllocator

(

)

Definition at line 31 of file kis_chunk_allocator.cpp.

{
}

Member Function Documentation

debugChunks()

void KisChunkAllocator::debugChunks

(

)

Definition at line 122 of file kis_chunk_allocator.cpp.

{
    quint64 idx = 0;
    KisChunkDataListIterator i;
 
    for(i = m_list.begin(); i != m_list.end(); ++i) {
        qInfo("chunk #%lld: [%lld %lld]", idx++, i->m_begin, i->m_end);
    }
}

References m_list.

debugFragmentation()

qreal KisChunkAllocator::debugFragmentation

(

bool

toStderr = true

)

Definition at line 161 of file kis_chunk_allocator.cpp.

{
    KisChunkDataListIterator i;
 
    quint64 totalSize = 0;
    quint64 allocated = 0;
    quint64 free = 0;
    qreal fragmentation = 0;
 
    for(i = m_list.begin(); i != m_list.end(); ++i) {
        allocated += i->m_end - i->m_begin + 1;
 
        if(HAS_PREVIOUS(m_list, i))
            free += GAP_SIZE(PEEK_PREVIOUS(i).m_end, i->m_begin);
        else
            free += i->m_begin;
    }
 
    i = m_list.end();
    if(HAS_PREVIOUS(m_list, i))
        totalSize = PEEK_PREVIOUS(i).m_end + 1;
 
    if(totalSize)
        fragmentation = qreal(free) / totalSize;
 
    if(toStderr) {
        qInfo() << "Hard store limit:\t" << m_storeMaxSize;
        qInfo() << "Slab size:\t\t" << m_storeSlabSize;
        qInfo() << "Num slabs:\t\t" << m_storeSize / m_storeSlabSize;
        qInfo() << "Store size:\t\t" << m_storeSize;
        qInfo() << "Total used:\t\t" << totalSize;
        qInfo() << "Allocated:\t\t" << allocated;
        qInfo() << "Free:\t\t\t" << free;
        qInfo() << "Fragmentation:\t\t" << fragmentation;
        DEBUG_FAIL_COUNTER();
    }
 
    Q_ASSERT(totalSize == allocated + free);
 
    return fragmentation;
}

References DEBUG_FAIL_COUNTER, GAP_SIZE, HAS_PREVIOUS, m_list, m_storeMaxSize, m_storeSize, m_storeSlabSize, and PEEK_PREVIOUS.

freeChunk()

void KisChunkAllocator::freeChunk

(

KisChunk

chunk

)

Definition at line 104 of file kis_chunk_allocator.cpp.

{
    if(m_iterator != m_list.end() && m_iterator == chunk.position()) {
        m_iterator = m_list.erase(m_iterator);
        return;
    }
 
    Q_ASSERT(chunk.position()->m_begin == chunk.begin());
    m_list.erase(chunk.position());
}

References KisChunk::begin(), m_iterator, m_list, and KisChunk::position().

getChunk()

KisChunk KisChunkAllocator::getChunk

(

quint64

size

)

Definition at line 35 of file kis_chunk_allocator.cpp.

{
    KisChunkDataListIterator startPosition = m_iterator;
    START_COUNTING();
 
    forever {
        if(tryInsertChunk(m_list, m_iterator, size))
            return WRAP_PREVIOUS_CHUNK_DATA(m_iterator);
 
        if(m_iterator == m_list.end())
            break;
 
        m_iterator++;
        REGISTER_STEP();
    }
 
    REGISTER_FAIL();
    m_iterator = m_list.begin();
 
    forever {
        if(tryInsertChunk(m_list, m_iterator, size))
            return WRAP_PREVIOUS_CHUNK_DATA(m_iterator);
 
        if(m_iterator == m_list.end() || m_iterator == startPosition)
            break;
 
        m_iterator++;
        REGISTER_STEP();
    }
 
    REGISTER_FAIL();
    m_iterator = m_list.end();
 
    while ((m_storeSize += m_storeSlabSize) <= m_storeMaxSize) {
        if(tryInsertChunk(m_list, m_iterator, size))
            return WRAP_PREVIOUS_CHUNK_DATA(m_iterator);
    }
 
    qFatal("KisChunkAllocator: out of swap space");
 
    // just let gcc be happy! :)
    return KisChunk(m_list.end());
}

References m_iterator, m_list, m_storeMaxSize, m_storeSize, m_storeSlabSize, REGISTER_FAIL, REGISTER_STEP, START_COUNTING, tryInsertChunk(), and WRAP_PREVIOUS_CHUNK_DATA.

numChunks()

quint64 KisChunkAllocator::numChunks ( ) const

inline

Definition at line 123 of file kis_chunk_allocator.h.

                                     {
        return m_list.size();
    }

sanityCheck()

bool KisChunkAllocator::sanityCheck

(

bool

pleaseCrash = true

)

Definition at line 132 of file kis_chunk_allocator.cpp.

{
    bool failed = false;
    KisChunkDataListIterator i;
 
    for(i = m_list.begin(); i != m_list.end(); ++i) {
        if(HAS_PREVIOUS(m_list, i)) {
            if(PEEK_PREVIOUS(i).m_end >= i->m_begin) {
                qWarning("Chunks overlapped: [%lld %lld], [%lld %lld]", PEEK_PREVIOUS(i).m_begin, PEEK_PREVIOUS(i).m_end, i->m_begin, i->m_end);
                failed = true;
                break;
            }
        }
    }
 
    i = m_list.end();
    if(HAS_PREVIOUS(m_list, i)) {
        if(PEEK_PREVIOUS(i).m_end >= m_storeSize) {
            warnKrita << "Last chunk exceeds the store size!";
            failed = true;
        }
    }
 
    if(failed && pleaseCrash)
        qFatal("KisChunkAllocator: sanity check failed!");
 
    return !failed;
}

References HAS_PREVIOUS, m_list, m_storeSize, PEEK_PREVIOUS, and warnKrita.

tryInsertChunk()

bool KisChunkAllocator::tryInsertChunk ( KisChunkDataList & list, KisChunkDataListIterator & iterator, quint64 size )

private

Definition at line 79 of file kis_chunk_allocator.cpp.

{
    bool result = false;
    quint64 highBound = m_storeSize;
    quint64 lowBound = 0;
    quint64 shift = 0;
 
    if(HAS_NEXT(list, iterator))
        highBound = PEEK_NEXT(iterator).m_begin;
 
    if(HAS_PREVIOUS(list, iterator)) {
        lowBound = PEEK_PREVIOUS(iterator).m_end;
        shift = 1;
    }
 
    if(GAP_SIZE(lowBound, highBound) >= size) {
        list.insert(iterator, KisChunkData(lowBound + shift, size));
        result = true;
    }
 
    return result;
}

References GAP_SIZE, HAS_NEXT, HAS_PREVIOUS, m_storeSize, PEEK_NEXT, and PEEK_PREVIOUS.

Member Data Documentation

m_iterator

KisChunkDataListIterator KisChunkAllocator::m_iterator

private

Definition at line 145 of file kis_chunk_allocator.h.

m_list

KisChunkDataList KisChunkAllocator::m_list

private

Definition at line 144 of file kis_chunk_allocator.h.

m_storeMaxSize

quint64 KisChunkAllocator::m_storeMaxSize

private

Definition at line 140 of file kis_chunk_allocator.h.

m_storeSize

quint64 KisChunkAllocator::m_storeSize

private

Definition at line 146 of file kis_chunk_allocator.h.

m_storeSlabSize

quint64 KisChunkAllocator::m_storeSlabSize

private

Definition at line 141 of file kis_chunk_allocator.h.

---

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

• libs/image/tiles3/swap/kis_chunk_allocator.h
• libs/image/tiles3/swap/kis_chunk_allocator.cpp