[Boost-commit] svn:boost r80520 - trunk/boost/interprocess

Subject: [Boost-commit] svn:boost r80520 - trunk/boost/interprocess
From: igaztanaga_at_[hidden]
Date: 2012-09-13 17:25:52

Author: igaztanaga
Date: 2012-09-13 17:25:51 EDT (Thu, 13 Sep 2012)
New Revision: 80520
URL: http://svn.boost.org/trac/boost/changeset/80520

Log:
Refactored out-of-line functions to avoid needless instantiations and improve cache friendliness
Text files modified: 
   trunk/boost/interprocess/offset_ptr.hpp |   130 ++++++++++++++++++++------------------- 
   1 files changed, 66 insertions(+), 64 deletions(-)

Modified: trunk/boost/interprocess/offset_ptr.hpp
==============================================================================
--- trunk/boost/interprocess/offset_ptr.hpp	(original)
+++ trunk/boost/interprocess/offset_ptr.hpp	2012-09-13 17:25:51 EDT (Thu, 13 Sep 2012)
@@ -44,6 +44,57 @@
 
 namespace interprocess {
 
+/// @cond
+namespace ipcdetail {
+
+   template<class OffsetType, std::size_t OffsetAlignment>
+   union offset_ptr_internal
+   {
+      OffsetType m_offset; //Distance between this object and pointee address
+      typename ::boost::aligned_storage
+         < sizeof(OffsetType)
+         , (OffsetAlignment == offset_type_alignment) ?
+            ::boost::alignment_of<OffsetType>::value : OffsetAlignment
+         >::type alignment_helper;
+   };
+
+   //Note: using the address of a local variable to point to another address
+   //is not standard conforming and this can be optimized-away by the compiler.
+   //Non-inlining is a method to remain illegal but correct
+   template <class OffsetType>
+   #if defined(_MSC_VER)
+   __declspec(noinline) //this workaround is needed for MSVC compilers
+   #elif defined (__GNUC__)//this workaround is needed for GCC
+   __attribute__((__noinline__))
+   #endif
+   void offset_ptr_set_offset(const volatile void *ptr, const void *this_ptr, OffsetType &offset)
+   {
+      //offset == 1 && ptr != 0 is not legal for this pointer
+      if(!ptr){
+         offset = 1;
+      }
+      else{
+         offset = (OffsetType)((const char*)ptr - (const char*)(this_ptr));
+         BOOST_ASSERT(offset != 1);
+      }
+   }
+
+   template <class OffsetType>
+   #if defined(_MSC_VER)
+   __declspec(noinline)
+   #elif defined (__GNUC__)
+   __attribute__((__noinline__))
+   #endif
+   void * offset_ptr_to_raw_pointer(const void *this_ptr, OffsetType offset)
+   {
+      return static_cast<void*>(
+            (offset-1) ? (const_cast<char*>(reinterpret_cast<const char*>(this_ptr)) + offset) : 0
+         );
+   }
+
+}  //namespace ipcdetail {
+/// @endcond
+
 //!A smart pointer that stores the offset between between the pointer and the
 //!the object it points. This allows offset allows special properties, since
 //!the pointer is independent from the address address of the pointee, if the
@@ -76,55 +127,56 @@
 
    //!Constructor from raw pointer (allows "0" pointer conversion).
    //!Never throws.
-   offset_ptr(pointer ptr = 0) {  this->set_offset(ptr); }
+   offset_ptr(pointer ptr = 0)
+   {  ipcdetail::offset_ptr_set_offset(ptr, this, this->internal.m_offset);  }
 
    //!Constructor from other pointer.
    //!Never throws.
    template <class T>
    offset_ptr( T *ptr
              , typename ipcdetail::enable_if< ipcdetail::is_convertible<T*, PointedType*> >::type * = 0)
-   {  this->set_offset(static_cast<PointedType*>(ptr)); }
+   {  ipcdetail::offset_ptr_set_offset(static_cast<PointedType*>(ptr), this, this->internal.m_offset);  }
 
    //!Constructor from other offset_ptr
    //!Never throws.
    offset_ptr(const offset_ptr& ptr)
-   {  this->set_offset(ptr.get());   }
+   {  ipcdetail::offset_ptr_set_offset(ptr.get(), this, this->internal.m_offset);  }
 
    //!Constructor from other offset_ptr. If pointers of pointee types are
    //!convertible, offset_ptrs will be convertibles. Never throws.
    template<class T2, class P2, class O2, std::size_t A2>
    offset_ptr( const offset_ptr<T2, P2, O2, A2> &ptr
              , typename ipcdetail::enable_if< ipcdetail::is_convertible<T2*, PointedType*> >::type * = 0)
-   {  this->set_offset(static_cast<PointedType*>(ptr.get()));   }
+   {  ipcdetail::offset_ptr_set_offset(static_cast<PointedType*>(ptr.get()), this, this->internal.m_offset);  }
 
    //!Emulates static_cast operator.
    //!Never throws.
    template<class T2, class P2, class O2, std::size_t A2>
    offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::static_cast_tag)
-   {  this->set_offset(static_cast<PointedType*>(r.get()));   }
+   {  ipcdetail::offset_ptr_set_offset(static_cast<PointedType*>(r.get()), this, this->internal.m_offset);  }
 
    //!Emulates const_cast operator.
    //!Never throws.
    template<class T2, class P2, class O2, std::size_t A2>
    offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::const_cast_tag)
