kvstore.h

Go to the documentation of this file.

#ifndef CVMFS_KVSTORE_H_
#define CVMFS_KVSTORE_H_

#include <pthread.h>
#include <unistd.h>

#include <string>
#include <vector>

#include "cache.h"
#include "lru.h"
#include "malloc_heap.h"
#include "statistics.h"
#include "util/async.h"
#include "util/single_copy.h"

using namespace std;  // NOLINT


struct AllocHeader {
  AllocHeader() : version(0), id() { }
  uint8_t version;
  shash::Any id;
};


struct MemoryBuffer {
  MemoryBuffer()
      : address(NULL), size(0), refcount(0), object_flags(0), id() { }
  void *address;
  size_t size;
  unsigned int refcount;
  int object_flags;
  shash::Any id;
};


class MemoryKvStore : SingleCopy, public Callbackable<MallocHeap::BlockPtr> {
 public:
  enum MemoryAllocator {
    kMallocLibc,
    kMallocHeap,
  };

  struct Counters {
    perf::Counter *sz_size;
    perf::Counter *n_getsize;
    perf::Counter *n_getrefcount;
    perf::Counter *n_incref;
    perf::Counter *n_unref;
    perf::Counter *n_read;
    perf::Counter *n_commit;
    perf::Counter *n_delete;
    perf::Counter *n_shrinkto;
    perf::Counter *sz_read;
    perf::Counter *sz_committed;
    perf::Counter *sz_deleted;
    perf::Counter *sz_shrunk;

    explicit Counters(perf::StatisticsTemplate statistics) {
      sz_size = statistics.RegisterTemplated("sz_size", "Total size");
      n_getsize = statistics.RegisterTemplated("n_getsize",
                                               "Number of GetSize calls");
      n_getrefcount = statistics.RegisterTemplated(
          "n_getrefcount", "Number of GetRefcount calls");
      n_incref = statistics.RegisterTemplated("n_incref",
                                              "Number of IncRef calls");
      n_unref = statistics.RegisterTemplated("n_unref",
                                             "Number of Unref calls");
      n_read = statistics.RegisterTemplated("n_read", "Number of Read calls");
      n_commit = statistics.RegisterTemplated("n_commit",
                                              "Number of Commit calls");
      n_delete = statistics.RegisterTemplated("n_delete",
                                              "Number of Delete calls");
      n_shrinkto = statistics.RegisterTemplated("n_shrinkto",
                                                "Number of ShrinkTo calls");
      sz_read = statistics.RegisterTemplated("sz_read", "Bytes read");
      sz_committed = statistics.RegisterTemplated("sz_committed",
                                                  "Bytes committed");
      sz_deleted = statistics.RegisterTemplated("sz_deleted", "Bytes deleted");
      sz_shrunk = statistics.RegisterTemplated("sz_shrunk", "Bytes shrunk");
    }
  };

  MemoryKvStore(unsigned int cache_entries,
                MemoryAllocator alloc,
                unsigned alloc_size,
                perf::StatisticsTemplate statistics);

  ~MemoryKvStore();

  bool Contains(const shash::Any &id);

  int64_t GetSize(const shash::Any &id);

  int64_t GetRefcount(const shash::Any &id);

  bool IncRef(const shash::Any &id);

  bool Unref(const shash::Any &id);

  int64_t Read(const shash::Any &id, void *buf, size_t size, size_t offset);

  int Commit(const MemoryBuffer &buf);

  bool Delete(const shash::Any &id);

  bool ShrinkTo(size_t size);

  size_t GetUsed() { return used_bytes_; }

 private:
  // Compact memory once utilization falls below the threshold
  static const double kCompactThreshold;  // = 0.8

  bool DoDelete(const shash::Any &id);
  int DoMalloc(MemoryBuffer *buf);
  void DoFree(MemoryBuffer *buf);
  int DoCommit(const MemoryBuffer &buf);
  void OnBlockMove(const MallocHeap::BlockPtr &ptr);
  bool CompactMemory();

  MemoryAllocator allocator_;
  size_t used_bytes_;
  unsigned int entry_count_;
  unsigned int max_entries_;
  lru::LruCache<shash::Any, MemoryBuffer> entries_;
  MallocHeap *heap_;
  pthread_rwlock_t rwlock_;
  Counters counters_;
};

#endif  // CVMFS_KVSTORE_H_