Scroom::MemoryBlobs::Blob Class Reference

#include <memoryblobs.hh>

Inheritance diagram for Scroom::MemoryBlobs::Blob:

Collaboration diagram for Scroom::MemoryBlobs::Blob:

Classes
class	UnloadData

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

Public Member Functions
RawPageData::Ptr	get ()
RawPageData::ConstPtr	getConst ()
RawPageData::Ptr	initialize (uint8_t value)
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 (PageProvider::Ptr provider, size_t size)

Private Types
enum	State { UNINITIALIZED , CLEAN , DIRTY , COMPRESSING }

Private Member Functions
	Blob (PageProvider::Ptr provider, size_t size)
void	unload ()
RawPageData::Ptr	load ()
void	compress ()

Private Attributes
PageProvider::Ptr	provider
size_t	size
uint8_t *	data {nullptr}
State	state {UNINITIALIZED}
boost::mutex	mut
RawPageData::WeakPtr	weakData
PageList	pages
std::shared_ptr< ThreadPool >	cpuBound
int	refcount {0}

Friends
class	UnloadData

Member Typedef Documentation

Ptr

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

Member Enumeration Documentation

State

enum Scroom::MemoryBlobs::Blob::State

private

Enumerator
UNINITIALIZED
CLEAN
DIRTY
COMPRESSING

    {
      UNINITIALIZED,
      CLEAN,
      DIRTY,
      COMPRESSING
    };

Constructor & Destructor Documentation

Blob()

Scroom::MemoryBlobs::Blob::Blob ( PageProvider::Ptr  provider, size_t  size  )

private

    : provider(std::move(provider_))
    , size(size_)
    , cpuBound(CpuBound())
 
  {
  }

Member Function Documentation

compress()

void Scroom::MemoryBlobs::Blob::compress ( )

private

  {
    boost::mutex::scoped_lock const lock(mut);
    if(state == COMPRESSING)
    {
      require(refcount == 0);
 
      pages = Detail::compressBlob(data, size, provider);
      free(data);
      data = nullptr;
 
      state = CLEAN;
    }
  }

Here is the call graph for this function:

create()

Blob::Ptr Scroom::MemoryBlobs::Blob::create ( PageProvider::Ptr  provider, size_t  size  )

static

{ return Ptr(new Blob(std::move(provider), size)); }

Referenced by for().

Here is the caller graph for this function:

get()

RawPageData::Ptr Scroom::MemoryBlobs::Blob::get

(

)

  {
    boost::mutex::scoped_lock const lock(mut);
    RawPageData::Ptr result = load();
    state = DIRTY;
    return result;
  }

Here is the call graph for this function:

getConst()

RawPageData::ConstPtr Scroom::MemoryBlobs::Blob::getConst

(

)

  {
    boost::mutex::scoped_lock const lock(mut);
    return load();
  }

Here is the call graph for this function:

initialize()

RawPageData::Ptr Scroom::MemoryBlobs::Blob::initialize

(

uint8_t

value

)

  {
    boost::mutex::scoped_lock const lock(mut);
    RawPageData::Ptr result = load();
    state = DIRTY;
    memset(result.get(), value, size);
    return result;
  }

Here is the call graph for this function:

load()

RawPageData::Ptr Scroom::MemoryBlobs::Blob::load ( )

private

  {
    RawPageData::Ptr result = weakData.lock();
    if(!result)
    {
      switch(state)
      {
      case UNINITIALIZED:
        // Allocate new data
        data = static_cast<uint8_t*>(malloc(size * sizeof(uint8_t)));
        break;
      case CLEAN:
        // Decompress data
        data = static_cast<uint8_t*>(malloc(size * sizeof(uint8_t)));
        Detail::decompressBlob(data, size, pages, provider);
        break;
      case DIRTY:
        break;
      case COMPRESSING:
        // Data is currently being compressed. Abort...
        state = DIRTY;
        break;
      default:
        defect_message(fmt::format("Illegal state {}", static_cast<int>(state)));
        break;
      }
 
      // data should point to something valid here...
      result = RawPageData::Ptr(data, UnloadData(shared_from_this<Blob>()));
      weakData = result;
      refcount++;
    }
 
    return result;
  }

Referenced by get(), getConst(), and initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

unload()

void Scroom::MemoryBlobs::Blob::unload ( )

private

  {
    boost::mutex::scoped_lock const lock(mut);
    refcount--;
    if(refcount == 0)
    {
      if(state == DIRTY)
      {
        state = COMPRESSING;
        cpuBound->schedule([me = shared_from_this<Blob>()] { me->compress(); }, COMPRESS_PRIO);
      }
      else
      {
        free(data);
        data = nullptr;
      }
    }
  }

Friends And Related Symbol Documentation

UnloadData

friend class UnloadData

friend

Member Data Documentation

cpuBound

std::shared_ptr<ThreadPool> Scroom::MemoryBlobs::Blob::cpuBound

private

Referenced by unload().

data

uint8_t* Scroom::MemoryBlobs::Blob::data {nullptr}

private

{nullptr};

Referenced by compress(), load(), and unload().

mut

boost::mutex Scroom::MemoryBlobs::Blob::mut

private

Referenced by compress(), get(), getConst(), initialize(), and unload().

pages

PageList Scroom::MemoryBlobs::Blob::pages

private

Referenced by compress(), and load().

provider

PageProvider::Ptr Scroom::MemoryBlobs::Blob::provider

private

Referenced by compress(), create(), and load().

refcount

int Scroom::MemoryBlobs::Blob::refcount {0}

private

{0}; // Yuk

Referenced by compress(), load(), and unload().

size

size_t Scroom::MemoryBlobs::Blob::size

private

Referenced by compress(), create(), initialize(), and load().

state

State Scroom::MemoryBlobs::Blob::state {UNINITIALIZED}

private

{UNINITIALIZED};

Referenced by compress(), get(), initialize(), load(), and unload().

weakData

RawPageData::WeakPtr Scroom::MemoryBlobs::Blob::weakData

private

Referenced by load().

---

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

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