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

@@ -11,7 +11,7 @@ t_linked_vptr* insert_in_vptr_list(t_linked_vptr* head, void* vptr_to_add) {
 
     t_linked_vptr* linked_vptr;
 
-    linked_vptr = (t_linked_vptr*)vtr::malloc(sizeof(t_linked_vptr));
+    linked_vptr = new t_linked_vptr;
 
     linked_vptr->data_vptr = vptr_to_add;
     linked_vptr->next = head;
@@ -26,7 +26,7 @@ t_linked_vptr* delete_in_vptr_list(t_linked_vptr* head) {
     if (head == nullptr)
         return nullptr;
     linked_vptr = head->next;
-    free(head);
+    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"
@@ -101,7 +102,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[(int)ceil(size / sizeof(char))];
 
             /* When debugging, uncomment the code below to see if memory allocation size */
             /* makes sense */
@@ -116,7 +119,7 @@ void* chunk_malloc(size_t size, t_chunk* chunk_info) {
         }
 
         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[(int)ceil(CHUNK_SIZE / sizeof(char))];
             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);
@@ -127,9 +130,10 @@ void* chunk_malloc(size_t size, t_chunk* chunk_info) {
          * to allocate normally.                                           */
 
         else {
-            tmp_ptr = (char*)vtr::malloc(size);
+            tmp_ptr = new char[(int)ceil(size / sizeof(char))];
             VTR_ASSERT(chunk_info != nullptr);
             chunk_info->chunk_ptr_head = insert_in_vptr_list(chunk_info->chunk_ptr_head, tmp_ptr);
+
             return (tmp_ptr);
         }
     }
@@ -157,11 +161,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/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;
     }
 }

vpr/src/power/power.cpp

@@ -173,7 +173,7 @@ static void power_usage_primitive(t_power_usage* power_usage, t_pb* pb, t_pb_gra
                         power_ctx.arch->LUT_transistor_size, SRAM_values,
                         input_probabilities, input_densities, power_ctx.solution_inf.T_crit);
         power_add_usage(power_usage, &sub_power_usage);
-        free(SRAM_values);
+        delete[](SRAM_values);
         delete[](input_probabilities);
         delete[](input_densities);
     } else if (strcmp(pb_graph_node->pb_type->blif_model, MODEL_LATCH) == 0) {
@@ -763,7 +763,7 @@ static void power_usage_clock_single(t_power_usage* power_usage,
 /* Frees a multiplexer graph */
 static void dealloc_mux_graph(t_mux_node* node) {
     dealloc_mux_graph_rec(node);
-    free(node);
+    delete (node);
 }
 
 static void dealloc_mux_graph_rec(t_mux_node* node) {
@@ -774,7 +774,7 @@ static void dealloc_mux_graph_rec(t_mux_node* node) {
         for (child_idx = 0; child_idx < node->num_inputs; child_idx++) {
             dealloc_mux_graph_rec(&node->children[child_idx]);
         }
-        free(node->children);
+        delete[] node->children;
     }
 }
 
@@ -1197,9 +1197,9 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
     }
 
     /* Initialize RR Graph Structures */
-    rr_node_power = (t_rr_node_power*)vtr::calloc(rr_graph.num_nodes(),
-                                                  sizeof(t_rr_node_power));
+    rr_node_power = new t_rr_node_power[rr_graph.num_nodes()];
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
+        rr_node_power[(size_t)rr_id] = t_rr_node_power();
         rr_node_power[(size_t)rr_id].driver_switch_type = OPEN;
     }
 
@@ -1219,10 +1219,13 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
                 max_IPIN_fanin = std::max(max_IPIN_fanin, node_fan_in);
                 max_fanin = std::max(max_fanin, node_fan_in);
 
-                node_power->in_dens = (float*)vtr::calloc(node_fan_in,
-                                                          sizeof(float));
-                node_power->in_prob = (float*)vtr::calloc(node_fan_in,
-                                                          sizeof(float));
+                node_power->in_dens = new float[node_fan_in];
+                node_power->in_prob = new float[node_fan_in];
+                for (int i = 0; i < node_fan_in; i++) {
+                    node_power->in_dens[i] = 0;
+                    node_power->in_prob[i] = 0;
+                }
+
                 break;
             case CHANX:
             case CHANY:
@@ -1238,10 +1241,12 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
                 max_seg_to_seg_fanout = std::max(max_seg_to_seg_fanout, fanout_to_seg);
                 max_fanin = std::max(max_fanin, node_fan_in);
 
