Scroom::MemoryBlobs::PageProvider Class Reference

#include <memoryblobs.hh>

Inheritance diagram for Scroom::MemoryBlobs::PageProvider:

Collaboration diagram for Scroom::MemoryBlobs::PageProvider:

Classes
class	MarkPageFree

Public Types
using	Ptr = std::shared_ptr< PageProvider >

Public Member Functions
Page::Ptr	getFreePage ()
size_t	getPageSize () const
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
std::shared_ptr< R >	shared_from_this ()
template<typename R >
std::shared_ptr< R const >	shared_from_this () const

Static Public Member Functions
static Ptr	create (size_t blockCount, size_t blockSize)

Private Member Functions
	PageProvider (size_t blockCount, size_t blockSize)
void	markPageFree (Scroom::MemoryBlocks::Page *page)

Private Attributes
size_t	blockCount
size_t	blockSize
Scroom::MemoryBlocks::BlockFactoryInterface::Ptr	blockFactoryInterface
Scroom::MemoryBlocks::PageList	allPages
std::list< Scroom::MemoryBlocks::Page * >	freePages
boost::mutex	mut

Friends
class	MarkPageFree

Member Typedef Documentation

Ptr

using Scroom::MemoryBlobs::PageProvider::Ptr = std::shared_ptr<PageProvider>

Constructor & Destructor Documentation

PageProvider()

Scroom::MemoryBlobs::PageProvider::PageProvider ( size_t  blockCount, size_t  blockSize  )

private

    : blockCount(blockCount_)
    , blockSize(blockSize_)
    , blockFactoryInterface(getBlockFactoryInterface())
  {
  }

Member Function Documentation

create()

PageProvider::Ptr Scroom::MemoryBlobs::PageProvider::create ( size_t  blockCount, size_t  blockSize  )

static

  {
    return Ptr(new PageProvider(blockCount, blockSize));
  }

Referenced by createProvider().

Here is the caller graph for this function:

getFreePage()

Page::Ptr Scroom::MemoryBlobs::PageProvider::getFreePage

(

)

  {
    boost::mutex::scoped_lock const lock(mut);
    if(freePages.empty())
    {
      Scroom::MemoryBlocks::PageList pages = blockFactoryInterface->create(blockCount, blockSize)->getPages();
      for(Scroom::MemoryBlocks::Page& p: pages)
      {
        freePages.push_back(&p);
      }
      allPages.splice(allPages.end(), pages);
    }
 
    Page::Ptr result(freePages.front(), MarkPageFree(shared_from_this<PageProvider>()));
    freePages.pop_front();
 
    return result;
  }

getPageSize()

size_t Scroom::MemoryBlobs::PageProvider::getPageSize

(

)

const

{ return blockSize; }

markPageFree()

void Scroom::MemoryBlobs::PageProvider::markPageFree ( Scroom::MemoryBlocks::Page *  page )

private

  {
    boost::mutex::scoped_lock const lock(mut);
    freePages.push_front(p);
  }

Friends And Related Symbol Documentation

MarkPageFree

friend class MarkPageFree

friend

Member Data Documentation

allPages

Scroom::MemoryBlocks::PageList Scroom::MemoryBlobs::PageProvider::allPages

private

Referenced by getFreePage().

blockCount

size_t Scroom::MemoryBlobs::PageProvider::blockCount

private

Referenced by create(), and getFreePage().

blockFactoryInterface

Scroom::MemoryBlocks::BlockFactoryInterface::Ptr Scroom::MemoryBlobs::PageProvider::blockFactoryInterface

private

Referenced by getFreePage().

blockSize

size_t Scroom::MemoryBlobs::PageProvider::blockSize

private

Referenced by create(), getFreePage(), and getPageSize().

freePages

std::list<Scroom::MemoryBlocks::Page*> Scroom::MemoryBlobs::PageProvider::freePages

private

Referenced by getFreePage(), and markPageFree().

mut

boost::mutex Scroom::MemoryBlobs::PageProvider::mut

private

Referenced by getFreePage(), and markPageFree().

---

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

• libs/memory-manager/inc/scroom/memoryblobs.hh
• libs/memory-manager/src/memoryblobs.cc