HDLRuby 2.0.8

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -0,0 +1,589 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <pthread.h>
+
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby simulation core, to be used with C code generated by
+ *  hruby_low2c. 
+ *  */
+
+/** The number of all the signals. */
+static int num_all_signals = 0;
+/** The capacity of the set of signals. */
+static int cap_all_signals = 0;
+/** The set of all the signals. */
+static SignalI* all_signals = NULL;
+
+/** The list of touched signals. */
+static ListS touched_signals_content = { NULL, NULL };
+static List touched_signals = &touched_signals_content;
+
+/** The list of touched signals in the sequential execution model. */
+static ListS touched_signals_seq_content = { NULL, NULL };
+static List touched_signals_seq = &touched_signals_seq_content;
+
+
+/** The list of activated code. */
+static ListS activate_codes_content = { NULL, NULL }; 
+static List activate_codes = &activate_codes_content;
+
+/** The number of timed behaviors. */
+static int num_timed_behaviors = 0;
+/** The capacity of the timed behaviors. */
+static int cap_timed_behaviors = 0;
+/** The timed behaviors. */
+static Behavior* timed_behaviors = NULL;
+
+/** The number of running behaviors. */
+static int num_run_behaviors = 0;
+/** The number of activated behaviors. */
+static int num_active_behaviors = 0;
+
+/** Flag saying the behaviors can run. */
+static int behaviors_can_run = 0;
+
+/** The current simulation time. */
+static unsigned long long hruby_sim_time = 0;
+
+/** The mutex for accessing the simulator ressources. */
+static pthread_mutex_t hruby_sim_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/** The condition the behaviors wait on. */
+static pthread_cond_t hruby_beh_cond = PTHREAD_COND_INITIALIZER;
+/** The condition the simulator waits on. */
+static pthread_cond_t hruby_sim_cond = PTHREAD_COND_INITIALIZER;
+
+/** Flags for the simulation. */
+static int sim_end_flag = 0;
+
+/** Adds a timed behavior for processing. 
+ *  @param behavior the timed behavior to register */
+void register_timed_behavior(Behavior behavior) {
+    if (num_timed_behaviors == cap_timed_behaviors) {
+        if (cap_timed_behaviors == 0) {
+            /* Need to create the array containing the timed behaviors. */
+            cap_timed_behaviors = 5;
+            timed_behaviors = calloc(sizeof(Behavior),cap_timed_behaviors);
+        } else {
+            /* Need to increase the capacity. */
+            Behavior* behaviors = calloc(sizeof(Behavior),cap_timed_behaviors*2);
+            memcpy(timed_behaviors,behaviors,sizeof(Behavior)*cap_timed_behaviors);
+            cap_timed_behaviors *= 2;
+        }
+    }
+    /* Add the behavior. */
+    timed_behaviors[num_timed_behaviors++] = behavior;
+}
+
+
+/** 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. */
+            cap_all_signals = 100;
+            all_signals = calloc(sizeof(SignalI),cap_all_signals);
+        } else {
+            /* Need to increase the capacity. */
+            Behavior* behaviors = calloc(sizeof(Behavior),cap_all_signals*2);
+            memcpy(all_signals,behaviors,sizeof(Behavior)*cap_all_signals);
+            cap_all_signals *= 2;
+        }
+    }
+    /* Add the behavior. */
+    all_signals[num_all_signals++] = signal;
+}
+
+
+/** Recursively update the signals until no (untimed) behavior are
+ *  activated. */
+void hruby_sim_update_signals() {
+    // printf("hruby_sim_update_signals...\n");
+    /* As long as the list of touched signals is not empty go on computing. */
+    while(!empty_list(touched_signals) || !empty_list(touched_signals_seq)) {
+        // printf("## Checking touched signals.\n");
+        /* Sets the new signals values and mark the signals as activating. */
+        /* For the case of the parallel execution model. */
+        while(!empty_list(touched_signals)) {
+            Elem e = remove_list(touched_signals);
+            SignalI sig = e->data;
+            delete_element(e);
+            /* Is there a change? */
+            if (same_content_value(sig->c_value,sig->f_value)) continue;
+            /* Yes, process the signal. */
+            println_signal(sig);
+            // printf("c_value="); print_value(sig->c_value);
+            // printf("\nf_value="); print_value(sig->f_value); printf("\n");
+            // printf("Touched signal: %p (%s)\n",sig,sig->name);
+            /* Update the current value of the signal. */
+            copy_value(sig->f_value,sig->c_value);
+            // /* Mark the signal as activated. */
+            // add_list(activate_signals,e);
+            /* Mark the corresponding code as activated. */
+            /* Any edge activation. */
+            int i;
+            for(i=0; i<sig->num_any; ++i) {
+                Object obj = sig->any[i];
+                if (obj->kind == BEHAVIOR) {
+                    /* Behavior case. */
+                    Behavior beh = (Behavior)obj;
+                    beh->activated = 1;
+                    add_list(activate_codes,get_element(beh));
+                } else {
+                    /* Other code case. */
+                    Code cod = (Code)obj;
+                    cod->activated = 1;
+                    add_list(activate_codes,get_element(cod));
+                }
+            }
+            /* Positive edge activation. */
+            if (!zero_value(sig->c_value)) {
+                for(i=0; i<sig->num_pos; ++i) {
+                    Object obj = sig->pos[i];
+                    if (obj->kind == BEHAVIOR) {
+                        /* Behavior case. */
+                        Behavior beh = (Behavior)obj;
+                        beh->activated = 1;
+                        add_list(activate_codes,get_element(beh));
+                    } else {
+                        /* Other code case. */
+                        Code cod = (Code)obj;
+                        cod->activated = 1;
+                        add_list(activate_codes,get_element(cod));
+                    }
+                }
+            }
+            /* Negative edge activation. */
+            if (zero_value(sig->c_value)) {
+                for(i=0; i<sig->num_neg; ++i) {
+                    Object obj = sig->neg[i];
+                    if (obj->kind == BEHAVIOR) {
+                        /* Behavior case. */
+                        Behavior beh = (Behavior)obj;
+                        beh->activated = 1;
+                        add_list(activate_codes,get_element(beh));
+                    } else {
+                        /* Other code case. */
+                        Code cod = (Code)obj;
+                        cod->activated = 1;
+                        add_list(activate_codes,get_element(cod));
+                    }
+                }
+            }
+        }
+        /* And fdor the case of the sequential execution model
+         * (no more content check nor update of current value necessary). */
+        while(!empty_list(touched_signals_seq)) {
+            Elem e = remove_list(touched_signals_seq);
+            SignalI sig = e->data;
+            delete_element(e);
+            /* Yes, process the signal. */
+            println_signal(sig);
+            /* Update the current value of the signal. */
+            /* Mark the corresponding code as activated. */
+            /* Any edge activation. */
+            int i;
+            for(i=0; i<sig->num_any; ++i) {
+                Object obj = sig->any[i];
+                if (obj->kind == BEHAVIOR) {
+                    /* Behavior case. */
+                    Behavior beh = (Behavior)obj;
+                    beh->activated = 1;
+                    add_list(activate_codes,get_element(beh));
+                } else {
+                    /* Other code case. */
+                    Code cod = (Code)obj;
+                    cod->activated = 1;
+                    add_list(activate_codes,get_element(cod));
+                }
+            }
+            /* Positive edge activation. */
+            if (!zero_value(sig->c_value)) {
+                for(i=0; i<sig->num_pos; ++i) {
+                    Object obj = sig->pos[i];
+                    if (obj->kind == BEHAVIOR) {
+                        /* Behavior case. */
+                        Behavior beh = (Behavior)obj;
+                        beh->activated = 1;
+                        add_list(activate_codes,get_element(beh));
+                    } else {
+                        /* Other code case. */
+                        Code cod = (Code)obj;
+                        cod->activated = 1;
+                        add_list(activate_codes,get_element(cod));
+                    }
+                }
+            }
+            /* Negative edge activation. */
+            if (zero_value(sig->c_value)) {
+                for(i=0; i<sig->num_neg; ++i) {
+                    Object obj = sig->neg[i];
+                    if (obj->kind == BEHAVIOR) {
+                        /* Behavior case. */
+                        Behavior beh = (Behavior)obj;
+                        beh->activated = 1;
+                        add_list(activate_codes,get_element(beh));
+                    } else {
+                        /* Other code case. */
+                        Code cod = (Code)obj;
+                        cod->activated = 1;
+                        add_list(activate_codes,get_element(cod));
+                    }
+                }
+            }
+        }
+
+        // printf("## Checking activate codes.\n");
+        /* Execute the behaviors activated by the signals. */
+        while(!empty_list(activate_codes)) {
+            Elem e = remove_list(activate_codes);
+            Object obj = e->data;
+            delete_element(e);
+            if (obj->kind == BEHAVIOR) {
+                /* Behavior case. */
+                Behavior beh = (Behavior)obj;
+                /* Is the code really activated? */
+                if (beh->activated) {
+                    /* Yes, execute it. */
+                    beh->block->function();
+                    /* And deactivate it. */
+                    beh->activated = 0;
+                }
+            } else {
+                /* Other code case. */
+                Code cod = (Code)obj;
+                /* Is the code really activated? */
+                if (cod->activated) {
+                    /* Yes, execute it. */
+                    cod->function();
+                    /* And deactivate it. */
+                    cod->activated = 0;
+                }
+            }
+        }
+    }
+}
+
+
+/** Advance time to the next time step. */
+void hruby_sim_advance_time() {
+    /* Collects the activation time of all the timed behaviors and find
+     * the shortest one. */
+    unsigned long long next_time = ULLONG_MAX;
+    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;
+    }
+    /* Sets the new activation time. */
+    hruby_sim_time = next_time;
+    println_time(hruby_sim_time);
+}
+
+
+/** Activates a behavior.
+ *  @param behavior the behavior to activate. */
+void activate_behavior(Behavior behavior) {
+
+}
+
+
+/** Activates the timed behavior that have to be activated at this
+  * time. */
+void hruby_sim_activate_behaviors_on_time() {
+    int i;
+    // printf("$1\n");
+    pthread_mutex_lock(&hruby_sim_mutex); 
+    /* 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) {
+            /* Increase the number of timed behavior to wait for. */
+            num_active_behaviors ++;
+            // printf("num_active_behaviors = %d\n",num_active_behaviors);
+        }
+    }
+    /* Activate the behaviors .*/
+    behaviors_can_run = 1;
+    // pthread_cond_signal(&compute_cond); /* No behaviors. */
+    pthread_cond_signal(&hruby_beh_cond); 
+    pthread_mutex_unlock(&hruby_sim_mutex);
+    // printf("$2\n");
+}
+
+
+/** 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("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);
+    }
+    behaviors_can_run = 0;
+    pthread_mutex_unlock(&hruby_sim_mutex);
+    // printf("$4\n");
+}
+
+
+/** The code for starting a behavior.
+ *  @param arg the behavior to execute. */
+void* behavior_run(void* arg) {
+    Behavior behavior = (Behavior)arg;
+    /* First lock the behavior until the simulation engine starts. */
+    // printf("#1\n");
+    pthread_mutex_lock(&hruby_sim_mutex);
+    num_active_behaviors -= 1;
+    while(!behaviors_can_run) {
+        // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
+        pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
+    }
+    pthread_mutex_unlock(&hruby_sim_mutex);
+    // printf("#2\n");
+    /* Now can start the execution of the behavior. */
+    behavior->block->function();
+    /* Stops the behavior. */
+    pthread_mutex_lock(&hruby_sim_mutex);
+    num_active_behaviors -= 1;
+    num_run_behaviors -= 1;
+    pthread_cond_signal(&hruby_sim_cond);
+    pthread_mutex_unlock(&hruby_sim_mutex);
+    /* End the thread. */
+    pthread_exit(NULL);
+}
+
+
+/** Starts the timed behaviors.
+ *  @note create a thread per timed behavior. */
+void hruby_sim_start_timed_behaviors() {
+    int i;
+    /* Sets the end flags to 0. */
+    sim_end_flag = 0;
+    /* 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);
+        pthread_create(&timed_behaviors[i]->thread,NULL,
+                       &behavior_run,timed_behaviors[i]);
+    }
+}
+
+/** Ends waiting all the threads properly terminates. */
+void hruby_sim_end_timed_behaviors() {
+    int i;
+    /* Sets the end flag to 1. */
+    sim_end_flag = 1;
+    /* Wait for the threads to terminate. */
+    for(i=0; i<num_timed_behaviors; ++i) {
+        pthread_join(timed_behaviors[i]->thread,NULL);
+    }
+}
+
+
+
+
+/** The simulation core function.
+ *  @param limit the time limit in fs. */
+void hruby_sim_core(unsigned long long limit) {
+    /* 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). */
+        hruby_sim_update_signals(); 
+        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;
+        }
+
+        /* Activate the timed behavior that are on time. */
+        hruby_sim_activate_behaviors_on_time();
+    }
+}
+
+
+
+
+/* ##################################################################### */
+/* ##                The interface for the HW description.            ## */
+/* ##################################################################### */
+
+
+
+
+/** Makes the behavior wait for a given time.
+ *  @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);
+    /* No go on with the wait procedure. */
+    pthread_mutex_lock(&hruby_sim_mutex);
+    /* Indicate the behavior finished current execution. */
+    num_active_behaviors -= 1;
+    pthread_cond_signal(&hruby_sim_cond);
+    /* Update the behavior's time. */
+    behavior->active_time += delay;
+    pthread_mutex_unlock(&hruby_sim_mutex);
+    /* Wait for being reactivated. */
+    while(behavior->active_time > hruby_sim_time) {
+        pthread_mutex_lock(&hruby_sim_mutex);
+        while(!behaviors_can_run) {
+            // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
+            pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
+        }
+        pthread_mutex_unlock(&hruby_sim_mutex);
+    }
+}
+
+
+/** Touch a signal. 
+ *  @param signal the signal to touch  */
+void touch_signal(SignalI signal) {
+    // printf("touching signal: %p\n",signal);
+    add_list(touched_signals,get_element(signal));
+    // println_signal(signal);
+    /* Now the signal is not fading any longer. */
+    signal->fading = 0;
+}
+
+
+/** Transmit a value to a 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) with fading=%d\n",signal->name,signal,signal->fading);
+    /* Copy the content. */
+    if (signal->fading)
+        signal->f_value = copy_value(value,signal->f_value);
+    else
+        signal->f_value = copy_value_no_z(value,signal->f_value);
+    /* And touch the signal. */
+    touch_signal(signal);
+}
+
+/** Transmit a value to a range within a signal.
+ *  @param value the value to transmit
+ *  @param ref the reference to the range in the signal to transmit the
+ *         value to. */
+void transmit_to_signal_range(Value value, RefRangeS ref) {
+    SignalI signal = ref.signal;
+    unsigned long long first = ref.first;
+    unsigned long long last = ref.last;
+    // printf("Tansmit to signal range: %s(%p)\n",signal->name,signal);
+    /* Can transmit, copy the content. */
+    if (signal->fading)
+        signal->f_value = write_range(value,first,last,signal->f_value);
+    else
+        signal->f_value = write_range_no_z(value,first,last,signal->f_value);
+    /* And touch the signal. */
+    touch_signal(signal);
+}
+
+
+
+/** Touch a signal in case of sequential execution model. 
+ *  @param signal the signal to touch  */
+void touch_signal_seq(SignalI signal) {
+    // printf("touching signal seq: %p\n",signal);
+    /* Is there a difference between the present and future value? */ 
+    if (same_content_value(signal->c_value,signal->f_value)) return;
+    /* Yes, add the signal to the list of touched sequential ones and update
+     * its current value. */
+    add_list(touched_signals_seq,get_element(signal));
+    copy_value(signal->f_value,signal->c_value);
+    // println_signal(signal);
+    /* Now the signal is not fading any longer. */
+    signal->fading = 0;
+}
+
+
+/** Transmit a value to a signal in case of a sequential execution model.
+ *  @param value the value to transmit
+ *  @param signal the signal to transmit the value to. */
+void transmit_to_signal_seq(Value value, SignalI signal) {
+    // printf("Tansmit to signal seq: %s(%p)\n",signal->name,signal);
+    /* Copy the content. */
+    if (signal->fading)
+        copy_value(value,signal->f_value);
+    else
+        copy_value_no_z(value,signal->f_value);
+    /* And touch the signal. */
+    touch_signal_seq(signal);
+}
+
+/** Transmit a value to a range within a signal in case of sequential
+ *  execution model.
+ *  @param value the value to transmit
+ *  @param ref the reference to the range in the signal to transmit the
+ *         value to. */
+void transmit_to_signal_range_seq(Value value, RefRangeS ref) {
+    SignalI signal = ref.signal;
+    unsigned long long first = ref.first;
+    unsigned long long last = ref.last;
+    // printf("Tansmit to signal range: %s(%p)\n",signal->name,signal);
+    /* Can transmit, copy the content. */
+    if (signal->fading)
+        write_range(value,first,last,signal->f_value);
+    else
+        write_range_no_z(value,first,last,signal->f_value);
+    /* And touch the signal. */
+    touch_signal_seq(signal);
+}
+
+/** Creates an event.
+ *  @param edge the edge of the event
+ *  @param signal the signal of the event */
+Event make_event(Edge edge, SignalI signal) {
+    Event event = malloc(sizeof(EventS));
+    event->edge = edge;
+    event->signal = signal;
+
+    return event;
+}
+
+
+/** Creates a delay.
+ *  Actually generates an unsigned long long giving the corresponding
+ *  delay in the base unit of the simulator. 
+ *  @param value the value of the delay
+ *  @param unit the used unit
+ *  @return the result delay in the base unit of the simulator (ns) */
+unsigned long long make_delay(int value, Unit unit) {
+    switch(unit) {
+        case  S: return value * 1000000000ULL;
+        case MS: return value * 1000000ULL;
+        case US: return value * 1000ULL;
+        case NS: return value * 1ULL;
+        default: 
+                 perror("Invalid unit for a delay."); 
+    }
+    return -1;
+}
+

