enable test_init_teardown in CI

Author: bratpiorka

.github/workflows/nightly.yml

@@ -59,11 +59,11 @@ jobs:
 
       - name: Run regular tests
         working-directory: ${{github.workspace}}/build
-        run: ctest -C ${{matrix.build_type}} --output-on-failure -E "fuzz|test_init_teardown"
+        run: ctest -C ${{matrix.build_type}} --output-on-failure -E "fuzz"
 
       - name: Run regular tests with proxy library
         working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so ctest -C ${{matrix.build_type}} --output-on-failure -E "fuzz|test_init_teardown"
+        run: LD_PRELOAD=./lib/libumf_proxy.so ctest -C ${{matrix.build_type}} --output-on-failure -E "fuzz"
 
       - name: Fuzz long test
         working-directory: ${{github.workspace}}/build

.github/workflows/pr_push.yml

@@ -16,88 +16,5 @@ permissions:
   contents: 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: ["v0.11.0-rc1"]
-    with:
-      tag: ${{matrix.tag}}

.github/workflows/reusable_multi_numa.yml

@@ -21,8 +21,8 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-22.04, rhel-9.1, sles-15]
-        build_type: [Debug, Release]
-        shared_library: ['ON', 'OFF']
+        build_type: [Debug]
+        shared_library: ['ON']
     runs-on:  ["DSS-MULTI-NUMA", "DSS-${{matrix.os}}"]
 
     steps:
@@ -57,37 +57,13 @@ jobs:
         # On RHEL/SLES, hwloc version is just a little too low.
         # Skip some tests until we upgrade hwloc and update CMake to properly handle local hwloc installation.
         # TODO: fix issue #560
-        # TODO: add issue for -E test_init_teardown - it is not clear why it fails
       - name: Run tests (on RHEL/SLES)
         if: (matrix.os == 'rhel-9.1') || (matrix.os == 'sles-15')
         working-directory: ${{github.workspace}}/build
         run: |
-          ctest --output-on-failure --test-dir test -E "test_provider_os_memory_multiple_numa_nodes|test_init_teardown"
+          UMF_LOG="level:debug;flush:debug;output:stderr;pid:no" ctest --output-on-failure --test-dir test -E "test_provider_os_memory_multiple_numa_nodes"
           ./test/test_provider_os_memory_multiple_numa_nodes \
-            --gtest_filter="-*checkModeLocal/*:*checkModePreferredEmptyNodeset/*:testNuma.checkModeInterleave"
-
-      - name: Run NUMA tests under valgrind
-        if: (matrix.os != 'rhel-9.1') && (matrix.os != 'sles-15')
-        run: |
-          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} memcheck "${{env.NUMA_TESTS}}"
-          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} drd "${{env.NUMA_TESTS}}"
-          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} helgrind "${{env.NUMA_TESTS}}"
-
-      - name: Check coverage
-        if: ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' }}
-        working-directory: ${{env.BUILD_DIR}}
-        run: |
-          export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}
-          echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
-          ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
-          mkdir -p ${{env.COVERAGE_DIR}}
-          mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
-
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' }}
-        with:
-          name: ${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}
-          path: ${{env.COVERAGE_DIR}}
+            --gtest_filter="-*checkModeLocal/*:*checkModePreferredEmptyNodeset/*:testNuma.checkModeInterleave" --verbose
 
       - name: Get information about platform
         if: always()

src/base_alloc/base_alloc_global.c

