HDLRuby 2.0.8

data/lib/HDLRuby/sim/hruby_sim_vizualize.c

@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby simulation visualization engine, to be used with C code
+ *  generated by hruby_low2c. 
+ **/
+
+/** Prints the time.
+ *  @param time the time to show. */
+void print_time(unsigned long long time) {
+    printf("# %lluns",time);
+}
+
+/** Prints the time and goes to the next line.
+ *  @param time the time to show. */
+void println_time(unsigned long long time) {
+    print_time(time);
+    printf("\n");
+}
+
+/** Prints the name of an object.
+ *  @param object the object to print the name. */
+void print_name(Object object) {
+    /* Recurse on the owner if any. */
+    // printf("owner=%p\n",object->owner);
+    if (object->owner != NULL) {
+        print_name(object->owner);
+        printf("::");
+    }
+    /* Depending on the kind of object. */
+    switch(object->kind) {
+        case SYSTEMT:
+        case SIGNALI:
+        case SCOPE:
+        case SYSTEMI:
+            /* Print the name if name. */
+            /* Trick: SystemT, SignalI, Scope and SystemI have the
+             * field name at the same place. */
+            if (((SystemI)object)->name != NULL) {
+                printf("%s",((SystemI)object)->name);
+            }
+        default: /* Nothing to do */
+            break;
+    }
+}
+
+/** Prints a value.
+ *  @param value the value to print */
+void print_value(Value value) {
+    if (value->numeric) {
+        unsigned long long width = type_width(value->type);
+        unsigned long long mask = 1ULL << (width-1);
+        for(; mask > 0; mask >>= 1) {
+            printf("%d",(value->data_int & mask) != 0);
+        }
+    } else {
+        /* Display a bitstring value. */
+        int i;
+        int width = type_width(value->type);
+        char* data = value->data_str;
+        if (value->capacity == 0) {
+            /* The value is empty, therefore undefined. */
+            for(i=width; i>0; --i) {
+                printf("u");
+            }
+        }
+        else {
+            /* The value is not empty. */
+            for(i=width; i>0; --i) {
+                printf("%c",data[i-1]);
+            } 
+        }
+    }
+}
+
+/** Prints a signal.
+ *  @param signal the signal to show */
+void print_signal(SignalI signal) {
+    print_name((Object)signal);
+    printf(": ");
+    print_value(signal->f_value);
+}
+
+/** Prints a signal and goes to the next line.
+ *  @param signal the signal to show */
+void println_signal(SignalI signal) {
+    print_signal(signal);
+    printf("\n");
+}

data/lib/HDLRuby/sim/hruby_value_pool.c

@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby pool used for quickly getting empty values, to be used 
+ *  with C code generated by hruby_low2c. 
+ **/
+
+static Value* pool_values = NULL;
+static unsigned int pool_cap = 0; /* The capacity of the pool. */
+static unsigned int pool_pos = 0; /* The position in the pool. */
+
+/** Get a fresh value. */
+Value get_value() {
+    if (pool_cap == 0) {
+        /* First allocation. */
+        pool_cap = 16;
+        pool_values = (Value*)malloc(pool_cap*sizeof(Value));
+        /* Allocate the new values. */
+        ValueS* new_values = (ValueS*)calloc(sizeof(ValueS),pool_cap);
+        /* Assign them to the pool. */
+        unsigned int i;
+        for(i=0; i<pool_cap; ++i) {
+            pool_values[i] = &(new_values[i]);
+        }
+    }
+    else if (pool_pos == pool_cap) {
+        /* Need to increase the pool capacity. */
+        pool_cap = pool_cap * 2;
+        pool_values = (Value*)realloc(pool_values,pool_cap*sizeof(Value));
+        /* Allocate the new values. */
+        /* Note: now pool_pos is the old pool_cap and is also the number
+         * of new values to allocate. */
+        ValueS* new_values = (ValueS*)calloc(sizeof(ValueS),pool_pos);
+        /* Assign them to the pool. */
+        unsigned int i;
+        for(i=0; i<pool_pos; ++i) {
+            pool_values[i+pool_pos] = &(new_values[i]);
+        }
+    }
+    /* Readjust the position in the pool and return the value. */
+    return pool_values[pool_pos++];
+}
+
+/** Frees the last value of the pool. */
+void free_value() {
+    if (pool_pos > 0) pool_pos--;
+}
+
+/** Gets the current state of the value pool. */
+unsigned int get_value_pos() {
+    return pool_pos;
+}
+
+/** Restores the state of the value pool.
+ *  @param pos the new position in the pool */
+void set_value_pos(unsigned int pos) {
+    pool_pos = pos;
+}

