Merge pull request #382 from Treece-Burgess/05-16-2025-cmp-memory-allocation

Treece-Burgess · web-flow · commit f2609ca9c2a0 · 2025-06-02T18:14:14.000-04:00
Various Components: Avoid Mixed Memory Allocation
diff --git a/src/components/coretemp/linux-coretemp.c b/src/components/coretemp/linux-coretemp.c
@@ -72,7 +72,7 @@ insert_in_list(char *name, char *units,
 		   /* Because this is a function, it is possible */
 		   /* we are called with root!=NULL but no last  */
 		   /* so add this to keep coverity happy         */
-		   free(temp);
+		   papi_free(temp);
 		   PAPIERROR("This shouldn't be possible\n");
 
 		   return PAPI_ECMP;
diff --git a/src/components/cuda/cupti_profiler.c b/src/components/cuda/cupti_profiler.c
@@ -460,7 +460,7 @@ static int get_counter_availability(cuptip_gpu_state_t *gpu_ctl)
 
     // Allocate the necessary memory for data
     gpu_ctl->counterAvailabilityImage.size = getCounterAvailabilityParams.counterAvailabilityImageSize;
-    gpu_ctl->counterAvailabilityImage.data = (uint8_t *) papi_malloc(gpu_ctl->counterAvailabilityImage.size);
+    gpu_ctl->counterAvailabilityImage.data = (uint8_t *) malloc(gpu_ctl->counterAvailabilityImage.size);
     if (gpu_ctl->counterAvailabilityImage.data == NULL) {
         ERRDBG("Failed to allocate memory for counterAvailabilityImage.data.\n");
         return PAPI_ENOMEM;
@@ -484,23 +484,23 @@ void free_and_reset_configuration_images(cuptip_gpu_state_t *gpu_ctl)
     COMPDBG("Entering.\n");
     // Note that you can find the memory allocation for the below variables
     // in cuptip_ctx_start as of April 21st, 2025
-    papi_free(gpu_ctl->configImage.data);
+    free(gpu_ctl->configImage.data);
     gpu_ctl->configImage.data = NULL;
     gpu_ctl->configImage.size = 0;
 
-    papi_free(gpu_ctl->counterDataPrefixImage.data);
+    free(gpu_ctl->counterDataPrefixImage.data);
     gpu_ctl->counterDataPrefixImage.data = NULL;
     gpu_ctl->counterDataPrefixImage.size = 0;
 
-    papi_free(gpu_ctl->counterDataScratchBuffer.data);
+    free(gpu_ctl->counterDataScratchBuffer.data);
     gpu_ctl->counterDataScratchBuffer.data = NULL;
     gpu_ctl->counterDataScratchBuffer.size = 0;
 
-    papi_free(gpu_ctl->counterDataImage.data);
+    free(gpu_ctl->counterDataImage.data);
     gpu_ctl->counterDataImage.data = NULL;
     gpu_ctl->counterDataImage.size = 0; 
     
-    papi_free(gpu_ctl->counterAvailabilityImage.data);
+    free(gpu_ctl->counterAvailabilityImage.data);
     gpu_ctl->counterAvailabilityImage.data = NULL;
     gpu_ctl->counterAvailabilityImage.size = 0;
 }
@@ -534,7 +534,7 @@ static int init_main_htable(void)
         val *= base;
     }    
    
