x

Author: bratpiorka

.github/workflows/pr_push.yml

@@ -17,88 +17,6 @@ permissions:
   packages: read
 
 jobs:
-  CodeChecks:
-    uses: ./.github/workflows/reusable_checks.yml
-  FastBuild:
-    name: Fast builds
-    needs: [CodeChecks]
-    uses: ./.github/workflows/reusable_fast.yml
-  Build:
-    name: Basic builds
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_basic.yml
-  DevDax:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_dax.yml
-  MultiNuma:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_multi_numa.yml
-  L0:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_gpu.yml
-    with:
-      provider: "LEVEL_ZERO"
-      runner: "L0"
-      shared_lib: "['ON']"
-  L0-BMG:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_gpu.yml
-    with:
-      provider: "LEVEL_ZERO"
-      runner: "L0-BMG"
-      shared_lib: "['ON']"
-      os: "['Ubuntu']"
-  CUDA:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_gpu.yml
-    with:
-      provider: "CUDA"
-      runner: "CUDA"
-      shared_lib: "['ON']"
-  Sanitizers:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_sanitizers.yml
-  QEMU:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_qemu.yml
-    with:
-      short_run: true
   ProxyLib:
-    needs: [Build]
     uses: ./.github/workflows/reusable_proxy_lib.yml
-  Valgrind:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_valgrind.yml
-  Coverage:
-    # total coverage (on upstream only)
-    if: github.repository == 'oneapi-src/unified-memory-framework'
-    needs: [Build, DevDax, L0, CUDA, MultiNuma, QEMU, ProxyLib]
-    uses: ./.github/workflows/reusable_coverage.yml
-    secrets: inherit
-    with:
-      trigger: "${{github.event_name}}"
-  Coverage_partial:
-    # partial coverage (on forks)
-    if: github.repository != 'oneapi-src/unified-memory-framework'
-    needs: [Build, QEMU, ProxyLib]
-    uses: ./.github/workflows/reusable_coverage.yml
-  CodeQL:
-    needs: [Build]
-    permissions:
-      contents: read
-      security-events: write
-    uses: ./.github/workflows/reusable_codeql.yml
-  Trivy:
-    needs: [Build]
-    permissions:
-      contents: read
-      security-events: write
-    uses: ./.github/workflows/reusable_trivy.yml
-  Compatibility:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_compatibility.yml
-    strategy:
-      matrix:
-        tag: ["v1.0.1"]
-    with:
-      tag: ${{matrix.tag}}
+    

.github/workflows/reusable_proxy_lib.yml

@@ -54,6 +54,10 @@ jobs:
       - name: Build UMF
         run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
 
+      - name: Run "ctest --output-on-failure" without proxy library
+        working-directory: ${{env.BUILD_DIR}}
+        run: ctest --output-on-failure
+        
       - name: Run "ctest --output-on-failure" with proxy library
         working-directory: ${{env.BUILD_DIR}}
         run: LD_PRELOAD=./lib/libumf_proxy.so ctest --output-on-failure

src/coarse/coarse.c

