cache_ram.h

Go to the documentation of this file.

#ifndef CVMFS_CACHE_RAM_H_
#define CVMFS_CACHE_RAM_H_

#include <pthread.h>

#include <cassert>
#include <cstdlib>
#include <string>
#include <vector>

#include "cache.h"
#include "crypto/hash.h"
#include "fd_table.h"
#include "kvstore.h"
#include "statistics.h"
#include "util/pointer.h"


class RamCacheManager : public CacheManager {
 public:
  struct Counters {
    perf::Counter *n_getsize;
    perf::Counter *n_close;
    perf::Counter *n_pread;
    perf::Counter *n_dup;
    perf::Counter *n_readahead;
    perf::Counter *n_starttxn;
    perf::Counter *n_write;
    perf::Counter *n_reset;
    perf::Counter *n_aborttxn;
    perf::Counter *n_committxn;
    perf::Counter *n_enfile;
    perf::Counter *n_openregular;
    perf::Counter *n_openvolatile;
    perf::Counter *n_openmiss;
    perf::Counter *n_overrun;
    perf::Counter *n_full;
    perf::Counter *n_realloc;

    explicit Counters(perf::StatisticsTemplate statistics) {
      n_getsize = statistics.RegisterTemplated("n_getsize",
        "Number of GetSize calls");
      n_close = statistics.RegisterTemplated("n_close",
        "Number of Close calls");
      n_pread = statistics.RegisterTemplated("n_pread",
        "Number of Pread calls");
      n_dup = statistics.RegisterTemplated("n_dup",
        "Number of Dup calls");
      n_readahead = statistics.RegisterTemplated("n_readahead",
        "Number of ReadAhead calls");
      n_starttxn = statistics.RegisterTemplated("n_starttxn",
        "Number of StartTxn calls");
      n_write = statistics.RegisterTemplated("n_write",
        "Number of Write calls");
      n_reset = statistics.RegisterTemplated("n_reset",
        "Number of Reset calls");
      n_aborttxn = statistics.RegisterTemplated("n_aborttxn",
        "Number of AbortTxn calls");
      n_committxn = statistics.RegisterTemplated("n_committxn",
        "Number of Commit calls");
      n_enfile = statistics.RegisterTemplated("n_enfile",
        "Number of times the limit on handles was reached");
      n_openregular = statistics.RegisterTemplated("n_openregular",
        "Number of opens from the regular cache");
      n_openvolatile = statistics.RegisterTemplated("n_openvolatile",
        "Number of opens from the volatile cache");
      n_openmiss = statistics.RegisterTemplated("n_openmiss",
        "Number of missed opens");
      n_realloc = statistics.RegisterTemplated("n_realloc",
        "Number of reallocs");
      n_overrun = statistics.RegisterTemplated("n_overrun",
        "Number of cache limit overruns");
      n_full = statistics.RegisterTemplated("n_full",
        "Number of overruns that could not be resolved");
    }
  };

  virtual CacheManagerIds id() { return kRamCacheManager; }
  virtual std::string Describe();

  RamCacheManager(
    uint64_t max_size,
    unsigned max_entries,
    MemoryKvStore::MemoryAllocator alloc,
    perf::StatisticsTemplate statistics);

  virtual ~RamCacheManager();

  virtual bool AcquireQuotaManager(QuotaManager *quota_mgr);

  virtual int Open(const BlessedObject &object);

  virtual int64_t GetSize(int fd);

  virtual int Close(int fd);

  virtual int64_t Pread(int fd, void *buf, uint64_t size, uint64_t offset);

  virtual int Dup(int fd);

  virtual int Readahead(int fd);


  virtual uint32_t SizeOfTxn() { return sizeof(Transaction); }


  virtual int StartTxn(const shash::Any &id, uint64_t size, void *txn);

  virtual void CtrlTxn(const ObjectInfo &object_info,
                       const int flags,
                       void *txn);

  virtual int64_t Write(const void *buf, uint64_t size, void *txn);

  virtual int Reset(void *txn);

  virtual int OpenFromTxn(void *txn);

  virtual int AbortTxn(void *txn);

  virtual int CommitTxn(void *txn);

  virtual void Spawn() { }

 private:
  // The null hash (hashed output is all null bytes) serves as a marker for
  // an invalid handle
  static const shash::Any kInvalidHandle;

  struct ReadOnlyHandle {
    ReadOnlyHandle()
      : handle(kInvalidHandle)
      , is_volatile(false)
      { }
    ReadOnlyHandle(const shash::Any &h, bool v)
      : handle(h)
      , is_volatile(v)
      { }
    bool operator ==(const ReadOnlyHandle &other) const {
      return this->handle == other.handle;
    }
    bool operator !=(const ReadOnlyHandle &other) const {
      return this->handle != other.handle;
    }

    shash::Any handle;
    bool is_volatile;
  };

  struct Transaction {
    Transaction()
      : buffer()
      , expected_size(0)
      , pos(0) { }
    MemoryBuffer buffer;
    uint64_t expected_size;
    uint64_t pos;
    std::string description;
  };

  inline MemoryKvStore *GetStore(const ReadOnlyHandle &fd) {
    if (fd.is_volatile) {
      return &volatile_entries_;
    } else {
      return &regular_entries_;
    }
  }

  inline MemoryKvStore *GetTransactionStore(Transaction *txn) {
    if (txn->buffer.object_type == kTypeVolatile) {
      return &volatile_entries_;
    } else {
      return &regular_entries_;
    }
  }

  int AddFd(const ReadOnlyHandle &handle);
  int64_t CommitToKvStore(Transaction *transaction);
  virtual int DoOpen(const shash::Any &id);

  uint64_t max_size_;
  FdTable<ReadOnlyHandle> fd_table_;
  pthread_rwlock_t rwlock_;
  MemoryKvStore regular_entries_;
  MemoryKvStore volatile_entries_;
  Counters counters_;
};  // class RamCacheManager

#endif  // CVMFS_CACHE_RAM_H_