fix: paths for CTP, isa_explorer, and deploy (#855)

Should fix the deployment

Author: dhower-qc

backends/ext_pdf_doc/tasks.rake

@@ -72,7 +72,7 @@ end
 
 rule %r{#{$resolver.gen_path}/ext_pdf_doc/.*/adoc/.*_extension\.adoc} => proc { |tname|
   config_name = Pathname.new(tname).relative_path_from("#{$resolver.gen_path}/ext_pdf_doc").to_s.split("/")[0]
-  arch_yaml_paths = Dir.glob("#{$root}/arch/**/*.yaml")
+  arch_yaml_paths = Dir.glob("#{$resolver.resolved_spec_path(config_name)}/**/*.yaml")
   cfg_path = $resolver.gen_path / "ext_pdf_doc" / "#{config_name}.yaml"
   cfg = Udb::AbstractConfig.create(cfg_path)
   arch_yaml_paths += Dir.glob("#{cfg.arch_overlay_abs}/**/*.yaml") unless cfg.arch_overlay.nil?

backends/isa_explorer/isa_explorer.rb

@@ -1,8 +1,12 @@
+
+# typed: true
 # frozen_string_literal: true
-#
+
 # Generate
 
+require "sorbet-runtime"
 require "write_xlsx"
+
 require "udb/architecture"
 
 # @param presence [String] Can be nil
@@ -85,9 +89,8 @@ def arch2ext_table(arch)
 
 # @param arch [Architecture] The entire RISC-V architecture
 # @return [Hash<String,Array<String>] Instruction table data
+sig { params(arch: Udb::Architecture).returns(T::Hash[String, T::Array[String]]) }
 def arch2inst_table(arch)
-  raise ArgumentError, "arch is a #{arch.class} class but needs to be Architecture" unless arch.is_a?(Architecture)
-
   sorted_profile_releases = get_sorted_profile_releases(arch)
 
   inst_table = {
@@ -134,9 +137,8 @@ def arch2inst_table(arch)
 
 # @param arch [Architecture] The entire RISC-V architecture
 # @return [Hash<String,Array<String>] CSR table data
+sig { params(arch: Udb::Architecture).returns(T::Hash[String, T::Array[String]]) }
 def arch2csr_table(arch)
-  raise ArgumentError, "arch is a #{arch.class} class but needs to be Architecture" unless arch.is_a?(Architecture)
-
   sorted_profile_releases = get_sorted_profile_releases(arch)
 
   csr_table = {
@@ -230,9 +232,8 @@ def gen_xlsx_table(table, workbook, worksheet)
 #
 # @param arch [Architecture] The entire RISC-V architecture
 # @param output_pname [String] Full absolute pathname to output file
+sig { params(arch: Udb::Architecture, output_pname: String).void }
 def gen_xlsx(arch, output_pname)
-  raise ArgumentError, "arch is a #{arch.class} class but needs to be Architecture" unless arch.is_a?(Architecture)
-  raise ArgumentError, "output_pname is a #{output_pname.class} class but needs to be String" unless output_pname.is_a?(String)
 
   # Create a new Excel workbook
   $logger.info "Creating Excel workboook #{output_pname}"

backends/isa_explorer/tasks.rake

@@ -81,7 +81,7 @@ file "#{GEN_XLSX}" => [
     __FILE__,
     src_pnames
 ].flatten do |t|
-    arch = create_arch
+    arch = $resolver.cfg_arch_for("_")
 
     # Ensure directory holding target file is present.
     FileUtils.mkdir_p File.dirname(t.name)

backends/portfolio/templates/normative_rules.adoc.erb

@@ -1,5 +1,5 @@
 <% unless db_obj.cert_normative_rules.empty? -%>
-<% nice_name = db_obj.is_a?(CsrField) ? "#{db_obj.parent.name}.#{db_obj.name}" : db_obj.name -%>
+<% nice_name = db_obj.is_a?(Udb::CsrField) ? "#{db_obj.parent.name}.#{db_obj.name}" : db_obj.name -%>
 <% if defined?(use_description_list) && use_description_list -%>
 Normative Rules for `<%= nice_name %>`: ::
 <% else -%>

backends/portfolio/templates/test_procedures.adoc.erb

@@ -1,5 +1,5 @@
 <% unless db_obj.cert_test_procedures.empty? -%>
-<% nice_name = db_obj.is_a?(CsrField) ? "#{db_obj.parent.name}.#{db_obj.name}" : db_obj.name -%>
+<% nice_name = db_obj.is_a?(Udb::CsrField) ? "#{db_obj.parent.name}.#{db_obj.name}" : db_obj.name -%>
 <% if defined?(use_description_list) && use_description_list -%>
 Test Procedures for `<%= nice_name %>`: ::
 <% else -%>

backends/proc_ctp/tasks.rake

@@ -5,21 +5,21 @@
 require "pathname"
 
 PROC_CTP_DOC_DIR = Pathname.new "#{$root}/backends/proc_ctp"
-PROC_CTP_GEN_DIR = $root / "gen" / "proc_ctp"
+PROC_CTP_GEN_DIR = $resolver.gen_path / "proc_ctp"
 
-Dir.glob("#{$root}/arch/proc_cert_model/*.yaml") do |f|
+Dir.glob("#{$resolver.std_path}/proc_cert_model/*.yaml") do |f|
   model_name = File.basename(f, ".yaml")
   model_obj = YAML.load_file(f, permitted_classes: [Date])
   class_name = File.basename(model_obj['class']['$ref'].split("#")[0], ".yaml")
   raise "Ill-formed processor certificate model file #{f}: missing 'class' field" if model_obj['class'].nil?
 
   file "#{PROC_CTP_GEN_DIR}/adoc/#{model_name}-CTP.adoc" => [
     __FILE__,
-    "#{$root}/arch/proc_cert_class/#{class_name}.yaml",
-    "#{$root}/arch/proc_cert_model/#{model_name}.yaml",
-    "#{$root}/lib/arch_obj_models/certificate.rb",
-    "#{$root}/lib/arch_obj_models/portfolio.rb",
-    "#{$root}/lib/portfolio_design.rb",
+    "#{$resolver.std_path}/proc_cert_class/#{class_name}.yaml",
+    "#{$resolver.std_path}/proc_cert_model/#{model_name}.yaml",
+    "#{Udb.gem_path}/lib/udb/obj/certificate.rb",
+    "#{Udb.gem_path}/lib/udb/obj/portfolio.rb",
+    "#{Udb.gem_path}/lib/udb/portfolio_design.rb",
     "#{$root}/backends/portfolio/templates/ext_appendix.adoc.erb",
     "#{$root}/backends/portfolio/templates/inst_appendix.adoc.erb",
     "#{$root}/backends/portfolio/templates/csr_appendix.adoc.erb",
@@ -65,8 +65,8 @@ namespace :gen do
       exit 1
     end
 
-    unless File.exist?("#{$root}/arch/proc_cert_model/#{model_name}.yaml")
-      warn "No certification model named '#{model_name}' found in arch/proc_cert_model"
+    unless File.exist?("#{$resolver.std_path}/proc_cert_model/#{model_name}.yaml")
+      warn "No certification model named '#{model_name}' found in #{$resolver.std_path}/proc_cert_model"
       exit 1
     end
 
@@ -77,16 +77,16 @@ namespace :gen do
     Generate Processor CTP (Certification Test Plan) as an HTML file.
 
     Required options:
-      model_name - The name of the certification model under arch/proc_cert_model
+      model_name - The name of the certification model under spec/std/isa/proc_cert_model
   DESC
   task :proc_ctp_html, [:model_name] do |_t, args|
     if args[:model_name].nil?
       warn "Missing required option: 'model_name'"
       exit 1
     end
 
-    unless File.exist?("#{$root}/arch/proc_cert_model/#{args[:model_name]}.yaml")
-      warn "No certification model named '#{args[:model_name]}' found in arch/proc_cert_model"
+    unless File.exist?("#{$resolver.std_path}/proc_cert_model/#{args[:model_name]}.yaml")
+      warn "No certification model named '#{args[:model_name]}' found in #{$resolver.std_path}/proc_cert_model"
       exit 1
     end
 

tools/ruby-gems/udb/lib/udb/req_expression.rb

@@ -9,7 +9,8 @@
 
 module Udb
 
-class ExtensionVersion; end
+  # sorbet needs a forward declration
+  class ExtensionVersion; end
 
   # return type for satisfied_by functions
   class SatisfiedResult < T::Enum
@@ -71,6 +72,7 @@ def initialize(composition_hash, cfg_arch)
 
     @hsh = composition_hash
     @arch = cfg_arch
+    @satisfied_by_cfg_arch = T.let({}, T::Hash[String, SatisfiedResult])
   end
 
   sig { override.returns(T.any(String, T::Hash[String, T.untyped])) }
@@ -625,24 +627,25 @@ def could_be_true?(cfg_arch)
 
   sig { override.params(cfg_arch: ConfiguredArchitecture).returns(SatisfiedResult) }
   def satisfied_by_cfg_arch?(cfg_arch)
-    if cfg_arch.fully_configured?
-      if satisfied_by? { |ext_req| cfg_arch.transitive_implemented_extension_versions.any? { |ev| ext_req.satisfied_by?(ev) } }
-        SatisfiedResult::Yes
+    @satisfied_by_cfg_arch[cfg_arch.name] ||=
+      if cfg_arch.fully_configured?
+        if satisfied_by? { |ext_req| cfg_arch.transitive_implemented_extension_versions.any? { |ev| ext_req.satisfied_by?(ev) } }
+          SatisfiedResult::Yes
+        else
+          SatisfiedResult::No
+        end
+      elsif cfg_arch.partially_configured?
+        if satisfied_by? { |cond_ext_req| cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| cond_ext_req.satisfied_by?(cfg_ext_req) }  }
+          SatisfiedResult::Yes
+        elsif satisfied_by? { |cond_ext_req| cfg_arch.possible_extension_versions.any? { |cfg_ext_ver| cond_ext_req.satisfied_by?(cfg_ext_ver) }  }
+          SatisfiedResult::Maybe
+        else
+          SatisfiedResult::No
+        end
       else
-        SatisfiedResult::No
-      end
-    elsif cfg_arch.partially_configured?
-      if satisfied_by? { |cond_ext_req| cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| cond_ext_req.satisfied_by?(cfg_ext_req) }  }
+        # unconfig. everything flies
         SatisfiedResult::Yes
-      elsif satisfied_by? { |cond_ext_req| cfg_arch.possible_extension_versions.any? { |cfg_ext_ver| cond_ext_req.satisfied_by?(cfg_ext_ver) }  }
-        SatisfiedResult::Maybe
-      else
-        SatisfiedResult::No
       end
-    else
-      # unconfig. everything flies
-      SatisfiedResult::Yes
-    end
   end
 
   # returns true if the list of extension requirements *can* satisfy the condition.

tools/ruby-gems/udb/lib/udb/resolver.rb

@@ -66,6 +66,14 @@ def self.default_cfgs_path
   class Resolver
     extend T::Sig
 
+    # return type of #cfg_info
+    class ConfigInfo < T::Struct
+      const :name, String
+      const :path, Pathname
+      const :unresolved_yaml, T::Hash[String, T.untyped]
+      prop :resolved_yaml, T.nilable(T::Hash[String, T.untyped])
+    end
+
     # path to find database schema files
     sig { returns(Pathname) }
     attr_reader :schemas_path
@@ -86,6 +94,18 @@ class Resolver
     sig { returns(Pathname) }
     attr_reader :custom_path
 
+    # path to merged spec (merged with custom overley, but prior to resolution)
+    sig { params(cfg_path_or_name: T.any(String, Pathname)).returns(Pathname) }
+    def merged_spec_path(cfg_path_or_name)
+      @gen_path / "spec" / cfg_info(cfg_path_or_name).name
+    end
+
+    # path to merged and resolved spec
+    sig { params(cfg_path_or_name: T.any(String, Pathname)).returns(Pathname) }
+    def resolved_spec_path(cfg_path_or_name)
+      @gen_path / "resolved_spec" / cfg_info(cfg_path_or_name).name
+    end
+
     # path to a python binary
     sig { returns(Pathname) }
     attr_reader :python_path
@@ -126,6 +146,9 @@ def initialize(
       @custom_path = custom_path_override || (@repo_root / "spec" / "custom" / "isa")
       @python_path = python_path_override || (@repo_root / ".home" / ".venv" / "bin" / "python3")
 
+      # cache of config names
+      @cfg_info = T.let({}, T::Hash[T.any(String, Pathname), ConfigInfo])
+
       FileUtils.mkdir_p @gen_path
     end
 
@@ -151,23 +174,24 @@ def run(cmd)
     # returns the config data
     sig { params(config_path: Pathname).returns(T::Hash[String, T.untyped]) }
     def resolve_config(config_path)
-      config_yaml = T.nilable(T::Hash[String, T.untyped])
-      config_name = config_path.basename(".yaml")
+      config_info = cfg_info(config_path)
+      return T.must(config_info.resolved_yaml) unless config_info.resolved_yaml.nil?
 
+      resolved_config_yaml = T.let({}, T.nilable(T::Hash[String, T.untyped]))
       # write the config with arch_overlay expanded
-      if any_newer?(gen_path / "cfgs" / "#{config_name}.yaml", [config_path])
-        config_yaml = YAML.load_file(config_path)
-
+      if any_newer?(gen_path / "cfgs" / "#{config_info.name}.yaml", [config_path])
         # is there anything to do here? validate?
 
+        resolved_config_yaml = config_info.unresolved_yaml.dup
+        resolved_config_yaml["$source"] = config_path.realpath.to_s
+
         FileUtils.mkdir_p gen_path / "cfgs"
-        File.write(gen_path / "cfgs" / "#{config_name}.yaml", YAML.dump(config_yaml))
+        File.write(gen_path / "cfgs" / "#{config_info.name}.yaml", YAML.dump(resolved_config_yaml))
       else
-        config_yaml = YAML.load_file(gen_path / "cfgs" / "#{config_name}.yaml")
+        resolved_config_yaml = YAML.load_file(gen_path / "cfgs" / "#{config_info.name}.yaml")
       end
 
-      config_yaml["$source"] = config_path.realpath
-      config_yaml
+      config_info.resolved_yaml = resolved_config_yaml
     end
 
     sig { params(config_yaml: T::Hash[String, T.untyped]).void }
@@ -189,16 +213,16 @@ def merge_arch(config_yaml)
         end
       raise "custom directory '#{overlay_path}' does not exist" if !overlay_path.nil? && !overlay_path.directory?
 
-      if any_newer?(gen_path / "spec" / config_name / ".stamp", deps)
+      if any_newer?(merged_spec_path(config_name) / ".stamp", deps)
         run [
           python_path.to_s,
           "#{Udb.gem_path}/python/yaml_resolver.py",
           "merge",
           std_path.to_s,
           overlay_path.nil? ? "/does/not/exist" : overlay_path.to_s,
-          "#{gen_path}/spec/#{config_name}"
+          merged_spec_path(config_name).to_s
         ]
-        FileUtils.touch(gen_path / "spec" / config_name / ".stamp")
+        FileUtils.touch(merged_spec_path(config_name) / ".stamp")
       end
     end
 
@@ -207,46 +231,58 @@ def resolve_arch(config_yaml)
       merge_arch(config_yaml)
       config_name = config_yaml["name"]
 
-      deps = Dir[gen_path / "arch" / config_yaml["name"] / "**" / "*.yaml"].map { |p| Pathname.new(p) }
-      if any_newer?(gen_path / "resolved_spec" / config_yaml["name"] / ".stamp", deps)
+      deps = Dir[merged_spec_path(config_name) / "**" / "*.yaml"].map { |p| Pathname.new(p) }
+      if any_newer?(resolved_spec_path(config_name) / ".stamp", deps)
         run [
           python_path.to_s,
           "#{Udb.gem_path}/python/yaml_resolver.py",
           "resolve",
-          "#{gen_path}/spec/#{config_name}",
-          "#{gen_path}/resolved_spec/#{config_name}"
+          merged_spec_path(config_name).to_s,
+          resolved_spec_path(config_name).to_s
         ]
-        FileUtils.touch(gen_path / "resolved_spec" / config_yaml["name"] / ".stamp")
+        FileUtils.touch(resolved_spec_path(config_name) / ".stamp")
       end
     end
 
-    # resolve the specification for a config, and return a ConfiguredArchitecture
-    sig { params(config_path_or_name: T.any(Pathname, String)).returns(Udb::ConfiguredArchitecture) }
-    def cfg_arch_for(config_path_or_name)
+    sig { params(config_path_or_name: T.any(Pathname, String)).returns(ConfigInfo) }
+    def cfg_info(config_path_or_name)
+      return @cfg_info.fetch(config_path_or_name) if config_path_or_name.is_a?(String) && @cfg_info.key?(config_path_or_name)
+      return @cfg_info.fetch(config_path_or_name.realpath) if config_path_or_name.is_a?(Pathname) && @cfg_info.key?(config_path_or_name.realpath)
+
       config_path =
         case config_path_or_name
         when Pathname
           raise "Path does not exist: #{config_path_or_name}" unless config_path_or_name.file?
 
-          config_path_or_name
+          config_path_or_name.realpath
         when String
-          @repo_root / "cfgs" / "#{config_path_or_name}.yaml"
+          (@repo_root / "cfgs" / "#{config_path_or_name}.yaml").realpath
         else
           T.absurd(config_path_or_name)
         end
 
-      @cfg_archs ||= {}
-      return @cfg_archs[config_path] if @cfg_archs.key?(config_path)
+      config_yaml = YAML.safe_load_file(config_path)
+      info = ConfigInfo.new(name: config_yaml["name"], path: config_path, unresolved_yaml: config_yaml)
+      @cfg_info[config_path] = info
+      @cfg_info[info.name] = info
+    end
+    private :cfg_info
 
-      config_yaml = resolve_config(config_path)
-      config_name = config_yaml["name"]
+    # resolve the specification for a config, and return a ConfiguredArchitecture
+    sig { params(config_path_or_name: T.any(Pathname, String)).returns(Udb::ConfiguredArchitecture) }
+    def cfg_arch_for(config_path_or_name)
+      config_info = cfg_info(config_path_or_name)
+
+      @cfg_archs ||= {}
+      return @cfg_archs[config_info.path] if @cfg_archs.key?(config_info.path)
 
-      resolve_arch(config_yaml)
+      resolve_config(config_info.path)
+      resolve_arch(config_info.unresolved_yaml)
 
-      @cfg_archs[config_path] = Udb::ConfiguredArchitecture.new(
-        config_name,
-        Udb::AbstractConfig.create(gen_path / "cfgs" / "#{config_name}.yaml"),
-        gen_path / "resolved_spec" / config_name
+      @cfg_archs[config_info.path] = Udb::ConfiguredArchitecture.new(
+        config_info.name,
+        Udb::AbstractConfig.create(gen_path / "cfgs" / "#{config_info.name}.yaml"),
+        resolved_spec_path(config_info.name)
       )
     end
   end