origen_testers 0.14.0 → 0.15.0

data/lib/origen_testers/pattern_compilers/igxl_based.rb

@@ -0,0 +1,348 @@
+module OrigenTesters
+  module PatternCompilers
+    class IGXLBasedPatternCompiler < BasePatternCompiler
+      def initialize(id, options = {})
+        super
+
+        # The following are pattern compiler options that are common between all IGXL platforms, these
+        #   are added onto the base options.  Specifc IGXL platforms can add on additional options
+        #   in their respective initialize methods.
+        @user_options = {}.merge(@user_options)
+
+        @job_options = {
+          pinmap_workbook:  dut.pinmap,    # required: will default to $dut.pinmap
+        }.merge(@job_options)
+
+        # These are compiler options that are common to both the UltraFLEX and J750 compilers
+        # Set all of these compiler options that don't have args to true/flase.  if true then send compiler '-opt'
+        @compiler_options = {
+          comments:              false,     # preserves comments in pattern binary
+          cpp:                   false,     # runs C++ preprocessor on pattern file
+          debug:                 false,     # generate intermediate file(s) to simplify debug ( application dependent )
+          import_all_undefineds: false,     # automatically import all undefined symbols.  the key is mis-spelled but correct!
+          suppress_log:          false,     # disables output to main log file
+          template:              false,     # generate setup template
+          timestamp:             false,     # enable log timestamp
+        }.merge(@compiler_options)
+
+        # These are compiler options that are common to both the UltraFLEX and J750 compilers
+        @compiler_options_with_args = {
+          define:       nil,       # Define macro values to be passed to C-preprocessor
+          digital_inst: nil,       # Name of digital instrument
+          logfile:      nil,       # Messages go to <filename> instead of <infile> log
+          opcode_mode:  nil,       # Patgen opcode mode, specific to digital instrument
+          output:       nil,       # Name of output file
+          pinmap_sheet: nil,       # Name of workbook containing pinmap
+          # pinmap_workbook:     nil,       # Name of sheet in workbook which contains pinmap (moved to @job_options)
+          setup:        nil,       # path to setup file
+        }.merge(@compiler_options_with_args)
+      end
+
+      def verify_pinmap_is_specified
+        if @job_options[:pinmap_workbook].nil?
+          # Check if the app has dut.pinmap defined
+          if dut.pinmap && File.exist?(dut.pinmap)
+            @job_options[:pinmap_workbook] = dut.pinmap
+          else
+            fail 'Pinmap is not defined!  Pass as an option or set $dut.pinmap.'
+          end
+        end
+        @job_options[:pinmap_workbook] = convert_to_pathname(@job_options[:pinmap_workbook])
+        fail 'Pinmap is not a file!' unless @job_options[:pinmap_workbook].file?
+      end
+
+      # Return the compiler instance pinmap
+      def pinmap
+        @job_options[:pinmap_workbook]
+      end
+
+      # Executes the compiler for each job in the queue
+      def run(list = nil, options = {})
+        # Check if there was a pattern list passed as an argument
+        # If so, then compile the patterns inside it.
+        # Otherwise compile the jobs in the queue
+        if list.nil?
+          if empty?
+            empty_msg
+            return
+          end
+          @jobs.each do |job|
+            fail "Error: compiler #{job.id} not ready for pattern #{job.name}" unless job.ready?
+            if job.location == :lsf
+              Origen.app.lsf.submit(ATPC_SETUP + '; ' + job.cmd)
+            else
+              Origen.profile "Linux pattern compiler compiles pattern #{job.pattern}" do
+                system job.cmd
+              end
+            end
+          end
+          if @job_options[:location] == :local
+            if @job_options[:clean] == true
+              puts 'Log file :clean option set to true, deleting log files'
+              clean_output
+            end
+          end
+          # Clear @jobs
+          clear
+        else
+          list = convert_to_pathname(list)
+          fail "Error: pattern list #{list} does not exist, exiting..." unless list.file?
+          File.open(list, 'r') do |file|
+            while (line = file.gets)
+              current_job_options = @job_options.merge(@compiler_options_with_args)
+              current_job_options.update_common(options)
+              # puts "current job options is #{current_job_options}"
+              compiler_opts = {}
+              line.strip!
+              pattern = line.match(/^(\S+)\s+(.*)/).captures[0]
+              unless File.file? pattern
+                puts "Warning: Pattern #{pattern} does not exist, skipping..."
+                next
+              end
+              pattern = convert_to_pathname(pattern)
+              line.match(/^\S+\s+(.*)/).captures[0].split(/\s+/).each do |e|
+                opt, arg = e.split(':')
+                opt.gsub!('-', '')
+                if arg.nil?
+                  compiler_opts[opt.to_sym] = true
+                else
+                  # Check for some specific options
+                  case opt
+                    when 'pinmap_workbook'
+                      current_job_options[opt.to_sym] = Pathname.new(arg)
+                    when 'output'
+                      dot_pat = Pathname.new(arg)
+                      current_job_options[:output_directory] = dot_pat.dirname
+                    else
+                      current_job_options[opt.to_sym] = arg
+                  end
+                end
+              end
+              @jobs << Job.new(pattern, current_job_options, compiler_opts)
+              inspect_jobs
+            end
+          end
+          run
+          # Clear @jobs
+          clear
+        end
+      end
+
+      # Finds the patterns and creates a compiler job for each one found.
+      # Handles singles files (.atp, .atp.gz, or .list) and directories (recursively or flat)
+      def find_jobs(path = @path)
+        fail 'Pattern path is set to nil, pass in a valid file (.atp or .atp.gz) or a valid directory' if path.nil?
+        @path = Pathname.new(path)
+        fail 'Pattern path does not exist, pass in a valid file (.atp or .atp.gz) or a valid directory' unless @path.exist?
+        @path = @path.expand_path
+        # Set the reference directory for pattern sub-dir mirroring
+        set_reference_directory
+        Origen.profile 'Linux pattern compiler finds patterns' do
+          # Check if the path is a file or a directory
+          if @path.directory?
+            # Get all of the patterns inside this dir or inside this directory recursively
+            process_directory(@path, @files, @user_options[:recursive])
+          elsif @path.file? # Found a file so no searching is necessary
+            process_file(@path, @files)
+          else # Didn't find a directory or a file so user must want a search for this arg string * NOT SUPPORTED YET
+            fail 'Error: Did not find a file or directory to compile, exiting...'
+          end
+        end
+
+        Origen.profile 'Linux pattern compiler creates jobs' do
+          @files.each do |f|
+            rel_dir = Pathname.new("#{f.dirname.to_s[@user_options[:reference_directory].to_s.size..-1]}")
+            if @job_options[:output_directory].nil?
+              # job output dir not specified, create a unique (hash) based on path/compiler_name
+              s = Digest::MD5.new
+              s << @user_options[:reference_directory].to_s
+              s << @id.to_s
+              out = "#{@user_options[:reference_directory]}/job_#{@id}_#{s.to_s[0..6].upcase}#{rel_dir}"
+              output_dir = Pathname.new(out)
+            else
+              output_dir = Pathname.new("#{@job_options[:output_directory]}#{rel_dir}")
+            end
+            unless output_dir.directory?
+              puts "Output directory #{output_dir} for pattern #{f.basename} does not exist, creating it..."
+              FileUtils.mkdir_p(output_dir)
+            end
+            current_job_options = @job_options.merge(@compiler_options_with_args)
+            current_job_options[:output_directory] = output_dir
+            @jobs << Job.new(f, current_job_options, @compiler_options)
+            current_job_options = {}
+          end
+        end
+        @files = []
+        if empty?
+          empty_msg
+        else
+          inspect_jobs
+        end
+      end
+
+      # Output all of the jobs into a pattern list so it can be compiled later
+      # Must be executed after the 'find_jobs' method and before the 'run' method
+      # or @jobs will be empty
+      def to_list(options = {})
+        options = {
+          name:             @id,
+          output_directory: Dir.pwd,
+          expand:           true,
+          force:            false
+        }.update_common(options)
+        list = "#{options[:output_directory]}/#{options[:name]}.list"
+        list = convert_to_pathname(list)
+        if empty?
+          empty_msg
+          return
+        end
+        if list.file?
+          if options[:force] == true
+            puts "Pattern list file #{list} already exists, deleting it..."
+            list.delete
+          else
+            fail "Pattern list file #{list} already exists, exiting..."
+          end
+        end
+        File.open(list, 'w') do |patlist|
+          @jobs.each do |job|
+            if options[:expand] == true
+              pinmap = job.pinmap_workbook
+              dot_pat_name = "#{job.output_directory}/#{job.pattern.basename.to_s.split('.').first}.PAT"
+              dot_atp_name = job.pattern
+            else
+              pinmap = job.pinmap_workbook.basename
+              dot_pat_name = "#{job.pattern.basename.to_s.split('.').first}.PAT"
+              dot_atp_name = job.pattern.basename
+            end
+            patlist.print("#{dot_atp_name} -pinmap_workbook:#{pinmap} -output:#{dot_pat_name}")
+            job.compiler_options.each_key { |k| patlist.print(" -#{k}") }
+            job.compiler_options_with_args.each_pair { |k, v| patlist.print(" -#{k}:#{v}") }
+            patlist.puts('')
+          end
+        end
+      end
+
+      # alias_method :find, :find_jobs
+      #
+      # Output the compiler jobs in the queue to the console
+      def inspect_jobs(index = nil)
+        return empty_msg if empty?
+        desc = []
+        puts "\n"
+        @jobs.each_with_index do |j, i|
+          unless index.nil?
+            next unless i == index
+          end
+          desc << '| Job: ' + "#{i + 1} ".rjust(8) + '|' + 'Pattern:'.rjust(18) + " #{j.pattern.basename}".ljust(120) + '|'
+          desc << '|              |' + 'Compiler ID:'.rjust(18) + " #{j.id} ".ljust(120) + '|'
+          desc << '|              |' + 'Pinmap:'.rjust(18) + " #{j.pinmap_workbook} ".ljust(120) + '|'
+          desc << '|              |' + '.atp directory:'.rjust(18) + " #{j.pattern.dirname} ".ljust(120) + '|'
+          desc << '|              |' + '.pat directory:'.rjust(18) + " #{j.output_directory} ".ljust(120) + '|'
+          desc << '|              |' + 'LSF:'.rjust(18) + " #{j.location == :lsf ? true : false} ".ljust(120) + '|'
+          desc << '|              |' + 'Delete log files:'.rjust(18) + " #{j.clean} ".ljust(120) + '|'
+          desc << '|              |' + 'Verbose:'.rjust(18) + " #{j.verbose} ".ljust(120) + '|'
+          fragment = '|              |' + 'Compiler args:'.rjust(18)
+          overflow_fragment = '|              |' + ' '.rjust(18)
+          compiler_args = []
+          compiler_fragment = ''
+          j.compiler_options.each_key do |k|
+            if compiler_fragment.size + " -#{k}".size >= 120
+              compiler_args << compiler_fragment
+              compiler_fragment = nil
+            end
+            compiler_fragment += " -#{k}"
+          end
+          compiler_args << compiler_fragment unless compiler_fragment.nil?
+          compiler_fragment = ''
+          j.compiler_options_with_args.each_pair do |k, v|
+            if compiler_fragment.size + " -#{k}:#{v}".size >= 120
+              compiler_args << compiler_fragment
+              compiler_fragment = nil
+            end
+            compiler_fragment += " -#{k}:#{v}"
+          end
+          compiler_args << compiler_fragment unless compiler_fragment.nil?
+          if compiler_args.join.length <= 120
+            desc << fragment + "#{compiler_args.join}".ljust(120) + '|'
+          else
+            # Need to cycle through compiler args and build a fragment <= 100 characters
+            # and print it.  Keep going until the remaining args is <= 100 and print again
+            char_cnt = 0
+            line_cnt = 0
+            args = []
+            compiler_args = compiler_args.join.strip.split(/\s+/)
+            until compiler_args.empty?
+              args = compiler_args.select { |e| (char_cnt += e.length + 1) < 120 }
+              # remove the args that fit on the first line
+              compiler_args -= args
+              if line_cnt == 0
+                desc << fragment + " #{args.join(' ')}".ljust(120) + '|'
+              else
+                desc << overflow_fragment + " #{args.join(' ')}".ljust(120) + '|'
+              end
+              args = []
+              line_cnt += 1
+              char_cnt = 0
+            end
+          end
+          desc << '-' * desc.first.size
+        end
+        puts desc.flatten.join("\n")
+      end
+      # For future checks on incorrect or incompatible arguments to compiler options
+      def options_ok?
+      end
+
+      def ready?
+        ready = true
+        paths_contain_data = true
+        ready &= paths_contain_data
+        ready &= !@job_options[:output_directory].nil?
+        ready &= !@user_options[:reference_directory].nil?
+        ready &= !@path.nil?
+        ready &= !@job_options[:pinmap_workbook].nil?
+        ready &= @job_options[:output_directory].directory?
+        ready &= @user_options[:reference_directory].directory?
+        ready &= @path.exist?
+        ready &= @job_options[:pinmap_workbook].file?
+        ready &= [true, false].include?(@job_options[:clean])
+        ready &= [:local, :lsf].include?(@job_options[:location])
+        ready &= File.exist?(@job_options[:compiler])
+        ready
+      end
+
+      def bad_options
+        bad = []
+        options = {
+          output_directory:    @job_options[:output_directory],
+          reference_directory: @user_options[:reference_directory],
+          path:                @path,
+          pinmap_workbook:     @job_options[:pinmap_workbook],
+          clean:               @job_options[:clean],
+          location:            @job_options[:location],
+          compiler:            @job_options[:compiler]
+        }
+        options.each do |k, v|
+          bad << k if v.nil?
+          if v.is_a? String # compiler
+            v = Pathname.new(v)
+            bad << k unless v.file?
+          elsif v.is_a? Symbol # clean
+            bad << k unless [:local, :lsf].include? v
+          elsif v.is_a? Pathname
+            if k.match(/directory/)
+              bad << k unless v.directory?
+            elsif k == :path
+              bad << k unless v.exist?
+            else # pinmap
+              bad << k unless v.file?
+            end
+          end
+        end
+        bad
+      end
+      alias_method :bad_opts, :bad_options
+    end
+  end
+end

