HDLRuby 3.0.0 → 3.2.0

data/lib/HDLRuby/std/sequencer.rb

@@ -77,20 +77,17 @@ module HDLRuby::High::Std
                     this.fill_top_user(blk)
                 end
             end
-            # # Ends the fsm with an infinite loop state.
-            # st = @fsm.state {}
-            # st.gotos << proc do
-            #     HDLRuby::High.top_user.instance_exec do
-            #         # next_state_sig <= st.value
-            #         next_state_sig <= EndStateValue
-            #     end
-            # end
 
             # Build the fsm.
             @fsm.build
         end
 
-        # Get the closest loop status in the status stack.
+        # Gets the number of states of the underlining fsm.
+        def size
+            return @fsm.size
+        end
+
+        # Gets the closest loop status in the status stack.
         # NOTE: raises an exception if there are not swhile state.
         def loop_status
             i = @status.size-1
@@ -122,6 +119,25 @@ module HDLRuby::High::Std
             return st
         end
 
+        # Mark several steps.
+        def steps(num)
+            # Create a counter. 
+            count = nil
+            zero = nil
+            one = nil
+            HDLRuby::High.cur_system.open do
+                if num.respond_to?(:width) then
+                    count = [num.width].inner(HDLRuby.uniq_name(:"steps_count"))
+                else
+                    count = num.to_expr.type.inner(HDLRuby.uniq_name(:"steps_count"))
+                end
+                zero = _b0
+                one  = _b1
+            end
+            count <= num
+            swhile(count > zero) { count <= count - one }
+        end
+
         # Breaks current iteration.
         def sbreak
             # Mark a step.
@@ -311,9 +327,49 @@ module HDLRuby::High::Std
     end
 
 
+    ## Remplement make_inners of block to support declaration within sequencers.
+
+
+    class HDLRuby::High::Block
+        # Save module method (unbounded) for further call since going to
+        # override make_inners.
+        # alias_method does not seem to work in such a context, so use
+        # this approach.
+        @@old_make_inners_proc = self.instance_method(:make_inners)
+
+        def make_inners(typ,*names)
+            res = nil
+            if SequencerT.current then
+                unames = names.map {|name| HDLRuby.uniq_name(name) }
+                res = HDLRuby::High.cur_scope.make_inners(typ, *unames)
+                names.zip(unames).each do |name,uname|
+                    HDLRuby::High.space_reg(name) { send(uname) }
+                end
+            else
+                # self.old_make_inners(typ,*names)
+                # Call the old make_inners.
+                res = @@old_make_inners_proc.bind(self).call(typ,*names)
+            end
+            return res
+        end
+    end
+
+
+
+
     # Module adding functionalities to object including the +seach+ method.
     module SEnumerable
-        
+
+        # Iterator on each of the elements in range +rng+.
+        # *NOTE*: 
+        #   - Stop iteration when the end of the range is reached or when there
+        #     are no elements left
+        #   - This is not a method from Ruby but one specific for hardware where
+        #     creating a array is very expensive.
+        def seach_range(rng,&ruby_block)
+            return self.seach.seach_range(rng,&ruby_block)
+        end
+
         # Tell if all the elements respect a given criterion given either
         # as +arg+ or as block.
         def sall?(arg = nil,&ruby_block)
@@ -713,8 +769,10 @@ module HDLRuby::High::Std
             # Declares the resulting vector.
             enum = self.seach
             res  = nil
+            # size = enum.size.to_value
             HDLRuby::High.cur_system.open do
-                res = enum.type[-enum.size].inner(HDLRuby.uniq_name(:"to_a_res"))
+                # res = enum.type[-enum.size].inner(HDLRuby.uniq_name(:"to_a_res"))
+                res = enum.type[-enum.size.to_i].inner(HDLRuby.uniq_name(:"to_a_res"))
             end
             # Fills it.
             self.seach_with_index do |elem,i|
@@ -1217,54 +1275,174 @@ module HDLRuby::High::Std
             raise "sslice_before is not supported yet."
         end
 
