malloc_heap.h

Go to the documentation of this file.

#ifndef CVMFS_MALLOC_HEAP_H_
#define CVMFS_MALLOC_HEAP_H_

#include <inttypes.h>
#include <stdint.h>

#include <cstdlib>

#include "util/async.h"

class MallocHeap {
 public:
  struct BlockPtr {
    BlockPtr() : pointer(NULL) { }
    explicit BlockPtr(void *p) : pointer(p) { }
    void *pointer;
  };

  // Pointer to the callback method invoked for each memory block that gets
  // compacted.
  typedef Callbackable<BlockPtr>::CallbackTN *CallbackPtr;

  MallocHeap(uint64_t capacity, CallbackPtr callback_ptr);
  ~MallocHeap();

  void *Allocate(uint64_t size, void *header, unsigned header_size);
  void *Expand(void *block, uint64_t new_size);
  void MarkFree(void *block);
  uint64_t GetSize(void *block);
  void Compact();

  inline uint64_t num_blocks() { return num_blocks_; }
  inline uint64_t used_bytes() { return gauge_; }
  inline uint64_t stored_bytes() { return stored_; }
  inline uint64_t compacted_bytes() {
    return stored_ + num_blocks_ * sizeof(Tag);
  }
  inline uint64_t capacity() { return capacity_; }
  inline double utilization() {
    return static_cast<double>(stored_) / static_cast<double>(gauge_);
  }
  bool HasSpaceFor(uint64_t nbytes);

 private:
  static const unsigned kMinCapacity = 1024;

  struct Tag {
    Tag() : size(0) { }
    explicit Tag(int64_t s) : size(s) { }
    inline uint64_t GetSize() {
      if (size < 0)
        return -size;
      return size;
    }
    inline bool IsFree() { return size < 0; }
    inline Tag *JumpToNext() {
      return reinterpret_cast<Tag *>(reinterpret_cast<unsigned char *>(this)
                                     + sizeof(Tag) + GetSize());
    }
    inline unsigned char *GetBlock() {
      return reinterpret_cast<unsigned char *>(this) + sizeof(Tag);
    }
    int64_t size;
  };

  CallbackPtr callback_ptr_;
  uint64_t capacity_;
  uint64_t gauge_;
  uint64_t stored_;
  uint64_t num_blocks_;
  unsigned char *heap_;
};  // class MallocHeap

#endif  // CVMFS_MALLOC_HEAP_H_