Remaining malloc to new

ODIN_II/SRC/adders.cpp

@@ -1064,7 +1064,7 @@ void remove_list_node(t_linked_vptr* pre, t_linked_vptr* next) {
         pre->next = next->next;
     else
         pre->next = NULL;
-    vtr::free(next);
+    delete next;
 }
 
 /*---------------------------------------------------------------------------
@@ -1434,4 +1434,4 @@ nnode_t* check_missing_ports(nnode_t* node, uintptr_t traverse_mark_number, netl
     }
 
     return new_node;
-}
+}

libs/libvtrutil/src/vtr_list.cpp

@@ -9,24 +9,16 @@ t_linked_vptr* insert_in_vptr_list(t_linked_vptr* head, void* vptr_to_add) {
     /* Inserts a new element at the head of a linked list of void pointers. *
      * Returns the new head of the list.                                    */
 
-    t_linked_vptr* linked_vptr;
-
-    linked_vptr = (t_linked_vptr*)vtr::malloc(sizeof(t_linked_vptr));
-
-    linked_vptr->data_vptr = vptr_to_add;
-    linked_vptr->next = head;
-    return (linked_vptr); /* New head of the list */
+    return new t_linked_vptr{vptr_to_add, head}; /* New head of the list */
 }
 
 /* Deletes the element at the head of a linked list of void pointers. *
  * Returns the new head of the list.                                    */
 t_linked_vptr* delete_in_vptr_list(t_linked_vptr* head) {
-    t_linked_vptr* linked_vptr;
-
     if (head == nullptr)
         return nullptr;
-    linked_vptr = head->next;
-    free(head);
+    t_linked_vptr* const linked_vptr = head->next;
+    delete head;
     return linked_vptr; /* New head of the list */
 }
 

libs/libvtrutil/src/vtr_memory.cpp

@@ -1,5 +1,6 @@
 #include <cstddef>
 #include <cstdlib>
+#include <math.h>
 
 #include "vtr_assert.h"
 #include "vtr_list.h"
