* Clean up constructor template auto deduction guides to use Boost.Container traits

* GitHub #73: '"triviality of pair".

* Fixed race condition bug in unsynchronized_pool_resource

doc/container.qbk

@@ -1247,12 +1247,17 @@ use [*Boost.Container]? There are several reasons for that:
 
 * Implemented C++14's heterogeneous lookup functions for `[multi]map/[multi]set/flat_[multi]map/flat_[multi]set`.
 
+* Added [@https://github.com/boostorg/container/pull/71 GitHub #71: ['"Constructor Template Auto Deduction guides "]].
+
 * Fixed bugs:
    * [@https://svn.boost.org/trac/boost/ticket/13533 Trac #13533:  ['"Boost vector resize causes assert(false)"]].
+   * [@https://github.com/boostorg/container/issues/73 GitHub #73: ['"triviality of pair"]].
+   * Fixed race condition bug in [classref boost::container::pmr::unsynchronized_pool_resource unsynchronized_pool_resource]
+     found by Arthur O'Dowyer in his blog post
+     [@https://quuxplusone.github.io/blog/2018/06/05/libcpp-memory-resource/ <memory_resource> for libc++]
 
 [endsect]
 
-
 [section:release_notes_boost_1_67_00 Boost 1.67 Release]
 
 * ['vector] can now have options, using [classref boost::container::vector_options vector_options].

include/boost/container/deque.hpp

@@ -2240,9 +2240,9 @@ class deque : protected deque_base<Allocator>
 
 #if __cplusplus >= 201703L
 template <typename InputIterator>
-deque(InputIterator, InputIterator) -> deque<typename std::iterator_traits<InputIterator>::value_type>;
+deque(InputIterator, InputIterator) -> deque<typename iterator_traits<InputIterator>::value_type>;
 template <typename InputIterator, typename Allocator>
-deque(InputIterator, InputIterator, Allocator const&) -> deque<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+deque(InputIterator, InputIterator, Allocator const&) -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 #endif
 
 }}

include/boost/container/detail/pair.hpp

@@ -550,6 +550,14 @@ struct is_class< std::pair<T1, T2> >
    static const bool value = true;
 };
 
+template<class A, class B>
+struct is_trivially_copy_assignable
+   <boost::container::dtl::pair<A,B> >
+{
+   static const bool value = boost::move_detail::is_trivially_copy_assignable<A>::value &&
+                             boost::move_detail::is_trivially_copy_assignable<B>::value ;
+};
+
 }  //namespace move_detail{
 
 }  //namespace boost {

include/boost/container/detail/thread_mutex.hpp

