HDLRuby 2.5.1 → 2.6.8

data/lib/HDLRuby/sim/hruby_sim.h

@@ -219,6 +219,13 @@ Value shift_right_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value equal_value(Value src0, Value src1, Value dst);
 
+/** Computes the greater comparision of two values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+extern Value greater_value(Value src0, Value src1, Value dst);
+
 /** Computes the lesser comparision of two values.
  *  @param src0 the first source value of the comparison
  *  @param src1 the second source value of the comparison
@@ -226,12 +233,19 @@ extern Value equal_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value lesser_value(Value src0, Value src1, Value dst);
 
-/** Computes the greater comparision of two values.
+/** Computes the greater or equal comparision of two values.
  *  @param src0 the first source value of the comparison
  *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
-extern Value greater_value(Value src0, Value src1, Value dst);
+extern Value greater_equal_value(Value src0, Value src1, Value dst);
+
+/** Computes the lesser or equal comparision of two values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+extern Value lesser_equal_value(Value src0, Value src1, Value dst);
 
 /** Selects a value depending on a condition.
  *  @param cond   the condition to use for selecting a value
@@ -451,7 +465,10 @@ typedef struct BehaviorS_ {
 
     int activated;      /* Tells if the behavior is activated or not. */
 
-    int timed;          /* Tell if the behavior is timed or not. */
+    int timed;          /* Tell if the behavior is timed or not:
+                           - 0: not timed
+                           - 1: timed
+                           - 2: timed and finished. */
     unsigned long long active_time; /* The next time the behavior has to be activated. */
     pthread_t thread;   /* The thread assotiated with the behavior (if any).*/
 } BehaviorS;
@@ -573,10 +590,15 @@ extern void each_all_signal(void (*func)(SignalI));
 /* Interface to the visualization engine. */
 
 typedef struct {
+    /* The simulation prints. */
     void (*print_time)(unsigned long long);
     void (*print_name)(Object);
     void (*print_value)(Value);
     void (*print_signal)(SignalI);
+    /* The custom 'string' prints. */
+    void (*print_string)(const char*);
+    void (*print_string_name)(Object);
+    void (*print_string_value)(Value);
 } PrinterS;
 
 extern PrinterS printer;
@@ -585,11 +607,29 @@ extern PrinterS printer;
  *  @param print_time the time printer
  *  @param print_name the name printer
  *  @param print_value the value printer
- *  @param print_signal the signal state printer. */
+ *  @param print_signal the signal state printer
+ *  @param print_string the string printer
+ *  @param print_string_name the string name printer
+ *  @param print_string_value the string value printer */
 extern void init_visualizer(void (*print_time)(unsigned long long), 
                             void (*print_name)(Object),
                             void (*print_value)(Value),
-                            void (*print_signal)(SignalI));
+                            void (*print_signal)(SignalI),
+                            void (*print_string)(const char*),
+                            void (*print_string_name)(Object),
+                            void (*print_string_value)(Value));
+
+/** Prints a name (default).
+ *  @param signal the signal to show */
+extern void default_print_name(Object);
+
+/** Prints a value (default).
+ *  @param signal the signal to show */
+extern void default_print_value(Value);
+
+/** Prints a string (default).
+ *  @param str the string to print. */
+extern void default_print_string(const char* str);
 
 // /** Prints the time.
 //  *  @param time the time to show. */

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -325,6 +325,9 @@ Value copy_value(Value src, Value dst) {
 /* Declared afterward. */
 static Value set_bitstring_value(Value src, Value dst);
 
+/* Declared afterward. */
+static Value set_numeric_value(Value src, Value dst);
+
 /** Copies a value to another but without overwritting with Z, the type of 
  *  the destination is preserved.
  *  @param src the source value
@@ -393,6 +396,35 @@ static Value set_bitstring_value(Value src, Value dst) {
     return dst;
 }
 
+/** Creates a numeric value from a bitstring value.
+ *  @param src the bitstring source value
+ *  @param dst the numeric destination value
+ *  @return dst. */
+static Value set_numeric_value(Value src, Value dst) {
+    /* Compute the width in bits of the source. */
+    unsigned long long width = type_width(src->type);
+    unsigned long long i;
+    /* Set the type and size of the destination from the type of the source.*/
+    dst->type = src->type;
+    dst->numeric = 1;
+
+    /* Access the data of the source and the destination. */
+    char* data_str = src->data_str;
+    unsigned long long data_int = 0;
+
+    /* Make the conversion. */
+    for(i=0; i < width; ++i) {
+        /* Get the bit from the source. */
+        unsigned long long bit = data_str[i] - '0';
+        /* And write it. */
+        data_int |= bit << i;
+    }
+    /* Update the destination. */
+    dst->data_int = data_int;
+    /* Return the destination. */
+    return dst;
+}
+
 
 /** Sets a value to undefined.
  *  @param dst the destination value
@@ -654,6 +686,21 @@ static Value mod_value_defined_bitstring(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the greater comparision of two defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the comparison. */
+    dst->data_int = (value2integer(src0) > value2integer(src1));
+    return dst;
+}
+
 /** Computes the lesser comparision of two defined bitstring values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -669,19 +716,33 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
     return dst;
 }
 
+/** Computes the greater or equal comparision of two defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
 
-/** Computes the greater comparision of two defined bitstring values.
+    /* Perform the comparison. */
+    dst->data_int = (value2integer(src0) >= value2integer(src1));
+    return dst;
+}
+
+/** Computes the lesser or equal comparision of two defined bitstring values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
  *  @param dst the destination value
  *  @return dst */