data/lib/origen_testers/pattern_compilers/j750.rb

@@ -0,0 +1,80 @@
+module OrigenTesters
+  module PatternCompilers
+    class J750PatternCompiler < IGXLBasedPatternCompiler
+      # Linux compiler executable path
+      def self.linux_compiler
+        Origen.site_config.origen_testers[:j750_linux_pattern_compiler]
+      end
+
+      # Windows compiler executable path
+      def self.windows_compiler
+        Origen.site_config.origen_testers[:j750_windows_pattern_compiler]
+      end
+
+      # Pre-compile environment setup if necessary
+      def self.atpc_setup
+        Origen.site_config.origen_testers[:j750_atpc_setup]
+      end
+
+      # Resolves to correct compiler based on operating system
+      def self.compiler
+        Origen.running_on_windows? ? windows_compiler : linux_compiler
+      end
+
+      def self.compiler_cmd
+        Pathname.new(compiler).absolute? ? compiler : eval('"' + compiler + '"')
+      end
+
+      def self.compiler_options
+        "#{compiler_cmd} -help"
+      end
+
+      def self.compiler_version
+        "#{compiler_cmd} -version"
+      end
+
+      def initialize(id, options = {})
+        super
+
+        @user_options = {}.merge(@user_options)
+
+        @job_options = {
+          tester:   :j750,
+          compiler: self.class.compiler,   # required
+        }.merge(@job_options)
+
+        # These are compiler options that are specific to J750 compiler (builds on options from IGXL-Based)
+        # Set all of these compiler options that don't have args to true/flase.  if true then send compiler '-opt'
+        @compiler_options = {
+          compress:      false,     # Compress the compiled output file.
+          extended:      false,     # Compiles the pattern for extended mode.
+          scan_parallel: false,     # Expands scan vectors into parallel SVM/LVM vectors.
+          svm_only:      false,     # Compile all vectors in the file for SVM.
+          svm_subr_only: false,     # Only SVM subroutines in file being used.
+        }.merge(@compiler_options)
+
+        # These are compiler options that are specific to J750 compiler (builds on options from IGXL-Based)
+        @compiler_options_with_args = {
+          i:          nil,          # Includes paths to be passed to C++ preprocessor.
+          lvm_size:   nil,          # Number of LVM vectors to allow in a single pattern.
+          max_errors: nil,          # Number of errors that will cause compilation of the pattern file to be aborted.
+          min_period: nil,          # Minimum period, in seconds, that will be used during a pattern burst.
+        }.merge(@compiler_options_with_args)
+
+        update_common_options(options)      # Update common options with default (see BasePatternCompiler)
+        verify_pinmap_is_specified          # verify pinmap specified correctly - IGXL specific
+        clean_and_verify_options            # Standard cleaning and verifying (see BasePatternCompiler)
+      end
+
+      # Executes the compiler for each job in the queue
+      def run(list = nil, options = {})
+        fail "Error: the tester #{Origen.tester} is not an J750 tester,exiting..." unless is_j750?
+        msg = "Error: application #{Origen.app.name} is running on Windows, "
+        msg += 'to run the pattern compiler you must be on a Linux machine'
+        fail msg if Origen.running_on_windows?
+
+        super
+      end
+    end
+  end
+end