@@ -22,13 +22,6 @@
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-#ifdef _WIN32
-UTIL_ONCE_FLAG Log_initialized = UTIL_ONCE_FLAG_INIT;
-#else
-void __attribute__((constructor)) coarse_init(void) { utils_log_init(); }
-void __attribute__((destructor)) coarse_destroy(void) {}
-#endif /* _WIN32 */
-
 typedef struct coarse_t {
     // handle of the memory provider
     void *provider;
@@ -883,9 +876,7 @@ static umf_result_t coarse_get_stats_no_lock(coarse_t *coarse,
 // PUBLIC API
 
 umf_result_t coarse_new(coarse_params_t *coarse_params, coarse_t **pcoarse) {
-#ifdef _WIN32
-    utils_init_once(&Log_initialized, utils_log_init);
-#endif /* _WIN32 */
+    utils_log_init();
 
     if (coarse_params == NULL || pcoarse == NULL) {
         LOG_ERR("coarse parameters or handle is missing");

src/libumf_linux.c

@@ -9,9 +9,19 @@
 
 #include <umf.h>
 
-void __attribute__((constructor)) umfCreate(void) { (void)umfInit(); }
+#include <stdio.h>
 
-void __attribute__((destructor)) umfDestroy(void) { (void)umfTearDown(); }
+void __attribute__((constructor(102))) umfCreate(void) {
+    fprintf(stderr, "libumf constructor pre\n");
+    (void)umfInit();
+    fprintf(stderr, "libumf constructor post\n");
+}
+
+void __attribute__((destructor(102))) umfDestroy(void) {
+    fprintf(stderr, "libumf destructor pre\n");
+    (void)umfTearDown();
+    fprintf(stderr, "libumf destructor post\n");
+}
 
 void libumfInit(void) {
     // do nothing, additional initialization not needed

src/proxy_lib/proxy_lib_linux.c

@@ -1,23 +1,24 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
 
+#include <stdio.h>
+
 #include "proxy_lib.h"
 
-// The priority 102 is used, because the constructor should be called as the second one
-// (just after the first constructor of the base allocator with priority 101)
-// and the destructor as the last but one (just before the last destructor
-// of the base allocator with priority 101), because this library
-// provides the memory allocation API.
-void __attribute__((constructor(102))) proxy_lib_create(void) {
+void __attribute__((constructor(101))) proxy_lib_create(void) {
+    fprintf(stderr, "libumf constructor pre\n");
     proxy_lib_create_common();
+    fprintf(stderr, "libumf constructor post\n");
 }
 
-void __attribute__((destructor(102))) proxy_lib_destroy(void) {
+void __attribute__((destructor(101))) proxy_lib_destroy(void) {
+    fprintf(stderr, "libumf destructor pre\n");
     proxy_lib_destroy_common();
+    fprintf(stderr, "libumf destructor post\n");
 }

src/utils/utils_load_library.c

@@ -79,10 +79,16 @@ void *utils_open_library(const char *filename, int userFlags) {
         LOG_FATAL("dlopen(%s) failed with error: %s", filename, dlerror());
     }
 
+    LOG_DEBUG("Opened library %s with handle %p", filename, handle);
+
     return handle;
 }
 
-int utils_close_library(void *handle) { return dlclose(handle); }
+int utils_close_library(void *handle) {
+    LOG_DEBUG("Closing library handle %p", handle);
+
+    return dlclose(handle);
+}
 
 void *utils_get_symbol_addr(void *handle, const char *symbol,
                             const char *libname) {

src/utils/utils_log.c

@@ -32,6 +32,10 @@
 #include "utils_common.h"
 #include "utils_log.h"
 
+#ifndef DISABLE_SINGLE_LOGGER
+#include "utils_concurrency.h"
+#endif
+
 #define UMF_MAGIC_STR "\x00@(#) "
 #define UMF_PREF_STR "Intel(R) "
 #define UMF_PREFIX UMF_MAGIC_STR UMF_PREF_STR
@@ -60,6 +64,10 @@ char const __umf_str_1__all_cmake_vars[] =
 #define MAX_FILE_PATH 256
 #define MAX_ENV_LEN 2048
 
+#ifndef DISABLE_CTL_LOGGER
+static UTIL_ONCE_FLAG initOnce = UTIL_ONCE_FLAG_INIT;
+#endif
+
 typedef struct {
     bool enableTimestamp;
     bool enablePid;
@@ -247,7 +255,7 @@ void utils_plog(utils_log_level_t level, const char *func, const char *format,
 
 static const char *bool_to_str(int b) { return b ? "yes" : "no"; }
 
-void utils_log_init(void) {
+static void utils_log_init_once(void) {
     const char *envVar = getenv("UMF_LOG");
 
     if (!envVar) {
@@ -343,6 +351,12 @@ void utils_log_init(void) {
 }
 
 // this is needed for logger unit test
+#ifndef DISABLE_SINGLE_LOGGER
+void utils_log_init(void) { utils_init_once(&initOnce, utils_log_init_once); }
+#else // DISABLE_SINGLE_LOGGER
+void utils_log_init(void) { utils_log_init_once(); }
+#endif
+
 #ifndef DISABLE_CTL_LOGGER
 static umf_result_t
 CTL_READ_HANDLER(timestamp)(void *ctx, umf_ctl_query_source_t source, void *arg,

src/utils/utils_log.h

@@ -37,6 +37,10 @@ typedef enum {
 #define LOG_PFATAL(...) utils_plog(LOG_FATAL, __func__, __VA_ARGS__);
 
 void utils_log_init(void);
+
+// this function is used in tests to initialize the logging system
+void utils_log_init_test(void);
+
 #ifdef _WIN32
 void utils_log(utils_log_level_t level, const char *func, const char *format,
                ...);

test/utils/utils_log.cpp

@@ -97,6 +97,7 @@ int mock_strerror_windows(char *buff, size_t s, int errnum) {
 
 extern "C" {
 #define DISABLE_CTL_LOGGER 1
+#define DISABLE_SINGLE_LOGGER 1
 const char *env_variable = "";
 #define fopen(A, B) mock_fopen(A, B)
 #define fputs(A, B) mock_fputs(A, B)
@@ -161,8 +162,8 @@ TEST_F(test, parseEnv_errors) {
     helper_checkConfig(&b, &loggerConfig);
     helper_log_init("_level:debug");
     helper_checkConfig(&b, &loggerConfig);
-    expected_message =
-        "[ERROR UMF] utils_log_init: Cannot open output file - path too long\n";
+    expected_message = "[ERROR UMF] utils_log_init_once: Cannot open output "
+                       "file - path too long\n";
     std::string test_env = "output:file," + std::string(300, 'x');
     helper_log_init(test_env.c_str());
 }
@@ -247,7 +248,8 @@ TEST_F(test, parseEnv) {
                             expect_fput_count = 1;
                             if (expected_filename.size() > MAX_FILE_PATH) {
                                 expected_message =
-                                    "[ERROR UMF] utils_log_init: Cannot open "
+                                    "[ERROR UMF] utils_log_init_once: Cannot "
+                                    "open "
                                     "output file - path too long\n";
                             }
                         }