InternalNewSpan()

scl::span * Spices::PageCache::InternalNewSpan ( size_t k )

private

Fetch pages span(internal call).

Parameters

[in]

k

pages count. @reurn Returns a new span.

Allocate from system.

Has empty pages in pc.

Pop a span.

Iter begger span, try find spare pages in pc.

Pop a span.

New a span to split bigger span.

Push splited span to list.

Allocate memory from system if no spare pages in pc.

New a span to mamage this memory.

Push span to list.

Allocate from system.

Has empty pages in pc.

Pop a span.

Iter begger span, try find spare pages in pc.

Pop a span.

New a span to split bigger span.

Push splited span to list.

Allocate memory from system if no spare pages in pc.

New a span to mamage this memory.

Push span to list.

Definition at line 132 of file PageCache.cpp.

    {
        assert(k > 0);
 
        if (k > MemoryPool::PAGE_NUM - 1)
        {
            void* ptr      = SystemAlloc(k);
            scl::span* s   = m_SpanPool.New();
            s->m_PageId    = reinterpret_cast<size_t>(ptr) >> MemoryPool::PAGE_SHIFT;
            s->m_NPages    = k;
            s->m_BlockSize = k * (1 << MemoryPool::PAGE_SHIFT);
 
            m_IdSpanMap.set(s->m_PageId, s);
 
            return s;
        }
 
        if (!m_SpanLists[k].Empty())
        {
            scl::span* s   = m_SpanLists[k].PopFront();
            s->m_BlockSize = k * (1 << MemoryPool::PAGE_SHIFT);
 
            for (size_t i = 0; i < s->m_NPages; ++i)
            {
                m_IdSpanMap.set(s->m_PageId + i, s);
            }
 
            return s;
        }
 
        for (size_t i = k + 1; i < MemoryPool::PAGE_NUM; ++i)
        {
            if (!m_SpanLists[i].Empty())
            {
                scl::span* nSpan   = m_SpanLists[i].PopFront();
 
                scl::span* kSpan   = m_SpanPool.New();
                kSpan->m_PageId    = nSpan->m_PageId;
                kSpan->m_NPages    = k;
                kSpan->m_BlockSize = (1 << MemoryPool::PAGE_SHIFT) * k;
 
                nSpan->m_PageId   += k;
                nSpan->m_NPages   -= k;
                nSpan->m_BlockSize = (1 << MemoryPool::PAGE_SHIFT) * nSpan->m_NPages;
 
                m_SpanLists[nSpan->m_NPages].PushFront(nSpan);
 
                m_IdSpanMap.set(nSpan->m_PageId, nSpan);
                m_IdSpanMap.set(nSpan->m_PageId + nSpan->m_NPages - 1, nSpan);
 
                for (size_t j = 0; j < kSpan->m_NPages; ++j)
                {
                    m_IdSpanMap.set(kSpan->m_PageId + j, kSpan);
                }
 
                return kSpan;
            }
        }
 
        void* ptr = SystemAlloc(MemoryPool::PAGE_NUM - 1);
 
        scl::span* bigSpan   = m_SpanPool.New();
        bigSpan->m_PageId    = reinterpret_cast<size_t>(ptr) >> MemoryPool::PAGE_SHIFT;
        bigSpan->m_NPages    = MemoryPool::PAGE_NUM - 1;
        bigSpan->m_BlockSize = (1 << MemoryPool::PAGE_SHIFT) * bigSpan->m_NPages;
 
        m_SpanLists[MemoryPool::PAGE_NUM - 1].PushFront(bigSpan);
 
        return InternalNewSpan(k);
    }