Allocator.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Hypertable. If not, see <http://www.gnu.org/licenses/>
 */

#ifndef HYPERTABLE_ALLOCATOR_H
#define HYPERTABLE_ALLOCATOR_H

#include "Error.h"

#include <utility>

namespace Hypertable {

inline void destruct(char *) {}
inline void destruct(unsigned char *) {}
inline void destruct(short *) {}
inline void destruct(unsigned short *) {}
inline void destruct(int *) {}
inline void destruct(unsigned int *) {}
inline void destruct(long *) {}
inline void destruct(unsigned long *) {}
inline void destruct(long long *) {}
inline void destruct(unsigned long long *) {}
inline void destruct(float *) {}
inline void destruct(double *) {}
inline void destruct(long double *) {}

template <typename T>
inline void destruct(T *p) { p->~T(); }


inline size_t get_align_offset(void *p) {
  if (sizeof(void *) == 8)
    return 8 - (((uint64_t)p) & 0x7);

  return 4 - (((uint64_t)p) & 0x3);
}


template <typename T>
struct AllocatorBase {
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef const T* const_pointer;
  typedef T& reference;
  typedef const T& const_reference;
  typedef T value_type;

  pointer address(reference x) const { return &x; }

  const_pointer address(const_reference x) const { return &x; }

  // implement the following 2 methods
  // pointer allocate(size_type sz);
  // void deallocate(pointer p, size_type n);

  size_type max_size() const throw() {
    return size_t(-1) / sizeof(value_type);
  }

  template< class U, class... Args >
    void construct( U* p, Args&&... args ) {
    ::new((void *)p) U(std::forward<Args>(args)...);
  }

  void construct(pointer p) {
    new(static_cast<void*>(p)) T();
  }

  void destroy(pointer p) { destruct(p); }
};


template <>
struct AllocatorBase<void> {
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void *pointer;
  typedef const void *const_pointer;
  // reference to void members are impossible.
  typedef void value_type;
};

template <typename T, class ArenaT>
class ArenaAllocatorBase : public AllocatorBase<T> {
  typedef AllocatorBase<T> Base;

  ArenaT *m_arenap;

 public:
  typedef typename Base::pointer pointer;
  typedef typename Base::size_type size_type;

  ArenaAllocatorBase() : m_arenap(NULL) {}

  ArenaAllocatorBase(ArenaT &arena) { m_arenap = &arena; }

  template <typename U>
  ArenaAllocatorBase(const ArenaAllocatorBase<U, ArenaT> &copy)
    : m_arenap(copy.m_arenap) {}

  // arena allocators only needs to implement
  // pointer allocate(size_type sz);

  inline void check_allocate_size(size_type sz) const {
    if (HT_UNLIKELY(sz > Base::max_size()))
      HT_THROW_(Error::BAD_MEMORY_ALLOCATION);
  }

  inline pointer default_allocate(size_type sz) {
    return (pointer)(::operator new(sz * sizeof(T)));
  }

  void deallocate(pointer p, size_type sz) { if (!m_arenap) ::operator delete(p); }

  template <typename U>
  bool operator==(const ArenaAllocatorBase<U, ArenaT> &x) const {
    return m_arenap == x.m_arenap;
  }

  template <typename U>
  bool operator!=(const ArenaAllocatorBase<U, ArenaT> &x) const {
    return m_arenap != x.m_arenap;
  }

  template <typename U>
  void swap(ArenaAllocatorBase<U, ArenaT> &other) {
    ArenaT *tmp = m_arenap;
    m_arenap = other.m_arenap;
    other.m_arenap = tmp;
  }

  ArenaT *arena() const { return m_arenap; }

  void set_arena(ArenaT *arena) { m_arenap = arena; }
};

} // namespace Hypertable

#endif /* HYPERTABLE_ALLOCATOR_H */