data/lib/origen_testers/pattern_compilers/job.rb

@@ -19,9 +19,27 @@ module OrigenTesters
       # Output directory for the .PAT file
       attr_accessor :output_directory
 
-      # Pinmap file
+      # Pinmap file (IGXL-Based)
       attr_accessor :pinmap_workbook
 
+      # Pinmap file (Smartest-Based)
+      attr_accessor :pinconfig
+
+      # Pinmap file (Smartest-Based)
+      attr_accessor :avc_dir
+
+      # Pinmap file (Smartest-Based)
+      attr_accessor :binl_dir
+
+      # Pattern count - should be 1 for IGXL; number of AVC files listed in AIV file for Smartest
+      attr_accessor :count
+
+      # tmf file (Smartest-Based)
+      attr_accessor :tmf
+
+      # aiv2b options (Smartest-Based)
+      attr_accessor :aiv2b_opts
+
       # Compiler options where only the opt has to be passed as '-opt'
       attr_accessor :compiler_options
 
@@ -33,6 +51,7 @@ module OrigenTesters
 
       def initialize(pattern, options_with_args, options)
         @pattern = pattern
+        @tester = options_with_args.delete(:tester)
         @compiler = options_with_args.delete(:compiler)
         @id = options_with_args.delete(:id)
         @location = options_with_args.delete(:location)