-    cuptiu_table_p = (cuptiu_event_table_t *) papi_malloc(sizeof(cuptiu_event_table_t));
+    cuptiu_table_p = (cuptiu_event_table_t *) malloc(sizeof(cuptiu_event_table_t));
     if (cuptiu_table_p == NULL) {
         ERRDBG("Failed to allocate memory for cuptiu_table_p.\n");
         return PAPI_ENOMEM;
@@ -543,19 +543,19 @@ static int init_main_htable(void)
     cuptiu_table_p->count = 0;
     cuptiu_table_p->event_stats_count = 0;
 
-    cuptiu_table_p->events = (cuptiu_event_t *) papi_calloc(val, sizeof(cuptiu_event_t));
+    cuptiu_table_p->events = (cuptiu_event_t *) calloc(val, sizeof(cuptiu_event_t));
     if (cuptiu_table_p->events == NULL) {
         ERRDBG("Failed to allocate memory for cuptiu_table_p->events.\n");
         return PAPI_ENOMEM;
     }
 
-    cuptiu_table_p->event_stats = (StringVector *) papi_calloc(val, sizeof(StringVector));
+    cuptiu_table_p->event_stats = (StringVector *) calloc(val, sizeof(StringVector));
     if (cuptiu_table_p->event_stats == NULL) {
         ERRDBG("Failed to allocate memory for cuptiu_table_p->event_stats.\n");
         return PAPI_ENOMEM;
     }
 
-    cuptiu_table_p->avail_gpu_info = (gpu_record_t *) papi_calloc(numDevicesOnMachine, sizeof(gpu_record_t));
+    cuptiu_table_p->avail_gpu_info = (gpu_record_t *) calloc(numDevicesOnMachine, sizeof(gpu_record_t));
     if (cuptiu_table_p->avail_gpu_info == NULL) {
         ERRDBG("Failed to allocate memory for cuptiu_table_p->avail_gpu_info.\n");
         return PAPI_ENOMEM;
@@ -732,19 +732,19 @@ int cuptip_ctx_create(cuptic_info_t thr_info, cuptip_control_t *pstate, uint32_t
 {
     COMPDBG("Entering.\n");
 
-    cuptip_control_t state = (cuptip_control_t) papi_calloc (1, sizeof(struct cuptip_control_s));
+    cuptip_control_t state = (cuptip_control_t) calloc (1, sizeof(struct cuptip_control_s));
     if (state == NULL) {
         SUBDBG("Failed to allocate memory for state.\n");
         return PAPI_ENOMEM;
     }
 
-    state->gpu_ctl = (cuptip_gpu_state_t *) papi_calloc(numDevicesOnMachine, sizeof(cuptip_gpu_state_t));
+    state->gpu_ctl = (cuptip_gpu_state_t *) calloc(numDevicesOnMachine, sizeof(cuptip_gpu_state_t));
     if (state->gpu_ctl == NULL) {
         SUBDBG("Failed to allocate memory for state->gpu_ctl.\n"); 
         return PAPI_ENOMEM;
     }
 
-    long long *counters = (long long *) papi_malloc(num_events * sizeof(*counters));
+    long long *counters = (long long *) malloc(num_events * sizeof(*counters));
     if (counters == NULL) {
         SUBDBG("Failed to allocate memory for counters.\n");
         return PAPI_ENOMEM;
@@ -1034,7 +1034,7 @@ int cuptip_ctx_read(cuptip_control_t state, long long **counters)
                 }
             }
         }
-        papi_free(metricValues);
+        free(metricValues);
         *counters = counter_vals;
 
         papi_errno = begin_pass();
@@ -1165,15 +1165,15 @@ int cuptip_ctx_destroy(cuptip_control_t *pstate)
         // Free the created rawMetricRequests from cuptip_ctx_start
         int j;
         for (j = 0; j < state->gpu_ctl[i].numberOfRawMetricRequests; j++) {
-            papi_free((void *) state->gpu_ctl[i].rawMetricRequests[j].pMetricName);
+            free((void *) state->gpu_ctl[i].rawMetricRequests[j].pMetricName);
         }
-        papi_free(state->gpu_ctl[i].rawMetricRequests);
+        free(state->gpu_ctl[i].rawMetricRequests);
     }
 
     // Free the allocated memory from cuptip_ctx_create
-    papi_free(state->counters);
-    papi_free(state->gpu_ctl);
-    papi_free(state);
+    free(state->counters);
+    free(state->gpu_ctl);
+    free(state);
     *pstate = NULL;
 
     return PAPI_OK;
@@ -1522,13 +1522,13 @@ static void shutdown_event_table(void)
 {
     cuptiu_table_p->count = 0;
 
-    papi_free(cuptiu_table_p->avail_gpu_info);
+    free(cuptiu_table_p->avail_gpu_info);
     cuptiu_table_p->avail_gpu_info = NULL;
 
-    papi_free(cuptiu_table_p->events);
+    free(cuptiu_table_p->events);
     cuptiu_table_p->events = NULL;
 
-    papi_free(cuptiu_table_p);
+    free(cuptiu_table_p);
     cuptiu_table_p = NULL;
 }
 
@@ -1545,7 +1545,7 @@ static void shutdown_event_stats_table(void)
     
     cuptiu_table_p->event_stats_count = 0;
 
-    papi_free(cuptiu_table_p->event_stats);
+    free(cuptiu_table_p->event_stats);
 }
 
 /** @class cuptip_evt_enum
diff --git a/src/components/cuda/cupti_utils.c b/src/components/cuda/cupti_utils.c
@@ -16,7 +16,7 @@
 
 int cuptiu_event_table_create_init_capacity(int capacity, int sizeof_rec, cuptiu_event_table_t **pevt_table)
 {
-    cuptiu_event_table_t *evt_table = (cuptiu_event_table_t *) papi_malloc(sizeof(cuptiu_event_table_t));
+    cuptiu_event_table_t *evt_table = (cuptiu_event_table_t *) malloc(sizeof(cuptiu_event_table_t));
     if (evt_table == NULL) {
         goto fn_fail;
     }
@@ -48,7 +48,7 @@ void cuptiu_event_table_destroy(cuptiu_event_table_t **pevt_table)
         evt_table->htable = NULL;
     }
 
-    papi_free(evt_table);
+    free(evt_table);
     *pevt_table = NULL;
 }
 
@@ -133,4 +133,4 @@ void free_vector(StringVector *vec) {
     }
     free(vec->arrayMetricStatistics); 
     vec->arrayMetricStatistics = NULL;
-}
+}
diff --git a/src/components/cuda/htable.h b/src/components/cuda/htable.h
@@ -121,7 +121,7 @@ htable_insert(void *handle, const char *key, void *in)
     return htable_errno;
   fn_fail:
     if (entry) {
-        papi_free(entry);
+        free(entry);
     }
     goto fn_exit;
 }
@@ -196,13 +196,13 @@ create_table(uint64_t size, struct hash_table **table)
 {
     int htable_errno = HTABLE_SUCCESS;
 
-    *table = papi_calloc(1, sizeof(**table));
+    *table = calloc(1, sizeof(**table));
     if (table == NULL) {
         htable_errno = HTABLE_ENOMEM;
         goto fn_exit;
     }
 
-    (*table)->buckets = papi_calloc(size, sizeof(*(*table)->buckets));
+    (*table)->buckets = calloc(size, sizeof(*(*table)->buckets));
     if ((*table)->buckets == NULL) {
         htable_errno = HTABLE_ENOMEM;
         goto fn_exit;
@@ -220,11 +220,11 @@ destroy_table(struct hash_table *table)
     int htable_errno = HTABLE_SUCCESS;
 
     if (table && table->buckets) {
-        papi_free(table->buckets);
+        free(table->buckets);
     }
 
     if (table) {
-        papi_free(table);
+        free(table);
     }
 
     return htable_errno;
@@ -258,7 +258,7 @@ move_table(struct hash_table *new_table, struct hash_table *old_table)
     old_table->size = new_table->size;
     old_table->buckets = new_table->buckets;
     new_table->buckets = NULL;
-    papi_free(old_buckets);
+    free(old_buckets);
 
     return htable_errno;
 }
@@ -322,7 +322,7 @@ create_table_entry(const char *key, void *val, struct hash_table_entry **entry)
 {
     int htable_errno = HTABLE_SUCCESS;
 
-    *entry = papi_calloc(1, sizeof(**entry));
+    *entry = calloc(1, sizeof(**entry));
     if (*entry == NULL) {
         return HTABLE_ENOMEM;
     }
@@ -337,8 +337,8 @@ int
 destroy_table_entry(struct hash_table_entry *entry)
 {
     int htable_errno = HTABLE_SUCCESS;
-    papi_free(entry->key);
-    papi_free(entry);
+    free(entry->key);
+    free(entry);
     return htable_errno;
 }
 
diff --git a/src/components/cuda/linux-cuda.c b/src/components/cuda/linux-cuda.c
@@ -449,7 +449,7 @@ int update_native_events(cuda_control_t *ctl, NativeInfo_t *ntv_info,
     struct event_map_item sorted_events[PAPI_CUDA_MAX_COUNTERS];
 
     if (ntv_count != ctl->num_events) {
-        ctl->events_id = papi_realloc(ctl->events_id,
+        ctl->events_id = realloc(ctl->events_id,
                                       ntv_count * sizeof(*ctl->events_id));
         if (ctl->events_id == NULL) {
             papi_errno = PAPI_ENOMEM;
@@ -642,7 +642,7 @@ static int cuda_cleanup_eventset(hwd_control_state_t *ctl)
     }
 
     /* free int array of event id's and reset number of events */
