Merge branch 'main' of github.com:TILOS-AI-Institute/MacroPlacement into flow_scripts

.gitignore

@@ -9,3 +9,4 @@ CodeElements/Plc_client/plc_client_os.py
 CodeElements/Plc_client/__pycache__/*
 CodeElements/Plc_client/proto_reader.py
 CodeElements/Plc_client/plc_client.py
+CodeElements/Plc_client/failed_proxy_plc/*
\ No newline at end of file

CodeElements/Grouping/README.md

 # **Grouping**
+Grouping is an important preprocessing step of clustering.
 The grouping step in Circuit Training requires as inputs:
-the post-synthesis gate-level netlist (standard cells and hard macros)
-placed IOs (ports, or terminals), typically at the borders of the chip canvas
-the grid of n_rows rows and n_cols columns of gridcells, which defines the gridded layout canvas
-The purpose of grouping, to our understanding, is to ensure that closely-related logic is kept close to hard macros and to clumps of IOs. The clumps of IOs are induced by IO locations with respect to the row and column coordinates in the gridded layout canvas.
- 
+the post-synthesis gate-level netlist (standard cells and hard macros),
+placed IOs (ports, or terminals), typically at the borders of the chip canvas,
+the grid of **n_rows** rows and **n_cols** columns of _gridcells_, which defines the gridded layout canvas.
+The purpose of grouping, to our understanding, is to ensure that closely-related standard-cell logic, 
+which connect to the same macro or the same clump of IO (noted as IO cluster), belong to the same standard-cell clusters.
+
+
+
 ## **The Grouping Process**
-In the Circuit Training approach, a given SRAM’s immediate fanins and immediate fanouts (with respect to all of the SRAM’s pins) comprise a group. One group is created for each SRAM in the design.
+The grouping consists of three steps:
+- Group the macro pins of the same macro into a cluster.
+In Circuit Training, the netlist consists of four building elements: 
+standard cells, IO ports, macro pins and macros.
+The following figure shows an example of netlist representation in Circuit Training.
+The left part is the real netlist; The right part is the Netlist Protocol Buffer 
+representation in Circuit Training. The solid arrow means the real signal net and the dashed
+arrow means the virtual nets between macro A and its macro pins.
+We can see that the macro pins and the related macro are both basic elements in the netlist, whereas there is no pins of standard cells.  Thus, it's necessary to group the macros pins of the same macro into a cluster, because the macro pins of the same macro will always stay together during macro placement. Note that only the macro pins are grouped and the macro itself is not grouped. For example, in this figure, **D\[0\]**, **D\[1\]**, **D\[2\]**, **Q\[0\]**,
+**Q\[1\]**, **Q\[2\]** are grouped into **cluster_1**, but **cluster_1** does not include macro A.
+<img src="./macro_example.png" width= "1600"/>
 
-Then, all of the IOs (ports) that are in each row-grid or column-grid of the boundary of the layout canvas are put into clumps.  There is one clump for each row-grid or column-grid of the boundary that contains at least one IO. A group is then comprised of the union of immediate fanins and immediate fanouts of a given clump. 
 
-Note that “immediate fanins” is equivalent to “transitive fanins up to level K_in = 1”, and that “immediate fanouts” is equivalent to “transitive fanouts up to level K_out = 1”. It is our understanding that both K_in and K_out are always set to a default value of 1 in Circuit Training. However, other values might be applied. 
+- Group the IOs that are within close proximity of each other boundary by boundary, 
+following the order of **LEFT** <span>&rarr;</span> **TOP** <span>&rarr;</span>  **RIGHT** <span>&rarr;</span> **BOTTOM**. For the **LEFT**/**RIGHT**(**TOP**/**Bottom**) boundary, we sort the all the ports on the boundary based on their y (x) coordinates in a non-decreasing order. Starting from the first IO port on the boundary, we group the IO ports within each **grid_height** (**grid_width**) into an IO cluster. For example, in following figure, we have three IO clusters on **TOP** boundary and two IO clusters on **RIGHT** boundary. The **grid_width** and **grid_height** are calculated based on the **n_cols** and **n_rows**:
+  - **grid_width** = **canvas_width** / **n_cols**
+  - **grid_height** = **canvas_height** / **n_rows**
 
-**Tie-Breaking.** If a given standard-cell instance can belong to two or more groups, we break ties according to the following, ordered criteria:  (1) when in the regime of K_in > 1 or K_out > 1, assign to the group with topologically closer (i.e., fewer levels away) macro or port; else (2) assign to the group induced by a clump containing lexicographically smallest port name; else (3) assign to the group induced by a macro having lexicographically smallest macro name.
+<img src="./IO_Groups.png" width= "1600"/>
 
-## **A Simple “Cartoon”**
-The following cartoon was recently provided by a Google engineer to explain the grouping process. In the cartoon, there are three rows and four columns of gridcells. There are also three clumps of IOs and two hard macros. As a result, in the cartoon we see a total of five groups. To our understanding, a given SRAM hard macro is not part of the group (of standard cells) that it induces.  And, a given clump of (placed, fixed) IO ports is not part of the group (of standard cells) that it induces. 
 
-<img src="./Cartoon.png" width= "1600"/>
+
+
+- Group the close-related standard cells,
+which connect to the same macro or the same IO cluster.
+Suppose that we have a design with 100 clusters of macro pins (i.e., 100 macros) and 10 clusters of IOs.
+Before we grouping the close-related standard cells to these clusters of macro pins or IOs,
+we assign each cluster with a cluster id from 0 to 119.
+Then for each cluster, we traverse the netlist and assign the same cluster id to the "immediate fanins" and "immediate fanouts" of its element (macro pin or IO).
+Note that "immediate fanin" is equivalent to "transitive fanins up to level K_in = 1", and that "immediate fanouts" is equivalent to "transitive fanouts up to level K_out = 1".
+It is our understanding that both K_in and K_out are always set to a default value of 1 
+in Circuit Training. However, other values might be applied. 
+In our implementation, we traverse the netlist in a depth-first-search manner.
+All the elements (standard cell, macro pin or IO ports) with the same cluster id form a cluster.  Each cluster is recorded in the ".fix file" that is part of the input to the hMETIS hypergraph partitioner when the standard cells are grouped into soft macros. 
+The part id of each cluster is the same as its cluster id.
+Note that a macro does not belong to any cluster, thus is not fixed 
+when we call the hMETIS hypergraph partitioner.
+
  
 ## **How Groups Are Used**
 Each group is recorded in the “.fix file” that is part of the input to the hMETIS hypergraph partitioner when the gate-level netlist is clustered into soft macros.
@@ -26,8 +56,7 @@ Each group is recorded in the “.fix file” that is part of the input to the h
 We provide [(an example)](https://github.com/TILOS-AI-Institute/MacroPlacement/blob/main/CodeElements/Grouping/test/test.py) about the usage of our grouping scripts.
 Basically our grouping scripts take follows as inputs: (i) [(setup_file)](https://github.com/TILOS-AI-Institute/MacroPlacement/blob/main/CodeElements/Grouping/test/setup.tcl)
 including enablement information (lefs/libs), synthesized gate-level netlist (*.v),  def file with placed IOs (*.def); (ii) n_rows and n_cols determined by the [(Gridding)](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/CodeElements/Gridding) step; (iii) K_in and K_out parameters; (iv) global_net_threshold for ignoring global nets. If a net has more than global_net_threshold instances, we ignore such net when we search "transitive" fanins and fanouts. After
-running grouping scripts,  you will get two files *.fix and *.fix.old.  The ".fix.old" file contains the IOs or macros in the corresponding group while *.fix file only contains standard cells in each group.
-
+running grouping scripts,  you will get the **.fix** file.  
 
 # Thanks
 We thank Google engineers for Q&A in a shared document, as well as live discussions on May 19, 2022, that explained the grouping method used in Circuit Training. All errors of understanding and implementation are the authors'. We will rectify such errors as soon as possible after being made aware of them.

CodeElements/Plc_client/README.md

@@ -85,5 +85,11 @@ $$
 
 Notice a smoothing range can be set for congestion. This is only applied to congestion due to net routing which by counting adjacent cells and adding the averaged congestion to these adjacent cells. More details are provided in the document above.
 
+## Placement Util
+**Disclaimer: We DO NOT own the content of placement_util_os.py. All rights belong to Google Authors. This is a modified version of placement_util.py and we are including in the repo for the sake of testing. Original Code can be viewed [here](https://github.com/google-research/circuit_training/blob/main/circuit_training/environment/placement_util.py)**.
+
+## Observation Extractor
+**Disclaimer: We DO NOT own the content of observation_extractor_os.py. All rights belong to Google Authors. This is a modified version of observation_extractor.py and we are including in the repo for the sake of testing. Original Code can be viewed [here](https://github.com/google-research/circuit_training/blob/main/circuit_training/environment/observation_extractor.py)**.
+
 
 

CodeElements/Plc_client/observation_config.py

+# coding=utf-8
+# Copyright 2021 The Circuit Training Team Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""A class to store the observation shape and sizes."""
+
+from typing import Dict, List, Optional, Text, Tuple, Union
+
+import gin
+import gym
+import numpy as np
+import tensorflow as tf
+
+TensorType = Union[np.ndarray, tf.Tensor]
+FeatureKeyType = Union[List[Text], Tuple[Text, ...]]
+
+HARD_MACRO = 1
+SOFT_MACRO = 2
+PORT_CLUSTER = 3
+
+NETLIST_METADATA = (
+    'normalized_num_edges',
+    'normalized_num_hard_macros',
+    'normalized_num_soft_macros',
+    'normalized_num_port_clusters',
+    'horizontal_routes_per_micron',
+    'vertical_routes_per_micron',
+    'macro_horizontal_routing_allocation',
+    'macro_vertical_routing_allocation',
+    'grid_cols',
+    'grid_rows',
+)
+
+GRAPH_ADJACENCY_MATRIX = ('sparse_adj_i', 'sparse_adj_j', 'sparse_adj_weight',
+                          'edge_counts')
+
+NODE_STATIC_FEATURES = (
+    'macros_w',
+    'macros_h',
+    'node_types',
+)
+
+STATIC_OBSERVATIONS = (
+    NETLIST_METADATA + GRAPH_ADJACENCY_MATRIX + NODE_STATIC_FEATURES)
+
+INITIAL_DYNAMIC_OBSERVATIONS = (
+    'locations_x',
+    'locations_y',
+    'is_node_placed',
+)
+
+DYNAMIC_OBSERVATIONS = (
+    'locations_x',
+    'locations_y',
+    'is_node_placed',
+    'current_node',
+    'mask',
+)
+
+ALL_OBSERVATIONS = STATIC_OBSERVATIONS + DYNAMIC_OBSERVATIONS
+
+INITIAL_OBSERVATIONS = STATIC_OBSERVATIONS + INITIAL_DYNAMIC_OBSERVATIONS
+
+
+@gin.configurable
+class ObservationConfig(object):
+  """A class that contains shared configs for observation."""
+
+  # The default numbers are the maximum number of nodes, edges, and grid size
+  # on a set of TPU blocks.
+  # Large numbers may cause GPU/TPU OOM during training.
+  def __init__(self,
+               max_num_nodes: int = 5000,
+               max_num_edges: int = 28400,
+               max_grid_size: int = 128):
+    self.max_num_edges = max_num_edges
+    self.max_num_nodes = max_num_nodes
+    self.max_grid_size = max_grid_size
+
+  @property
+  def observation_space(self) -> gym.spaces.Space:
+    """Env Observation space."""
+    return gym.spaces.Dict({
+        'normalized_num_edges':
+            gym.spaces.Box(low=0, high=1, shape=(1,)),
+        'normalized_num_hard_macros':
+            gym.spaces.Box(low=0, high=1, shape=(1,)),
+        'normalized_num_soft_macros':
+            gym.spaces.Box(low=0, high=1, shape=(1,)),
+        'normalized_num_port_clusters':
+            gym.spaces.Box(low=0, high=1, shape=(1,)),
+        'horizontal_routes_per_micron':
+            gym.spaces.Box(low=0, high=100, shape=(1,)),
+        'vertical_routes_per_micron':
+            gym.spaces.Box(low=0, high=100, shape=(1,)),
+        'macro_horizontal_routing_allocation':
+            gym.spaces.Box(low=0, high=100, shape=(1,)),
+        'macro_vertical_routing_allocation':
+            gym.spaces.Box(low=0, high=100, shape=(1,)),
+        'sparse_adj_weight':
+            gym.spaces.Box(low=0, high=100, shape=(self.max_num_edges,)),
+        'sparse_adj_i':
+            gym.spaces.Box(
+                low=0,
+                high=self.max_num_nodes - 1,
+                shape=(self.max_num_edges,),
+                dtype=np.int32),
+        'sparse_adj_j':
+            gym.spaces.Box(
+                low=0,
+                high=self.max_num_nodes - 1,
+                shape=(self.max_num_edges,),
+                dtype=np.int32),
+        'edge_counts':
+            gym.spaces.Box(
+                low=0,
+                high=self.max_num_edges - 1,
+                shape=(self.max_num_nodes,),
+                dtype=np.int32),
+        'node_types':
+            gym.spaces.Box(
+                low=0, high=3, shape=(self.max_num_nodes,), dtype=np.int32),
+        'is_node_placed':
+            gym.spaces.Box(
+                low=0, high=1, shape=(self.max_num_nodes,), dtype=np.int32),
+        'macros_w':
+            gym.spaces.Box(low=0, high=1, shape=(self.max_num_nodes,)),
+        'macros_h':
+            gym.spaces.Box(low=0, high=1, shape=(self.max_num_nodes,)),
+        'locations_x':
+            gym.spaces.Box(low=0, high=1, shape=(self.max_num_nodes,)),
+        'locations_y':
+            gym.spaces.Box(low=0, high=1, shape=(self.max_num_nodes,)),
+        'grid_cols':
+            gym.spaces.Box(low=0, high=1, shape=(1,)),
+        'grid_rows':
+            gym.spaces.Box(low=0, high=1, shape=(1,)),
+        'current_node':
+            gym.spaces.Box(
+                low=0, high=self.max_num_nodes - 1, shape=(1,), dtype=np.int32),
+        'mask':
+            gym.spaces.Box(
+                low=0, high=1, shape=(self.max_grid_size**2,), dtype=np.int32),
+    })
+
+
+def _to_dict(
+    flatten_obs: TensorType,
+    keys: FeatureKeyType,
+    observation_config: Optional[ObservationConfig] = None
+) -> Dict[Text, TensorType]:
+  """Unflatten the observation to a dictionary."""
+  if observation_config:
+    obs_space = observation_config.observation_space
+  else:
+    obs_space = ObservationConfig().observation_space
+  splits = [obs_space[k].shape[0] for k in keys]
+  splitted_obs = tf.split(flatten_obs, splits, axis=-1)
+  return {k: o for o, k in zip(splitted_obs, keys)}
+
+
+def _flatten(dict_obs: Dict[Text, TensorType],
+             keys: FeatureKeyType) -> TensorType:
+  out = [np.asarray(dict_obs[k]) for k in keys]
+  return np.concatenate(out, axis=-1)
+
+
+def flatten_static(dict_obs: Dict[Text, TensorType]) -> TensorType:
+  return _flatten(dict_obs=dict_obs, keys=STATIC_OBSERVATIONS)
+
+
+def flatten_dynamic(dict_obs: Dict[Text, TensorType]) -> TensorType:
+  return _flatten(dict_obs=dict_obs, keys=DYNAMIC_OBSERVATIONS)
+
+
+def flatten_all(dict_obs: Dict[Text, TensorType]) -> TensorType:
+  return _flatten(dict_obs=dict_obs, keys=ALL_OBSERVATIONS)
+
+
+def flatten_initial(dict_obs: Dict[Text, TensorType]) -> TensorType:
+  return _flatten(dict_obs=dict_obs, keys=INITIAL_OBSERVATIONS)
+
+
+def to_dict_static(
+    flatten_obs: TensorType,
+    observation_config: Optional[ObservationConfig] = None
+) -> Dict[Text, TensorType]:
+  """Convert the flattend numpy array of static observations back to a dict.
+
+  Args:
+    flatten_obs: a numpy array of static observations.
+    observation_config: Optional observation config.
+
+  Returns:
+    A dict representation of the observations.
+  """
+  return _to_dict(
+      flatten_obs=flatten_obs,
+      keys=STATIC_OBSERVATIONS,
+      observation_config=observation_config)
+
+
+def to_dict_dynamic(
+    flatten_obs: TensorType,
+    observation_config: Optional[ObservationConfig] = None
+) -> Dict[Text, TensorType]:
+  """Convert the flattend numpy array of dynamic observations back to a dict.
+
+  Args:
+    flatten_obs: a numpy array of dynamic observations.
+    observation_config: Optional observation config.
+
+  Returns:
+    A dict representation of the observations.
+  """
+  return _to_dict(
+      flatten_obs=flatten_obs,
+      keys=DYNAMIC_OBSERVATIONS,
+      observation_config=observation_config)
+
+
+def to_dict_all(
+    flatten_obs: TensorType,
+    observation_config: Optional[ObservationConfig] = None
+) -> Dict[Text, TensorType]:
+  """Convert the flattend numpy array of observations back to a dict.
+
+  Args:
+    flatten_obs: a numpy array of observations.
+    observation_config: Optional observation config.
+
+  Returns:
+    A dict representation of the observations.
+  """
+  return _to_dict(
+      flatten_obs=flatten_obs,
+      keys=ALL_OBSERVATIONS,
+      observation_config=observation_config)
\ No newline at end of file

CodeElements/Plc_client/test/0P2M0m/netlist.pb.txt

@@ -23,13 +23,13 @@ node {
   attr {
     key: "x"
     value {
-      f: 399
+      f: 300
     }
   }
   attr {
     key: "y"
     value {
-      f: 399
+      f: 300
     }
   }
   attr {
@@ -44,7 +44,7 @@ node {
   attr {
     key: "height"
     value {
-      f: 50
+      f: 200
     }
   }
   attr {
@@ -74,7 +74,7 @@ node {
   attr {
     key: "width"
     value {
-      f: 50
+      f: 200
     }
   }
 }
@@ -96,31 +96,31 @@ node {
   attr {
     key: "x_offset"
     value {
-      f: -25
+      f: -75
     }
   }
   attr {
     key: "y_offset"
     value {
-      f: -25
+      f: -75
     }
   }
   attr {
     key: "x"
     value {
-      f: 374
+      f: 0
     }
   }
   attr {
     key: "y"
     value {
-      f: 374
+      f: 0
     }
   }
   attr {
     key: "weight"
     value {
-      f: 1000
+      f: 1
     }
   }
 }
@@ -141,31 +141,31 @@ node {
   attr {
     key: "x_offset"
     value {
-      f: -25
+      f: -75
     }
   }
   attr {
     key: "y_offset"
     value {
-      f: 25
+      f: 75
     }
   }
   attr {
     key: "x"
     value {
-      f: 374
+      f: 0
     }
   }
   attr {
     key: "y"
     value {
-      f: 424
+      f: 0
     }
   }
   attr {
     key: "weight"
     value {
-      f: 1000
+      f: 1
     }
   }
 }
@@ -186,25 +186,25 @@ node {
   attr {
     key: "x_offset"
     value {
-      f: 25
+      f: 75
     }
   }
   attr {
     key: "y_offset"
     value {
-      f: -25
+      f: -75
     }
   }
   attr {
     key: "x"
     value {
-      f: 75
+      f: 0
     }
   }
   attr {
     key: "y"
     value {
-      f: 25
+      f: 0
     }
   }
 }
@@ -225,25 +225,25 @@ node {
   attr {
     key: "x_offset"
     value {
-      f: 25
+      f: 75
     }
   }
   attr {
     key: "y_offset"
     value {
-      f: 25
+      f: 75
     }
   }
   attr {
     key: "x"
     value {
-      f: 75
+      f: 0
     }
   }
   attr {
     key: "y"
     value {
-      f: 75
+      f: 0
     }
   }
 }
\ No newline at end of file

CodeElements/Plc_client/test/ariane133/initial.plc

 # Placement file for Circuit Training
-# Source input file(s) : ./output_ariane_NanGate45/22cols_30rows/g500_ub5_nruns10_c5_r3_v3_rc1/netlist.pb.txt
-# This file : ./output_ariane_NanGate45/22cols_30rows/g500_ub5_nruns10_c5_r3_v3_rc1/initial.plc
-# Original initial placement : 
-# Date : 2022-08-26 08:27:04
-# Columns : 22  Rows : 30
-# Width : 1357.360  Height : 1356.880
-# Area (stdcell+macros) : 1448306.937872215
-# Wirelength : 3264054.817
-# Wirelength cost : 0.0540
-# Congestion cost : 0.8487
-# Density cost : 0.6405
-# Fake net cost : 0.0000
-# 90% Congestion metric: (0.01363636363636364, 0.0006827604141139862)
-# Project : unset_project
-# Block : unset_block
-# Routes per micron, hor : 11.285  ver : 12.605
-# Routes used by macros, hor : 7.143  ver : 8.339
-# Smoothing factor : 0
-# Use incremental cost : False
-# 
-# To view this file (most options are default):
-# viewer_binary    --netlist_file ./output_ariane_NanGate45/22cols_30rows/g500_ub5_nruns10_c5_r3_v3_rc1/netlist.pb.txt    --canvas_width 1357.36 --canvas_height 1356.88    --grid_cols 22 --grid_rows=30    --init_placement ./output_ariane_NanGate45/22cols_30rows/g500_ub5_nruns10_c5_r3_v3_rc1/initial.plc    --project unset_project    --block_name unset_block    --congestion_smooth_range 0    --overlap_threshold 0    --noboundary_check
-# or you can simply run:
-# viewer_binary    --init_placement ./output_ariane_NanGate45/22cols_30rows/g500_ub5_nruns10_c5_r3_v3_rc1/initial.plc
-# 
-# 
-# 
+# Source input file(s) : environment/test_data/ariane/ariane.txt
+# This file : environment/test_data/ariane/init.plc
+# Date : 2022-03-13 09:30:00
+# Columns : 50  Rows : 50
+# Width : 1599.99  Height : 1598.8
+# Area : 1244102.4819999968
+# Wirelength : 0.0
+# Wirelength cost : 0.0
+# Congestion cost : 0.0
+# Block : ariane
+# Routes per micron, hor : 70.33  ver : 74.51
+# Routes used by macros, hor : 51.79  ver : 51.79
+# Smoothing factor : 2
+# Overlap threshold : 0.004
+#
+#
+#
 # Counts of node types:
 # HARD_MACROs     :       133
 # HARD_MACRO_PINs :      7847

Docs/OurProgress/README.md

@@ -1861,6 +1861,9 @@ We updated the detailed algorithm for [gridding](https://github.com/TILOS-AI-Ins
 In constrast to the open-source [grid_size_selection.py](https://github.com/google-research/circuit_training/blob/main/circuit_training/grouping/grid_size_selection.py) in Circuit Training repo, which still calls the wrapper functions of plc client, our python scripts implement
 the gridding from sractch and are easy to understand. The results of our scripts match exactly that of Circuit Training.
 
+**September 21:**
+We updated the detailed algorithm for [grouping](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/CodeElements/Grouping) and [Clustering](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/CodeElements/Clustering). Here we explictly shows how the netlist information such as net model is used during grouping and clustering, while the open-source Circuit Training implementation still calls the wrapper function of plc client to get netlist information.
+
 
 ## **Pinned (to bottom) question list:**
 

Docs/ProxyCost/README.md

@@ -184,7 +184,6 @@ Figure corresponding to point five.
 3. For each two pin nets we update congestion values.
 
 #### *Computation for Smoothing:*
-When a macro overlaps with multiple gridcells, if any part of the module partially overlaps with the gridcell (either vertically, or horizontally), we set the top row (if vertical) or right column (if horizontal) to 0.
 
 1. **Congestion smoothing = 0.0**
    1. Return the grid congestion that is due to net routing: no smoothing is applied.
@@ -203,6 +202,8 @@ When a macro overlaps with multiple gridcells, if any part of the module partial
 </p>
 
 #### *Computation for Macro Congestion:*
+When a macro overlaps with multiple gridcells, if any part of the module partially overlaps with the gridcell (either vertically, or horizontally), we set the top row (if vertical) or right column (if horizontal) to 0.
+
 - For each hard MACRO:
    - For each gridcell it overlaps with:
       - For both horizontal and vertical macro routing congestion map:
@@ -228,4 +229,4 @@ When a macro overlaps with multiple gridcells, if any part of the module partial
 #### *Computation of the final congestion cost:*
 - Adding the Macro allocation congestion and Net routing congestion together for both Vertical and Horizontal congestion map
 - Concat both vertical and horizontal congestion maps together.
-- Take the top **5**% of the most congested gridcells **in the concatenation**, and average them out to get the final congestion cost. 
\ No newline at end of file
+- Take the top **5**% of the most congested gridcells **in the concatenation**, and average them out to get the final congestion cost. 

README.md

@@ -211,16 +211,16 @@ while allowing soft macros (standard-cell clusters) to also find good locations.
 
 <!--## **Reproducible Example Solutions** -->
 
-## **Baseline for Circuit Training**
-We provide a competitive baseline for [Google Brain's Circuit Training](https://github.com/google-research/circuit_training) by placing macros manually following similar rules as the RL agent. The example for Ariane133 implemented on NanGate45 is shown [here](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/Flows/NanGate45/ariane133). We generate the manual macro placement in two steps:  
-(1) we call the [gridding](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/CodeElements/Gridding) scripts to generate grid cells (27 x 27 in our case); (2) we manually place macros on the center of grid cells.
+## **A Human Baseline for Circuit Training**
+We provide a human-generated baseline for [Google Brain's Circuit Training](https://github.com/google-research/circuit_training) by placing macros manually following similar (grid-restricted location) rules as the RL agent. The example for Ariane133 implemented on NanGate45 is shown [here](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/Flows/NanGate45/ariane133). We generate the manual macro placement in two steps:  
+(1) we call the [gridding](https://github.com/TILOS-AI-Institute/MacroPlacement/tree/main/CodeElements/Gridding) scripts to generate grid cells (27 x 27 in our case); (2) we manually place macros on the centers of grid cells.
 
 
 
 ## **FAQ**
 **Why are you doing this?**
 - The challenges of data and benchmarking in EDA research have, in our view, been contributing factors in the controversy regarding the Nature work. The mission of the [TILOS AI Institute](https://tilos.ai/) includes finding solutions to these challenges -- in high-stakes applied optimization domains (such as IC EDA), and at community-scale. We hope that our effort will become an existence proof for transparency, reproducibility, and democratization of research in EDA. [We applaud and thank Cadence Design Systems for allowing their tool runscripts to be shared openly by researchers, enabling reproducibility of results obtained via use of Cadence tools.]
-- We do understand that Google has been working hard to complete the open-sourcing of Morpheus, and that this effort continues today. However, as pointed out in [this Doc](https://docs.google.com/document/d/1vkPRgJEiLIyT22AkQNAxO8JtIKiL95diVdJ_O4AFtJ8/edit?usp=sharing), it has been more than a year since "Data and Code Availability" was committed with publication of the [Nature paper](https://www.nature.com/articles/s41586-021-03544-w). We consider our work a "backstop" or "safety net" for Google's internal efforts, and a platform for researchers to build on. 
+- We do understand that Google has been working hard to complete the open-sourcing of Morpheus, and that this effort continues today. However, as pointed out in [this Doc](https://docs.google.com/document/d/1vkPRgJEiLIyT22AkQNAxO8JtIKiL95diVdJ_O4AFtJ8/edit?usp=sharing), updated [here](https://docs.google.com/document/d/1c-uweo3DHiCWZyBzAdNCqqcOrAbKq1sVIfY0_4bFCYE/edit?usp=sharing), it has been more than a year since "Data and Code Availability" was committed with publication of the [Nature paper](https://www.nature.com/articles/s41586-021-03544-w). We consider our work a "backstop" or "safety net" for Google's internal efforts, and a platform for researchers to build on. 
 
 **What can others contribute?**
 - Our shopping list (updated August 2022) includes the following. Please join in!  
@@ -232,7 +232,7 @@ We provide a competitive baseline for [Google Brain's Circuit Training](https://
 
 **What is your timeline?**
 - We showed our [progress](https://open-source-eda-birds-of-a-feather.github.io/doc/slides/MacroPlacement-SpecPart-DAC-BOF-v5.pdf) at the Open-Source EDA and Benchmarking Summit birds-of-a-feather [meeting](https://open-source-eda-birds-of-a-feather.github.io/) on July 12 at DAC-2022.
-- We are now (late August 2022) studying benefits and limitations of the CT methodology itself, as noted in [this Doc](https://docs.google.com/document/d/1c-uweo3DHiCWZyBzAdNCqqcOrAbKq1sVIfY0_4bFCYE/edit).
+- We are now (late August 2022) studying benefits and limitations of the CT methodology itself, following a thread of experimental questions as noted [here](https://docs.google.com/document/d/1HHZNcid5CZvvRqj_njzF7hBhtNSpmRn3fCYniWNYBiY/edit?usp=sharing) and [here](https://docs.google.com/document/d/1c-uweo3DHiCWZyBzAdNCqqcOrAbKq1sVIfY0_4bFCYE/edit).
 
 
 ## **Related Links**