origen_sim 0.5.5 → 0.6.0

data/lib/origen_sim/commands/ci.rb

@@ -0,0 +1,36 @@
+require 'optparse'
+require 'origen/commands/helpers'
+
+options = {}
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Checkin the simulation object for the current or given environment/target.
+
+Note that this will commit whatever is in your workspace as the latest version, regardless
+of whether there exists any more recent version in the repository.
+
+Usage: origen sim:ci [options]
+  EOT
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  # Apply any application option extensions to the OptionParser
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+
+opt_parser.parse! ARGV
+
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+Origen.load_target
+
+unless tester.sim?
+  Origen.log.error 'To run the sim:ci command your target/environment must instantiate an OrigenSim::Tester'
+  exit 1
+end
+
+tester.simulator.commit_simulation_objects(options)

data/lib/origen_sim/commands/co.rb

@@ -0,0 +1,36 @@
+require 'optparse'
+require 'origen/commands/helpers'
+
+options = {}
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Checkout the simulation object for the current or given environment/target.
+
+Note that this will force a new checkout and will overwrite whatever is in your workspace.
+
+Usage: origen sim:co [options]
+  EOT
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  # Apply any application option extensions to the OptionParser
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+
+opt_parser.parse! ARGV
+
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+Origen.load_target
+
+unless tester.sim?
+  Origen.log.error 'To run the sim:co command your target/environment must instantiate an OrigenSim::Tester'
+  exit 1
+end
+
+options[:force] = true
+tester.simulator.fetch_simulation_objects(options)

data/lib/origen_sim/origen/pins/pin.rb

@@ -5,24 +5,12 @@ module Origen
     class Pin
       # The index number that is used to refer to the pin within the simulation
       attr_accessor :simulation_index
-      # When generating a testbench the top-level signal will be tied off to the given
-      # logic level if this is set to 0 or 1
-      attr_accessor :tie_off
 
       alias_method :_orig_initialize, :initialize
       def initialize(id, owner, options = {})
-        @tie_off = options[:tie_off]
         _orig_initialize(id, owner, options)
       end
 
-      def rtl_name
-        if primary_group
-          (@rtl_name || primary_group.id).to_s
-        else
-          (@rtl_name || id).to_s
-        end
-      end
-
       alias_method :_orig_set_value, :set_value
       def set_value(val)
         ret = _orig_set_value(val)
@@ -63,10 +51,16 @@ module Origen
         @simulator_value = nil
       end
 
+      def apply_force
+        if force
+          simulator.put("2^#{simulation_index}^#{force}")
+        end
+      end
+
       # Applies the current pin state to the simulation, this is triggered everytime
       # the pin state or value changes
       def update_simulation
-        return if tie_off || !simulation_index || !tester.timeset || !simulator_needs_update?
+        return if force || !simulation_index || !tester.timeset || !simulator_needs_update?
         case state
           when :drive
             @simulator_state = :drive

data/lib/origen_sim/origen_testers/api.rb

@@ -7,5 +7,71 @@ module OrigenTesters
       is_a?(OrigenSim::Tester)
     end
     alias_method :simulator?, :sim?
+
+    def sim_capture(id, *pins)
+      if @sim_capture
+        fail 'Nesting of sim_capture blocks is not yet supported!'
+      end
+      options = pins.last.is_a?(Hash) ? pins.pop : {}
+      pins = pins.map { |p| p.is_a?(String) || p.is_a?(Symbol) ? dut.pin(p) : p }
+      pins.each(&:save)
+      @sim_capture = pins.map { |p| [p, "origen.dut.#{p.rtl_name}"] }
+      Origen::OrgFile.open(id) do |org_file|
+        @org_file = org_file
+        if update_capture?
+          @sim_capture.each { |pin, net| pin.record_to_org_file(only: :assert) }
+        end
+        yield
+      end
+      pins.each(&:restore)
+      @sim_capture = nil
+    end
+
+    alias_method :_origen_testers_cycle, :cycle
+    def cycle(options = {})
+      if @sim_capture
+        # Need to un-roll all repeats to be sure we observe the true data, can't
+        # really assume that it will be constant for all cycles covered by the repeat
+        cycles = options.delete(:repeat) || 1
+        cycles.times do
+          if update_capture?
+            _origen_testers_cycle(options)
+            @sim_capture.each do |pin, net|
+              pin.assert(simulator.peek(net))
+              # Remove the assertion since it is for the previous cycle in terms of the current simulation,
+              # this won't be captured to the org file
+              pin.dont_care
+            end
+            Origen::OrgFile.cycle
+          else
+            unless @org_file.exist?
+              fail "The simulation capture \"#{id}\" has not been made yet, re-run this pattern with a simulation target first!"
+            end
+            apply_captured_data
+            _origen_testers_cycle(options)
+          end
+        end
+      else
+        _origen_testers_cycle(options)
+      end
+    end
+
+    def apply_captured_data
+      if @apply_captured_data_cycles && @apply_captured_data_cycles > 1
+        @apply_captured_data_cycles -= 1
+      else
+        @org_file.read_line do |operations, cycles|
+          @apply_captured_data_cycles = cycles
+          operations.each do |object, operation, *args|
+            object.send(operation, *args)
+          end
+        end
+      end
+    end
+
+    def update_capture?
+      return @update_capture if defined? @update_capture
+      @update_capture = sim? && (!@org_file.exist? || Origen.app!.update_sim_captures)
+    end
   end
 end