+        # # HW implementation of the Ruby sort.
+        # def ssort(&ruby_block)
+        #     enum = self.seach
+        #     n = enum.size
+        #     # Declare the result signal the flag and the result array size index
+        #     # used for implementing the algorithm (shift-based sorting).
+        #     res = nil
+        #     flg = nil
+        #     idx = nil
+        #     HDLRuby::High.cur_system.open do
+        #         res = enum.type[-n].inner(HDLRuby.uniq_name(:"sort_res"))
+        #         flg = bit.inner(HDLRuby.uniq_name(:"sort_flg"))
+        #         idx = bit[n.width].inner(HDLRuby.uniq_name(:"sort_idx"))
+        #     end
+        #     # Performs the sort using a shift-based algorithm (also used in 
+        #     # smin).
+        #     enum.srewind
+        #     # Do the iteration.
+        #     idx <= 0
+        #     SequencerT.current.swhile(enum.snext?) do
+        #         # Multiple min case.
+        #         SequencerT.current.sif(enum.snext?) do
+        #             elem = enum.snext
+        #             flg <= 1
+        #             n.times do |i|
+        #                 # Compute the comparison between the result element at i
+        #                 # and the enum element.
+        #                 if ruby_block then
+        #                     cond = ruby_block.call(res[i],elem) > 0
+        #                 else
+        #                     cond = res[i] > elem
+        #                 end
+        #                 # If flg is 0, elem is already set as min, skip.
+        #                 # If the result array size index is equal to i, then
+        #                 # put the element whatever the comparison is since the
+        #                 # place is still empty.
+        #                 hif(flg & (cond | (idx == i))) do
+        #                     # A new min is found, shift res from i.
+        #                     ((i+1)..(n-1)).reverse_each { |j| res[j] <= res[j-1] }
+        #                     # An set the new min in current position.
+        #                     res[i] <= elem
+        #                     # For now skip.
+        #                     flg <= 0
+        #                 end
+        #             end
+        #             idx <= idx + 1
+        #         end
+        #     end
+        #     return res
+        # end
+        
+        # Merge two arrays in order, for ssort only.
+        def ssort_merge(arI, arO, first, middle, last, &ruby_block)
+            # puts "first=#{first} middle=#{middle} last=#{last}"
+            # Declare and initialize the indexes and
+            # the ending flag.
+            idF = nil; idM = nil; idO = nil
+            flg = nil
+            HDLRuby::High.cur_system.open do
+                typ = [(last+1).width]
+                idF = typ.inner(HDLRuby.uniq_name(:"sort_idF"))
+                idM = typ.inner(HDLRuby.uniq_name(:"sort_idM"))
+                idO = typ.inner(HDLRuby.uniq_name(:"sort_idO"))
+                flg = inner(HDLRuby.uniq_name(:"sort_flg"))
+            end
+            idF <= first; idM <= middle; idO <= first
+            flg <= 0
+            SequencerT.current.swhile((flg == 0) & (idO < middle*2)) do
+                if ruby_block then
+                    cond = ruby_block.call(arI[idF],arI[idM]) < 0
+                else
+                    cond = arI[idF] < arI[idM]
+                end
+                hif((idF >= middle) & (idM > last)) { flg <= 1 }
+                helsif (idF >= middle) do
+                    arO[idO] <= arI[idM]
+                    idM <= idM + 1
+                end
+                helsif(idM > last) do
+                    arO[idO] <= arI[idF]
+                    idF <= idF + 1
+                end
+                helsif(cond) do
+                    arO[idO] <= arI[idF]
+                    idF <= idF + 1
+                end
+                helse do
+                    arO[idO] <= arI[idM]
+                    idM <= idM + 1
+                end
+                idO <= idO + 1
+            end
+        end
+
         # HW implementation of the Ruby sort.
         def ssort(&ruby_block)
             enum = self.seach
             n = enum.size
-            # Declare the result signal the flag and the result array size index
-            # used for implementing the algorithm (shift-based sorting).
+            # Declare the result signal.
             res = nil
             flg = nil
-            idx = nil
+            siz = nil
             HDLRuby::High.cur_system.open do
                 res = enum.type[-n].inner(HDLRuby.uniq_name(:"sort_res"))
-                flg = bit.inner(HDLRuby.uniq_name(:"sort_flg"))
-                idx = bit[n.width].inner(HDLRuby.uniq_name(:"sort_idx"))
             end
