origen_testers 0.4.0

data/lib/origen_testers/pattern_compilers/assembler.rb

@@ -0,0 +1,88 @@
+module OrigenTesters
+  module PatternCompilers
+    class UltraFlexPatternCompiler
+      private
+
+      # Check the file extension of a file, return status can be 'atp', 'list', or nil
+      def check_file_ext(file)
+        status = nil
+        ext = file.extname
+        name = file.basename
+        if ext == '.atp'
+          status = 'atp'
+        elsif ext == '.gz'
+          # Ensure we have a .atp.gz
+          sub_ext = name.to_s.split('.')[-2]
+          if sub_ext == 'atp'
+            status = 'atp'
+          end
+        elsif ext == '.list'
+          status = 'list'
+        end
+        status
+      end
+
+      # Parse a pattern list file recursively until all .atp or .atp.gz files are found
+      def parse_list(path, files)
+        list_name = path.basename
+        dir = path.dirname
+        line_number = 0
+        path.open('r') do |f|
+          while (line = f.gets)
+            line_number += 1
+            # Strip the leading and trailing whitespace for sloppy typers
+            line.strip!
+            # Skip a blank line
+            next if line.match(/^\s+$/)
+            # Check if the pattern or list exists
+            line_path = Pathname.new("#{dir}/#{line}")
+            unless line_path.file?
+              # puts "Skipping #{line_path.to_s} at line ##{line_number} in file #{path.to_s} because it is not a file"
+              next
+            end
+            # Process the file
+            process_file(line_path, files)
+          end
+        end
+      end
+
+      # Processes a file looking for a valid .atp or .list
+      def process_file(file, files)
+        # puts "processing file #{file.to_s}"
+        case check_file_ext(file)
+          when 'atp'
+            files << file unless files.include?(file)
+          when 'list'
+            parse_list(file, files)
+          end
+      end
+
+      # Processes a diretcory looking for files in '.' or recursively
+      def process_directory(dir, files, rec)
+        dir.children(true).each do |f|
+          # ignore sub-directories
+          if f.directory?
+            if rec == false
+              next
+            else
+              process_directory(f.expand_path, files, rec)
+            end
+          end
+          process_file(f.expand_path, files)
+        end
+      end
+
+      # Deletes the pattern compiler log files
+      def clean_output
+        @jobs.each do |job|
+          logfile = Pathname.new("#{job.pattern.dirname}/#{job.pattern.basename.to_s.chomp(job.pattern.extname)}.log")
+          logfile.cleanpath
+          if logfile.file?
+            # puts "Deleting log file #{logfile}"
+            logfile.delete
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/pattern_compilers/job.rb

@@ -0,0 +1,96 @@
+module OrigenTesters
+  module PatternCompilers
+    class Job
+      # Pattern to be compiled, is Pathname class.  Will use full path
+      attr_accessor :pattern
+
+      # Type of pattern as designated by the LinuxPatternCompiler
+      attr_accessor :id
+
+      # Where the job is to be executed, either locally ('local') or on Linux Server Farm ('lsf')
+      attr_accessor :location
+
+      # Controls whether the compiler log files are kept: true/false
+      attr_accessor :clean
+
+      # Controls whether the compiler STDOUT is displayed
+      attr_accessor :verbose
+
+      # Output directory for the .PAT file
+      attr_accessor :output_directory
+
+      # Pinmap file
+      attr_accessor :pinmap_workbook
+
+      # Compiler options where only the opt has to be passed as '-opt'
+      attr_accessor :compiler_options
+
+      # Compiler options where an opt and an arg have to be passed '-opt:arg'
+      attr_accessor :compiler_options_with_args
+
+      # linux compiler full path
+      attr_reader :compiler
+
+      def initialize(pattern, options_with_args, options)
+        @pattern = pattern
+        @compiler = options_with_args.delete(:compiler)
+        @id = options_with_args.delete(:id)
+        @location = options_with_args.delete(:location)
+        @clean = options_with_args.delete(:clean)
+        @verbose = options_with_args.delete(:verbose)
+        @output_directory = options_with_args.delete(:output_directory)
+        @pinmap_workbook = options_with_args.delete(:pinmap_workbook)
+        @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
+
+      def name
+        @pattern.basename
+      end
+
+      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} " }
+        if @verbose
+          cmd += ';'
+        else
+          cmd += '2>&1 > /dev/null;'
+        end
+        # If the job is to be run on the LSF add in the clean .log and mv the files if necessary
+        if @location == 'lsf'
+          cmd += clean_lsf if @clean == true
+        end
+        cmd
+      end
+
+      def ready?
+        ready = true
+        ready && @output_directory.directory? &&
+          @pattern.file? && @pinmap_workbook.file? &&
+          [true, false].include?(@clean) &&
+          [:local, :lsf].include?(@location)
+      end
+
+      private
+
+      def orig_dir
+        @pattern.dirname
+      end
+
+      # Generates the LSF commands to delete the pattern compiler log files
+      def clean_lsf
+        cmd = ''
+        logfile = Pathname.new("#{@pattern.dirname}/#{@pattern.basename.to_s.split('.').first}.log")
+        logfile.cleanpath
+        logfile.cleanpath
+        if @clean == true
+          cmd += "rm #{logfile}; "
+        end
+        cmd
+      end
+    end
+  end
+end

