UCS/MEMTRACK: added public API for memtrach:

- minor renamings
openucx · Jul 1, 2021 · 208a422 · 208a422
1 parent 723bd55
commit 208a422
Show file tree

Hide file tree

Showing 3 changed files with 35 additions and 40 deletions.
diff --git a/src/ucs/datastruct/ptr_array.c b/src/ucs/datastruct/ptr_array.c
@@ -117,7 +117,7 @@ static void ucs_ptr_array_clear(ucs_ptr_array_t *ptr_array)
 void ucs_ptr_array_init(ucs_ptr_array_t *ptr_array, const char *name)
 {
     ucs_ptr_array_clear(ptr_array);
-    ptr_array->name = ucs_strdup(name, "ptr_array name");
+    ptr_array->name = name;
 }
 
 void ucs_ptr_array_cleanup(ucs_ptr_array_t *ptr_array)
@@ -135,18 +135,17 @@ void ucs_ptr_array_cleanup(ucs_ptr_array_t *ptr_array)
     }
 
     ucs_free(ptr_array->start);
-    ucs_free((void*)ptr_array->name);
     ucs_ptr_array_clear(ptr_array);
 }
 
-static void ucs_ptr_array_grow(ucs_ptr_array_t *ptr_array, unsigned new_size,
-                               const char* alloc_name)
+static void ucs_ptr_array_grow(ucs_ptr_array_t *ptr_array, unsigned new_size)
 {
     ucs_ptr_array_elem_t *new_array;
     unsigned curr_size, i, next;
 
     /* Allocate new array */
-    new_array = ucs_malloc(new_size * sizeof(ucs_ptr_array_elem_t), alloc_name);
+    new_array = ucs_malloc(new_size * sizeof(ucs_ptr_array_elem_t),
+                           ptr_array->name);
     ucs_assert_always(new_array != NULL);
     curr_size = ptr_array->size;
     memcpy(new_array, ptr_array->start, curr_size * sizeof(ucs_ptr_array_elem_t));
@@ -185,7 +184,7 @@ unsigned ucs_ptr_array_insert(ucs_ptr_array_t *ptr_array, void *value)
 
     if (ptr_array->freelist == UCS_PTR_ARRAY_SENTINEL) {
         new_size = ucs_max(UCS_PTR_ARRAY_INITIAL_SIZE, ptr_array->size * 2);
-        ucs_ptr_array_grow(ptr_array, new_size, ptr_array->name);
+        ucs_ptr_array_grow(ptr_array, new_size);
     }
 
     /* Get the first item on the free list */
@@ -211,7 +210,7 @@ void ucs_ptr_array_set(ucs_ptr_array_t *ptr_array, unsigned element_index,
 
     if (ucs_unlikely(element_index >= ptr_array->size)) {
         new_size = ucs_max(ptr_array->size * 2, element_index + 1);
-        ucs_ptr_array_grow(ptr_array, new_size, ptr_array->name);
+        ucs_ptr_array_grow(ptr_array, new_size);
     } else if (!__ucs_ptr_array_is_free(ptr_array->start[element_index])) {
         ptr_array->start[element_index] = (uintptr_t)new_val;
         return;

diff --git a/src/ucs/debug/memtrack.c b/src/ucs/debug/memtrack.c
@@ -170,7 +170,8 @@ static void ucs_memtrack_generate_report()
     }
 }
 
-static void ucs_memtrack_do_allocated(void *ptr, size_t size, const char *name)
+static UCS_F_NOINLINE void
+ucs_memtrack_do_allocated(void *ptr, size_t size, const char *name)
 {
     ucs_memtrack_entry_t *entry;
     khiter_t iter;
@@ -183,6 +184,10 @@ static void ucs_memtrack_do_allocated(void *ptr, size_t size, const char *name)
     ucs_assert(!ucs_check_if_align_pow2((uintptr_t)ptr, UCX_ALLOC_ALIGN));
 #endif
 
+    if (ptr == NULL) {
+        return;
+    }
+
     pthread_mutex_lock(&ucs_memtrack_context.lock);
 
     entry = ucs_memtrack_entry_get(name);
@@ -220,21 +225,25 @@ static void ucs_memtrack_do_allocated(void *ptr, size_t size, const char *name)
 
 
 static UCS_F_ALWAYS_INLINE void
-ucs_memtrack_allocated_int(void *ptr, size_t size, const char *name)
+ucs_memtrack_allocated_internal(void *ptr, size_t size, const char *name)
 {
-    if ((ptr == NULL) || !ucs_memtrack_is_enabled()) {
+    if (!ucs_memtrack_is_enabled()) {
         return;
     }
 
     ucs_memtrack_do_allocated(ptr, size, name);
 }
 
-static void ucs_memtrack_do_releasing(void *ptr)
+static UCS_F_NOINLINE void ucs_memtrack_do_releasing(void *ptr)
 {
     ucs_memtrack_entry_t *entry;
     khiter_t iter;
     size_t size;
 
+    if (ptr == NULL) {
+        return;
+    }
+
     pthread_mutex_lock(&ucs_memtrack_context.lock);
 
     iter = kh_get(ucs_memtrack_ptr_hash, &ucs_memtrack_context.ptrs, (uintptr_t)ptr);
@@ -256,9 +265,9 @@ static void ucs_memtrack_do_releasing(void *ptr)
     pthread_mutex_unlock(&ucs_memtrack_context.lock);
 }
 
-static UCS_F_ALWAYS_INLINE void ucs_memtrack_releasing_int(void *ptr)
+static UCS_F_ALWAYS_INLINE void ucs_memtrack_releasing_internal(void *ptr)
 {
-    if ((ptr == NULL) || !ucs_memtrack_is_enabled()) {
+    if (!ucs_memtrack_is_enabled()) {
         return;
     }
 
@@ -268,22 +277,22 @@ static UCS_F_ALWAYS_INLINE void ucs_memtrack_releasing_int(void *ptr)
 void *ucs_malloc(size_t size, const char *name)
 {
     void *ptr = malloc(size);
-    ucs_memtrack_allocated_int(ptr, size, name);
+    ucs_memtrack_allocated_internal(ptr, size, name);
     return ptr;
 }
 
 void *ucs_calloc(size_t nmemb, size_t size, const char *name)
 {
     void *ptr = calloc(nmemb, size);
-    ucs_memtrack_allocated_int(ptr, nmemb * size, name);
+    ucs_memtrack_allocated_internal(ptr, nmemb * size, name);
     return ptr;
 }
 
 void *ucs_realloc(void *ptr, size_t size, const char *name)
 {
-    ucs_memtrack_releasing_int(ptr);
+    ucs_memtrack_releasing_internal(ptr);
     ptr = realloc(ptr, size);
-    ucs_memtrack_allocated_int(ptr, size, name);
+    ucs_memtrack_allocated_internal(ptr, size, name);
     return ptr;
 }
 
@@ -297,14 +306,14 @@ int ucs_posix_memalign(void **ptr, size_t boundary, size_t size, const char *nam
 #error "Port me"
 #endif
     if (ret == 0) {
-        ucs_memtrack_allocated_int(*ptr, size, name);
+        ucs_memtrack_allocated_internal(*ptr, size, name);
     }
     return ret;
 }
 
 void ucs_free(void *ptr)
 {
-    ucs_memtrack_releasing_int(ptr);
+    ucs_memtrack_releasing_internal(ptr);
     free(ptr);
 }
 
@@ -313,28 +322,28 @@ void *ucs_mmap(void *addr, size_t length, int prot, int flags, int fd,
 {
     void *ptr = mmap(addr, length, prot, flags, fd, offset);
     if (ptr != MAP_FAILED) {
-        ucs_memtrack_allocated_int(ptr, length, name);
+        ucs_memtrack_allocated_internal(ptr, length, name);
     }
     return ptr;
 }
 
 int ucs_munmap(void *addr, size_t length)
 {
-    ucs_memtrack_releasing_int(addr);
+    ucs_memtrack_releasing_internal(addr);
     return munmap(addr, length);
 }
 
 char *ucs_strdup(const char *src, const char *name)
 {
     char *str = strdup(src);
-    ucs_memtrack_allocated_int(str, strlen(str) + 1, name);
+    ucs_memtrack_allocated_internal(str, strlen(str) + 1, name);
     return str;
 }
 
 char *ucs_strndup(const char *src, size_t n, const char *name)
 {
     char *str = strndup(src, n);
-    ucs_memtrack_allocated_int(str, strlen(str) + 1, name);
+    ucs_memtrack_allocated_internal(str, strlen(str) + 1, name);
     return str;
 }
 
@@ -447,10 +456,10 @@ int ucs_posix_memalign_realloc(void **ptr, size_t boundary, size_t size,
 
 void ucs_memtrack_allocated(void *ptr, size_t size, const char *name)
 {
-    ucs_memtrack_allocated_int(ptr, size, name);
+    ucs_memtrack_allocated_internal(ptr, size, name);
 }
 
 void ucs_memtrack_releasing(void *ptr)
 {
-    ucs_memtrack_releasing_int(ptr);
+    ucs_memtrack_releasing_internal(ptr);
 }
diff --git a/src/ucs/debug/memtrack_int.h b/src/ucs/debug/memtrack_int.h
@@ -74,19 +74,6 @@ void ucs_memtrack_dump(FILE* output);
 void ucs_memtrack_total(ucs_memtrack_entry_t* total);
 
 
-/**
- * Track custom allocation. Need to be called after custom allocation returns.
- */
-void ucs_memtrack_allocated(void *ptr, size_t size, const char *name);
-
-
-/**
- * Track release of custom allocation. Need to be called before actually
- * releasing the memory.
- */
-void ucs_memtrack_releasing(void *ptr);
-
-
 /*
  * Memory allocation replacements. Their interface is the same as the originals,
  * except the additional parameter which specifies the allocation name.
@@ -103,12 +90,12 @@ int ucs_munmap(void *addr, size_t length);
 char *ucs_strdup(const char *src, const char *name);
 char *ucs_strndup(const char *src, size_t n, const char *name);
 
-END_C_DECLS
-
 /*
  * The functions below have no native implementation, they apply to both cases.
  */
 int ucs_posix_memalign_realloc(void **ptr, size_t boundary, size_t size,
                                const char *name);
 
+END_C_DECLS
+
 #endif /* UCS_MEMTRACK_INT_H_ */