leveldb::anonymous_namespace{cache.cc}::LRUCache Class Reference

Collaboration diagram for leveldb::anonymous_namespace{cache.cc}::LRUCache:

Public Member Functions
	LRUCache ()
	~LRUCache ()
void	SetCapacity (size_t capacity)
Cache::Handle *	Insert (const Slice &key, uint32_t hash, void *value, size_t charge, void(*deleter)(const Slice &key, void *value))
Cache::Handle *	Lookup (const Slice &key, uint32_t hash)
void	Release (Cache::Handle *handle)
void	Erase (const Slice &key, uint32_t hash)
void	Prune ()
size_t	TotalCharge () const

Private Member Functions
void	LRU_Remove (LRUHandle *e)
void	LRU_Append (LRUHandle *list, LRUHandle *e)
void	Ref (LRUHandle *e)
void	Unref (LRUHandle *e)
bool	FinishErase (LRUHandle *e)

Private Attributes
size_t	capacity_
port::Mutex	mutex_
size_t	usage_
LRUHandle	lru_
LRUHandle	in_use_
HandleTable	table_

Detailed Description

Definition at line 153 of file cache.cc.

Constructor & Destructor Documentation

LRUCache()

leveldb::anonymous_namespace{cache.cc}::LRUCache::LRUCache

(

)

Definition at line 200 of file cache.cc.

    : usage_(0) {
  // Make empty circular linked lists.
  lru_.next = &lru_;
  lru_.prev = &lru_;
  in_use_.next = &in_use_;
  in_use_.prev = &in_use_;
}

~LRUCache()

leveldb::anonymous_namespace{cache.cc}::LRUCache::~LRUCache

(

)

Definition at line 209 of file cache.cc.

                    {
  assert(in_use_.next == &in_use_);  // Error if caller has an unreleased handle
  for (LRUHandle* e = lru_.next; e != &lru_; ) {
    LRUHandle* next = e->next;
    assert(e->in_cache);
    e->in_cache = false;
    assert(e->refs == 1);  // Invariant of lru_ list.
    Unref(e);
    e = next;
  }
}

Here is the call graph for this function:

Member Function Documentation

Erase()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::Erase	(	const Slice &	key,
		uint32_t	hash
	)

Definition at line 318 of file cache.cc.

                                                    {
  MutexLock l(&mutex_);
  FinishErase(table_.Remove(key, hash));
}

Here is the call graph for this function:

Here is the caller graph for this function:

FinishErase()

bool leveldb::anonymous_namespace{cache.cc}::LRUCache::FinishErase ( LRUHandle *  e )

private

