origen_testers 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb7e94e2ce35ea525eeb90410b24ebe55c8576b7
-  data.tar.gz: 68d99c86782203d2ba107e3bf9233915c67d5f56
+  metadata.gz: ce3212799e833ec4c450e60a2ea3ebc37022db79
+  data.tar.gz: 8059fd5aaf0f9d7996e543101f1121aeb33f20a3
 SHA512:
-  metadata.gz: 1cbd6405ece9a4cc5f0b71facce92e3588b81dbf7d38f1815d6780e45cf0b71400ac8d8d82258892071c750ad3a1eea04a74d453f387f31e88137088ce33ab69
-  data.tar.gz: ad6cfc2654f121f21c14be9cf82e60075eeb0c3b7932a19ab8473a5bd169e87ecf425149eac9c2866da89d4012e1ebf2f29641abe0244963a1872d9c7d7ce98e
+  metadata.gz: db42da1b9ba4f47f1c8ff6319193c6cf55dc137f3b24e208db6df785c4b7180122d7a65235e403ce7e937e51efc73fb16c6611080a87042e21cb703d82ed8a06
+  data.tar.gz: 60a7b1d11f0d195031dc737cc8842bd114785a7f24003cf5ce48e2207ac07dac9fd63d984e5ff4ed348310535bc6b977d18fdafe416f7b5e6bf436d33f85e8d6

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
   MINOR = 9
-  BUGFIX = 2
+  BUGFIX = 3
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/origen_testers/smartest_based_tester.rb

@@ -1,8 +1,8 @@
 module OrigenTesters
   module SmartestBasedTester
-    autoload :Base,                'origen_testers/smartest_based_tester/base.rb'
-    autoload :V93K,                'origen_testers/smartest_based_tester/v93k.rb'
+    autoload :Base,                'origen_testers/smartest_based_tester/base'
+    autoload :V93K,                'origen_testers/smartest_based_tester/v93k'
   end
   # Convenience/Legacy names without the SmartestBasedTester namespace
-  autoload :V93K,                  'origen_testers/smartest_based_tester/v93k.rb'
+  autoload :V93K,                  'origen_testers/smartest_based_tester/v93k'
 end

data/lib/origen_testers/smartest_based_tester/base/flow.rb

@@ -1,3 +1,4 @@
+require 'origen_testers/smartest_based_tester/base/processors'
 module OrigenTesters
   module SmartestBasedTester
     class Base
@@ -43,7 +44,10 @@ module OrigenTesters
           @indent = 0
           @lines = []
           @stack = { on_fail: [], on_pass: [] }
-          process(model.ast)
+          m = Processors::IfRanCleaner.new.process(model.ast)
+          m = Processors::EmptyBranchCleaner.new.process(m)
+          m = Processors::FlagOptimizer.new.process(m)
+          process(m)
         end
 
         def line(str)

data/lib/origen_testers/smartest_based_tester/base/processors.rb

@@ -0,0 +1,12 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Include any V93K specific AST processors here
+        autoload :IfRanCleaner, 'origen_testers/smartest_based_tester/base/processors/if_ran_cleaner'
+        autoload :EmptyBranchCleaner, 'origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner'
+        autoload :FlagOptimizer, 'origen_testers/smartest_based_tester/base/processors/flag_optimizer'
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner.rb

@@ -0,0 +1,49 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class EmptyBranchCleaner < ATP::Processor
+          # Delete any on-fail child if it's 'empty'
+          def on_test(node)
+            on_pass = node.find(:on_pass)
+            on_fail = node.find(:on_fail)
+            unless on_fail.nil?
+              n = node.remove(on_fail) if branch_is_empty?(on_fail)
+              return n
+            end
+            node
+          end
+
+          # Returns true if:
+          #   - node is completely empty
+          #   - only child is (continue) node
+          #   - only two children, one continue and one set-result
+          def branch_is_empty?(node)
+            children = node.children.dup
+            return true if children.nil?
+
+            # test for only-child situation
+            first_born = children.shift
+            if children.empty?
+              if first_born == n0(:continue)
+                return true
+              else
+                return false
+              end
+            end
+
+            # if only 2 children, check qualificataions, else done and return false
+            next_born = children.shift
+            if children.empty?
+              if (first_born.type == :continue && next_born.type == :set_result) ||
+                 (first_born.type == :set_result && next_born.type == :continue)
+                return true
+              end
+            end
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/flag_optimizer.rb

