max_shared_ptr.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// This program 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
// (at your option) any later version.
//
// This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __MAX_SHARED_PTR_HH
# define __MAX_SHARED_PTR_HH

# include "../lockfree/unordered_set.hh"
# include <unordered_set>
# include "../memory/pool_allocator.hh"
# include <memory>
# include <atomic>

# include "../type_traits/is_same_ellipsis.hh"
# include <type_traits/is_constructible.hh>
# include "deref.hh"
# include "../hash/mhash.hh"
# include <wrappers/members.hh>

namespace aurelia {

  struct virt_ptr {
  public:
    std::atomic<long>& count() const {
      return const_cast<virt_ptr*>(this)->_count;
    }

  private:
    std::atomic<long> _count;

  public:
    virt_ptr() {
      _count.store(0);
    }

    ~virt_ptr() {
    }

  protected:
    virt_ptr(const virt_ptr& other): _count(0) {
      _count.store(other._count.load());
    }

  public:
    virt_ptr(virt_ptr&& other): _count(0) {
      _count.store(other._count.load());
    }

    virt_ptr& operator=(virt_ptr&& other) {
      long tmp = _count.load();
      _count.store(other._count.load());
      other._count.store(tmp);
      return *this;
    }
  };

  DEF_MEMBER_WRAPPER(collect);

  template <typename T,
            bool = IF(catsfoot::is_callable<member_collect(T&)>)>
  struct collector {
    static bool collect(T&) {
      return false;
    }
  };

  template <typename T>
  struct collector<T, true> {
    static bool collect(T& t) {
      return t.collect();
    }
  };

  template <typename T, typename Hash = mhash<T>,
            typename EqnFunc = std::equal_to<T>,
            typename Alloc = pool_allocator<T>,
            bool lockfree = true>
  struct max_shared_ptr {
  protected:
    struct ptr;
    typedef typename
    std::conditional<lockfree,
                     lockfree::unordered_set<ptr, deref_op<Hash>,
                                             deref_op<EqnFunc>,
                                             Alloc>,
                     std::unordered_set<ptr, deref_op<Hash>,
                                        deref_op<EqnFunc>,
                                        Alloc> >::type set_t;
    struct ptr: public virt_ptr {
    private:
      typedef virt_ptr super;
      T core;

      explicit ptr(T&& core): core(std::move(core)) {
      }

    public:
      static void init(set_t& _set) {
        //Ensure all allocators have been used before call to atexit
        //so that collect will be called before any call to static
        //cleanup of allocators.
        _set.insert(ptr(T()));
        _set.clear();
        while (collector<set_t>::collect(_set)) ;
        atexit(collect);
      }

      const T& operator*() const {
        return core;
      }

      const T* get() const {
        return &core;
      }

      ptr(const ptr& other): core(other.core) {}

      ptr(ptr&& other): super(std::move(other)),
                        core(std::move(other.core))
      {}

      ptr& operator=(ptr&& other) {
        std::swap(*(super*)this, (super&)other);
        std::swap(core, other.core);
        return *this;
      }

      static const typename set_t::iterator create(T&& core) {
        ptr tmp(std::move(core));
        while (true) {
          std::pair<typename set_t::iterator, bool> r =
            set().insert(std::move(tmp));
          if (r.second) {
            (*r.first).count()++;
            return r.first;
          }
          long count = (*r.first).count().load();
          if (count == 0)
            //Either being built, or destroyed.
            //Note in this case that ~ptr has been already called, but
            //not the deallocator. For this reason ~ptr should never
            //alter _count.
            continue ;
          if (!(*r.first).count().compare_exchange_strong(count, count+1))
            continue ;

          return r.first;
        }
      }
    };
  private:

    typename set_t::iterator _ptr;

  public:
    static void collect() {
      while (collector<set_t>::collect(set())) ;
    }

  private:
    struct init_set {
      set_t _set;
      init_set() {
        ptr::init(_set);
      }
    };

  protected:
    static set_t& set() {
      static init_set _set;
      return _set._set;
    }

  protected:
    explicit max_shared_ptr(const typename set_t::iterator& other)
      : _ptr(other) {
      ++((*_ptr).count());
    }

  public:
    ~max_shared_ptr() {
      if (_ptr == set().end())
        return ;
      if (0 == --((*_ptr).count())) {
        set().erase(_ptr);
      }
      _ptr = set().end();
    }

    max_shared_ptr(T&& core): _ptr(ptr::create(std::move(core))) {
    }

    max_shared_ptr(const max_shared_ptr& other): _ptr(other._ptr) {
      if (_ptr != set().end())
        (*_ptr).count()++;
    }

    max_shared_ptr(max_shared_ptr&& other): _ptr(other._ptr) {
      other._ptr = set().end();
    }

    max_shared_ptr& operator=(max_shared_ptr&& other) {
      std::swap(_ptr, other._ptr);
      return *this;
    }

    max_shared_ptr& operator=(const max_shared_ptr& other) {
      return *this = max_shared_ptr(other);
    }

    template <typename... Args,
              ENABLE_IF_NOT(type_traits::
                            is_same_ellipsis<max_shared_ptr,
                                             Args...>),
              ENABLE_IF(catsfoot::is_constructible<T(Args...)>)>
    max_shared_ptr(Args... args...):
      _ptr(ptr::create(T(std::forward<Args>(args)...))) {
    }

    max_shared_ptr(): _ptr(set().end()) {
    }

    bool operator==(const max_shared_ptr& other) const {
      return _ptr == other._ptr;
    }

    bool operator!=(const max_shared_ptr& other) const {
      return _ptr != other._ptr;
    }

    const T* get() const {
      return (*_ptr).get();
    }

    const T* operator->() const {
      return get();
    }

    const T& operator*() const {
      return *get();
    }
  };

}



#endif