Class: HDLRuby::High::Connection

Inherits:
Low::Connection show all
Defined in:
lib/HDLRuby/hruby_high.rb,
lib/HDLRuby/hruby_rsim.rb,
lib/HDLRuby/hruby_rcsim.rb

Overview

Extends the Connection class for hybrid Ruby-C simulation.

Constant Summary collapse

High = 
HDLRuby::High

Constants included from Low::Low2Symbol

Low::Low2Symbol::Low2SymbolPrefix, Low::Low2Symbol::Low2SymbolTable, Low::Low2Symbol::Symbol2LowTable

Instance Attribute Summary collapse

Attributes inherited from Low::Transmit

#left, #right

Attributes included from Low::Hparent

#parent

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Low::Connection

#array_connection, #break_concat_assigns, #eql?, #hash, #parent_system, #reassign_expressions!, #to_high, #to_verilog, #top_block, #top_scope

Methods inherited from Low::Transmit

#boolean_in_assign2select!, #break_concat_assigns, #casts_without_expression!, #clone, #each_block, #each_block_deep, #each_deep, #each_node, #each_node_deep, #each_statement_deep, #eql?, #explicit_types!, #extract_selects!, #hash, #initialize, #map_nodes!, #replace_expressions!, #set_left!, #set_right!, #signal2subs!, #to_c, #to_hdr, #to_high, #to_verilog, #to_vhdl, #use_name?

Methods inherited from Low::Statement

#add_blocks_code, #add_make_block, #behavior, #block, #blocks2seq!, #break_types!, #clone, #delete_related!, #delete_unless!, #each_deep, #each_statement, #eql?, #explicit_types!, #extract_declares!, #hash, #mix?, #par_in_seq2seq!, #parent_system, #replace_expressions!, #replace_names!, #scope, #to_c, #to_ch, #to_hdr, #to_high, #to_seq!, #to_upper_space!, #to_vhdl, #top_block, #top_scope, #use_name?, #with_boolean!

Methods included from Low::Low2Symbol

#to_sym

Methods included from Low::Hparent

#hierarchy, #no_parent!, #scope

Constructor Details

This class inherits a constructor from HDLRuby::Low::Transmit

Instance Attribute Details

#rcbehavior ⇒ Object (readonly)

Returns the value of attribute rcbehavior.



717
718
719
 
# File 'lib/HDLRuby/hruby_rcsim.rb', line 717

def rcbehavior
  @rcbehavior
end

Class Method Details

.add_rcevents(sig, rcevs, rcbehavior) ⇒ Object

Add recursively any event to +rcevs+ for activativing the connection from signal +sig+ attached to +rcbehavior+



721
722
723
724
725
726
727
728
729
730
731
 
# File 'lib/HDLRuby/hruby_rcsim.rb', line 721

def self.add_rcevents(sig,rcevs,rcbehavior)
    # Recurse on sub signals if any.
    sig.each_signal do |sub|
        Connection.add_rcevents(sub,rcevs,rcbehavior)
    end
    # Apply on the current node.
    rcsig = sig.is_a?(SignalI) ? sig.rcsignalI : sig.rcsignalC
    ev = RCSim.rcsim_make_event(:anyedge,rcsig)
    RCSim.rcsim_set_owner(ev,rcbehavior)
    rcevs << ev
end

Instance Method Details

#at(event) ⇒ Object

Creates a new behavior sensitive to +event+ including the connection converted to a transmission, and replace the former by the new behavior.



3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
 
# File 'lib/HDLRuby/hruby_high.rb', line 3762

def at(event)
    # Creates the behavior.
    left, right = self.left, self.right
    # Detached left and right from their connection since they will
    # be put in a new behavior instead.
    left.parent = right.parent = nil
    # Create the new behavior replacing the connection.
    behavior = Behavior.new(:par,event) do
        left <= right
    end
    # Adds the behavior.
    High.top_user.add_behavior(behavior)
    # Remove the connection
    High.top_user.delete_connection!(self)
end

#execute(mode) ⇒ Object

Executes the statement.



961
962
963
964
 
# File 'lib/HDLRuby/hruby_rsim.rb', line 961

def execute(mode)
    # puts "connection left=#{left} right=#{right}"
    self.left.assign(mode,self.right.execute(mode))
end

#hif(condition) ⇒ Object

Creates a new behavior with an if statement from +condition+ enclosing the connection converted to a transmission, and replace the former by the new behavior.

NOTE: the else part is defined through the helse method.



3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
 
# File 'lib/HDLRuby/hruby_high.rb', line 3783

def hif(condition)
    # Creates the behavior.
    left, right = self.left, self.right
    # Detached left and right from their connection since they will
    # be put in a new behavior instead.
    left.parent = right.parent = nil
    # Create the new behavior replacing the connection.
    behavior = Behavior.new(:par) do
        hif(condition) do
            left <= right
        end
    end
    # Adds the behavior.
    High.top_user.add_behavior(behavior)
    # Remove the connection
    High.top_user.delete_connection!(self)
end

#init_sim(systemT) ⇒ Object

Initialize the simulation for system +systemT+.



933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
 
# File 'lib/HDLRuby/hruby_rsim.rb', line 933

def init_sim(systemT)
    # Add the connection to the list of untimed objets.
    systemT.add_untimed(self)
    # Recurse on the left and right.
    self.left.init_sim(systemT)
    self.right.init_sim(systemT)
    # Process the sensitivity list.
    # Is it a clocked behavior?
    events = []
    # Generate the events list from the right values.
    # First get the references.
    refs = self.right.each_node_deep.select do |node|
        node.is_a?(RefObject) && !node.parent.is_a?(RefObject) 
    end.to_a
    # Keep only one ref per signal.
    refs.uniq! { |node| node.fullname }
    # puts "connection input: #{self.left.fullname}"
    # puts "connection refs=#{refs.map {|node| node.fullname}}"
    # # Generate the event.
    # events = refs.map {|ref| Event.new(:anyedge,ref) }
    # # Add them to the behavior for further processing.
    # events.each {|event| self.add_event(event) }
    # Now process the events: add the connection to the corresponding
    # activation list of the signals of the events.
    refs.each {|ref| ref.object.add_anyedge(self) }
end

#to_expr ⇒ Object

Converts the connection to a comparison expression.

NOTE: required because the <= operator is ambigous and by default produces a Transmit or a Connection.



3752
3753
3754
3755
3756
3757
 
# File 'lib/HDLRuby/hruby_high.rb', line 3752

def to_expr
    # Remove the connection from the system type.
    High.top_user.delete_connection(self)
    # Generate an expression.
    return Binary.new(:<=,self.left,self.right)
end

#to_low ⇒ Object

Converts the connection to HDLRuby::Low.



3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
 
# File 'lib/HDLRuby/hruby_high.rb', line 3802

def to_low
    # return HDLRuby::Low::Connection.new(self.left.to_low,
    #                                     self.right.to_low)
    connectionL = HDLRuby::Low::Connection.new(self.left.to_low,
                                        self.right.to_low)
    # # For debugging: set the source high object 
    # connectionL.properties[:low2high] = self.hdr_id
    # self.properties[:high2low] = connectionL
    return connectionL
end

#to_rcsim(rcowner) ⇒ Object

Generate the C description of the connection. +rcowner+ is a link to the C description of the owner scope.



735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
 
# File 'lib/HDLRuby/hruby_rcsim.rb', line 735

def to_rcsim(rcowner)
    # puts "make behavior with self.class=#{self.class}"
    # Create the connection C object, actually it is a behavior.
    @rcbehavior = RCSim.rcsim_make_behavior(false)

    # Set the owner.
    RCSim.rcsim_set_owner(@rcbehavior,rcowner)

    # Create and add the events.
    rcevs = []
    self.right.each_node_deep do |node|
        if node.is_a?(RefObject) && !node.parent.is_a?(RefObject) then
            Connection.add_rcevents(node.object,rcevs,@rcbehavior)
            # ev = RCSim.rcsim_make_event(:anyedge,node.to_rcsim)
            # RCSim.rcsim_set_owner(ev,@rcbehavior)
            # rcevs << ev
        end
    end
    if rcevs.any? then
        RCSim.rcsim_add_behavior_events(@rcbehavior,rcevs)
    end

    # Create and set the block.
    rcblock = RCSim.rcsim_make_block(:par)
    RCSim.rcsim_set_owner(rcblock,@rcbehavior)
    # puts "self.left=#{self.left} self.right=#{self.right}"
    RCSim.rcsim_add_block_statements(rcblock,
        [RCSim.rcsim_make_transmit(self.left.to_rcsim, self.right.to_rcsim)])
    RCSim.rcsim_set_behavior_block(@rcbehavior,rcblock)

    return @rcbehavior
end