HDLRuby 2.11.4 → 2.11.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b3303f28a79a14a42fb2421335afdbaa40c148440e622edaca2f8a98804192d
-  data.tar.gz: 12dd7c5fd160141c151db950b7d797ef53bf012549ef983f8cf1b648edb3a85e
+  metadata.gz: 450d4465eb4fb71c70d61bdadf5bd0d944b5b8c7f7f9f3d02f847d670eb74f76
+  data.tar.gz: b3cf3b934d8a50f6d85ffc74f3a34b0cfd2f074d472d2f6a8b93b4324cc2e5bd
 SHA512:
-  metadata.gz: 94ba5098e5e8003f64c53f86ba47f8e831e3e49d39aa4f8991f3595dfec560749079720a6602bf76f2e31eacf88c922a0c689bf575e2ec17a48256dba70010d0
-  data.tar.gz: 1856330cc10987e979ed13211d3a6aaaa1f382bfe9a6831a4a235eac35ea912844c5ca9b667f2a899b87a47518c29e38cb8c9b7c6a5ee27e953872fb810b8f30
+  metadata.gz: 667da8c2f678834407374f739ea4d0094803e82145b1485aa2b53bcef54f04b368668ad62996aaa67ae48b0e80fb9c9c9f731131e3eeb6c69c5c23363b2242e7
+  data.tar.gz: 39ae4cea2c84140063b601b5c3f171462db40a41b01739894daa95b90cec6dd8c87780cc86f65ff269a0d7fb4478412d06c114d4c3a921ade691c6c3d9868110

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -299,11 +299,14 @@ VALUE rcsim_make_event(VALUE mod, VALUE typeV, VALUE sigV) {
 }
 
 
