cstyle fixes

lplewa · lplewa · commit e165abd57248 · 2025-09-18T11:00:22.000+02:00
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -300,7 +300,7 @@ if(LINUX)
 
     target_include_directories(
         ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
-                                    ${UMF_CMAKE_SOURCE_DIR}/include)
+                                ${UMF_CMAKE_SOURCE_DIR}/include)
 
     target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
 
diff --git a/examples/ctl/ctl_statistics_example.c b/examples/ctl/ctl_statistics_example.c
@@ -94,9 +94,8 @@ static void print_pool_stat_by_handle(const char *label,
     size_t value = 0;
     /* Surround the {} placeholder with literal segments so CTL resolves
      * whichever pool handle the allocator hands back. */
-    umf_result_t res =
-        umfCtlGet("umf.pool.by_handle.{}.stats.{}", &value, sizeof(value),
-                  pool, stat_node);
+    umf_result_t res = umfCtlGet("umf.pool.by_handle.{}.stats.{}", &value,
+                                 sizeof(value), pool, stat_node);
     if (report_pool_stat_failure(label, required_trace_level, res)) {
         return;
     }
diff --git a/src/ctl/ctl_defaults.h b/src/ctl/ctl_defaults.h
@@ -9,8 +9,8 @@
 #ifndef UMF_CTL_DEFAULTS_H
 #define UMF_CTL_DEFAULTS_H 1
 
-#include <stddef.h>
 #include <stdarg.h>
+#include <stddef.h>
 
 #include <umf/base.h>
 
diff --git a/src/pool/pool_disjoint.c b/src/pool/pool_disjoint.c
@@ -205,8 +205,7 @@ CTL_WRITE_HANDLER(capacity)(void *ctx, umf_ctl_query_source_t source, void *arg,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
     size_t value = *(size_t *)arg;
-    umf_result_t ret =
-        umfDisjointPoolParamsSetCapacity(&pool->params, value);
+    umf_result_t ret = umfDisjointPoolParamsSetCapacity(&pool->params, value);
     if (ret == UMF_RESULT_SUCCESS) {
         pool->params_overridden |= DP_OVERRIDE_CAPACITY;
     }
@@ -279,8 +278,7 @@ CTL_WRITE_HANDLER(pool_trace)(void *ctx, umf_ctl_query_source_t source,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
     int value = *(int *)arg;
-    umf_result_t ret =
-        umfDisjointPoolParamsSetTrace(&pool->params, value);
+    umf_result_t ret = umfDisjointPoolParamsSetTrace(&pool->params, value);
     if (ret == UMF_RESULT_SUCCESS) {
         pool->params_overridden |= DP_OVERRIDE_POOL_TRACE;
     }
@@ -557,8 +555,8 @@ umf_result_t disjoint_pool_ctl(void *hPool,
                                umf_ctl_query_type_t queryType, va_list args) {
     utils_init_once(&ctl_initialized, initialize_disjoint_ctl);
 
-    return ctl_query(&disjoint_ctl_root, hPool, operationType, name,
-                     queryType, arg, size, args);
+    return ctl_query(&disjoint_ctl_root, hPool, operationType, name, queryType,
+                     arg, size, args);
 }
 
 // Temporary solution for disabling memory poisoning. This is needed because
diff --git a/src/pool/pool_jemalloc.c b/src/pool/pool_jemalloc.c
@@ -11,8 +11,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "ctl/ctl_internal.h"
 #include "base_alloc_global.h"
+#include "ctl/ctl_internal.h"
 #include "memory_provider_internal.h"
 #include "provider_tracking.h"
 #include "utils_common.h"
@@ -616,9 +616,10 @@ static umf_result_t op_post_initialize(void *pool) {
     return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
 }
 
-static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
-    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
-    umf_ctl_index_utlist_t *indexes) {
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
     (void)source;
     (void)arg;
     (void)size;
@@ -627,12 +628,11 @@ static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
 }
 
 static void initialize_jemalloc_ctl(void) {
-    jemalloc_ctl_root.root[jemalloc_ctl_root.first_free++] =
-        (umf_ctl_node_t){
-            .name = "post_initialize",
-            .type = CTL_NODE_LEAF,
-            .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
-        };
+    jemalloc_ctl_root.root[jemalloc_ctl_root.first_free++] = (umf_ctl_node_t){
+        .name = "post_initialize",
+        .type = CTL_NODE_LEAF,
+        .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+    };
 }
 
 static umf_result_t op_ctl(void *pool, umf_ctl_query_source_t operationType,
diff --git a/src/pool/pool_scalable.c b/src/pool/pool_scalable.c
@@ -469,9 +469,10 @@ static umf_result_t tbb_get_last_allocation_error(void *pool) {
     return TLS_last_allocation_error;
 }
 
-static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
-    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
-    umf_ctl_index_utlist_t *indexes) {
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
     (void)source;
     (void)arg;
     (void)size;
diff --git a/src/provider/provider_cuda.c b/src/provider/provider_cuda.c
@@ -110,9 +110,10 @@ struct ctl cu_memory_ctl_root;
 static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
 
 static umf_result_t cu_memory_provider_post_initialize(void *provider);
-static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
-    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
-    umf_ctl_index_utlist_t *indexes) {
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
     (void)source;
     (void)arg;
     (void)size;
@@ -159,12 +160,11 @@ static umf_result_t cu2umf_result(CUresult result) {
 
 static void initialize_cu_ctl(void) {
     CTL_REGISTER_MODULE(&cu_memory_ctl_root, stats);
-    cu_memory_ctl_root.root[cu_memory_ctl_root.first_free++] =
-        (umf_ctl_node_t){
-            .name = "post_initialize",
-            .type = CTL_NODE_LEAF,
-            .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
-        };
+    cu_memory_ctl_root.root[cu_memory_ctl_root.first_free++] = (umf_ctl_node_t){
+        .name = "post_initialize",
+        .type = CTL_NODE_LEAF,
+        .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+    };
 }
 
 static void init_cu_global_state(void) {
diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c
@@ -161,9 +161,10 @@ struct ctl file_memory_ctl_root;
 static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
 
 static umf_result_t file_post_initialize(void *provider);
-static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
-    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
-    umf_ctl_index_utlist_t *indexes) {
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
     (void)source;
     (void)arg;
     (void)size;
diff --git a/src/provider/provider_fixed_memory.c b/src/provider/provider_fixed_memory.c
@@ -66,9 +66,10 @@ struct ctl fixed_memory_ctl_root;
 static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
 
 static umf_result_t fixed_post_initialize(void *provider);
-static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
-    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
-    umf_ctl_index_utlist_t *indexes) {
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
     (void)source;
     (void)arg;
     (void)size;
diff --git a/test/common/fork_helpers.hpp b/test/common/fork_helpers.hpp
@@ -73,4 +73,3 @@ template <typename Func> void run_in_fork(Func &&func) {
 }
 
 } // namespace umf_test
-
diff --git a/test/ctl/ctl_api.cpp b/test/ctl/ctl_api.cpp
@@ -66,13 +66,13 @@ class CtlTest : public ::testing::Test {
 TEST_F(CtlTest, ctlDefault) {
     umf_test::run_in_fork([] {
         const char *arg = "default_name";
-        ASSERT_EQ(umfCtlSet("umf.pool.default.some_pool.some_path",
-                             (void *)arg, strlen(arg)),
+        ASSERT_EQ(umfCtlSet("umf.pool.default.some_pool.some_path", (void *)arg,
+                            strlen(arg)),
                   UMF_RESULT_SUCCESS);
 
         char output[64] = {1};
         ASSERT_EQ(umfCtlGet("umf.pool.default.some_pool.some_path",
-                             (void *)output, sizeof(output)),
+                            (void *)output, sizeof(output)),
                   UMF_RESULT_SUCCESS);
         ASSERT_STREQ(output, arg);
     });
@@ -123,8 +123,7 @@ TEST_F(CtlTest, ctlDefaultPoolMultithreaded) {
             threads.emplace_back([i, &totalRecords, &predefined_value,
                                   &name_prefix, max_size = max_size]() {
                 for (size_t j = 0; j < max_size; j++) {
-                    std::string name =
-                        name_prefix + std::to_string(i * 10 + j);
+                    std::string name = name_prefix + std::to_string(i * 10 + j);
                     umfCtlSet(name.c_str(), (void *)predefined_value,
                               strlen(predefined_value));
                     std::atomic_fetch_add(&totalRecords, 1UL);
@@ -179,16 +178,15 @@ TEST_F(CtlTest, ctlDefaultMultithreadedProvider) {
         const char *predefined_value = "xyzzyx";
         std::string name_prefix = "umf.provider.default.some_provider.";
         for (int i = 0; i < 8; i++) {
-            threads.emplace_back(
-                [i, &totalRecords, &predefined_value, &name_prefix]() {
-                    for (int j = 0; j < 10; j++) {
-                        std::string name =
-                            name_prefix + std::to_string(i * 10 + j);
-                        umfCtlSet(name.c_str(), (void *)predefined_value,
-                                  strlen(predefined_value));
-                        std::atomic_fetch_add(&totalRecords, 1);
-                    }
-                });
+            threads.emplace_back([i, &totalRecords, &predefined_value,
+                                  &name_prefix]() {
+                for (int j = 0; j < 10; j++) {
+                    std::string name = name_prefix + std::to_string(i * 10 + j);
+                    umfCtlSet(name.c_str(), (void *)predefined_value,
+                              strlen(predefined_value));
+                    std::atomic_fetch_add(&totalRecords, 1);
+                }
+            });
         }
         for (auto &thread : threads) {
             thread.join();
diff --git a/test/ctl/ctl_env_app.cpp b/test/ctl/ctl_env_app.cpp
@@ -92,8 +92,8 @@ static int test_disjoint_pool(int argc, char **argv) {
         return 0;
     }
 
-    if (umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params, &provider) !=
-        UMF_RESULT_SUCCESS) {
+    if (umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
+                                &provider) != UMF_RESULT_SUCCESS) {
         std::cerr << "Failed to create provider" << std::endl;
         goto out;
     }
@@ -108,8 +108,7 @@ static int test_disjoint_pool(int argc, char **argv) {
         const char *name = argv[i];
         const char *value = argv[i + 1];
         char path[128];
-        snprintf(path, sizeof(path),
-                 "umf.pool.by_handle.{}.params.%s", name);
+        snprintf(path, sizeof(path), "umf.pool.by_handle.{}.params.%s", name);
 
         if (strcmp(name, "pool_trace") == 0) {
             int got = 0;
diff --git a/test/ctl/ctl_env_driver.cpp b/test/ctl/ctl_env_driver.cpp
@@ -129,19 +129,17 @@ TEST_F(test, ctl_env_logger) {
 
 TEST_F(test, ctl_env_disjoint_pool_env) {
     run_case(
-        {{"UMF_CONF",
-          "umf.pool.default.disjoint.params.slab_min_size=65536;"
-          "umf.pool.default.disjoint.params.capacity=4;"
-          "umf.pool.default.disjoint.params.min_bucket_size=8;"
-          "umf.pool.default.disjoint.params.pool_trace=0"}},
+        {{"UMF_CONF", "umf.pool.default.disjoint.params.slab_min_size=65536;"
+                      "umf.pool.default.disjoint.params.capacity=4;"
+                      "umf.pool.default.disjoint.params.min_bucket_size=8;"
+                      "umf.pool.default.disjoint.params.pool_trace=0"}},
         {"disjoint_pool", "slab_min_size", "65536", "capacity", "4",
          "min_bucket_size", "8", "pool_trace", "0"});
 }
 
 TEST_F(test, ctl_env_disjoint_pool_file) {
     std::string cfg = CTL_CONF_FILE_DIR "/ctl_env_disjoint_pool.cfg";
-    run_case(
-        {{"UMF_CONF_FILE", cfg}},
-        {"disjoint_pool", "slab_min_size", "65536", "capacity", "4",
-         "min_bucket_size", "8", "pool_trace", "0"});
+    run_case({{"UMF_CONF_FILE", cfg}},
+             {"disjoint_pool", "slab_min_size", "65536", "capacity", "4",
+              "min_bucket_size", "8", "pool_trace", "0"});
 }
diff --git a/test/pools/disjoint_pool.cpp b/test/pools/disjoint_pool.cpp
@@ -4,10 +4,10 @@
 
 #include <memory>
 
+#include <cstdarg>
 #include <umf/base.h>
 #include <umf/memory_pool.h>
 #include <umf/pools/pool_disjoint.h>
-#include <cstdarg>
 
 #include "pool.hpp"
 #include "pool/pool_disjoint_internal.h"
@@ -70,9 +70,8 @@ TEST_F(test, internals) {
     EXPECT_EQ(res, UMF_RESULT_SUCCESS);
     va_list empty_args;
     get_test_va_list(&empty_args);
-    res = ops->ext_ctl((void *)pool, CTL_QUERY_PROGRAMMATIC,
-                       "post_initialize", nullptr, 0, CTL_QUERY_RUNNABLE,
-                       empty_args);
+    res = ops->ext_ctl((void *)pool, CTL_QUERY_PROGRAMMATIC, "post_initialize",
+                       nullptr, 0, CTL_QUERY_RUNNABLE, empty_args);
     va_end(empty_args);
     EXPECT_EQ(res, UMF_RESULT_SUCCESS);
     EXPECT_NE(pool, nullptr);
@@ -327,9 +326,8 @@ TEST_F(test, disjointPoolTrim) {
 
     va_list empty_args;
     get_test_va_list(&empty_args);
-    res = ops->ext_ctl((void *)pool, CTL_QUERY_PROGRAMMATIC,
-                       "post_initialize", nullptr, 0, CTL_QUERY_RUNNABLE,
-                       empty_args);
+    res = ops->ext_ctl((void *)pool, CTL_QUERY_PROGRAMMATIC, "post_initialize",
+                       nullptr, 0, CTL_QUERY_RUNNABLE, empty_args);
     va_end(empty_args);
     EXPECT_EQ(res, UMF_RESULT_SUCCESS);
 
diff --git a/test/pools/disjoint_pool_ctl.cpp b/test/pools/disjoint_pool_ctl.cpp

Original file line number	Diff line number	Diff line change
`@@ -205,8 +205,7 @@ CTL_WRITE_HANDLER(capacity)(void ctx, umf_ctl_query_source_t source, void arg,`
`205`	`205`	`return UMF_RESULT_ERROR_INVALID_ARGUMENT;`
`206`	`206`	`}`
`207`	`207`	`size_t value = (size_t )arg;`
`208`		`- umf_result_t ret =`
`209`		`- umfDisjointPoolParamsSetCapacity(&pool->params, value);`
	`208`	`+ umf_result_t ret = umfDisjointPoolParamsSetCapacity(&pool->params, value);`
`210`	`209`	`if (ret == UMF_RESULT_SUCCESS) {`
`211`	`210`	`pool->params_overridden \|= DP_OVERRIDE_CAPACITY;`
`212`	`211`	`}`
`@@ -279,8 +278,7 @@ CTL_WRITE_HANDLER(pool_trace)(void *ctx, umf_ctl_query_source_t source,`
`279`	`278`	`return UMF_RESULT_ERROR_INVALID_ARGUMENT;`
`280`	`279`	`}`
`281`	`280`	`int value = (int )arg;`
`282`		`- umf_result_t ret =`
`283`		`- umfDisjointPoolParamsSetTrace(&pool->params, value);`
	`281`	`+ umf_result_t ret = umfDisjointPoolParamsSetTrace(&pool->params, value);`
`284`	`282`	`if (ret == UMF_RESULT_SUCCESS) {`
`285`	`283`	`pool->params_overridden \|= DP_OVERRIDE_POOL_TRACE;`
`286`	`284`	`}`
`@@ -557,8 +555,8 @@ umf_result_t disjoint_pool_ctl(void *hPool,`
`557`	`555`	`umf_ctl_query_type_t queryType, va_list args) {`
`558`	`556`	`utils_init_once(&ctl_initialized, initialize_disjoint_ctl);`
`559`	`557`
`560`		`- return ctl_query(&disjoint_ctl_root, hPool, operationType, name,`
`561`		`- queryType, arg, size, args);`
	`558`	`+ return ctl_query(&disjoint_ctl_root, hPool, operationType, name, queryType,`
	`559`	`+ arg, size, args);`
`562`	`560`	`}`
`563`	`561`
`564`	`562`	`// Temporary solution for disabling memory poisoning. This is needed because`
Original file line number	Diff line number	Diff line change
`@@ -73,4 +73,3 @@ template <typename Func> void run_in_fork(Func &&func) {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`} // namespace umf_test`
`76`		`-`