clean up some more alloc/free's

Signed-off-by: Dustin DeWeese <[email protected]>

Author: HackerFoo

vpr/src/route/check_route.cpp

@@ -42,9 +42,7 @@ void check_route(enum e_route_type route_type) {
     int max_pins, inode, prev_node;
     unsigned int ipin;
     bool valid, connects;
-    bool* connected_to_route; /* [0 .. device_ctx.rr_nodes.size()-1] */
     t_trace* tptr;
-    bool* pin_done;
 
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -70,21 +68,21 @@ void check_route(enum e_route_type route_type) {
 
     auto non_configurable_rr_sets = identify_non_configurable_rr_sets();
 
-    connected_to_route = (bool*)vtr::calloc(device_ctx.rr_nodes.size(), sizeof(bool));
+    auto connected_to_route = std::make_unique<bool[]>(device_ctx.rr_nodes.size());
+    std::fill_n(connected_to_route.get(), device_ctx.rr_nodes.size(), false);
 
     max_pins = 0;
     for (auto net_id : cluster_ctx.clb_nlist.nets())
         max_pins = std::max(max_pins, (int)cluster_ctx.clb_nlist.net_pins(net_id).size());
 
-    pin_done = (bool*)vtr::malloc(max_pins * sizeof(bool));
+    auto pin_done = std::make_unique<bool[]>(max_pins);
 
     /* Now check that all nets are indeed connected. */
     for (auto net_id : cluster_ctx.clb_nlist.nets()) {
         if (cluster_ctx.clb_nlist.net_is_ignored(net_id) || cluster_ctx.clb_nlist.net_sinks(net_id).size() == 0) /* Skip ignored nets. */
             continue;
 
-        for (ipin = 0; ipin < cluster_ctx.clb_nlist.net_pins(net_id).size(); ipin++)
-            pin_done[ipin] = false;
+        std::fill_n(pin_done.get(), cluster_ctx.clb_nlist.net_pins(net_id).size(), false);
 
         /* Check the SOURCE of the net. */
         tptr = route_ctx.trace[net_id].head;
@@ -132,7 +130,7 @@ void check_route(enum e_route_type route_type) {
                 connected_to_route[inode] = true; /* Mark as in path. */
 
                 if (device_ctx.rr_nodes[inode].type() == SINK) {
-                    check_sink(inode, net_id, pin_done);
+                    check_sink(inode, net_id, pin_done.get());
                     num_sinks += 1;
                 }
 
@@ -160,12 +158,10 @@ void check_route(enum e_route_type route_type) {
 
         check_net_for_stubs(net_id);
 
-        reset_flags(net_id, connected_to_route);
+        reset_flags(net_id, connected_to_route.get());
 
     } /* End for each net */
 
-    free(pin_done);
-    free(connected_to_route);
     VTR_LOG("Completed routing consistency check successfully.\n");
     VTR_LOG("\n");
 }

vpr/src/route/route_common.cpp

@@ -44,9 +44,9 @@ struct t_trace_branch {
 
 /**************** Static variables local to route_common.c ******************/
 
-static t_heap** heap; /* Indexed from [1..heap_size] */
-static int heap_size; /* Number of slots in the heap array */
-static int heap_tail; /* Index of first unused slot in the heap array */
+static t_heap** heap = nullptr; /* Indexed from [1..heap_size] */
+static int heap_size;           /* Number of slots in the heap array */
+static int heap_tail;           /* Index of first unused slot in the heap array */
 
 /* For managing my own list of currently free heap data structures.     */
 static t_heap* heap_free_head = nullptr;
@@ -467,14 +467,18 @@ void pathfinder_update_cost(float pres_fac, float acc_fac) {
     }
 }
 
+// Note: malloc()/free() must be used for the heap,
+//       or realloc() must be eliminated from add_to_heap()
+//       because there is no C++ equivalent.
 void init_heap(const DeviceGrid& grid) {
     if (heap != nullptr) {
         vtr::free(heap + 1);
-        heap = nullptr;
     }
+
     heap_size = (grid.width() - 1) * (grid.height() - 1);
-    heap = (t_heap**)vtr::malloc(heap_size * sizeof(t_heap*));
-    heap--; /* heap stores from [1..heap_size] */
+
+    // heap stores from [1..heap_size]
+    heap = (t_heap**)vtr::malloc(heap_size * sizeof(t_heap*)) - 1;
     heap_tail = 1;
 }
 

vpr/src/route/route_timing.cpp

@@ -846,17 +846,11 @@ void alloc_timing_driven_route_structs(float** pin_criticality_ptr,
                                        t_rt_node*** rt_node_of_sink_ptr) {
     /* Allocates all the structures needed only by the timing-driven router.   */
 
-    int max_pins_per_net = get_max_pins_per_net();
-    int max_sinks = std::max(max_pins_per_net - 1, 0);
+    int max_sinks = std::max(get_max_pins_per_net() - 1, 0);
 
-    float* pin_criticality = (float*)vtr::malloc(max_sinks * sizeof(float));
-    *pin_criticality_ptr = pin_criticality - 1; /* First sink is pin #1. */
-
-    int* sink_order = (int*)vtr::malloc(max_sinks * sizeof(int));
-    *sink_order_ptr = sink_order - 1;
-
-    t_rt_node** rt_node_of_sink = (t_rt_node**)vtr::malloc(max_sinks * sizeof(t_rt_node*));
-    *rt_node_of_sink_ptr = rt_node_of_sink - 1;
+    *pin_criticality_ptr = new float[max_sinks] - 1; /* First sink is pin #1. */
+    *sink_order_ptr = new int[max_sinks] - 1;
+    *rt_node_of_sink_ptr = new t_rt_node*[max_sinks] - 1;
 
     alloc_route_tree_timing_structs();
 }
@@ -869,11 +863,11 @@ void free_timing_driven_route_structs(float* pin_criticality, int* sink_order, t
     /* Frees all the structures needed only by the timing-driven router.        */
 
     // coverity[offset_free : Intentional]
-    free(pin_criticality + 1); /* Starts at index 1. */
+    delete[](pin_criticality + 1); /* Starts at index 1. */
     // coverity[offset_free : Intentional]
-    free(sink_order + 1);
+    delete[](sink_order + 1);
     // coverity[offset_free : Intentional]
-    free(rt_node_of_sink + 1);
+    delete[](rt_node_of_sink + 1);
 
     free_route_tree_timing_structs();
 }

vpr/src/route/route_tree_timing.cpp

@@ -91,7 +91,7 @@ bool alloc_route_tree_timing_structs(bool exists_ok) {
 
 void free_route_tree_timing_structs() {
     /* Frees the structures needed to build routing trees, and really frees
-     * (i.e. calls free) all the data on the free lists.                         */
+     * (i.e. deletes) all the data on the free lists.                         */
 
     t_rt_node *rt_node, *next_node;
     t_linked_rt_edge *rt_edge, *next_edge;
@@ -102,7 +102,7 @@ void free_route_tree_timing_structs() {
 
     while (rt_node != nullptr) {
         next_node = rt_node->u.next;
-        free(rt_node);
+        delete rt_node;
         rt_node = next_node;
     }
 
@@ -112,7 +112,7 @@ void free_route_tree_timing_structs() {
 
     while (rt_edge != nullptr) {
         next_edge = rt_edge->next;
-        free(rt_edge);
+        delete rt_edge;
         rt_edge = next_edge;
     }
 
@@ -131,7 +131,7 @@ alloc_rt_node() {
     if (rt_node != nullptr) {
         rt_node_free_list = rt_node->u.next;
     } else {
-        rt_node = (t_rt_node*)vtr::malloc(sizeof(t_rt_node));
+        rt_node = new t_rt_node;
     }
 
     return (rt_node);
@@ -156,7 +156,7 @@ alloc_linked_rt_edge() {
     if (linked_rt_edge != nullptr) {
         rt_edge_free_list = linked_rt_edge->next;
     } else {
-        linked_rt_edge = (t_linked_rt_edge*)vtr::malloc(sizeof(t_linked_rt_edge));
+        linked_rt_edge = new t_linked_rt_edge;
     }
 
     VTR_ASSERT(linked_rt_edge != nullptr);