SSOPointer.hpp

// Copyright (c) 2020 Graphcore Ltd. All rights reserved.
 
#ifndef poplar_SSOPointer_hpp
#define poplar_SSOPointer_hpp
 
#include <memory>
#include <type_traits>
 
namespace poplar {
 
// small space optimised pointer. stores T inline (with an alignment of A) if
// it is N bytes or smaller and the alignment A is a multiple of T's natural
// alignment. otherwise T will be allocated on the heap.
template <typename T, std::size_t N = 8, std::size_t A = 8>
class SSOPointer final {
public:
  // same semantics as a unique_ptr: can't copy, can move.
  // additionally: cannot be null, must be constructed via the make factory
  // function below. however a moved from SSOPointer will have a undefined
  // null state.
  SSOPointer(const SSOPointer &) = delete;
  SSOPointer &operator=(const SSOPointer &) = delete;
 
  SSOPointer(SSOPointer &&o) noexcept {
    void *b = &buf;
    if (isPtr()) {
      auto &src = *reinterpret_cast<T **>(&o.buf);
      auto &dst = *reinterpret_cast<T **>(b);
      dst = src;
      src = nullptr;
    } else {
      new (b) T(std::move(*reinterpret_cast<T *>(&o.buf)));
    }
  }
 
  SSOPointer &operator=(SSOPointer &&o) noexcept {
    if (this != &o) {
      if (isPtr()) {
        auto &src = *reinterpret_cast<T **>(&o.buf);
        auto &dst = *reinterpret_cast<T **>(&buf);
        delete dst;
        dst = src;
        src = nullptr;
      } else {
        *reinterpret_cast<T *>(&buf) =
            std::move(*reinterpret_cast<T *>(&o.buf));
      }
    }
    return *this;
  }
 
  ~SSOPointer() {
    if (isPtr()) {
      delete *reinterpret_cast<T **>(&buf);
    } else {
      reinterpret_cast<T *>(&buf)->~T();
    }
  }
 
  template <typename... Args> static SSOPointer make(Args &&...args) {
    SSOPointer p;
    void *b = &p.buf;
    if (isPtr()) {
      new (b) T *(new T(std::forward<Args>(args)...));
    } else {
      new (b) T(std::forward<Args>(args)...);
    }
    return p;
  }
 
  T *get() noexcept {
    if (isPtr()) {
      return *reinterpret_cast<T **>(&buf);
    } else {
      return reinterpret_cast<T *>(&buf);
    }
  }
 
  const T *get() const noexcept {
    if (isPtr()) {
      return *reinterpret_cast<T *const *>(&buf);
    } else {
      return reinterpret_cast<const T *>(&buf);
    }
  }
 
  T *operator->() noexcept { return get(); }
  const T *operator->() const noexcept { return get(); }
 
  T &operator*() noexcept { return *get(); }
  const T &operator*() const noexcept { return *get(); }
 
  constexpr static bool isPtr() noexcept {
    return sizeof(T) > N || A % alignof(T) != 0;
  }
 
private:
  SSOPointer() = default;
 
  static_assert(N >= sizeof(T *), "Must be at least as big as a pointer");
  static_assert(A % alignof(T *) == 0,
                "Alignment must be a valid alignment of a pointer");
  typename std::aligned_storage<N, A>::type buf;
};
 
} // namespace poplar
 
#endif // poplar_SSOPointer_hpp