-            # Performs the sort using a shift-based algorithm (also used in 
-            # smin).
-            enum.srewind
-            # Do the iteration.
-            idx <= 0
-            SequencerT.current.swhile(enum.snext?) do
-                # Multiple min case.
-                SequencerT.current.sif(enum.snext?) do
-                    elem = enum.snext
-                    flg <= 1
-                    n.times do |i|
-                        # Compute the comparison between the result element at i
-                        # and the enum element.
-                        if ruby_block then
-                            cond = ruby_block.call(res[i],elem) > 0
-                        else
-                            cond = res[i] > elem
-                        end
-                        # If flg is 0, elem is already set as min, skip.
-                        # If the result array size index is equal to i, then
-                        # put the element whatever the comparison is since the
-                        # place is still empty.
-                        hif(flg & (cond | (idx == i))) do
-                            # A new min is found, shift res from i.
-                            ((i+1)..(n-1)).reverse_each { |j| res[j] <= res[j-1] }
-                            # An set the new min in current position.
-                            res[i] <= elem
-                            # For now skip.
-                            flg <= 0
-                        end
-                    end
-                    idx <= idx + 1
+            # Only one element?
+            if n == 1 then
+                # Just copy to the result and end here.
+                res[0] <= enum.snext
+                return res
+            end
+            tmp = []
+            idxF = nil; idxM = nil; idxO = nil
+            HDLRuby::High.cur_system.open do
+                # More elements, need to declare intermediate arrays.
+                ((n-1).width).times do
+                    tmp << enum.type[-n].inner(HDLRuby.uniq_name(:"sort_tmp"))
+                end
+                # The result will be the last of the intermediate arrays.
+                tmp << res
+            end
+            # Fills the first temporary array.
+            enum.seach_with_index { |e,i| tmp[0][i] <= e }
+            # Is there only 2 elements?
+            if n == 2 then
+                if ruby_block then
+                    cond = ruby_block.call(tmp[0][0],tmp[0][1]) < 0
+                else
+                    cond = tmp[0][0] < tmp[0][1]
+                end
+                # Just look for the min and the max.
+                hif(cond) do
+                    res[0] <= tmp[0][0]
+                    res[1] <= tmp[0][1]
                 end
+                helse do
+                    res[1] <= tmp[0][0]
+                    res[0] <= tmp[0][1]
+                end
+                return res
             end
+            # Performs the sort using a merge-based algorithm.
+            breadth = 1; i = 0
+            # while(breadth*2 < n)
+            while(breadth < n)
+                pos = 0; last = 0
+                while(pos+breadth < n)
+                    last = [n-1,pos+breadth*2-1].min
+                    ssort_merge(tmp[i], tmp[i+1], pos, pos+breadth,last,&ruby_block)
+                    pos = pos + breadth * 2
+                end
+                # Copy the remaining elements if any
+                # puts "n=#{n} breadth=#{breadth} last=#{last} n-last-1=#{n-last-1}"
+                if last < n-1 then
+                    (n-last-1).stimes do |j|
+                        tmp[i+1][last+1+j] <= tmp[i][last+1+j]
+                    end
+                end
+                # Next step
+                # SequencerT.current.step
+                breadth = breadth * 2
+                i += 1
+            end
+            # # Last merge if the array size was not a power of 2.
+            # if (breadth*2 != n) then
+            #     ssort_merge(tmp[-2],tmp[-1],0,breadth,n-1,&ruby_block)
+            #     # SequencerT.current.step
+            # end
             return res
         end
 
@@ -1302,7 +1480,7 @@ module HDLRuby::High::Std
                     # There is a ruby block, use it to process the element first.
                     res <= res + ruby_block.call(enum.snext)
                 else
-                    # No ruby block, just do the su,
+                    # No ruby block, just do the sum
                     res <= res + enum.snext
                 end
             end
@@ -1493,6 +1671,55 @@ module HDLRuby::High::Std
             end
         end
 
