Merge pull request #394 from lplewa/update_log

Update log

Author: lukaszstolarczuk

benchmark/ubench.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -44,7 +44,6 @@
 #define DISJOINT_POOL_MAX_POOLABLE_SIZE (2 * ALLOC_SIZE)
 #define DISJOINT_POOL_CAPACITY (N_ITERATIONS + 10)
 #define DISJOINT_POOL_MIN_BUCKET_SIZE (ALLOC_SIZE)
-#define DISJOINT_POOL_TRACE (0)
 
 typedef struct alloc_s {
     void *ptr;
@@ -115,7 +114,6 @@ static umf_os_memory_provider_params_t UMF_OS_MEMORY_PROVIDER_PARAMS = {
     /* .numa_mode = */ UMF_NUMA_MODE_DEFAULT,
 
     // others
-    /* .traces = */ OS_MEMORY_PROVIDER_TRACE,
 };
 
 static void *w_umfMemoryProviderAlloc(void *provider, size_t size,
@@ -237,7 +235,6 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
         DISJOINT_POOL_MAX_POOLABLE_SIZE;
     disjoint_memory_pool_params.Capacity = DISJOINT_POOL_CAPACITY;
     disjoint_memory_pool_params.MinBucketSize = DISJOINT_POOL_MIN_BUCKET_SIZE;
-    disjoint_memory_pool_params.PoolTrace = DISJOINT_POOL_TRACE;
 
     umf_memory_pool_handle_t disjoint_pool;
     umf_result = umfPoolCreate(umfDisjointPoolOps(), os_memory_provider,

include/umf/providers/provider_os_memory.h

@@ -70,10 +70,6 @@ typedef struct umf_os_memory_provider_params_t {
     unsigned long maxnode;
     /// Describes how nodemask is interpreted
     umf_numa_mode_t numa_mode;
-
-    // others
-    /// Log level of debug traces
-    int traces;
 } umf_os_memory_provider_params_t;
 
 /// @brief OS Memory Provider operation results
@@ -98,7 +94,6 @@ umfOsMemoryProviderParamsDefault(void) {
         NULL,                                       /* nodemask */
         0,                                          /* maxnode */
         UMF_NUMA_MODE_DEFAULT,                      /* numa_mode */
-        0                                           /* traces */
     };
 
     return params;

scripts/docs_config/introduction.rst

@@ -105,12 +105,12 @@ By default, there is a guarantee that *error* messages are flushed immediately.
 
 Loggers redirect messages to *stdout*, *stderr*, or a file
 
-By default, no messages are printed. To enable logger you have to set **UMF_LOG** environment variable which have following syntax for setting logger options:
+By default, only fatal messages are printed. To enable logger you have to set **UMF_LOG** environment variable which have following syntax for setting logger options:
 
-  "[level:debug|info|warning|error];[flush:debug|info|warning|error];[output:stdout|stderr|file,<path>];[timestamp:yes|no];[pid:yes|no]"
+  "[level:debug|info|warning|error|fatal];[flush:debug|info|warning|error|fatal];[output:stdout|stderr|file,<path>];[timestamp:yes|no];[pid:yes|no]"
 
   * level - a log level, meaning that only messages from this level and above are printed.
-            Possible values, from the lowest level to the highest one: *debug*, *info*, *warning*, *error*,
+            Possible values, from the lowest level to the highest one: *debug*, *info*, *warning*, *error*, *fatal*
   * flush - a flush level, meaning that messages at this level and above are guaranteed to be flushed immediately,
             possible values are the same as above,
   * output - indicates where messages should be printed.

src/base_alloc/base_alloc.c

@@ -11,6 +11,7 @@
 #include "base_alloc_internal.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
 #include "utils_sanitizers.h"
 
 // minimum size of a single pool of the base allocator
@@ -288,7 +289,7 @@ void umf_ba_destroy(umf_ba_pool_t *pool) {
 #ifndef NDEBUG
     ba_debug_checks(pool);
     if (pool->metadata.n_allocs) {
-        fprintf(stderr, "umf_ba_destroy(): pool->metadata.n_allocs = %zu\n",
+        LOG_ERR("umf_ba_destroy(): pool->metadata.n_allocs = %zu",
                 pool->metadata.n_allocs);
         assert(pool->metadata.n_allocs == 0);
     }

src/base_alloc/base_alloc_global.c

@@ -16,6 +16,7 @@
 #include "base_alloc_internal.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
 #include "utils_math.h"
 #include "utils_sanitizers.h"
 
@@ -52,8 +53,7 @@ static void umf_ba_create_global(void) {
         assert(0 == (BASE_ALLOC.ac_sizes[i] & (BASE_ALLOC.ac_sizes[i] - 1)));
         BASE_ALLOC.ac[i] = umf_ba_create(BASE_ALLOC.ac_sizes[i]);
         if (!BASE_ALLOC.ac[i]) {
-            fprintf(stderr,
-                    "base_alloc: Error. Cannot create base alloc allocation "
+            LOG_ERR("base_alloc: Cannot create base alloc allocation "
                     "class for size: %zu\n. Each allocation will fallback to "
                     "allocating memory from the OS.",
                     BASE_ALLOC.ac_sizes[i]);
@@ -163,18 +163,16 @@ void *umf_ba_global_aligned_alloc(size_t size, size_t alignment) {
 
     int ac_index = size_to_idx(size);
     if (ac_index >= NUM_ALLOCATION_CLASSES) {
-        // TODO: use logger here
-        // fprintf(stderr,
-        //         "base_alloc: allocation size (%zu) larger than the biggest "
-        //         "allocation class. Falling back to OS memory allocation.\n",
-        //         size);
+        LOG_WARN("base_alloc: allocation size (%zu) larger than the biggest "
+                 "allocation class. Falling back to OS memory allocation.",
+                 size);
         return add_metadata_and_align(ba_os_alloc(size), size, alignment);
     }
 
     if (!BASE_ALLOC.ac[ac_index]) {
         // if creating ac failed, fall back to os allocation
-        fprintf(stderr, "base_alloc: allocation class not created. Falling "
-                        "back to OS memory allocation.\n");
+        LOG_WARN("base_alloc: allocation class not created. Falling "
+                 "back to OS memory allocation.");
         return add_metadata_and_align(ba_os_alloc(size), size, alignment);
     }
 

src/base_alloc/base_alloc_linear.c

@@ -12,6 +12,7 @@
 #include "base_alloc_linear.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
 
 #ifndef NDEBUG
 #define _DEBUG_EXECUTE(expression) DO_WHILE_EXPRS(expression)
@@ -249,7 +250,7 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
 #ifndef NDEBUG
     _DEBUG_EXECUTE(ba_debug_checks(pool));
     if (pool->metadata.global_n_allocs) {
-        fprintf(stderr, "umf_ba_linear_destroy(): global_n_allocs = %zu\n",
+        LOG_ERR("umf_ba_linear_destroy(): global_n_allocs = %zu",
                 pool->metadata.global_n_allocs);
         assert(pool->metadata.global_n_allocs == 0);
     }

src/pool/pool_disjoint.cpp

@@ -25,6 +25,7 @@
 #include "../cpp_helpers.hpp"
 #include "pool_disjoint.h"
 #include "umf.h"
+#include "utils_log.h"
 #include "utils_math.h"
 #include "utils_sanitizers.h"
 
@@ -433,22 +434,22 @@ Slab::~Slab() {
     try {
         unregSlab(*this);
     } catch (std::exception &e) {
-        std::cerr << "DisjointPool: unexpected error: " << e.what() << "\n";
+        LOG_ERR("DisjointPool: unexpected error: %s", e.what());
     }
 
     try {
         memoryProviderFree(bucket.getMemHandle(), MemPtr);
     } catch (MemoryProviderError &e) {
-        std::cerr << "DisjointPool: error from memory provider: " << e.code
-                  << "\n";
+        LOG_ERR("DisjointPool: error from memory provider: %d", e.code);
+
         if (e.code == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
             const char *message = "";
             int error = 0;
 
             umfMemoryProviderGetLastNativeError(
                 umfGetLastFailedMemoryProvider(), &message, &error);
-            std::cerr << "Native error msg: " << message
-                      << ", native error code: " << error << std::endl;
+            LOG_ERR("Native error msg: %s, native error code: %d", message,
+                    error);
         }
     }
 }

src/pool/pool_jemalloc.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -13,6 +13,7 @@
 #include "base_alloc_global.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
 #include "utils_sanitizers.h"
 
 #include <umf/memory_pool.h>
@@ -116,7 +117,7 @@ static void arena_extent_destroy(extent_hooks_t *extent_hooks, void *addr,
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
-        fprintf(stderr, "umfMemoryProviderFree failed \n");
+        LOG_ERR("umfMemoryProviderFree failed");
     }
 }
 
@@ -138,7 +139,7 @@ static bool arena_extent_dalloc(extent_hooks_t *extent_hooks, void *addr,
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
-        fprintf(stderr, "umfMemoryProviderFree failed in dalloc \n");
+        LOG_ERR("umfMemoryProviderFree failed in dalloc");
     }
 
     return ret != UMF_RESULT_SUCCESS;
@@ -405,7 +406,7 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
     err = je_mallctl("arenas.create", (void *)&arena_index, &unsigned_size,
                      NULL, 0);
     if (err) {
-        fprintf(stderr, "Could not create arena.\n");
+        LOG_ERR("Could not create arena.");
         goto err_free_pool;
     }
 
@@ -416,8 +417,7 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
     if (err) {
         snprintf(cmd, sizeof(cmd), "arena.%u.destroy", arena_index);
         je_mallctl(cmd, NULL, 0, NULL, 0);
-        fprintf(stderr,
-                "Could not setup extent_hooks for newly created arena.\n");
+        LOG_ERR("Could not setup extent_hooks for newly created arena.");
         goto err_free_pool;
     }
 

src/pool/pool_scalable.c

@@ -24,6 +24,7 @@
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_load_library.h"
+#include "utils_log.h"
 #include "utils_sanitizers.h"
 
 typedef void *(*raw_alloc_tbb_type)(intptr_t, size_t *);
@@ -109,7 +110,7 @@ static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) {
     const char *lib_name = tbb_symbol[TBB_LIB_NAME];
     tbb_callbacks->lib_handle = util_open_library(lib_name);
     if (!tbb_callbacks->lib_handle) {
-        fprintf(stderr, "%s not found.\n", lib_name);
+        LOG_ERR("%s not found.", lib_name);
         return -1;
     }
 
@@ -134,7 +135,7 @@ static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) {
         !tbb_callbacks->pool_aligned_malloc || !tbb_callbacks->pool_free ||
         !tbb_callbacks->pool_create_v1 || !tbb_callbacks->pool_destroy ||
         !tbb_callbacks->pool_identify) {
-        fprintf(stderr, "Could not find symbols in %s.\n", lib_name);
+        LOG_ERR("Could not find symbols in %s", lib_name);
         util_close_library(tbb_callbacks->lib_handle);
         return -1;
     }
@@ -160,10 +161,8 @@ static void tbb_raw_free_wrapper(intptr_t pool_id, void *ptr, size_t bytes) {
     umf_result_t ret = umfMemoryProviderFree(pool->mem_provider, ptr, bytes);
     if (ret != UMF_RESULT_SUCCESS) {
         TLS_last_free_error = ret;
-        fprintf(
-            stderr,
-            "Memory provider failed to free memory, addr = %p, size = %zu\n",
-            ptr, bytes);
+        LOG_ERR("Memory provider failed to free memory, addr = %p, size = %zu",
+                ptr, bytes);
     }
 }
 
@@ -183,13 +182,13 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
     tbb_memory_pool_t *pool_data =
         umf_ba_global_alloc(sizeof(tbb_memory_pool_t));
     if (!pool_data) {
-        fprintf(stderr, "cannot allocate memory for metadata\n");
+        LOG_ERR("cannot allocate memory for metadata");
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     int ret = init_tbb_callbacks(&pool_data->tbb_callbacks);
     if (ret != 0) {
-        fprintf(stderr, "loading TBB symbols failed\n");
+        LOG_ERR("loading TBB symbols failed");
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 

src/provider/provider_level_zero.c

@@ -20,6 +20,7 @@
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_load_library.h"
+#include "utils_log.h"
 #include "utils_sanitizers.h"
 
 typedef struct ze_memory_provider_t {
@@ -59,7 +60,7 @@ static void init_ze_global_state(void) {
 
     if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice ||
         !g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree) {
-        fprintf(stderr, "Required Level Zero symbols not found.\n");
+        LOG_ERR("Required Level Zero symbols not found.");
         Init_ze_global_state_failed = true;
     }
 }
@@ -74,7 +75,7 @@ enum umf_result_t ze_memory_provider_initialize(void *params, void **provider) {
 
     util_init_once(&ze_is_initialized, init_ze_global_state);
     if (Init_ze_global_state_failed) {
-        fprintf(stderr, "Loading Level Zero symbols failed\n");
+        LOG_ERR("Loading Level Zero symbols failed");
         return UMF_RESULT_ERROR_UNKNOWN;
     }