Skip to content

Commit 249433e

Browse files
lukaszstolarczuklukaszstolarczuk
authored
Merge pull request #901 from vinser52/svinogra_config_params
Update params implementation
2 parents 882a4c8 + 9d74c17 commit 249433e

20 files changed

+1006
-207
lines changed

‎benchmark/multithread.cpp‎

Lines changed: 13 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -117,10 +117,15 @@ int main() {
117117
#endif
118118

119119
#if defined(UMF_BUILD_LIBUMF_POOL_DISJOINT)
120-
auto disjointParams = umfDisjointPoolParamsDefault();
120+
umf_disjoint_pool_params_handle_t hDisjointParams = nullptr;
121+
umf_result_t ret = umfDisjointPoolParamsCreate(&hDisjointParams);
122+
if (ret != UMF_RESULT_SUCCESS) {
123+
std::cerr << "disjoint pool params create failed" << std::endl;
124+
return -1;
125+
}
121126

122127
std::cout << "disjoint_pool mt_alloc_free: ";
123-
mt_alloc_free(poolCreateExtParams{umfDisjointPoolOps(), &disjointParams,
128+
mt_alloc_free(poolCreateExtParams{umfDisjointPoolOps(), hDisjointParams,
124129
umfOsMemoryProviderOps(), &osParams});
125130
#else
126131
std::cout << "skipping disjoint_pool mt_alloc_free" << std::endl;
@@ -129,5 +134,11 @@ int main() {
129134
// ctest looks for "PASSED" in the output
130135
std::cout << "PASSED" << std::endl;
131136

137+
ret = umfDisjointPoolParamsDestroy(hDisjointParams);
138+
if (ret != UMF_RESULT_SUCCESS) {
139+
std::cerr << "disjoint pool params destroy failed" << std::endl;
140+
return -1;
141+
}
142+
132143
return 0;
133144
}

‎benchmark/ubench.c‎

Lines changed: 85 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -260,16 +260,47 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
260260
exit(-1);
261261
}
262262

263-
umf_disjoint_pool_params_t disjoint_memory_pool_params = {0};
264-
disjoint_memory_pool_params.SlabMinSize = DISJOINT_POOL_SLAB_MIN_SIZE;
265-
disjoint_memory_pool_params.MaxPoolableSize =
266-
DISJOINT_POOL_MAX_POOLABLE_SIZE;
267-
disjoint_memory_pool_params.Capacity = DISJOINT_POOL_CAPACITY;
268-
disjoint_memory_pool_params.MinBucketSize = DISJOINT_POOL_MIN_BUCKET_SIZE;
263+
umf_disjoint_pool_params_handle_t disjoint_memory_pool_params = NULL;
264+
umf_result = umfDisjointPoolParamsCreate(&disjoint_memory_pool_params);
265+
if (umf_result != UMF_RESULT_SUCCESS) {
266+
fprintf(stderr, "ERROR: umfDisjointPoolParamsCreate failed\n");
267+
exit(-1);
268+
}
269+
270+
umf_result = umfDisjointPoolParamsSetSlabMinSize(
271+
disjoint_memory_pool_params, DISJOINT_POOL_SLAB_MIN_SIZE);
272+
if (umf_result != UMF_RESULT_SUCCESS) {
273+
fprintf(stderr,
274+
"error: umfDisjointPoolParamsSetSlabMinSize() failed\n");
275+
exit(-1);
276+
}
277+
278+
umf_result = umfDisjointPoolParamsSetMaxPoolableSize(
279+
disjoint_memory_pool_params, DISJOINT_POOL_MAX_POOLABLE_SIZE);
280+
if (umf_result != UMF_RESULT_SUCCESS) {
281+
fprintf(stderr,
282+
"error: umfDisjointPoolParamsSetMaxPoolableSize() failed\n");
283+
exit(-1);
284+
}
285+
286+
umf_result = umfDisjointPoolParamsSetCapacity(disjoint_memory_pool_params,
287+
DISJOINT_POOL_CAPACITY);
288+
if (umf_result != UMF_RESULT_SUCCESS) {
289+
fprintf(stderr, "error: umfDisjointPoolParamsSetCapacity() failed\n");
290+
exit(-1);
291+
}
292+
293+
umf_result = umfDisjointPoolParamsSetMinBucketSize(
294+
disjoint_memory_pool_params, DISJOINT_POOL_MIN_BUCKET_SIZE);
295+
if (umf_result != UMF_RESULT_SUCCESS) {
296+
fprintf(stderr,
297+
"error: umfDisjointPoolParamsSetMinBucketSize() failed\n");
298+
exit(-1);
299+
}
269300

270301
umf_memory_pool_handle_t disjoint_pool;
271302
umf_result = umfPoolCreate(umfDisjointPoolOps(), os_memory_provider,
272-
&disjoint_memory_pool_params, 0, &disjoint_pool);
303+
disjoint_memory_pool_params, 0, &disjoint_pool);
273304
if (umf_result != UMF_RESULT_SUCCESS) {
274305
fprintf(stderr, "error: umfPoolCreate() failed\n");
275306
exit(-1);
@@ -284,6 +315,7 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
284315
}
285316

286317
umfPoolDestroy(disjoint_pool);
318+
umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
287319
umfMemoryProviderDestroy(os_memory_provider);
288320
free(array);
289321
}
@@ -458,19 +490,50 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
458490
goto err_free_ipc_handles;
459491
}
460492

