HDLRuby 2.7.11 → 2.10.2

data/lib/HDLRuby/hruby_low2c.rb

@@ -135,6 +135,8 @@ module HDLRuby::Low
             objs.each { |obj| res << "   " << Low2C.make_name(obj) << "();\n" }
             # Sets the top systemT.
             res << "   top_system = " << Low2C.obj_name(top) << ";\n"
+            # Enable it.
+            res << "   set_enable_system(top_system,1);\n"
             # Starts the simulation.
             res<< "   hruby_sim_core(\"#{name}\",#{init_visualizer},-1);\n"
             # Close the main.
@@ -170,6 +172,7 @@ module HDLRuby::Low
         # is the list of extra h files to include.
         # def to_c(level = 0, *hnames)
         def to_c(res, level = 0, *hnames)
+            # puts "SystemT.to_c with name=#{Low2C.obj_name(self)}#{@wrapper ? " and wrapper=#{Low2C.obj_name(@wrapper)}" : ""}"
             # The header
             # res = Low2C.includes(*hnames)
             res << Low2C.includes(*hnames)
@@ -179,7 +182,16 @@ module HDLRuby::Low
 
             # Generate the signals of the system.
             # self.each_signal { |signal| signal.to_c(level) }
-            self.each_signal { |signal| signal.to_c(res,level) }
+            if ((defined? @wrapper) && @wrapper) then
+                # It is a reconfiguring system, alias the signals.
+                wrap_signals = @wrapper.each_signal.to_a
+                self.each_signal.with_index do |signal,i|
+                    signal.to_c_alias(res,wrap_signals[i],level)
+                end
+            else
+                # It is a single system, default generation.
+                self.each_signal { |signal| signal.to_c(res,level) }
+            end
 
             # Generate the code for all the blocks included in the system.
             self.scope.each_scope_deep do |scope|
@@ -686,6 +698,10 @@ module HDLRuby::Low
                 res << "behavior->owner = NULL;\n"
             end
 
+            # Set the behavior as not enabled. */
+            res << " " * (level+1)*3
+            res << "behavior->enabled = 0;\n"
+
             # Set the behavior as inactive. */
             res << " " * (level+1)*3
             res << "behavior->activated = 0;\n"
@@ -842,11 +858,8 @@ module HDLRuby::Low
         #  +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
-            # The resulting string.
-            # res = ""
-
+            # puts "Signal.to_c with name: #{Low2C.obj_name(self)}"
             # Declare the global variable holding the signal.
-            # res << "SignalI #{self.to_c_signal(level+1)};\n\n"
             res << "SignalI "
             self.to_c_signal(res,level+1)
             res << ";\n\n"
@@ -854,6 +867,7 @@ module HDLRuby::Low
             # The header of the signal generation.
             res << " " * level*3
             res << "SignalI " << Low2C.make_name(self) << "() {\n"
+
             # res << " " * level*3
             # res << "Value l,r,d;\n"
             # res << " " * (level+1)*3
@@ -866,7 +880,6 @@ module HDLRuby::Low
             # Sets the global variable of the signal.
             res << "\n"
             res << " " * (level+1)*3
-            # res << "#{self.to_c_signal(level+1)} = signalI;\n"
             self.to_c_signal(res,level+1)
             res << " = signalI;\n"
 
@@ -958,6 +971,43 @@ module HDLRuby::Low
 
             return res;
         end
+
+        ## Generates the C text of the equivalent HDLRuby code in case
+        #  the signals is actually an alias to another signal.
+        #  +other+ is the target signal of the alias.
+        #  +level+ is the hierachical level of the object.
+        def to_c_alias(res,target,level = 0)
+            # puts "Signal.to_c_alias with name: #{Low2C.obj_name(self)}"
+            # The resulting string.
+            # res = ""
+
+            # Declare the global variable holding the signal.
+            res << "SignalI "
+            self.to_c_signal(res,level+1)
+            res << ";\n\n"
+
+            # The header of the signal generation.
+            res << " " * level*3
+            res << "SignalI " << Low2C.make_name(self) << "() {\n"
+
+            res << "SignalI signalI = #{Low2C.obj_name(target)};\n"
+
+            # Sets the global variable of the signal.
+            res << "\n"
+            res << " " * (level+1)*3
+            self.to_c_signal(res,level+1)
+            res << " = signalI;\n"
+
+            # Generate the return of the signal.
+            res << "\n"
+            res << " " * (level+1)*3
+            res << "return signalI;\n"
+
+            # Close the signal.
+            res << " " * level*3
+            res << "};\n\n"
+            return res
+        end
     end
 
 
