Clean up AtomContext

Changes the fields of AtomContext from public to private
and provides two methods to get each field: One that
returns an immutable const reference and another that
returns a mutable reference. The main advantage here
is that it is now simple to see where the global
context is written to and where it is only read from.

Author: AmirhosseinPoolad

doc/src/api/vpr/mapping.rst

@@ -1,7 +1,7 @@
 ===============
 Netlist mapping
 ===============
-As shown in the previous section, there are multiple levels of abstraction (multiple netlists) in VPR which are the ClusteredNetlist and the AtomNetlist. To fully use these netlists, we provide some functions to map between them. 
+As shown in the previous section, there are multiple levels of abstraction (multiple netlists) in VPR which are the ClusteredNetlist and the AtomNetlist. To fully use these netlists, we provide some functions to map between them.
 
 In this section, we will state how to map between the atom and clustered netlists.
 
@@ -16,11 +16,11 @@ To get the block Id of a cluster in the ClusteredNetlist from the block Id of on
 
 .. code-block:: cpp
 
-    ClusterBlockId clb_index = g_vpr_ctx.atom().lookup.atom_clb(atom_blk_id);
+    ClusterBlockId clb_index = g_vpr_ctx.atom().lookup().atom_clb(atom_blk_id);
 
 
 * Using re_cluster_util.h helper functions
-    
+
 .. code-block:: cpp
 
     ClusterBlockId clb_index = atom_to_cluster(atom_blk_id);
@@ -53,7 +53,7 @@ To get the net Id in the ClusteredNetlist from its Id in the AtomNetlist, use At
 
 .. code-block:: cpp
 
-   ClusterNetId clb_net = g_vpr_ctx.atom().lookup.clb_net(atom_net);
+   ClusterNetId clb_net = g_vpr_ctx.atom().lookup().clb_net(atom_net);
 
 
 Cluster net Id to Atom net Id
@@ -62,4 +62,4 @@ To get the net Id in the AtomNetlist from its Id in the ClusteredNetlist, use At
 
 .. code-block:: cpp
 
-   ClusterNetId atom_net = g_vpr_ctx.atom().lookup.atom_net(clb_net);
+   ClusterNetId atom_net = g_vpr_ctx.atom().lookup().atom_net(clb_net);

utils/fasm/src/fasm.cpp

