memory.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <tenno/mutex.hpp>
#include <tenno/types.hpp>
#include <tenno/utility.hpp>
#include <type_traits>
 
namespace tenno
{
 
/*
// Example of a custom allocator
template <class T>
struct custom_allocator
{
  using value_type = T;
  custom_allocator() noexcept;
  template <class U> custom_allocator (const custom_allocator<U>&) noexcept;
  T* allocate (tenno::size n);
  void deallocate (T* p, tenno::size n);
  constexpr bool operator== (const custom_allocator&) const noexcept;
  constexpr bool operator!= (const custom_allocator&) const noexcept;
};
*/
 
template <class T> struct allocator
{
  using value_type = T;
  using pointer = T *;
  using const_pointer = const T *;
  using reference = T &;
  using const_referemce = const T &;
  using size_type = tenno::size;
 
  allocator() noexcept = default;
  template <class U> allocator(const allocator<U> &) noexcept
  {
  }
 
  T *allocate(tenno::size n)
  {
    return (T *) ::operator new(n * sizeof(T));
  }
 
  void deallocate(T *p, tenno::size n)
  {
    ::operator delete(p, n * sizeof(T));
  }
 
  constexpr bool operator==(const allocator &) const noexcept
  {
    return true;
  }
 
  constexpr bool operator!=(const allocator &) const noexcept
  {
    return false;
  }
};
 
template <typename T> struct default_delete
{
  default_delete() noexcept = default;
  void operator()(T *ptr) const noexcept
  {
    delete ptr;
  }
  template <typename U> void operator()(U *ptr) const noexcept
  {
    delete ptr;
  }
};
 
template <class T> class weak_ptr;
 
template <class T, class Deleter = tenno::default_delete<T>,
          class Alloc = tenno::allocator<T>>
class shared_ptr
{
public:
  using element_type = T;
 
  struct control_block
  {
    T *object;
    Alloc allocator;
    Deleter deleter;
    long num_ptrs;
    long num_weak_ptrs;
    tenno::mutex cb_mutex;
    control_block() = default;
    void deallocate()
    {
      this->deleter(this->object);
      if (this->num_weak_ptrs == 0)
        this->allocator.deallocate(
          (T *) this, sizeof(control_block) / sizeof(T)
                        + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    }
  };
 
  friend control_block;
  friend class tenno::weak_ptr<T>;
  template <class Y, class... Args>
  friend typename std::enable_if<!std::is_array<Y>::value, shared_ptr<Y>>::type
  make_shared(Args &&...args) noexcept;
  template <class Y> friend shared_ptr<Y> make_shared() noexcept;
  template <class Y>
  friend typename std::enable_if<std::is_array<Y>::value, shared_ptr<Y>>::type
  make_shared(tenno::size n) noexcept;
 
  shared_ptr() noexcept : _element(nullptr), _control_block(nullptr)
  {
  }
 