@@ -41,6 +41,7 @@ struct base_alloc_t {
 static struct base_alloc_t BASE_ALLOC = {.ac_sizes = ALLOCATION_CLASSES};
 
 void umf_ba_destroy_global(void) {
+    LOG_DEBUG("destroying global base allocator");
     ba_is_destroyed = true;
 
     for (int i = 0; i < NUM_ALLOCATION_CLASSES; i++) {
@@ -55,7 +56,10 @@ void umf_ba_destroy_global(void) {
     memcpy(&ba_is_initialized, &set_once, sizeof(ba_is_initialized));
 }
 
-bool umf_ba_global_is_destroyed(void) { return ba_is_destroyed; }
+bool umf_ba_global_is_destroyed(void) {
+    LOG_DEBUG("base_alloc: ba_is_destroyed: %d", ba_is_destroyed);
+    return ba_is_destroyed;
+}
 
 static void umf_ba_create_global(void) {
     for (int i = 0; i < NUM_ALLOCATION_CLASSES; i++) {
@@ -74,6 +78,7 @@ static void umf_ba_create_global(void) {
     BASE_ALLOC.smallest_ac_size_log2 = utils_msb64(smallestSize);
 
     LOG_DEBUG("UMF base allocator created");
+    ba_is_destroyed = false; // TODO ??
 }
 
 // returns index of the allocation class for a given size

src/memory_pool.c

@@ -115,6 +115,7 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 }
 
 void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
+    LOG_DEBUG("calling umfPoolDestroy");
     if (umf_ba_global_is_destroyed()) {
         return;
     }

src/pool/pool_scalable.c

@@ -315,6 +315,7 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
 
 static void tbb_pool_finalize(void *pool) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
+    fprintf(stderr, "finalizing TBB scalable pool\n");
     tbb_callbacks.pool_destroy(pool_data->tbb_pool);
     umf_ba_global_free(pool_data);
 }
@@ -329,6 +330,7 @@ static void *tbb_malloc(void *pool, size_t size) {
         }
         return NULL;
     }
+    fprintf(stderr, "tbb_malloc ptr=%p\n", ptr);
     utils_annotate_acquire(pool);
     return ptr;
 }
@@ -376,6 +378,7 @@ static void *tbb_aligned_malloc(void *pool, size_t size, size_t alignment) {
 }
 
 static umf_result_t tbb_free(void *pool, void *ptr) {
+    fprintf(stderr, "tbb_free ptr=%p\n", ptr);
     if (ptr == NULL) {
         return UMF_RESULT_SUCCESS;
     }

src/provider/provider_tracking.c

@@ -494,6 +494,7 @@ static umf_result_t trackingAlloc(void *hProvider, size_t size,
 
     *_ptr = ptr;
 
+    LOG_DEBUG("Memory region added: ptr=%p, size=%zu", ptr, size);
     return UMF_RESULT_SUCCESS;
 }
 
@@ -729,13 +730,13 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
 
         if (umfMemoryTrackerAdd(p->hTracker, p->pool, ptr, size) !=
             UMF_RESULT_SUCCESS) {
-            LOG_ERR(
-                "cannot add memory back to the tracker, ptr = %p, size = %zu",
-                ptr, size);
+            LOG_ERR("cannot add memory back to the tracker, ptr=%p, size=%zu",
+                    ptr, size);
         }
         return ret;
     }
 
+    LOG_DEBUG("Memory region removed: ptr=%p, size=%zu", ptr, size);
     return ret;
 }
 
@@ -770,6 +771,10 @@ static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
                                  FIND_G, &rkey, (void **)&rvalue)) {
             if (rvalue->pool == pool || pool == NULL) {
                 n_items++;
+                LOG_DEBUG(
+                    "found abandoned allocation in the tracking provider: "
+                    "pool=%p, ptr=%p, size=%zu",
+                    (void *)rvalue->pool, (void *)rkey, (size_t)rvalue->size);
             }
 
             last_key = rkey;

test/test_init_teardown.c

@@ -205,7 +205,10 @@ static int run_test(int n_init_teardown, int wrong_dtor_order) {
 
     assert(umf_default);
     void *ptr = (*umf_alloc)(umf_default, SIZE_ALLOC);
+    fprintf(stderr, "\n\n!!!! after alloc: %p\n", ptr);
+
     (*umf_free)(umf_default, ptr);
+    fprintf(stderr, "\n\n!!!! after free: %p\n", ptr);
 
     // simulate incorrect order of destructors (an additional, unwanted destructor call)
     if (wrong_dtor_order) {