data/lib/HDLRuby/std/channel.rb

@@ -0,0 +1,354 @@
+module HDLRuby::High::Std
+
+##
+# Standard HDLRuby::High library: channels
+# 
+########################################################################
+    
+    ## Describes a high-level channel type.
+    class ChannelT
+
+        # The name of the channel type.
+        attr_reader :name
+
+        # Creates a new channel type with +name+ built whose
+        # instances are created from +ruby_block+.
+        def initialize(name,&ruby_block)
+            # Checks and sets the name.
+            @name = name.to_sym
+            # Sets the block for instantiating a channel.
+            @ruby_block = ruby_block
+            # Sets the instantiation procedure.
+            obj = self
+            HDLRuby::High.space_reg(@name) do |*args|
+                obj.instantiate(*args)
+            end
+        end
+
+        ## Intantiates a channel
+        def instantiate(*args)
+            obj = self
+            # No argument, so not an instantiation but actually
+            # an access to the channel type.
+            return obj if args.empty?
+            # Process the case of generic channel.
+            if @ruby_block.arity > 0 then
+                # Actually the arguments are generic arguments,
+                # generates a new channel type with these arguments
+                # fixed.
+                ruby_block = @ruby_block
+                return ChannelT.new(:"") do
+                    HDLRuby::High.top_user.instance_exec(*args,&ruby_block)
+                end
+            end
+            # Generates the channels.
+            args.each do |nameI|
+                channelI = ChannelI.new(name,&@ruby_block)
+                HDLRuby::High.space_reg(nameI) { channelI }
+                channelI
+            end
+        end
+
+        alias_method :call, :instantiate
+    end
+
+
+    ## Creates a new channel type named +name+ whose instances are
+    #  creating executing +ruby_block+.
+    def channel(name,&ruby_block)
+        return ChannelT.new(name,&ruby_block)
+    end
+
+
+
+
+    ## 
+    # Describes a high-level channel instance.
+    class ChannelI
+        # include HDLRuby::High::HScope_missing
+        include HDLRuby::High::Hmissing
+
+        # The name of the channel instance.
+        attr_reader :name
+
+        # The namespace associated with the current execution when
+        # building a channel, its reader or its writer.
+        attr_reader :namespace
+
+        ## Creates a new channel instance with +name+ built from +ruby_block+.
+        def initialize(name,&ruby_block)
+            # Check and set the name
+            @name = name.to_sym
+
+            obj = self
+
+            # The reader input ports by name.
+            @reader_inputs = {}
+            # The reader output ports by name.
+            @reader_outputs = {}
+            # The reader inout ports by name.
+            @reader_inouts = {}
+
+            # The writer input ports by name.
+            @writer_inputs = {}
+            # The writer output ports by name.
+            @writer_outputs = {}
+            # The writer inout ports by name.
+            @writer_inouts = {}
+
+            # Create the namespaces for building the channel, its readers
+            # and its writers.
+
+            # Creates the namespace of the channel.
+            @channel_namespace = Namespace.new(self)
+            # Make it give access to the internal of the class.
+            @channel_namespace.add_method(:reader_input, &method(:reader_input))
+            @channel_namespace.add_method(:reader_output,&method(:reader_output))
+            @channel_namespace.add_method(:reader_inout, &method(:reader_inout))
+            @channel_namespace.add_method(:writer_input, &method(:writer_input))
+            @channel_namespace.add_method(:writer_output,&method(:writer_output))
+            @channel_namespace.add_method(:writer_inout, &method(:writer_inout))
+            @channel_namespace.add_method(:reader,       &method(:reader))
+            @channel_namespace.add_method(:writer,       &method(:writer))
+
+            # Creates the namespace of the reader.
+            @reader_namespace = Namespace.new(self)
+            # Creates the namespace of the writer.
+            @writer_namespace = Namespace.new(self)
+
+            # By default the namespace is the one of the namespace
+            @namespace = @channel_namespace
+
+            # Builds the channel.
+            HDLRuby::High.space_push(@namespace)
+            # puts "top_user=#{HDLRuby::High.top_user}"
+            HDLRuby::High.top_user.instance_eval(&ruby_block)
+            HDLRuby::High.space_pop
+
+            # Gives access to the channel by registering its name.
+            obj = self
+            HDLRuby::High.space_reg(@name) { self }
+        end
+
+        # The methods for defining the channel
+        
+        # For the channel itself
+        
+        ## Defines new command +name+ to execute +ruby_block+ for the
+        #  channel.
+        def command(name,&ruby_block)
+            # Ensures name is a symbol.
+            name = name.to_sym
+            # Sets the new command.
+            self.define_singleton_method(name) do
+                # Executes the command in the right environment.
+                HDLRuby::High.space_push(@namespace)
+                res = HDLRuby::High.top_user.instance_exec(&ruby_block)
+                HDLRuby::High.space_pop
+                res
+            end
+        end
+        
+        # For the reader and the writer
+
+        ## Sets the signals accessible through +key+ to be reader input port.
+        def reader_input(*keys)
+            # Registers each signal as reader port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @reader_inputs[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be reader output port.
+        def reader_output(*keys)
+            # Registers each signal as reader port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @reader_outputs[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be reader inout port.
+        def reader_inout(*keys)
+            # Registers each signal as reader port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @reader_inouts[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be writer input port.
+        def writer_input(*keys)
+            # Registers each signal as writer port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @writer_inputs[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be writer output port.
+        def writer_output(*keys)
+            # Registers each signal as writer port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @writer_outputs[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be writer inout port.
+        def writer_inout(*keys)
+            # Registers each signal as writer port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @writer_inouts[name] = send(key)
+            end
+        end
+
+        ## Sets the read procedure to be +ruby_block+.
+        def reader(&ruby_block)
+            @reader_proc = ruby_block
+        end
+
+        ## Sets the writter procedure to be +ruby_block+.
+        def writer(&ruby_block)
+            @writer_proc = ruby_block
+        end
+
+        # The methods for accessing the channel
+        
+        # Channel side.
+
+        ## Gets the list of the signals of the channel to be connected
+        #  to the reader.
+        def reader_signals
+            return @reader_inputs.values + @reader_outputs.values +
+                   @reader_inouts.values
+        end
+
+        ## Gets the list of the signals of the channel to be connected
+        #  to the writer.
+        def writer_signals
+            return @writer_inputs.values + @writer_outputs.values +
+                   @writer_inouts.values
+        end
+
+        # Reader an writer side.
+
+        ## Declares the ports for the reader.
+        def reader_ports
+            loc_inputs  = @reader_inputs
+            loc_outputs = @reader_outputs
+            loc_inouts  = @reader_inouts
+            HDLRuby::High.cur_system.open do
+                # The inputs
+                loc_inputs.each  { |name,sig| sig.type.input  name }
+                # The outputs
+                loc_outputs.each { |name,sig| sig.type.output name }
+                # The inouts
+                loc_inouts.each  { |name,sig| sig.type.inout  name }
+            end
+        end
+
+        ## Declares the ports for the writer.
+        def writer_ports
+            loc_inputs  = @writer_inputs
+            loc_outputs = @writer_outputs
+            loc_inouts  = @writer_inouts
+            HDLRuby::High.cur_system.open do
+                # The inputs
+                loc_inputs.each  { |name,sig| sig.type.input  name }
+                # The outputs
+                loc_outputs.each { |name,sig| sig.type.output name }
+                # The inouts
+                loc_inouts.each  { |name,sig| sig.type.inout  name }
+            end
+        end
+        
+        ## Performs a read on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def read(*args,&ruby_block)
+            # Fill the reader namespace with the access to the reader signals.
+            @reader_inputs.each do |name,sig|
+                @reader_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            @reader_outputs.each do |name,sig|
+                @reader_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            @reader_inouts.each do |name,sig|
+                @reader_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            # Gain access to the reader as local variable.
+            reader_proc = @reader_proc
+            # The context is the one of the reader.
+            @namespace = @reader_namespace
+            # Execute the code generating the reader in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&reader_proc)
+            end
+            HDLRuby::High.space_pop
+            # Restores the default context.
+            @namespace = @channel_namespace
+        end
+        
+        ## Performs a write on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def write(*args,&ruby_block)
+            # Fill the writer namespace with the access to the writer signals.
+            @writer_inputs.each do |name,sig|
+                @writer_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            @writer_outputs.each do |name,sig|
+                @writer_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            @writer_inouts.each do |name,sig|
+                @writer_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            # Gain access to the writer as local variable.
+            writer_proc = @writer_proc
+            # The context is the one of the writer.
+            @namespace = @writer_namespace
+            # Execute the code generating the writer in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&writer_proc)
+            end
+            HDLRuby::High.space_pop
+            # Restores the default context.
+            @namespace = @channel_namespace
+        end
+    end
+
+end
+