  shared_ptr(T *ptr)
  {
    auto *cb = (control_block *) tenno::allocator<T>().allocate(
      sizeof(control_block) / sizeof(T)
      + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    cb->object = ptr;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = tenno::allocator<T>();
    cb->deleter = tenno::default_delete<T>();
    cb->cb_mutex = tenno::mutex();
    this->_element = cb->object;
    this->_control_block = cb;
  }
 
  shared_ptr(T *ptr, Deleter deleter)
  {
    auto *cb = (control_block *) tenno::allocator<T>().allocate(
      sizeof(control_block) / sizeof(T)
      + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    cb->object = ptr;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = tenno::allocator<T>();
    cb->deleter = deleter;
    cb->cb_mutex = tenno::mutex();
    this->_element = cb->object;
    this->_control_block = cb;
  }
 
  shared_ptr(T *ptr, Deleter deleter, Alloc alloc)
  {
    control_block *cb = (control_block *) alloc.allocate(
      sizeof(control_block) / sizeof(T)
      + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    cb->object = ptr;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = alloc;
    cb->deleter = deleter;
    cb->cb_mutex = tenno::mutex();
    this->_element = cb->object;
    this->_control_block = cb;
  }
 
  shared_ptr(const shared_ptr &other) noexcept
      : _element(other._element), _control_block(other._control_block)
  {
    tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
    this->_control_block->num_ptrs++;
  }
 
  shared_ptr(shared_ptr &&other) noexcept
      : _element(other._element), _control_block(other._control_block)
  {
    other._element = nullptr;
    other._control_block = nullptr;
  }
 
  ~shared_ptr()
  {
    if (!this->_control_block)
      return;
 
    {
      tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
      this->_control_block->num_ptrs--;
    }
    if (this->_control_block->num_ptrs == 0)
    {
      this->_control_block->deallocate();
    }
  }
 
  shared_ptr &operator=(shared_ptr &&other) noexcept
  {
    if (this == &other)
      return *this;
 
    this->_element = other._element;
    this->_control_block = other._control_block;
    return *this;
  }
 
  shared_ptr &operator=(const shared_ptr &other) noexcept
  {
    if (this == &other)
      return *this;
 
    if (this->_control_block)
    {
      {
        tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
        this->_control_block->num_ptrs--;
      }
      if (this->_control_block->num_ptrs == 0)
      {
        this->_control_block->deallocate();
      }
    }
 
    this->_element = other._element;
    this->_control_block = other._control_block;
    other._control_block->num_ptrs++;
    return *this;
  }
 
  void reset() noexcept
  {
    if (!this->_control_block)
      return;
 
    {
      tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
      this->_control_block->num_ptrs--;
    }
    if (this->_control_block->num_ptrs == 0)
    {
      this->_control_block->deallocate();
    }
 
    this->_element = nullptr;
    this->_control_block = nullptr;
  }
 
  void reset(T *ptr) noexcept
  {
    if (!this->_control_block)
      return;
 
    {
      tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
      this->_control_block->num_ptrs--;
    }
    if (this->_control_block->num_ptrs == 0)
    {
      this->_control_block->deallocate();
    }
 
    auto *cb = (control_block *) tenno::allocator<T>().allocate(
      sizeof(control_block) / sizeof(T)
      + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    cb->object = ptr;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = tenno::allocator<T>();
    cb->deleter = tenno::default_delete<T>();
    cb->cb_mutex = tenno::mutex();
    this->_element = cb->object;
    this->_control_block = cb;
  }
 
  void reset(T *ptr, Deleter deleter) noexcept
  {
    if (!this->_control_block)
      return;
 
    {
      tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
      this->_control_block->num_ptrs--;
    }
    if (this->_control_block->num_ptrs == 0)
    {
      this->_control_block->deallocate();
    }
 
    auto *cb = (control_block *) tenno::allocator<T>().allocate(
      sizeof(control_block) / sizeof(T)
      + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    cb->object = ptr;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = tenno::allocator<T>();
    cb->deleter = deleter;
    cb->cb_mutex = tenno::mutex();
    this->_element = cb->object;
    this->_control_block = cb;
  }
 
  void reset(T *ptr, Deleter deleter, Alloc alloc) noexcept
  {
    if (!this->_control_block)
      return;
 
    {
      tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
      this->_control_block->num_ptrs--;
    }
    if (this->_control_block->num_ptrs == 0)
    {
      this->_control_block->deallocate();
    }
 
    control_block *cb = (control_block *) alloc.allocate(
      sizeof(control_block) / sizeof(T)
      + (sizeof(control_block) % sizeof(T) != 0 ? 1 : 0));
    cb->object = ptr;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = alloc;
    cb->deleter = deleter;
    cb->cb_mutex = tenno::mutex();
    this->_element = cb->object;
    this->_control_block = cb;
  }
 
  void swap(shared_ptr &other) noexcept
  {
    T *tmp_element = this->_element;
    control_block *tmp_control_block = this->_control_block;
 
    this->_element = other._element;
    this->_control_block = other._control_block;
 
    other._element = tmp_element;
    other._control_block = tmp_control_block;
  }
 
  T *get() const noexcept
  {
    return this->_element;
  }
 
  T &operator*() const noexcept
  {
    return *this->_element;
  }
 
  T *operator->() const noexcept
  {
    return this->_element;
  }
 
  auto &operator[](tenno::size index) const noexcept
  {
    return (*this->_element)[index];
  }
 
  long use_count() const noexcept
  {
    if (!this->_control_block)
      return 0;
    return this->_control_block->num_ptrs;
  }
 
  explicit operator bool() const noexcept
  {
    return this->_element != nullptr;
  }
 
  bool owner_before(const shared_ptr &other) const noexcept
  {
    return *this->_element < *other._element;
  }
 
  bool owner_equal(const shared_ptr &other) const noexcept
  {
    if (!this->_element && !other._element)
      return true;
    if (!this->_element || !other._element)
      return false;
    return *this->_element == *other._element;
  }
 
  // TODO:
  // - owner_hash (c++26)
 
#ifndef TENNO_DEBUG
private:
#endif
  T *_element;
  control_block *_control_block;
};
 
template <typename T> class weak_ptr
{
public:
  using element_type = T;
 
  constexpr weak_ptr() noexcept
  {
    this->_control_block = nullptr;
    this->_ptr = nullptr;
  }
 
  weak_ptr(const weak_ptr &r) noexcept
  {
    if (!r._control_block)
    {
      this->_control_block = nullptr;
      this->_ptr = nullptr;
      return;
    }
    this->_control_block = r._control_block;
    this->_ptr = r._ptr;
    this->_control_block->num_weak_ptrs++;
  }
 
  weak_ptr(weak_ptr &&r) noexcept
  {
    if (!r._control_block)
    {
      this->_control_block = nullptr;
      this->_ptr = nullptr;
      return;
    }
    this->_control_block = r._control_block;
    this->_ptr = r._ptr;
    r._control_block = nullptr;
    r._ptr = nullptr;
  }
 
  weak_ptr(const tenno::shared_ptr<T> &r) noexcept
  {
    if (!r._control_block)
    {
      this->_control_block = nullptr;
      this->_ptr = nullptr;
      return;
    }
    tenno::lock_guard<tenno::mutex> lock(r._control_block->cb_mutex);
    this->_ptr = r._element;
    this->_control_block = r._control_block;
    this->_control_block->num_weak_ptrs++;
  }
 
  ~weak_ptr()
  {
    if (this->_control_block)
    {
      {
        tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
        this->_control_block->num_weak_ptrs--;
      }
      if (this->_control_block->num_ptrs == 0
          && this->_control_block->num_weak_ptrs == 0)
        this->_control_block->deallocate();
    }
  }
 
  weak_ptr &operator=(const weak_ptr &r) noexcept
  {
    if (this->_control_block)
    {
      {
        tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
        this->_control_block->num_weak_ptrs--;
      }
      if (this->_control_block->num_ptrs == 0
          && this->_control_block->num_weak_ptrs == 0)
        this->_control_block->deallocate();
    }
    if (!r._control_block)
    {
      this->_control_block = nullptr;
      this->_ptr = nullptr;
      return *this;
    }
    tenno::lock_guard<tenno::mutex> lock(r._control_block->cb_mutex);
    this->_control_block = r._control_block;
    this->_ptr = r._ptr;
    this->_control_block->num_weak_ptrs++;
    return *this;
  }
 
  weak_ptr &operator=(const shared_ptr<T> &r) noexcept
  {
    if (this->_control_block)
    {
      {
        tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
        this->_control_block->num_weak_ptrs--;
      }
      if (this->_control_block->num_ptrs == 0
          && this->_control_block->num_weak_ptrs == 0)
        this->_control_block->deallocate();
    }
    if (!r._control_block)
    {
      this->_control_block = nullptr;
      this->_ptr = nullptr;
      return *this;
    }
    tenno::lock_guard<tenno::mutex> lock(r._control_block->cb_mutex);
    this->_ptr = r._element;
    this->_control_block = r._control_block;
    this->_control_block->num_weak_ptrs++;
    return *this;
  }
 
  weak_ptr &operator=(weak_ptr &&r) noexcept
  {
    if (this->_control_block)
    {
      {
        tenno::lock_guard<tenno::mutex> lock(this->_control_block->cb_mutex);
        this->_control_block->num_weak_ptrs--;
      }
      if (this->_control_block->num_ptrs == 0
          && this->_control_block->num_weak_ptrs == 0)
        this->_control_block->deallocate();
    }
    if (!r._control_block)
    {
      this->_control_block = nullptr;
      this->_ptr = nullptr;
      return *this;
    }
    this->_control_block = r._control_block;
    this->_ptr = r._ptr;
    r._control_block = nullptr;
    r._ptr = nullptr;
    return *this;
  }
 
  void reset() noexcept
  {
    if (this->_control_block)
      this->_control_block->num_weak_ptrs--;
    this->_control_block = nullptr;
    this->_ptr = nullptr;
  }
 
  void swap(weak_ptr &r) noexcept
  {
    auto cb_tmp = this->_control_block;
    auto ptr_tmp = this->_ptr;
    this->_control_block = r._control_block;
    this->_ptr = r._ptr;
    r._control_block = cb_tmp;
    r._ptr = ptr_tmp;
  }
 
  long use_count() const noexcept
  {
    if (this->_control_block)
      return this->_control_block->num_ptrs;
    return 0;
  }
 
  bool expired() const noexcept
  {
    if (!this->_control_block)
      return true;
    return this->_control_block->num_ptrs == 0;
  }
 
  tenno::shared_ptr<T> lock() const noexcept
  {
    if (this->_control_block->num_ptrs == 0)
      return tenno::shared_ptr<T>();
    auto sp = tenno::shared_ptr<T>();
    sp._element = this->_ptr;
    sp._control_block = this->_control_block;
    sp._control_block->num_ptrs++;
    return sp;
  }
 
  template <class Y> bool owner_before(const weak_ptr<Y> &other) const noexcept
  {
    if (this->_ptr && !other._ptr)
      return true;
    if (!this->_ptr && other._ptr)
      return false;
    if (!this->_ptr || !other._ptr)
      return false;
    return *this->_ptr < *other._ptr;
  }
 
  template <class Y>
  bool owner_before(const tenno::shared_ptr<Y> &other) const noexcept
  {
    return *this->_ptr < *other._element;
  }
 
  template <class Y>
  bool owner_equal(const tenno::shared_ptr<Y> &other) const noexcept
  {
    if (!this->_ptr && !other._element)
      return true;
    if (!this->_ptr || !other._element)
      return false;
    return *this->_ptr == *other._element;
  }
 
  // TODO
  /*
  tenno::size_t owner_hash() const noexcept
  {
      return std::hash<element_type>()(this->_ptr);
  }
  */
 
private:
  element_type *_ptr;
  typename tenno::shared_ptr<T>::control_block *_control_block;
};
 
template <class T, class Deleter = tenno::default_delete<T>> class unique_ptr
{
public:
  using pointer = T *;
  using element_type = T;
  using deleter_type = Deleter;
 
  constexpr unique_ptr() : _value(nullptr)
  {
  }
 
  constexpr unique_ptr(T *ptr, Deleter deleter = tenno::default_delete<T>())
      : _value(ptr), _deleter(deleter)
  {
  }
 
  constexpr unique_ptr(const unique_ptr &other) = delete;
  constexpr unique_ptr(unique_ptr &&other) noexcept
  {
    this->reset(other.release());
    this->_deleter = other.get_deleter();
  }
 
#if __cplusplus >= 202002L // C++20
  constexpr
#endif
    ~unique_ptr()
  {
    if (this->_value != nullptr)
      this->_deleter(this->_value);
  }
 
  constexpr unique_ptr &operator=(const unique_ptr &other) = delete;
  constexpr unique_ptr &operator=(unique_ptr &&other) noexcept
  {
    this->reset(other.release());
    this->_deleter = other.get_deleter();
    return *this;
  }
 
  constexpr pointer release() noexcept
  {
    if (!this->_value)
      return nullptr;
 
    pointer ptr = _value;
    this->_value = nullptr;
    return ptr;
  }
 
  constexpr void reset(pointer ptr = pointer()) noexcept
  {
    if (this->_value)
      this->_deleter(this->_value);
    this->_value = ptr;
  }
 
  void swap(unique_ptr &other) noexcept
  {
    T tmp_val = *other.get();
    Deleter del_tmp = other.get_deleter();
    *other.get() = *this->get();
    other.get_deleter() = this->get_deleter();
    *this->_value = tmp_val;
    this->_deleter = del_tmp;
  }
 
  constexpr pointer get() const noexcept
  {
    return this->_value;
  }
 
  deleter_type &get_deleter()
  {
    return this->_deleter;
  }
 
  explicit operator bool() const noexcept
  {
    return this->_value != nullptr;
  }
 
  T &operator*() noexcept
  {
    return *this->_value;
  }
 
  T &operator->() noexcept
  {
    return this->_value;
  }
 
private:
  pointer _value = nullptr;
  deleter_type _deleter;
};
 
template <class T, class... Args>
typename std::enable_if<!std::is_array<T>::value, shared_ptr<T>>::type
make_shared(Args &&...args) noexcept
{
  using cb_t = typename tenno::shared_ptr<T>::control_block;
  tenno::shared_ptr<T> sp;
  T *t = new T(args...);
  cb_t *cb = (cb_t *) tenno::allocator<T>().allocate(
    sizeof(cb_t) / sizeof(T) + (sizeof(cb_t) % sizeof(T) != 0 ? 1 : 0));
  cb->object = t;
  cb->num_ptrs = 1;
  cb->num_weak_ptrs = 0;
  cb->allocator = tenno::allocator<T>();
  cb->deleter = tenno::default_delete<T>();
  cb->cb_mutex = tenno::mutex();
  sp._element = t;
  sp._control_block = cb;
  return tenno::move(sp);
}
 
template <class T>
typename std::enable_if<std::is_array<T>::value, shared_ptr<T>>::type
make_shared(tenno::size n) noexcept
{
  using cb_t = typename tenno::shared_ptr<T>::control_block;
  tenno::shared_ptr<T> sp;
  T *t = new T[n];
  cb_t *cb = (cb_t *) tenno::allocator<T>().allocate(
    sizeof(cb_t) / sizeof(T) + (sizeof(cb_t) % sizeof(T) != 0 ? 1 : 0));
  cb->object = t;
  cb->num_ptrs = 1;
  cb->num_weak_ptrs = 0;
  cb->allocator = tenno::allocator<T>();
  cb->deleter = tenno::default_delete<T>();
  cb->cb_mutex = tenno::mutex();
  sp._element = t;
  sp._control_block = cb;
  return tenno::move(sp);
}
 
template <class T> shared_ptr<T> make_shared() noexcept
{
  using cb_t = typename tenno::shared_ptr<T>::control_block;
  tenno::shared_ptr<T> sp;
  T *t = new T();
  cb_t *cb = (cb_t *) tenno::allocator<T>().allocate(
    sizeof(cb_t) / sizeof(T) + (sizeof(cb_t) % sizeof(T) != 0 ? 1 : 0));
  cb->object = t;
  cb->num_ptrs = 1;
  cb->num_weak_ptrs = 0;
  cb->allocator = tenno::allocator<T>();
  cb->deleter = tenno::default_delete<T>();
  cb->cb_mutex = tenno::mutex();
  sp._element = t;
  sp._control_block = cb;
  return tenno::move(sp);
}
 
template <class T, class Alloc, class... Args>
// typename std::enable_if<!std::is_array<T>::value, shared_ptr<T>>::type
typename tenno::shared_ptr<T> allocate_shared(Alloc &alloc,
                                              Args &&...args) noexcept
{
  T *t = alloc.allocate(1);
  *t = T(args...);
  return tenno::shared_ptr<T>(t);
}
 
template <class T, class Alloc>
shared_ptr<T> allocate_shared(Alloc &alloc) noexcept
{
  T *t = alloc.allocate(1);
  *t = T();
  return tenno::shared_ptr<T>(t);
}
 
/*
template <class T, class Alloc>
typename std::enable_if<std::is_array<T>::value, shared_ptr<T>>::type
allocate_shared(Alloc &alloc, tenno::size n) noexcept
{
    using elem = std::remove_all_extents<T>::type;
 
    T *t = (T*) alloc.allocate(n);
    auto *cb =
        new tenno::shared_ptr<T, tenno::default_delete<elem>>::control_block();
    cb->object = t;
    cb->num_ptrs = 1;
    cb->num_weak_ptrs = 0;
    cb->allocator = alloc;
    cb->deleter = tenno::default_delete<elem>();
    cb->cb_mutex = tenno::mutex();
 
    auto sp = tenno::shared_ptr<T, tenno::default_delete<elem>>();
    sp._element = t;
    sp._control_block = cb;
    return tenno::move(sp);
}
*/
 
template <class T, class... Args>
constexpr unique_ptr<T> make_unique(Args &&...args)
{
  T *t = new T(args...);
  return tenno::unique_ptr<T>(t);
}
 
} // namespace tenno