@@ -40,6 +59,12 @@ module OrigenTesters
         @verbose = options_with_args.delete(:verbose)
         @output_directory = options_with_args.delete(:output_directory)
         @pinmap_workbook = options_with_args.delete(:pinmap_workbook)
+        @pinconfig = options_with_args.delete(:pinconfig)
+        @avc_dir = options_with_args.delete(:avc_dir)
+        @binl_dir = options_with_args.delete(:binl_dir)
+        @count = options_with_args.delete(:count) || 1
+        @tmf = options_with_args.delete(:tmf)
+        @aiv2b_opts = options_with_args.delete(:aiv2b_opts)
         @compiler_options_with_args = options_with_args.delete_if { |k, v| v.nil? }  # Whatever's left has to be valid compiler options
         @compiler_options = options.delete_if { |k, v| v == false }
       end
@@ -50,10 +75,17 @@ module OrigenTesters
 
       def cmd
         cmd = ''
-        cmd = "#{@compiler} -pinmap_workbook:#{@pinmap_workbook} -output:#{@output_directory}/#{@pattern.basename.to_s.split('.').first}.PAT #{@pattern} "
-        # add in any remaining compiler options
-        compiler_options.each_key { |k| cmd += "-#{k} " }
-        compiler_options_with_args.each_pair { |k, v| cmd += "-#{k}:#{v} " }
+        case @tester
+          when :v93k
+            cmd = "#{resolve_compiler_location} #{@pattern} "
+          when :ultraflex, :j750
+            cmd = "#{resolve_compiler_location} -pinmap_workbook:#{@pinmap_workbook} -output:#{@output_directory}/#{@pattern.basename.to_s.split('.').first}.PAT #{@pattern} "
+            # add in any remaining compiler options
+            compiler_options.each_key { |k| cmd += "-#{k} " }
+            compiler_options_with_args.each_pair { |k, v| cmd += "-#{k}:#{v} " }
+          else
+            fail 'Unsupported tester'
+        end
         if @verbose
           cmd += ';'
         else
@@ -66,12 +98,20 @@ module OrigenTesters
         cmd
       end
 
+      def resolve_compiler_location
+        Pathname.new(@compiler).absolute? ? @compiler : eval('"' + @compiler + '"')
+      end
+
       def ready?
         ready = true
-        ready && @output_directory.directory? &&
-          @pattern.file? && @pinmap_workbook.file? &&
-          [true, false].include?(@clean) &&
-          [:local, :lsf].include?(@location)
+        ready &= @output_directory.directory?
+        ready &= @pattern.file?
+        ready &= @pinmap_workbook.file? if @tester == :ultraflex || @tester == :j750
+        ready &= @pinconfig.file? if @tester == :v93k
+        ready &= @tmf.file? if @tester == :v93k
+        ready &= [true, false].include?(@clean)
+        ready &= [:local, :lsf].include?(@location)
+        ready
       end
 
       private