data/lib/origen_testers/pattern_compilers/ultraflex_pattern_compiler.rb

@@ -0,0 +1,599 @@
+module OrigenTesters
+  module PatternCompilers
+    class UltraFlexPatternCompiler
+      require 'pathname'
+      require_relative 'assembler'
+      require_relative 'job'
+
+      # Linux compiler executable path
+      LINUX_PATTERN_COMPILER = "#{Origen.root!}/bin/latest/bin/atpcompiler"
+      # LINUX_PATTERN_COMPILER = "#{Origen.root!}/bin/latest/bin/atpcompiler"
+
+      # Windows compiler executable path
+      WINDOWS_PATTERN_COMPILER = "#{ENV['IGXLROOT']}/bin/apc.exe"
+
+      # Linux compiler preamble
+      ATPC_SETUP = "#{Origen.root!}/bin/latest/etc/atpcrc.csh"
+
+      # ID will allow users to set default configurations for the compiler for unique pattern types
+      attr_accessor :id
+
+      # Compiler commands array
+      attr_accessor :jobs
+
+      def initialize(id, options = {})
+        @id = id
+        @id = @id.to_sym
+
+        @user_options = {
+          path:                nil,                # required: will be passed in or parsed from a .list file
+          reference_directory: nil, # optional: will be set to @path or Origen.app.config.pattern_output_directory
+          target:              nil,              # optional: allows user to temporarily set target and run compilation
+          recursive:           false          # optional: controls whether to look for patterns in a directory recursively
+        }
+        @job_options = {
+          compiler:         running_on_windows? ? WINDOWS_PATTERN_COMPILER : LINUX_PATTERN_COMPILER,   # required
+          id:               @id,                      # required
+          pinmap_workbook:  $dut.pinmap, # required: will default to $dut.pinmap
+          location:         :local,             # optional: controls whether the commands go to the LSF or run locally
+          clean:            false,                 # optional: controls whether compiler log files are deleted after compilation
+          output_directory: nil,        # optional:
+          verbose:          false                # optional: controls whether the compiler output gets put to STDOUT
+        }
+        @compiler_options = { # Set all of these compiler options that don't have args to true/flase.  if true then send compiler '-opt'
+          import_all_undefineds: false, # automatically import all undefined symbols.  the key is mis-spelled but correct!
+          cpp:                   false,                   # runs C++ preprocessor on pattern file
+          comments:              false,              # saves comments in binary file for tools visibility.  pass '-comments' if set to true
+          # pass nothing if set to false
+          nocompress:            false,            # do not compress pattern data blocks
+          suppress_log:          false,          # disables output to main log file
+          multiinst:             false,             # indicates more than one instrument is connected to a single pin
+          lock:                  false,                  # prevents pattern from being reverse compiled or opened in PatternTool
+          stdin:                 false,                 # Compile data from standard input. Do not use -cpp or specify any pattern file(s) when using this option.
+          debug:                 false,                 # generate intermediate file(s) to simplify debug ( application dependent )
+          template:              false,              # generate setup template
+          timestamp:             false,             # enable log timestamp
+        }
+        @compiler_options_with_args = {
+          output:              nil,                # Output filename, compiler defaults to <pattern name>.PAT
+          pinmap_sheet:        nil,          # <sheetname>
+          digital_inst:        nil,          # 'HSD4G', 'HSDM', or 'HSDMQ'
+          opcode_mode:         nil,           # HSDM mode: 'single' | 'dual'. HSDMQ mode: 'single' | 'dual' | 'quad'
+          pat_version:         nil,           # version of pattern file to compile
+          scan_type:           nil,             # type of scan data
+          max_errors:          nil,            # <n>, defaults to 200 on compiler side, valu eof 0 will never abort compilation
+          logfile:             nil,               # <filename>, directs any compiler messages to <filename>.  will default to output directory if nil
+          define:              nil,                # defines values of macros passed to C++ preprocessor.
+          # can only be defined once per pattern with space delimited list
+          includes:            nil,              # include paths to be passed to C- preprocessor.
+          post_processor:      nil,        # <pathname> customer's post-process executable.
+          # need to pass 'post-processor' to compiler
+          post_processor_args: nil,   # <args> customer's post-process executable arguments
+          # need to pass 'post-processor_args' to compiler
+          cdl_cache:           nil,             # 'yes' | 'no', turns on/off CDL caching, default on compiler side is 'yes'
+          init_pattern:        nil,          # <pattern>, uses the specified pattern module/file/set as an init patterns
+          check_set_msb:       nil,         # 'yes' | 'no', turns on/off check the 'set' or 'set_infinite' opcode
+          # is preceded by a 'set_msb' or 'set_msb_infinite' opcode. compiler default is 'yes'
+          time_domain:         nil,           # <time domain>, specifies time domain for pins in patterns
+          allow_mto_dash:      nil,        # Turn on/off support for channel data runtime repeat,i.e. vector dash in MTO patterns. Default value is "no".
+          check_vm_min_size:   nil,     # Turns on/off the check on minimum size of a VM pattern. Default value is "yes".
+          check_vm_mod_size:   nil,     # Turns on/off the check on a VM pattern module size. Default value is "yes".
+          check_oob_size:      nil,        # Turns on/off the check on size of OOB regions. Yes means size must be modulo 10. Default value is "no".
+          allow_mixed_1x2x:    nil,      # Turns on/off the support of mixed 1x/2x pin groups. Default value is "no".
+          allow_differential:  nil,    # Turns on/off support for differential pins. Default value is "yes".
+          allow_scan_in_srm:   nil,     # Allow/disallow scan vectors in SRM pattern modules. Default value is "no".
+          vm_block_size:       nil,         # Specifies uncompressed size in bytes of a pattern data block
+          setup:               nil,                 # path to setup file
+        }
+
+        @user_options.update_common(options)
+        @job_options.update_common(options)
+        @compiler_options.update_common(options)
+        @compiler_options_with_args.update_common(options)
+
+        # Check to make sure @compiler_options and @compiler_options_with_args do not have any keys in common
+        fail "Error: @compiler_options and @compiler_options_with_args share keys #{@compiler_options.intersections(@compiler_options_with_args)}.  They should be mutually exclusive, exiting..." if @compiler_options.intersect? @compiler_options_with_args
+
+        # Convert any path related options to Pathname object and expand the path
+        unless @user_options[:path].nil?
+          if @user_options[:path].is_a? Pathname
+            @path = @user_options[:path]
+          else
+            @path = Pathname.new(@user_options[:path])
+          end
+          @path = @path.expand_path
+          # path is set but output_directory is not so set output_directory to path
+          @job_options[:output_directory] = @path if @job_options[:output_directory].nil?
+        end
+
+        set_reference_directory
+
+        if @job_options[:output_directory].nil?
+          fail 'Output directory is not set!'
+        else
+          @job_options[:output_directory] = convert_to_pathname(@job_options[:output_directory])
+          # output_directory can not exist, will create for user
+          unless @job_options[:output_directory].directory?
+            puts "Output directory #{@job_options[:output_directory]} does not exist, creating it..."
+            FileUtils.mkdir_p(@job_options[:output_directory])
+          end
+        end
+
+        # Pinmap is required
+        if @job_options[:pinmap_workbook].nil?
+          # Check if the app has $dut.pinmap defined
+          if 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?
+
+        # Logfile is optional
+        unless @compiler_options[:logfile].nil?
+          @compiler_options[:logfile] = convert_to_pathname(@compiler_options[:logfile])
+          fail 'Pinmap is not a file' unless @job_options[:pinmap_workbook].file?
+        end
+
+        # Check if the LSF is setup in the application
+        if Origen.app.config.lsf.project.nil? || Origen.app.config.lsf.project.empty?
+          puts 'LSF is not set at Origen.app.config.lsf.project, changing to local compilation'
+          @job_options[:location] = :local
+        end
+
+        # Compiler jobs
+        @jobs = []
+
+        # .atp/.atp.gz files found
+        @files = []
+      end
+
+      # Return the id/name of the compiler instance
+      def name
+        @id
+      end
+
+      # Return the compiler instance pinmap
+      def pinmap
+        @job_options[:pinmap_workbook]
+      end
+
+      # Allow users to search for a pattern in the job queue or default
+      # to return all jobs
+      def jobs(search = nil)
+        found = false
+        if search.nil?
+          inspect_jobs
+          found = true
+        elsif search.is_a? String
+          @jobs.each_with_index do |job, index|
+            if job.pattern.to_s.match(search)
+              inspect_jobs(index)
+              found = true
+            else
+              puts "No match found for #{search}"
+            end
+          end
+        elsif search.is_a? Regexp
+          @jobs.each_with_index do |job, index|
+            if search.match(job.pattern.to_s)
+              inspect_jobs(index)
+              found = true
+            else
+              puts "No match found for #{search}"
+            end
+          end
+        elsif search.is_a? Integer
+          if @jobs[search].nil?
+            puts "The compiler queue does not contain a job at index #{search}"
+          else
+            inspect_jobs(search)
+            found = true
+          end
+        else
+          fail 'Search argument must be of type String, Regexp, or Integer'
+        end
+        found
+      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
+            # Check if the recursive arg was passed
+            if @user_options[:recursive] == true
+              process_directory(@path, @files, true)
+            else # Just grab the files found inside this directory
+              process_directory(@path, @files, false)
+            end
+          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]}")
+            output_dir = Pathname.new("#{@job_options[:output_directory]}#{rel_dir}")
+            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
+      alias_method :find, :find_jobs
+
+      # Executes the compiler for each job in the queue
+      def run(list = nil, options = {})
+        fail "Error: the tester #{Origen.tester} is not an Ultrflex tester,exiting..." unless is_ultraflex?
+        fail "Error: application #{Origen.app.name} is running on Windows, to run the pattern compiler you must be on a Linux machine" if running_on_windows?
+
+        # 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
+
+      # Clear the job queue
+      def clear
+        @jobs = []
+        @files = []
+      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
+
+      # For future checks on incorrect or incompatible arguments to compiler options
+      def options_ok?
+      end
+
+      def ready?
+        ready = true
+        paths_contain_data = true
+        # check for nil
+        ready = paths_contain_data && !@job_options[:output_directory].nil? &&
+                !@user_options[:reference_directory].nil? &&
+                !@path.nil? &&
+                !@job_options[:pinmap_workbook].nil?
+        ready && @job_options[:output_directory].directory? &&
+          @user_options[:reference_directory].directory? &&
+          @path.exist? &&
+          @job_options[:pinmap_workbook].file? &&
+          [true, false].include?(@job_options[:clean]) &&
+          [:local, :lsf].include?(@job_options[:location]) &&
+          File.exist?(@job_options[:compiler])
+      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
+
+      # Output the compiler options to the console
+      def inspect_options(verbose = nil)
+        desc = []
+        # Find the longest option argument string
+        my_job_options = @job_options
+        my_job_options.delete(:compiler)
+        all_arguments = @user_options.values + my_job_options.values + @compiler_options.values + @compiler_options_with_args.values
+        min_argument_padding = 'Argument'.length + 2
+        argument_padding = all_arguments.max_by { |e| e.to_s.length }.to_s.length + 3
+        argument_padding = min_argument_padding if argument_padding < min_argument_padding
+        puts "\n"
+        header = '| Option              ' + '| Argument'.ljust(argument_padding) + '| Required |'
+        desc << header
+        desc << '-' * header.length
+        [@user_options, my_job_options, @compiler_options, @compiler_options_with_args].each do |opt|
+          opt.each_pair do |k, v|
+            if k.match(/pinmap_workbook|path|id|directory|clean|location|recursive/i)
+              req = 'true '
+            else
+              next if v.nil? || v == false
+              req = 'false'
+            end
+            desc << "| #{k}".ljust(22) + "| #{v}".ljust(argument_padding) + "| #{req}    |"
+          end
+        end
+        puts desc
+      end
+
+      # 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(100) + '|'
+          desc << '|              |' + 'Compiler ID:'.rjust(18) + " #{j.id}".ljust(100) + '|'
+          desc << '|              |' + 'Pinmap:'.rjust(18) + " #{j.pinmap_workbook}".ljust(100) + '|'
+          desc << '|              |' + '.atp directory:'.rjust(18) + " #{j.pattern.dirname}".ljust(100) + '|'
+          desc << '|              |' + '.pat directory:'.rjust(18) + " #{j.output_directory}".ljust(100) + '|'
+          desc << '|              |' + 'LSF:'.rjust(18) + " #{j.location == :lsf ? true : false}".ljust(100) + '|'
+          desc << '|              |' + 'Delete log files:'.rjust(18) + " #{j.clean}".ljust(100) + '|'
+          desc << '|              |' + 'Verbose:'.rjust(18) + " #{j.verbose}".ljust(100) + '|'
+          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 >= 100
+              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 >= 100
+              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 <= 100
+            desc << fragment + "#{compiler_args.join}".ljust(100) + '|'
+          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) < 100 }
+              # remove the args that fit on the first line
+              compiler_args -= args
+              if line_cnt == 0
+                desc << fragment + " #{args.join(' ')}".ljust(100) + '|'
+              else
+                desc << overflow_fragment + " #{args.join(' ')}".ljust(100) + '|'
+              end
+              args = []
+              line_cnt += 1
+              char_cnt = 0
+            end
+          end
+          desc << '-' * desc.first.size
+        end
+        puts desc.flatten.join("\n")
+      end
+
+      # Returns the number of jobs in the compiler
+      def count
+        @jobs.size
+      end
+
+      # Checks if the compiler queue is empty
+      def empty?
+        @jobs.empty?
+      end
+
+      private
+
+      def running_on_windows?
+        RUBY_PLATFORM == 'i386-mingw32'
+      end
+
+      def empty_msg
+        puts "No compiler jobs created, check the compiler options\n" if self.empty?
+      end
+
+      def convert_to_pathname(opt)
+        if opt.is_a? String
+          opt = Pathname.new(opt)
+          opt = opt.expand_path
+        elsif opt.is_a? Pathname
+          opt = opt.expand_path
+        else
+          fail "Option #{opt} is not a String, cannot convert to Pathname"
+        end
+        opt
+      end
+
+      def set_reference_directory
+        if @user_options[:reference_directory].nil?
+          # Nothing passed for reference directory so set it to Origen.app.config.pattern_output_directory if valid
+          if File.directory? Origen.app.config.pattern_output_directory
+            @user_options[:reference_directory] = Pathname.new(Origen.app.config.pattern_output_directory)
+          elsif @path
+            if @path.directory?
+              @user_options[:reference_directory] = @path
+            else
+              @user_options[:reference_directory] = @path.dirname
+            end
+          end
+        elsif File.directory?(@user_options[:reference_directory])
+          @user_options[:reference_directory] = Pathname.new(@user_options[:reference_directory])
+        else
+          debug 'Reference directory not set, creating it...'
+          @user_options[:reference_directory] = Pathname.new(@user_options[:reference_directory])
+          FileUtils.mkdir_p(@user_options[:reference_directory])
+        end
+        @user_options[:reference_directory] = @user_options[:reference_directory].expand_path
+        # reference_directory must be a subset of @path. if it is not then set to @path if @path exists
+        unless @path.nil?
+          if @path.directory?
+            @user_options[:reference_directory] = @path unless @path.to_s.include? @user_options[:reference_directory].to_s
+          elsif @path.file?
+            @user_options[:reference_directory] = @path.dirname
+          else
+            debug "Path is set to #{@path} which is not a valid directory or file!"
+          end
+        end
+      end
+
+      # Check if the current tester is an Ultraflex
+      def is_ultraflex?
+        platform == :ultraflex ? true : false
+      end
+
+      def platform
+        if $tester.nil?
+          fail 'No tester instantiated, $tester is set to nil'
+        else
+          $tester.class.to_s.downcase.split('::').last.to_sym
+        end
+      end
+    end
+  end
+end