HDLRuby 3.1.0 → 3.3.0

data/lib/HDLRuby/std/sequencer.rb

@@ -338,17 +338,19 @@ module HDLRuby::High::Std
         @@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) }
-                HDLRuby::High.cur_scope.make_inners(typ, *unames)
+                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.
-                @@old_make_inners_proc.bind(self).call(typ,*names)
+                res = @@old_make_inners_proc.bind(self).call(typ,*names)
             end
+            return res
         end
     end
 
@@ -357,7 +359,17 @@ module HDLRuby::High::Std
 
     # 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)
@@ -1659,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
 
 
@@ -1682,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
@@ -1770,7 +1851,7 @@ module HDLRuby::High::Std
 
         # The directly delegate methods.
         def size
-            return @enumerator.size
+            return @enumertor.size
         end
 
         def type
@@ -1798,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)
@@ -1820,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.
@@ -1880,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
@@ -1890,6 +2084,8 @@ module HDLRuby::High::Std
     end
 
 
+
+
     module HDLRuby::High::HExpression
         # Enhance the HExpression module with sequencer iteration.
 
@@ -1897,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
@@ -1917,23 +2119,27 @@ module HDLRuby::High::Std
     end
 
 
-    class HDLRuby::High::Value
+    # 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 (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 (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 = val..(self.to_i)
+            range = AnyRange.new(val,self)
             hw_enum = SEnumeratorBase.new(signed[32],range.size) do |idx|
                 range.last - idx
             end
@@ -2034,6 +2240,51 @@ module HDLRuby::High::Std
     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
+                # Yes, apply it.
+                return hw_enum.seach(&ruby_block)
+            else
+                # No, return the resulting enumerator.
+                return hw_enum
+            end
+        end
+    end
+
+
     class ::Integer
         # Enhance the Integer class with sequencer iterations.
 
@@ -2081,5 +2332,4 @@ module HDLRuby::High::Std
     end
 
 
-
 end

data/lib/HDLRuby/std/sequencer_channel.rb

@@ -0,0 +1,90 @@
+require 'std/sequencer'
+
+module HDLRuby::High::Std
+
+    ##
+    # Standard HDLRuby::High library: channel generator.
+    # The idea is to have abstract communication interface whose
+    # implementation can be seamlessly modified.
+    # 
+    ########################################################################
+    
+
+
+
+
+    # Creates an abstract channel over an accessing method.
+    # NOTE: Works like an enumerator, but can be passed as generic arguments and
+    # generates a different enumerator per sequencer.
+    # - +typ+ is the data type of the elements.
+    # - +size+ is the number of elements.
+    # - +access+ is the block implementing the access method.
+    class SequencerChannel < SEnumerator
+
+        # Create a new channel for +size+ elements of type +type+ with an JW
+        # array-like accesser +access+.
+        def initialize(typ,size,&access)
+            @type = typ
+            @size = size
+            @access = access
+            @enums  = {} # The enumerator per sequencer.
+        end
+
+        # Get the enumerator for current sequencer.
+        # If does not exist create a new one.
+        def senumerator
+            unless SequencerT.current then
+                raise "Cannot get a channel enumerator from outside a sequencer."
+            end
+            enum = @enums[SequencerT.current]
+            unless enum then
+                enum = @enums[SequencerT.current] =
+                    SEnumeratorBase.new(@type,@size,&@access)
+            end
+            return enum
+        end
+
+        # Clones is ambigous here, so deactivated.
+        def clone
+            raise "clone not supported for channels."
+        end
+
+        # The array read accesses.
+        def [](addr)
+            return @access.call(addr)
+        end
+
+        # The array write access.
+        def []=(addr,val)
+            return @access.call(addr,val)
+        end
+
+        # The access to the already defined elements.
+        attr_reader :type
+        attr_reader :size
+
+        # Delegate the enumeration methods to the enumerator of the current
+        # system.
+        
+        [:result,:index,:access,:speek,
+         :snext,:snext?,:snext!,:srewind].each do |sym|
+            define_method(sym) do |*args,&ruby_block|
+                senumerator.send(sym,*args,&ruby_block)
+            end
+        end
+    end
+
+
+
+    # Creates an abstract channel over an accessing method.
+    # NOTE: Works like an enumerator or a memory access, but can be passed as
+    # generic arguments and generates a different enumerator per sequencer
+    # (memory access is identical for now though).
+    # - +typ+ is the data type of the elements.
+    # - +size+ is the number of elements.
+    # - +access+ is the block implementing the access method.
+    def schannel(typ,size,&access)
+        return SequencerChannel.new(typ,size,&access)
+    end
+
+end

data/lib/HDLRuby/std/sequencer_func.rb

@@ -16,6 +16,12 @@ module HDLRuby::High::Std
     #       their are set when the function is called.
     #       This is handle by the eigen functions (see SequencerFunctionE).
     class SequencerFunctionT
+
+        ZERO = :_b0.to_value
+        ONE = :_sb01.to_value
+        # ZERO = 0
+        # ONE = 1
+
         # The name of the function.
         attr_reader :name
 
@@ -69,7 +75,7 @@ module HDLRuby::High::Std
                         # hprint("returning with stack_ptr=",stack_ptr,"\n")
                         hif(stack_ptr <= depth) do
                             # hprint("poking recursive return value at idx=",funcI.returnIdx," with value=",st_call.value+1,"\n")
-                            funcI.poke(funcI.returnIdx,st_call.value + 1)
+                            funcI.poke(funcI.returnIdx,st_call.value + ONE)
                         end
                     end
                 end
@@ -89,7 +95,7 @@ module HDLRuby::High::Std
                     old_code.call
                     HDLRuby::High.top_user.instance_exec do
                         # hprint("poking return value at idx=",funcI.returnIdx," with value=",st_func.value+1,"\n")
