Skip to content

Commit 3321569

Browse files
vinser52vinser52
committed
Add logs to the tracking provider
1 parent 074089f commit 3321569

File tree

8 files changed

+155
-109
lines changed

8 files changed

+155
-109
lines changed

‎src/base_alloc/base_alloc.c

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -289,8 +289,7 @@ void umf_ba_destroy(umf_ba_pool_t *pool) {
289289
#ifndef NDEBUG
290290
ba_debug_checks(pool);
291291
if (pool->metadata.n_allocs) {
292-
LOG_ERR("umf_ba_destroy(): pool->metadata.n_allocs = %zu",
293-
pool->metadata.n_allocs);
292+
LOG_ERR("pool->metadata.n_allocs = %zu", pool->metadata.n_allocs);
294293
}
295294
#endif /* NDEBUG */
296295

‎src/base_alloc/base_alloc_linear.c

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -250,8 +250,7 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
250250
#ifndef NDEBUG
251251
_DEBUG_EXECUTE(ba_debug_checks(pool));
252252
if (pool->metadata.global_n_allocs) {
253-
LOG_ERR("umf_ba_linear_destroy(): global_n_allocs = %zu",
254-
pool->metadata.global_n_allocs);
253+
LOG_ERR("global_n_allocs = %zu", pool->metadata.global_n_allocs);
255254
}
256255
#endif /* NDEBUG */
257256

‎src/ipc.c

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
2525
umf_alloc_info_t allocInfo;
2626
umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
2727
if (ret != UMF_RESULT_SUCCESS) {
28-
LOG_ERR("umfGetIPCHandle: cannot get alloc info for ptr = %p.", ptr);
28+
LOG_ERR("cannot get alloc info for ptr = %p.", ptr);
2929
return ret;
3030
}
3131

@@ -37,22 +37,22 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
3737
size_t providerIPCHandleSize;
3838
ret = umfMemoryProviderGetIPCHandleSize(provider, &providerIPCHandleSize);
3939
if (ret != UMF_RESULT_SUCCESS) {
40-
LOG_ERR("umfGetIPCHandle: cannot get IPC handle size.");
40+
LOG_ERR("cannot get IPC handle size.");
4141
return ret;
4242
}
4343

4444
ipcHandleSize = sizeof(umf_ipc_data_t) + providerIPCHandleSize;
4545
umf_ipc_data_t *ipcData = umf_ba_global_alloc(ipcHandleSize);
4646
if (!ipcData) {
47-
LOG_ERR("umfGetIPCHandle: failed to allocate ipcData");
47+
LOG_ERR("failed to allocate ipcData");
4848
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
4949
}
5050

5151
ret = umfMemoryProviderGetIPCHandle(provider, allocInfo.base,
5252
allocInfo.baseSize,
5353
(void *)ipcData->providerIpcData);
5454
if (ret != UMF_RESULT_SUCCESS) {
55-
LOG_ERR("umfGetIPCHandle: failed to get IPC handle.");
55+
LOG_ERR("failed to get IPC handle.");
5656
umf_ba_global_free(ipcData);
5757
return ret;
5858
}
@@ -95,8 +95,7 @@ umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
9595
umf_result_t ret = umfMemoryProviderOpenIPCHandle(
9696
hProvider, (void *)umfIPCHandle->providerIpcData, &base);
9797
if (ret != UMF_RESULT_SUCCESS) {
98-
LOG_ERR(
99-
"umfOpenIPCHandle: memory provider failed to open the IPC handle.");
98+
LOG_ERR("memory provider failed to open the IPC handle.");
10099
return ret;
101100
}
102101
*ptr = (void *)((uintptr_t)base + umfIPCHandle->offset);
@@ -108,7 +107,7 @@ umf_result_t umfCloseIPCHandle(void *ptr) {
108107
umf_alloc_info_t allocInfo;
109108
umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
110109
if (ret != UMF_RESULT_SUCCESS) {
111-
LOG_ERR("umfCloseIPCHandle: cannot get alloc info for ptr = %p.", ptr);
110+
LOG_ERR("cannot get alloc info for ptr = %p.", ptr);
112111
return ret;
113112
}
114113

‎src/memory_pool.c

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,7 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
5959
}
6060

6161
*hPool = pool;
62+
LOG_INFO("Memory pool created: %p", (void *)pool);
6263
return UMF_RESULT_SUCCESS;
6364

6465
err_pool_init:
@@ -83,6 +84,9 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
8384
// Destroy tracking provider.
8485
umfMemoryProviderDestroy(hPool->provider);
8586
}
87+
88+
LOG_INFO("Memory pool destroyed: %p", (void *)hPool);
89+
8690
// TODO: this free keeps memory in base allocator, so it can lead to OOM in some scenarios (it should be optimized)
8791
umf_ba_global_free(hPool);
8892
}