-static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
+static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
     /* Perform the comparison. */
-    dst->data_int = (value2integer(src0) > value2integer(src1));
+    dst->data_int = (value2integer(src0) <= value2integer(src1));
     return dst;
 }
 
@@ -1620,7 +1681,7 @@ static Value not_value_numeric(Value src, Value dst) {
     dst->numeric = 1;
 
     /* Perform the not. */
-    dst->data_int = fix_numeric_type(dst->type,!src->data_int);
+    dst->data_int = fix_numeric_type(dst->type,~src->data_int);
     return dst;
 }
 
@@ -1730,12 +1791,29 @@ 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 !XOR. */
+    // dst->data_int = ~(src0->data_int ^ src1->data_int);
+    /* Perform the comparison. */
+    dst->data_int = (src0->data_int == src1->data_int) ? 1 : 0;
     return dst;
 }
 
 
+/** Computes the greater comparision of two numeric values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return the destination value */
+static Value greater_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the greater. */
+    dst->data_int = (src0->data_int > src1->data_int);
+    return dst;
+}
+
 /** Computes the lesser comparision of two numeric values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -1751,18 +1829,33 @@ static Value lesser_value_numeric(Value src0, Value src1, Value dst) {
     return dst;
 }
 
-/** Computes the greater comparision of two numeric values.
+/** Computes the greater or equal comparision of two numeric values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
  *  @param dst the destination value
  *  @return the destination value */
-static Value greater_value_numeric(Value src0, Value src1, Value dst) {
+static Value greater_equal_value_numeric(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the lesser. */
-    dst->data_int = (src0->data_int > src1->data_int);
+    /* Perform the greater or equal. */
+    dst->data_int = (src0->data_int >= src1->data_int);
+    return dst;
+}
+
+/** Computes the lesser or equal comparision of two numeric values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return the destination value */
+static Value lesser_equal_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the lesser or equal. */
+    dst->data_int = (src0->data_int <= src1->data_int);
     return dst;
 }
 
