HDLRuby 2.2.17 → 2.3.0

data/lib/HDLRuby/sim/hruby_sim.h

@@ -157,6 +157,13 @@ extern Value mul_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value div_value(Value src0, Value src1, Value dst);
 
+/** Computes the modulo of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+extern Value mod_value(Value src0, Value src1, Value dst);
+
 /** Computes the not of a value.
  *  @param src the source value of the not
  *  @param dst the destination value

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -397,6 +397,9 @@ static Value set_undefined_bitstring(Value dst) {
 
     /* set the type and size of the destination. */
     dst->numeric = 0;
+    /* Ensures the buffer of dst has the write size (in cas it was a fromer
+     * numeric for example). */
+    resize_value(dst,width);
 
     /* Get access to the destination data. */
     char* dst_data = dst->data_str;
@@ -604,7 +607,7 @@ static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
+    /* Perform the multiplication. */
     dst->data_int = value2integer(src0) * value2integer(src1);
     return dst;
 }
@@ -620,12 +623,29 @@ static Value div_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
+    /* Perform the division. */
     dst->data_int = value2integer(src0) / value2integer(src1);
     return dst;
 }
 
 
+/** Computes the modulo of two defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value mod_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the modulo. */
+    // printf("modulo with src0=%lld src1=%lld, result=%lld\n",value2integer(src0),value2integer(src1),value2integer(src0) % value2integer(src1));
+    dst->data_int = value2integer(src0) % value2integer(src1);
+    return dst;
+}
+
+
 /** Computes the lesser comparision of two defined bitstring values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -1415,7 +1435,10 @@ fix_numeric_type(Type type, unsigned long long val) {
     /* Get the width of the type. */
     int width = type_width(type);
     /* Compute the base mask. */
-    unsigned long long mask = ((unsigned long long)(-1)) << width;
+    // unsigned long long mask = ((unsigned long long)(-1)) << width;
+    /* NOTE: (ull)-1 << 64 becomes (ull)-1 on Intel processors, this is
+     * totally not what I expected (I expected 0). */
+    unsigned long long mask = width == 64 ? 0 : ((unsigned long long)(-1)) << width;
     // printf("width=%i val=%llu mask=%llx\n",width,val,mask);
 
     /* Is the type signed? */
@@ -1516,6 +1539,23 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the modulo of two numeric values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value mod_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the division. */
+    // printf("modulo numeric with src0=%lld src1=%lld, result=%lld\n",src0->data_int, src1->data_int,src0->data_int % src1->data_int);
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int % src1->data_int);
+    return dst;
+}
+
+
 /** Computes the NOT of a numeric value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -1690,7 +1730,7 @@ static Value concat_value_numeric_array(int num, int dir,
     unsigned int i,pos;
     /* Compute the bit width of the destination. */
     unsigned int width = 0;
-    // printf("concat_value_numeric with dir=%d\n",dir);
+    // printf("concat_value_numeric with dir=%d and width=%llu\n",dir,type_width(args[0]->type));
     for(i=0; i<num; ++i) width += type_width(args[i]->type);
 
     /* Sets state of the destination using the bit width. */
@@ -1714,6 +1754,7 @@ static Value concat_value_numeric_array(int num, int dir,
         pos += arg_width;
     }
     /* Return the destination. */
+    // printf("Result is dst=%llx\n",dst->data_int);
     return dst;
 }
 
