HDLRuby 2.11.2 → 2.11.4

data/ext/hruby_sim/hruby_sim.h

@@ -28,6 +28,7 @@ typedef struct PrintS_ PrintS;
 typedef struct HIfS_ HIfS;
 typedef struct HCaseS_ HCaseS;
 typedef struct TimeWaitS_ TimeWaitS;
+typedef struct TimeRepeatS_ TimeRepeatS;
 typedef struct TimeTerminateS_ TimeTerminateS;
 typedef struct ExpressionS_ ExpressionS;
 typedef struct UnaryS_ UnaryS;
@@ -63,6 +64,7 @@ typedef struct PrintS_* Print;
 typedef struct HIfS_* HIf;
 typedef struct HCaseS_* HCase;
 typedef struct TimeWaitS_* TimeWait;
+typedef struct TimeRepeatS_* TimeRepeat;
 typedef struct TimeTerminateS_* TimeTerminate;
 typedef struct ExpressionS_* Expression;
 typedef struct UnaryS_* Unary;
@@ -89,7 +91,8 @@ typedef enum {
 #endif
     OBJECT, SYSTEMT, SIGNALI, SCOPE, BEHAVIOR, SYSTEMI, CODE, BLOCK, EVENT,
 #ifdef RCSIM
-    /* Statements */  TRANSMIT, PRINT, HIF, HCASE, TIME_WAIT, TIME_TERMINATE,
+    /* Statements */  TRANSMIT, PRINT, HIF, HCASE, 
+                      TIME_WAIT, TIME_REPEAT, TIME_TERMINATE,
     /* Expressions */ UNARY, BINARY, SELECT, CONCAT, CAST,
     /* References */  REF_OBJECT, REF_INDEX, REF_RANGE, REF_CONCAT,
     /* Non-hardware*/ STRINGE,
@@ -670,6 +673,13 @@ typedef struct TimeWaitS_ {
     unsigned long long delay; /* The delay to wait in pico seconds. */
 } TimeWaitS;
 
+/** The C model of a time repeat statement. */
+typedef struct TimeRepeatS_ {
+    Kind kind;          /* The kind of object. */
+    long long number;   /* The number of interations, negative means infinity. */
+    Statement statement;/* The statement to execute in loop. */
+} TimeRepeatS;
+
 /** The C model of a time terminate statement. */
 typedef struct TimeTerminateS_ {
     Kind kind;          /* The kind of object. */

data/ext/hruby_sim/hruby_sim_calc.c

@@ -5,9 +5,9 @@
 #include <limits.h>
 #include "hruby_sim.h"
 
-#ifndef alloca
-#define alloca(x)  __builtin_alloca(x)
-#endif
+// #ifndef alloca
+// #define alloca(x)  __builtin_alloca(x)
+// #endif
 
 
 /**
@@ -147,7 +147,7 @@ Type get_type_signed() {
  *  @number the number of elements */
 Type make_type_vector(Type base, unsigned long long number) {
     /* Create the type. */
-    Type type = calloc(sizeof(TypeS),1);
+    Type type = calloc(1,sizeof(TypeS));
     type->base = type_width(base);
     type->number = number;
     type->flags = base->flags;
@@ -201,7 +201,7 @@ Value make_value(Type type, int numeric) {
     /* Compute the size in words of the data contained in the value. */
     unsigned long long width = type_width(type);
     /* Allocate the value. */
-    Value res = calloc(sizeof(ValueS),1);
+    Value res = calloc(1,sizeof(ValueS));
     /* Allocates the data of the value. */
     if (!numeric) {
         /* Allocate the bit string and fill it with u (undefined) by default. */
@@ -232,7 +232,7 @@ void resize_value(Value value, unsigned long long size) {
         /* Free the former data. */
         free(value->data_str);
         /* Reallocate it. */
-        value->data_str = calloc(sizeof(char),size*2);
+        value->data_str = calloc(size*2,sizeof(char));
         /* Update the size. */
         value->capacity = size*2;
     }
@@ -2977,12 +2977,15 @@ Value concat_valueP(unsigned int num, int dir, Value dst, Value* values) {
 }
 Value concat_valueV(unsigned int num, int dir, Value dst, va_list args) {
     unsigned int i;
-    Value* values = alloca(num*sizeof(Value)); /* The values to concatenate. */
+    // Value* values = alloca(num*sizeof(Value)); /* The values to concatenate. */
+    Value* values = calloc(num,sizeof(Value)); /* The values to concatenate. */
     /* Copy the arguments to values for easier processing. */
     for(i=0; i<num; ++i) {
         values[i] = va_arg(args,Value);
     }
-    return concat_valueP(num,dir,dst,values);
+    Value res = concat_valueP(num,dir,dst,values);
+    free(values);
+    return res;
 }
 Value concat_value(unsigned int num, int dir, Value dst, ...) {
     va_list args;

data/ext/hruby_sim/hruby_sim_core.c

@@ -72,11 +72,12 @@ void register_timed_behavior(Behavior behavior) {
         if (cap_timed_behaviors == 0) {
             /* Need to create the array containing the timed behaviors. */
             cap_timed_behaviors = 5;
-            timed_behaviors = calloc(sizeof(Behavior),cap_timed_behaviors);
+            timed_behaviors = calloc(cap_timed_behaviors,sizeof(Behavior));
         } else {
             /* Need to increase the capacity. */
-            Behavior* behaviors = calloc(sizeof(Behavior),cap_timed_behaviors*2);
-            memcpy(behaviors,timed_behaviors,sizeof(Behavior)*cap_timed_behaviors);
+            Behavior* behaviors = calloc(cap_timed_behaviors*2,sizeof(Behavior));
+            // memcpy(behaviors,timed_behaviors,sizeof(Behavior)*cap_timed_behaviors);
+            memcpy(behaviors,timed_behaviors,sizeof(Behavior[cap_timed_behaviors]));
             timed_behaviors = behaviors;
             cap_timed_behaviors *= 2;
         }
@@ -93,11 +94,12 @@ void register_signal(SignalI signal) {
         if (cap_all_signals == 0) {
             /* Need to create the array containing the timed behaviors. */
             cap_all_signals = 100;
-            all_signals = calloc(sizeof(SignalI),cap_all_signals);
+            all_signals = calloc(cap_all_signals,sizeof(SignalI));
         } else {
             /* Need to increase the capacity. */
-            SignalI* new_signals = calloc(sizeof(SignalI),cap_all_signals*2);
-            memcpy(new_signals,all_signals,sizeof(SignalI)*cap_all_signals);
+            SignalI* new_signals = calloc(cap_all_signals*2,sizeof(SignalI));
+            // memcpy(new_signals,all_signals,sizeof(SignalI)*cap_all_signals);
+            memcpy(new_signals,all_signals,sizeof(SignalI[cap_all_signals]));
             cap_all_signals *= 2;
             all_signals=new_signals;
         }

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -358,6 +358,20 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                 hw_wait(delay,behavior);
                 break;
             }
+        case TIME_REPEAT:
+            {
+                TimeRepeat rep = (TimeRepeat)stmnt;
+                if (rep->number>=0) {
+                    for(long long i=0; i<rep->number; ++i) {
+                        execute_statement(rep->statement,mode,behavior);
+                    }
+                } else {
+                    for(;;) {
+                        execute_statement(rep->statement,mode,behavior);
+                    }
+                }
+                break;
+            }
         case BLOCK:
             {
                 Block block = (Block)stmnt;

data/ext/hruby_sim/hruby_value_pool.c

@@ -20,9 +20,10 @@ Value get_value() {
     if (pool_cap == 0) {
         /* First allocation. */
         pool_cap = 16;
-        pool_values = (Value*)malloc(pool_cap*sizeof(Value));
+        // pool_values = (Value*)malloc(pool_cap*sizeof(Value));
+        pool_values = (Value*)calloc(pool_cap,sizeof(Value));
         /* Allocate the new values. */
-        ValueS* new_values = (ValueS*)calloc(sizeof(ValueS),pool_cap);
+        ValueS* new_values = (ValueS*)calloc(pool_cap,sizeof(ValueS));
         /* Assign them to the pool. */
         unsigned int i;
         for(i=0; i<pool_cap; ++i) {
@@ -32,7 +33,8 @@ Value get_value() {
     else if (pool_pos == pool_cap) {
         /* Need to increase the pool capacity. */
         pool_cap = pool_cap * 2;
-        pool_values = (Value*)realloc(pool_values,pool_cap*sizeof(Value));
+        // pool_values = (Value*)realloc(pool_values,pool_cap*sizeof(Value));
+        pool_values = (Value*)realloc(pool_values,sizeof(Value[pool_cap]));
         if (pool_values == NULL) {
             perror("Internal error with the pool of values.");
             exit(1);
@@ -40,7 +42,7 @@ Value get_value() {
         /* Allocate the new values. */
         /* Note: now pool_pos is the old pool_cap and is also the number
          * of new values to allocate. */
-        ValueS* new_values = (ValueS*)calloc(sizeof(ValueS),pool_pos);
+        ValueS* new_values = (ValueS*)calloc(pool_pos,sizeof(ValueS));
         /* Assign them to the pool. */
         unsigned int i;
         for(i=0; i<pool_pos; ++i) {

data/lib/HDLRuby/hdr_samples/repeat_bench.rb

@@ -0,0 +1,48 @@
+# A simple D-FF
+system :dff do
+    input  :d, :clk, :rst
+    output :q
+
+    (q <= d & ~rst).at(clk.posedge)
+end
+
+# A benchmark for the dff using repeat.
+system :dff_bench do
+    inner :d, :clk, :rst
+    inner :q
+
+    dff(:my_dff).(d,clk,rst,q)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        repeat(100) do
+            clk <= 0
+            d <= ~d
+            !10.ns
+            clk <= 1
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hruby_high.rb

@@ -2682,10 +2682,10 @@ module HDLRuby::High
 
         # Converts the repeat statement to HDLRuby::Low.
         def to_low
-            # return HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
+            # timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
             #                                     self.delay.to_low)
-            timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
-                                                self.delay.to_low)
+            timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.number,
+                                                       self.statement.to_low)
             # # For debugging: set the source high object 
             # timeRepeatL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = timeRepeatL
@@ -4233,15 +4233,20 @@ module HDLRuby::High
             self.add_statement(TimeWait.new(delay))
         end
 
-        # Adds a loop until +delay+ statement in the block in +mode+ whose
+        # # Adds a loop until +delay+ statement in the block in +mode+ whose
+        # # loop content is built using +ruby_block+.
+        # def repeat(delay, mode = nil, &ruby_block)
+        # Adds a +number+ times loop statement in the block in +mode+ whose
         # loop content is built using +ruby_block+.
-        def repeat(delay, mode = nil, &ruby_block)
+        # NOTE: if +number+ is negative, the number of iteration is infinite.
+        def repeat(number = -1, mode = nil, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Build the content block.
             content = High.make_block(mode,&ruby_block)
             # Create and add the statement.
-            self.add_statement(TimeRepeat.new(content,delay))
+            # self.add_statement(TimeRepeat.new(content,delay))
+            self.add_statement(TimeRepeat.new(number,content))
         end
 
         # Converts the time block to HDLRuby::Low.

data/lib/HDLRuby/hruby_low.rb

@@ -4042,15 +4042,20 @@ module HDLRuby::Low
     ## 
     # Describes a timed loop statement: not synthesizable!
     class TimeRepeat < Statement
-        # The delay until the loop is repeated
-        attr_reader :delay
+        # # The delay until the loop is repeated
+        # attr_reader :delay
+        # The number of interrations.
+        attr_reader :number
 
         # The statement to execute.
         attr_reader :statement
 
-        # Creates a new timed loop statement execute in a loop +statement+ until
-        # +delay+ has passed.
-        def initialize(statement,delay)
+        # # Creates a new timed loop statement execute in a loop +statement+ until
+        # # +delay+ has passed.
+        # def initialize(statement,delay)
+        # Creates a new timed loop statement execute in a loop +statement+ 
+        # +number+ times (negative means inifinity).
+        def initialize(number,statement)
             # Check and set the statement.
             unless statement.is_a?(Statement)
                 raise AnyError,
@@ -4061,13 +4066,15 @@ module HDLRuby::Low
             # And set its parent.
             statement.parent = self
 
-            # Check and set the delay.
-            unless delay.is_a?(Delay)
-                raise AnyError, "Invalid class for a delay: #{delay.class}."
-            end
-            @delay = delay
-            # And set its parent.
-            delay.parent = self
+            # # Check and set the delay.
+            # unless delay.is_a?(Delay)
+            #     raise AnyError, "Invalid class for a delay: #{delay.class}."
+            # end
+            # @delay = delay
+            # Check and set the number.
+            @number = number.to_i
+            # # And set its parent.
+            # delay.parent = self
         end
 
         # Iterates over each object deeply.
@@ -4080,26 +4087,29 @@ module HDLRuby::Low
             ruby_block.call(self)
             # Then apply on the statement.
             self.statement.each_deep(&ruby_block)
-            # Then apply on the delay.
-            self.delay.each_deep(&ruby_block)
+            # # Then apply on the delay.
+            # self.delay.each_deep(&ruby_block)
         end
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(TimeRepeat)
-            return false unless @delay.eql?(obj.delay)
+            # return false unless @delay.eql?(obj.delay)
+            return false unless @number.eql?(obj.number)
             return false unless @statement.eql?(obj.statement)
             return true
         end
 
         # Hash function.
         def hash
-            return [@delay,@statement].hash
+            # return [@delay,@statement].hash
+            return [@number,@statement].hash
         end
 
         # Clones the TimeRepeat (deeply)
         def clone
-            return TimeRepeat.new(@statement.clone,@delay.clone)
+            # return TimeRepeat.new(@statement.clone,@delay.clone)
+            return TimeRepeat.new(@statement.clone,@number)
         end
 
         # Iterates over the expression children if any.

data/lib/HDLRuby/hruby_low2c.rb

@@ -1803,20 +1803,39 @@ module HDLRuby::Low
     ## Extends the TimeRepeat class with generation of C text.
     class TimeRepeat
 
+        # # Generates the C text of the equivalent HDLRuby code.
+        # # +level+ is the hierachical level of the object.
+        # # def to_c(level = 0)
+        # def to_c(res,level = 0)
+        #     # The resulting string.
+        #     # res = " " * level*3
+        #     res << " " * level*3
+        #     # Generate an infinite loop executing the block and waiting.
+        #     res << "for(;;) {\n"
+        #     # res << "#{self.statement.to_c(level+1)}\n"
+        #     self.statement.to_c(res,level+1)
+        #     res << "\n"
+        #     res << " " * (level+1)*3
+        #     res << Low2C.wait_code(self,level)
+        #     # Return the resulting string.
+        #     return res
+        # end
+
         # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
             # The resulting string.
-            # res = " " * level*3
             res << " " * level*3
-            # Generate an infinite loop executing the block and waiting.
-            res << "for(;;) {\n"
-            # res << "#{self.statement.to_c(level+1)}\n"
+            if (number < 0) then
+                # Generate an infinite loop executing the block and waiting.
+                res << "for(;;) {\n"
+            else
+                # Generate a finite loop.
+                res << "for(long long i = 0; i<#{self.number}; ++i) {\n"
+            end
             self.statement.to_c(res,level+1)
-            res << "\n"
-            res << " " * (level+1)*3
-            res << Low2C.wait_code(self,level)
+            res << " " * level*3 << "}\n"
             # Return the resulting string.
             return res
         end