@@ -43,7 +44,7 @@ void* calloc(size_t nelem, size_t size) {
     if ((ret = std::calloc(nelem, size)) == nullptr) {
         throw VtrError("Unable to calloc memory.", __FILE__, __LINE__);
     }
-    return (ret);
+    return ret;
 }
 
 void* malloc(size_t size) {
@@ -55,7 +56,7 @@ void* malloc(size_t size) {
     if ((ret = std::malloc(size)) == nullptr && size != 0) {
         throw VtrError("Unable to malloc memory.", __FILE__, __LINE__);
     }
-    return (ret);
+    return ret;
 }
 
 void* realloc(void* ptr, size_t size) {
@@ -66,7 +67,7 @@ void* realloc(void* ptr, size_t size) {
         throw VtrError(string_fmt("Unable to realloc memory (ptr=%p, size=%d).", ptr, size),
                        __FILE__, __LINE__);
     }
-    return (ret);
+    return ret;
 }
 
 void* chunk_malloc(size_t size, t_chunk* chunk_info) {
@@ -102,7 +103,9 @@ void* chunk_malloc(size_t size, t_chunk* chunk_info) {
 
     if ((size_t)(chunk_info->mem_avail) < size) { /* Need to malloc more memory. */
         if (size > CHUNK_SIZE) {                  /* Too big, use standard routine. */
-            tmp_ptr = (char*)vtr::malloc(size);
+                                                  /* Want to allocate a block of memory the size of size.
+                                                   * i.e. malloc(size) */
+            tmp_ptr = new char[size];
 
             /* When debugging, uncomment the code below to see if memory allocation size */
             /* makes sense */
@@ -113,11 +116,11 @@ void* chunk_malloc(size_t size, t_chunk* chunk_info) {
 
             VTR_ASSERT(chunk_info != nullptr);
             chunk_info->chunk_ptr_head = insert_in_vptr_list(chunk_info->chunk_ptr_head, tmp_ptr);
-            return (tmp_ptr);
+            return tmp_ptr;
         }
 
         if (chunk_info->mem_avail < FRAGMENT_THRESHOLD) { /* Only a small scrap left. */
-            chunk_info->next_mem_loc_ptr = (char*)vtr::malloc(CHUNK_SIZE);
+            chunk_info->next_mem_loc_ptr = new char[CHUNK_SIZE];
             chunk_info->mem_avail = CHUNK_SIZE;
             VTR_ASSERT(chunk_info != nullptr);
             chunk_info->chunk_ptr_head = insert_in_vptr_list(chunk_info->chunk_ptr_head, chunk_info->next_mem_loc_ptr);
@@ -128,10 +131,11 @@ void* chunk_malloc(size_t size, t_chunk* chunk_info) {
          * to allocate normally.                                           */
 
         else {
-            tmp_ptr = (char*)vtr::malloc(size);
+            tmp_ptr = new char[size];
             VTR_ASSERT(chunk_info != nullptr);
             chunk_info->chunk_ptr_head = insert_in_vptr_list(chunk_info->chunk_ptr_head, tmp_ptr);
-            return (tmp_ptr);
+
+            return tmp_ptr;
         }
     }
 
@@ -147,7 +151,7 @@ void* chunk_malloc(size_t size, t_chunk* chunk_info) {
     tmp_ptr = chunk_info->next_mem_loc_ptr;
     chunk_info->next_mem_loc_ptr += aligned_size;
     chunk_info->mem_avail -= aligned_size;
-    return (tmp_ptr);
+    return tmp_ptr;
 }
 
 void free_chunk_memory(t_chunk* chunk_info) {
@@ -158,11 +162,14 @@ void free_chunk_memory(t_chunk* chunk_info) {
     curr_ptr = chunk_info->chunk_ptr_head;
 
     while (curr_ptr != nullptr) {
-        free(curr_ptr->data_vptr); /* Free memory "chunk". */
+        /* Must cast pointers to type char*, since the're of type void*, which delete can't
+         * be called on.*/
+        delete[]((char*)curr_ptr->data_vptr); /* Free memory "chunk". */
         prev_ptr = curr_ptr;
         curr_ptr = curr_ptr->next;
-        free(prev_ptr); /* Free memory used to track "chunk". */
+        delete (t_linked_vptr*)prev_ptr; /* Free memory used to track "chunk". */
     }
+
     chunk_info->chunk_ptr_head = nullptr;
     chunk_info->mem_avail = 0;
     chunk_info->next_mem_loc_ptr = nullptr;

vpr/src/base/SetupVPR.cpp

@@ -648,9 +648,11 @@ static void SetupPowerOpts(const t_options& Options, t_power_opts* power_opts, t
 
     if (power_opts->do_power) {
         if (!Arch->power)
-            Arch->power = (t_power_arch*)vtr::malloc(sizeof(t_power_arch));
+            Arch->power = new t_power_arch();
+
         if (!Arch->clocks)
-            Arch->clocks = (t_clock_arch*)vtr::malloc(sizeof(t_clock_arch));
+            Arch->clocks = new t_clock_arch();
+
         device_ctx.clock_arch = Arch->clocks;
     } else {
         Arch->power = nullptr;

vpr/src/draw/draw.cpp

@@ -516,8 +516,7 @@ void alloc_draw_structs(const t_arch* arch) {
 
     /* Space is allocated for draw_rr_node but not initialized because we do *
      * not yet know information about the routing resources.				  */
-    draw_state->draw_rr_node = (t_draw_rr_node*)vtr::malloc(
-        device_ctx.rr_graph.num_nodes() * sizeof(t_draw_rr_node));
+    draw_state->draw_rr_node.resize(device_ctx.rr_graph.num_nodes());
 
     draw_state->arch_info = arch;
 
@@ -534,7 +533,6 @@ void free_draw_structs() {
      *
      * For safety, set all the array pointers to NULL in case any data
      * structure gets freed twice.													 */
-    t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
 
     if (draw_coords != nullptr) {
@@ -544,10 +542,6 @@ void free_draw_structs() {
         draw_coords->tile_y = nullptr;
     }
 
-    if (draw_state != nullptr) {
-        free(draw_state->draw_rr_node);
-        draw_state->draw_rr_node = nullptr;
-    }
 #else
     ;
 #endif /* NO_GRAPHICS */
@@ -569,9 +563,7 @@ void init_draw_coords(float width_val) {
     /* Each time routing is on screen, need to reallocate the color of each *
      * rr_node, as the number of rr_nodes may change.						*/
     if (rr_graph.num_nodes() != 0) {
-        draw_state->draw_rr_node = (t_draw_rr_node*)vtr::realloc(
-            draw_state->draw_rr_node,
-            (rr_graph.num_nodes()) * sizeof(t_draw_rr_node));
+        draw_state->draw_rr_node.resize(rr_graph.num_nodes());
         /*FIXME: the type cast should be eliminated by making draw_rr_node adapt RRNodeId */
         for (const RRNodeId& rr_id : rr_graph.nodes()) {
             draw_state->draw_rr_node[(size_t)rr_id].color = DEFAULT_RR_NODE_COLOR;

vpr/src/draw/draw_types.h

@@ -203,7 +203,7 @@ struct t_draw_state {
     e_route_type draw_route_type = GLOBAL;
     char default_message[vtr::bufsize];
     vtr::vector<ClusterNetId, ezgl::color> net_color;
-    t_draw_rr_node* draw_rr_node = nullptr;
+    std::vector<t_draw_rr_node> draw_rr_node;
     std::shared_ptr<const SetupTimingInfo> setup_timing_info;
     const t_arch* arch_info = nullptr;
     std::shared_ptr<const vtr::ColorMap> color_map = nullptr;

vpr/src/pack/cluster_util.cpp

@@ -815,6 +815,7 @@ void alloc_and_load_pb_stats(t_pb* pb, const int feasible_block_array_size) {
     pb->pb_stats->lookahead_output_pins_used = std::vector<std::vector<AtomNetId>>(pb->pb_graph_node->num_output_pin_class);
     pb->pb_stats->num_feasible_blocks = NOT_VALID;
     pb->pb_stats->feasible_blocks = new t_pack_molecule*[feasible_block_array_size];
+
     for (int i = 0; i < feasible_block_array_size; i++)
         pb->pb_stats->feasible_blocks[i] = nullptr;
 

vpr/src/place/place_macro.cpp

@@ -424,17 +424,17 @@ void free_placement_macros_structs() {
     unsigned int itype;
     if (f_idirect_from_blk_pin != nullptr) {
         for (itype = 1; itype < device_ctx.physical_tile_types.size(); itype++) {
-            free(f_idirect_from_blk_pin[itype]);
+            delete[](f_idirect_from_blk_pin[itype]);
         }
-        free(f_idirect_from_blk_pin);
+        delete[](f_idirect_from_blk_pin);
         f_idirect_from_blk_pin = nullptr;
     }
 
     if (f_direct_type_from_blk_pin != nullptr) {
         for (itype = 1; itype < device_ctx.physical_tile_types.size(); itype++) {
-            free(f_direct_type_from_blk_pin[itype]);
+            delete[](f_direct_type_from_blk_pin[itype]);
         }
-        free(f_direct_type_from_blk_pin);
+        delete[](f_direct_type_from_blk_pin);
         f_direct_type_from_blk_pin = nullptr;
     }
 }