+        # Iterator on the +num+ next elements.
+        # *NOTE*:
+        #   - Stop iteration when the end of the range is reached or when there
+        #     are no elements left
+        #   - This is not a method from Ruby but one specific for hardware where
+        #     creating a array is very expensive.
+        def seach_nexts(num,&ruby_block)
+            # # No block given, returns a new enumerator.
+            # unless ruby_block then
+            #     res = SEnumeratorWrapper.new(self,:seach_nexts,num)
+            #     res.size = num
+            #     return res
+            # end
+            # # A block is given, iterate.
+            # enum = self.seach
+            # # Create a counter. 
+            # count = nil
+            # zero = nil
+            # one = nil
+            # HDLRuby::High.cur_system.open do
+            #     if num.respond_to?(:width) then
+            #         count = [num.width].inner(HDLRuby.uniq_name(:"snexts_count"))
+            #     else
+            #         count = num.to_expr.type.inner(HDLRuby.uniq_name(:"snexts_count"))
+            #     end
+            #     zero = _b0
+            #     one  = _b1
+            # end
+            # count <= num
+            # SequencerT.current.swhile(count > zero) do
+            #     ruby_block.call(enum.snext)
+            #     count <= count - one
+            # end
+            zero = nil
+            one = nil
+            HDLRuby::High.cur_system.open do
+                zero = _b0.as(num.to_expr.type)
+                one = _b1.as(num.to_expr.type)
+            end
+            subE = SEnumeratorSub.new(self,zero..num-one)
+            if ruby_block then
+                # A block is given, iterate immediatly.
+                subE.seach(&ruby_block)
+            else
+                # No block given, return the new sub iterator.
+                return subE
+            end
+        end
+
     end
 
 
@@ -1516,10 +1743,30 @@ module HDLRuby::High::Std
             return self unless ruby_block
             # A block is given, iterate.
             this = self
-            # Reitialize the iteration.
+            # Reinitialize the iteration.
             this.srewind
-            # Performs the iteration.
+            # Perform the iteration.
             SequencerT.current.swhile(self.index < self.size) do
+                # ruby_block.call(this.snext)
+                HDLRuby::High.top_user.instance_exec(this.snext,&ruby_block)
+            end
+        end
+
+        # Iterator on each of the elements in range +rng+.
+        # *NOTE*: 
+        #   - Stop iteration when the end of the range is reached or when there
+        #     are no elements left
+        #   - This is not a method from Ruby but one specific for hardware where
+        #     creating a array is very expensive.
+        def seach_range(rng,&ruby_block)
+            # No block given, returns a new enumerator.
+            return SEnumeratorWrapper.new(self,:seach_range) unless ruby_block
+            # A block is given, iterate.
+            this = self
+            # Perform the iteration.
+            self.index <= rng.first
+            SequencerT.current.swhile((self.index < self.size) & 
+                                      (self.index <= rng.last) ) do
                 ruby_block.call(this.snext)
             end
         end
@@ -1604,7 +1851,7 @@ module HDLRuby::High::Std
 
         # The directly delegate methods.
         def size
-            return @enumerator.size
+            return @enumertor.size
         end
 
         def type
@@ -1632,13 +1879,32 @@ module HDLRuby::High::Std
         end
 
         def snext?
+            # if @size then
+            #     return @enumerator.index < @size
+            # else
+            #     return @enumerator.snext?
+            # end
             return @enumerator.snext?
         end
 
+        def snext!(val)
+            return @enumerator.snext!(val)
+        end
+
         def srewind
             return @enumerator.srewind
         end
 
+        # Iterator on each of the elements in range +rng+.
+        # *NOTE*: 
+        #   - Stop iteration when the end of the range is reached or when there
+        #     are no elements left
+        #   - This is not a method from Ruby but one specific for hardware where
+        #     creating a array is very expensive.
+        def seach_range(rng,&ruby_block)
+            return @enumerator.seach_range(rng,&ruby_block)
+        end
+
         # Clones the enumerator.
         def clone
             return SEnumeratorWrapper.new(@enumerator,@iterator,*@arguments)
@@ -1654,6 +1920,92 @@ module HDLRuby::High::Std
     end
 
 