data/lib/HDLRuby/sim/hruby_sim_list.c

@@ -0,0 +1,93 @@
+#include <stdlib.h>
+
+#include "hruby_sim.h"
+
+/**
+ *  The lists used in HDLRuby simulation, to be used with C code generated by
+ *  hruby_low2c. 
+ *  */
+
+
+/* The pool of list elements to reduce number of memory allocations. */
+static ListS pool_elements = { NULL, NULL };
+
+/** Get a list element for containing some data.
+ *  @param data the data of the element
+ *  @return the resulting element */
+Elem get_element(void* data) {
+    Elem elem; /* The resulting element. */
+    /* Is the pool empty? */
+    if (empty_list(&pool_elements)) {
+        /* Yes, allocates a new element. */
+        elem = malloc(sizeof(ElemS));
+        elem->data = data;
+        elem->next = NULL;
+    } else {
+        /* No, get the element from the pool. */
+        elem = pool_elements.head;
+        elem->data = data;
+        elem->next = NULL;
+        pool_elements.head = pool_elements.head->next;
+        if (pool_elements.tail == elem)
+            pool_elements.tail = NULL;
+    }
+    return elem;
+}
+
+/** Delete an element (it will return to the pool).
+  *  @param elem the element to delete */
+void delete_element(Elem elem) {
+    elem->data = NULL;
+    add_list(&pool_elements,elem);
+}
+
+
+/** Builds a list.
+ *  @param list the place where to build the list
+ *  @return the resulting list */
+List build_list(List list) {
+    list->head = list->tail = NULL;
+    return list;
+}
+
+/** Clears a list.
+ *  @param list the list to clear */
+void clear_list(List list) {
+    list->head = list->tail = NULL;
+}
+
+/** Adds an element to the tail of a list.
+ *  @param list the list to add the element in
+ *  @param elem the element to add in the list */
+void add_list(List list, Elem elem) {
+    /* Ensures the element is unlinked. */
+    elem->next = NULL;
+    /* Is the list empty? */
+    if (empty_list(list)) {
+        /* Yes, the element is the head and the tail. */
+        list->head = list->tail = elem;
+    } else {
+        /* No, simply add to the tail. */
+        list->tail->next = elem;
+        list->tail = elem;
+    }
+}
+
+/** Remove the head of the list.
+ *  @param list the list to remove the head from
+ *  @return the removed element */
+Elem remove_list(List list) {
+    /* Is the list empty? */
+    if (empty_list(list)) {
+        /* Yes, no element to remove. */
+        return NULL;
+    } else {
+        /* No, remove the head. */
+        Elem elem = list->head;
+        list->head = list->head->next;
+        if (list->tail == elem) {
+            list->tail = NULL;
+        }
+        return elem;
+    }
+}