Abstract:
Methods and apparatus are provided for allowing flexible on-chip datapath interfaces on a device. Datapath connections allow data streamlining without any knowledge of channels or packet boundaries. Flexible and modular interface adapters are used to allow component designers to efficiently provide interoperable components without having to adhere to a strict datapath interface specification. Interface adapters from an adapter library are instantiated and configured automatically when two components are connected.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     This application claims benefit and priority under 35 U.S.C. §120 and is a continuation of co-pending U.S. patent application Ser. No. 11/432,275, filed May 10, 2006, titled “FLEXIBLE ON-CHIP DATAPATH INTERFACE HAVING FIRST AND SECOND COMPONENT INTERFACES THAT COMMUNICATE WITH EACH OTHER WITH DIFFERENT INTERFACE PROPERTIES”, which is hereby incorporated by reference in its entirety. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates to on-chip datapath interfaces. In one example, the present invention relates to methods and apparatus for providing a flexible datapath interface that allows interconnection of a variety of components on a device. 
     BACKGROUND 
     A variety of interconnection mechanisms are used to connect components on a device such as a programmable chip. In some examples, a standard on-chip data path interface specification is defined and components such as intellectual property (IP) cores are configured to conform to the interface specification. For example, components usually are configured to comply with a set of signals and particular timing requirements in order for components to operate with other components on a device. 
     Unfortunately, designers often select components that have support for particular standards or characteristics, thereby preventing design flexibility. In other examples, standard crossing bridges are manually inserted into a design and components supporting particular standards are segregated onto different portions of a design. 
     SUMMARY OF THE INVENTION 
     Conventional techniques and mechanisms for interconnecting components have significant limitations. Consequently, it is desirable to provide improved methods and apparatus for allowing connections between components by using a flexible datapath interface. 
     Methods and apparatus are provided for allowing flexible on-chip datapath interfaces on a device. Datapath connections allow simple data streams, as well as channelized or packet connections. Flexible and modular interface adapters are used to allow component designers to efficiently provide interoperable components without having to adhere to a strict datapath interface specification. Interface adapters from an adapter library are instantiated and configured automatically when two components are connected. 
     In one embodiment, a programmable chip includes a first component data interface associated with a first component and a first adapter data interface associated with a first adapter from an adapter library. The first component data interface includes computer readable first component data interface properties. The first adapter data interface includes first adapter data interface properties corresponding to first component data interface properties. A programmable chip system generator selects the first adapter from the adapter library upon reading first component data interface properties. 
     In another embodiment, a technique for generating a programmable chip is provided. A selection for a first component and a selection for a second component are received. The first component including a first component data interface is provided. The first component data interface includes computer readable first component data interface properties. The second component including a second component data interface is provided. The second component data interface includes computer readable second component data interface properties. A first adapter is selected from an adapter library upon determining first component data interface properties and second component data interface properties. 
     These and other features and advantages of the present invention will be presented in more detail in the following specification of the invention and the accompanying figures, which illustrate by way of example the principles of the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The invention may best be understood by reference to the following description taken in conjunction with the accompanying drawings, which illustrate embodiments of the present invention. 
         FIG. 1  is a diagrammatic representation of a programmable chip. 
         FIG. 2  is a diagrammatic representation showing one example of a programmable chip including components having data interfaces. 
         FIG. 3  is a diagrammatic representation showing one example of a data source interface and a data sink interface. 
         FIG. 4  is a diagrammatic representation depicting one example of an interface adapter. 
         FIG. 5  is a flow process diagram showing one technique for implementing adapters. 
         FIG. 6  is a diagrammatic representation showing one technique for implementing a programmable chip. 
         FIG. 7  is a diagrammatic representation depicting a computer system. 
     
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
     Reference will now be made in detail to some examples of the invention contemplated by the inventors for carrying out the invention. Examples of these embodiments are illustrated in the accompanying drawings. While the invention is described in conjunction with these exemplary embodiments, it will be understood that it is not intended to limit the invention to the described embodiments. On the contrary, it is intended to cover alternatives, modifications, and equivalents as may be included within the spirit and scope of the invention as defined by the appended claims. 
     For example, the techniques of the present invention will be described in the context of programmable chips. However, it should be noted that the techniques of the present invention can be applied to a variety of devices. In the following description, numerous details are set forth in order to provide a thorough understanding of the present invention. The present invention may be practiced without some or all of these details. In other instances, well known process operations have not been described in detail in order not to unnecessarily obscure the present invention. 
     Furthermore, techniques and mechanisms of the present invention will sometimes be described in singular form for clarity. However, it should be noted that some embodiments include multiple iterations of a technique or multiple instantiations of a mechanism unless noted otherwise. For example, a processor is used in a variety of contexts. However, it will be appreciated that multiple processors can also be used while remaining within the scope of the present invention unless otherwise noted. 
     Components on a device have source and sink data interfaces that allow efficient data transfers on a device. Any interface operable to carry high throughput packet, stream, or DSP traffic is referred to herein as a data interface. A datapath associated with many applications includes primarily data interfaces. A data interface is distinct from control, credit, and request interfaces. Control interfaces typically allow lower throughput data transfers and involve master and slave component read and write accesses. Credit interfaces provide buffer level information to a source data interface and request interfaces obtain information from buffers. 
     One component may include data interfaces as well as control, credit, and request interfaces. Other components may similarly include a variety of interfaces. A data interface is typically configured to meet a particular set of requirements. For example, in order to connect to a particular datapath, a data interface may be required to support particular width, bursting, and latency attributes. 
     In conventional systems, data interface compatibility in a system is ensured by using IP blocks that implement components with data interfaces that conform to a particular standard or set of characteristics. Any set of characteristics or parameters associated with a component connection to a bus or other interconnection fabric is referred to herein as interface characteristics. IP blocks are compatible by construction, but a system designer faces limitations. For example, one limitation is that the number of IP blocks supporting an interface specification may be limited. Using a single interface specification, the designer will usually has a less than optimal design. If the designer decides to use an IP block with an incompatible interface, the designer generally spends resources designing a “gasket” or “converter” that converts one data interface to another. 
     The techniques and mechanisms of the present invention recognize that another limitation is decreased performance or increased resource usage. Some IP blocks are designed to support multiple data interface types. For example, one data interface may support bursting and non-bursting transactions. But these more complicated requirements tend to complicate the interface circuitry of IP blocks because interfaces are usually aware of all transaction types, thereby decreasing system performance or increasing the cost of the IP. The techniques and mechanisms of the present invention recognize that the limitations are most pronounced when IP is targeted at programmable chips such as FPGAs. Rich interface standards supporting a variety of attributes often result in usage of complex circuitry that is relatively expensive on programmable chips to differentiate among a variety of transaction types. 
     Bridges and custom circuitry can also be used to convert from one interface type to another. However, adding bridges and custom circuitry is error prone, inefficient, and non-optimal. According to various embodiments, the techniques of the present invention analyze interface requirements and connections required by system components. Interface adapters available from a library of interface adapters are automatically selected for connecting interface types associated with different components. In some instances, multiple stages of interface adapter components may be selected to allow connection of system components. The interface adapters support a rich set of attributes including parameters associated with data transfers, bursting transfers, frame transfers, credit transfers, request transfers, multichannel transfers, etc. According to various embodiments, data interfaces support low latency, high throughput transfers with multiple channel support and flexible packet interleaving. Support is provided for data bursting and sideband signaling of control signals such as channel, error, and start and end of packet delineation. Multichannel credit and request interfaces can be implemented. Interface adapters allowing interconnection of components are automatically selected. 
       FIG. 1  is a diagrammatic representation showing one example of a programmable chip that can use the techniques of the present invention. Any device such as a Field Programmable Gate Array (FPGA) or a Programmable Logic Device (PLD) that is configurable using a hardware descriptor language (HDL) such as Verilog or VHDL is referred to herein as a programmable chip. A programmable chip  151  includes hard coded logic blocks  101  and  103 . In some examples, the hard coded logic blocks  101  and  103  are DSP blocks that can efficiently implement multiplication, multiply-accumulate (MAC) and multiply-add functions. In one example, the hard coded logic block  101  includes a multiplier  121 , an adder  123 , and an accumulator  125 . The multipliers can be configured to feed an adder or an accumulator. 
     According to various embodiments, the DSP block  101  also has input registers that can be configured to operate in a shift register chain for efficient implementation of functions like FIR filters. The programmable chip also includes logic array blocks (LABs), logic cells, or logic elements  111 . The programmable chip uses different types of resources that can be interchangeably used in different allocations to implement a programmable chip. In one example, the programmable chip uses logic elements for implementing each of the various components on the programmable chip. 
     Logic elements typically can be implemented using components such as antifuses, static RAM, and EPROMS. Any mechanism on a programmable chip that performs an operation on a given number of input lines to provide one or more outputs based on information programmed is herein referred to as a logic element. Some logic elements are implemented as combinations of look up tables and switches for performing Boolean operations on input lines. In one example, a logic element includes a 16-bit SRAM lookup table (LUT) that can implement an arbitrary 4-input logic function, circuitry that forms a fast carry chain and a fast cascade chain, a register and preset/reset logic for the register. 
     The programmable chip  151  can also include other components such as a hard coded processor or memory. Alternatively, logic elements can also be used to implement soft processors as well as other components such as hardware accelerators, peripheral devices, and peripheral interfaces. Peripheral devices and peripheral interfaces are herein referred to as components. In some embodiments, a system on a programmable chip can be implemented on the programmable chip  151 . The programmable chip system components are connected using one or more interconnection fabrics. Any mechanism or logic for connecting components in a system is referred to herein as an interconnection fabric. In one example, the interconnection fabric is a bus. In another example, the interconnection fabric is a fabric that actively selects interface adapters to allow components with incompatible data interfaces to connect. 
       FIG. 2  is a diagrammatic representation showing one example of a programmable chip including components having data interfaces. The programmable chip includes a receiver  201 . The receiver includes an external interface  201   a , a control path interface  201   b , and a data interface  201   c . The external interface  201   a  is used to communicate with off-chip components. The control interface  201   b  is used to communicate with a processor core  215  through processor core control interface  215   a  and is also used to communicate with a peripheral  217  through peripheral control interface  217   a . According to various embodiments, the control interface is associated with a Peripheral Components Interface (PCI) bus. In other examples, the control interface is associated with a slave side arbitration fabric or a simultaneous multiple master bus. The receiver data interface  201   c  is used to carry high throughput, low latency, packet, streaming, or DSP traffic. The receiver data interface  201   c  is connected to a demultiplexer  203  through demultiplexer data interface  203   a.    
     The demultiplexer  203  also includes data interfaces  203   b  and  203   c  connected to data buffer  205  through data buffer data interface  205   a  and data buffer  207  through data buffer data interface  207   a  respectively. Buffers  205  and  207  also include control interfaces  205   b  and  207   b  respectively. Credit interfaces  205   d  and  207   d  are used to communicate with scheduler  213  through scheduler credit interfaces  213   a  and  213   c . The credit interfaces are used to communicate the availability of data on an associated data interface, or alternatively, the ability of the interface to receive data. An interface that grants credits to indicate the amount of data it has available is referred to herein as a credit producer. A credit interface that reads credits from a credit producer is referred to herein as a credit consumer. Request interfaces  205   e  and  207   e  are used to communicate with scheduler  213  through scheduler request interfaces  213   b  and  213   d . The request interfaces are used to request data from an associated data interface. According to various embodiments, credit and request interfaces are control interfaces with defined data formats. The scheduler also has a control interface  213   e . The programmable chip also includes a transmitter  209  coupled to a demultiplexer  211  via interfaces  209   a  and  211   c . The demultiplexer  211  is coupled to buffer  205  via interfaces  205   c  and  211   b  and to buffer  207  via interfaces  207   c  and  211   a . Transmitter  209  further includes interfaces  209   b  and  209   c.    
     Parameters are used to specify attributes associated with an interface. According to various embodiments, each parameter defines an attribute such as a signal&#39;s width, or it defines an attribute of the entire interface such as a read latency parameter. A parameter can also be used to specify a signal type. A variety of signals and signal characteristics are supported in a variety of transmission environments. 
     A transfer is an operation that results in data and control being propagated from a source interface to a sink interface during one or more clock cycles. A clock cycle is a clock period. For data interfaces, a ready cycle is a cycle during which the sink can accept a transfer. A beat is the transfer of one unit of data from a source to a sink. For credit and request interfaces, transfers are read and write operations respectively. A symbol is the smallest atomic unit of data. A packet is an aggregation of data and control signals that is transmitted and switched as a composite whole. Packets can have variable length. A burst executes multiple transfers as a unit, rather than treating each cycle as an independent transfer. Bursts allow more efficient transfers. A continuous burst provides that the source will send a minimum amount of data without inserting idle cycles. A channel burst provides that the source will send a minimum amount of data without interleaving data for other channels. Once a source begins a channel burst transfer, it guarantees that no data will be sent for any other channel until the burst is complete. For components that support multiple channels, the credit and request interfaces can be used to communicate the credits available for multiple flows, where a flow is a collection of channels that share credit information. 
     A variety of components including components that support a variety of interfaces are available in a component library associated with a system generator tool such as System On A Programmable Chip (SOPC) Builder available from Altera Corporation of San Jose, Calif. 
       FIG. 3  is a diagrammatic representation showing one example of a data transfer between a source data interface and a sink data interface. A component  307  is associated with a source data interface  301  and a component  309  is associated with a sink data interface  303 . According to various embodiments, a valid signal is used to qualify valid data on cycles where data is being transferred from a source data interface  301  to a sink data interface  303 . On cycles where a valid signal is asserted, typically called beats, the data bus  305  and other source to sink signals are sampled by the sink  303 . On cycles when valid is deasserted, the sink does not sample signals. On interfaces that support backpressure, a ready signal is asserted by the sink  303  to mark ready cycles. A ready_latency parameter can be used to specify the relationship between the ready signal and ready cycles. A data signal typically carries the bulk of the information being transferred from a source to a sink and includes one or more symbols being transferred on every clock cycle. In one example, a first symbol  311 , a second symbol  313 , and a third symbol  315  are all transferred during a particular cycle. A symbol-type parameter may optionally be defined to specify the type of data being carried. Error signals can also be provided to show possible error conditions. 
     In conventional datapath specifications, all components are configured to support a particular set of requirements. For example, all components are usually required to support backpressure, or all components are often required to have the same value of read latency. However, this prevents implementation flexibility. The techniques of the present invention allow flexibility in providing components with different interfaces. 
       FIG. 4  is a diagrammatic representation showing use of interface adapters. Any mechanism holding logic such as IP blocks for implementing interface adapters on a device is referred to herein as an interface adapter library. In one embodiment, an interface adapter library is a database that includes bursting adapters, backpressure adapters, error signal adapters, credit adapters, request adapters, etc. 
     A receiver  403  includes a receiver data interface  405  and a receiver data interface  407 . The receiver data interface  405  is connected to both a demultiplexer  421  through a demultiplexer data interface  423  and to a buffer  425  through buffer data interface  427  over a datapath  441 . According to various embodiments, the techniques of the present invention automatically select adapters from a library of interface adapters. A backpressure support adapter  411  is used to allow connection between the receiver  403  and a buffer  425  through buffer data interface  427 . A ready_latency adapter  413  and the backpressure support adapter  411  are chained to allow connection between receiver  403  and demultiplexer  421 . The preconfigured interface adapters reduce complexity in implementing a device. However, it is recognized that latency may increase. 
     Interface adapters available from a library may not be optimally configured for applications and may indeed slow transfers of data between the receiver  403  and the demultiplexer  421  and the buffer  425 . However, the techniques of the present invention recognize that the tradeoff is beneficial particularly when implemented using a system builder tool. A system builder or system design tool allowing a designer to select components for implementing a system on a chip or a system on a programmable chip emphasizes simplicity of design over latency. For more optimal latency, components having compatible interfaces can be designed. 
     Sharing of adapters is encouraged by considering total cost. A system implemented using fewer adapters will generally have lower total cost. However, in some instances, sharing too extensively can adversely impact system performance. In some instances, the interface adapter itself may become a system bottleneck. Consequently, sharing of adapters is limited for high bandwidth components. 
     Components have a variety of signals and parameters that may cause compatibility problems. According to various embodiments, signals include clock, valid, ready, error, startofpacket, endofpacket, empty, channel, startofframe, emptybeat, and reset signals. According to various embodiments, parameters include width, symbol_type, symbols_per beat, ready_latency, cycles_per_beat, symbols_per_continuous_burst, packets_per_continuous_burst, max_channel, symbols_per_channel, packets_per_channel, is_required, default_value, and treat_as parameters. Any two components can have incompatibilities between signals and parameters. The following tables show some examples of interface adapters that can be provided in an interface adapter library to connect incompatible components. In some instances, no adapter is usually required. In other instances, no adapter logic is usually available to make components compatible. 
     
       
         
               
             
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Backpressure And Ready_Latency Adapters 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The source supports backpressure,  
                 This means that the source will respond  
               
               
                 but the sink does not. 
                 to backpressure, but the sink does not  
               
               
                   
                 need to apply it. The ready input to the  
               
               
                   
                 source interface will be connected  
               
               
                   
                 directly to ‘1’. 
               
               
                 The source does not support 
                 This means that the sink may apply 
               
               
                 backpressure, but the sink does. 
                 backpressure, but the source is unable  
               
               
                   
                 to respond to it. There is no logic that  
               
               
                   
                 the adapter can insert that will prevent  
               
               
                   
                 data loss when the source asserts valid  
               
               
                   
                 but the sink is not ready. The  
               
               
                   
                 components can not be connected. 
               
               
                 The source and sink both support 
                 No adaptation necessary. 
               
               
                 backpressure, and have the same  
                   
               
               
                 value for ready_latency. 
                   
               
               
                 The source and sink both support 
                 The source responds to ready assertion  
               
               
                 backpressure, but the sink&#39;s  
                 or deassertion faster than the sink  
               
               
                 ready_latency parameter is greater  
                 requires it. A number of pipeline stages  
               
               
                 than the source&#39;s. 
                 equal to the ready_latency difference  
               
               
                   
                 will be inserted in the ready path from  
               
               
                   
                 the sink back to the source, causing the  
               
               
                   
                 source and the sink to see the same  
               
               
                   
                 cycles as ready cycles. 
               
               
                 The source and sink both support 
                 The source can not respond to ready 
               
               
                 backpressure, but the sink&#39;s  
                 assertion or deassertion fast enough to 
               
               
                 ready_latency parameter is less than 
                 satisfy the sink. A buffer whose depth  
               
               
                 the source&#39;s. 
                 is equal to the ready_latency difference  
               
               
                   
                 is inserted to compensate for the  
               
               
                   
                 source&#39;s inability to respond in time. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 Error Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The source supports error, but the  
                 The error output from the source is left 
               
               
                 sink does not. 
                 unconnected, and any errors reported by 
               
               
                   
                 the source interface are lost. 
               
               
                   
                 This may indicate a problem with the 
               
               
                   
                 system design. 
               
               
                 The source does not support error,  
                 The error inputs to the sink are all tied to 
               
               
                 but the sink does. 
                 0. 
               
               
                 The source and sink both support  
                 The adapter follows the following steps: 
               
               
                 error. 
                 For each bit in the sink&#39;s error for which 
               
               
                   
                 there is a matching condition in the 
               
               
                   
                 source&#39;s error, the bits are connected. 
               
               
                   
                 If the sink&#39;s error has an “unknown” 
               
               
                   
                 condition, a logical OR is performed on 
               
               
                   
                 remaining source error conditions 
               
               
                   
                 connected to it. 
               
               
                   
                 If the sink&#39;s error has no “unknown” 
               
               
                   
                 condition, all remaining source error 
               
               
                   
                 conditions are left unconnected. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 Multi-Cycle Beat Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The source&#39;s cycles_per_beat  
                 The valid input to the sink is deasserted 
               
               
                 is greater than the sink&#39;s. 
                 once the sink&#39;s cycles_per_beat is satisfied. 
               
               
                   
                 The source&#39;s symbols_per_continuous_beat 
               
               
                   
                 parameter is treated as though it were equal 
               
               
                   
                 to a beat. 
               
               
                 The source&#39;s cycles_per_beat  
                 The adapter holds the data from the source 
               
               
                 is less than the sink&#39;s. 
                 and asserts valid to the sink until the sink&#39;s 
               
               
                   
                 cycles_per_beat is satisfied. The ready 
               
               
                   
                 input to the source is deasserted so that the 
               
               
                   
                 source waits. 
               
               
                   
                 If the source does not support 
               
               
                   
                 backpressure, an error is generated, and the 
               
               
                   
                 cores cannot be connected. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 4 
               
             
             
               
                   
               
               
                 Burst Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The source&#39;s 
                 Every burst from the source translates  
               
               
                 symbols_per_continuous_burst  
                 into an integer number of bursts to the  
               
               
                 is an integer multiple of the sink&#39;s. 
                 sink. No adaptation is necessary. 
               
               
                 The source&#39;s 
                 Per-port buffering is used to adapt to this 
               
               
                 symbols_per_continuous_burst  
                 condition. If no per-port buffering is 
               
               
                 is not an integer multiple of the  
                 available, a message recommending that 
               
               
                 sink&#39;s. 
                 the user instantiate a component that 
               
               
                   
                 supports per-port buffering is provided. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 5 
               
             
             
               
                   
               
               
                 Channel Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The source is channelized with  
                 The user is warned that the interfaces are 
               
               
                 channel or startofframe, but the  
                 incompatible, and should not be 
               
               
                 sink is not. 
                 connected. The channel outputs from the 
               
               
                   
                 source are left unconnected. 
               
               
                 The sink is channelized with  
                 The user is presented with a warning, and 
               
               
                 channel, and the source is not  
                 the channel inputs to the sink are all tied 
               
               
                 channelized. 
                 to 0 10 . 
               
               
                 The sink is channelized with 
                 The user is warned that the interfaces are 
               
               
                 startofframe, but the source is  
                 incompatible, and can not be connected. 
               
               
                 not. 
                 The connection fails. 
               
               
                 The source and sink both sup- 
                 The source&#39;s channel is connected to the 
               
               
                 port channel, and the source&#39;s 
                 sink&#39;s channel unchanged. If the sink&#39;s 
               
               
                 max_channel is less than the  
                 channel signal has more bits, then the 
               
               
                 sink&#39;s max_channel. 
                 higher bits are tied to ‘0’. 
               
               
                 The source and sink both sup- 
                 The source&#39;s channel is connected to the 
               
               
                 port channel, and the source&#39;s  
                 sink&#39;s channel unchanged. 
               
               
                 max_channel is greater than  
                 If the source&#39;s channel signal has more 
               
               
                 the sink&#39;s max_channel. 
                 bits, than the higher bits are left 
               
               
                   
                 unconnected. The user is presented with a 
               
               
                   
                 warning that channel information may be 
               
               
                   
                 lost. 
               
               
                   
                 If the value of the channel output from  
               
               
                   
                 the source is greater than the sink&#39;s 
               
               
                   
                 max_channel parameter, the valid signal 
               
               
                   
                 to the sink is deasserted, such that the  
               
               
                   
                 sink usually never sees data for channels 
               
               
                   
                 higher than 
               
               
                   
                 it&#39;s max_channel parameter. 
               
               
                 The source and sink both sup- 
                 No adaptation is necessary. 
               
               
                 port channel, and the source&#39;s  
                   
               
               
                 symbols_per _channel is an  
                   
               
               
                 integer multiple of the sink&#39;s. 
                   
               
               
                 The source and sink both sup- 
                 Per-port buffering is used to adapt to this 
               
               
                 port channel, and the source&#39;s 
                 condition. If no per-port buffering is 
               
               
                 symbols_per_channel is not an  
                 available, a message recommending that 
               
               
                 integer multiple of the sink&#39;s. 
                 the user instantiate a component that 
               
               
                   
                 supports per-port buffering is provided. 
               
               
                 The source and sink both sup- 
                 A timeslot reassignment component is 
               
               
                 port startofframe, and the  
                 used for adaptation. If no timeslot 
               
               
                 source&#39;s max_channel or  
                 reassignment component is available, a 
               
               
                 symbols_per_channel is 
                 message recommending that the user 
               
               
                 different than the sink&#39;s. 
                 instantiate an appropriate component is 
               
               
                   
                 provided. 
               
               
                 The source and sink both sup- 
                 The user is warned that information 
               
               
                 port startofframe, and the  
                 regarding which beats are empty will be 
               
               
                 source supports emptybeats,  
                 lost by the sink. The emptybeat output 
               
               
                 but the sink does not. 
                 from the source is left unconnected. 
               
               
                 The source and sink both support 
                 The emptybeat input to the sink is tied 
               
               
                 startofframe, and the sink sup- 
                 low, since the source normally never 
               
               
                 ports emptybeats, but the source  
                 provides empty beats. 
               
               
                 does not. 
                   
               
               
                 The source supports startofframe,  
                 The adapter generates channel number for 
               
               
                 and the sink supports channel. 
                 the sink if symbols_per_channel 
               
               
                   
                 and max_channel are compatible. 
               
               
                   
                 Otherwise, the users is presented with a 
               
               
                   
                 message recommending that the user 
               
               
                   
                 instantiate a VQC. 
               
               
                 The source supports channel, and  
                 The adapter can not adapt for this 
               
               
                 the sink supports startofframe. 
                 automatically. The user is presented with 
               
               
                   
                 an error and the connection fails. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 6 
               
             
             
               
                   
               
               
                 Component Signal Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The source and sink have a signal with  
                 The signals are directly connected  
               
               
                 the same type, width, treat_as, and 
                 to one another. 
               
               
                 matching directions. 
                   
               
               
                 The source and sink have a signal  
                 The connection fails. 
               
               
                 with the same type, but the width, 
                   
               
               
                 treat_as parameter, or direction does  
                   
               
               
                 not match. 
                   
               
               
                 The source or sink has a signal that the 
                 The connection fails. 
               
               
                 adjacent interface does not have, and  
                   
               
               
                 the signal&#39;s is_required parameter is ‘1’. 
                   
               
               
                 The source or sink has an output signal 
                 The output signal is left  
               
               
                 that the adjacent interface does not 
                 unconnected. 
               
               
                 have, and the signal&#39;s is_required  
                   
               
               
                 parameter is ‘0’. 
                   
               
               
                 The source or sink has an input signal  
                 The input signal is assigned a  
               
               
                 that the adjacent interface does not  
                 constant value equal to it&#39;s  
               
               
                 have, and the signal&#39;s is_required 
                 default_value parameter. 
               
               
                 parameter is ‘0’. 
               
               
                   
               
             
          
         
       
     
     Tables 1-6 describe interface adapters that can be used for connecting component data interfaces. The techniques of the present invention also provide interfaces adapters that can be used for connecting credit and request interfaces. Tables 7 and 8 show examples of some interface adapters that can be inserted between credit and request interfaces. According to various embodiments, credit and request interfaces are associated with a control path and connected to a fabric or bus such as a simultaneous multiple master fabric or a slave side arbitration fabric. 
     
       
         
               
             
               
               
             
           
               
                 TABLE 7 
               
             
             
               
                   
               
               
                 Credit Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 Fabric Data_Width parameters don&#39;t 
                 A control path bus width adapter is 
               
               
                 Match 
                 provided. 
               
               
                   
                 If the credit sink&#39;s interface is wider  
               
               
                   
                 than the credit source&#39;s, there is a loss  
               
               
                   
                 in status throughput that may affect  
               
               
                   
                 system performance. 
               
               
                 The credit_type of the credit pro- 
                 The interfaces can not be connected. 
               
               
                 ducer does not match that of the  
                   
               
               
                 credit consumer, or the credit pro- 
                   
               
               
                 ducer does not have it defined. 
                   
               
               
                 The credit_width of the credit pro- 
                 The adapter maintains the high order  
               
               
                 ducer is less than that of the credit 
                 bits of the credit counter, incrementing  
               
               
                 consumer. 
                 when it detects a 1-to-0 transition on  
               
               
                   
                 the highest bit from the credit source. 
               
               
                 The credit_width of the credit 
                 The interfaces can not be connected. 
               
               
                 producer is greater 
                   
               
               
                 than that of the credit consumer. 
                   
               
               
                 The max_flow of the credit pro- 
                 At system design time, the user is  
               
               
                 ducer is greater than that of 
                 warned that the max_flow param- 
               
               
                 the consumer. 
                 eters do not match. 
               
               
                 The max_flow of the credit producer  
                 The connection fails to prevent the case 
               
               
                 is less than that of the 
                 where the consumer tries to read credits  
               
               
                 Consumer. 
                 for a flow that doesn&#39;t exist. 
               
               
                 One component uses 
                 The connection fails. 
               
               
                 symbols_per_credit, and the other 
                   
               
               
                 uses packets_per_credit 
                   
               
               
                 The components use different  
                 The value of the credit grant is  
               
               
                 values for symbols_per_credit 
                 modified so that the correct number  
               
               
                   
                 of symbols is seen by the consumer,  
               
               
                   
                 as long as the resulting credit grant is 
               
               
                   
                 for an integer number of beats. If this  
               
               
                   
                 can not be guaranteed, the 
               
               
                   
                 connection fails. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 8 
               
             
             
               
                   
               
               
                 Request Adaptations 
               
             
          
           
               
                 Condition 
                 Description of Adapter Logic 
               
               
                   
               
               
                 The request_width of the request 
                 The request from the source is zero- 
               
               
                 source is less than 
                 extended, and connected to the 
               
               
                 that of the request sink. 
                 sink. 
               
               
                 The request_width of the request 
                 The request from the request source is 
               
               
                 source is greater than that of the  
                 truncated, and connected to the sink. 
               
               
                 request sink. 
                 If a request is made of a size greater  
               
               
                   
                 than that which can be expressed with  
               
               
                   
                 the remaining bits, the adapter will  
               
               
                   
                 assert waitrequest to the request master  
               
               
                   
                 and will provide multiple requests to  
               
               
                   
                 the slave. 
               
               
                 The max_flow of the request master 
                 At system design time, the user is  
               
               
                 Does not match that of the request  
                 warned that the max flow parameters  
               
               
                 slave. 
                 do not match. The signals are  
               
               
                   
                 connected directly. 
               
               
                 One component uses 
                 The connection fails. 
               
               
                 symbols_per_request, and  
                   
               
               
                 the other uses packets_per_request 
                   
               
               
                 The components use different  
                 The value of the request is modified so 
               
               
                 values for symbols_per_request 
                 that the correct number of 
               
               
                   
                 symbols match, as long as the resulting 
               
               
                   
                 request is for an integer 
               
               
                   
                 number of beats. If this can not be 
               
               
                   
                 guaranteed, the connection fails. 
               
               
                   
               
             
          
         
       
     
       FIG. 5  is a flow process diagram showing one technique for implementing a system using port adapters. At  501 , desired connections between primary component ports and secondary components ports are identified. At  505 , components having available compatible ports are connected. At  507 , the largest number of remaining ports on the master side and/or slave side having shared standards and attributes are identified. A shared port adapter is provided if possible at  513 . At  519 , the next largest number of remaining unconnected ports on the master side and/or slave side having shared standards and attributes are identified and a shared port adapter is provided. At  523 , additional shared and dedicated port adapters are provided. At  525 , port adapters are associated with arbitration logic. It should be noted that a variety of techniques are contemplated for selecting ports adapters. Iterative, cot weighting, and graphing techniques can be used. 
       FIG. 6  is a diagrammatic representation showing implementation of an electronic device that can use arbitration logic according to various embodiments. An input stage  601  receives selection information typically from a user for logic such as a processor core as well as other components such as a streaming output device to be implemented on an electronic device. In one example, the input received is in the form of a high-level language program. A generator program  605  creates a logic description  603  and provides the logic description along with other customized logic to any of a variety of synthesis tools, place and route programs, and logic configuration tools to allow a logic description to be implemented on an electronic device. 
     In one example, an input stage  601  often allows selection and parameterization of components to be used on an electronic device. The input stage  601  also allows configuration of variable or fixed latency support. In some examples, components provided to an input stage include intellectual property functions, megafunctions, and intellectual property cores. The input stage  601  may be a graphical user interface using wizards for allowing efficient or convenient entry of information. The input stage may also be a text interface or a program reading a data file such as a spreadsheet, database table, or schematic to acquire selection information. The input stage  601  produces an output containing information about the various modules selected. 
     In typical implementations, the generator program  605  can identify the selections and generate a logic description with information for implementing the various modules. The generator program  605  can be a Perl script creating HDL files such as Verilog, Abel, VHDL, and AHDL files from the module information entered by a user. In one example, the generator program identifies a portion of a high-level language program to accelerate. The other code is left for execution on a processor core. According to various embodiments, the generator program  605  identifies pointers and provides ports for each pointer. One tool with generator program capabilities is System on a Programmable Chip (SOPC) Builder available from Altera Corporation of San Jose, Calif. The generator program  605  also provides information to a synthesis tool  607  to allow HDL files to be automatically synthesized. In some examples, a logic description is provided directly by a designer. Hookups between various components selected by a user are also interconnected by a generator program. Some of the available synthesis tools are Leonardo Spectrum, available from Mentor Graphics Corporation of Wilsonville, Oreg. and Synplify available from Synplicity Corporation of Sunnyvale, Calif. The HDL files may contain technology code readable by a synthesis tool. The HDL files at this point may also be passed to a simulation tool. 
     As will be appreciated by one of skill in the art, the input stage  601 , generator program  605 , and synthesis tool  607  can be separate programs. The interface between the separate programs can be a database file, a log, or simply messages transmitted between the programs. For example, instead of writing a file to storage, the input stage  601  can send messages directly to the generator program  605  to allow the generator program to create a logic description. Similarly, the generator program can provide information directly to the synthesis tool instead of writing HDL files. Similarly, input stage  601 , generator program  605 , and synthesis tool  607  can be integrated into a single program. 
     A user may select various modules and an integrated program can then take the user selections and output a logic description in the form of a synthesized netlist without intermediate files. Any mechanism for depicting the logic to be implemented on an electronic device is referred to herein as a logic description. According to various embodiments, a logic description is an HDL file such as a VHDL, Abel, AHDL, or Verilog file. A logic description may be in various stages of processing between the user selection of components and parameters to the final configuration of the device. According to other embodiments, a logic description is a synthesized netlist such as an Electronic Design Interchange Format Input File (EDF file). An EDF file is one example of a synthesized netlist file that can be output by the synthesis tool  607 . 
     A synthesis tool  607  can take HDL files and output EDF files. Tools for synthesis allow the implementation of the logic design on an electronic device. Some of the available synthesis tools are Leonardo Spectrum, available from Mentor Graphics Corporation of Wilsonville, Oreg. and Synplify available from Synplicity Corporation of Sunnyvale, Calif. Various synthesized netlist formats will be appreciated by one of skill in the art. 
     A verification stage  613  typically follows the synthesis stage  607 . The verification stage checks the accuracy of the design to ensure that an intermediate or final design realizes the expected requirements. A verification stage typically includes simulation tools and timing analysis tools. Tools for simulation allow the application of inputs and the observation of outputs without having to implement a physical device. Simulation tools provide designers with cost effective and efficient mechanisms for both functional and timing verification of a design. Functional verification involves the circuit&#39;s logical operation independent of timing considerations. Parameters such as gate delays are generally disregarded. 
     Timing verification involves the analysis of the design&#39;s operation with timing delays. Setup, hold, and other timing requirements for sequential devices such as flip-flops are confirmed. Some available simulation tools include Synopsys VCS, VSS, and Scirocco, available from Synopsys Corporation of Sunnyvale, Calif. and Cadence NC-Verilog and NC-VHDL available from Cadence Design Systems of San Jose, Calif. After the verification stage  613 , the synthesized netlist file can be provided to physical design tools  619  including place and route and configuration tools. A place and route tool typically locates logic cells on logic elements of a target hardware device and connects wires between the inputs and outputs of the various logic elements in accordance with logic required to implement an electronic design. The device can also be physically tested at  623 . 
     For programmable logic devices, a programmable logic configuration stage can take the output of the place and route tool to program the logic device with the user selected and parameterized modules. According to various embodiments, the place and route tool and the logic configuration stage are provided in the Quartus II Development Tool, available from Altera Corporation of San Jose, Calif. As will be appreciated by one of skill in the art, a variety of synthesis, place and route, and programmable logic configuration tools can be tested using various techniques of the present invention. 
     As noted above, different stages and programs can be integrated in a variety of manners. According to one embodiment, the input stage  601 , the generator program  605 , the synthesis tool  607 , the verification tools  613 , and physical design tools  619  are integrated into a single program. The various stages are automatically run and transparent to a user. The program can receive the user selected modules, generate a logic description depicting logic for implementing the various selected modules, and implement the electronic device. As will be appreciated by one of skill in the art, HDL files and EDF files are mere examples of a logic description. Other file formats as well as internal program representations are other examples of a logic description. 
       FIG. 7  is a diagrammatic representation showing a typical computer system that can be used to implement a programmable chip having bus arbitration with priority encoding and fairness. The computer system  700  includes any number of processors  702  (also referred to as central processing units, or CPUs) that are coupled to devices including memory  706  (typically a random access memory, or “RAM”), memory  704  (typically a read only memory, or “ROM”). The processors  702  can be configured to generate a test sequence for any designated processor. As is well known in the art, memory  704  acts to transfer data and instructions uni-directionally to the CPU and memory  706  is used typically to transfer data and instructions in a bi-directional manner. 
     Both of these memory devices may include any suitable type of the computer-readable media described above. A mass storage device  708  is also coupled bi-directionally to CPU  702  and provides additional data storage capacity and may include any of the computer-readable media described above. The mass storage device  708  may be used to store programs, data and the like and is typically a secondary storage medium such as a hard disk that is slower than memory. The mass storage device  708  can be used to hold a library or database of prepackaged logic or intellectual property functions, as well as information on generating particular configurations. It will be appreciated that the information retained within the mass storage device  708 , may, in appropriate cases, be incorporated in standard fashion as part of memory  706  as virtual memory. A mass storage device such as a CD-ROM  714  may also pass data uni-directionally to the CPU. 
     CPU  702  is also coupled to an interface  710  that includes one or more input/output devices such as such as video monitors, track balls, mice, keyboards, microphones, touch-sensitive displays, transducer card readers, magnetic or paper tape readers, tablets, styluses, voice or handwriting recognizers, or other well-known input devices such as, of course, other computers. Finally, CPU  702  optionally may be coupled to a computer or telecommunications network using a network connection as shown generally at  712 . With such a network connection, it is contemplated that the CPU might receive information from the network, or might output information to the network in the course of performing the above-described method steps. It should be noted that the system  700  may also be associated with devices for transferring completed designs onto a programmable chip. The above-described devices and materials will be familiar to those of skill in the computer hardware and software arts. 
     The hardware elements described above may be configured (usually temporarily) to act as multiple software modules for performing the operations of this invention. For example, instructions for running a generator program, input stage (e.g., a wizard), and/or compiler may be stored on mass storage device  708  or  714  and executed on CPU  708  in conjunction with primary memory  706 . 
     Although many of the components and processes are described above in the singular for convenience, it will be appreciated by one of skill in the art that multiple components and repeated processes can also be used to practice the techniques of the present invention. 
     While the invention has been particularly shown and described with reference to embodiments thereof, it will be understood by those skilled in the art that changes in the form and details of the disclosed embodiments may be made without departing from the spirit or scope of the invention. For example, embodiments of the present invention may be employed with a variety of primary and secondary components and should not be restricted to the ones mentioned above. Although shared I/O lines have been described in the context of a memory controller and a simultaneous multiple primary component switch fabric, shared I/O lines can be used in a system without a memory controller and/or without a simultaneous multiple primary component switch fabric. It is therefore intended that the invention be interpreted to include all variations and equivalents that fall within the true spirit and scope of the present invention.