---

more/gen/memory.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal
//
//  This file 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 2 of the License, or
//  (at your option) any later version.
//
//  This file 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, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: memory.h,v 1.2 2002/08/24 13:58:27 petter_urkedal Exp $


#ifndef MORE_GEN_MEMORY_H
#define MORE_GEN_MEMORY_H

#include <memory>
#include <stdexcept>
#include <more/bits/config.h>
#if HAVE_BDWGC
#  include <bdwgc/gc.h>
#  include <bdwgc/gc_cpp.h>
#  include <limits>
#endif

namespace more {
namespace gen {

  /** \class bad_deref memory.h more/gen/memory.h
   **
   ** Exception when an invalid dereferece is detected. */
  struct bad_deref
      : std::exception
  {
      explicit bad_deref(char const* str = 0) throw() : m_what(str) {}
      virtual char const* what() const throw();
      virtual ~bad_deref() throw();
    private:
      char const* m_what;
  };

  /** \class allocator memory.h more/gen/memory.h
   **
   ** An allocator which supports default construction without
   ** copying.  This is a trivial extension of the STL container. */
  template<typename T>
    struct allocator : ::std::allocator<T>
    {
        using std::allocator<T>::construct;
        typedef typename ::std::allocator<T>::pointer pointer;

        /** Provides to typedef other. */
        template<typename U>
          struct rebind
          {
              /** The type of equivalen allocator except that it
                  allocates objects of type U. */
              typedef allocator<U> other;
          };

        /** No-op construction. */
        allocator() {}

        /** No-op copy construction. */
        allocator(allocator const& x) : std::allocator<T>(x) {}

        /** No-op construction. */
        template<typename U>
          allocator(allocator<U> const& x) : std::allocator<T>(x) {}

        /** Invoke the default constructor on \a p. */
        void construct(pointer p) { new(p) T; }

        /** Returns a deep copy of the object at \c p. */
        pointer copy(pointer p) { return new T(*p, *this); }
    };

#ifdef HAVE_BDWGC

  /** \class gc_allocator memory.h more/gen/memory.h
   **
   **  An allocator which allocates garbage collected objects. */
  template<typename T>
    struct gc_allocator
    {
        typedef T* pointer;
        typedef T const* const_pointer;
        typedef T& reference;
        typedef T const& const_reference;
        typedef T value_type;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        template<typename U> struct rebind { typedef gc_allocator<U> other; };

        /** Trivial constructor. */
        gc_allocator() {}
        /** Trivial copy constructor. */
        gc_allocator(gc_allocator const&) {}
        /** Trivial converting copy constructor. */
        template<typename U> gc_allocator(gc_allocator<U> const&) {}

        /** Returns true. */
        bool operator==(gc_allocator const&) { return true; }
        /** Returns false. */
        bool operator!=(gc_allocator const&) { return false; }

        /** Returns \c &x. */
        pointer address(reference x) const { return &x; }
        /** Returns \c &x. */
        const_pointer address(const_reference x) const { return &x; }

        /** Returns a pointer to \c n bytes of collected memory. */
        pointer allocate(size_type n, const_pointer hint = 0)
        {
            return static_cast<pointer>(GC_malloc(n*sizeof(T)));
        }

        /** Does nothing. */
        void deallocate(pointer p, size_type) {}

        /** Returns a huge number, more than your RAM chips supports. */
        size_type max_size()
        {
            return std::numeric_limits<size_type>::max();
        }

        /** Invokes \c new((void*)p) v. */
        void construct(pointer p, const_reference v) { ::new((void*)p) T(v); }

        /** Does nothing. */
        void destroy(pointer p) {}

        /** Returns a shallow copy of \c p. Actually, that is just the
         ** pointer itself. */
        pointer copy(pointer p) { return p; }
    };

  ///\if bits
  namespace bits {
    struct weak_ptr_base
    {
      protected:
        explicit weak_ptr_base(void* ptr) throw();

        void reset_base(void* ptr) throw();

        static void* mt_get(void*) throw();
        static void* mt_eq(void*) throw();
        static void* mt_lt(void*) throw();

        typedef void* atom_type[2];
        atom_type* m_atom;
    };
  }
  ///\endif

