diff --git a/benchmark/ubench.c b/benchmark/ubench.c index f70f19fb3..04695a0f4 100644 --- a/benchmark/ubench.c +++ b/benchmark/ubench.c @@ -53,7 +53,7 @@ #include "ubench.h" // BENCHMARK CONFIG #define N_ITERATIONS 1000 -#define ALLOC_SIZE (util_get_page_size()) +#define ALLOC_SIZE (utils_get_page_size()) // OS MEMORY PROVIDER CONFIG #define OS_MEMORY_PROVIDER_TRACE (0) diff --git a/src/base_alloc/base_alloc.c b/src/base_alloc/base_alloc.c index 144f5423b..353e5058d 100644 --- a/src/base_alloc/base_alloc.c +++ b/src/base_alloc/base_alloc.c @@ -36,7 +36,7 @@ struct umf_ba_chunk_t { struct umf_ba_main_pool_meta_t { size_t pool_size; // size of each pool (argument of each ba_os_alloc() call) size_t chunk_size; // size of all memory chunks in this pool - os_mutex_t free_lock; // lock of free_list + utils_mutex_t free_lock; // lock of free_list umf_ba_chunk_t *free_list; // list of free chunks size_t n_allocs; // number of allocated chunks #ifndef NDEBUG @@ -135,7 +135,7 @@ static void *ba_os_alloc_annotated(size_t pool_size) { umf_ba_pool_t *umf_ba_create(size_t size) { size_t chunk_size = ALIGN_UP(size, MEMORY_ALIGNMENT); - size_t mutex_size = ALIGN_UP(util_mutex_get_size(), MEMORY_ALIGNMENT); + size_t mutex_size = ALIGN_UP(utils_mutex_get_size(), MEMORY_ALIGNMENT); size_t metadata_size = sizeof(struct umf_ba_main_pool_meta_t); size_t pool_size = sizeof(void *) + metadata_size + mutex_size + @@ -168,10 +168,10 @@ umf_ba_pool_t *umf_ba_create(size_t size) { char *data_ptr = (char *)&pool->data; size_t size_left = pool_size - offsetof(umf_ba_pool_t, data); - util_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT); // init free_lock - os_mutex_t *mutex = util_mutex_init(&pool->metadata.free_lock); + utils_mutex_t *mutex = utils_mutex_init(&pool->metadata.free_lock); if (!mutex) { ba_os_free(pool, pool_size); return NULL; @@ -184,13 +184,13 @@ umf_ba_pool_t *umf_ba_create(size_t size) { } void *umf_ba_alloc(umf_ba_pool_t *pool) { - util_mutex_lock(&pool->metadata.free_lock); + utils_mutex_lock(&pool->metadata.free_lock); if (pool->metadata.free_list == NULL) { umf_ba_next_pool_t *new_pool = (umf_ba_next_pool_t *)ba_os_alloc_annotated( pool->metadata.pool_size); if (!new_pool) { - util_mutex_unlock(&pool->metadata.free_lock); + utils_mutex_unlock(&pool->metadata.free_lock); return NULL; } @@ -209,7 +209,7 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) { size_t size_left = pool->metadata.pool_size - offsetof(umf_ba_next_pool_t, data); - util_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT); ba_divide_memory_into_chunks(pool, data_ptr, size_left); } @@ -234,7 +234,7 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) { VALGRIND_DO_MALLOCLIKE_BLOCK(chunk, pool->metadata.chunk_size, 0, 0); utils_annotate_memory_undefined(chunk, pool->metadata.chunk_size); - util_mutex_unlock(&pool->metadata.free_lock); + utils_mutex_unlock(&pool->metadata.free_lock); return chunk; } @@ -269,7 +269,7 @@ void umf_ba_free(umf_ba_pool_t *pool, void *ptr) { umf_ba_chunk_t *chunk = (umf_ba_chunk_t *)ptr; - util_mutex_lock(&pool->metadata.free_lock); + utils_mutex_lock(&pool->metadata.free_lock); assert(pool_contains_pointer(pool, ptr)); chunk->next = pool->metadata.free_list; pool->metadata.free_list = chunk; @@ -281,14 +281,14 @@ void umf_ba_free(umf_ba_pool_t *pool, void *ptr) { VALGRIND_DO_FREELIKE_BLOCK(chunk, 0); utils_annotate_memory_inaccessible(chunk, pool->metadata.chunk_size); - util_mutex_unlock(&pool->metadata.free_lock); + utils_mutex_unlock(&pool->metadata.free_lock); } void umf_ba_destroy(umf_ba_pool_t *pool) { // Do not destroy if we are running in the proxy library, // because it may need those resources till // the very end of exiting the application. - if (pool->metadata.n_allocs && util_is_running_in_proxy_lib()) { + if (pool->metadata.n_allocs && utils_is_running_in_proxy_lib()) { return; } @@ -308,6 +308,6 @@ void umf_ba_destroy(umf_ba_pool_t *pool) { ba_os_free(current_pool, size); } - util_mutex_destroy_not_free(&pool->metadata.free_lock); + utils_mutex_destroy_not_free(&pool->metadata.free_lock); ba_os_free(pool, size); } diff --git a/src/base_alloc/base_alloc_global.c b/src/base_alloc/base_alloc_global.c index 12a93fd8b..ec6bc9fcb 100644 --- a/src/base_alloc/base_alloc_global.c +++ b/src/base_alloc/base_alloc_global.c @@ -149,7 +149,7 @@ static void *get_original_alloc(void *user_ptr, size_t *total_size, } void *umf_ba_global_aligned_alloc(size_t size, size_t alignment) { - util_init_once(&ba_is_initialized, umf_ba_create_global); + utils_init_once(&ba_is_initialized, umf_ba_create_global); if (size == 0) { return NULL; diff --git a/src/base_alloc/base_alloc_linear.c b/src/base_alloc/base_alloc_linear.c index be7b0943c..de4ac0b1e 100644 --- a/src/base_alloc/base_alloc_linear.c +++ b/src/base_alloc/base_alloc_linear.c @@ -31,7 +31,7 @@ typedef struct umf_ba_next_linear_pool_t umf_ba_next_linear_pool_t; // metadata is set and used only in the main (the first) pool typedef struct umf_ba_main_linear_pool_meta_t { size_t pool_size; // size of this pool (argument of ba_os_alloc() call) - os_mutex_t lock; + utils_mutex_t lock; char *data_ptr; size_t size_left; size_t pool_n_allocs; // number of allocations in this pool @@ -98,7 +98,7 @@ umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) { void *data_ptr = &pool->data; size_t size_left = pool_size - offsetof(umf_ba_linear_pool_t, data); - util_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT); pool->metadata.pool_size = pool_size; pool->metadata.data_ptr = data_ptr; @@ -109,7 +109,7 @@ umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) { _DEBUG_EXECUTE(pool->metadata.global_n_allocs = 0); // init lock - os_mutex_t *lock = util_mutex_init(&pool->metadata.lock); + utils_mutex_t *lock = utils_mutex_init(&pool->metadata.lock); if (!lock) { ba_os_free(pool, pool_size); return NULL; @@ -123,7 +123,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) { return NULL; } size_t aligned_size = ALIGN_UP(size, MEMORY_ALIGNMENT); - util_mutex_lock(&pool->metadata.lock); + utils_mutex_lock(&pool->metadata.lock); if (pool->metadata.size_left < aligned_size) { size_t pool_size = MINIMUM_LINEAR_POOL_SIZE; size_t usable_size = @@ -139,7 +139,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) { umf_ba_next_linear_pool_t *new_pool = (umf_ba_next_linear_pool_t *)ba_os_alloc(pool_size); if (!new_pool) { - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return NULL; } @@ -149,7 +149,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) { void *data_ptr = &new_pool->data; size_t size_left = new_pool->pool_size - offsetof(umf_ba_next_linear_pool_t, data); - util_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT); pool->metadata.data_ptr = data_ptr; pool->metadata.size_left = size_left; @@ -171,7 +171,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) { } _DEBUG_EXECUTE(pool->metadata.global_n_allocs++); _DEBUG_EXECUTE(ba_debug_checks(pool)); - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return ptr; } @@ -188,7 +188,7 @@ static inline int pool_contains_ptr(void *pool, size_t pool_size, // 0 - ptr belonged to the pool and was freed // -1 - ptr doesn't belong to the pool and wasn't freed int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) { - util_mutex_lock(&pool->metadata.lock); + utils_mutex_lock(&pool->metadata.lock); _DEBUG_EXECUTE(ba_debug_checks(pool)); if (pool_contains_ptr(pool, pool->metadata.pool_size, pool->data, ptr)) { pool->metadata.pool_n_allocs--; @@ -204,7 +204,7 @@ int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) { pool->metadata.pool_size = page_size; } _DEBUG_EXECUTE(ba_debug_checks(pool)); - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return 0; } @@ -227,14 +227,14 @@ int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) { ba_os_free(next_pool_ptr, size); } _DEBUG_EXECUTE(ba_debug_checks(pool)); - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return 0; } prev_pool = next_pool; next_pool = next_pool->next_pool; } - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); // ptr doesn't belong to the pool and wasn't freed return -1; } @@ -243,7 +243,7 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) { // Do not destroy if we are running in the proxy library, // because it may need those resources till // the very end of exiting the application. - if (util_is_running_in_proxy_lib()) { + if (utils_is_running_in_proxy_lib()) { return; } @@ -262,7 +262,7 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) { ba_os_free(current_pool, current_pool->pool_size); } - util_mutex_destroy_not_free(&pool->metadata.lock); + utils_mutex_destroy_not_free(&pool->metadata.lock); ba_os_free(pool, pool->metadata.pool_size); } @@ -272,12 +272,12 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) { // to the end of the pool if ptr belongs to the pool size_t umf_ba_linear_pool_contains_pointer(umf_ba_linear_pool_t *pool, void *ptr) { - util_mutex_lock(&pool->metadata.lock); + utils_mutex_lock(&pool->metadata.lock); char *cptr = (char *)ptr; if (cptr >= pool->data && cptr < ((char *)(pool)) + pool->metadata.pool_size) { size_t size = ((char *)(pool)) + pool->metadata.pool_size - cptr; - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return size; } @@ -286,12 +286,12 @@ size_t umf_ba_linear_pool_contains_pointer(umf_ba_linear_pool_t *pool, if (cptr >= next_pool->data && cptr < ((char *)(next_pool)) + next_pool->pool_size) { size_t size = ((char *)(next_pool)) + next_pool->pool_size - cptr; - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return size; } next_pool = next_pool->next_pool; } - util_mutex_unlock(&pool->metadata.lock); + utils_mutex_unlock(&pool->metadata.lock); return 0; } diff --git a/src/base_alloc/base_alloc_linux.c b/src/base_alloc/base_alloc_linux.c index 3e5456b2c..260eec5aa 100644 --- a/src/base_alloc/base_alloc_linux.c +++ b/src/base_alloc/base_alloc_linux.c @@ -37,6 +37,6 @@ void ba_os_free(void *ptr, size_t size) { static void _ba_os_init_page_size(void) { Page_size = sysconf(_SC_PAGE_SIZE); } size_t ba_os_get_page_size(void) { - util_init_once(&Page_size_is_initialized, _ba_os_init_page_size); + utils_init_once(&Page_size_is_initialized, _ba_os_init_page_size); return Page_size; } diff --git a/src/base_alloc/base_alloc_windows.c b/src/base_alloc/base_alloc_windows.c index 6f6c58fbc..2e9da23d9 100644 --- a/src/base_alloc/base_alloc_windows.c +++ b/src/base_alloc/base_alloc_windows.c @@ -28,6 +28,6 @@ static void _ba_os_init_page_size(void) { } size_t ba_os_get_page_size(void) { - util_init_once(&Page_size_is_initialized, _ba_os_init_page_size); + utils_init_once(&Page_size_is_initialized, _ba_os_init_page_size); return Page_size; } diff --git a/src/critnib/critnib.c b/src/critnib/critnib.c index 965ca03b9..62d14af73 100644 --- a/src/critnib/critnib.c +++ b/src/critnib/critnib.c @@ -130,25 +130,25 @@ struct critnib { uint64_t remove_count; - struct os_mutex_t mutex; /* writes/removes */ + struct utils_mutex_t mutex; /* writes/removes */ }; /* * atomic load */ static void load(void *src, void *dst) { - util_atomic_load_acquire((word *)src, (word *)dst); + utils_atomic_load_acquire((word *)src, (word *)dst); } static void load64(uint64_t *src, uint64_t *dst) { - util_atomic_load_acquire(src, dst); + utils_atomic_load_acquire(src, dst); } /* * atomic store */ static void store(void *dst, void *src) { - util_atomic_store_release((word *)dst, (word)src); + utils_atomic_store_release((word *)dst, (word)src); } /* @@ -187,7 +187,7 @@ struct critnib *critnib_new(void) { memset(c, 0, sizeof(struct critnib)); - void *mutex_ptr = util_mutex_init(&c->mutex); + void *mutex_ptr = utils_mutex_init(&c->mutex); if (!mutex_ptr) { goto err_free_critnib; } @@ -226,7 +226,7 @@ void critnib_delete(struct critnib *c) { delete_node(c, c->root); } - util_mutex_destroy_not_free(&c->mutex); + utils_mutex_destroy_not_free(&c->mutex); for (struct critnib_node *m = c->deleted_node; m;) { struct critnib_node *mm = m->child[0]; @@ -325,11 +325,11 @@ static struct critnib_leaf *alloc_leaf(struct critnib *__restrict c) { * Takes a global write lock but doesn't stall any readers. */ int critnib_insert(struct critnib *c, word key, void *value, int update) { - util_mutex_lock(&c->mutex); + utils_mutex_lock(&c->mutex); struct critnib_leaf *k = alloc_leaf(c); if (!k) { - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return ENOMEM; } @@ -345,7 +345,7 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) { if (!n) { store(&c->root, kn); - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return 0; } @@ -363,7 +363,7 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) { n = prev; store(&n->child[slice_index(key, n->shift)], kn); - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return 0; } @@ -377,22 +377,22 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) { if (update) { to_leaf(n)->value = value; - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return 0; } else { - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return EEXIST; } } /* and convert that to an index. */ - sh_t sh = util_mssb_index(at) & (sh_t) ~(SLICE - 1); + sh_t sh = utils_mssb_index(at) & (sh_t) ~(SLICE - 1); struct critnib_node *m = alloc_node(c); if (!m) { free_leaf(c, to_leaf(kn)); - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return ENOMEM; } @@ -408,7 +408,7 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) { m->path = key & path_mask(sh); store(parent, m); - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return 0; } @@ -420,14 +420,14 @@ void *critnib_remove(struct critnib *c, word key) { struct critnib_leaf *k; void *value = NULL; - util_mutex_lock(&c->mutex); + utils_mutex_lock(&c->mutex); struct critnib_node *n = c->root; if (!n) { goto not_found; } - word del = (util_atomic_increment(&c->remove_count) - 1) % DELETED_LIFE; + word del = (utils_atomic_increment(&c->remove_count) - 1) % DELETED_LIFE; free_node(c, c->pending_del_nodes[del]); free_leaf(c, c->pending_del_leaves[del]); c->pending_del_nodes[del] = NULL; @@ -490,7 +490,7 @@ void *critnib_remove(struct critnib *c, word key) { c->pending_del_leaves[del] = k; not_found: - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); return value; } @@ -813,9 +813,9 @@ static int iter(struct critnib_node *__restrict n, word min, word max, void critnib_iter(critnib *c, uintptr_t min, uintptr_t max, int (*func)(uintptr_t key, void *value, void *privdata), void *privdata) { - util_mutex_lock(&c->mutex); + utils_mutex_lock(&c->mutex); if (c->root) { iter(c->root, min, max, func, privdata); } - util_mutex_unlock(&c->mutex); + utils_mutex_unlock(&c->mutex); } diff --git a/src/libumf.c b/src/libumf.c index 1d99ab26a..2fcda07a0 100644 --- a/src/libumf.c +++ b/src/libumf.c @@ -22,8 +22,8 @@ umf_memory_tracker_handle_t TRACKER = NULL; static unsigned long long umfRefCount = 0; int umfInit(void) { - if (util_fetch_and_add64(&umfRefCount, 1) == 0) { - util_log_init(); + if (utils_fetch_and_add64(&umfRefCount, 1) == 0) { + utils_log_init(); TRACKER = umfMemoryTrackerCreate(); } @@ -31,7 +31,7 @@ int umfInit(void) { } void umfTearDown(void) { - if (util_fetch_and_add64(&umfRefCount, -1) == 1) { + if (utils_fetch_and_add64(&umfRefCount, -1) == 1) { #if !defined(_WIN32) && !defined(UMF_NO_HWLOC) umfMemspaceHostAllDestroy(); umfMemspaceHighestCapacityDestroy(); diff --git a/src/memspaces/memspace_highest_bandwidth.c b/src/memspaces/memspace_highest_bandwidth.c index 3fb721717..a6ea558d7 100644 --- a/src/memspaces/memspace_highest_bandwidth.c +++ b/src/memspaces/memspace_highest_bandwidth.c @@ -96,7 +96,7 @@ static void umfMemspaceHighestBandwidthInit(void) { } umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void) { - util_init_once(&UMF_MEMSPACE_HBW_INITIALIZED, - umfMemspaceHighestBandwidthInit); + utils_init_once(&UMF_MEMSPACE_HBW_INITIALIZED, + umfMemspaceHighestBandwidthInit); return UMF_MEMSPACE_HIGHEST_BANDWIDTH; } diff --git a/src/memspaces/memspace_highest_capacity.c b/src/memspaces/memspace_highest_capacity.c index 2469ba496..8a4e19148 100644 --- a/src/memspaces/memspace_highest_capacity.c +++ b/src/memspaces/memspace_highest_capacity.c @@ -68,7 +68,7 @@ static void umfMemspaceHighestCapacityInit(void) { } umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void) { - util_init_once(&UMF_MEMSPACE_HIGHEST_CAPACITY_INITIALIZED, - umfMemspaceHighestCapacityInit); + utils_init_once(&UMF_MEMSPACE_HIGHEST_CAPACITY_INITIALIZED, + umfMemspaceHighestCapacityInit); return UMF_MEMSPACE_HIGHEST_CAPACITY; } diff --git a/src/memspaces/memspace_host_all.c b/src/memspaces/memspace_host_all.c index 63d4611a8..09d5877c3 100644 --- a/src/memspaces/memspace_host_all.c +++ b/src/memspaces/memspace_host_all.c @@ -90,6 +90,6 @@ static void umfMemspaceHostAllInit(void) { } umf_const_memspace_handle_t umfMemspaceHostAllGet(void) { - util_init_once(&UMF_MEMSPACE_HOST_ALL_INITIALIZED, umfMemspaceHostAllInit); + utils_init_once(&UMF_MEMSPACE_HOST_ALL_INITIALIZED, umfMemspaceHostAllInit); return UMF_MEMSPACE_HOST_ALL; } diff --git a/src/memspaces/memspace_lowest_latency.c b/src/memspaces/memspace_lowest_latency.c index 9a34e3f83..52f8e7f36 100644 --- a/src/memspaces/memspace_lowest_latency.c +++ b/src/memspaces/memspace_lowest_latency.c @@ -96,7 +96,7 @@ static void umfMemspaceLowestLatencyInit(void) { } umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void) { - util_init_once(&UMF_MEMSPACE_LOWEST_LATENCY_INITIALIZED, - umfMemspaceLowestLatencyInit); + utils_init_once(&UMF_MEMSPACE_LOWEST_LATENCY_INITIALIZED, + umfMemspaceLowestLatencyInit); return UMF_MEMSPACE_LOWEST_LATENCY; } diff --git a/src/pool/pool_scalable.c b/src/pool/pool_scalable.c index cb5d5b157..ebf42493c 100644 --- a/src/pool/pool_scalable.c +++ b/src/pool/pool_scalable.c @@ -106,7 +106,7 @@ static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) { assert(tbb_callbacks); const char *lib_name = tbb_symbol[TBB_LIB_NAME]; - tbb_callbacks->lib_handle = util_open_library(lib_name, 0); + tbb_callbacks->lib_handle = utils_open_library(lib_name, 0); if (!tbb_callbacks->lib_handle) { LOG_ERR("%s required by Scalable Pool not found - install TBB malloc " "or make sure it is in the default search paths.", @@ -114,22 +114,22 @@ static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) { return -1; } - *(void **)&tbb_callbacks->pool_malloc = util_get_symbol_addr( + *(void **)&tbb_callbacks->pool_malloc = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_MALLOC], lib_name); - *(void **)&tbb_callbacks->pool_realloc = util_get_symbol_addr( + *(void **)&tbb_callbacks->pool_realloc = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_REALLOC], lib_name); *(void **)&tbb_callbacks->pool_aligned_malloc = - util_get_symbol_addr(tbb_callbacks->lib_handle, - tbb_symbol[TBB_POOL_ALIGNED_MALLOC], lib_name); - *(void **)&tbb_callbacks->pool_free = util_get_symbol_addr( + utils_get_symbol_addr(tbb_callbacks->lib_handle, + tbb_symbol[TBB_POOL_ALIGNED_MALLOC], lib_name); + *(void **)&tbb_callbacks->pool_free = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_FREE], lib_name); - *(void **)&tbb_callbacks->pool_create_v1 = util_get_symbol_addr( + *(void **)&tbb_callbacks->pool_create_v1 = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_CREATE_V1], lib_name); - *(void **)&tbb_callbacks->pool_destroy = util_get_symbol_addr( + *(void **)&tbb_callbacks->pool_destroy = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_DESTROY], lib_name); - *(void **)&tbb_callbacks->pool_identify = util_get_symbol_addr( + *(void **)&tbb_callbacks->pool_identify = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_IDENTIFY], lib_name); - *(void **)&tbb_callbacks->pool_msize = util_get_symbol_addr( + *(void **)&tbb_callbacks->pool_msize = utils_get_symbol_addr( tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_MSIZE], lib_name); if (!tbb_callbacks->pool_malloc || !tbb_callbacks->pool_realloc || @@ -137,7 +137,7 @@ static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) { !tbb_callbacks->pool_create_v1 || !tbb_callbacks->pool_destroy || !tbb_callbacks->pool_identify) { LOG_ERR("Could not find symbols in %s", lib_name); - util_close_library(tbb_callbacks->lib_handle); + utils_close_library(tbb_callbacks->lib_handle); return -1; } @@ -208,7 +208,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; pool_data->tbb_callbacks.pool_destroy(pool_data->tbb_pool); - util_close_library(pool_data->tbb_callbacks.lib_handle); + utils_close_library(pool_data->tbb_callbacks.lib_handle); umf_ba_global_free(pool_data); } diff --git a/src/provider/provider_cuda.c b/src/provider/provider_cuda.c index d72c47022..b7c4a308d 100644 --- a/src/provider/provider_cuda.c +++ b/src/provider/provider_cuda.c @@ -93,21 +93,21 @@ static void init_cu_global_state(void) { // NOTE: some symbols defined in the lib have _vX postfixes - it is // important to load the proper version of functions *(void **)&g_cu_ops.cuMemGetAllocationGranularity = - util_get_symbol_addr(0, "cuMemGetAllocationGranularity", lib_name); + utils_get_symbol_addr(0, "cuMemGetAllocationGranularity", lib_name); *(void **)&g_cu_ops.cuMemAlloc = - util_get_symbol_addr(0, "cuMemAlloc_v2", lib_name); + utils_get_symbol_addr(0, "cuMemAlloc_v2", lib_name); *(void **)&g_cu_ops.cuMemAllocHost = - util_get_symbol_addr(0, "cuMemAllocHost_v2", lib_name); + utils_get_symbol_addr(0, "cuMemAllocHost_v2", lib_name); *(void **)&g_cu_ops.cuMemAllocManaged = - util_get_symbol_addr(0, "cuMemAllocManaged", lib_name); + utils_get_symbol_addr(0, "cuMemAllocManaged", lib_name); *(void **)&g_cu_ops.cuMemFree = - util_get_symbol_addr(0, "cuMemFree_v2", lib_name); + utils_get_symbol_addr(0, "cuMemFree_v2", lib_name); *(void **)&g_cu_ops.cuMemFreeHost = - util_get_symbol_addr(0, "cuMemFreeHost", lib_name); + utils_get_symbol_addr(0, "cuMemFreeHost", lib_name); *(void **)&g_cu_ops.cuGetErrorName = - util_get_symbol_addr(0, "cuGetErrorName", lib_name); + utils_get_symbol_addr(0, "cuGetErrorName", lib_name); *(void **)&g_cu_ops.cuGetErrorString = - util_get_symbol_addr(0, "cuGetErrorString", lib_name); + utils_get_symbol_addr(0, "cuGetErrorString", lib_name); if (!g_cu_ops.cuMemGetAllocationGranularity || !g_cu_ops.cuMemAlloc || !g_cu_ops.cuMemAllocHost || !g_cu_ops.cuMemAllocManaged || @@ -136,7 +136,7 @@ static umf_result_t cu_memory_provider_initialize(void *params, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - util_init_once(&cu_is_initialized, init_cu_global_state); + utils_init_once(&cu_is_initialized, init_cu_global_state); if (Init_cu_global_state_failed) { LOG_ERR("Loading CUDA symbols failed"); return UMF_RESULT_ERROR_UNKNOWN; diff --git a/src/provider/provider_devdax_memory.c b/src/provider/provider_devdax_memory.c index 321c68d9c..ed0c2a25d 100644 --- a/src/provider/provider_devdax_memory.c +++ b/src/provider/provider_devdax_memory.c @@ -31,7 +31,7 @@ typedef struct devdax_memory_provider_t { size_t size; // size of the file used for memory mapping void *base; // base address of memory mapping size_t offset; // offset in the file used for memory mapping - os_mutex_t lock; // lock of ptr and offset + utils_mutex_t lock; // lock of ptr and offset unsigned protection; // combination of OS-specific protection flags } devdax_memory_provider_t; @@ -119,7 +119,7 @@ static umf_result_t devdax_initialize(void *params, void **provider) { } devdax_provider->size = in_params->size; - if (util_copy_path(in_params->path, devdax_provider->path, PATH_MAX)) { + if (utils_copy_path(in_params->path, devdax_provider->path, PATH_MAX)) { goto err_free_devdax_provider; } @@ -143,7 +143,7 @@ static umf_result_t devdax_initialize(void *params, void **provider) { LOG_DEBUG("devdax memory mapped (path=%s, size=%zu, addr=%p)", in_params->path, devdax_provider->size, devdax_provider->base); - if (util_mutex_init(&devdax_provider->lock) == NULL) { + if (utils_mutex_init(&devdax_provider->lock) == NULL) { LOG_ERR("lock init failed"); ret = UMF_RESULT_ERROR_UNKNOWN; goto err_unmap_devdax; @@ -167,17 +167,17 @@ static void devdax_finalize(void *provider) { } devdax_memory_provider_t *devdax_provider = provider; - util_mutex_destroy_not_free(&devdax_provider->lock); + utils_mutex_destroy_not_free(&devdax_provider->lock); utils_munmap(devdax_provider->base, devdax_provider->size); umf_ba_global_free(devdax_provider); } static int devdax_alloc_aligned(size_t length, size_t alignment, void *base, - size_t size, os_mutex_t *lock, void **out_addr, - size_t *offset) { + size_t size, utils_mutex_t *lock, + void **out_addr, size_t *offset) { assert(out_addr); - if (util_mutex_lock(lock)) { + if (utils_mutex_lock(lock)) { LOG_ERR("locking file offset failed"); return -1; } @@ -192,7 +192,7 @@ static int devdax_alloc_aligned(size_t length, size_t alignment, void *base, size_t new_offset = ptr - (uintptr_t)base + length; if (new_offset > size) { - util_mutex_unlock(lock); + utils_mutex_unlock(lock); LOG_ERR("cannot allocate more memory than the device DAX size: %zu", size); return -1; @@ -201,7 +201,7 @@ static int devdax_alloc_aligned(size_t length, size_t alignment, void *base, *offset = new_offset; *out_addr = (void *)ptr; - util_mutex_unlock(lock); + utils_mutex_unlock(lock); return 0; } @@ -295,7 +295,7 @@ static umf_result_t devdax_get_recommended_page_size(void *provider, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - *page_size = util_get_page_size(); + *page_size = utils_get_page_size(); return UMF_RESULT_SUCCESS; } diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c index 0936daaf0..757dcb1d0 100644 --- a/src/provider/provider_file_memory.c +++ b/src/provider/provider_file_memory.c @@ -26,7 +26,7 @@ #define TLS_MSG_BUF_LEN 1024 typedef struct file_memory_provider_t { - os_mutex_t lock; // lock for file parameters (size and offsets) + utils_mutex_t lock; // lock for file parameters (size and offsets) char path[PATH_MAX]; // a path to the file int fd; // file descriptor for memory mapping @@ -114,7 +114,7 @@ static umf_result_t file_initialize(void *params, void **provider) { umf_file_memory_provider_params_t *in_params = (umf_file_memory_provider_params_t *)params; - size_t page_size = util_get_page_size(); + size_t page_size = utils_get_page_size(); if (in_params->path == NULL) { LOG_ERR("file path is missing"); @@ -136,7 +136,7 @@ static umf_result_t file_initialize(void *params, void **provider) { goto err_free_file_provider; } - if (util_copy_path(in_params->path, file_provider->path, PATH_MAX)) { + if (utils_copy_path(in_params->path, file_provider->path, PATH_MAX)) { goto err_free_file_provider; } @@ -158,7 +158,7 @@ static umf_result_t file_initialize(void *params, void **provider) { LOG_DEBUG("size of the file %s is: %zu", in_params->path, file_provider->size_fd); - if (util_mutex_init(&file_provider->lock) == NULL) { + if (utils_mutex_init(&file_provider->lock) == NULL) { LOG_ERR("lock init failed"); ret = UMF_RESULT_ERROR_UNKNOWN; goto err_close_fd; @@ -185,7 +185,7 @@ static umf_result_t file_initialize(void *params, void **provider) { err_delete_fd_offset_map: critnib_delete(file_provider->fd_offset_map); err_mutex_destroy_not_free: - util_mutex_destroy_not_free(&file_provider->lock); + utils_mutex_destroy_not_free(&file_provider->lock); err_close_fd: utils_close_fd(file_provider->fd); err_free_file_provider: @@ -211,7 +211,7 @@ static void file_finalize(void *provider) { key = rkey; } - util_mutex_destroy_not_free(&file_provider->lock); + utils_mutex_destroy_not_free(&file_provider->lock); utils_close_fd(file_provider->fd); critnib_delete(file_provider->fd_offset_map); critnib_delete(file_provider->mmaps); @@ -291,7 +291,7 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider, umf_result_t umf_result; - if (util_mutex_lock(&file_provider->lock)) { + if (utils_mutex_lock(&file_provider->lock)) { LOG_ERR("locking file data failed"); return UMF_RESULT_ERROR_UNKNOWN; } @@ -299,7 +299,7 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider, if (file_provider->size_mmap - file_provider->offset_mmap < size) { umf_result = file_mmap_aligned(file_provider, size, alignment); if (umf_result != UMF_RESULT_SUCCESS) { - util_mutex_unlock(&file_provider->lock); + utils_mutex_unlock(&file_provider->lock); return umf_result; } } @@ -321,7 +321,7 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider, if (file_provider->size_mmap - new_offset_mmap < size) { umf_result = file_mmap_aligned(file_provider, size, alignment); if (umf_result != UMF_RESULT_SUCCESS) { - util_mutex_unlock(&file_provider->lock); + utils_mutex_unlock(&file_provider->lock); return umf_result; } } @@ -334,7 +334,7 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider, *out_addr = (void *)new_aligned_ptr; - util_mutex_unlock(&file_provider->lock); + utils_mutex_unlock(&file_provider->lock); return UMF_RESULT_SUCCESS; } @@ -436,7 +436,7 @@ static umf_result_t file_get_recommended_page_size(void *provider, size_t size, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - *page_size = util_get_page_size(); + *page_size = utils_get_page_size(); return UMF_RESULT_SUCCESS; } diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c index 19a0dfb0d..6c2cf84b1 100644 --- a/src/provider/provider_level_zero.c +++ b/src/provider/provider_level_zero.c @@ -92,25 +92,25 @@ static void init_ze_global_state(void) { // check if Level Zero shared library is already loaded // we pass 0 as a handle to search the global symbol table *(void **)&g_ze_ops.zeMemAllocHost = - util_get_symbol_addr(0, "zeMemAllocHost", lib_name); + utils_get_symbol_addr(0, "zeMemAllocHost", lib_name); *(void **)&g_ze_ops.zeMemAllocDevice = - util_get_symbol_addr(0, "zeMemAllocDevice", lib_name); + utils_get_symbol_addr(0, "zeMemAllocDevice", lib_name); *(void **)&g_ze_ops.zeMemAllocShared = - util_get_symbol_addr(0, "zeMemAllocShared", lib_name); + utils_get_symbol_addr(0, "zeMemAllocShared", lib_name); *(void **)&g_ze_ops.zeMemFree = - util_get_symbol_addr(0, "zeMemFree", lib_name); + utils_get_symbol_addr(0, "zeMemFree", lib_name); *(void **)&g_ze_ops.zeMemGetIpcHandle = - util_get_symbol_addr(0, "zeMemGetIpcHandle", lib_name); + utils_get_symbol_addr(0, "zeMemGetIpcHandle", lib_name); *(void **)&g_ze_ops.zeMemPutIpcHandle = - util_get_symbol_addr(0, "zeMemPutIpcHandle", lib_name); + utils_get_symbol_addr(0, "zeMemPutIpcHandle", lib_name); *(void **)&g_ze_ops.zeMemOpenIpcHandle = - util_get_symbol_addr(0, "zeMemOpenIpcHandle", lib_name); + utils_get_symbol_addr(0, "zeMemOpenIpcHandle", lib_name); *(void **)&g_ze_ops.zeMemCloseIpcHandle = - util_get_symbol_addr(0, "zeMemCloseIpcHandle", lib_name); + utils_get_symbol_addr(0, "zeMemCloseIpcHandle", lib_name); *(void **)&g_ze_ops.zeContextMakeMemoryResident = - util_get_symbol_addr(0, "zeContextMakeMemoryResident", lib_name); + utils_get_symbol_addr(0, "zeContextMakeMemoryResident", lib_name); *(void **)&g_ze_ops.zeDeviceGetProperties = - util_get_symbol_addr(0, "zeDeviceGetProperties", lib_name); + utils_get_symbol_addr(0, "zeDeviceGetProperties", lib_name); if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice || !g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree || @@ -148,7 +148,7 @@ static umf_result_t ze_memory_provider_initialize(void *params, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - util_init_once(&ze_is_initialized, init_ze_global_state); + utils_init_once(&ze_is_initialized, init_ze_global_state); if (Init_ze_global_state_failed) { LOG_ERR("Loading Level Zero symbols failed"); return UMF_RESULT_ERROR_UNKNOWN; @@ -188,7 +188,7 @@ static void ze_memory_provider_finalize(void *provider) { return; } - util_init_once(&ze_is_initialized, init_ze_global_state); + utils_init_once(&ze_is_initialized, init_ze_global_state); umf_ba_global_free(provider); // portable version of "ze_is_initialized = UTIL_ONCE_FLAG_INIT;" diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c index fe2505dce..8c18e98cc 100644 --- a/src/provider/provider_os_memory.c +++ b/src/provider/provider_os_memory.c @@ -501,7 +501,7 @@ static umf_result_t os_initialize(void *params, void **provider) { } if (os_provider->fd > 0) { - if (util_mutex_init(&os_provider->lock_fd) == NULL) { + if (utils_mutex_init(&os_provider->lock_fd) == NULL) { LOG_ERR("initializing the file size lock failed"); ret = UMF_RESULT_ERROR_UNKNOWN; goto err_destroy_bitmaps; @@ -546,7 +546,7 @@ static void os_finalize(void *provider) { os_memory_provider_t *os_provider = provider; if (os_provider->fd > 0) { - util_mutex_destroy_not_free(&os_provider->lock_fd); + utils_mutex_destroy_not_free(&os_provider->lock_fd); } critnib_delete(os_provider->fd_offset_map); @@ -611,7 +611,7 @@ static inline void assert_is_page_aligned(uintptr_t ptr, size_t page_size) { static int utils_mmap_aligned(void *hint_addr, size_t length, size_t alignment, size_t page_size, int prot, int flag, int fd, - size_t max_fd_size, os_mutex_t *lock_fd, + size_t max_fd_size, utils_mutex_t *lock_fd, void **out_addr, size_t *fd_size, size_t *fd_offset) { assert(out_addr); @@ -629,20 +629,20 @@ static int utils_mmap_aligned(void *hint_addr, size_t length, size_t alignment, *fd_offset = 0; if (fd > 0) { - if (util_mutex_lock(lock_fd)) { + if (utils_mutex_lock(lock_fd)) { LOG_ERR("locking file size failed"); return -1; } if (*fd_size + extended_length > max_fd_size) { - util_mutex_unlock(lock_fd); + utils_mutex_unlock(lock_fd); LOG_ERR("cannot grow a file size beyond %zu", max_fd_size); return -1; } *fd_offset = *fd_size; *fd_size += extended_length; - util_mutex_unlock(lock_fd); + utils_mutex_unlock(lock_fd); } void *ptr = @@ -815,7 +815,7 @@ static membind_t membindFirst(os_memory_provider_t *provider, void *addr, if (provider->mode == UMF_NUMA_MODE_INTERLEAVE) { assert(provider->part_size != 0); - size_t s = util_fetch_and_add64(&provider->alloc_sum, size); + size_t s = utils_fetch_and_add64(&provider->alloc_sum, size); membind.node = (s / provider->part_size) % provider->nodeset_len; membind.bitmap = provider->nodeset[membind.node]; membind.bind_size = ALIGN_UP(provider->part_size, membind.page_size); @@ -1034,7 +1034,7 @@ static umf_result_t os_get_recommended_page_size(void *provider, size_t size, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - *page_size = util_get_page_size(); + *page_size = utils_get_page_size(); return UMF_RESULT_SUCCESS; } diff --git a/src/provider/provider_os_memory_internal.h b/src/provider/provider_os_memory_internal.h index e01a3de75..41b4ea11a 100644 --- a/src/provider/provider_os_memory_internal.h +++ b/src/provider/provider_os_memory_internal.h @@ -31,10 +31,10 @@ typedef struct os_memory_provider_t { unsigned visibility; // memory visibility mode // a name of a shared memory file (valid only in case of the shared memory visibility) char shm_name[NAME_MAX]; - int fd; // file descriptor for memory mapping - size_t size_fd; // size of file used for memory mapping - size_t max_size_fd; // maximum size of file used for memory mapping - os_mutex_t lock_fd; // lock for updating file size + int fd; // file descriptor for memory mapping + size_t size_fd; // size of file used for memory mapping + size_t max_size_fd; // maximum size of file used for memory mapping + utils_mutex_t lock_fd; // lock for updating file size // A critnib map storing (ptr, fd_offset + 1) pairs. We add 1 to fd_offset // in order to be able to store fd_offset equal 0, because diff --git a/src/provider/provider_tracking.c b/src/provider/provider_tracking.c index 726f7d4e8..5e1db9d14 100644 --- a/src/provider/provider_tracking.c +++ b/src/provider/provider_tracking.c @@ -184,7 +184,7 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr, splitValue->pool = provider->pool; splitValue->size = firstSize; - int r = util_mutex_lock(&provider->hTracker->splitMergeMutex); + int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex); if (r) { goto err_lock; } @@ -235,12 +235,12 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr, // free the original value umf_ba_free(provider->hTracker->tracker_allocator, value); - util_mutex_unlock(&provider->hTracker->splitMergeMutex); + utils_mutex_unlock(&provider->hTracker->splitMergeMutex); return UMF_RESULT_SUCCESS; err: - util_mutex_unlock(&provider->hTracker->splitMergeMutex); + utils_mutex_unlock(&provider->hTracker->splitMergeMutex); err_lock: umf_ba_free(provider->hTracker->tracker_allocator, splitValue); return ret; @@ -262,7 +262,7 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr, mergedValue->pool = provider->pool; mergedValue->size = totalSize; - int r = util_mutex_lock(&provider->hTracker->splitMergeMutex); + int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex); if (r) { goto err_lock; } @@ -316,12 +316,12 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr, umf_ba_free(provider->hTracker->tracker_allocator, erasedhighValue); - util_mutex_unlock(&provider->hTracker->splitMergeMutex); + utils_mutex_unlock(&provider->hTracker->splitMergeMutex); return UMF_RESULT_SUCCESS; err: - util_mutex_unlock(&provider->hTracker->splitMergeMutex); + utils_mutex_unlock(&provider->hTracker->splitMergeMutex); err_lock: umf_ba_free(provider->hTracker->tracker_allocator, mergedValue); return ret; @@ -414,7 +414,7 @@ static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker, // Do not assert if we are running in the proxy library, // because it may need those resources till // the very end of exiting the application. - if (!util_is_running_in_proxy_lib()) { + if (!utils_is_running_in_proxy_lib()) { if (pool) { LOG_ERR("tracking provider of pool %p is not empty! " "(%zu items left)", @@ -710,7 +710,7 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) { handle->tracker_allocator = tracker_allocator; - void *mutex_ptr = util_mutex_init(&handle->splitMergeMutex); + void *mutex_ptr = utils_mutex_init(&handle->splitMergeMutex); if (!mutex_ptr) { goto err_destroy_tracker_allocator; } @@ -726,7 +726,7 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) { return handle; err_destroy_mutex: - util_mutex_destroy_not_free(&handle->splitMergeMutex); + utils_mutex_destroy_not_free(&handle->splitMergeMutex); err_destroy_tracker_allocator: umf_ba_destroy(tracker_allocator); err_free_handle: @@ -742,7 +742,7 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) { // Do not destroy if we are running in the proxy library, // because it may need those resources till // the very end of exiting the application. - if (util_is_running_in_proxy_lib()) { + if (utils_is_running_in_proxy_lib()) { return; } @@ -755,7 +755,7 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) { // and used in many places. critnib_delete(handle->map); handle->map = NULL; - util_mutex_destroy_not_free(&handle->splitMergeMutex); + utils_mutex_destroy_not_free(&handle->splitMergeMutex); umf_ba_destroy(handle->tracker_allocator); handle->tracker_allocator = NULL; umf_ba_global_free(handle); diff --git a/src/provider/provider_tracking.h b/src/provider/provider_tracking.h index 585b4fe5c..f020c3da8 100644 --- a/src/provider/provider_tracking.h +++ b/src/provider/provider_tracking.h @@ -28,7 +28,7 @@ extern "C" { struct umf_memory_tracker_t { umf_ba_pool_t *tracker_allocator; critnib *map; - os_mutex_t splitMergeMutex; + utils_mutex_t splitMergeMutex; }; typedef struct umf_memory_tracker_t *umf_memory_tracker_handle_t; diff --git a/src/proxy_lib/proxy_lib.c b/src/proxy_lib/proxy_lib.c index 4819313d1..ca8d69315 100644 --- a/src/proxy_lib/proxy_lib.c +++ b/src/proxy_lib/proxy_lib.c @@ -59,7 +59,7 @@ #define UTIL_ONCE_FLAG INIT_ONCE #define UTIL_ONCE_FLAG_INIT INIT_ONCE_STATIC_INIT -void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)); +void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)); #else /* Linux *************************************************/ @@ -108,7 +108,7 @@ static __TLS int was_called_from_umfPool = 0; /*****************************************************************************/ void proxy_lib_create_common(void) { - util_log_init(); + utils_log_init(); umf_os_memory_provider_params_t os_params = umfOsMemoryProviderParamsDefault(); umf_result_t umf_result; @@ -116,14 +116,14 @@ void proxy_lib_create_common(void) { #ifndef _WIN32 char shm_name[NAME_MAX]; - if (util_env_var_has_str("UMF_PROXY", "page.disposition=shared-fd")) { + if (utils_env_var_has_str("UMF_PROXY", "page.disposition=shared-fd")) { LOG_DEBUG("proxy_lib: using the MAP_SHARED visibility mode with the " "file descriptor duplication"); os_params.visibility = UMF_MEM_MAP_SHARED; os_params.shm_name = NULL; - } else if (util_env_var_has_str("UMF_PROXY", - "page.disposition=shared-shm")) { + } else if (utils_env_var_has_str("UMF_PROXY", + "page.disposition=shared-shm")) { LOG_DEBUG("proxy_lib: using the MAP_SHARED visibility mode with the " "named shared memory"); os_params.visibility = UMF_MEM_MAP_SHARED; @@ -157,7 +157,7 @@ void proxy_lib_create_common(void) { } void proxy_lib_destroy_common(void) { - if (util_is_running_in_proxy_lib()) { + if (utils_is_running_in_proxy_lib()) { // We cannot destroy 'Base_alloc_leak' nor 'Proxy_pool' nor 'OS_memory_provider', // because it could lead to use-after-free in the program's unloader // (for example _dl_fini() on Linux). @@ -209,7 +209,7 @@ static void ba_leak_create(void) { Base_alloc_leak = umf_ba_linear_create(0); } // it does not implement destroy(), because we cannot destroy non-freed memory static void ba_leak_init_once(void) { - util_init_once(&Base_alloc_leak_initialized, ba_leak_create); + utils_init_once(&Base_alloc_leak_initialized, ba_leak_create); } static inline void *ba_leak_malloc(size_t size) { diff --git a/src/topology.c b/src/topology.c index 79caffdb6..eab7992ce 100644 --- a/src/topology.c +++ b/src/topology.c @@ -41,6 +41,6 @@ static void umfCreateTopology(void) { } hwloc_topology_t umfGetTopology(void) { - util_init_once(&topology_initialized, umfCreateTopology); + utils_init_once(&topology_initialized, umfCreateTopology); return topology; } diff --git a/src/utils/utils_common.c b/src/utils/utils_common.c index 5ae1be3a1..cf1a953df 100644 --- a/src/utils/utils_common.c +++ b/src/utils/utils_common.c @@ -13,7 +13,7 @@ #include "utils_common.h" // align a pointer and a size -void util_align_ptr_size(void **ptr, size_t *size, size_t alignment) { +void utils_align_ptr_size(void **ptr, size_t *size, size_t alignment) { uintptr_t p = (uintptr_t)*ptr; size_t s = *size; @@ -31,7 +31,7 @@ void util_align_ptr_size(void **ptr, size_t *size, size_t alignment) { *size = s; } -int util_env_var_has_str(const char *envvar, const char *str) { +int utils_env_var_has_str(const char *envvar, const char *str) { char *value = getenv(envvar); if (value && strstr(value, str)) { return 1; @@ -41,12 +41,12 @@ int util_env_var_has_str(const char *envvar, const char *str) { } // check if we are running in the proxy library -int util_is_running_in_proxy_lib(void) { - return util_env_var_has_str("LD_PRELOAD", "libumf_proxy.so"); +int utils_is_running_in_proxy_lib(void) { + return utils_env_var_has_str("LD_PRELOAD", "libumf_proxy.so"); } -const char *util_parse_var(const char *var, const char *option, - const char **extraArg) { +const char *utils_parse_var(const char *var, const char *option, + const char **extraArg) { const char *found = strstr(var, option); // ensure that found string is first on list or it's a separating semicolon if (!found) { @@ -76,7 +76,7 @@ const char *util_parse_var(const char *var, const char *option, return found; } -int util_copy_path(const char *in_path, char out_path[], size_t path_max) { +int utils_copy_path(const char *in_path, char out_path[], size_t path_max) { // (- 1) because there should be a room for the terminating null byte ('\0') size_t max_len = path_max - 1; diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h index a9796415f..a58614061 100644 --- a/src/utils/utils_common.h +++ b/src/utils/utils_common.h @@ -54,9 +54,9 @@ typedef enum umf_purge_advise_t { #endif /* _WIN32 */ // Check if the environment variable contains the given string. -int util_env_var_has_str(const char *envvar, const char *str); +int utils_env_var_has_str(const char *envvar, const char *str); -// util_parse_var - Parses var for a prefix, +// utils_parse_var - Parses var for a prefix, // optionally identifying a following argument. // Parameters: // - var: String to parse in "option1;option2,arg2;..." format, with options @@ -70,16 +70,16 @@ int util_env_var_has_str(const char *envvar, const char *str); // // IMPORTANT: Both extraArg and return values are pointers within var, // and are not null-terminated. -const char *util_parse_var(const char *var, const char *option, - const char **extraArg); +const char *utils_parse_var(const char *var, const char *option, + const char **extraArg); // check if we are running in the proxy library -int util_is_running_in_proxy_lib(void); +int utils_is_running_in_proxy_lib(void); -size_t util_get_page_size(void); +size_t utils_get_page_size(void); // align a pointer and a size -void util_align_ptr_size(void **ptr, size_t *size, size_t alignment); +void utils_align_ptr_size(void **ptr, size_t *size, size_t alignment); // get the current process ID int utils_getpid(void); @@ -93,7 +93,7 @@ int utils_close_fd(int fd); // obtain a duplicate of another process's file descriptor umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out); -int util_copy_path(const char *in_path, char out_path[], size_t path_max); +int utils_copy_path(const char *in_path, char out_path[], size_t path_max); umf_result_t utils_translate_flags(unsigned in_flags, unsigned max, umf_result_t (*translate_flag)(unsigned, diff --git a/src/utils/utils_concurrency.h b/src/utils/utils_concurrency.h index dcc67dc42..f48c6f910 100644 --- a/src/utils/utils_concurrency.h +++ b/src/utils/utils_concurrency.h @@ -36,19 +36,19 @@ extern "C" { #endif -typedef struct os_mutex_t { +typedef struct utils_mutex_t { #ifdef _WIN32 CRITICAL_SECTION lock; #else pthread_mutex_t lock; #endif -} os_mutex_t; +} utils_mutex_t; -size_t util_mutex_get_size(void); -os_mutex_t *util_mutex_init(void *ptr); -void util_mutex_destroy_not_free(os_mutex_t *m); -int util_mutex_lock(os_mutex_t *mutex); -int util_mutex_unlock(os_mutex_t *mutex); +size_t utils_mutex_get_size(void); +utils_mutex_t *utils_mutex_init(void *ptr); +void utils_mutex_destroy_not_free(utils_mutex_t *m); +int utils_mutex_lock(utils_mutex_t *mutex); +int utils_mutex_unlock(utils_mutex_t *mutex); #if defined(_WIN32) #define UTIL_ONCE_FLAG INIT_ONCE @@ -58,50 +58,50 @@ int util_mutex_unlock(os_mutex_t *mutex); #define UTIL_ONCE_FLAG_INIT PTHREAD_ONCE_INIT #endif -void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)); +void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)); #if defined(_WIN32) -static __inline unsigned char util_lssb_index(long long value) { +static __inline unsigned char utils_lssb_index(long long value) { unsigned long ret; _BitScanForward64(&ret, value); return (unsigned char)ret; } -static __inline unsigned char util_mssb_index(long long value) { +static __inline unsigned char utils_mssb_index(long long value) { unsigned long ret; _BitScanReverse64(&ret, value); return (unsigned char)ret; } // There is no good way to do atomic_load on windows... -#define util_atomic_load_acquire(object, dest) \ +#define utils_atomic_load_acquire(object, dest) \ do { \ *dest = InterlockedOr64Acquire((LONG64 volatile *)object, 0); \ } while (0) -#define util_atomic_store_release(object, desired) \ +#define utils_atomic_store_release(object, desired) \ InterlockedExchange64((LONG64 volatile *)object, (LONG64)desired) -#define util_atomic_increment(object) \ +#define utils_atomic_increment(object) \ InterlockedIncrement64((LONG64 volatile *)object) -#define util_fetch_and_add64(ptr, value) \ +#define utils_fetch_and_add64(ptr, value) \ InterlockedExchangeAdd64((LONG64 *)(ptr), value) #else -#define util_lssb_index(x) ((unsigned char)__builtin_ctzll(x)) -#define util_mssb_index(x) ((unsigned char)(63 - __builtin_clzll(x))) -#define util_atomic_load_acquire(object, dest) \ +#define utils_lssb_index(x) ((unsigned char)__builtin_ctzll(x)) +#define utils_mssb_index(x) ((unsigned char)(63 - __builtin_clzll(x))) +#define utils_atomic_load_acquire(object, dest) \ do { \ utils_annotate_acquire((void *)object); \ __atomic_load(object, dest, memory_order_acquire); \ } while (0) -#define util_atomic_store_release(object, desired) \ +#define utils_atomic_store_release(object, desired) \ do { \ __atomic_store_n(object, desired, memory_order_release); \ utils_annotate_release((void *)object); \ } while (0) -#define util_atomic_increment(object) \ +#define utils_atomic_increment(object) \ __atomic_add_fetch(object, 1, __ATOMIC_ACQ_REL) -#define util_fetch_and_add64 __sync_fetch_and_add +#define utils_fetch_and_add64 __sync_fetch_and_add #endif #ifdef __cplusplus diff --git a/src/utils/utils_linux_common.c b/src/utils/utils_linux_common.c index 1ee5cccc8..f5f76be21 100644 --- a/src/utils/utils_linux_common.c +++ b/src/utils/utils_linux_common.c @@ -168,7 +168,7 @@ static int syscall_memfd_create(void) { int utils_create_anonymous_fd(void) { int fd = -1; - if (!util_env_var_has_str("UMF_MEM_FD_FUNC", "memfd_create")) { + if (!utils_env_var_has_str("UMF_MEM_FD_FUNC", "memfd_create")) { fd = syscall_memfd_secret(); if (fd > 0) { return fd; diff --git a/src/utils/utils_load_library.c b/src/utils/utils_load_library.c index cc5fe29fc..2c13acc8d 100644 --- a/src/utils/utils_load_library.c +++ b/src/utils/utils_load_library.c @@ -28,19 +28,19 @@ #ifdef _WIN32 -void *util_open_library(const char *filename, int userFlags) { +void *utils_open_library(const char *filename, int userFlags) { (void)userFlags; //unused for win return LoadLibrary(TEXT(filename)); } -int util_close_library(void *handle) { +int utils_close_library(void *handle) { // If the FreeLibrary function succeeds, the return value is nonzero. // If the FreeLibrary function fails, the return value is zero. return (FreeLibrary((HMODULE)handle) == 0); } -void *util_get_symbol_addr(void *handle, const char *symbol, - const char *libname) { +void *utils_get_symbol_addr(void *handle, const char *symbol, + const char *libname) { if (!handle) { if (libname == NULL) { return NULL; @@ -52,7 +52,7 @@ void *util_get_symbol_addr(void *handle, const char *symbol, #else /* Linux */ -void *util_open_library(const char *filename, int userFlags) { +void *utils_open_library(const char *filename, int userFlags) { int dlopenFlags = RTLD_LAZY; if (userFlags & UMF_UTIL_OPEN_LIBRARY_GLOBAL) { dlopenFlags |= RTLD_GLOBAL; @@ -60,10 +60,10 @@ void *util_open_library(const char *filename, int userFlags) { return dlopen(filename, dlopenFlags); } -int util_close_library(void *handle) { return dlclose(handle); } +int utils_close_library(void *handle) { return dlclose(handle); } -void *util_get_symbol_addr(void *handle, const char *symbol, - const char *libname) { +void *utils_get_symbol_addr(void *handle, const char *symbol, + const char *libname) { (void)libname; //unused if (!handle) { handle = RTLD_DEFAULT; diff --git a/src/utils/utils_load_library.h b/src/utils/utils_load_library.h index c066b548f..3206183f5 100644 --- a/src/utils/utils_load_library.h +++ b/src/utils/utils_load_library.h @@ -19,10 +19,10 @@ extern "C" { #endif #define UMF_UTIL_OPEN_LIBRARY_GLOBAL 1 -void *util_open_library(const char *filename, int userFlags); -int util_close_library(void *handle); -void *util_get_symbol_addr(void *handle, const char *symbol, - const char *libname); +void *utils_open_library(const char *filename, int userFlags); +int utils_close_library(void *handle); +void *utils_get_symbol_addr(void *handle, const char *symbol, + const char *libname); #ifdef __cplusplus } diff --git a/src/utils/utils_log.c b/src/utils/utils_log.c index ca16014f0..bdb9ce823 100644 --- a/src/utils/utils_log.c +++ b/src/utils/utils_log.c @@ -40,14 +40,14 @@ typedef struct { int timestamp; int pid; - util_log_level_t level; - util_log_level_t flushLevel; + utils_log_level_t level; + utils_log_level_t flushLevel; FILE *output; -} util_log_config_t; +} utils_log_config_t; -util_log_config_t loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL}; +utils_log_config_t loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL}; -static const char *level_to_str(util_log_level_t l) { +static const char *level_to_str(utils_log_level_t l) { switch (l) { case LOG_DEBUG: return "DEBUG"; @@ -73,9 +73,9 @@ static const char *level_to_str(util_log_level_t l) { #pragma warning(disable : 6262) #endif // _MSC_VER -static void util_log_internal(util_log_level_t level, int perror, - const char *func, const char *format, - va_list args) { +static void utils_log_internal(utils_log_level_t level, int perror, + const char *func, const char *format, + va_list args) { if (!loggerConfig.output && level != LOG_FATAL) { return; //logger not enabled } @@ -203,25 +203,25 @@ static void util_log_internal(util_log_level_t level, int perror, #pragma warning(pop) #endif // _MSC_VER -void util_log(util_log_level_t level, const char *func, const char *format, - ...) { +void utils_log(utils_log_level_t level, const char *func, const char *format, + ...) { va_list args; va_start(args, format); - util_log_internal(level, 0, func, format, args); + utils_log_internal(level, 0, func, format, args); va_end(args); } -void util_plog(util_log_level_t level, const char *func, const char *format, - ...) { +void utils_plog(utils_log_level_t level, const char *func, const char *format, + ...) { va_list args; va_start(args, format); - util_log_internal(level, 1, func, format, args); + utils_log_internal(level, 1, func, format, args); va_end(args); } static const char *bool_to_str(int b) { return b ? "yes" : "no"; } -void util_log_init(void) { +void utils_log_init(void) { const char *envVar = getenv("UMF_LOG"); if (!envVar) { @@ -229,11 +229,11 @@ void util_log_init(void) { } const char *arg; - if (util_parse_var(envVar, "output:stdout", NULL)) { + if (utils_parse_var(envVar, "output:stdout", NULL)) { loggerConfig.output = stdout; - } else if (util_parse_var(envVar, "output:stderr", NULL)) { + } else if (utils_parse_var(envVar, "output:stderr", NULL)) { loggerConfig.output = stderr; - } else if (util_parse_var(envVar, "output:file", &arg)) { + } else if (utils_parse_var(envVar, "output:file", &arg)) { loggerConfig.output = NULL; const char *argEnd = strstr(arg, ";"); char file[MAX_FILE_PATH + 1]; @@ -269,39 +269,39 @@ void util_log_init(void) { return; } - if (util_parse_var(envVar, "timestamp:yes", NULL)) { + if (utils_parse_var(envVar, "timestamp:yes", NULL)) { loggerConfig.timestamp = 1; - } else if (util_parse_var(envVar, "timestamp:no", NULL)) { + } else if (utils_parse_var(envVar, "timestamp:no", NULL)) { loggerConfig.timestamp = 0; } - if (util_parse_var(envVar, "pid:yes", NULL)) { + if (utils_parse_var(envVar, "pid:yes", NULL)) { loggerConfig.pid = 1; - } else if (util_parse_var(envVar, "pid:no", NULL)) { + } else if (utils_parse_var(envVar, "pid:no", NULL)) { loggerConfig.pid = 0; } - if (util_parse_var(envVar, "level:debug", NULL)) { + if (utils_parse_var(envVar, "level:debug", NULL)) { loggerConfig.level = LOG_DEBUG; - } else if (util_parse_var(envVar, "level:info", NULL)) { + } else if (utils_parse_var(envVar, "level:info", NULL)) { loggerConfig.level = LOG_INFO; - } else if (util_parse_var(envVar, "level:warning", NULL)) { + } else if (utils_parse_var(envVar, "level:warning", NULL)) { loggerConfig.level = LOG_WARNING; - } else if (util_parse_var(envVar, "level:error", NULL)) { + } else if (utils_parse_var(envVar, "level:error", NULL)) { loggerConfig.level = LOG_ERROR; - } else if (util_parse_var(envVar, "level:fatal", NULL)) { + } else if (utils_parse_var(envVar, "level:fatal", NULL)) { loggerConfig.level = LOG_FATAL; } - if (util_parse_var(envVar, "flush:debug", NULL)) { + if (utils_parse_var(envVar, "flush:debug", NULL)) { loggerConfig.flushLevel = LOG_DEBUG; - } else if (util_parse_var(envVar, "flush:info", NULL)) { + } else if (utils_parse_var(envVar, "flush:info", NULL)) { loggerConfig.flushLevel = LOG_INFO; - } else if (util_parse_var(envVar, "flush:warning", NULL)) { + } else if (utils_parse_var(envVar, "flush:warning", NULL)) { loggerConfig.flushLevel = LOG_WARNING; - } else if (util_parse_var(envVar, "flush:error", NULL)) { + } else if (utils_parse_var(envVar, "flush:error", NULL)) { loggerConfig.flushLevel = LOG_ERROR; - } else if (util_parse_var(envVar, "flush:fatal", NULL)) { + } else if (utils_parse_var(envVar, "flush:fatal", NULL)) { loggerConfig.flushLevel = LOG_FATAL; } diff --git a/src/utils/utils_log.h b/src/utils/utils_log.h index 4e9e98690..ab40121ce 100644 --- a/src/utils/utils_log.h +++ b/src/utils/utils_log.h @@ -20,31 +20,31 @@ typedef enum { LOG_WARNING, LOG_ERROR, LOG_FATAL -} util_log_level_t; +} utils_log_level_t; -#define LOG_DEBUG(...) util_log(LOG_DEBUG, __func__, __VA_ARGS__); -#define LOG_INFO(...) util_log(LOG_INFO, __func__, __VA_ARGS__); -#define LOG_WARN(...) util_log(LOG_WARNING, __func__, __VA_ARGS__); -#define LOG_ERR(...) util_log(LOG_ERROR, __func__, __VA_ARGS__); -#define LOG_FATAL(...) util_log(LOG_FATAL, __func__, __VA_ARGS__); +#define LOG_DEBUG(...) utils_log(LOG_DEBUG, __func__, __VA_ARGS__); +#define LOG_INFO(...) utils_log(LOG_INFO, __func__, __VA_ARGS__); +#define LOG_WARN(...) utils_log(LOG_WARNING, __func__, __VA_ARGS__); +#define LOG_ERR(...) utils_log(LOG_ERROR, __func__, __VA_ARGS__); +#define LOG_FATAL(...) utils_log(LOG_FATAL, __func__, __VA_ARGS__); -#define LOG_PDEBUG(...) util_plog(LOG_DEBUG, __func__, __VA_ARGS__); -#define LOG_PINFO(...) util_plog(LOG_INFO, __func__, __VA_ARGS__); -#define LOG_PWARN(...) util_plog(LOG_WARNING, __func__, __VA_ARGS__); -#define LOG_PERR(...) util_plog(LOG_ERROR, __func__, __VA_ARGS__); -#define LOG_PFATAL(...) util_plog(LOG_FATAL, __func__, __VA_ARGS__); +#define LOG_PDEBUG(...) utils_plog(LOG_DEBUG, __func__, __VA_ARGS__); +#define LOG_PINFO(...) utils_plog(LOG_INFO, __func__, __VA_ARGS__); +#define LOG_PWARN(...) utils_plog(LOG_WARNING, __func__, __VA_ARGS__); +#define LOG_PERR(...) utils_plog(LOG_ERROR, __func__, __VA_ARGS__); +#define LOG_PFATAL(...) utils_plog(LOG_FATAL, __func__, __VA_ARGS__); -void util_log_init(void); +void utils_log_init(void); #ifdef _WIN32 -void util_log(util_log_level_t level, const char *func, const char *format, - ...); -void util_plog(util_log_level_t level, const char *func, const char *format, +void utils_log(utils_log_level_t level, const char *func, const char *format, ...); +void utils_plog(utils_log_level_t level, const char *func, const char *format, + ...); #else -void util_log(util_log_level_t level, const char *func, const char *format, ...) - __attribute__((format(printf, 3, 4))); -void util_plog(util_log_level_t level, const char *func, const char *format, +void utils_log(utils_log_level_t level, const char *func, const char *format, ...) __attribute__((format(printf, 3, 4))); +void utils_plog(utils_log_level_t level, const char *func, const char *format, + ...) __attribute__((format(printf, 3, 4))); #endif #ifdef __cplusplus diff --git a/src/utils/utils_posix_common.c b/src/utils/utils_posix_common.c index 42a5d06f1..10c2473c2 100644 --- a/src/utils/utils_posix_common.c +++ b/src/utils/utils_posix_common.c @@ -39,10 +39,10 @@ static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT; static size_t Page_size; -static void _util_get_page_size(void) { Page_size = sysconf(_SC_PAGE_SIZE); } +static void _utils_get_page_size(void) { Page_size = sysconf(_SC_PAGE_SIZE); } -size_t util_get_page_size(void) { - util_init_once(&Page_size_is_initialized, _util_get_page_size); +size_t utils_get_page_size(void) { + utils_init_once(&Page_size_is_initialized, _utils_get_page_size); return Page_size; } diff --git a/src/utils/utils_posix_concurrency.c b/src/utils/utils_posix_concurrency.c index 5f2b2569d..fcf04ed95 100644 --- a/src/utils/utils_posix_concurrency.c +++ b/src/utils/utils_posix_concurrency.c @@ -12,28 +12,28 @@ #include "utils_concurrency.h" -size_t util_mutex_get_size(void) { return sizeof(pthread_mutex_t); } +size_t utils_mutex_get_size(void) { return sizeof(pthread_mutex_t); } -os_mutex_t *util_mutex_init(void *ptr) { +utils_mutex_t *utils_mutex_init(void *ptr) { pthread_mutex_t *mutex = (pthread_mutex_t *)ptr; int ret = pthread_mutex_init(mutex, NULL); - return ret == 0 ? ((os_mutex_t *)mutex) : NULL; + return ret == 0 ? ((utils_mutex_t *)mutex) : NULL; } -void util_mutex_destroy_not_free(os_mutex_t *m) { +void utils_mutex_destroy_not_free(utils_mutex_t *m) { pthread_mutex_t *mutex = (pthread_mutex_t *)m; int ret = pthread_mutex_destroy(mutex); (void)ret; // TODO: add logging } -int util_mutex_lock(os_mutex_t *m) { +int utils_mutex_lock(utils_mutex_t *m) { return pthread_mutex_lock((pthread_mutex_t *)m); } -int util_mutex_unlock(os_mutex_t *m) { +int utils_mutex_unlock(utils_mutex_t *m) { return pthread_mutex_unlock((pthread_mutex_t *)m); } -void util_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) { +void utils_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) { pthread_once(flag, oneCb); } diff --git a/src/utils/utils_windows_common.c b/src/utils/utils_windows_common.c index f33b29e1b..33faa1b97 100644 --- a/src/utils/utils_windows_common.c +++ b/src/utils/utils_windows_common.c @@ -25,14 +25,14 @@ static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT; static size_t Page_size; -static void _util_get_page_size(void) { +static void _utils_get_page_size(void) { SYSTEM_INFO SystemInfo; GetSystemInfo(&SystemInfo); Page_size = SystemInfo.dwPageSize; } -size_t util_get_page_size(void) { - util_init_once(&Page_size_is_initialized, _util_get_page_size); +size_t utils_get_page_size(void) { + utils_init_once(&Page_size_is_initialized, _utils_get_page_size); return Page_size; } diff --git a/src/utils/utils_windows_concurrency.c b/src/utils/utils_windows_concurrency.c index 50bc71c66..696f4523b 100644 --- a/src/utils/utils_windows_concurrency.c +++ b/src/utils/utils_windows_concurrency.c @@ -9,21 +9,21 @@ #include "utils_concurrency.h" -size_t util_mutex_get_size(void) { return sizeof(os_mutex_t); } +size_t utils_mutex_get_size(void) { return sizeof(utils_mutex_t); } -os_mutex_t *util_mutex_init(void *ptr) { - os_mutex_t *mutex_internal = (os_mutex_t *)ptr; +utils_mutex_t *utils_mutex_init(void *ptr) { + utils_mutex_t *mutex_internal = (utils_mutex_t *)ptr; InitializeCriticalSection(&mutex_internal->lock); - return (os_mutex_t *)mutex_internal; + return (utils_mutex_t *)mutex_internal; } -void util_mutex_destroy_not_free(os_mutex_t *mutex) { - os_mutex_t *mutex_internal = (os_mutex_t *)mutex; +void utils_mutex_destroy_not_free(utils_mutex_t *mutex) { + utils_mutex_t *mutex_internal = (utils_mutex_t *)mutex; DeleteCriticalSection(&mutex_internal->lock); } -int util_mutex_lock(os_mutex_t *mutex) { - os_mutex_t *mutex_internal = (os_mutex_t *)mutex; +int utils_mutex_lock(utils_mutex_t *mutex) { + utils_mutex_t *mutex_internal = (utils_mutex_t *)mutex; EnterCriticalSection(&mutex_internal->lock); if (mutex_internal->lock.RecursionCount > 1) { @@ -34,8 +34,8 @@ int util_mutex_lock(os_mutex_t *mutex) { return 0; } -int util_mutex_unlock(os_mutex_t *mutex) { - os_mutex_t *mutex_internal = (os_mutex_t *)mutex; +int utils_mutex_unlock(utils_mutex_t *mutex) { + utils_mutex_t *mutex_internal = (utils_mutex_t *)mutex; LeaveCriticalSection(&mutex_internal->lock); return 0; } @@ -50,6 +50,6 @@ static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter, return TRUE; } -void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)) { +void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)) { InitOnceExecuteOnce(flag, initOnceCb, (void *)onceCb, NULL); } diff --git a/test/providers/cuda_helpers.cpp b/test/providers/cuda_helpers.cpp index 08584a45f..366efc197 100644 --- a/test/providers/cuda_helpers.cpp +++ b/test/providers/cuda_helpers.cpp @@ -36,7 +36,7 @@ struct libcu_ops { struct DlHandleCloser { void operator()(void *dlHandle) { if (dlHandle) { - util_close_library(dlHandle); + utils_close_library(dlHandle); } } }; @@ -52,77 +52,77 @@ int InitCUDAOps() { // NOTE that we use UMF_UTIL_OPEN_LIBRARY_GLOBAL which add all loaded // symbols to the global symbol table. cuDlHandle = std::unique_ptr( - util_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL)); + utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL)); // NOTE: some symbols defined in the lib have _vX postfixes - this is // important to load the proper version of functions *(void **)&libcu_ops.cuInit = - util_get_symbol_addr(cuDlHandle.get(), "cuInit", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuInit", lib_name); if (libcu_ops.cuInit == nullptr) { fprintf(stderr, "cuInit symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuCtxCreate = - util_get_symbol_addr(cuDlHandle.get(), "cuCtxCreate_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuCtxCreate_v2", lib_name); if (libcu_ops.cuCtxCreate == nullptr) { fprintf(stderr, "cuCtxCreate_v2 symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuCtxDestroy = - util_get_symbol_addr(cuDlHandle.get(), "cuCtxDestroy_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuCtxDestroy_v2", lib_name); if (libcu_ops.cuCtxDestroy == nullptr) { fprintf(stderr, "cuCtxDestroy symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuDeviceGet = - util_get_symbol_addr(cuDlHandle.get(), "cuDeviceGet", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuDeviceGet", lib_name); if (libcu_ops.cuDeviceGet == nullptr) { fprintf(stderr, "cuDeviceGet symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemAlloc = - util_get_symbol_addr(cuDlHandle.get(), "cuMemAlloc_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemAlloc_v2", lib_name); if (libcu_ops.cuMemAlloc == nullptr) { fprintf(stderr, "cuMemAlloc_v2 symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemFree = - util_get_symbol_addr(cuDlHandle.get(), "cuMemFree_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemFree_v2", lib_name); if (libcu_ops.cuMemFree == nullptr) { fprintf(stderr, "cuMemFree_v2 symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemAllocHost = - util_get_symbol_addr(cuDlHandle.get(), "cuMemAllocHost_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemAllocHost_v2", lib_name); if (libcu_ops.cuMemAllocHost == nullptr) { fprintf(stderr, "cuMemAllocHost_v2 symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemAllocManaged = - util_get_symbol_addr(cuDlHandle.get(), "cuMemAllocManaged", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemAllocManaged", lib_name); if (libcu_ops.cuMemAllocManaged == nullptr) { fprintf(stderr, "cuMemAllocManaged symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemFreeHost = - util_get_symbol_addr(cuDlHandle.get(), "cuMemFreeHost", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemFreeHost", lib_name); if (libcu_ops.cuMemFreeHost == nullptr) { fprintf(stderr, "cuMemFreeHost symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemsetD32 = - util_get_symbol_addr(cuDlHandle.get(), "cuMemsetD32_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemsetD32_v2", lib_name); if (libcu_ops.cuMemsetD32 == nullptr) { fprintf(stderr, "cuMemsetD32_v2 symbol not found in %s\n", lib_name); return -1; } *(void **)&libcu_ops.cuMemcpyDtoH = - util_get_symbol_addr(cuDlHandle.get(), "cuMemcpyDtoH_v2", lib_name); + utils_get_symbol_addr(cuDlHandle.get(), "cuMemcpyDtoH_v2", lib_name); if (libcu_ops.cuMemcpyDtoH == nullptr) { fprintf(stderr, "cuMemcpyDtoH_v2 symbol not found in %s\n", lib_name); return -1; } - *(void **)&libcu_ops.cuPointerGetAttributes = util_get_symbol_addr( + *(void **)&libcu_ops.cuPointerGetAttributes = utils_get_symbol_addr( cuDlHandle.get(), "cuPointerGetAttributes", lib_name); if (libcu_ops.cuPointerGetAttributes == nullptr) { fprintf(stderr, "cuPointerGetAttributes symbol not found in %s\n", @@ -241,7 +241,7 @@ void init_cuda_once() { } int init_cuda() { - util_init_once(&cuda_init_flag, init_cuda_once); + utils_init_once(&cuda_init_flag, init_cuda_once); return InitResult; } diff --git a/test/providers/level_zero_helpers.cpp b/test/providers/level_zero_helpers.cpp index 06b3ae56e..4cd993956 100644 --- a/test/providers/level_zero_helpers.cpp +++ b/test/providers/level_zero_helpers.cpp @@ -66,7 +66,7 @@ struct libze_ops { struct DlHandleCloser { void operator()(void *dlHandle) { if (dlHandle) { - util_close_library(dlHandle); + utils_close_library(dlHandle); } } }; @@ -82,26 +82,26 @@ int InitLevelZeroOps() { // NOTE that we use UMF_UTIL_OPEN_LIBRARY_GLOBAL which add all loaded symbols to the // global symbol table. zeDlHandle = std::unique_ptr( - util_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL)); + utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL)); *(void **)&libze_ops.zeInit = - util_get_symbol_addr(zeDlHandle.get(), "zeInit", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeInit", lib_name); if (libze_ops.zeInit == nullptr) { fprintf(stderr, "zeInit symbol not found in %s\n", lib_name); return -1; } *(void **)&libze_ops.zeDriverGet = - util_get_symbol_addr(zeDlHandle.get(), "zeDriverGet", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeDriverGet", lib_name); if (libze_ops.zeDriverGet == nullptr) { fprintf(stderr, "zeDriverGet symbol not found in %s\n", lib_name); return -1; } *(void **)&libze_ops.zeDeviceGet = - util_get_symbol_addr(zeDlHandle.get(), "zeDeviceGet", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeDeviceGet", lib_name); if (libze_ops.zeDeviceGet == nullptr) { fprintf(stderr, "zeDeviceGet symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeDeviceGetProperties = util_get_symbol_addr( + *(void **)&libze_ops.zeDeviceGetProperties = utils_get_symbol_addr( zeDlHandle.get(), "zeDeviceGetProperties", lib_name); if (libze_ops.zeDeviceGetProperties == nullptr) { fprintf(stderr, "zeDeviceGetProperties symbol not found in %s\n", @@ -109,25 +109,25 @@ int InitLevelZeroOps() { return -1; } *(void **)&libze_ops.zeContextCreate = - util_get_symbol_addr(zeDlHandle.get(), "zeContextCreate", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeContextCreate", lib_name); if (libze_ops.zeContextCreate == nullptr) { fprintf(stderr, "zeContextCreate symbol not found in %s\n", lib_name); return -1; } *(void **)&libze_ops.zeContextDestroy = - util_get_symbol_addr(zeDlHandle.get(), "zeContextDestroy", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeContextDestroy", lib_name); if (libze_ops.zeContextDestroy == nullptr) { fprintf(stderr, "zeContextDestroy symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeCommandQueueCreate = util_get_symbol_addr( + *(void **)&libze_ops.zeCommandQueueCreate = utils_get_symbol_addr( zeDlHandle.get(), "zeCommandQueueCreate", lib_name); if (libze_ops.zeCommandQueueCreate == nullptr) { fprintf(stderr, "zeCommandQueueCreate symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeCommandQueueDestroy = util_get_symbol_addr( + *(void **)&libze_ops.zeCommandQueueDestroy = utils_get_symbol_addr( zeDlHandle.get(), "zeCommandQueueDestroy", lib_name); if (libze_ops.zeCommandQueueDestroy == nullptr) { fprintf(stderr, "zeCommandQueueDestroy symbol not found in %s\n", @@ -135,29 +135,29 @@ int InitLevelZeroOps() { return -1; } *(void **)&libze_ops.zeCommandQueueExecuteCommandLists = - util_get_symbol_addr(zeDlHandle.get(), - "zeCommandQueueExecuteCommandLists", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), + "zeCommandQueueExecuteCommandLists", lib_name); if (libze_ops.zeCommandQueueExecuteCommandLists == nullptr) { fprintf(stderr, "zeCommandQueueExecuteCommandLists symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeCommandQueueSynchronize = util_get_symbol_addr( + *(void **)&libze_ops.zeCommandQueueSynchronize = utils_get_symbol_addr( zeDlHandle.get(), "zeCommandQueueSynchronize", lib_name); if (libze_ops.zeCommandQueueSynchronize == nullptr) { fprintf(stderr, "zeCommandQueueSynchronize symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeCommandListCreate = - util_get_symbol_addr(zeDlHandle.get(), "zeCommandListCreate", lib_name); + *(void **)&libze_ops.zeCommandListCreate = utils_get_symbol_addr( + zeDlHandle.get(), "zeCommandListCreate", lib_name); if (libze_ops.zeCommandListCreate == nullptr) { fprintf(stderr, "zeCommandListCreate symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeCommandListDestroy = util_get_symbol_addr( + *(void **)&libze_ops.zeCommandListDestroy = utils_get_symbol_addr( zeDlHandle.get(), "zeCommandListDestroy", lib_name); if (libze_ops.zeCommandListDestroy == nullptr) { fprintf(stderr, "zeCommandListDestroy symbol not found in %s\n", @@ -165,13 +165,13 @@ int InitLevelZeroOps() { return -1; } *(void **)&libze_ops.zeCommandListClose = - util_get_symbol_addr(zeDlHandle.get(), "zeCommandListClose", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeCommandListClose", lib_name); if (libze_ops.zeCommandListClose == nullptr) { fprintf(stderr, "zeCommandListClose symbol not found in %s\n", lib_name); return -1; } - *(void **)&libze_ops.zeCommandListAppendMemoryCopy = util_get_symbol_addr( + *(void **)&libze_ops.zeCommandListAppendMemoryCopy = utils_get_symbol_addr( zeDlHandle.get(), "zeCommandListAppendMemoryCopy", lib_name); if (libze_ops.zeCommandListAppendMemoryCopy == nullptr) { fprintf(stderr, @@ -179,7 +179,7 @@ int InitLevelZeroOps() { lib_name); return -1; } - *(void **)&libze_ops.zeCommandListAppendMemoryFill = util_get_symbol_addr( + *(void **)&libze_ops.zeCommandListAppendMemoryFill = utils_get_symbol_addr( zeDlHandle.get(), "zeCommandListAppendMemoryFill", lib_name); if (libze_ops.zeCommandListAppendMemoryFill == nullptr) { fprintf(stderr, @@ -187,7 +187,7 @@ int InitLevelZeroOps() { lib_name); return -1; } - *(void **)&libze_ops.zeMemGetAllocProperties = util_get_symbol_addr( + *(void **)&libze_ops.zeMemGetAllocProperties = utils_get_symbol_addr( zeDlHandle.get(), "zeMemGetAllocProperties", lib_name); if (libze_ops.zeMemGetAllocProperties == nullptr) { fprintf(stderr, "zeMemGetAllocProperties symbol not found in %s\n", @@ -195,13 +195,13 @@ int InitLevelZeroOps() { return -1; } *(void **)&libze_ops.zeMemAllocDevice = - util_get_symbol_addr(zeDlHandle.get(), "zeMemAllocDevice", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeMemAllocDevice", lib_name); if (libze_ops.zeMemAllocDevice == nullptr) { fprintf(stderr, "zeMemAllocDevice symbol not found in %s\n", lib_name); return -1; } *(void **)&libze_ops.zeMemFree = - util_get_symbol_addr(zeDlHandle.get(), "zeMemFree", lib_name); + utils_get_symbol_addr(zeDlHandle.get(), "zeMemFree", lib_name); if (libze_ops.zeMemFree == nullptr) { fprintf(stderr, "zeMemFree symbol not found in %s\n", lib_name); return -1; @@ -661,7 +661,7 @@ void init_level_zero_once() { } int init_level_zero() { - util_init_once(&level_zero_init_flag, init_level_zero_once); + utils_init_once(&level_zero_init_flag, init_level_zero_once); return InitResult; } diff --git a/test/test_base_alloc_linear.cpp b/test/test_base_alloc_linear.cpp index 94425fb03..3f8371d8d 100644 --- a/test/test_base_alloc_linear.cpp +++ b/test/test_base_alloc_linear.cpp @@ -60,7 +60,7 @@ TEST_F(test, baseAllocLinearMultiThreadedAllocMemset) { // but not big enough to hold all allocations, // so that there were more pools allocated. // This is needed to test freeing the first pool. - size_t pool_size = 2 * util_get_page_size(); + size_t pool_size = 2 * utils_get_page_size(); auto pool = std::shared_ptr( umf_ba_linear_create(pool_size), umf_ba_linear_destroy); diff --git a/test/utils/utils.cpp b/test/utils/utils.cpp index de4a71d65..302971f7e 100644 --- a/test/utils/utils.cpp +++ b/test/utils/utils.cpp @@ -8,52 +8,52 @@ using umf_test::test; -TEST_F(test, util_parse_var) { - EXPECT_FALSE(util_parse_var("", "test1", 0)); +TEST_F(test, utils_parse_var) { + EXPECT_FALSE(utils_parse_var("", "test1", 0)); - EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test1", 0)); - EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test2", 0)); - EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test3", 0)); - EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test4", 0)); + EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test1", 0)); + EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test2", 0)); + EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test3", 0)); + EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test4", 0)); - EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test1", 0)); - EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test2", 0)); - EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test3", 0)); - EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test4", 0)); + EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test1", 0)); + EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test2", 0)); + EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test3", 0)); + EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test4", 0)); - EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test5", 0)); + EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test5", 0)); - EXPECT_FALSE(util_parse_var("test1test2test3test4", "test1", 0)); - EXPECT_FALSE(util_parse_var("test1test2test3test4", "test2", 0)); - EXPECT_FALSE(util_parse_var("test1test2test3test4", "test3", 0)); - EXPECT_FALSE(util_parse_var("test1test2test3test4", "test4", 0)); + EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test1", 0)); + EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test2", 0)); + EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test3", 0)); + EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test4", 0)); - EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test1", 0)); - EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test2", 0)); - EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test3", 0)); - EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test4", 0)); + EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test1", 0)); + EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test2", 0)); + EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test3", 0)); + EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test4", 0)); - EXPECT_TRUE(util_parse_var("test1:test2;test3:test4", "test1:test2", 0)); - EXPECT_TRUE(util_parse_var("test1:test2;test3:test4", "test3:test4", 0)); - EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test2:test3'", 0)); + EXPECT_TRUE(utils_parse_var("test1:test2;test3:test4", "test1:test2", 0)); + EXPECT_TRUE(utils_parse_var("test1:test2;test3:test4", "test3:test4", 0)); + EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test2:test3'", 0)); EXPECT_TRUE( - util_parse_var("test1;;test2;invalid;test3;;;test4", "test1", 0)); + utils_parse_var("test1;;test2;invalid;test3;;;test4", "test1", 0)); EXPECT_TRUE( - util_parse_var("test1;;test2;invalid;test3;;;test4", "test2", 0)); + utils_parse_var("test1;;test2;invalid;test3;;;test4", "test2", 0)); EXPECT_TRUE( - util_parse_var("test1;;test2;invalid;test3;;;test4", "test3", 0)); + utils_parse_var("test1;;test2;invalid;test3;;;test4", "test3", 0)); EXPECT_TRUE( - util_parse_var("test1;;test2;invalid;test3;;;test4", "test4", 0)); + utils_parse_var("test1;;test2;invalid;test3;;;test4", "test4", 0)); const char *arg; - EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test1", &arg)); - EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test2", &arg)); - EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test3", &arg)); - EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test4", &arg)); - - EXPECT_TRUE(util_parse_var("test1,abc;test2;test3;test4", "test1", &arg)); - EXPECT_TRUE(util_parse_var("test1;test2,abc;test3;test4", "test2", &arg)); - EXPECT_TRUE(util_parse_var("test1;test2;test3,abc;test4", "test3", &arg)); - EXPECT_TRUE(util_parse_var("test1;test2;test3;test4,abc", "test4", &arg)); + EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test1", &arg)); + EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test2", &arg)); + EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test3", &arg)); + EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test4", &arg)); + + EXPECT_TRUE(utils_parse_var("test1,abc;test2;test3;test4", "test1", &arg)); + EXPECT_TRUE(utils_parse_var("test1;test2,abc;test3;test4", "test2", &arg)); + EXPECT_TRUE(utils_parse_var("test1;test2;test3,abc;test4", "test3", &arg)); + EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4,abc", "test4", &arg)); } diff --git a/test/utils/utils_log.cpp b/test/utils/utils_log.cpp index f865b416b..c0f81abf0 100644 --- a/test/utils/utils_log.cpp +++ b/test/utils/utils_log.cpp @@ -19,7 +19,7 @@ FILE *mock_fopen(const char *filename, const char *mode) { } const std::string MOCK_FN_NAME = "MOCK_FUNCTION_NAME"; -std::string expected_message = "[ERROR UMF] util_log_init: Logging output not " +std::string expected_message = "[ERROR UMF] utils_log_init: Logging output not " "set - logging disabled (UMF_LOG = \"\")\n"; // The expected_message (above) is printed to stderr. FILE *expected_stream = stderr; @@ -98,7 +98,7 @@ const char *env_variable = ""; #define fopen(A, B) mock_fopen(A, B) #define fputs(A, B) mock_fputs(A, B) #define fflush(A) mock_fflush(A) -#define util_env_var(A, B, C) mock_util_env_var(A, B, C) +#define utils_env_var(A, B, C) mock_utils_env_var(A, B, C) #if defined(__APPLE__) #define strerror_r(A, B, C) mock_strerror_posix(A, B, C) #else @@ -111,7 +111,7 @@ const char *env_variable = ""; #define UMF_VERSION "test version" #endif #include "utils/utils_log.c" -#undef util_env_var +#undef utils_env_var #undef fopen #undef fputs #undef fflush @@ -122,13 +122,13 @@ void helper_log_init(const char *var) { env_variable = var; fopen_count = 0; fput_count = 0; - util_log_init(); + utils_log_init(); env_variable = NULL; EXPECT_EQ(fopen_count, expect_fopen_count); EXPECT_EQ(fput_count, expect_fput_count); } -void helper_checkConfig(util_log_config_t *expected, util_log_config_t *is) { +void helper_checkConfig(utils_log_config_t *expected, utils_log_config_t *is) { EXPECT_EQ(expected->level, is->level); EXPECT_EQ(expected->flushLevel, is->flushLevel); EXPECT_EQ(expected->output, is->output); @@ -142,7 +142,7 @@ TEST_F(test, parseEnv_errors) { expect_fput_count = 0; expected_stream = stderr; - util_log_config_t b = loggerConfig; + utils_log_config_t b = loggerConfig; helper_log_init(NULL); helper_checkConfig(&b, &loggerConfig); @@ -156,13 +156,13 @@ TEST_F(test, parseEnv_errors) { helper_log_init("_level:debug"); helper_checkConfig(&b, &loggerConfig); expected_message = - "[ERROR UMF] util_log_init: Cannot open output file - path too long\n"; + "[ERROR UMF] utils_log_init: 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()); } TEST_F(test, parseEnv) { - util_log_config_t b = loggerConfig; + utils_log_config_t b = loggerConfig; expected_message = ""; std::vector> logLevels = { @@ -228,9 +228,9 @@ TEST_F(test, parseEnv) { expected_stream = output.second; b.timestamp = timestamp.second; b.pid = pid.second; - b.flushLevel = (util_log_level_t)flushLevel.second; + b.flushLevel = (utils_log_level_t)flushLevel.second; - b.level = (util_log_level_t)logLevel.second; + b.level = (utils_log_level_t)logLevel.second; if (logLevel.second <= LOG_INFO) { expect_fput_count = 1; } @@ -238,7 +238,7 @@ TEST_F(test, parseEnv) { expect_fput_count = 1; if (expected_filename.size() > MAX_FILE_PATH) { expected_message = - "[ERROR UMF] util_log_init: Cannot open " + "[ERROR UMF] utils_log_init: Cannot open " "output file - path too long\n"; } } @@ -254,7 +254,7 @@ TEST_F(test, parseEnv) { template void helper_test_log(Args... args) { fput_count = 0; fflush_count = 0; - util_log(args...); + utils_log(args...); EXPECT_EQ(fput_count, expect_fput_count); EXPECT_EQ(fflush_count, expect_fflush_count); } @@ -281,7 +281,7 @@ TEST_F(test, log_levels) { expected_stream = stderr; for (int i = LOG_DEBUG; i <= LOG_ERROR; i++) { for (int j = LOG_DEBUG; j <= LOG_ERROR; j++) { - loggerConfig = {0, 0, (util_log_level_t)i, LOG_DEBUG, stderr}; + loggerConfig = {0, 0, (utils_log_level_t)i, LOG_DEBUG, stderr}; if (i > j) { expect_fput_count = 0; expect_fflush_count = 0; @@ -292,7 +292,7 @@ TEST_F(test, log_levels) { } expected_message = "[" + helper_log_str(j) + " UMF] " + MOCK_FN_NAME + ": example log\n"; - helper_test_log((util_log_level_t)j, MOCK_FN_NAME.c_str(), "%s", + helper_test_log((utils_log_level_t)j, MOCK_FN_NAME.c_str(), "%s", "example log"); } } @@ -315,7 +315,7 @@ TEST_F(test, flush_levels) { expect_fput_count = 1; for (int i = LOG_DEBUG; i <= LOG_ERROR; i++) { for (int j = LOG_DEBUG; j <= LOG_ERROR; j++) { - loggerConfig = {0, 0, LOG_DEBUG, (util_log_level_t)i, stderr}; + loggerConfig = {0, 0, LOG_DEBUG, (utils_log_level_t)i, stderr}; if (i > j) { expect_fflush_count = 0; } else { @@ -323,7 +323,7 @@ TEST_F(test, flush_levels) { } expected_message = "[" + helper_log_str(j) + " UMF] " + MOCK_FN_NAME + ": example log\n"; - helper_test_log((util_log_level_t)j, MOCK_FN_NAME.c_str(), "%s", + helper_test_log((utils_log_level_t)j, MOCK_FN_NAME.c_str(), "%s", "example log"); } } @@ -420,7 +420,7 @@ TEST_F(test, log_macros) { template void helper_test_plog(Args... args) { fput_count = 0; fflush_count = 0; - util_plog(args...); + utils_plog(args...); EXPECT_EQ(fput_count, expect_fput_count); EXPECT_EQ(fflush_count, expect_fflush_count); }