@@ -999,9 +1049,22 @@ module HDLRuby::Low
             # Set the name
             res << " " * (level+1)*3
             res << "systemI->name = \"#{self.name}\";\n"
-            # Set the type.
+            # # Set the type.
+            # res << " " * (level+1)*3
+            # res << "systemI->system = " << Low2C.obj_name(self.systemT) << ";\n"
+            # Set the systems.
+            num_sys = self.each_systemT.to_a.size
             res << " " * (level+1)*3
-            res << "systemI->system = " << Low2C.obj_name(self.systemT) << ";\n"
+            res << "systemI->num_systems = #{num_sys};\n"
+            res << " " * (level+1)*3
+            res << "systemI->systems = calloc(sizeof(SystemT), #{num_sys});\n"
+            self.each_systemT.with_index do |sysT,i|
+                res << " " * (level+1)*3
+                res << "systemI->systems[#{i}] = #{Low2C.obj_name(sysT)};\n"
+            end
+
+            # Configure the instance to current systemT.
+            res << (" " * (level*3)) << "configure(systemI,0);\n"
 
             # Generate the return of the signal.
             res << "\n"
@@ -1100,6 +1163,10 @@ module HDLRuby::Low
                 res << "code->owner = NULL;\n"
             end
 
+            # Set the code as enabled (for now, may change in a near future). */
+            res << " " * (level+1)*3
+            res << "code->enabled = 1;\n"
+
             # Set the code as inactive. */
             res << " " * (level+1)*3
             res << "code->activated = 0;\n"
@@ -1392,6 +1459,28 @@ module HDLRuby::Low
         end
     end
 
+    ## Extends the TimeTerminate class with generation of C text.
+    class TimeTerminate
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(res,level = 0)
+            # Save the value pool state.
+            res << (" " * (level*3)) << "terminate();\n"
+        end
+    end
+
+    ## Extends the Configure class with generation of C text.
+    class Configure
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(res,level = 0)
+            # Save the value pool state.
+            res << (" " * (level*3)) << "configure(#{Low2C.obj_name(self.ref.resolve)},#{self.index});\n"
+        end
+    end
+
     
     ## Extends the If class with generation of C text.
     class If
@@ -1993,11 +2082,11 @@ module HDLRuby::Low
             if str =~ /^[01]+$/ && str.length <= 64 then
                 # Yes, generate a numeral value.
                 res << " " * (level+1)*3
-                # res << "static unsigned long long data[] = { "
                 res << "static unsigned int data[] = { "
                 res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
                     sub.to_i(2).to_s # + "ULL"
                 end.join(",")
+                res << ", 0" if (str.length <= 32)
                 res << " };\n"
                 # Create the value.
                 res << " " * (level+1)*3

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -925,6 +925,18 @@ module HDLRuby::Low
             end.join(" & ") + ";\n"
         end
     end
+
+    ## Extends the TimeTerminate class with generation of HDLRuby::High text.
+    class TimeTerminate
+
+        # Generates the text of the equivalent HDLRuby::High code.
+        # +vars+ is the list of the variables and
+        # +level+ is the hierachical level of the object.
+        def to_vhdl(vars,level = 0)
+            # Generate a report statement.
+            return " " * (level*3) + "finish;\n"
+        end
+    end
     
     ## Extends the If class with generation of HDLRuby::High text.
     class If

data/lib/HDLRuby/hruby_low_bool2select.rb

@@ -75,6 +75,18 @@ module HDLRuby::Low
         end
     end
 
+
+    ## Extends the TimeTerminate class with functionality for converting booleans
+    #  in assignments to select operators.
+    class TimeTerminate
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Nothing to do.
+            return self
+        end
+    end
+
     
     ## Extends the If class with functionality for converting booleans
     #  in assignments to select operators.

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -71,7 +71,7 @@ module HDLRuby::Low
     class Statement
         # Explicit the types conversions in the statement.
         def explicit_types!
-            raise "Should implement explicit_types for class #{self.class}."
+            raise "Should implement explicit_types! for class #{self.class}."
         end
     end
 
@@ -98,7 +98,26 @@ module HDLRuby::Low
             self.map_args!(&:explicit_types)
             return self
         end
+    end
+
+
+    ## Extends the Configure class with fixing of types and constants.
+    class Configure
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Nothing to do.
+            return self
+        end
+    end
 