‎src/provider/provider_tracking.c

Lines changed: 48 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,8 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
3737

3838
tracker_value_t *value = umf_ba_alloc(hTracker->tracker_allocator);
3939
if (value == NULL) {
40+
LOG_ERR("failed to allocate tracker value, ptr=%p, size=%zu", ptr,
41+
size);
4042
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
4143
}
4244

@@ -46,16 +48,20 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
4648
int ret = critnib_insert(hTracker->map, (uintptr_t)ptr, value, 0);
4749

4850
if (ret == 0) {
51+
LOG_DEBUG("memory region is added, tracker=%p, ptr=%p, size=%zu",
52+
(void *)hTracker, ptr, size);
4953
return UMF_RESULT_SUCCESS;
5054
}
5155

56+
LOG_ERR("failed to insert tracker value, ret=%d, ptr=%p, size=%zu", ret,
57+
ptr, size);
58+
5259
umf_ba_free(hTracker->tracker_allocator, value);
5360

5461
if (ret == ENOMEM) {
5562
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
5663
}
5764

58-
LOG_ERR("umfMemoryTrackerAdd: Unknown Error %d", ret);
5965
return UMF_RESULT_ERROR_UNKNOWN;
6066
}
6167

@@ -70,7 +76,7 @@ static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
7076

7177
void *value = critnib_remove(hTracker->map, (uintptr_t)ptr);
7278
if (!value) {
73-
LOG_ERR("umfMemoryTrackerRemove: pointer %p not found in the map", ptr);
79+
LOG_ERR("pointer %p not found in the map", ptr);
7480
return UMF_RESULT_ERROR_UNKNOWN;
7581
}
7682

@@ -109,6 +115,9 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
109115
int found = critnib_find(TRACKER->map, (uintptr_t)ptr, FIND_LE,
110116
(void *)&rkey, (void **)&rvalue);
111117
if (!found || (uintptr_t)ptr >= rkey + rvalue->size) {
118+
LOG_WARN("pointer %p not found in the "
119+
"tracker, TRACKER=%p",
120+
ptr, (void *)TRACKER);
112121
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
113122
}
114123

@@ -181,20 +190,21 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
181190
tracker_value_t *value =
182191
(tracker_value_t *)critnib_get(provider->hTracker->map, (uintptr_t)ptr);
183192
if (!value) {
184-
LOG_ERR("tracking split: no such value");
193+
LOG_ERR("region for split is not found in the tracker");
185194
ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
186195
goto err;
187196
}
188197
if (value->size != totalSize) {
189-
LOG_ERR("tracking split: %zu != %zu", value->size, totalSize);
198+
LOG_ERR("tracked size %zu does not match requested size to split: %zu",
199+
value->size, totalSize);
190200
ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
191201
goto err;
192202
}
193203

194204
ret = umfMemoryProviderAllocationSplit(provider->hUpstream, ptr, totalSize,
195205
firstSize);
196206
if (ret != UMF_RESULT_SUCCESS) {
197-
LOG_ERR("tracking split: umfMemoryProviderAllocationSplit failed");
207+
LOG_ERR("umfMemoryProviderAllocationSplit failed");
198208
goto err;
199209
}
200210