@@ -0,0 +1,179 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2018-2018. 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)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+//
+// This code is partially based on the lightweight mutex implemented
+// by Boost.SmartPtr:
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) Microsoft Corporation 2014
+//
+// 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)
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#ifndef BOOST_CONTAINER_DETAIL_THREAD_MUTEX_HPP
+#define BOOST_CONTAINER_DETAIL_THREAD_MUTEX_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <pthread.h>
+#include <boost/assert.hpp>
+
+namespace boost{
+namespace container {
+namespace dtl {
+
+class thread_mutex
+{
+   public:
+   thread_mutex()
+   {
+      BOOST_VERIFY(pthread_mutex_init(&m_mut, 0) == 0);
+   }
+
+   ~thread_mutex()
+   {
+     BOOST_VERIFY(pthread_mutex_destroy(&m_mut) == 0);
+   }
+
+   void lock()
+   {
+      BOOST_VERIFY(pthread_mutex_lock( &m_mut) == 0);
+   }
+
+   void unlock()
+   {
+      BOOST_VERIFY(pthread_mutex_unlock(&m_mut) == 0);
+   }
+
+   private:
+   thread_mutex(thread_mutex const &);
+   thread_mutex & operator=(thread_mutex const &);
+   
+   pthread_mutex_t m_mut;
+};
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#else //!BOOST_HAS_PTHREADS (Windows implementation)
+
+#ifdef BOOST_USE_WINDOWS_H
+
+#include <windows.h>
+
+namespace boost{
+namespace container {
+namespace dtl {
+
+typedef ::CRITICAL_SECTION win_critical_section;
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#else //! BOOST_USE_WINDOWS_H
+
+struct _RTL_CRITICAL_SECTION_DEBUG;
+struct _RTL_CRITICAL_SECTION;
+   
+namespace boost{
+namespace container {
+namespace dtl {
+
+#ifdef BOOST_PLAT_WINDOWS_UWP
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
+#else
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_CRITICAL_SECTION *);
+#endif
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(::_RTL_CRITICAL_SECTION *);
+
+struct win_critical_section
+{
+   struct _RTL_CRITICAL_SECTION_DEBUG * DebugInfo;
+   long LockCount;
+   long RecursionCount;
+   void * OwningThread;
+   void * LockSemaphore;
+   #if defined(_WIN64)
+   unsigned __int64 SpinCount;
+   #else
+   unsigned long SpinCount;
+   #endif
+};
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#endif   //BOOST_USE_WINDOWS_H
+
+namespace boost{
+namespace container {
+namespace dtl {
+
+class thread_mutex
+{
+   public:
+   thread_mutex()
+   {
+      #ifdef BOOST_PLAT_WINDOWS_UWP
+      InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect), 4000, 0);
+      #else
+      InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+      #endif
+   }
+
+   void lock()
+   {
+      EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+   }
+
+   void unlock()
+   {
+      LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+   }
+
+   ~thread_mutex()
+   {
+      DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+   }
+  
+   private:
+   thread_mutex(thread_mutex const &);
+   thread_mutex & operator=(thread_mutex const &);
+   
+   win_critical_section m_crit_sect;
+};
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#endif   //BOOST_HAS_PTHREADS
+
+#endif // #ifndef BOOST_CONTAINER_DETAIL_THREAD_MUTEX_HPP

include/boost/container/flat_map.hpp

@@ -1546,22 +1546,57 @@ class flat_map
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_map(InputIterator, InputIterator) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_map(InputIterator, InputIterator) ->
+   flat_map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_map(InputIterator, InputIterator, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_map(InputIterator, InputIterator, Allocator const&) ->
+   flat_map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_map(InputIterator, InputIterator, Compare const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_map(InputIterator, InputIterator, Compare const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_map(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_map(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -2776,22 +2811,57 @@ class flat_multimap
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_multimap(InputIterator, InputIterator) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_multimap(InputIterator, InputIterator) ->
+   flat_multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multimap(InputIterator, InputIterator, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_multimap(InputIterator, InputIterator, Allocator const&) ->
+   flat_multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type
+                        , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+                        , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multimap(InputIterator, InputIterator, Compare const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_multimap(InputIterator, InputIterator, Compare const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multimap(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_multimap(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-flat_multimap(ordered_range_t, InputIterator, InputIterator) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 }}

include/boost/container/flat_set.hpp

@@ -1092,22 +1092,39 @@ class flat_set
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_set(InputIterator, InputIterator) -> flat_set<typename std::iterator_traits<InputIterator>::value_type>;
+flat_set(InputIterator, InputIterator) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_set(InputIterator, InputIterator, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_set(InputIterator, InputIterator, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_set(InputIterator, InputIterator, Compare const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_set(InputIterator, InputIterator, Compare const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator) -> flat_set<typename std::iterator_traits<InputIterator>::value_type>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1765,22 +1782,43 @@ class flat_multiset
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_multiset(InputIterator, InputIterator) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type>;
+flat_multiset(InputIterator, InputIterator) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multiset(InputIterator, InputIterator, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_multiset(InputIterator, InputIterator, Allocator const&) ->
+   flat_multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multiset(InputIterator, InputIterator, Compare const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_multiset(InputIterator, InputIterator, Compare const&) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-flat_multiset(ordered_range_t, InputIterator, InputIterator) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_multiset< typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/list.hpp

@@ -1466,9 +1466,12 @@ class list
 
 #if __cplusplus >= 201703L
 template <typename InputIterator>
-list(InputIterator, InputIterator) -> list<typename std::iterator_traits<InputIterator>::value_type>;
+list(InputIterator, InputIterator) ->
+   list<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-list(InputIterator, InputIterator, Allocator const&) -> list<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+list(InputIterator, InputIterator, Allocator const&) ->
+   list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/map.hpp

@@ -1264,22 +1264,57 @@ class map
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-map(InputIterator, InputIterator) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+map(InputIterator, InputIterator) ->
+   map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-map(InputIterator, InputIterator, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+map(InputIterator, InputIterator, Allocator const&) ->
+   map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-map(InputIterator, InputIterator, Compare const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+map(InputIterator, InputIterator, Compare const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-map(InputIterator, InputIterator, Compare const&, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+map(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-map(ordered_unique_range_t, InputIterator, InputIterator) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+map(ordered_unique_range_t, InputIterator, InputIterator) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 
@@ -2118,22 +2153,57 @@ class multimap
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-multimap(InputIterator, InputIterator) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+multimap(InputIterator, InputIterator) ->
+   multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-multimap(InputIterator, InputIterator, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+multimap(InputIterator, InputIterator, Allocator const&) ->
+   multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type
+                        , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+                        , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multimap(InputIterator, InputIterator, Compare const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+multimap(InputIterator, InputIterator, Compare const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multimap(InputIterator, InputIterator, Compare const&, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+multimap(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-multimap(ordered_range_t, InputIterator, InputIterator) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+multimap(ordered_range_t, InputIterator, InputIterator) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/pmr/synchronized_pool_resource.hpp

@@ -20,6 +20,7 @@
 #include <boost/container/detail/auto_link.hpp>
 #include <boost/container/pmr/memory_resource.hpp>
 #include <boost/container/detail/pool_resource.hpp>
+#include <boost/container/detail/thread_mutex.hpp>
 
 #include <cstddef>
 
@@ -60,8 +61,8 @@ namespace pmr {
 class BOOST_CONTAINER_DECL synchronized_pool_resource
    : public memory_resource
 {
+   dtl::thread_mutex m_mut;
    pool_resource     m_pool_resource;
-   void *m_opaque_sync;
 
    public:
 

include/boost/container/set.hpp

@@ -935,22 +935,39 @@ class set
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-set(InputIterator, InputIterator) -> set<typename std::iterator_traits<InputIterator>::value_type>;
+set(InputIterator, InputIterator) ->
+   set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-set(InputIterator, InputIterator, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+set(InputIterator, InputIterator, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-set(InputIterator, InputIterator, Compare const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+set(InputIterator, InputIterator, Compare const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-set(InputIterator, InputIterator, Compare const&, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-set(ordered_unique_range_t, InputIterator, InputIterator) -> set<typename std::iterator_traits<InputIterator>::value_type>;
+set(ordered_unique_range_t, InputIterator, InputIterator) ->
+   set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1540,22 +1557,43 @@ class multiset
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-multiset(InputIterator, InputIterator) -> multiset<typename std::iterator_traits<InputIterator>::value_type>;
+multiset(InputIterator, InputIterator) ->
+   multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-multiset(InputIterator, InputIterator, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+multiset(InputIterator, InputIterator, Allocator const&) ->
+   multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multiset(InputIterator, InputIterator, Compare const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+multiset(InputIterator, InputIterator, Compare const&) ->
+   multiset<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multiset(InputIterator, InputIterator, Compare const&, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-multiset(ordered_range_t, InputIterator, InputIterator) -> multiset<typename std::iterator_traits<InputIterator>::value_type>;
+multiset(ordered_range_t, InputIterator, InputIterator) ->
+   multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   multiset< typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/slist.hpp

@@ -1633,10 +1633,15 @@ class slist
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InpIt>
-slist(InpIt, InpIt) -> slist<typename std::iterator_traits<InpIt>::value_type>;
+slist(InpIt, InpIt) ->
+   slist<typename iterator_traits<InpIt>::value_type>;
+
 template <typename InpIt, typename Allocator>
-slist(InpIt, InpIt, Allocator const&) -> slist<typename std::iterator_traits<InpIt>::value_type, Allocator>;
+slist(InpIt, InpIt, Allocator const&) ->
+   slist<typename iterator_traits<InpIt>::value_type, Allocator>;
+
 #endif
 
 }}

include/boost/container/stable_vector.hpp

@@ -2086,10 +2086,15 @@ class stable_vector
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-stable_vector(InputIterator, InputIterator) -> stable_vector<typename std::iterator_traits<InputIterator>::value_type>;
+stable_vector(InputIterator, InputIterator) ->
+   stable_vector<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-stable_vector(InputIterator, InputIterator, Allocator const&) -> stable_vector<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+stable_vector(InputIterator, InputIterator, Allocator const&) ->
+   stable_vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/string.hpp

@@ -2934,10 +2934,15 @@ class basic_string
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-basic_string(InputIterator, InputIterator) -> basic_string<typename std::iterator_traits<InputIterator>::value_type>;
+basic_string(InputIterator, InputIterator) ->
+   basic_string<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-basic_string(InputIterator, InputIterator, Allocator const&) -> basic_string<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+basic_string(InputIterator, InputIterator, Allocator const&) ->
+   basic_string<typename iterator_traits<InputIterator>::value_type, Allocator>;
+
 #endif
 
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/vector.hpp

@@ -3365,10 +3365,15 @@ class vector
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-vector(InputIterator, InputIterator) -> vector<typename std::iterator_traits<InputIterator>::value_type>;
+vector(InputIterator, InputIterator) ->
+   vector<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-vector(InputIterator, InputIterator, Allocator const&) -> vector<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+vector(InputIterator, InputIterator, Allocator const&) ->
+   vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
+
 #endif
 
 

proj/vc7ide/container.vcproj

@@ -314,6 +314,9 @@
 				<File
 					RelativePath="..\..\..\..\boost\container\detail\std_fwd.hpp">
 				</File>
+				<File
+					RelativePath="..\..\..\..\boost\container\detail\thread_mutex.hpp">
+				</File>
 				<File
 					RelativePath="..\to-do.txt">
 				</File>

src/synchronized_pool_resource.cpp

@@ -11,31 +11,29 @@
 #define BOOST_CONTAINER_SOURCE
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
-#include <boost/container/detail/dlmalloc.hpp>
+#include <boost/container/detail/thread_mutex.hpp>
 
 #include <boost/container/pmr/synchronized_pool_resource.hpp>
 #include <cstddef>
 
 namespace {
 
-using namespace boost::container;
+using namespace boost::container::dtl;
 
-class dlmalloc_sync_scoped_lock
+class thread_mutex_lock
 {
-   void *m_sync;
+   thread_mutex &m_mut;
 
    public:
-   explicit dlmalloc_sync_scoped_lock(void *sync)
+   explicit thread_mutex_lock(thread_mutex &m)
-      : m_sync(sync)
+      : m_mut(m)
    {
-      if(!dlmalloc_sync_lock(m_sync)){
+      m_mut.lock();
-         throw_bad_alloc();
-      }
    }
 
-   ~dlmalloc_sync_scoped_lock()
+   ~thread_mutex_lock()
    {
-      dlmalloc_sync_unlock(m_sync);
+      m_mut.unlock();
    }
 };
 
@@ -46,32 +44,28 @@ namespace container {
 namespace pmr {
 
 synchronized_pool_resource::synchronized_pool_resource(const pool_options& opts, memory_resource* upstream) BOOST_NOEXCEPT
-   : m_pool_resource(opts, upstream), m_opaque_sync()
+   : m_mut(), m_pool_resource(opts, upstream)
 {}
 
 synchronized_pool_resource::synchronized_pool_resource() BOOST_NOEXCEPT
-   : m_pool_resource(), m_opaque_sync()
+   : m_mut(), m_pool_resource()
 {}
 
 synchronized_pool_resource::synchronized_pool_resource(memory_resource* upstream) BOOST_NOEXCEPT
-   : m_pool_resource(upstream), m_opaque_sync()
+   : m_mut(), m_pool_resource(upstream)
 {}
 
 synchronized_pool_resource::synchronized_pool_resource(const pool_options& opts) BOOST_NOEXCEPT
-   : m_pool_resource(opts), m_opaque_sync()
+   : m_mut(), m_pool_resource(opts)
 {}
 
 synchronized_pool_resource::~synchronized_pool_resource() //virtual
-{
+{}
-   if(m_opaque_sync)
-      dlmalloc_sync_destroy(m_opaque_sync);
-}
 
 void synchronized_pool_resource::release()
 {
-   if(m_opaque_sync){   //If there is no mutex, no allocation could be done
+   thread_mutex_lock lck(m_mut); (void)lck;
    m_pool_resource.release();
-   }
 }
 
 memory_resource* synchronized_pool_resource::upstream_resource() const
@@ -82,19 +76,13 @@ pool_options synchronized_pool_resource::options() const
 
 void* synchronized_pool_resource::do_allocate(std::size_t bytes, std::size_t alignment) //virtual
 {
-   if(!m_opaque_sync){   //If there is no mutex, no allocation could be done
+   thread_mutex_lock lck(m_mut); (void)lck;
-      m_opaque_sync = dlmalloc_sync_create();
-      if(!m_opaque_sync){
-         throw_bad_alloc();
-      }
-   }
-   dlmalloc_sync_scoped_lock lock(m_opaque_sync); (void)lock;
    return m_pool_resource.do_allocate(bytes, alignment);
 }
 
 void synchronized_pool_resource::do_deallocate(void* p, std::size_t bytes, std::size_t alignment) //virtual
 {
-   dlmalloc_sync_scoped_lock lock(m_opaque_sync); (void)lock;
+   thread_mutex_lock lck(m_mut); (void)lck;
    return m_pool_resource.do_deallocate(p, bytes, alignment);
 }