@@ -343,9 +343,9 @@ static AtomNetId _find_atom_input_logical_net(const t_pb* atom, const t_pb_route
 
 static LogicVec lut_outputs(const t_pb* atom_pb, size_t num_inputs, const t_pb_routes &pb_route) {
     auto& atom_ctx = g_vpr_ctx.atom();
-    AtomBlockId block_id = atom_ctx.lookup.pb_atom(atom_pb);
-    const auto& truth_table = atom_ctx.nlist.block_truth_table(block_id);
-    auto ports = atom_ctx.nlist.block_input_ports(atom_ctx.lookup.pb_atom(atom_pb));
+    AtomBlockId block_id = atom_ctx.lookup().pb_atom(atom_pb);
+    const auto& truth_table = atom_ctx.netlist().block_truth_table(block_id);
+    auto ports = atom_ctx.netlist().block_input_ports(atom_ctx.lookup().pb_atom(atom_pb));
 
     const t_pb_graph_node* gnode = atom_pb->pb_graph_node;
 
@@ -384,7 +384,7 @@ static LogicVec lut_outputs(const t_pb* atom_pb, size_t num_inputs, const t_pb_r
 
         if(impl_input_net_id) {
             //If there is a valid net connected in the implementation
-            AtomNetId logical_net_id = atom_ctx.nlist.port_net(port_id, orig_index);
+            AtomNetId logical_net_id = atom_ctx.netlist().port_net(port_id, orig_index);
             VTR_ASSERT(impl_input_net_id == logical_net_id);
 
             //Mark the permutation.
@@ -537,7 +537,7 @@ static const t_pb_routes &find_pb_route(const t_pb* pb) {
 void FasmWriterVisitor::check_for_param(const t_pb *atom) {
     auto& atom_ctx = g_vpr_ctx.atom();
 
-    auto atom_blk_id = atom_ctx.lookup.pb_atom(atom);
+    auto atom_blk_id = atom_ctx.lookup().pb_atom(atom);
     if (atom_blk_id == AtomBlockId::INVALID()) {
         return;
     }
@@ -580,7 +580,7 @@ void FasmWriterVisitor::check_for_param(const t_pb *atom) {
 
     auto &params = iter->second;
 
-    for(const auto& param : atom_ctx.nlist.block_params(atom_blk_id)) {
+    for(const auto& param : atom_ctx.netlist().block_params(atom_blk_id)) {
         auto feature = params.EmitFasmFeature(param.first, param.second);
 
         if(!feature.empty()) {
@@ -592,12 +592,12 @@ void FasmWriterVisitor::check_for_param(const t_pb *atom) {
 void FasmWriterVisitor::check_for_lut(const t_pb* atom) {
     auto& atom_ctx = g_vpr_ctx.atom();
 
-    auto atom_blk_id = atom_ctx.lookup.pb_atom(atom);
+    auto atom_blk_id = atom_ctx.lookup().pb_atom(atom);
     if (atom_blk_id == AtomBlockId::INVALID()) {
         return;
     }
 
-    const t_model* model = atom_ctx.nlist.block_model(atom_blk_id);
+    const t_model* model = atom_ctx.netlist().block_model(atom_blk_id);
     if (model->name == std::string(MODEL_NAMES)) {
       VTR_ASSERT(atom->pb_graph_node != nullptr);
       const auto *lut_definition = find_lut(atom->pb_graph_node);

utils/fasm/src/main.cpp

@@ -41,7 +41,7 @@ static bool write_fasm(bool is_flat) {
   auto& device_ctx = g_vpr_ctx.device();
   auto& atom_ctx = g_vpr_ctx.atom();
 
-  std::string fasm_filename = atom_ctx.nlist.netlist_name() + ".fasm";
+  std::string fasm_filename = atom_ctx.netlist().netlist_name() + ".fasm";
   vtr::printf("Writing Implementation FASM: %s\n", fasm_filename.c_str());
   std::ofstream fasm_os(fasm_filename);
   fasm::FasmWriterVisitor visitor(&device_ctx.arch->strings, fasm_os, is_flat);

utils/route_diag/src/main.cpp

@@ -284,7 +284,7 @@ int main(int argc, const char **argv) {
 
         bool is_flat = vpr_setup.RouterOpts.flat_routing;
 
-        const Netlist<>& net_list = is_flat ? (const Netlist<>&)g_vpr_ctx.atom().nlist :
+        const Netlist<>& net_list = is_flat ? (const Netlist<>&)g_vpr_ctx.atom().netlist() :
                                             (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
 
         t_chan_width chan_width = setup_chan_width(vpr_setup.RouterOpts,

vpr/src/analysis/timing_reports.cpp

@@ -23,7 +23,7 @@ void generate_setup_timing_stats(const std::string& prefix,
 
     print_setup_timing_summary(*timing_ctx.constraints, *timing_info.setup_analyzer(), "Final ", analysis_opts.write_timing_summary);
 
-    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc, is_flat, blk_loc_registry);
+    VprTimingGraphResolver resolver(atom_ctx.netlist(), atom_ctx.lookup(), *timing_ctx.graph, delay_calc, is_flat, blk_loc_registry);
     resolver.set_detail_level(analysis_opts.timing_report_detail);
 
     tatum::TimingReporter timing_reporter(resolver, *timing_ctx.graph, *timing_ctx.constraints);
@@ -48,7 +48,7 @@ void generate_hold_timing_stats(const std::string& prefix,
 
     print_hold_timing_summary(*timing_ctx.constraints, *timing_info.hold_analyzer(), "Final ");
 
-    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc, is_flat, blk_loc_registry);
+    VprTimingGraphResolver resolver(atom_ctx.netlist(), atom_ctx.lookup(), *timing_ctx.graph, delay_calc, is_flat, blk_loc_registry);
     resolver.set_detail_level(analysis_opts.timing_report_detail);
 
     tatum::TimingReporter timing_reporter(resolver, *timing_ctx.graph, *timing_ctx.constraints);

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -63,7 +63,7 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
     vtr::ScopedStartFinishTimer timer("Analytical Placement");
 
     // The global state used/modified by this flow.
-    const AtomNetlist& atom_nlist = g_vpr_ctx.atom().nlist;
+    const AtomNetlist& atom_nlist = g_vpr_ctx.atom().netlist();
     const DeviceContext& device_ctx = g_vpr_ctx.device();
     const UserPlaceConstraints& constraints = g_vpr_ctx.floorplanning().constraints;
 
@@ -107,4 +107,3 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                                                         device_ctx.grid);
     full_legalizer->legalize(p_placement);
 }
-

vpr/src/analytical_place/full_legalizer.cpp

@@ -234,7 +234,7 @@ static LegalizationClusterId create_new_cluster(PackMoleculeId seed_molecule_id,
     VTR_ASSERT(seed_molecule_id.is_valid());
     const t_pack_molecule& seed_molecule = prepacker.get_molecule(seed_molecule_id);
     AtomBlockId root_atom = seed_molecule.atom_block_ids[seed_molecule.root];
-    const t_model* root_model = atom_ctx.nlist.block_model(root_atom);
+    const t_model* root_model = atom_ctx.netlist().block_model(root_atom);
 
     auto itr = primitive_candidate_block_types.find(root_model);
     VTR_ASSERT(itr != primitive_candidate_block_types.end());
@@ -535,4 +535,3 @@ void APPack::legalize(const PartialPlacement& p_placement) {
     //       it.
     post_place_sync();
 }
-

vpr/src/base/clustered_netlist_utils.cpp

@@ -45,8 +45,8 @@ void ClusterAtomsLookup::init_lookup() {
 
     cluster_atoms.resize(cluster_ctx.clb_nlist.blocks().size());
 
-    for (auto atom_blk_id : atom_ctx.nlist.blocks()) {
-        ClusterBlockId clb_index = atom_ctx.lookup.atom_clb(atom_blk_id);
+    for (auto atom_blk_id : atom_ctx.netlist().blocks()) {
+        ClusterBlockId clb_index = atom_ctx.lookup().atom_clb(atom_blk_id);
 
         /* if this data structure is being built alongside the clustered netlist    */
         /* e.g. when ingesting and legalizing a flat placement solution, some atoms */

vpr/src/base/load_flat_place.cpp

@@ -71,11 +71,11 @@ static void print_flat_cluster(FILE* fp,
     // Print a line for each atom.
     for (AtomBlockId atom : atoms_lookup[blk_id]) {
         // Get the atom pb graph node.
-        t_pb_graph_node* atom_pbgn = atom_ctx.lookup.atom_pb(atom)->pb_graph_node;
+        t_pb_graph_node* atom_pbgn = atom_ctx.lookup().atom_pb(atom)->pb_graph_node;
 
         // Print the flat placement information for this atom.
         fprintf(fp, "%s  %d %d %d %d %d #%zu %s\n",
-                atom_ctx.nlist.block_name(atom).c_str(),
+                atom_ctx.netlist().block_name(atom).c_str(),
                 blk_loc.x, blk_loc.y, blk_loc.layer,
                 blk_loc.sub_tile,
                 atom_pbgn->flat_site_index,
@@ -299,7 +299,7 @@ void log_flat_placement_reconstruction_info(
         //       debugging flat placement reconstruction.
         /*
         VTR_LOG("%s %d %d %d %d\n",
-                g_vpr_ctx.atom().nlist.block_name(atom_blk_id).c_str(),
+                g_vpr_ctx.atom().netlist().block_name(atom_blk_id).c_str(),
                 clb_loc.loc.x,
                 clb_loc.loc.y,
                 clb_loc.loc.layer,
@@ -322,4 +322,3 @@ void log_flat_placement_reconstruction_info(
     VTR_LOG("\tPercent of atoms misplaced from the flat placement: %f\n",
             static_cast<float>(num_atoms_missplaced) / static_cast<float>(num_atoms));
 }
-

vpr/src/base/netlist_walker.cpp

@@ -6,7 +6,7 @@ void NetlistWalker::walk() {
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
-    visitor_.visit_top(atom_ctx.nlist.netlist_name().c_str());
+    visitor_.visit_top(atom_ctx.netlist().netlist_name().c_str());
 
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         const auto* pb = cluster_ctx.clb_nlist.block_pb(blk_id);

vpr/src/base/netlist_writer.cpp

@@ -827,15 +827,15 @@ class NetlistWriterVisitor : public NetlistVisitor {
         auto& atom_ctx = g_vpr_ctx.atom();
 
         //Initialize the pin to tnode look-up
-        for (AtomPinId pin : atom_ctx.nlist.pins()) {
-            AtomBlockId blk = atom_ctx.nlist.pin_block(pin);
-            ClusterBlockId clb_idx = atom_ctx.lookup.atom_clb(blk);
+        for (AtomPinId pin : atom_ctx.netlist().pins()) {
+            AtomBlockId blk = atom_ctx.netlist().pin_block(pin);
+            ClusterBlockId clb_idx = atom_ctx.lookup().atom_clb(blk);
 
-            const t_pb_graph_pin* gpin = atom_ctx.lookup.atom_pin_pb_graph_pin(pin);
+            const t_pb_graph_pin* gpin = atom_ctx.lookup().atom_pin_pb_graph_pin(pin);
             VTR_ASSERT(gpin);
             int pb_pin_idx = gpin->pin_count_in_cluster;
 
-            tatum::NodeId tnode_id = atom_ctx.lookup.atom_pin_tnode(pin);
+            tatum::NodeId tnode_id = atom_ctx.lookup().atom_pin_tnode(pin);
 
             auto key = std::make_pair(clb_idx, pb_pin_idx);
             auto value = std::make_pair(key, tnode_id);
@@ -859,11 +859,11 @@ class NetlistWriterVisitor : public NetlistVisitor {
     void visit_atom_impl(const t_pb* atom) override {
         auto& atom_ctx = g_vpr_ctx.atom();
 
-        auto atom_pb = atom_ctx.lookup.pb_atom(atom);
+        auto atom_pb = atom_ctx.lookup().pb_atom(atom);
         if (atom_pb == AtomBlockId::INVALID()) {
             return;
         }
-        const t_model* model = atom_ctx.nlist.block_model(atom_pb);
+        const t_model* model = atom_ctx.netlist().block_model(atom_pb);
 
         if (model->name == std::string(MODEL_INPUT)) {
             inputs_.emplace_back(make_io(atom, PortType::INPUT));
@@ -1787,12 +1787,12 @@ class NetlistWriterVisitor : public NetlistVisitor {
         }
 
         auto& atom_ctx = g_vpr_ctx.atom();
-        AtomBlockId blk_id = atom_ctx.lookup.pb_atom(atom);
-        for (auto param : atom_ctx.nlist.block_params(blk_id)) {
+        AtomBlockId blk_id = atom_ctx.lookup().pb_atom(atom);
+        for (auto param : atom_ctx.netlist().block_params(blk_id)) {
             params[param.first] = param.second;
         }
 
-        for (auto attr : atom_ctx.nlist.block_attrs(blk_id)) {
+        for (auto attr : atom_ctx.netlist().block_attrs(blk_id)) {
             attrs[attr.first] = attr.second;
         }
 
@@ -1809,8 +1809,8 @@ class NetlistWriterVisitor : public NetlistVisitor {
     tatum::NodeId find_tnode(const t_pb* atom, int cluster_pin_idx) {
         auto& atom_ctx = g_vpr_ctx.atom();
 
-        AtomBlockId blk_id = atom_ctx.lookup.pb_atom(atom);
-        ClusterBlockId clb_index = atom_ctx.lookup.atom_clb(blk_id);
+        AtomBlockId blk_id = atom_ctx.lookup().pb_atom(atom);
+        ClusterBlockId clb_index = atom_ctx.lookup().atom_clb(blk_id);
 
         auto key = std::make_pair(clb_index, cluster_pin_idx);
         auto iter = pin_id_to_tnode_lookup_.find(key);
@@ -1840,7 +1840,7 @@ class NetlistWriterVisitor : public NetlistVisitor {
                            const t_pb* atom) { //LUT primitive
         auto& atom_ctx = g_vpr_ctx.atom();
 
-        const t_model* model = atom_ctx.nlist.block_model(atom_ctx.lookup.pb_atom(atom));
+        const t_model* model = atom_ctx.netlist().block_model(atom_ctx.lookup().pb_atom(atom));
         VTR_ASSERT(model->name == std::string(MODEL_NAMES));
 
 #ifdef DEBUG_LUT_MASK
@@ -1851,7 +1851,7 @@ class NetlistWriterVisitor : public NetlistVisitor {
         std::vector<int> permute = determine_lut_permutation(num_inputs, atom);
 
         //Retrieve the truth table
-        const auto& truth_table = atom_ctx.nlist.block_truth_table(atom_ctx.lookup.pb_atom(atom));
+        const auto& truth_table = atom_ctx.netlist().block_truth_table(atom_ctx.lookup().pb_atom(atom));
 
         //Apply the permutation
         auto permuted_truth_table = permute_truth_table(truth_table, num_inputs, permute);
@@ -1896,7 +1896,7 @@ class NetlistWriterVisitor : public NetlistVisitor {
         //
         //We walk through the logical inputs to this atom (i.e. in the original truth table/netlist)
         //and find the corresponding input in the implementation atom (i.e. in the current netlist)
-        auto ports = atom_ctx.nlist.block_input_ports(atom_ctx.lookup.pb_atom(atom_pb));
+        auto ports = atom_ctx.netlist().block_input_ports(atom_ctx.lookup().pb_atom(atom_pb));
         if (ports.size() == 1) {
             const t_pb_graph_node* gnode = atom_pb->pb_graph_node;
             VTR_ASSERT(gnode->num_input_ports == 1);
@@ -1913,16 +1913,16 @@ class NetlistWriterVisitor : public NetlistVisitor {
 
                 if (impl_input_net_id) {
                     //If there is a valid net connected in the implementation
-                    AtomNetId logical_net_id = atom_ctx.nlist.port_net(port_id, orig_index);
+                    AtomNetId logical_net_id = atom_ctx.netlist().port_net(port_id, orig_index);
 
                     // Fatal error should be flagged when the net marked in implementation
                     // does not match the net marked in input netlist
                     if (impl_input_net_id != logical_net_id) {
                         VPR_FATAL_ERROR(VPR_ERROR_IMPL_NETLIST_WRITER,
                                         "Unmatch:\n\tlogical net is '%s' at pin '%lu'\n\timplmented net is '%s' at pin '%s'\n",
-                                        atom_ctx.nlist.net_name(logical_net_id).c_str(),
+                                        atom_ctx.netlist().net_name(logical_net_id).c_str(),
                                         size_t(orig_index),
-                                        atom_ctx.nlist.net_name(impl_input_net_id).c_str(),
+                                        atom_ctx.netlist().net_name(impl_input_net_id).c_str(),
                                         gpin->to_string().c_str());
                     }
 
@@ -2144,11 +2144,11 @@ class MergedNetlistWriterVisitor : public NetlistWriterVisitor {
     void visit_atom_impl(const t_pb* atom) override {
         auto& atom_ctx = g_vpr_ctx.atom();
 
-        auto atom_pb = atom_ctx.lookup.pb_atom(atom);
+        auto atom_pb = atom_ctx.lookup().pb_atom(atom);
         if (atom_pb == AtomBlockId::INVALID()) {
             return;
         }
-        const t_model* model = atom_ctx.nlist.block_model(atom_pb);
+        const t_model* model = atom_ctx.netlist().block_model(atom_pb);
 
         if (model->name == std::string(MODEL_INPUT)) {
             auto merged_io_name = make_io(atom, PortType::INPUT);