data/lib/origen_sim/simulator.rb

@@ -22,14 +22,72 @@ module OrigenSim
       end
     end
 
+    def fetch_simulation_objects(options = {})
+      sid = options[:id] || id
+      ldir = "#{Origen.root}/simulation/#{sid}"
+      tmp_dir = "#{Origen.root}/tmp/origen_sim/tmp"
+      if config[:rc_dir_url]
+        unless config[:rc_version]
+          puts "You must supply an :rc_version option when using :rc_dir_url (you can set this to something like 'Trunk' or 'master' if you want)"
+          exit 1
+        end
+        if !File.exist?(compiled_dir) ||
+           (File.exist?(compiled_dir) && Dir.entries(compiled_dir).size <= 2) ||
+           (Origen.app.session.origen_sim[sid] != config[:rc_version]) ||
+           options[:force]
+          Origen.log.info "Fetching the simulation object for #{sid}..."
+          Origen.app.session.origen_sim[sid] = nil # Clear this up front, if the checkout fails we won't know what we have
+          FileUtils.rm_rf(tmp_dir) if File.exist?(tmp_dir)
+          FileUtils.mkdir_p(tmp_dir)
+          FileUtils.mkdir_p("#{Origen.root}/simulation")
+          rc = Origen::RevisionControl.new remote: config[:rc_dir_url], local: tmp_dir
+          rc.checkout "#{sid}.tar.gz", force: true, version: config[:rc_version]
+          FileUtils.mv "#{tmp_dir}/#{sid}.tar.gz", "#{Origen.root}/simulation"
+          FileUtils.rm_rf(ldir) if File.exist?(ldir)
+          Dir.chdir "#{Origen.root}/simulation/" do
+            system "tar -xvf #{sid}.tar.gz"
+          end
+          Origen.app.session.origen_sim[sid] = config[:rc_version]
+        end
+      else
+        if !File.exist?(compiled_dir) ||
+           (File.exist?(compiled_dir) && Dir.entries(compiled_dir).size <= 2)
+          puts "There is no previously compiled simulation object in: #{compiled_dir}"
+          exit 1
+        end
+      end
+    ensure
+      FileUtils.rm_f "#{ldir}.tar.gz" if File.exist?("#{ldir}.tar.gz")
+      FileUtils.rm_rf tmp_dir if File.exist?(tmp_dir)
+    end
+
+    def commit_simulation_objects(options = {})
+      sid = options[:id] || id
+      ldir = "#{Origen.root}/simulation/#{sid}"
+      tmp_dir = "#{Origen.root}/tmp/origen_sim/tmp"
+      unless File.exist?(ldir)
+        fail "The simulation directory to check in does not exist: #{ldir}"
+      end
+      Dir.chdir "#{Origen.root}/simulation/" do
+        system "tar -cvzf #{sid}.tar.gz #{sid}"
+      end
+
+      FileUtils.rm_rf(tmp_dir) if File.exist?(tmp_dir)
+      FileUtils.mkdir_p(tmp_dir)
+      FileUtils.cp "#{ldir}.tar.gz", tmp_dir
+
+      rc = Origen::RevisionControl.new remote: config[:rc_dir_url], local: tmp_dir
+      rc.checkin "#{sid}.tar.gz", unmanaged: true, force: true, comment: 'Checked in via sim:rc command'
+    ensure
+      FileUtils.rm_f "#{ldir}.tar.gz" if File.exist?("#{ldir}.tar.gz")
+      FileUtils.rm_rf tmp_dir if File.exist?(tmp_dir)
+    end
+
     def configure(options)
       fail 'A vendor must be supplied, e.g. OrigenSim::Tester.new(vendor: :icarus)' unless options[:vendor]
       unless VENDORS.include?(options[:vendor])
         fail "Unknown vendor #{options[:vendor]}, valid values are: #{VENDORS.map { |v| ':' + v.to_s }.join(', ')}"
       end