data/lib/HDLRuby/std/clocks.rb

@@ -0,0 +1,165 @@
+module HDLRuby::High::Std
+
+##
+# Standard HDLRuby::High library: clocks
+# 
+########################################################################
+
+
+    # Initialize the clock generator with +rst+ as reset signal.
+    def configure_clocks(rst = $rst)
+        @@__clocks_rst = rst
+    end
+
+    # Create a clock inverted every +times+ occurence of an +event+.
+    def make_clock(event, times)
+        clock = nil # The resulting clock
+
+        # Enters the current system
+        HDLRuby::High.cur_system.open do
+
+            # Ensures times is a value.
+            times = times.to_value
+
+            # Create the counter.
+            # Create the name of the counter.
+            name = HDLRuby.uniq_name
+            # Declare the counter.
+            [times.width].inner(name)
+            # Get the signal of the counter.
+            counter = get_inner(name)
+
+            # Create the clock.
+            # Create the name of the clock.
+            name = HDLRuby.uniq_name
+            # Declares the clock.
+            bit.inner(name)
+            # Get the signal of the clock.
+            clock = get_inner(name)
+            
+            # Control it.
+            par(event) do
+                hif(@@__clocks_rst) do
+                    counter.to_ref <= times.to_expr
+                    clock.to_ref <= 0
+                end
+                helsif(counter.to_expr == 0) do
+                    counter.to_ref <= times.to_expr 
+                    clock.to_ref <= ~ clock.to_expr
+                end
+                helse do
+                    counter.to_ref <= counter.to_expr + 1
+                end
+            end
+        end
+        return clock
+    end
+
+    # module clk_div3(clk,reset, clk_out);
+
+    #     input clk;
+    #     input reset;
+    #     output clk_out;
+
+    #     reg [1:0] pos_count, neg_count;
+    #     wire [1:0] r_nxt;
+
+    #     always @(posedge clk)
+    #     if (reset)
+    #         pos_count <=0;
+    #     else if (pos_count ==2) pos_count <= 0;
+    #     else pos_count<= pos_count +1;
+
+    #     always @(negedge clk)
+    #     if (reset)
+    #         neg_count <=0;
+    #     else  if (neg_count ==2) neg_count <= 0;
+    #     else neg_count<= neg_count +1;
+
+    #     assign clk_out = ((pos_count == 2) | (neg_count == 2));
+    # endmodule
+
+    # Creates a clock inverted every +times+ occurence of an +event+ and its
+    # everted.
+    def make_2edge_clock(event,times)
+        clock = nil # The resulting clock
+
+        # Enters the current system
+        HDLRuby::High.cur_system.open do
+            # Ensure times is a value.
+            times = times.to_value
+
+            # Create the event counter.
+            # Create the name of the counter.
+            name = HDLRuby.uniq_name
+            # Declare the counter.
+            [times.width].inner(name)
+            # Get the signal of the counter.
+            counter = get_inner(name)
+
+            # Create the inverted event counter.
+            # Create the name of the counter.
+            name = HDLRuby.uniq_name
+            # Declare the counter.
+            [times.width].inner(name)
+            # Get the signal of the counter.
+            counter_inv = get_inner(name)
+
+            # Create the clock.
+            # Create the name of the clock.
+            name = HDLRuby.uniq_name
+            # Declare the clock.
+            bit.inner(name)
+            # Get the signal of the clock.
+            clock = get_inner(name)
+
+            # Control the event counter
+            par(event) do
+                hif(@@__clocks_rst | counter.to_expr == 0) do
+                    counter.to_ref <= times.to_expr/2 + 1
+                end
+            end
+            # Control the inverteed event counter
+            par(event.invert) do
+                hif(@@__clocks_rst | counter_inv.to_expr == 0) do
+                    counter_inv.to_ref <= times.to_expr/2 + 1
+                end
+            end
+            # Compute the clock.
+            clock.to_ref <= (counter.to_expr == times.to_expr/2 + 1) |
+                (counter_inv.to_expr == times.to_expr/2 + 1)
+        end
+        # Return it.
+        return clock
+    end
+end
+
+
+# Enhnace the events with multiply operator.
+class HDLRuby::High::Event
+
+    # Creates a new event activated every +times+ occurences of the 
+    # current event.
+    def *(times)
+        # The event must be an edge
+        unless (self.type == :posedge or self.type == :negedge) then
+            raise "Only posedge or negedge events can be multiplied."
+        end
+        # +times+ must be a value.
+        times = times.to_value
+        # Creates the clock for the new event.
+        clock = nil
+        # There are two cases: times is even or times is odd.
+        if times.even? then
+            # Even case: make a clock inverted every times/2 occurance of
+            # current event.
+            clock = HDLRuby::High::Std::make_clock(self,times/2)
+        else
+            # Odd case: make a clock raised every times occurance using
+            # both event and inverted event
+            clock = HDLRuby::High::Std::make_2edge_clock(self,times)
+        end
+        # Use the clock to create the new event.
+        return clock.posedge
+    end
+end