remove cout

Author: bratpiorka

src/pool/pool_disjoint.c

@@ -36,15 +36,15 @@ static size_t CutOff = (size_t)1 << 31; // 2GB
 #define POISON_MEMORY 0
 #endif
 
-/*static */ void annotate_memory_inaccessible(void *ptr, size_t size) {
+static void annotate_memory_inaccessible(void *ptr, size_t size) {
     (void)ptr;
     (void)size;
 #if (POISON_MEMORY != 0)
     utils_annotate_memory_inaccessible(ptr, size);
 #endif
 }
 
-/*static*/ void annotate_memory_undefined(void *ptr, size_t size) {
+static void annotate_memory_undefined(void *ptr, size_t size) {
     (void)ptr;
     (void)size;
 #if (POISON_MEMORY != 0)
@@ -124,8 +124,9 @@ void destroy_slab(slab_t *slab) {
     umf_ba_global_free(slab);
 }
 
-// return the index of the first available chunk, SIZE_MAX otherwise
 size_t slab_find_first_available_chunk_idx(const slab_t *slab) {
+    // return the index of the first available chunk, SIZE_MAX otherwise
+
     // use the first free chunk index as a hint for the search
     bool *chunk = slab->chunks + sizeof(bool) * slab->first_free_chunk_idx;
     while (chunk != slab->chunks + sizeof(bool) * slab->num_chunks) {
@@ -143,8 +144,6 @@ size_t slab_find_first_available_chunk_idx(const slab_t *slab) {
 }
 
 void *slab_get_chunk(slab_t *slab) {
-    // assert(slab->num_allocated != slab->num_chunks);
-
     // free chunk must exist, otherwise we would have allocated another slab
     const size_t chunk_idx = slab_find_first_available_chunk_idx(slab);
     assert(chunk_idx != SIZE_MAX);
@@ -168,7 +167,7 @@ void *slab_get_end(const slab_t *slab) {
 }
 
 void slab_free_chunk(slab_t *slab, void *ptr) {
-    // This method should be called through bucket(since we might remove the
+    // This method should be called through bucket (since we might remove the
     // slab as a result), therefore all locks are done on that level.
 
     // Make sure that we're in the right slab
@@ -256,7 +255,6 @@ create_bucket(size_t sz, disjoint_pool_t *pool,
     bucket->shared_limits = shared_limits;
 
     utils_mutex_init(&bucket->bucket_lock);
-
     return bucket;
 }
 
@@ -463,9 +461,9 @@ void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool) {
         in_pool * bucket_slab_alloc_size(bucket);
 }
 
-// If a slab was available in the pool then note that the current pooled
-// size has reduced by the size of a slab in this bucket.
 void bucket_decrement_pool(bucket_t *bucket, bool *from_pool) {
+    // If a slab was available in the pool then note that the current pooled
+    // size has reduced by the size of a slab in this bucket.
     *from_pool = true;
     bucket_update_stats(bucket, 1, -1);
     utils_fetch_and_add64(&bucket->shared_limits->total_size,
@@ -570,7 +568,6 @@ void slab_unreg_by_addr(void *addr, slab_t *slab) {
     utils_mutex_unlock(lock);
 }
 
-//TODO add static
 static size_t size_to_idx(disjoint_pool_t *pool, size_t size) {
     assert(size <= CutOff && "Unexpected size");
     assert(size > 0 && "Unexpected size");
@@ -622,20 +619,32 @@ bucket_t *disjoint_pool_find_bucket(disjoint_pool_t *pool, size_t size) {
     return pool->buckets[calculated_idx];
 }
 
-// TODO
+void bucket_print_stats(bucket_t *bucket, bool *title_printed,
+                        const char *label) {
+    if (bucket->alloc_count) {
+        if (!*title_printed) {
+            LOG_DEBUG("%s memory statistics", label);
+            LOG_DEBUG("%14s %12s %12s %18s %20s %21s", "Bucket Size", "Allocs",
+                      "Frees", "Allocs from Pool", "Peak Slabs in Use",
+                      "Peak Slabs in Pool");
+            *title_printed = true;
+        }
+        LOG_DEBUG("%14zu %12zu %12zu %18zu %20zu %21zu", bucket->size,
+                  bucket->alloc_count, bucket->free_count,
+                  bucket->alloc_pool_count, bucket->max_slabs_in_use,
+                  bucket->max_slabs_in_pool);
+    }
+}
+
 void disjoint_pool_print_stats(disjoint_pool_t *pool, bool *title_printed,
                                size_t *high_bucket_size,
                                size_t *high_peak_slabs_in_use,
                                const char *mt_name) {
-    (void)title_printed; // TODO
-    (void)mt_name;       // TODO
-
     *high_bucket_size = 0;
     *high_peak_slabs_in_use = 0;
     for (size_t i = 0; i < pool->buckets_num; i++) {
-        // TODO
-        //(*B).disjoint_pool_print_stats(title_printed, mt_name);
         bucket_t *bucket = pool->buckets[i];
+        bucket_print_stats(bucket, title_printed, mt_name);
         *high_peak_slabs_in_use =
             utils_max(bucket->max_slabs_in_use, *high_peak_slabs_in_use);
         if (bucket->alloc_count) {
@@ -699,27 +708,6 @@ std::ostream &operator<<(std::ostream &Os, slab_t &Slab) {
 }
 */
 
-/*
-// TODO move
-void Bucket::printStats(bool &TitlePrinted, const std::string &Label) {
-    if (alloc_count) {
-        if (!TitlePrinted) {
-            std::cout << Label << " memory statistics\n";
-            std::cout << std::setw(14) << "Bucket Size" << std::setw(12)
-                      << "Allocs" << std::setw(12) << "Frees" << std::setw(18)
-                      << "Allocs from Pool" << std::setw(20)
-                      << "Peak Slabs in Use" << std::setw(21)
-                      << "Peak Slabs in Pool" << std::endl;
-            TitlePrinted = true;
-        }
-        std::cout << std::setw(14) << getSize() << std::setw(12) << alloc_count
-                  << std::setw(12) << free_count << std::setw(18)
-                  << allocPoolCount << std::setw(20) << max_slabs_in_use
-                  << std::setw(21) << max_slabs_in_pool << std::endl;
-    }
-}
-*/
-
 umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
                                       void *params, void **ppPool) {
     if (!provider) {
@@ -800,20 +788,15 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
 }
 
 void *disjoint_pool_malloc(void *pool, size_t size) {
-    // For full-slab allocations indicates
-    // whether slab is from Pool.
-
+    // For full-slab allocations indicates whether slab is from Pool.
     disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
 
     bool from_pool;
     void *ptr = disjoint_pool_allocate(hPool, size, &from_pool);
 
     if (hPool->params.pool_trace > 2) {
-        const char *MT = hPool->params.name;
-        (void)MT;
-        //std::cout << "Allocated " << std::setw(8) << size << " " << MT
-        //          << " bytes from " << (FromPool ? "Pool" : "Provider") << " ->"
-        //          << ptr << std::endl;
+        LOG_DEBUG("Allocated %8zu %s bytes from %s -> %p", size,
+                  hPool->params.name, (from_pool ? "pool" : "provider"), ptr);
     }
 
     return ptr;
@@ -896,21 +879,16 @@ void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
         bucket_count_alloc(bucket, from_pool);
     }
 
+    if (disjoint_pool->params.pool_trace > 2) {
+        LOG_DEBUG("Allocated %8zu %s bytes aligned at %zu from %s -> %p", size,
+                  disjoint_pool->params.name, alignment,
+                  (from_pool ? "pool" : "provider"), ptr);
+    }
+
     VALGRIND_DO_MEMPOOL_ALLOC(disjoint_pool, ALIGN_UP((size_t)ptr, alignment),
                               size);
     annotate_memory_undefined((void *)ALIGN_UP((size_t)ptr, alignment), size);
     return (void *)ALIGN_UP((size_t)ptr, alignment);
-
-    if (disjoint_pool->params.pool_trace > 2) {
-        const char *MT = disjoint_pool->params.name;
-        (void)MT;
-        //std::cout << "Allocated " << std::setw(8) << size << " " << MT
-        //          << " bytes aligned at " << alignment << " from "
-        //          << (FromPool ? "Pool" : "Provider") << " ->" << Ptr
-        //          << std::endl;
-    }
-
-    return ptr;
 }
 
 size_t disjoint_pool_malloc_usable_size(void *pool, void *ptr) {
@@ -959,8 +937,6 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
     }
 
     bool to_pool = false;
-    // TODO - no multimap
-    // for (auto It = Slabs.first; It != Slabs.second; ++It) {
 
     // The slab object won't be deleted until it's removed from the map which is
     // protected by the lock, so it's safe to access it here.
@@ -984,15 +960,14 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
 
         return UMF_RESULT_SUCCESS;
     }
-    //} // for multimap
 
     /*
     if (ret == UMF_RESULT_SUCCESS) {
 
         if (impl->getParams().pool_trace > 2) {
             auto MT = impl->getParams().Name;
             std::cout << "Freed " << MT << " " << ptr << " to "
-                      << (ToPool ? "Pool" : "Provider")
+                      << (ToPool ? "pool" : "provider")
                       << ", Current total pool size "
                       << impl->getLimits()->TotalSize.load()
                       << ", Current pool size for " << MT << " "
@@ -1001,8 +976,8 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
     }*/
 
     // There is a rare case when we have a pointer from system allocation next
-    // to some slab with an entry in the map. So we find a slab
-    // but the range checks fail.
+    // to some slab with an entry in the map. So we find a slab but the range
+    // checks fail.
     assert(0);
     return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
 }