Subject: [Boost-commit] svn:boost r85020 - in trunk: boost/log/detail libs/log/src
From: andrey.semashev_at_[hidden]
Date: 2013-07-12 16:24:42
Author: andysem
Date: 2013-07-12 16:24:42 EDT (Fri, 12 Jul 2013)
New Revision: 85020
URL: http://svn.boost.org/trac/boost/changeset/85020
Log:
Refactored aligned memory allocation. Added support for Android. Fixes #8815.
Added:
trunk/boost/log/detail/malloc_aligned.hpp (contents, props changed)
Text files modified:
trunk/boost/log/detail/malloc_aligned.hpp | 134 ++++++++++++++++++++++++++++++++++++++++
trunk/libs/log/src/light_rw_mutex.cpp | 21 +----
trunk/libs/log/src/threadsafe_queue.cpp | 66 +------------------
3 files changed, 145 insertions(+), 76 deletions(-)
Added: trunk/boost/log/detail/malloc_aligned.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/log/detail/malloc_aligned.hpp 2013-07-12 16:24:42 EDT (Fri, 12 Jul 2013) (r85020)
@@ -0,0 +1,134 @@
+/*
+ * Copyright Andrey Semashev 2007 - 2013.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file malloc_aligned.hpp
+ * \author Andrey Semashev
+ * \date 12.07.2013
+ *
+ * \brief This header is the Boost.Log library implementation, see the library documentation
+ * at http://www.boost.org/libs/log/doc/log.html.
+ */
+
+#ifndef BOOST_LOG_DETAIL_MALLOC_ALIGNED_HPP_INCLUDED_
+#define BOOST_LOG_DETAIL_MALLOC_ALIGNED_HPP_INCLUDED_
+
+#include <cstddef>
+#include <cstdlib>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/log/detail/config.hpp>
+
+// MSVC has its own _aligned_malloc and _aligned_free functions.
+// But MinGW doesn't declare these aligned memory allocation routines for MSVC 6 runtime.
+#if defined(BOOST_WINDOWS) && !(defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0700)
+#include <malloc.h>
+#define BOOST_LOG_HAS_MSVC_ALIGNED_MALLOC 1
+#endif
+
+#if defined(BOOST_HAS_UNISTD_H)
+#include <unistd.h> // _POSIX_VERSION
+#endif
+
+#if defined(__APPLE__) || defined(__APPLE_CC__) || defined(macintosh)
+#include <AvailabilityMacros.h>
+#if defined(MAC_OS_X_VERSION_MIN_REQUIRED) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1060)
+// Mac OS X 10.6 and later have posix_memalign
+#define BOOST_LOG_HAS_POSIX_MEMALIGN 1
+#endif
+#elif defined(__ANDROID__)
+// Android NDK (up to release 8e, at least) doesn't have posix_memalign despite it defines POSIX macros as if it does.
+// But we can use memalign() with free() on this platform.
+#include <malloc.h>
+#define BOOST_LOG_HAS_FREEABLE_MEMALIGN 1
+#elif (defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200112L)) || (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600))
+// Solaris 10 does not have posix_memalign. Solaris 11 and later seem to have it.
+#if !(defined(sun) || defined(__sun)) || defined(__SunOS_5_11) || defined(__SunOS_5_12)
+#define BOOST_LOG_HAS_POSIX_MEMALIGN 1
+#endif
+#endif
+
+#include <boost/log/detail/header.hpp>
+
+#ifdef BOOST_LOG_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifndef BOOST_LOG_CPU_CACHE_LINE_SIZE
+//! The macro defines the CPU cache line size for the target architecture. This is mostly used for optimization.
+#define BOOST_LOG_CPU_CACHE_LINE_SIZE 64
+#endif
+
+namespace boost {
+
+BOOST_LOG_OPEN_NAMESPACE
+
+namespace aux {
+
+/*!
+ * Allocates uninitialized aligned memory. Memory alignment must be a power of 2 and a multiple of sizeof(void*).
+ * The implementation may impose an upper bound of the alignment as well.
+ */
+inline void* malloc_aligned(std::size_t size, uint32_t alignment)
+{
+#if defined(BOOST_LOG_HAS_POSIX_MEMALIGN)
+ void* p = NULL;
+ if (posix_memalign(&p, alignment, size) != 0)
+ return NULL;
+ return p;
+#elif defined(BOOST_LOG_HAS_FREEABLE_MEMALIGN)
+ return memalign(alignment, size);
+#elif defined(BOOST_LOG_HAS_MSVC_ALIGNED_MALLOC)
+ return _aligned_malloc(size, alignment);
+#else
+ BOOST_ASSERT(alignment >= sizeof(void*));
+ void* p = std::malloc(size + alignment);
+ if (p)
+ {
+ unsigned char* q = static_cast< unsigned char* >(p) + alignment;
+#if defined(BOOST_HAS_INTPTR_T)
+ q = (unsigned char*)((uintptr_t)q & (~(uintptr_t)(alignment - 1u)));
+#else
+ q -= ((std::size_t)q & (std::size_t)(alignment - 1u));
+#endif
+ // Here we assume that the system allocator aligns to 4 bytes at the very least.
+ // Therefore we will always have at least 4 bytes before the aligned pointer.
+ const uint32_t diff = q - static_cast< unsigned char* >(p);
+ p = q;
+ *reinterpret_cast< uint32_t* >(q - 4u) = diff;
+ }
+ return p;
+#endif
+}
+
+/*!
+ * Frees memory allocated with \c malloc_aligned.
+ */
+inline void free_aligned(void* p)
+{
+#if defined(BOOST_LOG_HAS_POSIX_MEMALIGN) || defined(BOOST_LOG_HAS_FREEABLE_MEMALIGN)
+ free(p);
+#elif defined(BOOST_LOG_HAS_MSVC_ALIGNED_MALLOC)
+ _aligned_free(p);
+#else
+ if (p)
+ {
+ unsigned char* const q = static_cast< unsigned char* >(p);
+ const uint32_t diff = *reinterpret_cast< uint32_t* >(q - 4u);
+ std::free(q - diff);
+ }
+#endif
+}
+
+} // namespace aux
+
+BOOST_LOG_CLOSE_NAMESPACE // namespace log
+
+} // namespace boost
+
+#include <boost/log/detail/footer.hpp>
+
+#endif // BOOST_LOG_DETAIL_MALLOC_ALIGNED_HPP_INCLUDED_
Modified: trunk/libs/log/src/light_rw_mutex.cpp
==============================================================================
--- trunk/libs/log/src/light_rw_mutex.cpp Fri Jul 12 14:28:17 2013 (r85019)
+++ trunk/libs/log/src/light_rw_mutex.cpp 2013-07-12 16:24:42 EDT (Fri, 12 Jul 2013) (r85020)
@@ -25,20 +25,13 @@
#include <boost/assert.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <boost/log/utility/once_block.hpp>
+#include <boost/log/detail/malloc_aligned.hpp>
#include "windows_version.hpp"
#include <windows.h>
-#include <malloc.h>
#include <boost/log/detail/header.hpp>
-#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0700
-// MinGW doesn't declare aligned memory allocation routines for MSVC 6 runtime
-inline void* _aligned_malloc(size_t size, size_t) { return malloc(size); }
-inline void _aligned_free(void* p) { free(p); }
-#endif
-
-
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
@@ -67,17 +60,15 @@
// To avoid cache line aliasing we do aligned memory allocation here
enum
{
- // Cache line size on x86
- cache_line_size = 64,
// Allocation size is the minimum number of cache lines to accommodate shared_mutex
size =
(
- sizeof(shared_mutex) / cache_line_size
- + ((sizeof(shared_mutex) % cache_line_size) != 0)
+ sizeof(shared_mutex) / BOOST_LOG_CPU_CACHE_LINE_SIZE
+ + ((sizeof(shared_mutex) % BOOST_LOG_CPU_CACHE_LINE_SIZE) != 0)
)
- * cache_line_size
+ * BOOST_LOG_CPU_CACHE_LINE_SIZE
};
- mtx->p = _aligned_malloc(size, cache_line_size);
+ mtx->p = malloc_aligned(size, BOOST_LOG_CPU_CACHE_LINE_SIZE);
BOOST_ASSERT(mtx->p != NULL);
new (mtx->p) shared_mutex();
}
@@ -85,7 +76,7 @@
void __stdcall DeinitializeSharedMutex(mutex_impl* mtx)
{
static_cast< shared_mutex* >(mtx->p)->~shared_mutex();
- _aligned_free(mtx->p);
+ free_aligned(mtx->p);
mtx->p = NULL;
}
Modified: trunk/libs/log/src/threadsafe_queue.cpp
==============================================================================
--- trunk/libs/log/src/threadsafe_queue.cpp Fri Jul 12 14:28:17 2013 (r85019)
+++ trunk/libs/log/src/threadsafe_queue.cpp 2013-07-12 16:24:42 EDT (Fri, 12 Jul 2013) (r85020)
@@ -25,44 +25,14 @@
#ifndef BOOST_LOG_NO_THREADS
-#include <stdlib.h>
#include <new>
#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
#include <boost/throw_exception.hpp>
#include <boost/type_traits/alignment_of.hpp>
#include <boost/log/detail/spin_mutex.hpp>
#include <boost/log/detail/locks.hpp>
#include <boost/log/detail/alignas.hpp>
-
-#if defined(BOOST_HAS_UNISTD_H)
-#include <unistd.h> // _POSIX_VERSION
-#endif
-
-#if defined(BOOST_HAS_STDINT_H)
-#include <stdint.h> // uintptr_t
-#else
-// MSVC defines integer types here
-#include <stddef.h> // uintptr_t
-#endif
-
-#if defined(__APPLE__) || defined(__APPLE_CC__) || defined(macintosh)
-#include <AvailabilityMacros.h>
-#if defined(MAC_OS_X_VERSION_MIN_REQUIRED) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1060)
-// Mac OS X 10.6 and later have posix_memalign
-#define BOOST_LOG_HAS_POSIX_MEMALIGN 1
-#endif
-#elif (defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200112L)) || (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600))
-// Solaris 10 does not have posix_memalign. Solaris 11 and later seem to have it.
-#if !(defined(sun) || defined(__sun)) || defined(__SunOS_5_11) || defined(__SunOS_5_12)
-#define BOOST_LOG_HAS_POSIX_MEMALIGN 1
-#endif
-#endif
-
-#if defined(BOOST_WINDOWS)
-#include <malloc.h> // _aligned_malloc, _aligned_free
-#endif
-
+#include <boost/log/detail/malloc_aligned.hpp>
#include <boost/log/detail/header.hpp>
namespace boost {
@@ -81,9 +51,9 @@
/*!
* A structure that contains a pointer to the node and the associated mutex.
- * The alignment below allows to eliminate false sharing, it should be not less than CPU cache line size (which is assumed to be 64 bytes in most cases).
+ * The alignment below allows to eliminate false sharing, it should not be less than CPU cache line size.
*/
- struct BOOST_LOG_ALIGNAS(64) pointer
+ struct BOOST_LOG_ALIGNAS(BOOST_LOG_CPU_CACHE_LINE_SIZE) pointer
{
//! Pointer to the either end of the queue
node_base* node;
@@ -168,41 +138,15 @@
BOOST_LOG_API void* threadsafe_queue_impl::operator new (std::size_t size)
{
- void* p = NULL;
-
-#if defined(BOOST_LOG_HAS_POSIX_MEMALIGN)
- if (posix_memalign(&p, 64, size) || !p)
- BOOST_THROW_EXCEPTION(std::bad_alloc());
- return p;
-#elif defined(BOOST_WINDOWS)
- p = _aligned_malloc(size, 64);
- if (!p)
- BOOST_THROW_EXCEPTION(std::bad_alloc());
-#else
- p = malloc(size + 64);
+ void* p = malloc_aligned(size, BOOST_LOG_CPU_CACHE_LINE_SIZE);
if (!p)
BOOST_THROW_EXCEPTION(std::bad_alloc());
- unsigned char* q = static_cast< unsigned char* >(p) + 64;
- q = (unsigned char*)((uintptr_t)q & (~(uintptr_t)63));
- const unsigned char diff = q - static_cast< unsigned char* >(p);
- p = q;
- *--q = diff;
-#endif
-
return p;
}
BOOST_LOG_API void threadsafe_queue_impl::operator delete (void* p, std::size_t)
{
-#if defined(BOOST_LOG_HAS_POSIX_MEMALIGN)
- free(p);
-#elif defined(BOOST_WINDOWS)
- _aligned_free(p);
-#else
- unsigned char* q = static_cast< unsigned char* >(p);
- const unsigned char diff = *--q;
- free(static_cast< unsigned char* >(p) - diff);
-#endif
+ free_aligned(p);
}
} // namespace aux