-    papi_free(cuda_ctl->events_id);
+    free(cuda_ctl->events_id);
     cuda_ctl->events_id = NULL;
     cuda_ctl->num_events = 0;
 
diff --git a/src/components/cuda/papi_cupti_common.c b/src/components/cuda/papi_cupti_common.c
@@ -761,7 +761,7 @@ int cuptic_ctxarr_create(cuptic_info_t *pinfo)
     }
   
     /* allocate memory */ 
-    *pinfo = (cuptic_info_t) papi_calloc (total_gpus, sizeof(*pinfo));
+    *pinfo = (cuptic_info_t) calloc (total_gpus, sizeof(*pinfo));
     if (*pinfo == NULL) {
         return PAPI_ENOMEM;
     }
@@ -837,7 +837,7 @@ int cuptic_ctxarr_get_ctx(cuptic_info_t info, int gpu_idx, CUcontext *ctx)
 
 int cuptic_ctxarr_destroy(cuptic_info_t *pinfo)
 {
-    papi_free(*pinfo);
+    free(*pinfo);
     *pinfo = NULL;
     return PAPI_OK;
 }
diff --git a/src/components/infiniband/linux-infiniband.c b/src/components/infiniband/linux-infiniband.c
@@ -303,11 +303,12 @@ add_ib_device(const char* name, int port)
         return (0);
     }
 