+
+    ## Extends the TimeTerminate class with fixing of types and constants.
+    class TimeTerminate
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Nothing to do.
+            return self
+        end
     end
 
 

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -242,7 +242,7 @@ module HDLRuby::Low
                     parent = parent.parent
                 end
                 # Not found.
-                # puts "Not found!"
+                puts "Not found!"
                 return nil
             end
         end

data/lib/HDLRuby/hruby_low_without_connection.rb

@@ -92,6 +92,7 @@ module HDLRuby::Low
                             inputs_blk.add_statement(
                                 Transmit.new(right.clone,left.clone))
                         elsif (left_is_o) then
+                            # puts "left=#{left} right=#{right}"
                             outputs_blk.add_statement(
                                 Transmit.new(right.clone,left.clone))
                         elsif (right_is_o) then

data/lib/HDLRuby/hruby_low_without_select.rb

@@ -163,7 +163,7 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the String class with functionality for converting select
+    ## Extends the Print class with functionality for converting select
     #  expressions to case statements.
     class Print
         # Extract the Select expressions.
@@ -175,6 +175,16 @@ module HDLRuby::Low
             return selects
         end
     end
+
+    ## Extends the TimeTerminate class with functionality for converting select
+    #  expressions to case statements.
+    class TimeTerminate
+        # Extract the Select expressions.
+        def extract_selects!
+            # Nothing to extract.
+            return []
+        end
+    end
     
     ## Extends the If class with functionality for converting select
     #  expressions to case statements.

data/lib/HDLRuby/hruby_verilog.rb

@@ -171,7 +171,7 @@ module HDLRuby::Low
 
     # Enhance Print with generation of verilog code.
     class Print
-        # Converts the system to Verilog code.
+        # Converts the print to Verilog code.
         def to_verilog(spc = 3)
             code = "#{" " * spc}$write(#{self.each_arg.map do |arg|
             arg.to_verilog
@@ -180,6 +180,14 @@ module HDLRuby::Low
         end
     end
 
+    # Enhance TimeTerminate with generation of verilog code.
+    class TimeTerminate
+        # Converts the terminate to Verilog code.
+        def to_verilog(spc = 3)
+            return "#{" " * spc}$finish;"
+        end
+    end
+
     # To scheduling to the Block.
     # Enhance Block with generation of verilog code.
     class Block

data/lib/HDLRuby/sim/hruby_sim.h

@@ -467,7 +467,10 @@ typedef struct SystemIS_ {
     Object owner;       /* The owner if any. */
 
     char* name;         /* The name of the signal. */
-    SystemT system;     /* The instantiated system. */
+    SystemT system;     /* The currently instantiated system. */
+
+    int num_systems;    /* The number of systems possibly instantiated here. */
+    SystemT* systems;   /* The systems possibly instantiated here. */
 } SystemIS;
 
 
@@ -499,6 +502,8 @@ typedef struct BehaviorS_ {
     Event* events;      /* The events of the behavior. */
     Block block;        /* The block of the behavior. */
 
+    int enabled;        /* Tells if the behavior is enabled or not. */
+
     int activated;      /* Tells if the behavior is activated or not. */
 
     int timed;          /* Tell if the behavior is timed or not:
@@ -519,6 +524,8 @@ typedef struct CodeS_ {
     Event* events;      /* The events of the behavior. */
     void (*function)(); /* The function to execute for the code. */
 
+    int enabled;        /* Tells if the behavior is enabled or not. */
+
     int activated;      /* Tells if the code is activated or not. */
 } CodeS;
 
@@ -623,6 +630,16 @@ extern unsigned long long make_delay(int value, Unit unit);
  * @param func function to applie on each signal. */
 extern void each_all_signal(void (*func)(SignalI));
 
