Enhancements to compare technology versions

Signed-off-by: Jeff Ng <[email protected]>

Author: jeffng-or

flow/scripts/klayout/README.md

@@ -17,6 +17,10 @@ Copy the following files into ~/.klayout/ruby
 - GenericLayerNameMapper.rb
 - KLayoutLayerMapGenerator.rb
 - KLayoutLayerPropertiesFileGenerator.rb
+- LEFViaData.rb
+- LEFNamedObject.rb
+- LEFVia.rb
+- LEFLayer.rb
 
 Also make sure that you have the import_tf.rb file from [tf_import](https://github.com/klayoutmatthias/tf_import) copied there as well. If you follow the instructions at [Guide to Integrate a New Platform into the OpenROAD Flow](https://openroad-flow-scripts.readthedocs.io/en/latest/contrib/PlatformBringUp.html#klayout-properties-file), it will be installed in ~/.klayout/salt/tf_import. Just copy it over to ~/.klayout/ruby, so that the scripts can find it.
 

flow/scripts/klayout/src/KLayoutTechFileGenerator.rb

@@ -72,13 +72,16 @@ def add_via_connectivity(lef_file, sorted_layer_map)
         via_data = LEFViaData.new()
         via_data.read_file(lef_file)
         connectivity = @tech.component("connectivity")
-        via_data.get_map().each do | via_name, layer_stack |
-            lower_layer = layer_stack[0]
-            via_layer = layer_stack[1]
-            upper_layer = layer_stack[2]
+        via_data.get_map().each do | via_name, via |
+            layer_list = via.get_layer_list()
+            lower_layer = layer_list[0]
+            via_layer = layer_list[1]
+            upper_layer = layer_list[2]
             connection = NetTracerConnectivity.new
             connection.name = via_name
-            connection.connection(lower_layer, via_layer, upper_layer)
+            connection.connection(lower_layer.get_layer().get_name(),
+                                  via_layer.get_layer().get_name(),
+                                  upper_layer.get_layer().get_name())
             connectivity.add(connection)
         end
         # add symbolic mappings based on layers having multiple mappings

flow/scripts/klayout/src/LEFLayer.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'digest'
+require_relative 'LEFNamedObject'
+
+#
+# Class to store LEF layer data
+#
+class LEFLayer < LEFNamedObject
+    #
+    # Initializer
+    #
+    def initialize(name, num, type=nil)
+        super(name)
+        @num = num
+        @type = type
+    end
+
+    #
+    # Sets the layer type
+    #
+    def set_type(layer_type)
+        @type = layer_type
+    end
+
+    #
+    # Sets the layer number (order of layer in the tech LEF, which implies
+    # layer stacking order
+    #
+    def get_number()
+        return @num
+    end
+
+    #
+    # Returns the layer type
+    #
+    def get_type()
+        return @type
+    end
+
+    #
+    # Writes the LEF statement snippet for the layer
+    #
+    def write_lef(out)
+        layer_name = get_name()
+        out.puts sprintf("LAYER %s", layer_name)
+        out.puts sprintf("  TYPE %s ;", get_type())
+        out.puts sprintf("END %s", layer_name)
+        out.puts
+    end
+
+    #
+    # Returns the SHA256 for the layer
+    #
+    # Layer number is skipped since the layer number could be different between
+    # tech LEF versions and we'd like to use this to compare across versions
+    #
+    def sha256()
+        if get_type.nil?
+            return Digest::SHA256.hexdigest(get_name())
+        end
+        return Digest::SHA256.hexdigest(get_name() + get_type())
+    end
+end

flow/scripts/klayout/src/LEFNamedObject.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+#
+# Class for a basic LEF named object
+#
+class LEFNamedObject
+    #
+    # Initializer
+    #
+    def initialize(name)
+        @name = name
+    end
+
+    #
+    # Returns the name
+    #
+    def get_name()
+        return @name
+    end
+end

flow/scripts/klayout/src/LEFVia.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+require 'digest'
+require 'json'
+require_relative 'LEFNamedObject'
+
+#
+# Class to store LEF via information
+#
+class LEFVia < LEFNamedObject
+    #
+    # Container class that store information about the and shapes that are part
+    # of the via that exist on the specified layer. Only RECTs are supported.
+    #
+    class LEFViaLayer
+        #
+        # Initializer
+        #
+        # layer is a ref to a LEFLayer
+        # shape_list is the list of shapes for the via on the specified layer
+        #
+        def initialize(layer)
+            # make sure this is a LEFLayer
+            if !layer.is_a?(LEFLayer)
+                raise ArgumentError, sprintf("LEFViaLayer initialize expects LEFLayer, got %s", layer.class.name)
+            end
+            @layer = layer
+            @shape_list = []
+        end
+
+        #
+        # Adds a shape to the shape list
+        #
+        def add_shape(shape)
+            @shape_list << shape
+        end
+
+        #
+        # Returns the LEF layer for the shapes
+        #
+        def get_layer()
+            return @layer
+        end
+
+        #
+        # Returns the shape list
+        #
+        def get_shape_list()
+            return @shape_list
+        end
+
+        #
+        # Computes and returns the sha256 for the container
+        #
+        def sha256()
+            layer_sha = get_layer().sha256()
+            serialized_shapes = JSON.generate(get_shape_list)
+            shape_list_sha = Digest::SHA256.hexdigest(serialized_shapes)
+            return Digest::SHA256.hexdigest(layer_sha + shape_list_sha)
+        end
+
+        #
+        # Writes the LEF snippet for the container
+        #
+        def write_lef(outfh)
+            outfh.puts sprintf("  LAYER %s ;", get_layer().get_name())
+            get_shape_list.each do | rect |
+                outfh.puts sprintf("  RECT %5.3f %5.3f %5.3f %5.3f ;", rect[0],
+                                   rect[1], rect[2], rect[3])
+            end
+        end
+    end
+
+    #
+    # Initializer
+    #
+    # layer_list is a list of LEFViaLayers, which is unsorted. That way whoever
+    # is creating the via can just add LEFViaLayers without regard for the
+    # layer stacking order.
+    #
+    def initialize(name, is_default=false)
+        super(name)
+        @is_default = is_default
+
+        # List of LEFViaLayers - unsorted
+        @layer_list = []
+    end
+
+    #
+    # Computes and returns the sha256 for the via
+    #
+    def sha256()
+        layer_stack = get_layer_list()
+        hashes = get_layer_list.map { |layer| layer.sha256 }
+        concat_hashes = hashes.join
+        return Digest::SHA256.hexdigest(concat_hashes)
+    end
+
+    #
+    # Returns the LEFViaLayer list for the via
+    #
+    # default is to sort the layers, by the layer number. That way it's returned
+    # bottom layer to top layer
+    #
+    def get_layer_list(sorted=true)
+        if sorted
+            return @layer_list.sort_by { |layer| layer.get_layer().get_number }
+        end
+        return @layer_list
+    end
+
+    #
+    # Adds a layer to the layer list
+    #
+    def add_layer(layer)
+        @layer_list << layer
+    end
+
+    #
+    # Writes the LEF snippet
+    #
+    def write_lef(outfh)
+        via_name = get_name()
+        if @is_default
+            default_str = " DEFAULT"
+        else
+            default_str = ""
+        end
+        outfh.puts sprintf("VIA %s%s", via_name, default_str)
+        get_layer_list().each do | layer |
+            layer.write_lef(outfh)
+        end
+        outfh.puts sprintf("END %s", via_name)
+        outfh.puts
+    end
+end