HDLRuby 3.0.0 → 3.1.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,6 +327,34 @@ 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)
+            if SequencerT.current then
+                unames = names.map {|name| HDLRuby.uniq_name(name) }
+                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.
+                @@old_make_inners_proc.bind(self).call(typ,*names)
+            end
+        end
+    end
+
+
+
+
     # Module adding functionalities to object including the +seach+ method.
     module SEnumerable
         
@@ -713,8 +757,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 +1263,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 +1468,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
@@ -1674,7 +1840,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
@@ -1749,6 +1917,38 @@ module HDLRuby::High::Std
     end
 
 
+    class HDLRuby::High::Value
+        # Enhance the Value class with sequencer iterations.
+
+        # HW times iteration.
+        def stimes(&ruby_block)
+            return (0..self-1).seach(&ruby_block)
+        end
+
+        # HW upto iteration.
+        def supto(val,&ruby_block)
+            return (self..val).seach(&ruby_block)
+        end
+
+        # HW downto iteration.
+        def sdownto(val,&ruby_block)
+            # Create the hardware iterator.
+            range = val..(self.to_i)
+            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 +1987,40 @@ 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
@@ -1811,7 +2039,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.