Definition at line 307 of file cache.cc.

                                       {
  if (e != NULL) {
    assert(e->in_cache);
    LRU_Remove(e);
    e->in_cache = false;
    usage_ -= e->charge;
    Unref(e);
  }
  return e != NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Insert()

Cache::Handle * leveldb::anonymous_namespace{cache.cc}::LRUCache::Insert	(	const Slice &	key,
		uint32_t	hash,
		void *	value,
		size_t	charge,
		void(*)(const Slice &key, void *value)	deleter
	)

Definition at line 269 of file cache.cc.

                                                    {
  MutexLock l(&mutex_);

  LRUHandle* e = reinterpret_cast<LRUHandle*>(
      malloc(sizeof(LRUHandle)-1 + key.size()));
  e->value = value;
  e->deleter = deleter;
  e->charge = charge;
  e->key_length = key.size();
  e->hash = hash;
  e->in_cache = false;
  e->refs = 1;  // for the returned handle.
  memcpy(e->key_data, key.data(), key.size());

  if (capacity_ > 0) {
    e->refs++;  // for the cache's reference.
    e->in_cache = true;
    LRU_Append(&in_use_, e);
    usage_ += charge;
    FinishErase(table_.Insert(e));
  } // else don't cache.  (Tests use capacity_==0 to turn off caching.)

  while (usage_ > capacity_ && lru_.next != &lru_) {
    LRUHandle* old = lru_.next;
    assert(old->refs == 1);
    bool erased = FinishErase(table_.Remove(old->key(), old->hash));
    if (!erased) {  // to avoid unused variable when compiled NDEBUG
      assert(erased);
    }
  }

  return reinterpret_cast<Cache::Handle*>(e);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Lookup()

Cache::Handle * leveldb::anonymous_namespace{cache.cc}::LRUCache::Lookup	(	const Slice &	key,
		uint32_t	hash
	)

Definition at line 255 of file cache.cc.

                                                             {
  MutexLock l(&mutex_);
  LRUHandle* e = table_.Lookup(key, hash);
  if (e != NULL) {
    Ref(e);
  }
  return reinterpret_cast<Cache::Handle*>(e);
}

Here is the call graph for this function:

Here is the caller graph for this function:

LRU_Append()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::LRU_Append ( LRUHandle *  list, LRUHandle *  e  )

private

Definition at line 247 of file cache.cc.

                                                       {
  // Make "e" newest entry by inserting just before *list
  e->next = list;
  e->prev = list->prev;
  e->prev->next = e;
  e->next->prev = e;
}

Here is the caller graph for this function:

LRU_Remove()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::LRU_Remove ( LRUHandle *  e )

private

Definition at line 242 of file cache.cc.

                                      {
  e->next->prev = e->prev;
  e->prev->next = e->next;
}

Here is the caller graph for this function:

Prune()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::Prune

(

)

Definition at line 323 of file cache.cc.

                     {
  MutexLock l(&mutex_);
  while (lru_.next != &lru_) {
    LRUHandle* e = lru_.next;
    assert(e->refs == 1);
    bool erased = FinishErase(table_.Remove(e->key(), e->hash));
    if (!erased) {  // to avoid unused variable when compiled NDEBUG
      assert(erased);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ref()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::Ref ( LRUHandle *  e )

private

Definition at line 221 of file cache.cc.

                               {
  if (e->refs == 1 && e->in_cache) {  // If on lru_ list, move to in_use_ list.
    LRU_Remove(e);
    LRU_Append(&in_use_, e);
  }
  e->refs++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Release()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::Release

(

Cache::Handle *

handle

)

Definition at line 264 of file cache.cc.

                                          {
  MutexLock l(&mutex_);
  Unref(reinterpret_cast<LRUHandle*>(handle));
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCapacity()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::SetCapacity ( size_t  capacity )

inline

Definition at line 159 of file cache.cc.

{ capacity_ = capacity; }

Here is the call graph for this function:

Here is the caller graph for this function:

TotalCharge()

size_t leveldb::anonymous_namespace{cache.cc}::LRUCache::TotalCharge ( ) const

inline

Definition at line 169 of file cache.cc.

                             {
    MutexLock l(&mutex_);
    return usage_;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Unref()

void leveldb::anonymous_namespace{cache.cc}::LRUCache::Unref ( LRUHandle *  e )

private

Definition at line 229 of file cache.cc.

                                 {
  assert(e->refs > 0);
  e->refs--;
  if (e->refs == 0) { // Deallocate.
    assert(!e->in_cache);
    (*e->deleter)(e->key(), e->value);
    free(e);
  } else if (e->in_cache && e->refs == 1) {  // No longer in use; move to lru_ list.
    LRU_Remove(e);
    LRU_Append(&lru_, e);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

capacity_

size_t leveldb::anonymous_namespace{cache.cc}::LRUCache::capacity_

private

Definition at line 182 of file cache.cc.

in_use_

LRUHandle leveldb::anonymous_namespace{cache.cc}::LRUCache::in_use_

private

Definition at line 195 of file cache.cc.

lru_

LRUHandle leveldb::anonymous_namespace{cache.cc}::LRUCache::lru_

private

Definition at line 191 of file cache.cc.

mutex_

port::Mutex leveldb::anonymous_namespace{cache.cc}::LRUCache::mutex_

mutableprivate

Definition at line 185 of file cache.cc.

table_

HandleTable leveldb::anonymous_namespace{cache.cc}::LRUCache::table_

private

Definition at line 197 of file cache.cc.

usage_

size_t leveldb::anonymous_namespace{cache.cc}::LRUCache::usage_

private

Definition at line 186 of file cache.cc.

---

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

• util/cache.cc