-      unless options[:rtl_top]
-        fail "The name of the file containing the DUT top-level must be supplied, e.g. OrigenSim::Tester.new(rtl_top: 'my_ip')" unless options[:rtl_top]
-      end
       @configuration = options
       @tmp_dir = nil
     end
@@ -49,14 +107,6 @@ module OrigenSim
       end
     end
 
-    def artifacts_dir
-      @artifacts_dir ||= begin
-        d = "#{Origen.root}/simulation/#{id}/artifacts"
-        FileUtils.mkdir_p(d)
-        d
-      end
-    end
-
     # Returns the directory where the compiled simulation object lives, this should
     # be checked into your Origen app's repository
     def compiled_dir
@@ -93,20 +143,20 @@ module OrigenSim
 
     def wave_config_file
       @wave_config_file ||= begin
-        f = "#{wave_config_dir}/#{User.current.id}.svcf"
+        f = "#{wave_config_dir}/#{User.current.id}.#{wave_config_ext}"
         unless File.exist?(f)
           # Take a default wave if one has been set up
-          d = "#{wave_config_dir}/default.svcf"
+          d = "#{wave_config_dir}/default.#{wave_config_ext}"
           if File.exist?(d)
             FileUtils.cp(d, f)
           else
             # Otherwise seed it with the latest existing setup by someone else
-            d = Dir.glob("#{wave_config_dir}/*.svcf").max { |a, b| File.ctime(a) <=> File.ctime(b) }
+            d = Dir.glob("#{wave_config_dir}/*.#{wave_config_ext}").max { |a, b| File.ctime(a) <=> File.ctime(b) }
             if d
               FileUtils.cp(d, f)
             else
               # We tried our best, start from scratch
-              d = "#{Origen.root!}/templates/empty.svcf"
+              d = "#{Origen.root!}/templates/empty.#{wave_config_ext}"
               FileUtils.cp(d, f)
             end
           end
@@ -115,15 +165,24 @@ module OrigenSim
       end
     end
 
+    def wave_config_ext
+      case config[:vendor]
+      when :icarus
+        'gtkw'
+      when :cadence
+        'svcf'
+      end
+    end
+
     def run_cmd
       case config[:vendor]
       when :icarus
         cmd = configuration[:vvp] || 'vvp'
-        cmd += " -M#{compiled_dir} -morigen #{compiled_dir}/dut.vvp +socket+#{socket_id}"
+        cmd += " -M#{compiled_dir} -morigen #{compiled_dir}/origen.vvp +socket+#{socket_id}"
 
       when :cadence
         input_file = "#{tmp_dir}/#{id}.tcl"
-        unless File.exist?(input_file)
+        if !File.exist?(input_file) || config_changed?
           Origen.app.runner.launch action:            :compile,
                                    files:             "#{Origen.root!}/templates/probe.tcl.erb",
                                    output:            tmp_dir,
@@ -133,7 +192,7 @@ module OrigenSim
                                    output_file_name:  "#{id}.tcl"
         end
         input_file_fast = "#{tmp_dir}/#{id}_fast.tcl"
-        if $use_fast_probe_depth
+        if !File.exist?(input_file_fast) || config_changed?
           fast_probe_depth = config[:fast_probe_depth] || 1
           Origen.app.runner.launch action:            :compile,
                                    files:             "#{Origen.root!}/templates/probe.tcl.erb",
@@ -143,8 +202,8 @@ module OrigenSim
                                    options:           { dir: wave_dir, force: config[:force], setup: config[:setup], depth: fast_probe_depth },
                                    output_file_name:  "#{id}_fast.tcl"
         end
-        wave_dir  # Ensure this exists since it won't be referenced above if the
-        # input file is already generated
+        save_config_signature
+        wave_dir  # Ensure this exists since it won't be referenced above if the input file is already generated
 
         cmd = configuration[:irun] || 'irun'
         cmd += " -r origen -snapshot origen +socket+#{socket_id}"
@@ -157,6 +216,15 @@ module OrigenSim
     def view_wave_command
       cmd = nil
       case config[:vendor]
