Skip to content

Commit 5bb040d

Browse files
lukaszstolarczuklukaszstolarczuk
authored
Merge pull request #869 from ldorau/Remove_dead_code
Remove dead code
2 parents 64456b7 + ac2389b commit 5bb040d

File tree

9 files changed

+70
-277
lines changed

9 files changed

+70
-277
lines changed

‎examples/custom_file_provider/custom_file_provider.c

Lines changed: 2 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -113,10 +113,6 @@ static void file_deinit(void *provider) {
113113
// Function to allocate memory from the file provider
114114
static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
115115
void **ptr) {
116-
if (provider == NULL || ptr == NULL) {
117-
fprintf(stderr, "Provider or ptr cannot be null\n");
118-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
119-
}
120116
file_provider_t *file_provider = (file_provider_t *)provider;
121117
size_t page_size = file_provider->page_size;
122118

@@ -165,8 +161,8 @@ static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
165161

166162
// Function to free allocated memory from the file provider
167163
static umf_result_t file_free(void *provider, void *ptr, size_t size) {
168-
if (provider == NULL || ptr == NULL) {
169-
fprintf(stderr, "Provider or ptr cannot be null\n");
164+
if (ptr == NULL) {
165+
fprintf(stderr, "ptr cannot be null\n");
170166
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
171167
}
172168
file_provider_t *file_provider = (file_provider_t *)provider;
@@ -221,11 +217,6 @@ static void file_get_last_native_error(void *provider, const char **ppMessage,
221217
static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
222218
size_t *pageSize) {
223219
(void)size; // Unused parameter
224-
if (provider == NULL || pageSize == NULL) {
225-
fprintf(stderr, "Provider or pageSize cannot be null\n");
226-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
227-
}
228-
229220
file_provider_t *file_provider = (file_provider_t *)provider;
230221
*pageSize = file_provider->page_size;
231222
return UMF_RESULT_SUCCESS;
@@ -235,11 +226,6 @@ static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
235226
static umf_result_t file_get_min_page_size(void *provider, void *ptr,
236227
size_t *pageSize) {
237228
(void)ptr; // Unused parameter
238-
if (provider == NULL || pageSize == NULL) {
239-
fprintf(stderr, "Provider or pageSize cannot be null\n");
240-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
241-
}
242-
243229
file_provider_t *file_provider = (file_provider_t *)provider;
244230
*pageSize = file_provider->page_size;
245231
return UMF_RESULT_SUCCESS;

‎src/memory_provider.c

Lines changed: 29 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -226,6 +226,7 @@ checkErrorAndSetLastProvider(umf_result_t result,
226226
umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
227227
size_t size, size_t alignment, void **ptr) {
228228
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
229+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
229230
umf_result_t res =
230231
hProvider->ops.alloc(hProvider->provider_priv, size, alignment, ptr);
231232
checkErrorAndSetLastProvider(res, hProvider);
@@ -258,6 +259,7 @@ umf_result_t
258259
umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
259260
size_t size, size_t *pageSize) {
260261
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
262+
UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
261263
umf_result_t res = hProvider->ops.get_recommended_page_size(
262264
hProvider->provider_priv, size, pageSize);
263265
checkErrorAndSetLastProvider(res, hProvider);
@@ -268,6 +270,7 @@ umf_result_t
268270
umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
269271
void *ptr, size_t *pageSize) {
270272
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
273+
UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
271274
umf_result_t res = hProvider->ops.get_min_page_size(
272275
hProvider->provider_priv, ptr, pageSize);
273276
checkErrorAndSetLastProvider(res, hProvider);
@@ -282,6 +285,7 @@ const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider) {
282285
umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
283286
void *ptr, size_t size) {
284287
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
288+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
285289
umf_result_t res =
286290
hProvider->ops.ext.purge_lazy(hProvider->provider_priv, ptr, size);
287291
checkErrorAndSetLastProvider(res, hProvider);
@@ -291,6 +295,7 @@ umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
291295
umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
292296
void *ptr, size_t size) {
293297
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
298+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
294299
umf_result_t res =
295300
hProvider->ops.ext.purge_force(hProvider->provider_priv, ptr, size);
296301
checkErrorAndSetLastProvider(res, hProvider);
@@ -305,15 +310,11 @@ umf_result_t
305310
umfMemoryProviderAllocationSplit(umf_memory_provider_handle_t hProvider,
306311
void *ptr, size_t totalSize,
307312
size_t firstSize) {
308-
if (!ptr) {
309-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
310-
}
311-
if (firstSize == 0 || totalSize == 0) {
312-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
313-
}
314-
if (firstSize >= totalSize) {
315-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
316-
}
313+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
314+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
315+
UMF_CHECK((firstSize != 0 && totalSize != 0),
316+
UMF_RESULT_ERROR_INVALID_ARGUMENT);
317+
UMF_CHECK((firstSize < totalSize), UMF_RESULT_ERROR_INVALID_ARGUMENT);
317318

318319
umf_result_t res = hProvider->ops.ext.allocation_split(
319320
hProvider->provider_priv, ptr, totalSize, firstSize);
@@ -325,18 +326,13 @@ umf_result_t
325326
umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
326327
void *lowPtr, void *highPtr,
327328
size_t totalSize) {
328-
if (!lowPtr || !highPtr) {
329-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
330-
}
331-
if (totalSize == 0) {
332-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
333-
}
334-
if ((uintptr_t)lowPtr >= (uintptr_t)highPtr) {
335-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
336-
}
337-
if ((uintptr_t)highPtr - (uintptr_t)lowPtr > totalSize) {
338-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
339-
}
329+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
330+
UMF_CHECK((lowPtr && highPtr), UMF_RESULT_ERROR_INVALID_ARGUMENT);
331+
UMF_CHECK((totalSize != 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
332+
UMF_CHECK(((uintptr_t)lowPtr < (uintptr_t)highPtr),
333+
UMF_RESULT_ERROR_INVALID_ARGUMENT);
334+
UMF_CHECK(((uintptr_t)highPtr - (uintptr_t)lowPtr < totalSize),
335+
UMF_RESULT_ERROR_INVALID_ARGUMENT);
340336

341337
umf_result_t res = hProvider->ops.ext.allocation_merge(
342338
hProvider->provider_priv, lowPtr, highPtr, totalSize);
@@ -347,6 +343,8 @@ umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
347343
umf_result_t
348344
umfMemoryProviderGetIPCHandleSize(umf_memory_provider_handle_t hProvider,
349345
size_t *size) {
346+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
347+
UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
350348
return hProvider->ops.ipc.get_ipc_handle_size(hProvider->provider_priv,
351349
size);
352350
}
@@ -355,27 +353,37 @@ umf_result_t
355353
umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
356354
const void *ptr, size_t size,
357355
void *providerIpcData) {
356+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
357+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
358+
UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
358359
return hProvider->ops.ipc.get_ipc_handle(hProvider->provider_priv, ptr,
359360
size, providerIpcData);
360361
}
361362

362363
umf_result_t
363364
umfMemoryProviderPutIPCHandle(umf_memory_provider_handle_t hProvider,
364365
void *providerIpcData) {
366+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
367+
UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
365368
return hProvider->ops.ipc.put_ipc_handle(hProvider->provider_priv,
366369
providerIpcData);
367370
}
368371

369372
umf_result_t
370373
umfMemoryProviderOpenIPCHandle(umf_memory_provider_handle_t hProvider,
371374
void *providerIpcData, void **ptr) {
375+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
376+
UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
377+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
372378
return hProvider->ops.ipc.open_ipc_handle(hProvider->provider_priv,
373379
providerIpcData, ptr);
374380
}
375381

376382
umf_result_t
377383
umfMemoryProviderCloseIPCHandle(umf_memory_provider_handle_t hProvider,
378384
void *ptr, size_t size) {
385+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
386+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
379387
return hProvider->ops.ipc.close_ipc_handle(hProvider->provider_priv, ptr,
380388
size);
381389
}

‎src/provider/provider_coarse.c

Lines changed: 0 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1478,10 +1478,6 @@ coarse_memory_provider_get_stats(void *provider,
14781478

14791479
static umf_result_t coarse_memory_provider_purge_lazy(void *provider, void *ptr,
14801480
size_t size) {
1481-
if (provider == NULL || ptr == NULL) {
1482-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1483-
}
1484-
14851481
coarse_memory_provider_t *coarse_provider =
14861482
(struct coarse_memory_provider_t *)provider;
14871483
if (coarse_provider->upstream_memory_provider == NULL) {
@@ -1495,10 +1491,6 @@ static umf_result_t coarse_memory_provider_purge_lazy(void *provider, void *ptr,
14951491

14961492
static umf_result_t coarse_memory_provider_purge_force(void *provider,
14971493
void *ptr, size_t size) {
1498-
if (provider == NULL || ptr == NULL) {
1499-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1500-
}
1501-
15021494
coarse_memory_provider_t *coarse_provider =
15031495
(struct coarse_memory_provider_t *)provider;
15041496
if (coarse_provider->upstream_memory_provider == NULL) {
@@ -1514,11 +1506,6 @@ static umf_result_t coarse_memory_provider_allocation_split(void *provider,
15141506
void *ptr,
15151507
size_t totalSize,
15161508
size_t firstSize) {
1517-
if (provider == NULL || ptr == NULL || (firstSize >= totalSize) ||
1518-
firstSize == 0) {
1519-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1520-
}
1521-
15221509
umf_result_t umf_result;
15231510

15241511
coarse_memory_provider_t *coarse_provider =
@@ -1578,12 +1565,6 @@ static umf_result_t coarse_memory_provider_allocation_merge(void *provider,
15781565
void *lowPtr,
15791566
void *highPtr,
15801567
size_t totalSize) {
1581-
if (provider == NULL || lowPtr == NULL || highPtr == NULL ||
1582-
((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
1583-
((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
1584-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1585-
}
1586-
15871568
umf_result_t umf_result;
15881569

15891570
coarse_memory_provider_t *coarse_provider =

‎src/provider/provider_cuda.c

Lines changed: 5 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -160,7 +160,7 @@ static void init_cu_global_state(void) {
160160

161161
static umf_result_t cu_memory_provider_initialize(void *params,
162162
void **provider) {
163-
if (provider == NULL || params == NULL) {
163+
if (params == NULL) {
164164
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
165165
}
166166

@@ -214,11 +214,6 @@ static umf_result_t cu_memory_provider_initialize(void *params,
214214
}
215215

216216
static void cu_memory_provider_finalize(void *provider) {
217-
if (provider == NULL) {
218-
ASSERT(0);
219-
return;
220-
}
221-
222217
umf_ba_global_free(provider);
223218
}
224219

@@ -250,10 +245,6 @@ static inline umf_result_t set_context(CUcontext required_ctx,
250245
static umf_result_t cu_memory_provider_alloc(void *provider, size_t size,
251246
size_t alignment,
252247
void **resultPtr) {
253-
if (provider == NULL || resultPtr == NULL) {
254-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
255-
}
256-
257248
cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
258249

259250
if (alignment > cu_provider->min_alignment) {
@@ -318,10 +309,6 @@ static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
318309
size_t bytes) {
319310
(void)bytes;
320311

321-
if (provider == NULL) {
322-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
323-
}
324-
325312
if (ptr == NULL) {
326313
return UMF_RESULT_SUCCESS;
327314
}
@@ -385,10 +372,6 @@ static umf_result_t cu_memory_provider_get_min_page_size(void *provider,
385372
size_t *pageSize) {
386373
(void)ptr;
387374

388-
if (provider == NULL || pageSize == NULL) {
389-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
390-
}
391-
392375
cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
393376

394377
CUmemAllocationProp allocProps = {0};
@@ -407,10 +390,6 @@ cu_memory_provider_get_recommended_page_size(void *provider, size_t size,
407390
size_t *pageSize) {
408391
(void)size;
409392

410-
if (provider == NULL || pageSize == NULL) {
411-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
412-
}
413-
414393
cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
415394

416395
CUmemAllocationProp allocProps = {0};
@@ -431,10 +410,7 @@ static const char *cu_memory_provider_get_name(void *provider) {
431410

432411
static umf_result_t cu_memory_provider_get_ipc_handle_size(void *provider,
433412
size_t *size) {
434-
if (provider == NULL || size == NULL) {
435-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
436-
}
437-
413+
(void)provider;
438414
*size = sizeof(cu_ipc_data_t);
439415
return UMF_RESULT_SUCCESS;
440416
}
@@ -443,12 +419,9 @@ static umf_result_t cu_memory_provider_get_ipc_handle(void *provider,
443419
const void *ptr,
444420
size_t size,
445421
void *providerIpcData) {
422+
(void)provider;
446423
(void)size;
447424

448-
if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
449-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
450-
}
451-
452425
CUresult cu_result;
453426
cu_ipc_data_t *cu_ipc_data = (cu_ipc_data_t *)providerIpcData;
454427

@@ -463,20 +436,14 @@ static umf_result_t cu_memory_provider_get_ipc_handle(void *provider,
463436

464437
static umf_result_t cu_memory_provider_put_ipc_handle(void *provider,
465438
void *providerIpcData) {
466-
if (provider == NULL || providerIpcData == NULL) {
467-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
468-
}
469-
439+
(void)provider;
440+
(void)providerIpcData;
470441
return UMF_RESULT_SUCCESS;
471442
}
472443

473444
static umf_result_t cu_memory_provider_open_ipc_handle(void *provider,
474445
void *providerIpcData,
475446
void **ptr) {
476-
if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
477-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
478-
}
479-
480447
cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
481448

482449
CUresult cu_result;
@@ -505,10 +472,6 @@ static umf_result_t
505472
cu_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
506473
(void)size;
507474

508-
if (provider == NULL || ptr == NULL) {
509-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
510-
}
511-
512475
CUresult cu_result;
513476

514477
cu_result = g_cu_ops.cuIpcCloseMemHandle((CUdeviceptr)ptr);

0 commit comments

Comments
 (0)