-    new_dev->dev_name = strdup(name);
+    new_dev->dev_name = papi_strdup(name);
     new_dev->dev_port = port;
     if (new_dev->dev_name==0)
     {
         PAPIERROR("cannot allocate memory for device internal fields");
+        papi_free(new_dev->dev_name);
         papi_free(new_dev);
         return (0);
     }
@@ -328,8 +329,8 @@ add_ib_counter(const char* name, const char* file_name, int extended, ib_device_
         return (0);
     }
 
-    new_cnt->ev_name = strdup(name);
-    new_cnt->ev_file_name = strdup(file_name);
+    new_cnt->ev_name = papi_strdup(name);
+    new_cnt->ev_file_name = papi_strdup(file_name);
     new_cnt->extended = extended;
     new_cnt->ev_device = device;
     if (new_cnt->ev_name==0 || new_cnt->ev_file_name==0)
@@ -599,9 +600,9 @@ deallocate_infiniband_resources()
     {
         for (i=0 ; i<num_events ; ++i) {
             if (infiniband_native_events[i].name)
-                free(infiniband_native_events[i].name);
+                papi_free(infiniband_native_events[i].name);
             if (infiniband_native_events[i].file_name)
-                free(infiniband_native_events[i].file_name);
+                papi_free(infiniband_native_events[i].file_name);
             if (infiniband_native_events[i].description)
                 papi_free(infiniband_native_events[i].description);
         }
@@ -612,7 +613,7 @@ deallocate_infiniband_resources()
     while (iter != 0) 
     {
         if (iter->dev_name)
-            free(iter->dev_name);
+            papi_free(iter->dev_name);
 
         ib_device_t *tmp = iter;
         iter = iter->next;
diff --git a/src/components/net/linux-net.c b/src/components/net/linux-net.c
@@ -173,7 +173,7 @@ generateNetEventList( void )
             } else if (last) {
                 last->next = temp;
             } else {
-                free(temp);
+                papi_free(temp);
                 fclose(fin);
                 PAPIERROR("This shouldn't be possible\n");
                 snprintf(_net_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN-2,
diff --git a/src/components/rocm/htable.h b/src/components/rocm/htable.h
@@ -325,7 +325,7 @@ create_table_entry(const char *key, void *val, struct hash_table_entry **entry)
     if (*entry == NULL) {
         return HTABLE_ENOMEM;
     }
-    (*entry)->key = strdup(key);
+    (*entry)->key = papi_strdup(key);
     (*entry)->val = val;
     (*entry)->next = NULL;
 
diff --git a/src/components/rocm_smi/htable.h b/src/components/rocm_smi/htable.h
@@ -325,7 +325,7 @@ create_table_entry(const char *key, void *val, struct hash_table_entry **entry)
     if (*entry == NULL) {
         return HTABLE_ENOMEM;
     }
-    (*entry)->key = strdup(key);
+    (*entry)->key = papi_strdup(key);
     (*entry)->val = val;
     (*entry)->next = NULL;
 
diff --git a/src/components/rocm_smi/rocs.c b/src/components/rocm_smi/rocs.c

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`
`17`	`17`	`int cuptiu_event_table_create_init_capacity(int capacity, int sizeof_rec, cuptiu_event_table_t **pevt_table)`
`18`	`18`	`{`
`19`		`- cuptiu_event_table_t evt_table = (cuptiu_event_table_t ) papi_malloc(sizeof(cuptiu_event_table_t));`
	`19`	`+ cuptiu_event_table_t evt_table = (cuptiu_event_table_t ) malloc(sizeof(cuptiu_event_table_t));`
`20`	`20`	`if (evt_table == NULL) {`
`21`	`21`	`goto fn_fail;`
`22`	`22`	`}`
`@@ -48,7 +48,7 @@ void cuptiu_event_table_destroy(cuptiu_event_table_t **pevt_table)`
`48`	`48`	`evt_table->htable = NULL;`
`49`	`49`	`}`
`50`	`50`
`51`		`- papi_free(evt_table);`
	`51`	`+ free(evt_table);`
`52`	`52`	`*pevt_table = NULL;`
`53`	`53`	`}`
`54`	`54`
`@@ -133,4 +133,4 @@ void free_vector(StringVector *vec) {`
`133`	`133`	`}`
`134`	`134`	`free(vec->arrayMetricStatistics);`
`135`	`135`	`vec->arrayMetricStatistics = NULL;`
`136`		`-}`
	`136`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ htable_insert(void handle, const char key, void *in)`
`121`	`121`	`return htable_errno;`
`122`	`122`	`fn_fail:`
`123`	`123`	`if (entry) {`
`124`		`- papi_free(entry);`
	`124`	`+ free(entry);`
`125`	`125`	`}`
`126`	`126`	`goto fn_exit;`
`127`	`127`	`}`
`@@ -196,13 +196,13 @@ create_table(uint64_t size, struct hash_table **table)`
`196`	`196`	`{`
`197`	`197`	`int htable_errno = HTABLE_SUCCESS;`
`198`	`198`
`199`		`- table = papi_calloc(1, sizeof(*table));`
	`199`	`+ table = calloc(1, sizeof(*table));`
`200`	`200`	`if (table == NULL) {`
`201`	`201`	`htable_errno = HTABLE_ENOMEM;`
`202`	`202`	`goto fn_exit;`
`203`	`203`	`}`
`204`	`204`
`205`		`- (table)->buckets = papi_calloc(size, sizeof((*table)->buckets));`
	`205`	`+ (table)->buckets = calloc(size, sizeof((*table)->buckets));`
`206`	`206`	`if ((*table)->buckets == NULL) {`
`207`	`207`	`htable_errno = HTABLE_ENOMEM;`
`208`	`208`	`goto fn_exit;`
`@@ -220,11 +220,11 @@ destroy_table(struct hash_table *table)`
`220`	`220`	`int htable_errno = HTABLE_SUCCESS;`
`221`	`221`
`222`	`222`	`if (table && table->buckets) {`
`223`		`- papi_free(table->buckets);`
	`223`	`+ free(table->buckets);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`if (table) {`
`227`		`- papi_free(table);`
	`227`	`+ free(table);`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`return htable_errno;`
`@@ -258,7 +258,7 @@ move_table(struct hash_table new_table, struct hash_table old_table)`
`258`	`258`	`old_table->size = new_table->size;`
`259`	`259`	`old_table->buckets = new_table->buckets;`
`260`	`260`	`new_table->buckets = NULL;`
`261`		`- papi_free(old_buckets);`
	`261`	`+ free(old_buckets);`
`262`	`262`
`263`	`263`	`return htable_errno;`
`264`	`264`	`}`
`@@ -322,7 +322,7 @@ create_table_entry(const char key, void val, struct hash_table_entry **entry)`
`322`	`322`	`{`
`323`	`323`	`int htable_errno = HTABLE_SUCCESS;`
`324`	`324`
`325`		`- entry = papi_calloc(1, sizeof(*entry));`
	`325`	`+ entry = calloc(1, sizeof(*entry));`
`326`	`326`	`if (*entry == NULL) {`
`327`	`327`	`return HTABLE_ENOMEM;`
`328`	`328`	`}`
`@@ -337,8 +337,8 @@ int`
`337`	`337`	`destroy_table_entry(struct hash_table_entry *entry)`
`338`	`338`	`{`
`339`	`339`	`int htable_errno = HTABLE_SUCCESS;`
`340`		`- papi_free(entry->key);`
`341`		`- papi_free(entry);`
	`340`	`+ free(entry->key);`
	`341`	`+ free(entry);`
`342`	`342`	`return htable_errno;`
`343`	`343`	`}`
`344`	`344`
Original file line number	Diff line number	Diff line change
`@@ -761,7 +761,7 @@ int cuptic_ctxarr_create(cuptic_info_t *pinfo)`
`761`	`761`	`}`
`762`	`762`
`763`	`763`	`/* allocate memory */`
`764`		`- pinfo = (cuptic_info_t) papi_calloc (total_gpus, sizeof(pinfo));`
	`764`	`+ pinfo = (cuptic_info_t) calloc (total_gpus, sizeof(pinfo));`
`765`	`765`	`if (*pinfo == NULL) {`
`766`	`766`	`return PAPI_ENOMEM;`
`767`	`767`	`}`
`@@ -837,7 +837,7 @@ int cuptic_ctxarr_get_ctx(cuptic_info_t info, int gpu_idx, CUcontext *ctx)`
`837`	`837`
`838`	`838`	`int cuptic_ctxarr_destroy(cuptic_info_t *pinfo)`
`839`	`839`	`{`
`840`		`- papi_free(*pinfo);`
	`840`	`+ free(*pinfo);`
`841`	`841`	`*pinfo = NULL;`
`842`	`842`	`return PAPI_OK;`
`843`	`843`	`}`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ create_table_entry(const char key, void val, struct hash_table_entry **entry)`
`325`	`325`	`if (*entry == NULL) {`
`326`	`326`	`return HTABLE_ENOMEM;`
`327`	`327`	`}`
`328`		`- (*entry)->key = strdup(key);`
	`328`	`+ (*entry)->key = papi_strdup(key);`
`329`	`329`	`(*entry)->val = val;`
`330`	`330`	`(*entry)->next = NULL;`
`331`	`331`