  /** \class weak_ptr memory.h more/gen/memory.h
   **
   ** A weak pointer.  A weak_ptr holds a hidden instance of a
   ** pointer, and has methods which will return the pointer if it is
   ** still vaild, or 0 if the segment it points to is collected.
   ** This implementation provides equality and a strict ordering
   ** which is unaffected by the garbage collection.  That makes it
   ** possible to use weak_ptr as keys in maps and sets.  XXX Thread
   ** safety is not verified.  */
  template <typename T>
    struct weak_ptr
        : private bits::weak_ptr_base
    {
        typedef T element_type;

        /** Construct a weak pointer which equals ptr. The segment
            that ptr points into must not be explicitely
            deallocated. */
        weak_ptr(T* ptr = 0) throw()
            : weak_ptr_base(ptr) {}

        weak_ptr(weak_ptr const& wp) throw()
            : weak_ptr_base(wp) {}

        weak_ptr& operator=(weak_ptr const& wp) throw()
        {
            m_atom = wp.m_atom;
            return *this;
        }

        /** Returns the hidden pointer or 0 if its segment is collected. */
        T* get() const throw()
        {
#ifdef MORE_CF_WITH_THREADS
            if (more::cf::there_are_other_treads())
                return static_cast<T*>(
                    GC_call_with_alloc_lock(mt_get, (weak_ptr_base*)this));
#endif
            return static_cast<T*>((*m_atom)[0]);
        }

        /** If valid, return *get(), otherwise throw bad_deref. */
        T& operator*() const throw(bad_deref, std::logic_error)
        {
            if (T* ptr = get())
                return *ptr;
            else if ((*m_atom)[1])
                throw bad_deref("more::gen::weak_ptr::operator->: "
                                "Dereference of collected memory.");
            else
                throw std::logic_error("more::gen::weak_ptr::operator->: "
                                       "Dereference of null pointer.");
        }

        /** If non-null, return get(), otherwise throw bad_deref. */
        T* operator->() const throw(bad_deref, std::logic_error)
        {
            if (T* ptr = get())
                return *ptr;
            else if ((*m_atom)[1])
                throw bad_deref("more::gen::weak_ptr::operator->: "
                                "Dereference of collected memory.");
            else
                throw std::logic_error("more::gen::weak_ptr::operator->: "
                                       "Dereference of null pointer.");
        }

        /** GC-invariant equality comparison. That is, it is
            guaranteed to be unaffected by the collection of the
            segment it points to. */
        bool operator==(weak_ptr const& rhs) const throw()
        {
#ifdef MORE_CF_WITH_THREADS
            if (more::cf::threre_are_other_threads()) {
                void* args[2] = { (weak_ptr_base*)this,
                                  (weak_ptr_base*)&rhs };
                return GC_call_with_alloc_lock(mt_eq, args);
            }
#endif
            return (*m_atom)[1] == (*rhs.m_atom)[1];
        }

        /** GC-invariant less-than predicate. The implied ordering of
            weak_ptr objects it is guaranteed to be unaffected by the
            collection of the segments they point to. */
        bool operator<(weak_ptr const& rhs) const throw()
        {
#ifdef MORE_CF_WITH_THREADS
            if (more::cf::threre_are_other_threads()) {
                void* args[2] = { (weak_ptr_base*)this,
                                  (weak_ptr_base*)&rhs };
                return GC_call_with_alloc_lock(mt_lt, args);
            }
#endif
            return (*m_atom)[1] < (*rhs.m_atom)[1];
        }

        /** Set the pointer to a new value. */
        T* reset(T* p) throw() { reset_base(p); }
    };

  /** \class hidden_ptr memory.h more/gen/memory.h
   **
   ** A pointer that is hidden to the garbage collector.  The pointer
   ** accessible by the get() method is invalidated when the segment
   ** it points (in)to is collected.  Typically the object pointed to
   ** has a cleanup function which removes all instances of hidden_ptr
   ** pointing to it.  hidden_ptr has lower time and space complexity
   ** than weak_ptr, especially in multithreaded applications.  */
  template <typename T>
    struct hidden_ptr
    {
        typedef T element_type;
      private:
        typedef T* atom_type;
      public:

        /** Construct a hidden pointer which equals ptr. The segment
            that ptr points into must not be explicitely
            deallocated. */
        hidden_ptr(T* ptr = 0) throw()
            : m_atom(GC_NEW_ATOMIC(atom_type)) { *m_atom = ptr; }

        hidden_ptr(hidden_ptr const& wp) throw()
            : m_atom(wp.m_atom) {}

        hidden_ptr& operator=(hidden_ptr const& wp) throw()
        {
            m_atom = wp.m_atom;
            return *this;
        }

        /** Returns the hidden pointer. Note that the segment
            containing the object pointed to may be colleced and so
            that the pointer is not dereferenceable. It is up to the
            client to make sure such hidden_ptr instances are
            removed. */
        T* get() const throw() { return *m_atom; }

        /** Returns *get(), see note on get(). */
        T& operator*() const throw() { return *get(); }

        /** Returns get(), see note on get(). */
        T* operator->() const throw() { return get(); }

        /** GC-invariant equality predicate. */
        bool operator==(hidden_ptr const& rhs) const throw()
        {
            return *m_atom == *rhs.m_atom;
        }

        /** GC-invariant less-than predicate. */
        bool operator<(hidden_ptr const& rhs) const throw()
        {
            return *m_atom < *rhs.m_atom;
        }

        /** Set the pointer to a new value. */
        T* reset(T* ptr) throw()
        {
            m_atom = GC_NEW_ATOMIC(atom_type);
            *m_atom = ptr;
        }

      private:
        atom_type* m_atom;
    };

#endif

}} // more::gen

#endif

---