+      when :icarus
+        edir = Pathname.new(wave_config_dir).relative_path_from(Pathname.pwd)
+        cmd = "cd #{edir} && "
+        cmd += configuration[:gtkwave] || 'gtkwave'
+        dir = Pathname.new(wave_dir).relative_path_from(edir.expand_path)
+        cmd += " #{dir}/origen.vcd "
+        f = Pathname.new(wave_config_file).relative_path_from(edir.expand_path)
+        cmd += " --save #{f} &"
+
       when :cadence
         edir = Pathname.new(wave_config_dir).relative_path_from(Pathname.pwd)
         cmd = "cd #{edir} && "
@@ -165,6 +233,7 @@ module OrigenSim
         cmd += " #{dir}/#{id}.dsn #{dir}/#{id}.trn"
         f = Pathname.new(wave_config_file).relative_path_from(edir.expand_path)
         cmd += " -input #{f} &"
+
       end
       cmd
     end
@@ -178,22 +247,12 @@ module OrigenSim
       end
     end
 
-    def link_artifacts
-      done = "#{run_dir}/.artifacts_linked"
-      unless File.exist?(done)
-        Dir.foreach(artifacts_dir) do |item|
-          next if item == '.' || item == '..'
-          FileUtils.ln_s("#{artifacts_dir}/#{item}", "#{run_dir}/#{item}") unless File.exist?("#{run_dir}/#{item}")
-        end
-        FileUtils.touch(done)
-      end
-    end
-
     # Starts up the simulator process
     def start
+      fetch_simulation_objects
+
       server = UNIXServer.new(socket_id)
       verbose = Origen.debugger_enabled?
-      link_artifacts
       cmd = run_cmd + ' & echo \$!'
 
       launch_simulator = %(
@@ -224,7 +283,7 @@ module OrigenSim
       simulator_parent_process = spawn("ruby -e \"#{launch_simulator}\"")
       Process.detach(simulator_parent_process)
 
-      timeout_connection(config[:startup_timeout] || 15) do
+      timeout_connection(config[:startup_timeout] || 60) do
         @socket = server.accept
         @connection_established = true
         if @connection_timed_out
@@ -350,10 +409,11 @@ module OrigenSim
     # set up internal handles to efficiently access them
     def define_pins
       dut.rtl_pins.each_with_index do |(name, pin), i|
-        unless pin.tie_off
-          pin.simulation_index = i
-          put("0^#{pin.id}^#{i}^#{pin.drive_wave.index}^#{pin.compare_wave.index}")
-        end
+        pin.simulation_index = i
+        put("0^#{pin.rtl_name}^#{i}^#{pin.drive_wave.index}^#{pin.compare_wave.index}")
+      end
+      dut.rtl_pins.each do |name, pin|
+        pin.apply_force
       end
     end
 
@@ -407,11 +467,13 @@ module OrigenSim
 
     # Returns the current simulation error count
     def error_count
-      peek('origen.debug.errors')
+      peek('origen.debug.errors').to_i
     end
 
     # Returns the current value of the given net, or nil if the given path does not
     # resolve to a valid node
+    #
+    # The value is returned as an instance of Origen::Value
     def peek(net)
       # The Verilog spec does not specify that underlying VPI put method should
       # handle a part select, so some simulators do not handle it. Therefore we
@@ -427,21 +489,20 @@ module OrigenSim
 
       sync_up
       put("9^#{clean(net)}")
-
       m = get.strip
+
       if m == 'FAIL'
         return nil
       else
-        m = m.to_i
         if msb
           # Setting a range of bits
           if lsb
-            m[msb..lsb]
+            Origen::Value.new('b' + m[(m.size - 1 - msb)..(m.size - 1 - lsb)])
           else
-            m[msb]
+            Origen::Value.new('b' + m[m.size - 1 - msb])
           end
         else
-          m
+          Origen::Value.new('b' + m)
         end
       end
     end
@@ -587,6 +648,25 @@ module OrigenSim
       @sync_active
     end
 
+    # Returns true if the config has been changed since the last time we called save_config_signature
+    def config_changed?
+      Origen.app.session.origen_sim["#{id}_config"] != config
+    end
+
+    # Locally saves a signature for the current config, this will cause config_changed? to return false
+    # until its contents change
+    def save_config_signature
+      Origen.app.session.origen_sim["#{id}_config"] = config
+    end
+
+    # Returns the version of Origen Sim that the current DUT object was compiled with
+    def dut_version
+      @dut_version ||= begin
+        put('i^')
+        Origen::VersionString.new(get.strip)
+      end
+    end
+
     private
 
     def clean(net)