-   {  this->set_offset(const_cast<PointedType*>(r.get()));   }
+   {  ipcdetail::offset_ptr_set_offset(const_cast<PointedType*>(r.get()), this, this->internal.m_offset);   }
 
    //!Emulates dynamic_cast operator.
    //!Never throws.
    template<class T2, class P2, class O2, std::size_t A2>
    offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::dynamic_cast_tag)
-   {  this->set_offset(dynamic_cast<PointedType*>(r.get()));   }
+   {  ipcdetail::offset_ptr_set_offset(dynamic_cast<PointedType*>(r.get()), this, this->internal.m_offset);  }
 
    //!Emulates reinterpret_cast operator.
    //!Never throws.
    template<class T2, class P2, class O2, std::size_t A2>
    offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::reinterpret_cast_tag)
-   {  this->set_offset(reinterpret_cast<PointedType*>(r.get()));   }
+   {  ipcdetail::offset_ptr_set_offset(reinterpret_cast<PointedType*>(r.get()), this, this->internal.m_offset);   }
 
    //!Obtains raw pointer from offset.
    //!Never throws.
-   pointer get()const
-   {  return this->to_raw_pointer();   }
+   pointer get() const
+   {  return (pointer)ipcdetail::offset_ptr_to_raw_pointer(this, this->internal.m_offset);   }
 
    offset_type get_offset() const
    {  return internal.m_offset;  }
@@ -152,19 +204,19 @@
    //!Assignment from pointer (saves extra conversion).
    //!Never throws.
    offset_ptr& operator= (pointer from)
-   {  this->set_offset(from); return *this;  }
+   {  ipcdetail::offset_ptr_set_offset(from, this, this->internal.m_offset); return *this;  }
 
    //!Assignment from other offset_ptr.
    //!Never throws.
    offset_ptr& operator= (const offset_ptr & pt)
-   {  pointer p(pt.get());  (void)p; this->set_offset(p);  return *this;  }
+   {  ipcdetail::offset_ptr_set_offset(pt.get(), this, this->internal.m_offset);  return *this;  }
 
    //!Assignment from related offset_ptr. If pointers of pointee types
    //!   are assignable, offset_ptrs will be assignable. Never throws.
    template<class T2, class P2, class O2, std::size_t A2>
    typename ipcdetail::enable_if<ipcdetail::is_convertible<T2*, PointedType*>, offset_ptr&>::type
       operator= (const offset_ptr<T2, P2, O2, A2> & ptr)
-   {  this->set_offset(static_cast<PointedType*>(ptr.get()));  return *this;  }
+   {  ipcdetail::offset_ptr_set_offset(static_cast<PointedType*>(ptr.get()), this, this->internal.m_offset);  return *this;  }
 
    //!offset_ptr += difference_type.
    //!Never throws.
@@ -309,63 +361,13 @@
 
    private:
    /// @cond
-
-   //Note: using the address of a local variable to point to another address
-   //is not standard conforming and this can be optimized-away by the compiler.
-   //Non-inlining is a method to remain illegal and correct
-   #if defined(_MSC_VER)
-   __declspec(noinline) //this workaround is needed for MSVC compilers
-   #elif defined (__GNUC__)//this workaround is needed for GCC
-   __attribute__((__noinline__))
-   #endif
-   void set_offset(const PointedType *ptr)
-   {
-      #if defined (__GNUC__)
-      //asm(""); //Prevents the function to be optimized-away (provokes an special "side-effect")
-      #endif
-      //offset == 1 && ptr != 0 is not legal for this pointer
-      if(!ptr){
-         internal.m_offset = 1;
-      }
-      else{
-         internal.m_offset = (OffsetType)((const char*)ptr - (const char*)(this));
-         BOOST_ASSERT(internal.m_offset != 1);
-      }
-   }
-
-   #if defined(_MSC_VER) && (_MSC_VER >= 1400)
-   __declspec(noinline)
-   #elif defined (__GNUC__)
-   __attribute__((__noinline__))
-   #endif
-   PointedType * to_raw_pointer() const
-   {
-      #if defined (__GNUC__)
-      //asm(""); //Prevents the function to be optimized-away (provokes an special "side-effect")
-      #endif
-      return static_cast<PointedType *>(
-         static_cast<void*>(
-            (internal.m_offset == 1) ?
-               0 :
-                  (const_cast<char*>(reinterpret_cast<const char*>(this)) + internal.m_offset)
-         )
-      );
-   }
-
    void inc_offset(DifferenceType bytes)
    {  internal.m_offset += bytes;   }
 
    void dec_offset(DifferenceType bytes)
    {  internal.m_offset -= bytes;   }
 
-   union internal_type{
-      OffsetType m_offset; //Distance between this object and pointee address
-    typename ::boost::aligned_storage
-         < sizeof(OffsetType)
-         , (OffsetAlignment == offset_type_alignment) ?
-            ::boost::alignment_of<OffsetType>::value : OffsetAlignment
-         >::type alignment_helper;
-   } internal;
+   ipcdetail::offset_ptr_internal<OffsetType, OffsetAlignment> internal;
    /// @endcond
 };