@@ -1724,6 +1765,7 @@ static Value concat_value_numeric_array(int num, int dir,
  *  @param dst the destination value
  *  @return dst */
 static Value cast_value_numeric(Value src, Type type, Value dst) {
+    // printf("cast_value_numeric with src=%llx",src->data_int);
     /* Copy the source to the destination. */
     dst->data_int = src->data_int;
     /* Update the destination type to the cast. */
@@ -1783,6 +1825,7 @@ static int same_content_value_range_numeric(Value value0,
  *  @return dst */
 Value read_range_numeric(Value value, long long first, long long last,
         Type base, Value dst) {
+    /* printf("read_range_numeric with value=%llx and first=%llu and last=%llu\n",value->data_int,first,last); */
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1795,15 +1838,18 @@ Value read_range_numeric(Value value, long long first, long long last,
     unsigned long long bw = type_width(base);
     /* Scale the range according to the base type. */
     first *= bw;
+    last  *= bw;
     length *= bw;
-    // printf("first=%lld last=%lld bw=%llu length=%lld\n",first,last,bw,length);
+    /* printf("first=%lld last=%lld bw=%llu length=%lld\n",first,last,bw,length); */
 
     /* Set the type and size of the destination from the type of the source.*/
     dst->type = make_type_vector(get_type_bit(),length);
     dst->numeric = 1;
 
     /* Compute the read mask. */
-    unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
+    // unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
+    /* NOTE: once again, << 64 does not work like expected. */
+    unsigned long long mask = mask+bw < 64 ? (~((-1LL) << (last+bw))) : -1LL;
     /* Performs the read. */
     unsigned long long data = (value->data_int & mask) >> first;
     /* Write it to the destination. */
@@ -1999,6 +2045,33 @@ Value div_value(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the modulo of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+Value mod_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return mod_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return mod_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 /** Computes the NOT of a general value.
  *  @param src the source value of the not
  *  @param dst the destination value

data/lib/HDLRuby/std/channel.rb

@@ -81,9 +81,17 @@ module HDLRuby::High::Std
     end
 
 
-    ##
-    #  Module for wrapping channel ports.
-    module ChannelPortWrapping
+    # ##
+    # #  Module for wrapping channel ports.
+    # module ChannelPortWrapping
+    #     # Wrap with +args+ arguments.
+    #     def wrap(*args)
+    #         return ChannelPortB.new(self,*args)
+    #     end
+    # end
+
+    ## Describes a channel port.
+    class ChannelPort
         # Wrap with +args+ arguments.
         def wrap(*args)
             return ChannelPortB.new(self,*args)
@@ -93,8 +101,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes a read port to a channel.
-    class ChannelPortR
-        include ChannelPortWrapping
+    class ChannelPortR < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel reader running in +namespace+ and
         # reading using +reader_proc+ and reseting using +reseter_proc+.
@@ -137,8 +145,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes a writer port to a channel.
-    class ChannelPortW
-        include ChannelPortWrapping
+    class ChannelPortW < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel writer running in +namespace+ and
         # writing using +writer_proc+ and reseting using +reseter_proc+.
@@ -181,8 +189,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes an access port to a channel.
-    class ChannelPortA
-        include ChannelPortWrapping
+    class ChannelPortA < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel accesser running in +namespace+
         # and reading using +reader_proc+, writing using +writer_proc+,
@@ -243,8 +251,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes port wrapper (Box) for fixing arugments.
-    class ChannelPortB
-        include ChannelPortWrapping
+    class ChannelPortB < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel box over channel port +port+ fixing +args+
         # as arguments.
@@ -600,13 +608,23 @@ module HDLRuby::High::Std
 
         # Defines a branch in the channel named +name+ built executing
         # +ruby_block+.
-        def brancher(name,&ruby_block)
+        # Alternatively, a ready channel instance can be passed as argument
+        # as +channelI+.
+        def brancher(name,channelI = nil,&ruby_block)
             # Ensure name is a symbol.
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
-            # Create the branch.
-            channelI = HDLRuby::High.channel_instance(name, &ruby_block)
+            # Is there a ready channel instance.
+            if channelI then
+                # Yes, use it directly.
+                @branches[name] = channelI
+                return self
+            end
+            # No, create the branch.
+            # channelI = HDLRuby::High.channel_instance(name, &ruby_block)
+            channelI = HDLRuby::High::Std.channel_instance(name, &ruby_block)
             @branches[name] = channelI
+            return self
         end
 
 
@@ -619,6 +637,7 @@ module HDLRuby::High::Std
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
             # Get the branch.
+            channelI = @branches[name]
             return @branches[name]
         end
 
@@ -902,7 +921,7 @@ module HDLRuby::High::Std
 
 
     # Wrapper to make an object run like a channel port.
-    class ChannelPortObject
+    class ChannelPortObject < ChannelPort
         # Create a new object wrapper for +obj+.
         def initialize(obj)
             @obj = obj
@@ -946,9 +965,13 @@ module HDLRuby::High::Std
 
 
     # Wrap object +obj+ to act like a channel port.
-    def channel_port(obj)
+    def self.channel_port(obj)
+        return obj if obj.is_a?(ChannelPort) # No need to wrap.
         return ChannelPortObject.new(obj)
     end
+    def channel_port(obj)
+        return HDLRuby::High::Std.channel_port(obj)
+    end
 end
 
 

data/lib/HDLRuby/std/fixpoint.rb

@@ -26,17 +26,18 @@ module HDLRuby::High::Std
                 if args.size == 1 then
                     return self.send(:"_[]_fixpoint",*args)
                 else
-                    # Handle the arguments.
+                    # Handle the arguments and compute the fix point sizes.
                     arg0,arg1 = *args
                     if arg0.respond_to?(:to_i) then
-                        arg0 = (arg0.to_i.abs-1)..0
+                        isize = arg0
+                    else
+                        isize = (arg0.first-arg0.last).abs+1
                     end
                     if arg1.respond_to?(:to_i) then
-                        arg1 = (arg1.to_i.abs-1)..0
+                        fsize = arg1
+                    else
+                        fsize = (arg1.first-arg1.last).abs+1
                     end
-                    # Compute the fix point sizes.
-                    isize = (arg0.first-arg0.last).abs+1
-                    fsize = (arg1.first-arg1.last).abs+1
                     # Build the type.
                     case(self.name)
                     when :bit

data/lib/HDLRuby/std/linear.rb

@@ -244,6 +244,74 @@ module HDLRuby::High::Std
     end
 
 
+    # Declares a simple pipelined multiple mac with single right data.
+    #
+    # Can be used for the product of a martix-vector product.
+    function :mac_np do |typ,ev,req,ack,lefts, rights, last,
+        mul = proc { |x,y| x*y }, add = proc { |x,y| x+y }|
+        # Ensure ev is really an event.
+        ev = ev.posedge unless ev.is_a?(Event)
+        # Ensures lefts is an array.
+        lefts = lefts.to_a
+        # Ensures rights is an array.
+        rights = rights.to_a
+        # Get the size of the pipeline and ensure lefts and rights have the
+        # same.
+        size = lefts.size
+        if (rights.size != size) then
+            raise "Incompatible lefts and rights sizes: lefts size is #{size} and rights size is #{rights.size}"
+        end
+        # Declares the accumulators.
+        accs = size.times.map { |i| typ.inner :"acc#{i}" }
+        # Left value and right value.
+        lvs = lefts.each_with_index.map { |left,i| typ.inner :"lv#{i}" }
+        rvs = rights.each_with_index.map { |right,i| typ.inner :"rv#{i}" }
+        # typ.inner :rv
+        # lv and rv are valid.
+        lvoks = lefts.each_with_index.map { |left,i| inner :"lvok#{i}" }
+        # inner :rvok
+        rvoks = rights.each_with_index.map { |right,i| inner :"rvok#{i}" }
+        # Run flag
+        inner :run
+        par(ev) do
+            ack <= 0
+            run <= 0
+            hif(req | run) do
+                run <= 1
+                # Computation request.
+                lefts.zip(rights).each_with_index do |(left,right),i|
+                    left.read(lvs[i])  { lvoks[i] <= 1 }
+                    right.read(rvs[i]) { rvoks[i] <= 1 }
+                    hif(lvoks[i] & rvoks[i]) do
+                        ack <= 1
+                        run <= 0
+                        if (i < lefts.size-1) then
+                            if (i>0) then 
+                                accs[i] <= add.(accs[i],mul.(lvs[i],rvs[i])) +
+                                    accs[i-1]
+                            else
+                                accs[i] <= add.(accs[i],mul.(lvs[i],rvs[i]))
+                            end
+                        else
+                            # The last is reached
+                            seq do
+                                accs[i] <= add.(accs[i],mul.(lvs[i],rvs[i]))
+                                last.write(accs[i])
+                            end
+                        end
+                    end
+                end
+            end
+            helse do
+                lefts.each_with_index do |left,i|
+                    lvoks[i] <= 0
+                    rvoks[i] <= 0
+                    accs[i] <= 0
+                end
+            end
+        end
+    end
+
 
 
 end

data/lib/HDLRuby/std/loop.rb

@@ -0,0 +1,101 @@
+require 'std/task.rb'
+
+
+
+##
+# Standard HDLRuby::High library: loops encapsulated in tasks.
+# 
+########################################################################
+
+## While loop: loops until +condition+ is met execution +ruby_block+.
+#  The loop is synchronized on +clk_e+ and initialized by +init+.
+#  If +condition+ is nil, then +init+ is used as +condition+.
+HDLRuby::High::Std.task(:while_task) do |clk_e, init, condition, ruby_block|
+    # Ensure clk_e is an event, if not set it to a positive edge.
+    clk_e = clk_e.posedge unless clk_e.is_a?(Event)
+
+    # Ensures there is a condition.
+    unless condition then
+        condition = init
+        init = nil
+    end
+
+    # Transform condition into a proc if it is not the case.
+    unless condition.is_a?(Proc) then
+        condition_expr = condition
+        condition = proc { condition_expr }
+    end
+
+    # Ensures init to be a proc if not nil
+    init = init.to_proc unless init == nil
+
+    # Declares the signals for controlling the loop.
+    inner :req  # Signal to set to 1 for running the loop.
+
+    # Declares the runner signals.
+    runner_output :req
+
+    par(clk_e) do
+        # Performs the loop.
+        hif(req) do
+            # By default the loop is not finished.
+            # If the condition is still met go on looping.
+            hif(condition.call,&ruby_block)
+        end
+        # # if (init) then
+        # #     # There is an initialization, do it when there is no req.
+        # #     helse do
+        # #         init.call
+        # #     end
+        # # end
+    end
+
+    # The code for reseting the task.
+    if (init) then
+        # reseter(&init)
+        reseter do
+            req <= 0
+            init.call
+        end
+    end
+
+    # The code for running the task.
+    runner do
+        # top_block.unshift { req <= 0 }
+        req <= 1
+    end
+
+    # The code for checking the end of execution.
+    finisher do |blk|
+        hif(~condition.call,&blk)
+    end
+
+end
+
+
+
+## A simplified loop: loops until +condition+ is met execution +ruby_block+.
+#  The loop is synchronized on +clk_e+ and initialized by +init+.
+#  If +condition+ is nil, then +init+ is used as +condition+.
+def while_loop(clk_e, init, condition = nil, &ruby_block)
+    # Create the loop task.
+    tsk = while_task(clk_e,init,condition,ruby_block).(HDLRuby.uniq_name)
+    # Create the inner access port.
+    prt = tsk.inner HDLRuby.uniq_name
+    # Return the access port.
+    return prt
+end
+
+## Loop +num+ times executing +ruby_block+.
+#  The loop is synchronized on +clk_e+.
+def times_loop(clk_e, num, &ruby_block)
+    # Compute the width of the counter.
+    width = num.respond_to?(:width) ? num.width : num.type.width
+    # Declares the counter.
+    cnt = [width].inner(HDLRuby.uniq_name)
+    # Create the loop.
+    return while_loop(clk_e, proc{cnt<=0}, cnt<num) do
+        cnt <= cnt + 1
+        ruby_block.call
+    end
+end