-                        funcI.poke(funcI.returnIdx,st_func.value + 1)
+                        funcI.poke(funcI.returnIdx,st_func.value + ONE)
                     end
                 end
             end
@@ -151,6 +157,11 @@ module HDLRuby::High::Std
 
     # Describes a sequencer function instance.
     class SequencerFunctionI
+
+        ZERO = SequencerFunctionT::ZERO
+        ONE = SequencerFunctionT::ONE
+
+
         @@current_stack = [] # The stack of current function instance.
 
         # Get the function instance currently processing.
@@ -194,7 +205,7 @@ module HDLRuby::High::Std
             # Create the stacks for the arguments.
             @funcE.each_argT { |argT| self.make_stack(argT) }
             # @argsIdx = @returnIdx + 2
-            @argsIdx = @returnIdx + 1
+            @argsIdx = @returnIdx + ONE
 
             # Create the return value, however, at first their type is unknown
             # to set it as a simple bit.
@@ -296,7 +307,7 @@ module HDLRuby::High::Std
 
             # Get the state value of the function: it is the state
             # following the first function call.
-            func_state_value = call_state.value + 1
+            func_state_value = call_state.value + ONE
             # Do the call.
             call_state.gotos << proc do
                 HDLRuby::High.top_user.instance_exec do
@@ -329,7 +340,7 @@ module HDLRuby::High::Std
                 # Since not pushed the stack yet for not loosing the previous
                 # arguments, add +1 to the offset when poking the new arguments.
                 # args.each_with_index { |arg,i| self.poke(@argsIdx + i,arg,1) }
-                args.each_with_index { |arg,i| this.poke(argsIdx + i,arg,1) }
+                args.each_with_index { |arg,i| this.poke(argsIdx + i,arg,ONE) }
             end
 
             # Push a new frame.
@@ -349,7 +360,7 @@ module HDLRuby::High::Std
 
             # Get the state value of the function: it is the state
             # following the first function call.
-            func_state_value = @state.value + 1
+            func_state_value = @state.value + ONE
             # Do the call.
             call_state.gotos << proc do
                 HDLRuby::High.top_user.instance_exec do
@@ -358,7 +369,7 @@ module HDLRuby::High::Std
                     end
                     helse do
                         # Overflow! Skip the call.
-                        next_state_sig <= call_state_value + 1
+                        next_state_sig <= call_state_value + ONE
                         # if overflow then
                         #     # There is some overflow code to execute.
                         #     HDLRuby::High.top_user.instance_exec(&overflow)
@@ -395,32 +406,32 @@ module HDLRuby::High::Std
             @stack_sigs << stack_sig
 
             # Returns the index of the newly created stack.
-            return @stack_sigs.size-1
+            return @stack_sigs.size - ONE
         end
 
         ## Pushes a new frame to the top of the stacks.
         def push_all
             # HDLRuby::High.cur_system.hprint("push_all\n")
-            @stack_ptr <= @stack_ptr + 1
+            @stack_ptr <= @stack_ptr + ONE
         end
 
         ## Remove the top frame from the stacks.
         def pop_all
             # HDLRuby::High.cur_system.hprint("pop_all\n")
-            @stack_ptr <= @stack_ptr -1
+            @stack_ptr <= @stack_ptr - ONE
         end
 
         ## Get a value from the top of stack number +idx+
         #  If +off+ is the offeset in the stack.
         def peek(idx, off = 0)
-            return @stack_sigs[idx][@stack_ptr-1+off]
+            return @stack_sigs[idx][(@stack_ptr-ONE)+off]
         end
 
         ## Sets value +val+ to the top of stack number +idx+.
         #  If +off+ is the offeset in the stack.
         def poke(idx,val, off = 0)
             # puts "idx=#{idx} val=#{val} sig=#{@stack_sigs[idx].name}"
-            @stack_sigs[idx][@stack_ptr-1+off] <= val
+            @stack_sigs[idx][@stack_ptr-ONE+off] <= val
         end
 
         ## Access the return value signal.
@@ -449,7 +460,7 @@ module HDLRuby::High::Std
             # ret_state_value = self.peek(@returnIdx, HDLRuby::High.top_user.mux(@stack_ptr < @depth,-1,0))
             # Peek before the stack pointer value to account from the fact that
             # the pop is performed beforehand.
-            ret_state_value = self.peek(@returnIdx, HDLRuby::High.top_user.mux(@stack_ptr < @depth,0,+1))
+            ret_state_value = self.peek(@returnIdx, HDLRuby::High.top_user.mux(@stack_ptr < @depth,ZERO,ONE))
             # Return.
             this = self
             state.gotos << proc do
@@ -483,15 +494,17 @@ module HDLRuby::High::Std
         alias_method :old_make_inners, :make_inners
 
         def make_inners(typ,*names)
+            res = nil
             if SequencerFunctionI.current then
                 unames = names.map {|name| HDLRuby.uniq_name(name) }
-                HDLRuby::High.cur_scope.make_inners(typ, *unames)
+                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)
+                res = self.old_make_inners(typ,*names)
             end
+            return res
         end
     end
 

data/lib/HDLRuby/std/std.rb

@@ -4,10 +4,16 @@
 # 
 ########################################################################
 
+# Hardware libraries.
+
 require 'std/clocks.rb'
 require 'std/fixpoint.rb'
 require 'std/decoder.rb'
 require 'std/fsm.rb'
 require 'std/sequencer.rb'
+require 'std/sequencer_channel.rb'
 require 'std/sequencer_sync.rb'
 require 'std/sequencer_func.rb'
+
+# User interface libraries.
+require 'ui/hruby_board.rb'