+
+/** Configure a system instance.
+ *  @param systemI the system instance to configure.
+ *  @param idx the index of the target system. */
+extern void configure(SystemI systemI, int idx);
+
+
+/** Terminates the simulation. */
+extern void terminate();
+
 /* Interface to the visualization engine. */
 
 typedef struct {
@@ -701,6 +718,11 @@ extern void init_vcd_visualizer(char* name);
 
 /* The interface to the simulator core. */
 
+/** Sets the enable status of the behaviors of a system type. 
+ *  @param systemT the system type to process.
+ *  @param status the enable status. */
+extern void set_enable_system(SystemT systemT, int status);
+
 /** The simulation core function.
  *  @param name the name of the simulation.
  *  @param init_vizualizer the vizualizer engine initializer.

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -1871,10 +1871,11 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Perform the !XOR. */
-    // dst->data_int = ~(src0->data_int ^ src1->data_int);
     /* Perform the comparison. */
     dst->data_int = (src0->data_int == src1->data_int) ? 1 : 0;
+    printf("scr0->data_int=%lld\n",src0->data_int);
+    printf("scr1->data_int=%lld\n",src1->data_int);
+    printf("dst->data_int=%lld\n",dst->data_int);
     return dst;
 }
 

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -253,8 +253,8 @@ void hruby_sim_update_signals() {
             if (obj->kind == BEHAVIOR) {
                 /* Behavior case. */
                 Behavior beh = (Behavior)obj;
-                /* Is the code really activated? */
-                if (beh->activated) {
+                /* Is the code really enabled and activated? */
+                if (beh->enabled && beh->activated) {
                     /* Yes, execute it. */
                     beh->block->function();
                     /* And deactivate it. */
@@ -264,7 +264,7 @@ void hruby_sim_update_signals() {
                 /* Other code case. */
                 Code cod = (Code)obj;
                 /* Is the code really activated? */
-                if (cod->activated) {
+                if (cod->enabled && cod->activated) {
                     /* Yes, execute it. */
                     cod->function();
                     /* And deactivate it. */
@@ -294,6 +294,35 @@ void hruby_sim_advance_time() {
 }
 
 
+/** Sets the enamble status of the behaviors of a scope.
+ *  @param scope the scope to process.
+ *  @param status the enable status. */
+static void set_enable_scope(Scope scope, int status) {
+    int i;
+    int num_beh = scope->num_behaviors;
+    Behavior*  behs = scope->behaviors;
+    int num_scp = scope->num_scopes;
+    Scope* scps = scope->scopes;
+
+    /* Enable the behaviors. */
+    for(i=0; i<num_beh; ++i) {
+        behs[i]->enabled = status;
+    }
+
+    /* Recurse on the sub scopes. */
+    for(i=0; i<num_scp; ++i) {
+        set_enable_scope(scps[i],status);
+    }
+}
+
+/** Sets the enable status of the behaviors of a system type. 
+ *  @param systemT the system type to process.
+ *  @param status the enable status. */
+void set_enable_system(SystemT systemT, int status) {
+    set_enable_scope(systemT->scope,status);
+}
+
+
 /** Activates a behavior.
  *  @param behavior the behavior to activate. */
 void activate_behavior(Behavior behavior) {
@@ -359,7 +388,8 @@ void* behavior_run(void* arg) {
     pthread_mutex_unlock(&hruby_sim_mutex);
     // printf("#2\n");
     /* Now can start the execution of the behavior. */
-    behavior->block->function();
+    if (behavior->enabled)
+        behavior->block->function();
     // printf("#3\n");
     /* Now can start the execution of the behavior. */
     /* Stops the behavior. */
@@ -635,11 +665,35 @@ unsigned long long make_delay(int value, Unit unit) {
 
 
 
-/* Iterate over all the signals.
- * @param func function to applie on each signal. */
+/** Iterates over all the signals.
+ *  @param func function to applie on each signal. */
 void each_all_signal(void (*func)(SignalI)) {
     int i;
     for(i = 0; i<num_all_signals; ++i) {
         func(all_signals[i]);
     }
 }
+
+
+/** Configure a system instance.
+ *  @param systemI the system instance to configure.
+ *  @param idx the index of the target system. */
+void configure(SystemI systemI, int idx) {
+    int i;
+    // printf("Configure to: %i\n",idx);
+    /* Sets the current system type. */
+    systemI->system = systemI->systems[idx];
+    /* Disable all the behaviors of the system instance. */
+    for(i=0; i<systemI->num_systems; ++i) {
+        if (i != idx)
+            set_enable_system(systemI->systems[i],0);
+    }
+    /* Enable the current system. */
+    set_enable_system(systemI->systems[idx],1);
+}
+
+
+/** Terminates the simulation. */
+void terminate() {
+    exit(0);
+}

data/lib/HDLRuby/sim/hruby_sim_vcd.c

@@ -85,7 +85,7 @@ static void vcd_print_name(Object object) {
                 vcd_print("%s",name);
             } else {
                 /* No name, use the address of the object as name generator.*/
-                vcd_print("$%p",(void*)object);
+                vcd_print("x$%p",(void*)object);
             }
             break;
         default: /* Nothing to do */

data/lib/HDLRuby/std/delays.rb

@@ -0,0 +1,92 @@
+module HDLRuby::High::Std
+
+##
+# Standard HDLRuby::High library: delays
+#
+########################################################################
+
+
+    ## Module describing a simple delay using handshake for working.
+    #  @param num the number of clock cycles to delay.
+    system :delay do |num|
+        # Checks and process the number of clock to wait.
+        num = num.to_i
+        raise "The delay generic argument must be positive: #{num}" if (num < 0)
+
+        input  :clk     # The clock to make the delay on.
+        input  :req     # The handshake request.
+        output :ack     # The handshake acknoledgment.
+
+        # The process of the delay.
+        if (num == 0) then
+            # No delay case.
+            ack <= req
+        else
+            # The is a delay.
+            inner run: 0               # Tell if the deayl is running.
+            [num.width+1].inner :count # The counter for computing the delay.
+            par(clk.posedge) do
+                # Is there a request to treat?
+                hif(req & ~run) do
+                    # Yes, intialize the delay.
+                    run <= 1
+                    count <= 0
+                    ack <= 0
+                end
+                # No, maybe there is a request in processing.
+                helsif(run) do
+                    # Yes, increase the counter.
+                    count <= count + 1
+                    # Check if the delay is reached.
+                    hif(count == num-1) do
+                        # Yes, tells it and stop the count.
+                        ack <= 1
+                        run <= 0
+                    end
+                end
+            end
+        end
+    end
+
+
+
+    ## Module describing a pipeline delay (supporting multiple successive delays)
+    #  using handshake for working.
+    #  @param num the number of clock cycles to delay.
+    system :delayp do |num|
+        # Checks and process the number of clock to wait.
+        num = num.to_i
+        raise "The delay generic argument must be positive: #{num}" if (num < 0)
+
+        input  :clk          # The clock to make the delay on.
+        input  :req          # The handshake request.
+        output :ack          # The handshake acknoledgment.
+
+        if (num==0) then
+            # No delay.
+            ack <= req
+        else
+            # There is a delay.
+
+            [num].inner state: 0 # The shift register containing the progression
+                                 # of each requested delay.
+
+            # The acknoledgment is directly the last bit of the state register.
+            ack <= state[-1]
+
+
+            # The process controlling the delay.
+            seq(clk.posedge) do
+                # Update the state.
+                if (num > 1) then
+                    state <= state << 1
+                else
+                    state <= 0
+                end
+                # Handle the input.
+                ( state[0] <= 1 ).hif(req)
+            end
+        end
+    end
+
+end

data/lib/HDLRuby/std/handshakes.rb

@@ -0,0 +1,60 @@
+module HDLRuby::High::Std
+
+##
+# Standard HDLRuby::High library: handshake protocols.
+#
+########################################################################
+
+
+    ## Module describing a simple client handshake for working.
+    #  @param event the event to synchronize the handshake.
+    #  @param req   the signal telling a request is there.
+    #  @param cond  the condition allowing the protocol.
+    system :hs_client do |event, req, cond=_1|
+        input :reqI
+        output ackI: 0
+
+        # A each synchronization event.
+        par(event) do
+            # Is the protocol is allowed and a request is present.
+            hif(cond & reqI) do
+                # Yes perform the action and tell the request has been treated.
+                req  <= 1 if req
+                ackI <= 1
+            end
+            helse do
+                # No, do not perform the action, and do not acknowledge.
+                req  <= 0 if req
+                ackI <= 0
+            end
+        end
+    end
+
+
+    ## Module describing a simple server handshake for working.
+    #  @param event the event to synchronize the handshake.
+    #  @param req   the signal for asking a new request.
+    system :hs_server do |event, req|
+        output reqO: 0
+        input  :ackO
+
+        # A each synchronization event.
+        par(event) do
+            # Shall we start the output?
+            hif(ackO)  { reqO <= 0 }
+            hif(req)   { reqO <= 1 }
+        end
+    end
+
+
+    ## Module describing a pipeline with handshakes.
+    #  @param event the event to synchronize the handshakes.
+    #  @param read  the signal telling there is a request from the client side
+    #  @param write the signal used for asking the server to issue a request
+    system :hs_pipe do |event,read,write|
+        inner :cond
+        include(hs_client(event,read,cond))
+        include(hs_server(event,write))
+        cond <= ~reqO
+    end
+end