@@ -206,7 +216,7 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
206216
ret = umfMemoryTrackerAdd(provider->hTracker, provider->pool, highPtr,
207217
secondSize);
208218
if (ret != UMF_RESULT_SUCCESS) {
209-
LOG_ERR("tracking split: umfMemoryTrackerAdd failed");
219+
LOG_ERR("umfMemoryTrackerAdd failed");
210220
// TODO: what now? should we rollback the split? This can only happen due to ENOMEM
211221
// so it's unlikely but probably the best solution would be to try to preallocate everything
212222
// (value and critnib nodes) before calling umfMemoryProviderAllocationSplit.
@@ -256,33 +266,32 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
256266
tracker_value_t *lowValue = (tracker_value_t *)critnib_get(
257267
provider->hTracker->map, (uintptr_t)lowPtr);
258268
if (!lowValue) {
259-
LOG_ERR("tracking merge: no left value");
269+
LOG_ERR("no left value");
260270
ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
261271
goto err;
262272
}
263273
tracker_value_t *highValue = (tracker_value_t *)critnib_get(
264274
provider->hTracker->map, (uintptr_t)highPtr);
265275
if (!highValue) {
266-
LOG_ERR("tracking merge: no right value");
276+
LOG_ERR("no right value");
267277
ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
268278
goto err;
269279
}
270280
if (lowValue->pool != highValue->pool) {
271-
LOG_ERR("tracking merge: pool mismatch");
281+
LOG_ERR("pool mismatch");
272282
ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
273283
goto err;
274284
}
275285
if (lowValue->size + highValue->size != totalSize) {
276-
LOG_ERR("tracking merge: lowValue->size + highValue->size != "
277-
"totalSize");
286+
LOG_ERR("lowValue->size + highValue->size != totalSize");
278287
ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
279288
goto err;
280289
}
281290

282291
ret = umfMemoryProviderAllocationMerge(provider->hUpstream, lowPtr, highPtr,
283292
totalSize);
284293
if (ret != UMF_RESULT_SUCCESS) {
285-
LOG_ERR("tracking merge: umfMemoryProviderAllocationMerge failed");
294+
LOG_ERR("umfMemoryProviderAllocationMerge failed");
286295
goto err;
287296
}
288297

@@ -338,17 +347,17 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
338347
ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
339348
cache_value->providerIpcData);
340349
if (ret != UMF_RESULT_SUCCESS) {
341-
LOG_ERR("tracking free: failed to put IPC handle");
350+
LOG_ERR("failed to put IPC handle");
342351
}
343352
umf_ba_global_free(value);
344353
}
345354

346355
ret = umfMemoryProviderFree(p->hUpstream, ptr, size);
347356
if (ret != UMF_RESULT_SUCCESS) {
348-
LOG_ERR("tracking free: umfMemoryProviderFree failed");
357+
LOG_ERR("umfMemoryProviderFree failed");
349358
if (umfMemoryTrackerAdd(p->hTracker, p->pool, ptr, size) !=
350359
UMF_RESULT_SUCCESS) {
351-
LOG_ERR("tracking free: umfMemoryTrackerAdd failed");
360+
LOG_ERR("umfMemoryTrackerAdd failed");
352361
}
353362
return ret;
354363
}
@@ -485,34 +494,29 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
485494
ret = umfMemoryProviderGetIPCHandle(p->hUpstream, ptr, size,
486495
providerIpcData);
487496
if (ret != UMF_RESULT_SUCCESS) {
488-
LOG_ERR("tracking get ipc handle: "
489-
"umfMemoryProviderGetIPCHandle failed");
497+
LOG_ERR("umfMemoryProviderGetIPCHandle failed");
490498
return ret;
491499
}
492500

493501
ret = umfMemoryProviderGetIPCHandleSize(p->hUpstream, &ipcDataSize);
494502
if (ret != UMF_RESULT_SUCCESS) {
495-
LOG_ERR("tracking get ipc handle: "
496-
"umfMemoryProviderGetIPCHandleSize failed");
503+
LOG_ERR("umfMemoryProviderGetIPCHandleSize failed");
497504
ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
498505
providerIpcData);
499506
if (ret != UMF_RESULT_SUCCESS) {
500-
LOG_ERR("tracking get ipc handle: "
501-
"umfMemoryProviderPutIPCHandle failed");
507+
LOG_ERR("umfMemoryProviderPutIPCHandle failed");
502508
}
503509
return ret;
504510
}
505511