@@ -0,0 +1,143 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class FlagOptimizer < ATP::Processor
+          attr_reader :run_flag_table
+          # This optimizes the AST such that any adjacent flow noes that
+          #
+          # For example this AST:
+          #   (flow
+          #     (test
+          #       (name "test1")
+          #       (on-fail
+          #         (set-run-flag "t1_FAILED")))
+          #     (run-flag "t1_FAILED" true
+          #       (test
+          #         (name "test2"))
+          #       (test
+          #         (name "test3")))
+          #     (test
+          #       (name "test4")
+          #       (on-pass
+          #         (set-run-flag "t4_PASSED"))
+          #       (on-fail
+          #         (continue)))
+          #     (run-flag "t4_PASSED" true
+          #       (test
+          #         (name "test5"))
+          #       (test
+          #         (name "test6"))))
+          #
+          # Will be optimized to this:
+          #   (flow
+          #     (test
+          #       (name "test1")
+          #       (on-fail
+          #         (test
+          #           (name "test2"))
+          #         (test
+          #           (name "test3"))))
+          #     (test
+          #       (name "test4")
+          #       (on-pass
+          #         (test
+          #           (name "test5"))
+          #         (test
+          #           (name "test6")))
+          #       (on-fail
+          #         (continue))))
+
+          # Processes the AST and tabulates occurences of unique set_run_flag nodes
+          class ExtractRunFlagTable < ATP::Processor
+            # Hash table of run_flag name with number of times used
+            attr_reader :run_flag_table
+
+            # Reset hash table
+            def initialize
+              @run_flag_table = {}
+            end
+
+            # For run_flag nodes, increment # of occurences for specified flag
+            def on_run_flag(node)
+              children = node.children.dup
+              name = children.shift
+              state = children.shift
+              unless name.is_a?(Array)
+                if @run_flag_table[name.to_sym].nil?
+                  @run_flag_table[name.to_sym] = 1
+                else
+                  @run_flag_table[name.to_sym] += 1
+                end
+              end
+            end
+          end
+
+          # Only run this on top level flow and consider adjacent nodes, no need for
+          # looking at nested conditions.
+          def on_flow(node)
+            # Pre-process the AST for # of occurences of each run-flag used
+            t = ExtractRunFlagTable.new
+            t.process(node)
+            @run_flag_table = t.run_flag_table
+
+            name, *nodes = *node
+            results = []
+            node_a = nil
+            nodes.each do |node_b|
+              if node_a && node_a.type == :test && node_b.type == :run_flag
+                result, node_a = remove_run_flag(node_a, node_b)
+                results << result
+              else
+                results << node_a unless node_a.nil?
+                node_a = node_b
+              end
+            end
+            results << node_a unless node_a.nil?
+            node.updated(nil, [name] + results)
+          end
+
+          # Given two adjacent nodes, where the first (a) is a test and the second (b)
+          # is a run_flag, determine if (a) conditionally sets the same flag that (b)
+          # uses.  If it does, do a logical replacement, if not, move on quietly.
+          def remove_run_flag(node_a, node_b)
+            on_pass = node_a.find(:on_pass)
+            on_fail = node_a.find(:on_fail)
+
+            unless on_pass.nil? && on_fail.nil?
+              if on_pass.nil?
+                flag_node = on_fail.find(:set_run_flag)
+                conditional = [flag_node, on_fail]
+              else
+                flag_node = on_pass.find(:set_run_flag)
+                conditional = [flag_node, on_pass]
+              end
+            end
+            unless conditional.nil?
+              children = node_b.children.dup
+              name = children.shift
+              # remove the '_RAN' here so it won't match and if_ran cases are ignored
+              name = name.gsub(/_RAN$/, '') unless name.is_a?(Array)
+              state = children.shift
+              *nodes = *children
+              flag_node_b = n2(:set_run_flag, name, 'auto_generated') if state == true
+
+              if conditional.first == flag_node_b
+                n = conditional.last.dup
+                result = node_a.remove(n)
+                n = n.remove(conditional.first) if @run_flag_table[name.to_sym] == 1
+                n = n.remove(n0(:continue)) if n.type == :on_fail
+                s = n.find(:set_result) if n.type == :on_fail
+                n = n.remove(s) if s
+                n = n.updated(nil, n.children + (nodes.is_a?(Array) ? nodes : [nodes]))
+                result = result.updated(nil, result.children + (n.is_a?(Array) ? n : [n]))
+                return result, nil
+              end
+            end
+            [node_a, node_b]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/if_ran_cleaner.rb

@@ -0,0 +1,34 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class IfRanCleaner < ATP::Processor
+          def on_test(node)
+            on_pass = node.find(:on_pass)
+            on_fail = node.find(:on_fail)
+
+            unless on_pass.nil? || on_fail.nil?
+              set_run_flag = on_fail.find(:set_run_flag)
+              set_result = on_fail.find(:set_result)
+              unless set_run_flag.nil? || set_result.nil?
+                children = set_run_flag.children.dup
+                name = children.shift
+                ag_string = children.shift
+
+                if name =~ /_RAN$/ && ag_string == 'auto_generated'
+                  f = on_fail.dup
+                  f = f.remove(set_result)
+                  n = node.remove(on_fail)
+                  n = n.updated(nil, n.children + (f.is_a?(Array) ? f : [f]))
+                  return n
+                end
+
+              end
+            end
+            node
+          end
+        end
+      end
+    end
+  end
+end

data/program/flow_control.rb

@@ -294,4 +294,28 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
   unless_flag :my_flag do
     test :test3
   end
+  
+  if tester.v93k?
+    log "This should retain the set-run-flag in the else conditional"
+    func :test22, id: :at22
+    
+    if_failed :at22 do
+      func :test22a
+      func :test22b
+    end 
+    
+    func :test22c
+    func :test22d
+  
+    if_failed :at22 do
+      func :test22e
+      func :test22f
+    end 
+  end
+
+  if tester.v93k?
+    log "This should optimize away then/else branches that are empty"
+    func :test36, continue: true
+    func :test36b, bin: 12, continue:true
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: 0.5.4
 description: 
 email:
 - stephen.f.mcginty@gmail.com
@@ -239,6 +239,10 @@ files:
 - lib/origen_testers/smartest_based_tester/base/generator.rb
 - lib/origen_testers/smartest_based_tester/base/pattern_compiler.rb
 - lib/origen_testers/smartest_based_tester/base/pattern_master.rb
+- lib/origen_testers/smartest_based_tester/base/processors.rb
+- lib/origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner.rb
+- lib/origen_testers/smartest_based_tester/base/processors/flag_optimizer.rb
+- lib/origen_testers/smartest_based_tester/base/processors/if_ran_cleaner.rb
 - lib/origen_testers/smartest_based_tester/base/test_method.rb
 - lib/origen_testers/smartest_based_tester/base/test_methods.rb
 - lib/origen_testers/smartest_based_tester/base/test_methods/ac_tml.rb