461-
umf_disjoint_pool_params_t disjoint_params = {0};
462-
disjoint_params.SlabMinSize = BUFFER_SIZE * 10;
463-
disjoint_params.MaxPoolableSize = 4ull * 1024ull * 1024ull;
464-
disjoint_params.Capacity = 64ull * 1024ull;
465-
disjoint_params.MinBucketSize = 64;
466-
umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_OWN_PROVIDER;
493+
umf_disjoint_pool_params_handle_t disjoint_params = NULL;
494+
umf_result = umfDisjointPoolParamsCreate(&disjoint_params);
495+
if (umf_result != UMF_RESULT_SUCCESS) {
496+
fprintf(stderr, "ERROR: umfDisjointPoolParamsCreate failed\n");
497+
goto err_provider_destroy;
498+
}
499+
500+
umf_result =
501+
umfDisjointPoolParamsSetSlabMinSize(disjoint_params, BUFFER_SIZE * 10);
502+
if (umf_result != UMF_RESULT_SUCCESS) {
503+
fprintf(stderr,
504+
"error: umfDisjointPoolParamsSetSlabMinSize() failed\n");
505+
goto err_params_destroy;
506+
}
507+
508+
umf_result = umfDisjointPoolParamsSetMaxPoolableSize(
509+
disjoint_params, 4ull * 1024ull * 1024ull);
510+
if (umf_result != UMF_RESULT_SUCCESS) {
511+
fprintf(stderr,
512+
"error: umfDisjointPoolParamsSetMaxPoolableSize() failed\n");
513+
goto err_params_destroy;
514+
}
515+
516+
umf_result =
517+
umfDisjointPoolParamsSetCapacity(disjoint_params, 64ull * 1024ull);
518+
if (umf_result != UMF_RESULT_SUCCESS) {
519+
fprintf(stderr, "error: umfDisjointPoolParamsSetCapacity() failed\n");
520+
goto err_params_destroy;
521+
}
522+
523+
umf_result = umfDisjointPoolParamsSetMinBucketSize(disjoint_params, 64);
524+
if (umf_result != UMF_RESULT_SUCCESS) {
525+
fprintf(stderr,
526+
"error: umfDisjointPoolParamsSetMinBucketSize() failed\n");
527+
goto err_params_destroy;
528+
}
529+
530+
umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_NONE;
467531
umf_memory_pool_handle_t pool;
468-
umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, &disjoint_params,
532+
umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, disjoint_params,
469533
flags, &pool);
470534
if (umf_result != UMF_RESULT_SUCCESS) {
471535
fprintf(stderr, "error: umfPoolCreate() failed\n");
472-
umfMemoryProviderDestroy(provider);
473-
goto err_free_ipc_handles;
536+
goto err_params_destroy;
474537
}
475538