+static size_t last_signal_id = 0;
+
 /* Creating a signal C object. */
 VALUE rcsim_make_signal(VALUE mod, VALUE name, VALUE type) {
     // printf("rcsim_make_signal\n");
     /* Allocates the signal. */
     SignalI signal = (SignalI)malloc(sizeof(SignalIS));
+    signal->id = last_signal_id++;
     // printf("signal=%p\n",signal);
     /* Set it up. */
     signal->kind = SIGNALI;

data/ext/hruby_sim/hruby_sim.h

@@ -524,6 +524,8 @@ typedef struct SignalIS_ {
     Object* pos;        /* The objects actvated on pos edge. */
     int num_neg;        /* The number of behavior activated on neg edge. */
     Object* neg;        /* The objects actvated on neg edge. */
+
+    size_t id;          /* The identity of the signal. */
 } SignalIS;
 
 

data/ext/hruby_sim/hruby_sim_core.c

@@ -62,7 +62,8 @@ static pthread_cond_t hruby_beh_cond = PTHREAD_COND_INITIALIZER;
 static pthread_cond_t hruby_sim_cond = PTHREAD_COND_INITIALIZER;
 
 /** Flags for the simulation. */
-static int sim_end_flag = 0;
+static int sim_single_flag = 0; /* Run in single timed behavior mode. */
+static int sim_end_flag = 0;    /* Ending the simulation. */
 
 /** Adds a timed behavior for processing. 
  *  @param behavior the timed behavior to register */
@@ -422,6 +423,21 @@ void* behavior_run(void* arg) {
     pthread_exit(NULL);
 }
 
+/** Starts a signle timed behavior to run without the multi-threaded engine. */
+void hruby_sim_start_single_timed_behavior() {
+    int i;
+    // printf("hruby_sim_start_single_timed_behaviors\n");fflush(stdout);
+    /* Set in mono-thread mode. */
+    sim_single_flag = 1;
+    Behavior behavior = timed_behaviors[0];
+    /* Simply run the timed behavior. */
+#ifdef RCSIM
+        execute_statement((Statement)(behavior->block),0,behavior);
+#else
+        behavior->block->function();
+#endif
+}
+
 
 /** Starts the timed behaviors.
  *  @note create a thread per timed behavior. */
@@ -473,37 +489,46 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
     /* Initialize the time to 0. */
     hruby_sim_time = 0;
 
-    /* Start all the timed behaviors. */
-    hruby_sim_start_timed_behaviors();
-    // /* Activate the timed behavior that are on time. */
-    // hruby_sim_activate_behaviors_on_time();
-
-    /* Run while there are active behaviors and the time limit is not 
-     * reached */
-    while(hruby_sim_time<limit) {
-        int i;
-        // printf("num_active_behaviors = %d\n",num_active_behaviors);
-        /* Wait for the active timed behaviors to perform their computations. */
-        hruby_sim_wait_behaviors();
-        /* Update the signal values (recursively executing blocks locked
-         * on the signals). */
+    if (num_timed_behaviors == 1) {
+        /* Initialize and touch all the signals. */
         hruby_sim_update_signals(); 
-        if (hruby_sim_time == 0) {
-            /* Initially touch all the signals. */
-            each_all_signal(&touch_signal);
-        }
-        // printf("num_run_behavior=%d\n",num_run_behaviors);
-        if (num_run_behaviors <= 0) break;
-        /* Advance time to next timestep. */
-        hruby_sim_advance_time();
+        each_all_signal(&touch_signal);
+        /* Only one timed behavior, no need of the multi-threaded engine. */
+        hruby_sim_start_single_timed_behavior();
+    } else {
+        /* Use the multi-threaded engine. */
+        /* Start all the timed behaviors. */
+        hruby_sim_start_timed_behaviors();
+        // /* Activate the timed behavior that are on time. */
+        // hruby_sim_activate_behaviors_on_time();
+
+        /* Run while there are active behaviors and the time limit is not 
+         * reached */
+        while(hruby_sim_time<limit) {
+            int i;
+            // printf("num_active_behaviors = %d\n",num_active_behaviors);
+            /* Wait for the active timed behaviors to perform their computations. */
+            hruby_sim_wait_behaviors();
+            /* Update the signal values (recursively executing blocks locked
+             * on the signals). */
+            hruby_sim_update_signals(); 
+            if (hruby_sim_time == 0) {
+                /* Initially touch all the signals. */
+                each_all_signal(&touch_signal);
+            }
+            // printf("num_run_behavior=%d\n",num_run_behaviors);
+            if (num_run_behaviors <= 0) break;
+            /* Advance time to next timestep. */
+            hruby_sim_advance_time();
+
+            /* Mark the signals as fading. */
+            for(i=0; i<num_all_signals; ++i) {
+                all_signals[i]->fading = 1;
+            }
 
-        /* Mark the signals as fading. */
-        for(i=0; i<num_all_signals; ++i) {
-            all_signals[i]->fading = 1;
+            /* Activate the timed behavior that are on time. */
+            hruby_sim_activate_behaviors_on_time();
         }
-
-        /* Activate the timed behavior that are on time. */
-        hruby_sim_activate_behaviors_on_time();
     }
 }
 
@@ -521,29 +546,38 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
  *  @param delay the delay to wait in ps.
  *  @param behavior the current behavior. */
 void hw_wait(unsigned long long delay, Behavior behavior) {
-    /* Maybe the thread is to end immediatly. */
-    if (sim_end_flag)
-        pthread_exit(NULL);
-    /* No go on with the wait procedure. */
-    pthread_mutex_lock(&hruby_sim_mutex);
-    /* Indicate the behavior finished current execution. */
-    num_active_behaviors -= 1;
-    // printf("!!num_active_behaviors=%d\n",num_active_behaviors);
-    // pthread_cond_signal(&hruby_sim_cond);
-    /* Update the behavior's time. */
-    behavior->active_time += delay;
-    pthread_mutex_unlock(&hruby_sim_mutex);
-    pthread_cond_signal(&hruby_sim_cond);
-    /* Wait for being reactivated. */
-    while(behavior->active_time > hruby_sim_time) {
+    /* Is it in single timed behavior mode? */
+    if (sim_single_flag) {
+        /* Yes, simply update signals and advance time. */
+        behavior->active_time += delay;
+        hruby_sim_update_signals(); 
+        hruby_sim_advance_time();
+    } else {
+        /* No, handle the multi-threading. */
+        /* Maybe the thread is to end immediatly. */
+        if (sim_end_flag)
+            pthread_exit(NULL);
+        /* No go on with the wait procedure. */
         pthread_mutex_lock(&hruby_sim_mutex);
-        while(!behaviors_can_run) {
-            // printf("!1\n");
-            // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
-            pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
-            // printf("!2\n");
-        }
+        /* Indicate the behavior finished current execution. */
+        num_active_behaviors -= 1;
+        // printf("!!num_active_behaviors=%d\n",num_active_behaviors);
+        // pthread_cond_signal(&hruby_sim_cond);
+        /* Update the behavior's time. */
+        behavior->active_time += delay;
         pthread_mutex_unlock(&hruby_sim_mutex);
+        pthread_cond_signal(&hruby_sim_cond);
+        /* Wait for being reactivated. */
+        while(behavior->active_time > hruby_sim_time) {
+            pthread_mutex_lock(&hruby_sim_mutex);
+            while(!behaviors_can_run) {
+                // printf("!1\n");
+                // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
+                pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
+                // printf("!2\n");
+            }
+            pthread_mutex_unlock(&hruby_sim_mutex);
+        }
     }
 }
 

data/ext/hruby_sim/hruby_sim_vcd.c

@@ -98,7 +98,6 @@ static void vcd_print_name(Object object) {
  *  @param object the object to print the name. */
 static void vcd_print_full_name(Object object) {
     /* Recurse on the owner if any. */
-    // printf("owner=%p\n",object->owner);
     if (object->owner != NULL) {
         vcd_print_full_name(object->owner);
         vcd_print("$");
@@ -107,12 +106,23 @@ static void vcd_print_full_name(Object object) {
     vcd_print_name(object);
 }
 
+/** Prints the id of a signal in vcd indentifier format.
+ *  @param signal the signal to print the id. */
+static void vcd_print_signal_id(SignalI signal) {
+    size_t id = signal->id;
+    do {
+        vcd_print("%c",(id % (127-33)) + 33);
+        id = id / (127-33);
+    } while (id > 0);
+}
+
 /** Prints a value.
  *  @param value the value to print */
 static void vcd_print_value(Value value) {
-    vcd_print("b");
+    unsigned long long width = type_width(value->type);
+    if (width > 1) vcd_print("b");
     if (value->numeric) {
-        unsigned long long width = type_width(value->type);
+        // unsigned long long width = type_width(value->type);
         unsigned long long mask = 1ULL << (width-1);
         for(; mask > 0; mask >>= 1) {
             vcd_print("%d",(value->data_int & mask) != 0);
@@ -120,7 +130,7 @@ static void vcd_print_value(Value value) {
     } else {
         /* Display a bitstring value. */
         unsigned long long i;
-        unsigned long long width = type_width(value->type);
+        // unsigned long long width = type_width(value->type);
         char* data = value->data_str;
         if (value->capacity == 0) {
             /* The value is empty, therefore undefined. */
@@ -135,13 +145,15 @@ static void vcd_print_value(Value value) {
             } 
         }
     }
+    if (width > 1) vcd_print(" ");
 }
 
 /** Prints a signal declaration.
  *  @param signal the signal to declare */
 static void vcd_print_var(SignalI signal) {
     vcd_print("$var wire %d ",type_width(signal->type));
-    vcd_print_full_name((Object)signal);
+    // vcd_print_full_name((Object)signal);
+    vcd_print_signal_id(signal);
     vcd_print(" ");
     vcd_print_name((Object)signal);
     vcd_print(" $end\n");
@@ -153,8 +165,9 @@ static void vcd_print_var(SignalI signal) {
 static void vcd_print_signal_fvalue(SignalI signal) {
     if (signal->f_value) {
         vcd_print_value(signal->f_value);
-        vcd_print(" ");
-        vcd_print_full_name((Object)signal);
+        // vcd_print(" ");
+        // vcd_print_full_name((Object)signal);
+        vcd_print_signal_id(signal);
         vcd_print("\n");
     }
 }
@@ -165,8 +178,9 @@ static void vcd_print_signal_fvalue(SignalI signal) {
 static void vcd_print_signal_cvalue(SignalI signal) {
     if (signal->c_value) {
         vcd_print_value(signal->c_value);
-        vcd_print(" ");
-        vcd_print_full_name((Object)signal);
+        // vcd_print(" ");
+        // vcd_print_full_name((Object)signal);
+        vcd_print_signal_id(signal);
         vcd_print("\n");
     }
 }

data/lib/HDLRuby/hruby_low2c.rb

@@ -843,6 +843,9 @@ module HDLRuby::Low
     ## Extends the SignalI class with generation of C text.
     class SignalI
 
+        # The id of a signal in the simulator.
+        @@signal_id = 0
+
         ## Generates the C text for an access to the signal.
         #  +level+ is the hierachical level of the object.
         # def to_c_signal(level = 0)
@@ -881,6 +884,8 @@ module HDLRuby::Low
             res << "SignalI signalI = malloc(sizeof(SignalIS));\n"
             res << " " * (level+1)*3
             res << "signalI->kind = SIGNALI;\n";
+            res << "signalI->id = #{@@signal_id};\n"
+            @@signal_id = @@signal_id+1;
 
             # Sets the global variable of the signal.
             res << "\n"

data/lib/HDLRuby/hruby_rsim.rb

@@ -16,6 +16,9 @@ module HDLRuby::High
     # Enhance a system type with Ruby simulation.
     class SystemT
 
+        # Tell if the simulation is in multithread mode or not.
+        attr_reader :multithread
+
         ## Add timed behavior +beh+.
         #  Returns the id of the timed behavior.
         def add_timed_behavior(beh)
@@ -36,6 +39,50 @@ module HDLRuby::High
             @sig_active << sig
         end
 
+        ## Advance the global simulator.
+        def advance
+            # Display the time
+            self.show_time
+            shown_values = {}
+            # Get the behaviors waiting on activated signals.
+            until @sig_active.empty? do
+                # # Update the signals.
+                # @sig_active.each { |sig| sig.c_value = sig.f_value }
+                # puts "sig_active.size=#{@sig_active.size}"
+                # Look for the behavior sensitive to the signals.
+                @sig_active.each do |sig|
+                    sig.each_anyedge { |beh| @sig_exec << beh }
+                    if (sig.c_value.zero? && !sig.f_value.zero?) then
+                        # puts "sig.c_value=#{sig.c_value.content}"
+                        sig.each_posedge { |beh| @sig_exec << beh }
+                    elsif (!sig.c_value.zero? && sig.f_value.zero?) then
+                        sig.each_negedge { |beh| @sig_exec << beh }
+                    end
+                end
+                # Update the signals.
+                @sig_active.each { |sig| sig.c_value = sig.f_value }
+                # puts "first @sig_exec.size=#{@sig_exec.size}"
+                @sig_exec.uniq! {|beh| beh.object_id }
+                # Display the activated signals.
+                @sig_active.each do |sig|
+                    if !shown_values[sig].eql?(sig.f_value) then
+                        self.show_signal(sig) 
+                        shown_values[sig] = sig.f_value
+                    end
+                end
+                # Clear the list of active signals.
+                @sig_active.clear
+                # puts "sig_exec.size=#{@sig_exec.size}"
+                # Execute the relevant behaviors and connections.
+                @sig_exec.each { |obj| obj.execute(:par) }
+                @sig_exec.clear
+                @sig_active.uniq! {|sig| sig.object_id }
+                # puts "@sig_active.size=#{@sig_active.size}"
+                # Advance time.
+                @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
+            end
+        end
+
         ## Run the simulation from the current systemT and outputs the resuts
         #  on simout.
         def sim(simout)
@@ -43,15 +90,6 @@ module HDLRuby::High
             HDLRuby.show "#{Time.now}#{show_mem}"
             # Merge the included.
             self.merge_included!
-            # Initializes the run mutex and the conditions.
-            @mutex = Mutex.new
-            @master = ConditionVariable.new
-            @master_flag = 0
-            @slave = ConditionVariable.new
-            @slave_flags_not = 0
-            @num_done = 0
-            # @lock = 0
-            # @runs = 0
             # Initializes the time.
             @time = 0
             # Initializes the time and signals execution buffers.
@@ -68,72 +106,93 @@ module HDLRuby::High
             self.init_sim(self)
             # Initialize the displayer.
             self.show_init(simout)
-            # exit
-            # First all the timed behaviors are to be executed.
-            @timed_behaviors.each {|beh| @tim_exec << beh }
-            # But starts locked.
-            @slave_flags_not = 2**@timed_behaviors.size - 1
-            # Starts the threads.
-            @timed_behaviors.each {|beh| beh.make_thread }
-
-            HDLRuby.show "Starting Ruby-level simulator..."
-            HDLRuby.show "#{Time.now}#{show_mem}"
-            # Run the simulation.
-            self.run_init do
-                # # Wake the behaviors.
-                # @timed_behaviors.each {|beh| beh.run }
-                until @tim_exec.empty? do
-                    # Display the time
-                    self.show_time
-                    # Execute the time behaviors that are ready.
-                    self.run_ack
-                    self.run_wait
-                    shown_values = {}
-                    # Get the behaviors waiting on activated signals.
-                    until @sig_active.empty? do
-                        # # Update the signals.
-                        # @sig_active.each { |sig| sig.c_value = sig.f_value }
-                        # puts "sig_active.size=#{@sig_active.size}"
-                        # Look for the behavior sensitive to the signals.
-                        @sig_active.each do |sig|
-                            sig.each_anyedge { |beh| @sig_exec << beh }
-                            if (sig.c_value.zero? && !sig.f_value.zero?) then
-                                # puts "sig.c_value=#{sig.c_value.content}"
-                                sig.each_posedge { |beh| @sig_exec << beh }
-                            elsif (!sig.c_value.zero? && sig.f_value.zero?) then
-                                sig.each_negedge { |beh| @sig_exec << beh }
-                            end
-                        end
-                        # Update the signals.
-                        @sig_active.each { |sig| sig.c_value = sig.f_value }
-                        # puts "first @sig_exec.size=#{@sig_exec.size}"
-                        @sig_exec.uniq! {|beh| beh.object_id }
-                        # Display the activated signals.
-                        @sig_active.each do |sig|
-                            if !shown_values[sig].eql?(sig.f_value) then
-                                self.show_signal(sig) 
-                                shown_values[sig] = sig.f_value
-                            end
+
+            # Is there more than one timed behavior.
+            if @total_timed_behaviors <= 1 then
+                # No, no need of multithreading.
+                @multithread = false
+                # Simple execute the block of the behavior.
+                @timed_behaviors[0].block.execute(:seq)
+            else
+                # Yes, need of multithreading.
+                @multithread = true
+                # Initializes the run mutex and the conditions.
+                @mutex = Mutex.new
+                @master = ConditionVariable.new
+                @master_flag = 0
+                @slave = ConditionVariable.new
+                @slave_flags_not = 0
+                @num_done = 0
+
+                # First all the timed behaviors are to be executed.
+                @timed_behaviors.each {|beh| @tim_exec << beh }
+                # But starts locked.
+                @slave_flags_not = 2**@timed_behaviors.size - 1
+                # Starts the threads.
+                @timed_behaviors.each {|beh| beh.make_thread }
+
+                HDLRuby.show "Starting Ruby-level simulator..."
+                HDLRuby.show "#{Time.now}#{show_mem}"
+                # Run the simulation.
+                self.run_init do
+                    # # Wake the behaviors.
+                    # @timed_behaviors.each {|beh| beh.run }
+                    until @tim_exec.empty? do
+                        # Execute the time behaviors that are ready.
+                        self.run_ack
+                        self.run_wait
+                        # Advance the global simulator.
+                        self.advance
+                        # # Display the time
+                        # self.show_time
+                        # shown_values = {}
+                        # # Get the behaviors waiting on activated signals.
+                        # until @sig_active.empty? do
+                        #     # # Update the signals.
+                        #     # @sig_active.each { |sig| sig.c_value = sig.f_value }
+                        #     # puts "sig_active.size=#{@sig_active.size}"
+                        #     # Look for the behavior sensitive to the signals.
+                        #     @sig_active.each do |sig|
+                        #         sig.each_anyedge { |beh| @sig_exec << beh }
+                        #         if (sig.c_value.zero? && !sig.f_value.zero?) then
+                        #             # puts "sig.c_value=#{sig.c_value.content}"
+                        #             sig.each_posedge { |beh| @sig_exec << beh }
+                        #         elsif (!sig.c_value.zero? && sig.f_value.zero?) then
+                        #             sig.each_negedge { |beh| @sig_exec << beh }
+                        #         end
+                        #     end
+                        #     # Update the signals.
+                        #     @sig_active.each { |sig| sig.c_value = sig.f_value }
+                        #     # puts "first @sig_exec.size=#{@sig_exec.size}"
+                        #     @sig_exec.uniq! {|beh| beh.object_id }
+                        #     # Display the activated signals.
+                        #     @sig_active.each do |sig|
+                        #         if !shown_values[sig].eql?(sig.f_value) then
+                        #             self.show_signal(sig) 
+                        #             shown_values[sig] = sig.f_value
+                        #         end
+                        #     end
+                        #     # Clear the list of active signals.
+                        #     @sig_active.clear
+                        #     # puts "sig_exec.size=#{@sig_exec.size}"
+                        #     # Execute the relevant behaviors and connections.
+                        #     @sig_exec.each { |obj| obj.execute(:par) }
+                        #     @sig_exec.clear
+                        #     @sig_active.uniq! {|sig| sig.object_id }
+                        #     # puts "@sig_active.size=#{@sig_active.size}"
+                        # end
+
+                        # # Advance time.
+                        # @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
+                        break if @timed_behaviors.empty?
+                        # Schedule the next timed behavior to execute.
+                        @tim_exec = []
+                        @timed_behaviors.each do |beh|
+                            @tim_exec << beh if beh.time == @time
                         end
-                        # Clear the list of active signals.
-                        @sig_active.clear
-                        # puts "sig_exec.size=#{@sig_exec.size}"
-                        # Execute the relevant behaviors and connections.
-                        @sig_exec.each { |obj| obj.execute(:par) }
-                        @sig_exec.clear
-                        @sig_active.uniq! {|sig| sig.object_id }
-                        # puts "@sig_active.size=#{@sig_active.size}"
-                    end
-                    break if @timed_behaviors.empty?
-                    # Advance time.
-                    @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
-                    # Schedule the next timed behavior to execute.
-                    @tim_exec = []
-                    @timed_behaviors.each do |beh|
-                        @tim_exec << beh if beh.time == @time
+                        # puts "@tim_exec.size=#{@tim_exec.size}"
+                        # puts "@timed_bevaviors.size=#{@timed_behaviors.size}"
                     end
-                    # puts "@tim_exec.size=#{@tim_exec.size}"
-                    # puts "@timed_bevaviors.size=#{@timed_behaviors.size}"
                 end
             end
         end
@@ -358,7 +417,8 @@ module HDLRuby::High
                     begin
                         # puts "Starting thread"
                         systemT.run_req(@id)
-                        self.block.execute(:par)
+                        # self.block.execute(:par)
+                        self.block.execute(:seq)
                         # puts "Ending thread"
                     rescue => e
                         puts "Got exception: #{e.full_message}"
@@ -690,10 +750,16 @@ module HDLRuby::High
         def execute(mode)
             @behavior ||= self.behavior
             @behavior.time += self.delay.time_ps
-            # puts "Stopping #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
-            @sim.run_done(@behavior.id)
-            # puts "Rerunning #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
-            @sim.run_req(@behavior.id)
+            if @sim.multithread then
+                # Multi thread mode: synchronize.
+                # puts "Stopping #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
+                @sim.run_done(@behavior.id)
+                # puts "Rerunning #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
+                @sim.run_req(@behavior.id)
+            else
+                # No thread mode, need to advance the global simulator.
+                @sim.advance
+            end
         end
     end
 

data/lib/HDLRuby/hruby_rsim_vcd.rb

@@ -11,6 +11,35 @@ module HDLRuby::High
         return name.to_s.gsub(/[^a-zA-Z0-9_$]/,"$")
     end
 
+    ## Converts a bit string to a vcd format.
+    def self.vcd_bitstr(str)
+        if str.length > 1 then
+            return "b" + str + " "
+        else
+            return str
+        end
+    end
+
+    ## Converts a HDLRuby object to a VCD id string.
+    @@rsim_object_idstr = { }
+    @@rsim_object_idstr_count = 0
+    def self.vcd_idstr(obj)
+        idstr = @@rsim_object_idstr[obj]
+        unless idstr then
+            # Must generate a new id string.
+            chars = []
+            id = @@rsim_object_idstr_count
+            @@rsim_object_idstr_count += 1
+            loop do
+                chars << ((id % (127-33)) + 33).chr
+                break if ((id=id/(127-33)) == 0)
+            end
+            idstr = chars.join
+            @@rsim_object_idstr[obj] = idstr
+        end
+        return idstr
+    end
+
     ##
     # Enhance the system type class with VCD support.
     class SystemT
@@ -40,14 +69,24 @@ module HDLRuby::High
             # Closes the header.
             @vcdout << "$enddefinitions $end\n"
             # Initializes the variables with their name.
-            @vars_with_fullname = self.get_vars_with_fullname
+            # @vars_with_fullname = self.get_vars_with_fullname
+            @vars_with_idstr = self.get_vars_with_idstr
             @vcdout << "$dumpvars\n"
-            @vars_with_fullname.each_pair do |sig,fullname|
+            # @vars_with_fullname.each_pair do |sig,fullname|
+            #     if sig.f_value then
+            #         @vcdout << "   b#{sig.f_value.to_vstr} #{fullname}\n"
+            #     else
+            #         @vcdout << "   b#{"x"} #{fullname}\n"
+            #     end
+            # end
+            @vars_with_idstr.each_pair do |sig,idstr|
                 if sig.f_value then
-                    @vcdout << "   b#{sig.f_value.to_vstr} #{fullname}\n"
+                    # @vcdout << "   b#{sig.f_value.to_vstr} #{idstr}\n"
+                    @vcdout << HDLRuby::High.vcd_bitstr(sig.f_value.to_vstr) <<
+                               idstr << "\n"
                 else
-                    # @vcdout << "   b#{"x"*sig.type.width} #{fullname}\n"
-                    @vcdout << "   b#{"x"} #{fullname}\n"
+                    # @vcdout << "   b#{"x"} #{idstr}\n"
+                    @vcdout << HDLRuby::High.vcd_bitstr("x") << idstr << "\n"
                 end
             end
             @vcdout << "$end\n"
@@ -63,6 +102,16 @@ module HDLRuby::High
             return self.scope.get_vars_with_fullname(vars_with_fullname)
         end
 
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Adds the signals of the interface of the system.
+            self.each_signal do |sig|
+                vars_with_idstr[sig] = HDLRuby::High.vcd_idstr(sig)
+            end
+            # Recurse on the scope.
+            return self.scope.get_vars_with_idstr(vars_with_idstr)
+        end
+
         ## Shows the hierarchy of the variables.
         def show_hierarchy(vcdout)
             # puts "show_hierarchy for module #{self} (#{self.name})"
@@ -72,7 +121,8 @@ module HDLRuby::High
             self.each_signal do |sig|
                 # puts "showing signal #{HDLRuby::High.vcd_name(sig.fullname)}"
                 vcdout << "$var wire #{sig.type.width} "
-                vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                # vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                vcdout << "#{HDLRuby::High.vcd_idstr(sig)} "
                 vcdout << "#{HDLRuby::High.vcd_name(sig.name)} $end\n"
             end
             # Recurse on the scope.
@@ -88,8 +138,9 @@ module HDLRuby::High
 
         ## Displays the value of signal +sig+.
         def show_signal(sig)
-            @vcdout << "b#{sig.f_value.to_vstr} "
-            @vcdout << "#{@vars_with_fullname[sig]}\n"
+            # @vcdout << "b#{sig.f_value.to_vstr} "
+            @vcdout << HDLRuby::High.vcd_bitstr(sig.f_value.to_vstr)
+            @vcdout << "#{@vars_with_idstr[sig]}\n"
         end
 
         ## Displays value +val+.
@@ -121,7 +172,8 @@ module HDLRuby::High
             self.each_inner do |sig|
                 # puts "showing inner signal #{HDLRuby::High.vcd_name(sig.fullname)}"
                 vcdout << "$var wire #{sig.type.width} "
-                vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                # vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                vcdout << "#{HDLRuby::High.vcd_idstr(sig)} "
                 vcdout << "#{HDLRuby::High.vcd_name(sig.name)} $end\n"
             end
             # Recurse on the behaviors' blocks
@@ -162,6 +214,27 @@ module HDLRuby::High
             end
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Adds the inner signals.
+            self.each_inner do |sig|
+                vars_with_idstr[sig] = HDLRuby::High.vcd_idstr(sig)
+            end
+            # Recurse on the behaviors' blocks
+            self.each_behavior do |beh|
+                beh.block.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recurse on the systemI's Eigen system.
+            self.each_systemI do |sys|
+                sys.systemT.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recurse on the subscopes.
+            self.each_scope do |scope|
+                scope.get_vars_with_idstr(vars_with_idstr)
+            end
+            return vars_with_idstr
+        end
     end
 
 
@@ -177,6 +250,11 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
     ##
@@ -192,6 +270,11 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their idstr.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
     ##
@@ -206,6 +289,11 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
     ##
@@ -220,6 +308,11 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
 
@@ -238,7 +331,8 @@ module HDLRuby::High
             self.each_inner do |sig|
                 # puts "showing inner signal #{HDLRuby::High.vcd_name(sig.fullname)}"
                 vcdout << "$var wire #{sig.type.width} "
-                vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                # vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                vcdout << "#{HDLRuby::High.vcd_idstr(sig)} "
                 vcdout << "#{HDLRuby::High.vcd_name(sig.name)} $end\n"
             end
             # Recurse on the statements
@@ -263,6 +357,19 @@ module HDLRuby::High
             end
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Adds the inner signals.
+            self.each_inner do |sig|
+                vars_with_idstr[sig] = HDLRuby::High.vcd_idstr(sig)
+            end
+            # Recurse on the statements.
+            self.each_statement do |stmnt|
+                stmnt.get_vars_with_idstr(vars_with_idstr)
+            end
+            return vars_with_idstr
+        end
     end
 
 
@@ -307,6 +414,19 @@ module HDLRuby::High
             self.no.get_vars_with_fullname(vars_with_fullname) if self.no
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Recurse on the yes.
+            self.yes.get_vars_with_idstr(vars_with_idstr)
+            # Recurse on the noifs.
+            self.each_noif do |cond,stmnt|
+                stmnt.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recure on the no if any.
+            self.no.get_vars_with_idstr(vars_with_idstr) if self.no
+            return vars_with_idstr
+        end
     end
 
 
@@ -333,5 +453,41 @@ module HDLRuby::High
             self.default.get_vars_with_fullname(vars_with_fullname)
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Recurse on each when.
+            self.each_when do |w|
+                w.statement.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recurse on the default if any.
+            self.default.get_vars_with_idstr(vars_with_idstr)
+            return vars_with_idstr
+        end
+    end
+
+    ##
+    # Enhance the TimeRepeat class with VCD support.
+    class TimeRepeat
+        ## Shows the hierarchy of the variables.
+        def show_hierarchy(vcdout)
+            # Recurse on the statement.
+            self.statement.show_hierarchy(vcdout)
+        end
+
+        ## Gets the VCD variables with their long name.
+        def get_vars_with_fullname(vars_with_fullname = {})
+            # Recurse on the statement.
+            self.statement.get_vars_with_fullname(vars_with_fullname)
+            return vars_with_fullname
+        end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Recurse on the statement.
+            self.statement.get_vars_with_idstr(vars_with_idstr)
+            return vars_with_idstr
+        end
     end
+
 end

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.11.4"
+  VERSION = "2.11.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.11.4
+  version: 2.11.5
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-11 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler