HDLRuby 2.2.17 → 2.3.4

data/lib/HDLRuby/sim/hruby_sim.h

@@ -157,6 +157,13 @@ extern Value mul_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value div_value(Value src0, Value src1, Value dst);
 
+/** Computes the modulo 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 */
+extern Value mod_value(Value src0, Value src1, Value dst);
+
 /** Computes the not of a value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -605,14 +612,18 @@ extern Value read_range(Value value, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-extern Value write_range(Value src, long long first, long long last, Value dst);
+extern Value write_range(Value src, long long first, long long last, 
+        Type base, Value dst);
 
 /** Writes to a range within a value but without overwrite with Z. 
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-extern Value write_range_no_z(Value src, long long first, long long last, Value dst);
+extern Value write_range_no_z(Value src, long long first, long long last,
+        Type base, Value dst);

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -397,6 +397,9 @@ static Value set_undefined_bitstring(Value dst) {
 
     /* set the type and size of the destination. */
     dst->numeric = 0;
+    /* Ensures the buffer of dst has the write size (in cas it was a fromer
+     * numeric for example). */
+    resize_value(dst,width);
 
     /* Get access to the destination data. */
     char* dst_data = dst->data_str;
@@ -604,7 +607,7 @@ static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
+    /* Perform the multiplication. */
     dst->data_int = value2integer(src0) * value2integer(src1);
     return dst;
 }
@@ -620,12 +623,29 @@ static Value div_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
+    /* Perform the division. */
     dst->data_int = value2integer(src0) / value2integer(src1);
     return dst;
 }
 
 
+/** Computes the modulo 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 mod_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 modulo. */
+    // printf("modulo with src0=%lld src1=%lld, result=%lld\n",value2integer(src0),value2integer(src1),value2integer(src0) % value2integer(src1));
+    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
@@ -1334,10 +1354,11 @@ Value read_range_bitstring(Value src, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
 Value write_range_bitstring(Value src, long long first, long long last,
-        Value dst) {
+        Type base, Value dst) {
     unsigned long long i;
     /* Ensure first is the smaller. */
     if (first > last) {
@@ -1350,7 +1371,8 @@ Value write_range_bitstring(Value src, long long first, long long last,
     unsigned long long src_width = type_width(src->type);
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type. */
-    unsigned long long bw = dst->type->base;
+    // unsigned long long bw = dst->type->base;
+    unsigned long long bw = type_width(base);
     first *= bw;
     last *=  bw;
     last += bw-1;
@@ -1371,10 +1393,11 @@ Value write_range_bitstring(Value src, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
 Value write_range_bitstring_no_z(Value src, long long first, long long last,
-        Value dst) {
+        Type base, Value dst) {
     unsigned long long i;
     /* Ensure first is the smaller. */
     if (first > last) {
@@ -1386,7 +1409,8 @@ Value write_range_bitstring_no_z(Value src, long long first, long long last,
     unsigned long long src_width = type_width(src->type);
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type. */
-    unsigned long long bw = dst->type->base;
+    // unsigned long long bw = dst->type->base;
+    unsigned long long bw = type_width(base);
     first *= bw;
     last *=  bw;
     /* Access the source and destination bitstring data. */
@@ -1415,7 +1439,10 @@ fix_numeric_type(Type type, unsigned long long val) {
     /* Get the width of the type. */
     int width = type_width(type);
     /* Compute the base mask. */
-    unsigned long long mask = ((unsigned long long)(-1)) << width;
+    // unsigned long long mask = ((unsigned long long)(-1)) << width;
+    /* NOTE: (ull)-1 << 64 becomes (ull)-1 on Intel processors, this is
+     * totally not what I expected (I expected 0). */
+    unsigned long long mask = width == 64 ? 0 : ((unsigned long long)(-1)) << width;
     // printf("width=%i val=%llu mask=%llx\n",width,val,mask);
 
     /* Is the type signed? */
@@ -1516,6 +1543,23 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the modulo 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 dst */
+static Value mod_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 division. */
+    // printf("modulo numeric with src0=%lld src1=%lld, result=%lld\n",src0->data_int, src1->data_int,src0->data_int % src1->data_int);
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int % src1->data_int);
+    return dst;
+}
+
+
 /** Computes the NOT of a numeric value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -1690,7 +1734,7 @@ static Value concat_value_numeric_array(int num, int dir,
     unsigned int i,pos;
     /* Compute the bit width of the destination. */
     unsigned int width = 0;
-    // printf("concat_value_numeric with dir=%d\n",dir);
+    // printf("concat_value_numeric with dir=%d and width=%llu\n",dir,type_width(args[0]->type));
     for(i=0; i<num; ++i) width += type_width(args[i]->type);
 
     /* Sets state of the destination using the bit width. */
@@ -1714,6 +1758,7 @@ static Value concat_value_numeric_array(int num, int dir,
         pos += arg_width;
     }
     /* Return the destination. */
+    // printf("Result is dst=%llx\n",dst->data_int);
     return dst;
 }
 
@@ -1724,6 +1769,7 @@ static Value concat_value_numeric_array(int num, int dir,
  *  @param dst the destination value
  *  @return dst */
 static Value cast_value_numeric(Value src, Type type, Value dst) {
+    // printf("cast_value_numeric with src=%llx",src->data_int);
     /* Copy the source to the destination. */
     dst->data_int = src->data_int;
     /* Update the destination type to the cast. */
@@ -1783,6 +1829,7 @@ static int same_content_value_range_numeric(Value value0,
  *  @return dst */
 Value read_range_numeric(Value value, long long first, long long last,
         Type base, Value dst) {
+    /* printf("read_range_numeric with value=%llx and first=%llu and last=%llu\n",value->data_int,first,last); */
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1795,15 +1842,18 @@ Value read_range_numeric(Value value, long long first, long long last,
     unsigned long long bw = type_width(base);
     /* Scale the range according to the base type. */
     first *= bw;
+    last  *= bw;
     length *= bw;
-    // printf("first=%lld last=%lld bw=%llu length=%lld\n",first,last,bw,length);
+    /* printf("first=%lld last=%lld bw=%llu length=%lld\n",first,last,bw,length); */
 
     /* Set the type and size of the destination from the type of the source.*/
     dst->type = make_type_vector(get_type_bit(),length);
     dst->numeric = 1;
 
     /* Compute the read mask. */
-    unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
+    // unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
+    /* NOTE: once again, << 64 does not work like expected. */
+    unsigned long long mask = mask+bw < 64 ? (~((-1LL) << (last+bw))) : -1LL;
     /* Performs the read. */
     unsigned long long data = (value->data_int & mask) >> first;
     /* Write it to the destination. */
@@ -1818,10 +1868,11 @@ Value read_range_numeric(Value value, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
 Value write_range_numeric(Value src, long long first, long long last,
-        Value dst) {
+        Type base, Value dst) {
     // printf("write_range_numeric\n");
     /* Ensure first is the smaller. */
     if (first > last) {
@@ -1833,7 +1884,8 @@ Value write_range_numeric(Value src, long long first, long long last,
     unsigned long long src_width = type_width(src->type);
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type of the destination. */
-    unsigned long long bw = dst->type->base;
+    // unsigned long long bw = dst->type->base;
+    unsigned long long bw = type_width(base);
     // printf("src_width=%llu dst_wdith=%llu bw=%llu\n",src_width,dst_width,bw);
     first *= bw;
     last *= bw;
@@ -1999,6 +2051,33 @@ Value div_value(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the modulo 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 mod_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 mod_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return mod_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 NOT of a general value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -2618,14 +2697,17 @@ Value read_range(Value value, long long first, long long last, Type base,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-Value write_range(Value src, long long first, long long last, Value dst) {
+Value write_range(Value src, long long first, long long last, Type base,
+        Value dst) {
     // printf("write_range\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */
-        return write_range_numeric(src,first,last,dst);
+        // return write_range_numeric(src,first,last,dst);
+        return write_range_numeric(src,first,last,base,dst);
     } else {
         /* No, do a bitstring range read. */
         if (dst->numeric) {
@@ -2635,7 +2717,8 @@ Value write_range(Value src, long long first, long long last, Value dst) {
             /* Need to convert the source to a bitstring. */
             src = set_bitstring_value(src,get_value());
         }
-        return write_range_bitstring(src,first,last,dst);
+        // return write_range_bitstring(src,first,last,dst);
+        return write_range_bitstring(src,first,last,base,dst);
     }
 }
 
@@ -2644,14 +2727,16 @@ Value write_range(Value src, long long first, long long last, Value dst) {
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-Value write_range_no_z(Value src, long long first, long long last, Value dst) {
+Value write_range_no_z(Value src, long long first, long long last, Type base,
+        Value dst) {
     // printf("write_range_no_z\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */
-        return write_range_numeric(src,first,last,dst);
+        return write_range_numeric(src,first,last,base,dst);
     } else {
         /* No, do a bitstring range read. */
         if (dst->numeric) {
@@ -2661,7 +2746,8 @@ Value write_range_no_z(Value src, long long first, long long last, Value dst) {
             /* Need to convert the source to a bitstring. */
             src = set_bitstring_value(src,get_value());
         }
-        return write_range_bitstring_no_z(src,first,last,dst);
+        // return write_range_bitstring_no_z(src,first,last,dst);
+        return write_range_bitstring_no_z(src,first,last,base,dst);
     }
 }
 

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -365,6 +365,7 @@ void* behavior_run(void* arg) {
  *  @note create a thread per timed behavior. */
 void hruby_sim_start_timed_behaviors() {
     int i;
+    pthread_mutex_lock(&hruby_sim_mutex);
     /* Sets the end flags to 0. */
     sim_end_flag = 0;
     /* Create and start the threads. */
@@ -375,6 +376,7 @@ void hruby_sim_start_timed_behaviors() {
         pthread_create(&timed_behaviors[i]->thread,NULL,
                        &behavior_run,timed_behaviors[i]);
     }
+    pthread_mutex_unlock(&hruby_sim_mutex);
 }
 
 /** Ends waiting all the threads properly terminates. */
@@ -497,12 +499,18 @@ 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;
+    /* The base type is stored here to avoid allocating a new type each time.
+     * It have an arbitrary base size a single element. */
+    static TypeS baseT = { 1, 1 };
+    baseT.base = signal->f_value->type->base;
     // printf("Tansmit to signal range: %s(%p) [%lld:%lld]\n",signal->name,signal,first,last);
     /* Can transmit, copy the content. */
     if (signal->fading)
-        signal->f_value = write_range(value,first,last,signal->f_value);
+        signal->f_value = write_range(value,first,last,&baseT,
+                signal->f_value);
     else
-        signal->f_value = write_range_no_z(value,first,last,signal->f_value);
+        signal->f_value = write_range_no_z(value,first,last,&baseT,
+                signal->f_value);
     /* And touch the signal. */
     touch_signal(signal);
 }
@@ -551,9 +559,9 @@ void transmit_to_signal_range_seq(Value value, RefRangeS ref) {
     // 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);
+        write_range(value,first,last,signal->f_value->type,signal->f_value);
     else
-        write_range_no_z(value,first,last,signal->f_value);
+        write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
     /* And touch the signal. */
     touch_signal_seq(signal);
 }

data/lib/HDLRuby/std/channel.rb

@@ -81,20 +81,31 @@ module HDLRuby::High::Std
     end
 
 
-    ##
-    #  Module for wrapping channel ports.
-    module ChannelPortWrapping
+    # ##
+    # #  Module for wrapping channel ports.
+    # module ChannelPortWrapping
+    #     # Wrap with +args+ arguments.
+    #     def wrap(*args)
+    #         return ChannelPortB.new(self,*args)
+    #     end
+    # end
+
+    ## Describes a channel port.
+    class ChannelPort
         # Wrap with +args+ arguments.
         def wrap(*args)
             return ChannelPortB.new(self,*args)
         end
+
+        # The scope the port has been declared in.
+        attr_reader :scope
     end
 
 
     ##
     # Describes a read port to a channel.
-    class ChannelPortR
-        include ChannelPortWrapping
+    class ChannelPortR < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel reader running in +namespace+ and
         # reading using +reader_proc+ and reseting using +reseter_proc+.
@@ -105,6 +116,7 @@ module HDLRuby::High::Std
             @namespace = namespace
             @reader_proc = reader_proc.to_proc
             @rester_proc = reseter_proc ? reseter_proc.to_proc : proc {}
+            @scope = HDLRuby::High.cur_scope
         end
 
         ## Performs a read on the channel using +args+ and +ruby_block+
@@ -137,8 +149,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes a writer port to a channel.
-    class ChannelPortW
-        include ChannelPortWrapping
+    class ChannelPortW < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel writer running in +namespace+ and
         # writing using +writer_proc+ and reseting using +reseter_proc+.
@@ -149,6 +161,7 @@ module HDLRuby::High::Std
             @namespace = namespace
             @writer_proc = writer_proc.to_proc
             @reseter_proc = reseter_proc ? reseter_proc.to_proc : proc {}
+            @scope = HDLRuby::High.cur_scope
         end
 
         ## Performs a write on the channel using +args+ and +ruby_block+
@@ -181,8 +194,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes an access port to a channel.
-    class ChannelPortA
-        include ChannelPortWrapping
+    class ChannelPortA < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel accesser running in +namespace+
         # and reading using +reader_proc+, writing using +writer_proc+,
@@ -198,6 +211,7 @@ module HDLRuby::High::Std
             @reader_proc  = reader_proc ? reader_proc.to_proc : proc { }
             @writer_proc  = writer_proc ? writer_proc.to_proc : proc { }
             @reseter_proc = reseter_proc ? reseter_proc.to_proc : proc {}
+            @scope = HDLRuby::High.cur_scope
         end
 
         ## Performs a read on the channel using +args+ and +ruby_block+
@@ -243,8 +257,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes port wrapper (Box) for fixing arugments.
-    class ChannelPortB
-        include ChannelPortWrapping
+    class ChannelPortB < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel box over channel port +port+ fixing +args+
         # as arguments.
@@ -273,6 +287,8 @@ module HDLRuby::High::Std
                 @args_write = args.clone
                 @args_access = args.clone
             end
+
+            @scope = @port.scope
         end
 
         ## Performs a read on the channel using +args+ and +ruby_block+
@@ -324,6 +340,12 @@ module HDLRuby::High::Std
         # building a channel.
         attr_reader :namespace
 
+        # The read port if any.
+        attr_reader :read_port
+
+        # The write port if any.
+        attr_reader :write_port
+
         ## Creates a new channel instance with +name+ built from +ruby_block+.
         def initialize(name,&ruby_block)
             # Check and set the name of the channel.
@@ -338,6 +360,10 @@ module HDLRuby::High::Std
             # Keep access to self.
             obj = self
 
+            # At first there no read nor write port.
+            @read_port = nil
+            @write_port = nil
+
             # The reader input ports by name.
             @reader_inputs = {}
             # The reader output ports by name.
@@ -359,11 +385,6 @@ module HDLRuby::High::Std
             # The accesser inout ports by name.
             @accesser_inouts = {}
 
-            # # The default reset procedures (reseters), by default do nothing.
-            # @input_reseter_proc  = proc {}
-            # @output_reseter_proc = proc {}
-            # @inout_reseter_proc  = proc {}
-
             # The branch channels
             @branches = {}
 
@@ -419,6 +440,11 @@ module HDLRuby::High::Std
             HDLRuby::High.space_reg(@name) { obj }
         end
 
+        # Get the parent system.
+        def parent_system
+            return self.scope.parent_system
+        end
+
         # The methods for defining the channel
         
         # For the channel itself
@@ -598,15 +624,30 @@ module HDLRuby::High::Std
                    @writer_inouts.values
         end
 
+        ## Tells if the channel support inout port.
+        def inout?
+            return @accesser_inputs.any? || @accesser_outputs.any? ||
+                   @accesser_inouts.any?
+        end
+
         # Defines a branch in the channel named +name+ built executing
         # +ruby_block+.
-        def brancher(name,&ruby_block)
+        # Alternatively, a ready channel instance can be passed as argument
+        # as +channelI+.
+        def brancher(name,channelI = nil,&ruby_block)
             # Ensure name is a symbol.
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
-            # Create the branch.
-            channelI = HDLRuby::High.channel_instance(name, &ruby_block)
+            # Is there a ready channel instance.
+            if channelI then
+                # Yes, use it directly.
+                @branches[name] = channelI
+                return self
+            end
+            # Now, create the branch.
+            channelI = HDLRuby::High::Std.channel_instance(name, &ruby_block)
             @branches[name] = channelI
+            return self
         end
 
 
@@ -619,60 +660,90 @@ module HDLRuby::High::Std
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
             # Get the branch.
+            channelI = @branches[name]
             return @branches[name]
         end
 
 
         # Reader, writer and accesser side.
 
-        ## Declares the ports for the reader and assigned them to +name+.
-        def input(name)
+        ## Declares the reader port as and assigned them to +name+.
+        def input(name = nil)
             # Ensure name is a symbol.
+            name = HDLRuby.uniq_name unless name
             name = name.to_sym
+            # Ensure the port is not already existing.
+            if @read_port then
+                raise "Read port already declared for channel instance: " +
+                    self.name
+            end
+
             # Access the ports
-            loc_inputs  = @reader_inputs
-            loc_outputs = @reader_outputs
-            loc_inouts  = @reader_inouts
+            # loc_inputs  = @reader_inputs
+            # loc_outputs = @reader_outputs
+            # loc_inouts  = @reader_inouts
+            loc_inputs  = @reader_inputs.merge(@accesser_inputs)
+            loc_outputs = @reader_outputs.merge(@accesser_outputs)
+            loc_inouts  = @reader_inouts.merge(@accesser_inouts)
+            locs = loc_inputs.merge(loc_outputs).merge(loc_inouts)
             # The generated port with corresponding channel port pairs.
             port_pairs = []
-            # Add them to the current system.
-            HDLRuby::High.cur_system.open do
-                # The inputs
-                loc_inputs.each  do |name,sig|
-                    # puts "name=#{name} sig.name=#{sig.name}"
-                    port_pairs << [sig, sig.type.input(name)]
+            if HDLRuby::High.cur_system == self.parent_system then
+                # Port in same system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    locs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.inner(name)]
+                    end
                 end
-                # The outputs
-                loc_outputs.each do |name,sig| 
-                    port_pairs << [sig, sig.type.output(name)]
+                obj = self
+                # Make the inner connection
+                port_pairs.each do |sig, port|
+                    sig.parent.open do
+                        port.to_ref <= sig
+                    end
                 end
-                # The inouts
-                loc_inouts.each  do |name,sig| 
-                    port_pairs << [sig, sig.type.inout(name)]
+            else
+                # Port in different system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    # The inputs
+                    loc_inputs.each  do |name,sig|
+                        # puts "name=#{name} sig.name=#{sig.name}"
+                        port_pairs << [sig, sig.type.input(name)]
+                    end
+                    # The outputs
+                    loc_outputs.each do |name,sig| 
+                        port_pairs << [sig, sig.type.output(name)]
+                    end
+                    # The inouts
+                    loc_inouts.each  do |name,sig| 
+                        port_pairs << [sig, sig.type.inout(name)]
+                    end
                 end
-            end
-            obj = self
-            # Make the connection of the instance.
-            HDLRuby::High.cur_system.on_instance do |inst|
-                obj.scope.open do
-                    port_pairs.each do |sig, port|
-                        RefObject.new(inst,port.to_ref) <= sig
+                obj = self
+                # Make the connection of the instance.
+                HDLRuby::High.cur_system.on_instance do |inst|
+                    obj.scope.open do
+                        port_pairs.each do |sig, port|
+                            RefObject.new(inst,port.to_ref) <= sig
+                        end
                     end
                 end
             end
 
             # Fill the reader namespace with the access to the reader signals.
-            @reader_inputs.each do |name,sig|
+            loc_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|
+            loc_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|
+            loc_inouts.each do |name,sig|
                 @reader_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
@@ -682,56 +753,88 @@ module HDLRuby::High::Std
             # NOTE: for now, simply associate the channel to name.
             chp = ChannelPortR.new(@reader_namespace,@reader_proc,@input_reseter_proc)
             HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @read_port = chp
             return chp
         end
 
         ## Declares the ports for the writer and assigned them to +name+.
-        def output(name)
+        def output(name = nil)
             # Ensure name is a symbol.
+            name = HDLRuby.uniq_name unless name
             name = name.to_sym
+            # Ensure the port is not already existing.
+            if @write_port then
+                raise "Write port already declared for channel instance: " +
+                    self.name
+            end
             # Access the ports
-            loc_inputs  = @writer_inputs
-            loc_outputs = @writer_outputs
-            loc_inouts  = @writer_inouts
+            # loc_inputs  = @writer_inputs
+            # loc_outputs = @writer_outputs
+            # loc_inouts  = @writer_inouts
+            loc_inputs  = @writer_inputs.merge(@accesser_inputs)
+            loc_outputs = @writer_outputs.merge(@accesser_outputs)
+            loc_inouts  = @writer_inouts.merge(@accesser_inouts)
+            locs = loc_inputs.merge(loc_outputs).merge(loc_inouts)
             # The generated port with corresponding channel port pairs.
             port_pairs = []
-            # Add them to the current system.
-            HDLRuby::High.cur_system.open do
-                # The inputs
-                loc_inputs.each  do |name,sig|
-                    port_pairs << [sig, sig.type.input(name)]
+            # puts "cur_system=#{HDLRuby::High.cur_system} self.parent_system=#{self.parent_system}"
+            if HDLRuby::High.cur_system == self.parent_system then
+                # puts "Inner found!"
+                # Port in same system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    locs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.inner(name)]
+                    end
                 end
-                # The outputs
-                loc_outputs.each do |name,sig| 
-                    port_pairs << [sig, sig.type.output(name)]
+                obj = self
+                # Make the inner connection
+                port_pairs.each do |sig, port|
+                    sig.parent.open do
+                        port.to_ref <= sig
+                    end
                 end
-                # The inouts
-                loc_inouts.each  do |name,sig| 
-                    port_pairs << [sig, sig.type.inout(name)]
+            else
+                # Portds in different system as the channel's case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    # The inputs
+                    loc_inputs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.input(name)]
+                    end
+                    # The outputs
+                    loc_outputs.each do |name,sig| 
+                        port_pairs << [sig, sig.type.output(name)]
+                    end
+                    # The inouts
+                    loc_inouts.each  do |name,sig| 
+                        port_pairs << [sig, sig.type.inout(name)]
+                    end
                 end
-            end
-            obj = self
-            # Make the connection of the instance.
-            HDLRuby::High.cur_system.on_instance do |inst|
-                obj.scope.open do
-                    port_pairs.each do |sig, port|
-                        RefObject.new(inst,port.to_ref) <= sig
+                obj = self
+                # Make the connection of the instance.
+                HDLRuby::High.cur_system.on_instance do |inst|
+                    obj.scope.open do
+                        port_pairs.each do |sig, port|
+                            RefObject.new(inst,port.to_ref) <= sig
+                        end
                     end
                 end
             end
 
             # Fill the writer namespace with the access to the writer signals.
-            @writer_inputs.each do |name,sig|
+            loc_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|
+            loc_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|
+            loc_inouts.each do |name,sig|
                 @writer_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
@@ -741,73 +844,28 @@ module HDLRuby::High::Std
             # NOTE: for now, simply associate the channel to name.
             chp = ChannelPortW.new(@writer_namespace,@writer_proc,@output_reseter_proc)
             HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @write_port = chp
             return chp
         end
 
-        ## Declares the ports for the accesser and assigned them to +name+.
-        def inout(name)
+
+        ## Declares the accesser port and assigned them to +name+.
+        def inout(name = nil)
             # Ensure name is a symbol.
+            name = HDLRuby.uniq_name unless name
             name = name.to_sym
-            # Access the ports
-            loc_inputs  = @accesser_inputs
-            loc_outputs = @accesser_outputs
-            loc_inouts  = @accesser_inouts
-            # The generated port with corresponding channel port pairs.
-            port_pairs = []
-            # Add them to the current system.
-            HDLRuby::High.cur_system.open do
-                # The inputs
-                loc_inputs.each  do |name,sig|
-                    port_pairs << [sig, sig.type.input(name)]
-                end
-                # The outputs
-                loc_outputs.each do |name,sig| 
-                    port_pairs << [sig, sig.type.output(name)]
-                end
-                # The inouts
-                loc_inouts.each  do |name,sig| 
-                    port_pairs << [sig, sig.type.inout(name)]
-                end
-            end
-            obj = self
-            # Make the connection of the instance.
-            HDLRuby::High.cur_system.on_instance do |inst|
-                obj.scope.open do
-                    port_pairs.each do |sig, port|
-                        RefObject.new(inst,port.to_ref) <= sig
-                    end
-                end
+            # Ensure the port is not already existing.
+            if @read_port then
+                raise "Read port already declared for channel instance: " +
+                    self.name
             end
 
-            # Set ups the accesser's namespace
-            @accesser_inputs.each do |name,sig|
-                @accesser_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
-            end
-            @accesser_outputs.each do |name,sig|
-                @accesser_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
-            end
-            @accesser_inouts.each do |name,sig|
-                @accesser_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
+            if @write_port then
+                raise "Write port already declared for channel instance: " +
+                    self.name
             end
 
-            # Give access to the ports through name.
-            # NOTE: for now, simply associate the channel to name.
-            chp = ChannelPortA.new(@accesser_namespace,@reader_proc,@writer_proc,@inout_reseter_proc)
-            HDLRuby::High.space_reg(name) { chp }
-            return chp
-        end
-
-        ## Declares the ports for accessing the channel as an inner component
-        #  and assigned them to +name+.
-        def inner(name)
-            # Ensure name is a symbol.
-            name = name.to_sym
             # Access the ports
             loc_inputs  = @accesser_inputs.merge(@reader_inputs).
                 merge(@writer_inputs)
@@ -818,21 +876,51 @@ module HDLRuby::High::Std
             locs = loc_inputs.merge(loc_outputs).merge(loc_inouts)
             # The generated port with corresponding channel port pairs.
             port_pairs = []
-            # Add them to the current system.
-            HDLRuby::High.cur_system.open do
-                locs.each  do |name,sig|
-                    port_pairs << [sig, sig.type.inner(name)]
+            if HDLRuby::High.cur_system == self.parent_system then
+                # Port in same system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    locs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.inner(name)]
+                    end
                 end
-            end
-            obj = self
-            # Make the inner connection
-            port_pairs.each do |sig, port|
-                sig.parent.open do
-                    port.to_ref <= sig
+                obj = self
+                # Make the inner connection
+                port_pairs.each do |sig, port|
+                    sig.parent.open do
+                        port.to_ref <= sig
+                    end
+                end
+            else
+                # Port in different system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    # The inputs
+                    loc_inputs.each  do |name,sig|
+                        # puts "name=#{name} sig.name=#{sig.name}"
+                        port_pairs << [sig, sig.type.input(name)]
+                    end
+                    # The outputs
+                    loc_outputs.each do |name,sig| 
+                        port_pairs << [sig, sig.type.output(name)]
+                    end
+                    # The inouts
+                    loc_inouts.each  do |name,sig| 
+                        port_pairs << [sig, sig.type.inout(name)]
+                    end
+                end
+                obj = self
+                # Make the connection of the instance.
+                HDLRuby::High.cur_system.on_instance do |inst|
+                    obj.scope.open do
+                        port_pairs.each do |sig, port|
+                            RefObject.new(inst,port.to_ref) <= sig
+                        end
+                    end
                 end
             end
 
-            # Set ups the accesser's namespace
+            # Fill the reader namespace with the access to the reader signals.
             loc_inputs.each do |name,sig|
                 @accesser_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
@@ -853,37 +941,121 @@ module HDLRuby::High::Std
             # NOTE: for now, simply associate the channel to name.
             chp = ChannelPortA.new(@accesser_namespace,@reader_proc,@writer_proc,@inout_reseter_proc)
             HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @read_port = chp
+            @write_port = chp
             return chp
         end
 
+        # ## Declares the ports for accessing the channel as an inner component
+        # #  and assigned them to +name+.
+        # def inner(name)
+        #     # Ensure name is a symbol.
+        #     name = name.to_sym
+        #     # Access the ports
+        #     loc_inputs  = @accesser_inputs.merge(@reader_inputs).
+        #         merge(@writer_inputs)
+        #     loc_outputs = @accesser_outputs.merge(@reader_outputs).
+        #         merge(@writer_outputs)
+        #     loc_inouts  = @accesser_inouts.merge(@reader_inouts).
+        #         merge(@writer_inouts)
+        #     locs = loc_inputs.merge(loc_outputs).merge(loc_inouts)
+        #     # The generated port with corresponding channel port pairs.
+        #     port_pairs = []
+        #     # Add them to the current system.
+        #     HDLRuby::High.cur_system.open do
+        #         locs.each  do |name,sig|
+        #             port_pairs << [sig, sig.type.inner(name)]
+        #         end
+        #     end
+        #     obj = self
+        #     # Make the inner connection
+        #     port_pairs.each do |sig, port|
+        #         sig.parent.open do
+        #             port.to_ref <= sig
+        #         end
+        #     end
+
+        #     # Set ups the accesser's namespace
+        #     loc_inputs.each do |name,sig|
+        #         @accesser_namespace.add_method(sig.name) do
+        #             HDLRuby::High.top_user.send(name)
+        #         end
+        #     end
+        #     loc_outputs.each do |name,sig|
+        #         @accesser_namespace.add_method(sig.name) do
+        #             HDLRuby::High.top_user.send(name)
+        #         end
+        #     end
+        #     loc_inouts.each do |name,sig|
+        #         @accesser_namespace.add_method(sig.name) do
+        #             HDLRuby::High.top_user.send(name)
+        #         end
+        #     end
+
+        #     # Give access to the ports through name.
+        #     # NOTE: for now, simply associate the channel to name.
+        #     chp = ChannelPortA.new(@accesser_namespace,@reader_proc,@writer_proc,@inout_reseter_proc)
+        #     HDLRuby::High.space_reg(name) { chp }
+        #     return chp
+        # end
+
+
         
         ## Performs a read on the channel using +args+ and +ruby_block+
         #  as arguments.
+        #  NOTE:
+        #  * Will generate a port if not present.
+        #  * Will generate an error if a read is tempted while the read
+        #    port has been declared within another system.
         def read(*args,&ruby_block)
-            # Gain access to the reader as local variable.
-            reader_proc = @reader_proc
-            # # The context is the one of the reader.
-            # 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)
+            # Is there a port to read?
+            unless self.read_port then
+                # No, generate a new one.
+                # Is it possible to be inout?
+                if self.inout? then
+                    # Yes, create an inout port.
+                    self.inout(HDLRuby.uniq_name)
+                else
+                    # No, create an input port.
+                    self.input(HDLRuby.uniq_name)
+                end
             end
-            HDLRuby::High.space_pop
+            # Ensure the read port is within current system.
+            unless self.read_port.scope.system != HDLRuby::High.cur_system then
+                raise "Cannot read from a port external of current system for channel " + self.name
+            end
+            # Performs the read.
+            self.read_port.read(*args,&ruby_block)
         end
         
         ## Performs a write on the channel using +args+ and +ruby_block+
         #  as arguments.
+        #  NOTE:
+        #  * Will generate a port if not present.
+        #  * Will generate an error if a read is tempted while the read
+        #    port has been declared within another system.
         def write(*args,&ruby_block)
-            # Gain access to the writer as local variable.
-            writer_proc = @writer_proc
-            # # The context is the one of the writer.
-            # 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)
+            # Is there a port to write?
+            unless self.write_port then
+                # No, generate a new one.
+                # Is it possible to be inout?
+                if self.inout? then
+                    # Yes, create an inout port.
+                    self.inout(HDLRuby.uniq_name)
+                else
+                    # No, create an output port.
+                    self.output(HDLRuby.uniq_name)
+                end
             end
-            HDLRuby::High.space_pop
+            # Ensure the write port is within current system.
+            unless self.write_port.scope.system != HDLRuby::High.cur_system then
+                raise "Cannot write from a port external of current system for channel " + self.name
+            end
+            # Performs the write.
+            self.write_port.write(*args,&ruby_block)
         end
+        
 
         ## Performs a reset on the channel using +args+ and +ruby_block+
         #  as arguments.
@@ -902,10 +1074,12 @@ module HDLRuby::High::Std
 
 
     # Wrapper to make an object run like a channel port.
-    class ChannelPortObject
+    class ChannelPortObject < ChannelPort
         # Create a new object wrapper for +obj+.
         def initialize(obj)
             @obj = obj
+
+            @scope = HDLRuby::High.cur_scope
         end
 
         # Port read with arguments +args+ executing +ruby_block+ in
@@ -946,9 +1120,13 @@ module HDLRuby::High::Std
 
 
     # Wrap object +obj+ to act like a channel port.
-    def channel_port(obj)
+    def self.channel_port(obj)
+        return obj if obj.is_a?(ChannelPort) # No need to wrap.
         return ChannelPortObject.new(obj)
     end
+    def channel_port(obj)
+        return HDLRuby::High::Std.channel_port(obj)
+    end
 end