HDLRuby 2.11.4 → 2.11.7

data/ext/hruby_sim/hruby_sim_core.c

@@ -35,6 +35,15 @@ static List touched_signals_seq = &touched_signals_seq_content;
 static ListS activate_codes_content = { NULL, NULL }; 
 static List activate_codes = &activate_codes_content;
 
+
+/** The number of behavior to run for initialization (not the timed ones!). */
+static int num_init_behaviors = 0;
+/** The capacity of teh behavior to run for initialization. */
+static int cap_init_behaviors = 0;
+/** The behaviors to run for initialization (not the timed ones!). */
+static Behavior* init_behaviors = 0;
+
+
 /** The number of timed behaviors. */
 static int num_timed_behaviors = 0;
 /** The capacity of the timed behaviors. */
@@ -62,7 +71,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 */
@@ -87,12 +97,33 @@ void register_timed_behavior(Behavior behavior) {
 }
 
 
+/** Adds a behavior for initialization (not timed!).
+ *  @param beh the behavior to register. */
+void register_init_behavior(Behavior beh) {
+    if (num_init_behaviors == cap_init_behaviors) {
+        if (cap_init_behaviors == 0) {
+            /* Need to create the array containing the behaviors. */
+            cap_init_behaviors = 100;
+            init_behaviors = calloc(cap_init_behaviors,sizeof(Behavior));
+        } else {
+            /* Need to increase the capacity. */
+            Behavior* new_behs = calloc(cap_init_behaviors*2,sizeof(Behavior));
+            memcpy(new_behs,init_behaviors,sizeof(Behavior[cap_init_behaviors]));
+            cap_init_behaviors *= 2;
+            init_behaviors=new_behs;
+        }
+    }
+    /* Add the behavior. */
+    init_behaviors[num_init_behaviors++] = beh;
+}
+
+
 /** Adds a signal for global processing. 
  *  @param signal the signal to register  */
 void register_signal(SignalI signal) {
     if (num_all_signals == cap_all_signals) {
         if (cap_all_signals == 0) {
-            /* Need to create the array containing the timed behaviors. */
+            /* Need to create the array containing the signals. */
             cap_all_signals = 100;
             all_signals = calloc(cap_all_signals,sizeof(SignalI));
         } else {
@@ -109,6 +140,24 @@ void register_signal(SignalI signal) {
 }
 
 
+
+/** Initial run of the behaviors to init. */
+void run_init_behaviors() {
+    int i;
+    for(i = 0; i<num_init_behaviors; ++i) {
+        Behavior beh = init_behaviors[i];
+#ifdef RCSIM
+        // printf("Going to initialize behavior=%p with block=%p\n",beh,beh->block);fflush(stdout);
+        execute_statement((Statement)(beh->block),0,beh);
+#else
+        beh->block->function();
+#endif
+    }
+}
+
+
+
+
 /** Recursively update the signals until no (untimed) behavior are
  *  activated. */
 void hruby_sim_update_signals() {
@@ -303,6 +352,8 @@ void hruby_sim_advance_time() {
         if (timed_behaviors[i]->timed == 1)
             if (beh_time < next_time) next_time = beh_time;
     }
+    /* Mark again all the signals as fading. */
+    for(i=0; i<num_all_signals; ++i) all_signals[i]->fading = 1;
     // printf("hruby_sim_time=%llu next_time=%llu\n",hruby_sim_time,next_time);
     /* Sets the new activation time. */
     hruby_sim_time = next_time;
@@ -422,6 +473,20 @@ 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() {
+    // 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 +538,51 @@ 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);
+        run_init_behaviors();
+        /* Only one timed behavior, no need of the multi-threaded engine. */
+        hruby_sim_start_single_timed_behavior();
+    } else {
+        /* Use the multi-threaded engine. */
+        /* Initialize and touch all the signals. */
+        hruby_sim_update_signals(); 
+        // each_all_signal(&touch_signal);
+        run_init_behaviors();
+        /* 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 +600,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);
+        }
     }
 }
 
@@ -563,6 +651,7 @@ void touch_signal(SignalI signal) {
  *  @param value the value to transmit
  *  @param signal the signal to transmit the value to. */
 void transmit_to_signal(Value value, SignalI signal) {
+    // printf("Tansmit to signal: %s(%p)\n",signal->name,signal);
     /* Copy the content. */
     if (signal->fading)
         signal->f_value = copy_value(value,signal->f_value);
@@ -684,7 +773,6 @@ unsigned long long make_delay(int value, Unit unit) {
 
 
 
-
 /** Iterates over all the signals.
  *  @param func function to applie on each signal. */
 void each_all_signal(void (*func)(SignalI)) {

data/ext/hruby_sim/hruby_sim_mute.c

@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h>
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby simulation mute output engine, to be used with C code
+ *  generated by the csim engine or by the rcsim engine. 
+ **/
+
+/* Global variables storing the configuration of the vcd generation. */
+
+
+
+/* Low-end print functions. */
+
+/** Prints the time.
+ *  @param time the time to show (given in ps). */
+static void mute_print_time(unsigned long long time) {
+}
+
+/** Prints the name of an object without its hierarchy.
+ *  @param object the object to print the name. */
+static void mute_print_name(Object object) {
+}
+
+/** Prints the full name of an object without its hierarchy.
+ *  @param object the object to print the name. */
+static void mute_print_full_name(Object object) {
+}
+
+/** Prints a value.
+ *  @param value the value to print */
+static void mute_print_value(Value value) {
+}
+
+/** Prints a signal with its future value if any.
+ *  @param signal the signal to show */
+static void mute_print_signal_fvalue(SignalI signal) {
+}
+
+/** Prints a signal with its current value if any
+ *  @param signal the signal to show */
+static void mute_print_signal_cvalue(SignalI signal) {
+}
+
+
+
+/* The configuration and initialization of the vcd vizualizer. */
+
+
+/** Sets up the mute vizualization engine.
+ *  @param name the name of the vizualization. */
+extern void init_mute_visualizer(char* name) {
+    /* Initialize the vizualizer printer engine. */
+    init_visualizer(&mute_print_time,
+                    &mute_print_full_name,
+                    &mute_print_value,
+                    &mute_print_signal_fvalue,
+                    &default_print_string,
+                    &default_print_name,
+                    &default_print_value);
+}

data/ext/hruby_sim/hruby_sim_stack_calc.c

@@ -106,6 +106,16 @@ Value binary(Value (*oper)(Value,Value,Value)) {
     return oper(l,r,peek());
 }
 
+/** Selection calculation.
+ * @param num the number of choices to select within. */
+Value select(unsigned int num) {
+    Value* vals = alloca(num*sizeof(Value));
+    int i;
+    /* Get the values to concat from the stack. */
+    for(i=1;i<=num;++i) vals[num-i] = pop();
+    return select_valueP(pop(),peek(),num,vals);
+}
+
 /** Cast calculation.
  *  @param typ the type to cast to.
  *  @return the destination.

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -46,11 +46,38 @@ Value calc_expression(Expression expr, Value res) {
                 Value right = get_value();
                 left = calc_expression(bexpr->left,left);
                 right = calc_expression(bexpr->right,right);
+                // printf("left=%.*s\n",left->capacity,left->data_str);
+                // printf("right=%.*s\n",right->capacity,right->data_str);
                 res = bexpr->oper(left,right,res);
                 free_value();
                 free_value();
                 break;
             }
+        case SELECT:
+            {
+                Select sexpr = (Select)expr;
+                /* Calculate the selection expression. */
+                Value selV = get_value();
+                selV = calc_expression(sexpr->select,selV);
+                /* Is the selection defined? */
+                if (is_defined_value(selV)) {
+                    /* Yes, can perform the selection. */
+                    long long sel = value2integer(selV);
+                    if (sel >= 0 && sel < sexpr->num_choices) {
+                        /* Possible choice, proceed the computation. */
+                        res = calc_expression(sexpr->choices[sel],res);
+                    }
+                } else {
+                    /* Cannot compute, simply undefines the destination. */
+                    /* First ensure res has the right shape. */
+                    res->type = sexpr->choices[0]->type;
+                    resize_value(res,type_width(res->type));
+                    /* Then make it undefined. */
+                    set_undefined_bitstring(res);
+                }
+                free_value();
+                break;
+            }
         case CONCAT:
             {
                 Concat cexpr = (Concat)expr;
@@ -70,7 +97,9 @@ Value calc_expression(Expression expr, Value res) {
                 Cast cexpr = (Cast)expr;
                 Value child = get_value();
                 child = calc_expression(cexpr->child,child);
+                // printf("going to cast value of numeric=%d and width=%llu to width=%llu\n",child->numeric,type_width(child->type),type_width(cexpr->type));
                 res = cast_value(child,cexpr->type,res);
+                // printf("result is numeric=%d\n",res->numeric);
                 free_value();
                 break;
             }
@@ -157,16 +186,15 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
         case TRANSMIT: 
             {
                 Transmit trans = (Transmit)stmnt;
-                // printf("trans=%p trans->left=%p trans->left->kind=%d\n",trans,trans->left,trans->left->kind);
                 /* Compute the right value. */
-                // Value right = calc_expression(trans->right);
                 Value right = get_value();
                 right = calc_expression(trans->right,right);
+                // printf("transmit to left=%p with kind=%d and right=%p with kind=%d\n",trans->left,trans->left->kind,trans->right,trans->right->kind);fflush(stdout);
                 /* Depending on the left value. */
                 switch (trans->left->kind) {
                     case SIGNALI:
                         // printf("left->name=%s\n",((SignalI)(trans->left))->name);
-                        fflush(stdout);
+                        // fflush(stdout);
                         /* Simple transmission. */
                         if (mode)
                             transmit_to_signal_seq(right,(SignalI)(trans->left));
@@ -178,7 +206,6 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                             /* Transmission to sub element. */
                             RefIndex refi = (RefIndex)(trans->left);
                             /* Compute the index. */
-                            // Value indexV = calc_expression(refi->index);
                             Value indexV = get_value();
                             indexV = calc_expression(refi->index,indexV);
                             long long index = value2integer(indexV);
@@ -231,8 +258,9 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                             /* For each sub reference. */
                             for(int i=0; i < refc->num_refs; ++i) {
                                 /* Set up the transmit. */
-                                subtrans.left = refc->refs[i];
-                                long long size = type_width(subtrans.left->type);
+                                subtrans.left = refc->refs[refc->num_refs-i-1];
+                                unsigned long long size = type_width(subtrans.left->type);
+                                // printf("i=%i left=%p left->type=%p &left->type=%p right->kind=%i pos=%llu size=%llu\n",i,subtrans.left,subtrans.left->type,&(subtrans.left->type),right->kind,pos,size,size);fflush(stdout);
                                 subtrans.right = (Expression)get_value();
                                 subtrans.right = (Expression)read_range(
                                         right,pos,pos+size-1,
@@ -244,6 +272,7 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                                 free_value();
                                 pos += size;
                             }
+                            break;
                         }
                     default:
                         perror("Invalid kind for a reference.");
@@ -279,7 +308,6 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
             {
                 HIf hif = (HIf)stmnt;
                 /* Calculation the condition. */
-                // Value condition = calc_expression(hif->condition);
                 Value condition = get_value();
                 condition = calc_expression(hif->condition,condition);
                 /* Is it true? */
@@ -290,7 +318,6 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                     /* No, maybe an alternate condition is met. */
                     int met = 0;/* Tell if an alternate condition has been met.*/
                     for(int i=0; i<hif->num_noifs; ++i) {
-                        // Value subcond = calc_expression(hif->noconds[i]);
                         Value subcond = get_value();
                         subcond = calc_expression(hif->noconds[i],subcond);
                         if (is_defined_value(subcond) && value2integer(subcond)){
@@ -305,7 +332,7 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                         free_value();
                     }
                     /* Where there a sub condition met? */
-                    if (!met) {
+                    if (!met && hif->no) {
                         /* No, execute the no statement. */
                         execute_statement(hif->no,mode,behavior);
                     }

data/ext/hruby_sim/hruby_sim_vcd.c

@@ -7,7 +7,7 @@
 
 /**
  *  The HDLRuby simulation vcd format genertion engine, to be used with C code
- *  generated by hruby_low2c. 
+ *  generated by the csim engine or by the rcsim engine.
  **/
 
 /* Global variables storing the configuration of the vcd generation. */
@@ -74,20 +74,24 @@ static void vcd_print_name(Object object) {
         case SCOPE:
         case SYSTEMI:
         case BLOCK:
-            /* Print the name if name. */
-            /* Trick: SystemT, SignalI, Scope and SystemI have the
-             * field name at the same place. */
-            if ((((Block)object)->name != NULL) &&
-                    strlen(((Block)object)->name)>0) {
-                char name[256];
-                strncpy(name,((Block)object)->name,256);
-                replace_char(name,':','$');
-                vcd_print("%s",name);
-            } else {
-                /* No name, use the address of the object as name generator.*/
-                vcd_print("x$%p",(void*)object);
+            {
+                /* Print the name if name. */
+                /* Trick: SystemT, Block, Scope and SystemI have the
+                 * field name at the same place. */
+                char* namep = object->kind == SIGNALI ? 
+                    ((SignalI)object)->name : ((Block)object)->name;
+                if (namep!=NULL &&
+                        strlen(namep)>0) {
+                    char name[256];
+                    strncpy(name,namep,256);
+                    replace_char(name,':','$');
+                    vcd_print("%s",name);
+                } else {
+                    /* No name, use the address of the object as name generator.*/
+                    vcd_print("x$%p",(void*)object);
+                }
+                break;
             }
-            break;
         default: /* Nothing to do */
             break;
     }
@@ -98,7 +102,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 +110,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 +134,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 +149,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 +169,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 +182,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");
     }
 }