+    # Describes a sequencer enumerator class that allows to generate HW iterations
+    # over HW or SW objects within sequencers.
+    # This is the sub Enumerator over an other one for interating inside the
+    # enumerator.
+    # This is specific the HDLRuby for avoiding creation of array which are
+    # expensive in HW. Used by seach_next for example.
+    # Will change the index position of the initial iterator without reseting
+    # it.
+    class SEnumeratorSub < SEnumerator
+
+        # Create a new SEnumerator wrapper over +enum+ among +rng+ indexes.
+        def initialize(enum,rng,*args)
+            @enumerator = enum.seach
+            @range = rng.first..rng.last
+            # Declare the sub index.
+            idx = nil
+            siz = @range.last-@range.first+1
+            HDLRuby::High.cur_system.open do
+                idx = [siz.width].inner({
+                    HDLRuby.uniq_name("sub_idx") => 0 })
+            end
+            @index = idx
+            @size = siz
+        end
+
+        # The directly delegate methods.
+        def size
+            return @size
+        end
+
+        def type
+            return @enumerator.type
+        end
+
+        def result
+            return @enumerator.result
+        end
+
+        def index
+            return @index
+        end
+
+        def access(idx)
+            return @enumerator.access(@index+@range.first)
+        end
+
+        def speek
+            return @enumerator.speek
+        end
+
+        def snext
+            @index <= @index + 1
+            return @enumerator.snext
+        end
+
+        def snext?
+            return @index < self.size
+        end
+
+        def snext!(val)
+            return @enumerator.snext!(val)
+        end
+
+        def srewind
+            @index <= 0
+        end
+
+        # Clones the enumerator.
+        def clone
+            return SEnumeratorSub.new(@enumerator,@range)
+        end
+
+        # Iterate over each element.
+        def seach(&ruby_block)
+            # No block given, returns self.
+            return self unless ruby_block
+            # A block is given, iterate.
+            this = self
+            SequencerT.current.swhile(this.snext?) do
+                ruby_block.call(this.snext)
+            end
+        end
+    end
+
+
+
     # Describes a sequencer enumerator class that allows to generate HW 
     # iterations over HW or SW objects within sequencers.
     # This is the base Enumerator that directly iterates.
@@ -1674,7 +2026,9 @@ module HDLRuby::High::Std
             # Sets the accesser.
             @access = access
             # Compute the index width (default: safe 32 bits).
-            width = @size.respond_to?(:width) ? @size.width : 32
+            width = @size.respond_to?(:width) ? @size.width : 
+                    @size.respond_to?(:type) ? size.type.width : 32
+            # puts "width=#{width}"
             # Create the index and the iteration result.
             idx = nil
             result = nil
@@ -1712,9 +2066,17 @@ module HDLRuby::High::Std
 
         # Tell if there is a next element.
         def snext?
+            # puts "@index=#{index}, @size=#{@size}"
             return @index < @size
         end
 
+        # Set the next element.
+        def snext!(val)
+            @access.call(@index,val)
+            @index <= @index + 1
+            return val
+        end
+
         # Restart the iteration.
         def srewind
             @index <= 0
@@ -1722,6 +2084,8 @@ module HDLRuby::High::Std
     end
 
 
+
+
     module HDLRuby::High::HExpression
         # Enhance the HExpression module with sequencer iteration.
 
@@ -1729,8 +2093,14 @@ module HDLRuby::High::Std
         def seach(&ruby_block)
             # Create the hardware iterator.
             this = self
-            hw_enum = SEnumeratorBase.new(this.type.base,this.type.size) do |idx|
-                this[idx]
+            hw_enum = SEnumeratorBase.new(this.type.base,this.type.size) do |idx,val = nil|
+                if val then
+                    # Write access
+                    this[idx] <= val
+                else
+                    # Read access
+                    this[idx]
+                end
             end
             # Is there a ruby block?
             if(ruby_block) then
@@ -1749,6 +2119,42 @@ module HDLRuby::High::Std
     end
 
 
+    # class HDLRuby::High::Value
+    module HDLRuby::High::HExpression
+        # Enhance the Value class with sequencer iterations.
+
+        # HW times iteration.
+        def stimes(&ruby_block)
+            # return (0..self-1).seach(&ruby_block)
+            return AnyRange.new(0,self-1).seach(&ruby_block)
+        end
+
+        # HW upto iteration.
+        def supto(val,&ruby_block)
+            # return (self..val).seach(&ruby_block)
+            return AnyRange.new(self,val).seach(&ruby_block)
+        end
+
+        # HW downto iteration.
+        def sdownto(val,&ruby_block)
+            # Create the hardware iterator.
+            # range = val..(self.to_i)
+            range = AnyRange.new(val,self)
+            hw_enum = SEnumeratorBase.new(signed[32],range.size) do |idx|
+                range.last - idx
+            end
+            # Is there a ruby block?
+            if(ruby_block) then
+                # Yes, apply it.
+                return hw_enum.seach(&ruby_block)
+            else
+                # No, return the resulting enumerator.
+                return hw_enum
+            end
+        end
+    end
+
+
     module ::Enumerable
         # Enhance the Enumerable module with sequencer iteration.
 
