[counting-allocator] macOS buildtools/third_party/libc++/trunk/ changes.

src/memory.cpp

 //===------------------------ memory.cpp ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_MEMORY
+#include "cassert"
 #include "memory"
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include "mutex"
 #include "thread"
 #endif
 #include "include/atomic_support.h"
 
+#if defined(__APPLE__)
+#include <malloc/malloc.h>
+#elif defined(ANDROID)
+extern "C" size_t dlmalloc_usable_size(const void*) __attribute__((weak));
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace
 {
 
 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
 // should be sufficient for thread safety.
 // See https://llvm.org/bugs/show_bug.cgi?id=22803
 template <class T>
 inline T
@@ skipping 190 matching lines @@
         if (d <= space - size)
         {
             r = p2;
             ptr = r;
             space -= d;
         }
     }
     return r;
 }
 
+// allocation_counter
+
+namespace
+{
+
+struct lockable_counter {
+    pthread_mutex_t lock;
+    allocation_counter::value value;
+};
+
+lockable_counter lockable_counters[] =
+{
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+    {PTHREAD_MUTEX_INITIALIZER},
+};
+constexpr size_t lockable_counters_size = sizeof(lockable_counters) / sizeof(*lockable_counters);
+static_assert(lockable_counters_size == allocation_group_count, "bad number of allocation counters");
+
+lockable_counter& counter_for_group(allocation_group group)
+{
+    return lockable_counters[static_cast<int>(group)];
+}
+
+size_t get_usable_size(const void* ptr) {
+#if defined(__APPLE__)
+    return malloc_size(ptr);
+#elif defined(ANDROID)
+    return dlmalloc_usable_size(ptr);
+#else
+    #error Unsupported platform!
+#endif
+}
+
+}  // namespace
+
+const char* get_allocation_group_name(allocation_group group)
+{
+    switch (group)
+    {
+        case allocation_group::allocator: return "std::allocator";
+        case allocation_group::deque: return "std::deque";
+        case allocation_group::list: return "std::list";
+        case allocation_group::map: return "std::map";
+        case allocation_group::multimap: return "std::multimap";
+        case allocation_group::multiset: return "std::multiset";
+        case allocation_group::set: return "std::set";
+        case allocation_group::shared_ptr: return "std::shared_ptr";
+        case allocation_group::string: return "std::string";
+        case allocation_group::unordered_map: return "std::unordered_map";
+        case allocation_group::unordered_multimap: return "std::unordered_multimap";
+        case allocation_group::unordered_multiset: return "std::unordered_multiset";
+        case allocation_group::unordered_set: return "std::unordered_set";
+        case allocation_group::vector: return "std::vector";
+        case allocation_group::vector_bool: return "std::vector<bool>";
+
+        case allocation_group::group_count: break;
+    }
+    return nullptr;
+}
+
+allocation_counter::value allocation_counter::get(allocation_group group)
+{
+    value result;
+    auto& counter = counter_for_group(group);
+    pthread_mutex_lock(&counter.lock);
+    {
+        result = counter.value;
+    }
+    pthread_mutex_unlock(&counter.lock);
+    return result;
+}
+
+void allocation_counter::allocated(allocation_group group, const void* ptr, size_t size, size_t payload_size)
+{
+    if (!ptr) {
+        return;
+    }
+    size_t usable_size = get_usable_size(ptr);
+    assert(usable_size >= size);
+    auto& counter = counter_for_group(group);
+    pthread_mutex_lock(&counter.lock);
+    {
+        counter.value.total_usable_size += usable_size;
+        counter.value.total_size += size;
+        counter.value.total_count += 1;
+        counter.value.total_payload_size += payload_size;
+    }
+    pthread_mutex_unlock(&counter.lock);
+}
+
+void allocation_counter::deallocated(allocation_group group, const void* ptr, size_t size, size_t payload_size)
+{
+    size_t usable_size = get_usable_size(ptr);
+    assert(usable_size >= size);
+    auto& counter = counter_for_group(group);
+    pthread_mutex_lock(&counter.lock);
+    {
+        assert(counter.value.total_usable_size >= usable_size &&
+               counter.value.total_size >= size &&
+               counter.value.total_count >= 1 &&
+               counter.value.total_payload_size >= payload_size);
+        counter.value.total_usable_size -= usable_size;
+        counter.value.total_size -= size;
+        counter.value.total_count -= 1;
+        counter.value.total_payload_size -= payload_size;
+        assert(counter.value.total_constructed_size <= counter.value.total_size);
+    }
+    pthread_mutex_unlock(&counter.lock);
+}
+
+void allocation_counter::constructed(allocation_group group, size_t size) {
+    auto& counter = counter_for_group(group);
+    pthread_mutex_lock(&counter.lock);
+    {
+        counter.value.total_constructed_size += size;
+        assert(counter.value.total_constructed_size <= counter.value.total_size);
+    }
+    pthread_mutex_unlock(&counter.lock);
+}
+
+void allocation_counter::destroyed(allocation_group group, size_t size) {
+    auto& counter = counter_for_group(group);
+    pthread_mutex_lock(&counter.lock);
+    {
+        assert(size <= counter.value.total_constructed_size);
+        counter.value.total_constructed_size -= size;
+    }
+    pthread_mutex_unlock(&counter.lock);
+}
+
 _LIBCPP_END_NAMESPACE_STD