-                node_power->in_dens = (float*)vtr::calloc(node_fan_in,
-                                                          sizeof(float));
-                node_power->in_prob = (float*)vtr::calloc(node_fan_in,
-                                                          sizeof(float));
+                node_power->in_dens = new float[node_fan_in];
+                node_power->in_prob = new float[node_fan_in];
+                for (int i = 0; i < node_fan_in; i++) {
+                    node_power->in_dens[i] = 0;
+                    node_power->in_prob[i] = 0;
+                }
                 break;
             default:
                 /* Do nothing */
@@ -1302,15 +1307,16 @@ bool power_init(const char* power_out_filepath,
     /* Set global power architecture & options */
     power_ctx.arch = arch->power;
     power_ctx.commonly_used = new t_power_commonly_used;
-    power_ctx.tech = (t_power_tech*)vtr::malloc(sizeof(t_power_tech));
-    power_ctx.output = (t_power_output*)vtr::malloc(sizeof(t_power_output));
+    power_ctx.tech = new t_power_tech;
+    power_ctx.output = new t_power_output;
 
     /* Set up Logs */
     power_ctx.output->num_logs = POWER_LOG_NUM_TYPES;
-    power_ctx.output->logs = (t_log*)vtr::calloc(power_ctx.output->num_logs,
-                                                 sizeof(t_log));
-    power_ctx.output->logs[POWER_LOG_ERROR].name = vtr::strdup("Errors");
-    power_ctx.output->logs[POWER_LOG_WARNING].name = vtr::strdup("Warnings");
+    power_ctx.output->logs = new t_log[power_ctx.output->num_logs];
+    for (int i = 0; i < power_ctx.output->num_logs; i++)
+        power_ctx.output->logs[i] = t_log();
+    power_ctx.output->logs[POWER_LOG_ERROR].name = "Errors";
+    power_ctx.output->logs[POWER_LOG_WARNING].name = "Warnings";
 
     /* Initialize output file */
     if (!error) {
@@ -1353,8 +1359,6 @@ bool power_init(const char* power_out_filepath,
  */
 bool power_uninit() {
     int mux_size;
-    int log_idx;
-    int msg_idx;
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& power_ctx = g_vpr_ctx.power();
@@ -1367,17 +1371,15 @@ bool power_uninit() {
             case CHANX:
             case CHANY:
             case IPIN:
-                if (rr_graph.node_fan_in(rr_id)) {
-                    free(node_power->in_dens);
-                    free(node_power->in_prob);
-                }
+                delete[] node_power->in_dens;
+                delete[] node_power->in_prob;
                 break;
             default:
                 /* Do nothing */
                 break;
         }
     }
-    free(rr_node_power);
+    delete[](rr_node_power);
 
     /* Free mux architectures */
     for (std::map<float, t_power_mux_info*>::iterator it = power_ctx.commonly_used->mux_info.begin();
@@ -1386,31 +1388,24 @@ bool power_uninit() {
         for (mux_size = 1; mux_size <= mux_info->mux_arch_max_size; mux_size++) {
             dealloc_mux_graph(mux_info->mux_arch[mux_size].mux_graph_head);
         }
-        free(mux_info->mux_arch);
+
         delete mux_info;
     }
     /* Free components */
     for (int i = 0; i < POWER_CALLIB_COMPONENT_MAX; ++i) {
         delete power_ctx.commonly_used->component_callibration[i];
     }
-    free(power_ctx.commonly_used->component_callibration);
+    delete[] power_ctx.commonly_used->component_callibration;
 
     delete power_ctx.commonly_used;
 
     /* Free logs */
     if (power_ctx.output->out) {
         fclose(power_ctx.output->out);
     }
-    for (log_idx = 0; log_idx < power_ctx.output->num_logs; log_idx++) {
-        for (msg_idx = 0; msg_idx < power_ctx.output->logs[log_idx].num_messages;
-             msg_idx++) {
-            free(power_ctx.output->logs[log_idx].messages[msg_idx]);
-        }
-        free(power_ctx.output->logs[log_idx].messages);
-        free(power_ctx.output->logs[log_idx].name);
-    }
-    free(power_ctx.output->logs);
-    free(power_ctx.output);
+
+    delete[](power_ctx.output->logs);
+    delete (power_ctx.output);
 
     power_pb_pins_uninit();
 

vpr/src/power/power.h

@@ -208,15 +208,16 @@ struct t_power_output {
 };
 
 struct t_log {
-    char* name;
-    char** messages;
+    std::string name;
+    std::vector<std::string> messages;
     int num_messages;
 };
 
 struct t_power_mux_info {
     /* Mux architecture information for 0..mux_arch_max_size */
     int mux_arch_max_size;
-    t_mux_arch* mux_arch;
+    //    t_mux_arch* mux_arch;
+    std::vector<t_mux_arch> mux_arch;
 };
 
 /**