Memory clean up to placer

libs/libarchfpga/src/arch_util.cpp

@@ -33,7 +33,7 @@ InstPort::InstPort(std::string str) {
     }
 }
 
-InstPort::name_index InstPort::parse_name_index(std::string str) {
+InstPort::name_index InstPort::parse_name_index(const std::string& str) {
     auto open_bracket_pos = str.find("[");
     auto close_bracket_pos = str.find("]");
     auto colon_pos = str.find(":");

libs/libarchfpga/src/arch_util.h

@@ -31,7 +31,7 @@ class InstPort {
         int high_idx = UNSPECIFIED;
     };
 
-    name_index parse_name_index(std::string str);
+    name_index parse_name_index(const std::string& str);
 
     name_index instance_;
     name_index port_;

libs/libarchfpga/src/expr_eval.cpp

@@ -2,104 +2,18 @@
 #include "arch_error.h"
 #include "vtr_util.h"
 #include "vtr_math.h"
-#include <vector>
-#include <stack>
 #include <string>
 #include <sstream>
-#include <cstring> //memset
 
 using std::stack;
 using std::string;
 using std::stringstream;
 using std::vector;
 
-/**** Enums ****/
-/* Used to identify the type of symbolic formula object */
-typedef enum e_formula_obj {
-    E_FML_UNDEFINED = 0,
-    E_FML_NUMBER,
-    E_FML_BRACKET,
-    E_FML_COMMA,
-    E_FML_OPERATOR,
-    E_FML_NUM_FORMULA_OBJS
-} t_formula_obj;
-
-/* Used to identify an operator in a formula */
-typedef enum e_operator {
-    E_OP_UNDEFINED = 0,
-    E_OP_ADD,
-    E_OP_SUB,
-    E_OP_MULT,
-    E_OP_DIV,
-    E_OP_MIN,
-    E_OP_MAX,
-    E_OP_GCD,
-    E_OP_LCM,
-    E_OP_NUM_OPS
-} t_operator;
-
-/**** Class Definitions ****/
-/* This class is used to represent an object in a formula, such as
- * a number, a bracket, an operator, or a variable */
-class Formula_Object {
-  public:
-    /* indicates the type of formula object this is */
-    t_formula_obj type;
-
-    /* object data, accessed based on what kind of object this is */
-    union u_Data {
-        int num;           /*for number objects*/
-        t_operator op;     /*for operator objects*/
-        bool left_bracket; /*for bracket objects -- specifies if this is a left bracket*/
-
-        u_Data() { memset(this, 0, sizeof(u_Data)); }
-    } data;
-
-    Formula_Object() {
-        this->type = E_FML_UNDEFINED;
-    }
-
-    std::string to_string() const {
-        if (type == E_FML_NUMBER) {
-            return std::to_string(data.num);
-        } else if (type == E_FML_BRACKET) {
-            if (data.left_bracket) {
-                return "(";
-            } else {
-                return ")";
-            }
-        } else if (type == E_FML_COMMA) {
-            return ",";
-        } else if (type == E_FML_OPERATOR) {
-            if (data.op == E_OP_ADD) {
-                return "+";
-            } else if (data.op == E_OP_SUB) {
-                return "-";
-            } else if (data.op == E_OP_MULT) {
-                return "*";
-            } else if (data.op == E_OP_DIV) {
-                return "/";
-            } else if (data.op == E_OP_MIN) {
-                return "min";
-            } else if (data.op == E_OP_MAX) {
-                return "max";
-            } else if (data.op == E_OP_GCD) {
-                return "gcd";
-            } else if (data.op == E_OP_LCM) {
-                return "lcm";
-            } else {
-                return "???"; //Unkown
-            }
-        } else {
-            return "???"; //Unkown
-        }
-    }
-};
-
 /*---- Functions for Parsing the Symbolic Formulas ----*/
 
 /* converts specified formula to a vector in reverse-polish notation */
-static void formula_to_rpn(const char* formula, const t_formula_data& mydata, vector<Formula_Object>& rpn_output);
+static void formula_to_rpn(const char* formula, const t_formula_data& mydata, vector<Formula_Object>& rpn_output, stack<Formula_Object>& op_stack);
 
 static void get_formula_object(const char* ch, int& ichar, const t_formula_data& mydata, Formula_Object* fobj);
 
@@ -142,14 +56,15 @@ static bool goto_next_char(int* str_ind, const string& pw_formula, char ch);
 
 /**** Function Implementations ****/
 /* returns integer result according to specified non-piece-wise formula and data */
-int parse_formula(std::string formula, const t_formula_data& mydata) {
+int FormulaParser::parse_formula(std::string formula, const t_formula_data& mydata) {
     int result = -1;
 
     /* output in reverse-polish notation */
-    vector<Formula_Object> rpn_output;
+    auto& rpn_output = rpn_output_;
+    rpn_output.clear();
 
     /* now we have to run the shunting-yard algorithm to convert formula to reverse polish notation */
-    formula_to_rpn(formula.c_str(), mydata, rpn_output);
+    formula_to_rpn(formula.c_str(), mydata, rpn_output, op_stack_);
 
     /* then we run an RPN parser to get the final result */
     result = parse_rpn_vector(rpn_output);
@@ -171,7 +86,7 @@ int parse_formula(std::string formula, const t_formula_data& mydata) {
  *
  * {start_0:end_0} formula_0; ... {start_i;end_i} formula_i; ...
  */
-int parse_piecewise_formula(const char* formula, const t_formula_data& mydata) {
+int FormulaParser::parse_piecewise_formula(const char* formula, const t_formula_data& mydata) {
     int result = -1;
     int str_ind = 0;
     int str_size = 0;
@@ -283,9 +198,13 @@ static bool goto_next_char(int* str_ind, const string& pw_formula, char ch) {
 
 /* Parses the specified formula using a shunting yard algorithm (see wikipedia). The function's result
  * is stored in the rpn_output vector in reverse-polish notation */
-static void formula_to_rpn(const char* formula, const t_formula_data& mydata, vector<Formula_Object>& rpn_output) {
-    stack<Formula_Object> op_stack; /* stack for handling operators and brackets in formula */
-    Formula_Object fobj;            /* for parsing formula objects */
+static void formula_to_rpn(const char* formula, const t_formula_data& mydata, vector<Formula_Object>& rpn_output, stack<Formula_Object>& op_stack) {
+    // Empty op_stack.
+    while (!op_stack.empty()) {
+        op_stack.pop();
+    }
+
+    Formula_Object fobj; /* for parsing formula objects */
 
     int ichar = 0;
     const char* ch = nullptr;
@@ -372,7 +291,10 @@ static void get_formula_object(const char* ch, int& ichar, const t_formula_data&
         } else {
             //A variable
             fobj->type = E_FML_NUMBER;
-            fobj->data.num = mydata.get_var_value(var_name);
+            fobj->data.num = mydata.get_var_value(
+                vtr::string_view(
+                    var_name.data(),
+                    var_name.size()));
         }
 
         ichar += (id_len - 1); //-1 since ichar is incremented at end of loop in formula_to_rpn()
@@ -764,7 +686,7 @@ static int identifier_length(const char* str) {
 }
 
 /* checks if the specified formula is piece-wise defined */
-bool is_piecewise_formula(const char* formula) {
+bool FormulaParser::is_piecewise_formula(const char* formula) {
     bool result = false;
     /* if formula is piecewise, we expect '{' to be the very first character */
     if ('{' == formula[0]) {

libs/libarchfpga/src/expr_eval.h

@@ -2,34 +2,145 @@
 #define EXPR_EVAL_H
 #include <map>
 #include <string>
+#include <vector>
+#include <stack>
 #include "arch_error.h"
+#include <cstring>
+
+#include "vtr_string_view.h"
+#include "vtr_flat_map.h"
 
 /**** Structs ****/
 
 class t_formula_data {
   public:
-    void set_var_value(std::string var, int value) { vars_[var] = value; }
+    void clear() {
+        vars_.clear();
+    }
+
+    void set_var_value(vtr::string_view var, int value) { vars_[var] = value; }
+    void set_var_value(const char* var, int value) { vars_[vtr::string_view(var)] = value; }
 
-    int get_var_value(std::string var) const {
+    int get_var_value(const std::string& var) const {
+        return get_var_value(vtr::string_view(var.data(), var.size()));
+    }
+
+    int get_var_value(vtr::string_view var) const {
         auto iter = vars_.find(var);
         if (iter == vars_.end()) {
+            std::string copy(var.data(), var.size());
             archfpga_throw(__FILE__, __LINE__,
-                           "No value found for variable '%s' from expression\n", var.c_str());
+                           "No value found for variable '%s' from expression\n", copy.c_str());
         }
 
         return iter->second;
     }
 
   private:
-    std::map<std::string, int> vars_;
+    vtr::flat_map<vtr::string_view, int> vars_;
 };
 
-/* returns integer result according to specified formula and data */
-int parse_formula(std::string formula, const t_formula_data& mydata);
+/**** Enums ****/
+/* Used to identify the type of symbolic formula object */
+typedef enum e_formula_obj {
+    E_FML_UNDEFINED = 0,
+    E_FML_NUMBER,
+    E_FML_BRACKET,
+    E_FML_COMMA,
+    E_FML_OPERATOR,
+    E_FML_NUM_FORMULA_OBJS
+} t_formula_obj;
+
+/* Used to identify an operator in a formula */
+typedef enum e_operator {
+    E_OP_UNDEFINED = 0,
+    E_OP_ADD,
+    E_OP_SUB,
+    E_OP_MULT,
+    E_OP_DIV,
+    E_OP_MIN,
+    E_OP_MAX,
+    E_OP_GCD,
+    E_OP_LCM,
+    E_OP_NUM_OPS
+} t_operator;
+
+/**** Class Definitions ****/
+/* This class is used to represent an object in a formula, such as
+ * a number, a bracket, an operator, or a variable */
+class Formula_Object {
+  public:
+    /* indicates the type of formula object this is */
+    t_formula_obj type;
+
+    /* object data, accessed based on what kind of object this is */
+    union u_Data {
+        int num;           /*for number objects*/
+        t_operator op;     /*for operator objects*/
+        bool left_bracket; /*for bracket objects -- specifies if this is a left bracket*/
+
+        u_Data() { memset(this, 0, sizeof(u_Data)); }
+    } data;
+
+    Formula_Object() {
+        this->type = E_FML_UNDEFINED;
+    }
 
-/* returns integer result according to specified piece-wise formula and data */
-int parse_piecewise_formula(const char* formula, const t_formula_data& mydata);
+    std::string to_string() const {
+        if (type == E_FML_NUMBER) {
+            return std::to_string(data.num);
+        } else if (type == E_FML_BRACKET) {
+            if (data.left_bracket) {
+                return "(";
+            } else {
+                return ")";
+            }
+        } else if (type == E_FML_COMMA) {
+            return ",";
+        } else if (type == E_FML_OPERATOR) {
+            if (data.op == E_OP_ADD) {
+                return "+";
+            } else if (data.op == E_OP_SUB) {
+                return "-";
+            } else if (data.op == E_OP_MULT) {
+                return "*";
+            } else if (data.op == E_OP_DIV) {
+                return "/";
+            } else if (data.op == E_OP_MIN) {
+                return "min";
+            } else if (data.op == E_OP_MAX) {
+                return "max";
+            } else if (data.op == E_OP_GCD) {
+                return "gcd";
+            } else if (data.op == E_OP_LCM) {
+                return "lcm";
+            } else {
+                return "???"; //Unkown
+            }
+        } else {
+            return "???"; //Unkown
+        }
+    }
+};
+
+class FormulaParser {
+  public:
+    FormulaParser() = default;
+    FormulaParser(const FormulaParser&) = delete;
+    FormulaParser& operator=(const FormulaParser&) = delete;
+
+    /* returns integer result according to specified formula and data */
+    int parse_formula(std::string formula, const t_formula_data& mydata);
+
+    /* returns integer result according to specified piece-wise formula and data */
+    int parse_piecewise_formula(const char* formula, const t_formula_data& mydata);
+
+    /* checks if the specified formula is piece-wise defined */
+    static bool is_piecewise_formula(const char* formula);
+
+  private:
+    std::vector<Formula_Object> rpn_output_;
+    std::stack<Formula_Object> op_stack_; /* stack for handling operators and brackets in formula */
+};
 
-/* checks if the specified formula is piece-wise defined */
-bool is_piecewise_formula(const char* formula);
 #endif

libs/libarchfpga/src/parse_switchblocks.cpp

@@ -447,7 +447,7 @@ static void check_wireconn(const t_arch* arch, const t_wireconn_inf& wireconn) {
 /*---- Functions for Parsing the Symbolic Switchblock Formulas ----*/
 
 /* returns integer result according to the specified switchblock formula and data. formula may be piece-wise */
-int get_sb_formula_raw_result(const char* formula, const t_formula_data& mydata) {
+int get_sb_formula_raw_result(FormulaParser& formula_parser, const char* formula, const t_formula_data& mydata) {
     /* the result of the formula will be an integer */
     int result = -1;
 
@@ -459,11 +459,11 @@ int get_sb_formula_raw_result(const char* formula, const t_formula_data& mydata)
     }
 
     /* parse based on whether formula is piece-wise or not */
-    if (is_piecewise_formula(formula)) {
+    if (formula_parser.is_piecewise_formula(formula)) {
         //EXPERIMENTAL
-        result = parse_piecewise_formula(formula, mydata);
+        result = formula_parser.parse_piecewise_formula(formula, mydata);
     } else {
-        result = parse_formula(formula, mydata);
+        result = formula_parser.parse_formula(formula, mydata);
     }
 
     return result;

libs/libarchfpga/src/parse_switchblocks.h

@@ -17,6 +17,6 @@ void read_sb_wireconns(const t_arch_switch_inf* switches, int num_switches, pugi
 void check_switchblock(const t_switchblock_inf* sb, const t_arch* arch);
 
 /* returns integer result according to the specified formula and data */
-int get_sb_formula_raw_result(const char* formula, const t_formula_data& mydata);
+int get_sb_formula_raw_result(FormulaParser& formula_parser, const char* formula, const t_formula_data& mydata);
 
 #endif /* PARSE_SWITCHBLOCKS_H */

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -4800,7 +4800,7 @@ static void link_physical_logical_types(std::vector<t_physical_tile_type>& Physi
 
         auto& equivalent_sites = physical_tile.equivalent_sites;
 
-        auto criteria = [physical_tile](const t_logical_block_type* lhs, const t_logical_block_type* rhs) {
+        auto criteria = [&physical_tile](const t_logical_block_type* lhs, const t_logical_block_type* rhs) {
             int num_physical_pins = physical_tile.num_pins / physical_tile.capacity;
 
             int lhs_num_logical_pins = lhs->pb_type->num_pins;
@@ -4838,7 +4838,7 @@ static void link_physical_logical_types(std::vector<t_physical_tile_type>& Physi
         std::unordered_map<int, bool> ignored_pins_check_map;
         std::unordered_map<int, bool> global_pins_check_map;
 
-        auto criteria = [logical_block](const t_physical_tile_type* lhs, const t_physical_tile_type* rhs) {
+        auto criteria = [&logical_block](const t_physical_tile_type* lhs, const t_physical_tile_type* rhs) {
             int num_logical_pins = logical_block.pb_type->num_pins;
 
             int lhs_num_physical_pins = lhs->num_pins / lhs->capacity;