476539
for (size_t i = 0; i < N_BUFFERS; ++i) {
@@ -495,6 +558,12 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
495558

496559
umfPoolDestroy(pool);
497560

561+
err_params_destroy:
562+
umfDisjointPoolParamsDestroy(disjoint_params);
563+
564+
err_provider_destroy:
565+
umfMemoryProviderDestroy(provider);
566+
498567
err_free_ipc_handles:
499568
free(ipc_handles);
500569

‎examples/cuda_shared_memory/cuda_shared_memory.c‎

Lines changed: 37 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -67,23 +67,48 @@ int main(void) {
6767

6868
// Setup parameters for the Disjoint Pool. It will be used for managing the
6969
// memory allocated using memory provider.
70-
umf_disjoint_pool_params_t disjoint_memory_pool_params =
71-
umfDisjointPoolParamsDefault();
70+
umf_disjoint_pool_params_handle_t hDisjointParams = NULL;
71+
res = umfDisjointPoolParamsCreate(&hDisjointParams);
72+
if (res != UMF_RESULT_SUCCESS) {
73+
fprintf(stderr, "disjoint pool params create failed\n");
74+
ret = -1;
75+
goto memory_provider_destroy;
76+
}
7277
// Set the Slab Min Size to 64KB - the page size for GPU allocations
73-
disjoint_memory_pool_params.SlabMinSize = 64 * 1024L;
78+
res = umfDisjointPoolParamsSetSlabMinSize(hDisjointParams, 64 * 1024L);
79+
if (res != UMF_RESULT_SUCCESS) {
80+
fprintf(stderr, "Failed to set the slab min size!\n");
81+
ret = -1;
82+
goto pool_params_destroy;
83+
}
7484
// We would keep only single slab per each allocation bucket
75-
disjoint_memory_pool_params.Capacity = 1;
85+
res = umfDisjointPoolParamsSetCapacity(hDisjointParams, 1);
86+
if (res != UMF_RESULT_SUCCESS) {
87+
fprintf(stderr, "Failed to set the capacity!\n");
88+
ret = -1;
89+
goto pool_params_destroy;
90+
}
7691
// Set the maximum poolable size to 64KB - objects with size above this
7792
// limit will not be stored/allocated from the pool.
78-
disjoint_memory_pool_params.MaxPoolableSize = 64 * 1024L;
93+
res = umfDisjointPoolParamsSetMaxPoolableSize(hDisjointParams, 64 * 1024L);
94+
if (res != UMF_RESULT_SUCCESS) {
95+
fprintf(stderr, "Failed to set the max poolable size!\n");
96+
ret = -1;
97+
goto pool_params_destroy;
98+
}
7999
// Enable tracing
80-
disjoint_memory_pool_params.PoolTrace = 1;
100+
res = umfDisjointPoolParamsSetTrace(hDisjointParams, 1);
101+
if (res != UMF_RESULT_SUCCESS) {
102+
fprintf(stderr, "Failed to set the pool trace!\n");
103+
ret = -1;
104+
goto pool_params_destroy;
105+
}
81106

82107
// Create Disjoint Pool memory pool.
83108
umf_memory_pool_handle_t cu_disjoint_memory_pool;
84-
res = umfPoolCreate(umfDisjointPoolOps(), cu_memory_provider,
85-
&disjoint_memory_pool_params, UMF_POOL_CREATE_FLAG_NONE,
86-
&cu_disjoint_memory_pool);
109+
res =
110+
umfPoolCreate(umfDisjointPoolOps(), cu_memory_provider, hDisjointParams,
111+
UMF_POOL_CREATE_FLAG_NONE, &cu_disjoint_memory_pool);
87112
if (res != UMF_RESULT_SUCCESS) {
88113
fprintf(stderr, "Failed to create a memory pool!\n");
89114
ret = -1;
@@ -116,6 +141,9 @@ int main(void) {
116141
memory_pool_destroy:
117142
umfPoolDestroy(cu_disjoint_memory_pool);
118143

144+
pool_params_destroy:
145+
umfDisjointPoolParamsDestroy(hDisjointParams);
146+
119147
memory_provider_destroy:
120148
umfMemoryProviderDestroy(cu_memory_provider);
121149

‎examples/dram_and_fsdax/dram_and_fsdax.c‎

Lines changed: 19 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -67,19 +67,35 @@ static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
6767
// so it should be used with a pool manager that will take over
6868
// the managing of the provided memory - for example the jemalloc pool
6969
// with the `disable_provider_free` parameter set to true.
70-
umf_jemalloc_pool_params_t pool_params;
71-
pool_params.disable_provider_free = true;
70+
umf_jemalloc_pool_params_handle_t pool_params;
71+
umf_result = umfJemallocPoolParamsCreate(&pool_params);
72+
if (umf_result != UMF_RESULT_SUCCESS) {
73+
fprintf(stderr, "Failed to create jemalloc params!\n");
74+
umfMemoryProviderDestroy(provider_fsdax);
75+
return NULL;
76+
}
77+
umf_result = umfJemallocPoolParamsSetKeepAllMemory(pool_params, true);
78+
if (umf_result != UMF_RESULT_SUCCESS) {
79+
fprintf(stderr, "Failed to set KeepAllMemory!\n");
80+
umfMemoryProviderDestroy(provider_fsdax);
81+
return NULL;
82+
}
7283

7384
// Create an FSDAX memory pool
7485
umf_result =
75-
umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, &pool_params,
86+
umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, pool_params,
7687
UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
7788
if (umf_result != UMF_RESULT_SUCCESS) {
7889
fprintf(stderr, "Failed to create an FSDAX memory pool!\n");
7990
umfMemoryProviderDestroy(provider_fsdax);
8091
return NULL;
8192
}
8293

94+
umf_result = umfJemallocPoolParamsDestroy(pool_params);
95+
if (umf_result != UMF_RESULT_SUCCESS) {
96+
fprintf(stderr, "Failed to destroy jemalloc params!\n");
97+
}
98+
8399
return pool_fsdax;
84100
}
85101

‎examples/ipc_level_zero/ipc_level_zero.c‎

Lines changed: 15 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -35,17 +35,29 @@ int create_level_zero_pool(ze_context_handle_t context,
3535
return -1;
3636
}
3737

38+
umf_disjoint_pool_params_handle_t disjoint_params = NULL;
39+
umf_result = umfDisjointPoolParamsCreate(&disjoint_params);
40+
if (umf_result != UMF_RESULT_SUCCESS) {
41+
fprintf(stderr, "ERROR: Failed to create pool params!\n");
42+
goto provider_destroy;
43+
}
44+
3845
// create pool
3946
umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_OWN_PROVIDER;
40-
umf_disjoint_pool_params_t disjoint_params = umfDisjointPoolParamsDefault();
41-
umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, &disjoint_params,
47+
umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, disjoint_params,
4248
flags, pool);
49+
umfDisjointPoolParamsDestroy(disjoint_params);
4350
if (umf_result != UMF_RESULT_SUCCESS) {
4451
fprintf(stderr, "ERROR: Failed to create pool!\n");
45-
return -1;
52+
goto provider_destroy;
4653
}
4754

4855
return 0;
56+
57+
provider_destroy:
58+
umfMemoryProviderDestroy(provider);
59+
60+
return -1;
4961
}
5062

5163
int main(void) {

‎examples/level_zero_shared_memory/level_zero_shared_memory.c‎

Lines changed: 38 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -72,27 +72,54 @@ int main(void) {
7272

7373
// Setup parameters for the Disjoint Pool. It will be used for managing the
7474
// memory allocated using memory provider.
75-
umf_disjoint_pool_params_t disjoint_memory_pool_params =
76-
umfDisjointPoolParamsDefault();
75+
umf_disjoint_pool_params_handle_t disjoint_memory_pool_params = NULL;
76+
res = umfDisjointPoolParamsCreate(&disjoint_memory_pool_params);
77+
if (res != UMF_RESULT_SUCCESS) {
78+
fprintf(stderr, "Failed to create pool params!\n");
79+
ret = -1;
80+
goto memory_provider_destroy;
81+
}
7782
// Set the Slab Min Size to 64KB - the page size for GPU allocations
78-
disjoint_memory_pool_params.SlabMinSize = 64 * 1024L;
83+
res = umfDisjointPoolParamsSetSlabMinSize(disjoint_memory_pool_params,
84+
64 * 1024L);
85+
if (res != UMF_RESULT_SUCCESS) {
86+
fprintf(stderr, "Failed to set Slab Min Size!\n");
87+
ret = -1;
88+
goto disjoint_params_destroy;
89+
}
7990
// We would keep only single slab per each allocation bucket
80-
disjoint_memory_pool_params.Capacity = 1;
91+
res = umfDisjointPoolParamsSetCapacity(disjoint_memory_pool_params, 1);
92+
if (res != UMF_RESULT_SUCCESS) {
93+
fprintf(stderr, "Failed to set Capacity!\n");
94+
ret = -1;
95+
goto disjoint_params_destroy;
96+
}
8197
// Set the maximum poolable size to 64KB - objects with size above this
8298
// limit will not be stored/allocated from the pool.
83-
disjoint_memory_pool_params.MaxPoolableSize = 64 * 1024L;
99+
res = umfDisjointPoolParamsSetMaxPoolableSize(disjoint_memory_pool_params,
100+
64 * 1024L);
101+
if (res != UMF_RESULT_SUCCESS) {
102+
fprintf(stderr, "Failed to set Max Poolable Size!\n");
103+
ret = -1;
104+
goto disjoint_params_destroy;
105+
}
84106
// Enable tracing
85-
disjoint_memory_pool_params.PoolTrace = 1;
107+
res = umfDisjointPoolParamsSetTrace(disjoint_memory_pool_params, 1);
108+
if (res != UMF_RESULT_SUCCESS) {
109+
fprintf(stderr, "Failed to set Trace!\n");
110+
ret = -1;
111+
goto disjoint_params_destroy;
112+
}
86113

87114
// Create Disjoint Pool memory pool.
88115
umf_memory_pool_handle_t ze_disjoint_memory_pool;
89116
res = umfPoolCreate(umfDisjointPoolOps(), ze_memory_provider,
90-
&disjoint_memory_pool_params, UMF_POOL_CREATE_FLAG_NONE,
117+
disjoint_memory_pool_params, UMF_POOL_CREATE_FLAG_NONE,
91118
&ze_disjoint_memory_pool);
92119
if (res != UMF_RESULT_SUCCESS) {
93120
fprintf(stderr, "Failed to create a memory pool!\n");
94121
ret = -1;
95-
goto memory_provider_destroy;
122+
goto disjoint_params_destroy;
96123
}
97124

98125
printf("Disjoint Pool created at %p\n", (void *)ze_disjoint_memory_pool);
@@ -121,6 +148,9 @@ int main(void) {
121148
memory_pool_destroy:
122149
umfPoolDestroy(ze_disjoint_memory_pool);
123150

151+
disjoint_params_destroy:
152+
umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
153+
124154
memory_provider_destroy:
125155
umfMemoryProviderDestroy(ze_memory_provider);
126156

0 commit comments

Comments
 (0)