@@ -2068,15 +2161,39 @@ Value sub_value(Value src0, Value src1, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 Value mul_value(Value src0, Value src1, Value dst) {
+    // printf("mul_value with src0=%llx src1=%llx\n",value2integer(src0),value2integer(src1));
+    // printf("src0->numeric=%d src1->numeric=%d\n",src0->numeric,src1->numeric);
+    // printf("is_defined_value(src0)=%d is_defined_value(src1)=%d\n",is_defined_value(src0),is_defined_value(src1));
     /* Might allocate a new value so save the current pool state. */
     unsigned int pos = get_value_pos();
     /* Do a numeric computation if possible, otherwise fallback to bitstring
      * computation. */
-    if (src0->numeric && src1->numeric) {
-        /* Both sources are numeric. */
-        return mul_value_numeric(src0,src1,dst);
+    if (src0->numeric) {
+        if (src1->numeric) {
+            /* Both sources are numeric. */
+            return mul_value_numeric(src0,src1,dst);
+        } else if (is_defined_value(src1)) {
+            // /* src1 is a defined bitstring, convert src0 to bitstring. */
+            // src0 = set_bitstring_value(src0,get_value());
+            // /* And do a bitstring multiplying. */
+            // return mul_value_defined_bitstring(src0,src1,dst);
+            /* src1 is a defined bitstring, convert it to a numeric. */
+            src1 = set_numeric_value(src1,get_value());
+            /* And do a numeri multiplying. */
+            return mul_value_numeric(src0,src1,dst);
+        }
+    } else if (src1->numeric && is_defined_value(src0)) {
+        // /* src1 is numeric but src0 is a defined bitstring, convert src1 to
+        //  * bitstring. */
+        // src1 = set_bit_string_value(src1,get_value());
+        // /* And do a bitstring multiplying. */
+        // return mul_value_defined_bitstring(src0,src1,dst);
+            /* src0 is a defined bitstring, convert it to a numeric. */
+            src0 = set_numeric_value(src0,get_value());
+            /* And do a numeri multiplying. */
+            return mul_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
-        /* Both sources can be converted to numeric values. */
+        /* Both sources are defined bitstrings. */
         return mul_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
@@ -2377,6 +2494,34 @@ Value equal_value(Value src0, Value src1, Value dst) {
 }
 
 
+
+/** Computes the greater comparision of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+Value greater_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return greater_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return greater_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 /** Computes the lesser comparision of two general values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -2404,22 +2549,22 @@ Value lesser_value(Value src0, Value src1, Value dst) {
 }
 
 
-/** Computes the greater comparision of two general values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+/** Computes the greater or equal comparision of two values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
-Value greater_value(Value src0, Value src1, Value dst) {
+Value greater_equal_value(Value src0, Value src1, Value dst) {
     /* Might allocate a new value so save the current pool state. */
     unsigned int pos = get_value_pos();
     /* Do a numeric computation if possible, otherwise fallback to bitstring
      * computation. */
     if (src0->numeric && src1->numeric) {
         /* Both sources are numeric. */
-        return greater_value_numeric(src0,src1,dst);
+        return greater_equal_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
-        return greater_value_defined_bitstring(src0,src1,dst);
+        return greater_equal_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
         /* First ensure dst has the right shape. */
@@ -2430,6 +2575,33 @@ Value greater_value(Value src0, Value src1, Value dst) {
     return dst;
 }
 
+/** Computes the lesser or equal comparision of two values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+Value lesser_equal_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return lesser_equal_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return lesser_equal_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 
 /** Selects a value depending on a general condition.
  *  @param cond   the condition to use for selecting a value

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -285,7 +285,8 @@ void hruby_sim_advance_time() {
     int i;
     for(i=0; i<num_timed_behaviors; ++i) {
         unsigned long long beh_time = timed_behaviors[i]->active_time;
-        if (beh_time < next_time) next_time = beh_time;
+        if (timed_behaviors[i]->timed == 1)
+            if (beh_time < next_time) next_time = beh_time;
     }
     /* Sets the new activation time. */
     hruby_sim_time = next_time;
@@ -310,7 +311,9 @@ void hruby_sim_activate_behaviors_on_time() {
     /* Count the number of behaviors that will be activated. */
     for(i=0; i<num_timed_behaviors; ++i) {
         Behavior beh = timed_behaviors[i];
-        if (beh->active_time == hruby_sim_time) {
+        // printf("beh->active_time=%llu\n",beh->active_time);
+        // if (beh->active_time == hruby_sim_time) {
+        if (beh->timed == 1 && beh->active_time == hruby_sim_time) {
             /* Increase the number of timed behavior to wait for. */
             num_active_behaviors ++;
             // printf("num_active_behaviors = %d\n",num_active_behaviors);
@@ -318,18 +321,19 @@ void hruby_sim_activate_behaviors_on_time() {
     }
     /* Activate the behaviors .*/
     behaviors_can_run = 1;
+    // printf("$2\n");
     // pthread_cond_signal(&compute_cond); /* No behaviors. */
-    pthread_cond_signal(&hruby_beh_cond); 
+    // pthread_cond_signal(&hruby_beh_cond); 
     pthread_mutex_unlock(&hruby_sim_mutex);
-    // printf("$2\n");
+    pthread_cond_broadcast(&hruby_beh_cond); 
 }
 
 
 /** Wait for the active timed behaviors to advance. */
 void hruby_sim_wait_behaviors() {
-    // printf("$3\n");
     pthread_mutex_lock(&hruby_sim_mutex);
     while(num_active_behaviors > 0) {
+        // printf("$3\n");
         // printf("num_active_behaviors = %d\n",num_active_behaviors);
         // pthread_cond_wait(&active_behaviors_cond, &hruby_sim_mutex);
         pthread_cond_wait(&hruby_sim_cond, &hruby_sim_mutex);
@@ -349,6 +353,7 @@ void* behavior_run(void* arg) {
     pthread_mutex_lock(&hruby_sim_mutex);
     num_active_behaviors -= 1;
     while(!behaviors_can_run) {
+        // printf("cannot run\n");
         // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
         pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
     }
@@ -356,12 +361,17 @@ void* behavior_run(void* arg) {
     // printf("#2\n");
     /* Now can start the execution of the behavior. */
     behavior->block->function();
+    // printf("#3\n");
+    /* Now can start the execution of the behavior. */
     /* Stops the behavior. */
     pthread_mutex_lock(&hruby_sim_mutex);
     num_active_behaviors -= 1;
     num_run_behaviors -= 1;
-    pthread_cond_signal(&hruby_sim_cond);
+    // printf("num_run_behaviors=%d\n",num_run_behaviors);
+    behavior->timed = 2;
+    // pthread_cond_signal(&hruby_sim_cond);
     pthread_mutex_unlock(&hruby_sim_mutex);
+    pthread_cond_signal(&hruby_sim_cond);
     /* End the thread. */
     pthread_exit(NULL);
 }
@@ -374,11 +384,13 @@ void hruby_sim_start_timed_behaviors() {
     pthread_mutex_lock(&hruby_sim_mutex);
     /* Sets the end flags to 0. */
     sim_end_flag = 0;
+    /* Tells the behavior can run. */
+    behaviors_can_run = 1;
     /* Create and start the threads. */
     for(i=0; i<num_timed_behaviors; ++i) {
         num_run_behaviors += 1;
         // ++num_active_behaviors;
-        // printf("0 num_active_behaviors = %d\n",num_active_behaviors);
+        // printf("0 num_run_behaviors = %d\n",num_run_behaviors);
         pthread_create(&timed_behaviors[i]->thread,NULL,
                        &behavior_run,timed_behaviors[i]);
     }
@@ -457,7 +469,6 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
  *  @param delay the delay to wait in fs.
  *  @param behavior the current behavior. */
 void hw_wait(unsigned long long delay, Behavior behavior) {
-    // printf("!1\n");
     /* Maybe the thread is to end immediatly. */
     if (sim_end_flag)
         pthread_exit(NULL);
@@ -465,16 +476,20 @@ void hw_wait(unsigned long long delay, Behavior behavior) {
     pthread_mutex_lock(&hruby_sim_mutex);
     /* Indicate the behavior finished current execution. */
     num_active_behaviors -= 1;
-    pthread_cond_signal(&hruby_sim_cond);
+    // 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);
     }