506512
size_t value_size = sizeof(ipc_cache_value_t) + ipcDataSize;
507513
ipc_cache_value_t *cache_value = umf_ba_global_alloc(value_size);
508514
if (!cache_value) {
509-
LOG_ERR(
510-
"tracking get ipc handle: failed to allocate cache_value");
515+
LOG_ERR("failed to allocate cache_value");
511516
ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
512517
providerIpcData);
513518
if (ret != UMF_RESULT_SUCCESS) {
514-
LOG_ERR("tracking get ipc handle: "
515-
"umfMemoryProviderPutIPCHandle failed");
519+
LOG_ERR("umfMemoryProviderPutIPCHandle failed");
516520
}
517521
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
518522
}
@@ -538,13 +542,11 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
538542
ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
539543
providerIpcData);
540544
if (ret != UMF_RESULT_SUCCESS) {
541-
LOG_ERR("tracking get ipc handle: "
542-
"umfMemoryProviderPutIPCHandle failed");
545+
LOG_ERR("umfMemoryProviderPutIPCHandle failed");
543546
return ret;
544547
}
545548
if (insRes == ENOMEM) {
546-
LOG_ERR(
547-
"tracking get ipc handle: insert to IPC cache failed");
549+
LOG_ERR("insert to IPC cache failed");
548550
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
549551
}
550552
}
@@ -585,13 +587,17 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
585587

586588
ret = umfMemoryProviderOpenIPCHandle(p->hUpstream, providerIpcData, ptr);
587589
if (ret != UMF_RESULT_SUCCESS) {
590+
LOG_ERR("umfMemoryProviderOpenIPCHandle failed");
588591
return ret;
589592
}
590593
size_t bufferSize = getDataSizeFromIpcHandle(providerIpcData);
591594
ret = umfMemoryTrackerAdd(p->hTracker, p->pool, *ptr, bufferSize);
592595
if (ret != UMF_RESULT_SUCCESS) {
596+
LOG_ERR("umfMemoryTrackerAdd failed, ptr=%p, size=%zu", *ptr,
597+
bufferSize);
593598
if (umfMemoryProviderCloseIPCHandle(p->hUpstream, *ptr, bufferSize)) {
594-
// TODO: LOG
599+
LOG_ERR("umfMemoryProviderCloseIPCHandle failed, ptr=%p, size=%zu",
600+
*ptr, bufferSize);
595601
}
596602
}
597603
return ret;
@@ -611,7 +617,8 @@ static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
611617
if (ret != UMF_RESULT_SUCCESS) {
612618
// DO NOT return an error here, because the tracking provider
613619
// cannot change behaviour of the upstream provider.
614-
LOG_ERR("tracking free: umfMemoryTrackerRemove failed");
620+
LOG_ERR("umfMemoryTrackerRemove failed, ptr=%p, size=%zu", ptr,
621+
size);
615622
}
616623
}
617624
return umfMemoryProviderCloseIPCHandle(p->hUpstream, ptr, size);
@@ -645,14 +652,21 @@ umf_result_t umfTrackingMemoryProviderCreate(
645652
params.hUpstream = hUpstream;
646653
params.hTracker = TRACKER;
647654
if (!params.hTracker) {
655+
LOG_ERR("failed, TRACKER is NULL");
648656
return UMF_RESULT_ERROR_UNKNOWN;
649657
}
650658
params.pool = hPool;
651659
params.ipcCache = critnib_new();
652660
if (!params.ipcCache) {
661+
LOG_ERR("failed to create IPC cache");
653662
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
654663
}
655664

665+
LOG_DEBUG("upstream=%p, tracker=%p, "
666+
"pool=%p, ipcCache=%p",
667+
(void *)params.hUpstream, (void *)params.hTracker,
668+
(void *)params.pool, (void *)params.ipcCache);
669+
656670
return umfMemoryProviderCreate(&UMF_TRACKING_MEMORY_PROVIDER_OPS, &params,
657671
hTrackingProvider);
658672
}
@@ -691,6 +705,9 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
691705
goto err_destroy_mutex;
692706
}
693707

708+
LOG_DEBUG("tracker created, handle=%p, segment map=%p", (void *)handle,
709+
(void *)handle->map);
710+
694711
return handle;
695712

696713
err_destroy_mutex:

0 commit comments

Comments
 (0)