@@ -1787,12 +2193,85 @@ module HDLRuby::High::Std
         # HW iteration on each element.
         def seach(&ruby_block)
             # Create the iteration type.
-            typ = bit[[self.first.width,self.last.width].max]
+            # if self.first < 0 || self.last < 0 then
+            #     fw = self.first.is_a?(Numeric) ? self.first.abs.width :
+            #          self.first.width
+            #     lw = self.last.is_a?(Numeric) ? self.last.abs.width :
+            #          self.last.width
+            #     typ = signed[[fw,lw].max]
+            # else
+            #     typ = bit[[self.first.width,self.last.width].max]
+            # end
+            # Create the iteration type: selection of the larger HDLRuby type
+            # between first and last. If one of first and last is a Numeric,
+            # priority to the non Numeric one.
+            if (self.last.is_a?(Numeric)) then
+                typ = self.first.to_expr.type
+            elsif (self.first.is_a?(Numeric)) then
+                typ = self.last.to_expr.type
+            else
+                typ = self.first.type.width > self.last.type.width ? 
+                    self.first.type : self.last.type
+            end
             # Create the hardware iterator.
             this = self
             size = this.size ? this.size : this.last - this.first + 1
-            hw_enum = SEnumeratorBase.new(signed[32],size) do |idx|
-                idx.as(typ) + this.first
+            # size = size.to_expr
+            # if size.respond_to?(:cast) then
+            #     size = size.cast(typ)
+            # else
+            #     size = size.as(typ)
+            # end
+            size = size.to_expr.as(typ)
+            # hw_enum = SEnumeratorBase.new(signed[32],size) do |idx|
+            hw_enum = SEnumeratorBase.new(typ,size) do |idx|
+                # idx.as(typ) + this.first
+                idx.as(typ) + this.first.to_expr.as(typ)
+            end
+            # Is there a ruby block?
+            if(ruby_block) then
+                # Yes, apply it.
+                return hw_enum.seach(&ruby_block)
+            else
+                # No, return the resulting enumerator.
+                return hw_enum
+            end
+        end
+    end
+
+
+    # Range substitute class for sequencers that supports any kind of bounds.
+    class AnyRange
+        # Enhance the AnyRange class with sequencer iteration.
+        include SEnumerable
+
+        attr_reader :first, :last
+
+        def initialize(first,last)
+            @first = first
+            @last = last
+        end
+
+        # HW iteration on each element.
+        def seach(&ruby_block)
+            # Create the iteration type: selection of the larger HDLRuby type
+            # between first and last. If one of first and last is a Numeric,
+            # priority to the non Numeric one.
+            if (self.last.is_a?(Numeric)) then
+                typ = self.first.to_expr.type
+            elsif (self.first.is_a?(Numeric)) then
+                typ = self.last.to_expr.type
+            else
+                typ = self.first.type.width > self.last.type.width ? 
+                    self.first.type : self.last.type
+            end
+            # Create the hardware iterator.
+            this = self
+            # size = this.size ? this.size : this.last - this.first + 1
+            size = this.last - this.first + 1
+            size = size.to_expr.as(typ)
+            hw_enum = SEnumeratorBase.new(typ,size) do |idx|
+                idx.as(typ) + this.first.to_expr.as(typ)
             end
             # Is there a ruby block?
             if(ruby_block) then
@@ -1811,7 +2290,7 @@ module HDLRuby::High::Std
 
         # HW times iteration.
         def stimes(&ruby_block)
-            return (0...self).seach(&ruby_block)
+            return (0..self-1).seach(&ruby_block)
         end
 
         # HW upto iteration.
@@ -1853,5 +2332,4 @@ module HDLRuby::High::Std
     end
 
 
-
 end