Patent Publication Number: US-5835491-A

Title: Method for supporting multicast capabilities in switching networks with a reservation ring

Description:
Cross reference is made to the co-pending U.S. Pat. applications Ser. Nos. 08/754,727, 08/754,734, and 08/754,688 filed concurrently herewith, and entitled &#34;ATM Switch With Output Port Clustering For Dynamically Allocating Bandwidth Between Ports,&#34; &#34;Arbitration Ring For Accessing A Limited Bandwidth Switching Network,&#34; and &#34;Arbitration Ring With Automatic Sizing For A Partially Populated Switching Network&#34; respectively. 
     The present invention relates generally to communications networks, and more particularly to a method for arbitrating multicast packet access to a switching network using a reservation ring operating in an ATM (Asynchronous Transfer Mode) switch. 
     BACKGROUND OF THE INVENTION 
     The ATM (Asynchronous Transfer Mode) protocol is an example of a packet switched network protocol that supports a plurality of communications services such as voice, video, and data. Information is transmitted over an ATM network using fixed-sized data packets called cells. Routing information that is used to direct a cell to its destination is contained in the cell&#39;s header. The cell routing information, which is determined at call setup time, specifies a fixed route through a switching network. Depending on the particular fixed route defined through a network, a cell may travel through a series of ATM switches before arriving at its destination. 
     As ATM networks become common and are used as office networks, the availability of small scaleable switches becomes increasingly desirable. ATM switches that are readily scaleable support a number of different configurations at once. Also, a switch that is readily scaleable operates efficiently when its port capacity is partially utilized (or populated). For example, a switch that is readily scaleable can be used to deploy multiple versions of the switch using identical printed circuit boards, thereby reducing manufacturing and development costs. It would, therefore, be advantageous for an ATM switch to operate efficiently using identical circuit boards when the number of ports vary between configurations. Also, it would be desirable to provide an ATM switch that automatically determines while in operation how many ports of the ATM switch are in use during a switch cycle. 
     In an office environment these small, scaleable switches can be used as &#34;ATM extension cords&#34; to connect office equipment to larger and more central switches via a single physical connection. When used in this manner small switches do not necessarily need to support the throughput levels required by a central switch. It is, therefore, desirable that this small scaleable switch architecture operate efficiently while operating with limited switching bandwidth. Small scaleable switches with limited bandwidth switching networks have a set of output ports to which the switching network can transmit a limited number of cells each switch cycle. In general, a switch with limited switching bandwidth operates with a throughput that is less than the aggregate maximum link rate at which the input ports can theoretically operate. In addition to operating with limited bandwidth, it is desirable to have a small switch architecture that ensures that cell loss is infrequent, while supporting traffic priorities and multicast operations. 
     A switch that operates with a limited bandwidth may be &#34;blocking&#34; because such a switch is unable to generate all possible one-to-one input port to output port mappings in a single switch cycle. In a switch that may be blocking, input buffering is required in order to avoid cell loss. Input buffering is also desirable even in the presence of output buffering. For example, input buffers are necessary when output buffers are incapable of queuing the maximum number of cells that might be destined for any particular output buffer during any single switch cycle. As described in U.S. Pat. No. 5,305,311, the combination of input and output buffering provides an effective method for limiting the output buffer bandwidth required to achieve loss-less switching. 
     It is well known, however, that switches that use input queuing and deliver one cell to an output port per switch cycle suffer from head of queue blocking. Generally, head of queue blocking will cause a gross degradation in throughput. U.S. Pat. 5,305,311, discloses the notion of speeding up each output port by a factor of &#34;k&#34; (e.g. k=2) each switch cycle to minimize head of queue blocking. This speedup of &#34;k&#34; per output port increases throughput from approximately 58% for k=1 (purely input queued) to approximately 89% for k=2 and nearly 100% for k=4 and above. 
     One resource that limits the amount of bandwidth available when designing a small scaleable switch is the number of pins available on integrated circuits used to build the switch. For example, in a bus-based switching network, the width of the bus limits the bandwidth of the bus. Besides the bus width, the bandwidth for a bus-based switching network is limited by the clock speed of the switch, and the number of ports on the switch. Consequently, in a small scaleable switch with a bus based switching network, the bandwidth at which the switch can operate is often constrained by the number of wires that link input and output ports of the switching network. 
     SUMMARY OF THE INVENTION 
     In accordance with one aspect of the invention, there is provided in a switch a method for arbitrating multicast packet access to destination output channels of a switching network with a reservation ring. The switching network routes in a single pass multicast packets from selected ones of I input channels to selected ones of J output channels during a switch cycle. The reservation ring resolves conflicts between input channels contending for identical output channels during the switch cycle. The method includes the steps of: initiating an arbitration session for a multicast cell by submitting an arbitration request identifying a set of destination output channels; arbitrating, during an arbitration cycle, for access to each of the destination output channels in the set of destination output channels; eliminating from the set of destination output channels those destination output channels that were granted a reservation after completing the arbitration cycle; and repeating the arbitrating step and the eliminating step over consecutive arbitration cycles. The repeating step terminates the arbitration session when each destination output channel in the set of destination output channels is granted a reservation. 
     In accordance with another aspect of the invention, there is provided in a switch a method for determining when to route a multicast packet over a switching network with a reservation ring. The switching network routes multicast packets from selected ones of a plurality of input channels to selected ones of a plurality of output channels during a switch cycle. The reservation ring resolves conflicts between input channels contending for identical output channels during a switch cycle. The method includes the steps of: submitting to the reservation ring an arbitration request identifying a multicast packet to be routed from one of the input channels to a set of the output channels; performing an arbitration cycle with the reservation ring to identify a subset of output channels in the set of output channels of the arbitration request that are available next switch cycle; and repeating the performing step during subsequent switch cycles until access to each of the output channels in the set of output channels is granted. 
     In accordance with yet another aspect of the invention, there is provided a switch that includes a switching network for routing in a single pass multicast packets from ones of I input channels to ones of J output channels during a switch cycle. A reservation ring resolves conflicts between input channels contending for identical output channels during the switch cycle. Means initiate an arbitration session over the reservation ring for a multicast cell by submitting an arbitration request identifying a set of destination output channels. Means arbitrate, with the reservation ring during an arbitration cycle, for access to each of the destination output channels in the set of destination output channels. Means eliminate from the set of destination output channels those destination output channels that were granted a reservation after completing the arbitration cycle. Means repeat the arbitrating means and the eliminating means over consecutive arbitration cycles. The repeating means terminates the arbitration session when each destination output channel in the set of destination output channels is granted a reservation. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     These and other aspects of the invention will become apparent from the following description which illustrates a preferred embodiment of the invention read in conjunction with the accompanying drawings wherein the same reference numerals have been applied to like parts and in which: 
     FIG. 1 schematically illustrates a modular hierarchical ATM (Asynchronous Transfer Mode) switch incorporating the present invention; 
     FIG. 2 schematically illustrates a data path diagram of the cluster modules shown in FIG. 1; 
     FIG. 3 schematically illustrates data structures in a memory unit of a cluster module shown in FIG. 1; 
     FIG. 4 schematically illustrates an alternate embodiment of the modular hierarchical ATM switch shown in FIG. 1; 
     FIG. 5 schematically illustrates multi-port clusters with speedup consolidation; 
     FIG. 6 schematically illustrates an example of speedup consolidation using a bus-based network; 
     FIG. 7 schematically illustrates an example of speedup consolidation using parallel routing networks, such as a multi-plane crossbar or banyan routing network; 
     FIG. 8 schematically illustrates an example of a bus-based switching network that is blocking; 
     FIG. 9 schematically illustrates an example of a dual bus-based switching network that is blocking; 
     FIG. 10 schematically illustrates an example of a fabric-based switching network that is blocking; 
     FIG. 11 schematically illustrates a reservation ring operating in the modular hierarchical switch shown in FIG. 1; 
     FIG. 12 schematically illustrates the control state of an arbitration unit; 
     FIG. 13 illustrates a flow chart depicting the general steps performed by each arbitration unit during an arbitration session; 
     FIG. 14 illustrates a flow chart detailing steps 106 and 108 shown in FIG. 13 that relate to arbitrating for output channels and output ports; 
     FIG. 15 illustrates a flow chart detailing steps 110 and 112 shown in FIG. 13 that relate to arbitrating for switching fabric bandwidth; 
     FIG. 16 illustrates a flow chart detailing steps 114, 116, and 117 shown in FIG. 13 that relate to determining which arbitration units have won a current arbitration cycle; 
     FIGS. 17A-17C schematically illustrate the reservation ring 14 performing multicast arbitration; 
     FIG. 18 illustrates one embodiment for automatically determining the length of a reservation ring; 
     FIGS. 19 and 20 illustrate a flow chart depicting the general steps performed by each arbitration unit forming the arbitration ring in FIG. 18; 
     FIGS. 21 and 22 illustrates a manner of operating the reservation ring shown in FIG. 18; 
     FIGS. 23 and 24 illustrate a flow chart depicting the general steps performed by each arbitration unit of the reservation ring shown in FIG. 11 in another embodiment for automatically determining the length of a reservation ring; 
     FIGS. 25, 26, 27, and 28 illustrates a manner for operating the reservation ring shown in FIG. 11; 
     FIG. 29 illustrates a flow chart detailing yet another embodiment for automatically sizing the length of a reservation ring using a configuration mask register; and 
     FIG. 30 schematically illustrates again yet another embodiment for automatically sizing the length of a reservation ring using a detection circuit. 
    
    
     DETAILED DESCRIPTION 
     A. Modular Hierarchical Switch Architecture 
     Referring now to the drawings where the showings are for the purpose of describing an embodiment of the invention and not for limiting same, FIG. 1 illustrates a general block diagram of an ATM (Asynchronous Transfer Mode) switch 5 incorporating the present invention. It will be appreciated by those skilled in the art that the present invention is not limited to an ATM switch but can be generalized to any packet switched network. It will also be appreciated that unlike ATM networks, other packet switched networks do not require fixed-sized data packets but instead require only that data packets not exceed a maximum permissible transport unit size (MTU). 
     The switch 5 includes a plurality of cluster modules 8 that are coupled by switching network channels 12 and 13 to an intercluster switching network 10. Each cluster module 8 has one or more input/output (I/O) ports 16. The architecture of the switch 5 is both modular and hierarchical. The modularity of the switch permits the switch to be readily scaleable, while the hierarchical nature of the switch increases average throughput of the switch by enabling ports to share switching bandwidth and by allowing traffic destined for ports 16 on the same cluster module 8 to avoid traversing the switching network 10. Access by a cluster module 8 to the intercluster switching network 10 is scheduled using an arbitration or reservation ring 14. The reservation ring 14 is a distributed arbiter that is implemented as a linear systolic array of finite state machines or arbitration units 15 that are coupled by lines 17. Each arbitration unit 15 in the ring 14 communicates with its immediate neighbor. Among the advantages of a linear systolic array, such as reservation ring 14, are that all communications are local and electrical loads do not grow with array size. This enables linear scaling of the switch 5. 
     Switching of cells or packets through intercluster switching network 10 can be performed by any one of a plurality of switching networks. For example, the intercluster switching network 10 can be implemented using either a cross bar network, a bus network, or batcher/banyan routing network. The makeup of intercluster switching network 10 depends on a number of factors that include the number of cluster modules 8 coupled to switching network 10, and the bandwidth requirements of the switch 5. Typically, a bus architecture is used with a switch 5 that connects a moderate number of ports, while a cross bar architecture may be used to connect a larger number of ports. Each cluster module 8 accesses the intercluster switching network 10 while servicing a plurality of ports 16. 
     The switch 5 includes a host processor 20 which communicates over host control bus 22. The host processor 20 responds to control cells, such as OAM cells (Operations, Administration, and Maintenance), manages virtual circuits, allocates queue buffers, configures the VCI/VPI (virtual circuit index/virtual path index) maps, sets switch registers 42 (shown in FIG. 2), and responds to errors from cluster modules 8. The host processor 20 includes serial and parallel interfaces (not shown) that can be used for communicating control, monitoring information, and debugging problems in the switch 5. Communication between host processor 20 and cluster controller 24 is asynchronous. The host processor 20 can be any standard processing unit such as the Motorola MC68360 processor. 
     Each cluster module 8 includes a cluster controller 24, a memory unit 28, a port interface unit 27, and at least one switching network interface unit 19. The cluster controller 24, an example of which is discussed below, provides the control and primary data path of the cluster module 8. The memory unit 28, which is external to the cluster controller 24, buffers cells and stores cell mapping information. Because the memory unit 28 is external to the cluster controller 24, the amount of memory in unit 28 can be readily altered. This modular aspect of switch 5 provides flexibility when installing adequate cell buffering for specified traffic management requirements. 
     The port interface unit 27 of each cluster module 8 contains a plurality of port interfaces 26. Each port interface 26 is an interface for receiving and transmitting cells over a network such as a Synchronous Optical NETwork (SONET). For example, when a port interface 26 is coupled to a SONET interface (not shown) through an external port 16, the interface control unit 27 receives and converts a SONET serial stream into an input cell byte stream which is stored in a first internal FIFO (first-in first-out) memory queue (not shown). In addition, the interface control unit accepts an output cell byte stream, which is independent from the input cell byte stream, into a second internal FIFO memory queue (not shown) before converting it into an appropriate SONET serial stream for transmission over fiber optic cables (not shown). Examples of interface control units that perform this or most of this functionality are the TI TDC1500, the IGT WAC-013-A, and the PMC SUNI-LITE. Alternatively, a port interface 26 can provide interface control to other networks such as radio, and microwave. 
     The routing of packets through switch 5 is hierarchically organized. Specifically, packets do not necessarily route through intercluster switching network 10. Rather, packets destined to ports within a cluster module 8 are routed without accessing the intercluster switching network 10. For example, intra-cluster communication occurs between two hosts, such as two workstations, that are each coupled via a SONET link to a port 16 of a single cluster module 8. More specifically, intra-cluster communication occurs when two ports 16 of a cluster module 8 do not transmit packets over the intercluster switching network 10. This hierarchical aspect of the switch 5 reduces the bandwidth requirements of intercluster switching network 10 because each cluster module 8 manages its own intra-cluster data traffic. Also, this hierarchical aspect reduces latency for intra-cluster communication since the associated delays with the switching network are avoided. 
     Accordingly, each cluster module 8 supports both intra-cluster as well as inter-cluster communication. Inter-cluster communication involves switching between ports coupled to different cluster modules 8 using the intercluster switching network 10. Access to the intercluster switching network 10 is gained through the switching network interface unit 19 of each cluster module 8. Each switching network interface unit 19 includes an arbitration unit 15 and a switching network interface 18. A packet of data is initially held by switching network interface 18 until access (or a reservation) to both the switching network 10 and an output channel 13 of switching network 10 is won (or made) by arbitration unit 15. The method for arbitrating access to the switching network 10 over reservation ring 14 is discussed in detail below. 
     FIG. 2 illustrates a data path diagram of the cluster module 8 shown in FIG. 1. Data is routed through the cluster controller 24 using a shared memory bus 30. Access to bandwidth of shared memory bus 30 is scheduled so that access is guaranteed to memory bus 30 by buffers 32 coupled to interface control unit 26, by buffers 38 coupled to switching network interface 18, and by the host interface 46. One form of scheduling is round robin scheduling. Another form of scheduling is dynamic scheduling that assigns varying levels of priority for access to bandwidth of shared memory bus 30. Queue/map address registers 42, and queue status and counters 44 are coupled to shared memory bus 30 and are used for controlling data stored in memory 28. 
     Cluster controller 24 communicates with each port interface 26 through a set of port buffers that are indicated generally by reference numeral 32. FIG. 2 shows cluster controller communicating with two port interfaces 26. Each set of port buffers 32 include registers 34 that transmit cell data to and from cell buffers 36. Cell buffers 36 provide temporary storage for a cell before acquiring access to shared memory bus 30. In addition, host processor 20 communicates with a cluster controller 24 through processor interface 46 that is coupled to shared memory bus 30. 
     Cluster controller 24, also, communicates with switching network interface 18 through a set of buffers indicated by reference numeral 38. The set of buffers 38 include cell buffers 31 and 33, registers 34, and multiplexers 35 and 37. Buffer 33 is a pipeline register where cells are stored until access to the switching network 10 is won by arbitration unit 15. The multiplexers 35 and 37 adjust the width of the data path as it changes between the intercluster switching network 10 and the shared memory bus 30. The switching network interface 18, which consists of cell buffer 39 and switching network output buffer 40, communicates through connections 21 with the set of buffers 38. The size of the switching network output buffer 40 is selected to satisfy the requirements of the intercluster switching network 10, the specifics of which are discussed below. In general, the cell buffers could also be used to transfer data across clock domains (e.g., different logic units running off of different clocks) if the cluster controller 24 operates of at a different frequency than its external interface operates. 
     The set of buffers 38 and the switching network interface 18 form a pair of double buffers. Communication between the intercluster switching network 10 and the cluster controller 24 is double buffered on the output path so that the transmission of an cell can overlap with the arbitration for a subsequent cell&#39;s access to the intercluster switching network 10. Also, communication between the intercluster switching network 10 and the cluster controller 24 is double buffered on the input path so that receiving a cell from the switching network is independent and concurrent with the transferring of cell data to memory unit 28. 
     FIG. 3 illustrates data structures that are defined in memory 28 and used for buffering cells and scheduling output through port buffers 32 to interface control unit 26. Specifically, the data structures in memory 28 include input queues 50, a plurality of output queues 52, VPINCI maps 54, and free cell list 56. In accordance with the hierarchical organization of each cluster module 8, cells originating from port buffers 32 are routed through shared bus 30 to either input queues 50 or output queues 52, as indicated by arrows 51 and 53 respectively. These queues insure rate matching between ports 16 and channels 12 and 13. In the case of inter-cluster switching, cells are directed to input queues 50 for routing over intercluster switching network 10. Cells routed through intercluster switching network 10 are directed to output queues 52, as indicated by arrows 55. In the case of intra-cluster switching, cells originating from buffers 32 are not routed over intercluster switching network 10, but instead are directed to output queues 52 before being routed to ports 16. 
     The data structures shown in FIG. 3 are configured to organize cells into FIFO (first in first out) queues. The number of FIFO queues defined in memory 28 of a particular switch 5 depends on cell flow priority policies that dictate how cells are managed. In one instance, FIFO queues are created one per virtual circuit and then scheduled according to a packet scheduling algorithm such as virtual clock or weighted fair queuing. Alternatively, as shown in FIG. 3, FIFO queues can be organized according to traffic priority. In FIG. 3, input queues or buffers 50 include input queue 60 which handles high priority reserved or rate-guaranteed traffic, and input queue 62 which handles lower priority unreserved traffic. The input queues 50 can be implemented using circular linked lists that are allocated by the host processor 20. Since the head and tail pointers of the linked lists are shared between virtual circuits (VCs) and cannot be stored in the VCI Map 54, the status of the queue pointers are stored in registers 44 (shown in FIG. 2). The output queues or buffers 52, in FIG. 3, are organized as FIFO linked lists whose elements are dynamically allocated as needed from free cell list 56. Output queues 52 include output queue 66 which handles high priority reserved traffic, and output queue 68 which handles lower priority unreserved traffic. Cells from host processor 20 are routed to a single input queue 64 since the host processor 20 does not enqueue cells rapidly. Cells to be output to host processor 20 are stored either in output queue 70 or output queue 72. Higher priority reserved traffic is stored in output queue 70 while lower priority unreserved traffic is stored in output queue 72. 
     Cells stored in input queues 50 are scheduled for routing through intercluster switching network 10 by reservation ring 14. In contrast, cells stored in output queues 52 are output to port 16 or host processor 20 according to their priority in the output queues 52. Cells in the higher priority output queues 66 and 70 are given priority over cells in output queues 68 and 72. In the instance in which an output queue is created per virtual circuit, a scheduling mechanism is used to decide which output queue to select a cell for output from, the details of which are discussed below. An example of two scheduling mechanisms for servicing output queues which are created per virtual circuit are a calendar queue and a schedule wheel. Schedule wheels are described in detail in U.S. Provisional patent application entitled &#34;Rate Shaping in Per-Flow Output Queued Routing Mechanisms Having Output Links Servicing Multiple Physical Layers,&#34; Ser. No. 60/020,642, the disclosure of which is incorporated herein by reference. 
     FIG. 4 illustrates an alternate embodiment of the switch architecture shown in FIG. 1. In the embodiment shown in FIG. 4, channel units 23 replace the cluster controllers 24 and the cluster memory units 28 shown in FIG. 1. Each channel unit 23 includes a port interface 26, a channel controller 25, and a channel memory unit 29. Cells routed from the switching network via outgoing channels 13 are copied to each channel unit 23. Consequently, each channel unit 23 must determine whether a cell from switching network interface 19 is destined to its port 16. 
     It will be appreciated by those skilled in the art that in either the embodiment show in FIG. 1 or the embodiment shown in FIG. 4, the switch architectures are not limited to having a single arbitration unit 15, a single input channel 12, or a single output channel 13 per cluster module but instead can be configured to have two or more arbitration units 15, input channels 12, and output channels 13. It will also be appreciated by those skilled in the art that the number of input channels and output channels, and the number of input ports and output ports coupled to each cluster module does not have to be constant but can vary in number between cluster modules of the switch 5. 
     B. Output Port Clustering For Speedup Consolidation 
     U.S. Pat. No. 5,327,420 to Lyles, describes a reservation ring which reduces output port contention by ensuring that up to &#34;k&#34; cells are presented to a switching fabric for distribution to any one output port (e.g. output port 16) during a single switch cycle, where k is an integer greater than one. It has been found that distributing more than one (i.e., k&gt;1) cell to an output port per switch cycle reduces input queue blocking. Consequently, it is advantageous for a switching network to distribute as many cells to an output port as possible during any one switch cycle. However, as &#34;k&#34; is increased for a switch, costs for the switch tend to increase significantly since increasing &#34;k&#34; in the switching network typically involves either using higher speed circuits or duplicating parts of switching networks &#34;k&#34; times. For example, the batcher sorting network requires &#34;k&#34; banyan routing switches in the batcher/banyan switching fabric disclosed in U.S. Pat. No. 5,327,420. 
     Even though each output port in the switch described in U.S. Pat. No. 5,327,420 (&#39;420) has a speed up factor of &#34;k&#34; that is greater than one, on average (i.e., over a period of time in which there exists a sustainable throughput of cells through the switch) the switch in &#39;420 must have no more than one cell per cell time arriving in the output buffer for each port. If this were not true, then the output buffer would eventually overflow since cells would be inserted into the output buffer faster than they would be output from the buffer. This means that, the switch in &#39;420 operates so that the effective utilization factor of the switching network 10 of any output buffer is equal to one on average. This implies that any speedup factor of &#34;k&#34; greater than one goes unused over time when data packet traffic has an acceptable traffic profile (e.g., when the traffic is conforming as defined by ITu-T Recommendation I.371). 
     FIG. 5 schematically illustrates how cluster modules 8 can be used to reduce output port contention while increasing the effective &#34;k&#34; speedup of each output port 16. In operation, the reservation ring 14 schedules up to &#34;K&#34; (upper case) (where K &gt;1) cells for distribution to any one output channel 13 through the intercluster switching network 10 during a switch cycle. As described above, a speedup factor of &#34;k&#34; reduces output port contention caused by head of queue blocking. However, unlike the speedup factor &#34;k&#34; (lower case) described in U.S. Pat. No. 5,327,420, the speedup factor &#34;K&#34; (upper case) is shared among output ports 16 of a cluster module 8. Sharing the speedup factor of &#34;K&#34; with each port of a cluster module 8 has the advantageous result of increasing the effective &#34;k&#34; (lower case) speedup per output port 16 without comparable increases in cost. 
     In essence, &#34;K&#34; (upper case) is a speed up factor per cluster module 8 that equals (p*k) where &#34;p&#34; is the number of ports 16 per cluster module 8, and &#34;k&#34; (lower case) is a speed up factor per port 16 in a switch without clustering. This speedup factor of &#34;K&#34; (upper case) per output channel 13 is shared among output ports 16 within a single cluster module 8. Thus, clustering can be used to increase the peak speedup per port from &#34;k&#34; to &#34;K&#34;. In other words, by limiting the number of cells directed to an output channel 13 of a cluster module 8 to &#34;K&#34; during a switch cycle rather than limiting the number of cells directed to a single output port 16 to &#34;k&#34; (lower case), the effective &#34;k&#34; for each output port of a cluster module can be increased. 
     In addition, consolidating the &#34;k&#34; port speed up factors into a &#34;K&#34; speed up factor per cluster module advantageously increases the average throughput of the switch 5 during a switch cycle. Average throughput is increased by increasing the effective &#34;k&#34; speed up per output port 16. An additional advantage of sharing the speedup factor &#34;K&#34; between ports of a cluster module, is that less of the aggregated speedup factor &#34;K&#34; of the cluster module goes unused over time. To this end, consolidating and sharing bandwidth needed to support single port 16 into the bandwidth needed to support an associated cluster module 8 ensures that otherwise idle bandwidth of an inactive port of a cluster module can be utilized by an active port of the cluster module during a switch cycle. 
     For example, the switch 5 shown in FIG. 5 increases the peak bandwidth for each of the six (&#34;P&#34;=6) output ports 16 by switching up to four (K=4) cells per cluster module 8 through intercluster switching network 10 during a switch cycle. More specifically in FIG. 5, two (&#34;p&#34;=2) output ports 16 are coupled to each of the three (&#34;M&#34;=3) cluster modules 8 thereby sharing the intercluster switching network&#39;s capacity for delivering up to four (K=4) data packets to each cluster module every switch cycle. Thus, depending on the number of cells directed to a particular output port 16 during a switch cycle, the intercluster switching network 10 can deliver a maximum of four (K=4) (upper case) cells to a single output port 16 of a cluster module 8 each switch cycle. Accordingly, the peak &#34;k&#34; (lower case) per port 16 of a cluster module 8 (e.g. K (upper case)) is larger than the average peak &#34;k&#34; of the ports 16 of the cluster module 8 (e.g., &#34;k&#34;=K/p=2). 
     It will be appreciated by those skilled in the art that &#34;K&#34; for a cluster module can be defined so that the number of cells delivered to an output port 16 is less than one on average per switch cycle. For example, the switch 5 in FIG. 5 could operate with a speedup equal to one (K=1). This would mean that each of the two (p=2) output ports 16 of a cluster module would share the intercluster switching network&#39;s capacity for delivering up to one (K=1) data packet per switch cycle. Defining output channels that cannot deliver a cell to every port of the cluster module during one switch cycle provides the effect of using part or all of a switch as a consolidator instead of using the cluster module for sharing increased bandwidth &#34;K&#34; between ports. 
     B.1 Speedup Consolidation For Bus-Based Switching Networks 
     FIG. 6 illustrates a manner of performing speedup consolidation on a bus-based switching network. More specifically, FIG. 6 illustrates several switch cycles of a bus based switching network that is represented using frames. In FIG. 6, each frame(f) is divided into three time slots (e.g., one time slot per input channel 12 of the bus-based switching network). During each time slot of a frame, a cell is transmitted over the bus-based switching network. When cells are not available to fill a slot during a frame, idle cells are sent in the place of actual cells. Arbitration for access to the bus-based switching network takes place during one bus frame since the time required for an arbitration cycle may be longer than the time required to transmit a cell over the bus-based switching network. Thus, arbitration for bus slots in a subsequent bus frame (e.g., frame(f+1)) takes place during transmission of a current bus frame (e.g., frame(f)). In the event a cell is multicast, the multicast cell can be sent to each switching channel 13 over the bus-based switching network in one bus slot so long as the K speedup per output channel is not exceeded. 
     FIG. 6 shows one manner of representing several switch cycles of a bus-based switching network with a consolidated speedup of K per output channel. Speedup consolidation is achieved in a bus-based switching network by delivering up to K cells to an output channel 13 during a switch cycle. In a bus-based switching network having a switch cycle equivalent to a frame &#34;f&#34; shown in FIG. 6, the value of &#34;K&#34; for the bus-based switching network is defined by the number of data packets that each output channel 13 can receive during each frame time. In the example shown in FIG. 6, each of three output channels Out 1 , Out 2 , and Out 3  may receive up to two (K=2) data packets or cells each bus frame from different ones of three input channels In 1 , In 2 , and In 3 . The switching bandwidth can be allocated in a number of ways. For example, one slot can be allocated in a round robin fashion to each of the input channels. Once bandwidth is reserved in a frame &#34;f&#34;, as discussed in detail below, cell data C i:j  is output onto the bus-based switching network from input channel &#34;i&#34; for transmission to one or more output channels &#34;j&#34; of the bus-based switching network. The number of destination output channels to which the input channels transmit is limited so that the speedup factor of K per output channel is not violated. In the example shown in FIG. 6, during frame(f) cell data is transmitted from input channel In 1  to output channel Out 2  (e.g., C 1:2 ) in slot zero, cell data is transmitted from input channel In 2  to output channels Out 1  and Out 3  (e.g., C 2:1 .3) during slot one, and cell data is transmitted from input channel In 3  to output channel Out 2  (e.g., C 3:2 ) during slot two. In this example speedup consolidation is maintained because no more than K=2 cells are transmitted to each of the three output channels each frame time. 
     To accommodate speedup consolidation when switch 5 is configured with a bus-based switching network, the capacity of the buffer 40 of cluster module 8 (shown in FIG. 3) must be large enough to accommodate a burst of &#34;K&#34; cells during a switch cycle from output channel 13. For example, in a switch with a speedup of K=4 cells, the buffer 40 must have a storage capacity of approximately eight cells in the event a cluster module 8 receives four cells during two consecutive switch cycles. This storage capacity is sufficient to buffer up to two back-to-back burst of K=4 cells. In other words, the buffer 40 can be filled over a switch cycle with 2*K cells by receiving K cells at the end of one switch cycle and K cells at the beginning of the next switch cycle. The actual required storage capacity of buffer 40, however, may be somewhat less than the size of eight cells since the buffer 40 is simultaneously emptied and filled. 
     B.2 Speedup Consolidation For Fabric-Based Switching Networks 
     FIG. 7 illustrates an example of speedup consolidation using fabric-based routing networks (i.e., parallel networks). In FIG. 7, the intercluster switching network 10 is composed of &#34;K&#34; (upper case) fabric-based routing networks (i.e., &#34;K&#34; parallel routing planes). An example of a fabric-based routing network is a banyan routing network, which is described in U.S. Pat. No. 5,327,420, the disclosure of which is incorporated herein by reference. More specifically, FIG. 7 illustrates a fabric-based routing network in which each output channel 13 has four parallel sub-channels. Each sub-channel is connected to a different routing plane (e.g., a distinct banyan routing network). Unlike the bus-based switching network described in FIG. 6 which time multiplexes the delivery of cells to output channel destinations, the fabric-based routing network space multiplexes up to four (e.g. K=4) cells to each output channel 13 each switch cycle. 
     B.3 Dynamic Allocation Of Speedup Consolidation 
     Because the speed-up &#34;k&#34; (lower case) is no longer fixed per output port 16, the peak &#34;k&#34; for a port 16 can be dynamically allocated. In this embodiment, the switch 5 dynamically divides the speed-up of &#34;K&#34; per cluster module among associated cluster module output ports 16. More specifically, in this embodiment a maximum speed-up of &#34;k --  alloc&#34; cells is defined for each output port 16 such that the sum of the speedup (k --  alloc) for each output port within a cluster module 8 is less than or equal to K. That is &#34;k --  alloc&#34; represents a peak number of cells that can be received by an associated output port 16 of a cluster module 8 during a switch cycle. In addition, this defined maximum speed-up of k --  alloc cells per output port can be dynamically adjusted in response to expected traffic patterns so that 0≦k --  alloc≦K. In effect, the speed-up k --  alloc per output port 16 defines a maximum peak &#34;k&#34; for an output port 16 of a cluster module 8. 
     Dynamically allocating the speed-up of &#34;K&#34; per cluster module among its output ports advantageously provides a method for altering the effective &#34;k&#34; for each port 16 of a cluster module 8 to account for varying traffic conditions. In other words, the switch 5 defines and dynamically regulates a unique &#34;k --  alloc&#34; for each port of a cluster module as cell data traffic changes over time. More specifically, dynamically regulating the peak speed up &#34;k&#34; (i.e. &#34;k --  alloc&#34;) of each port 16 provides a mechanism for allocating switching among output ports to insure that no single port 16 persistently blocks other ports 16 from routing cells over intercluster switching network 10. In one embodiment, software running on control processor 20 sets a maximum k --  alloc speed up per output port at switch initialization or in response to changing traffic patterns. Also, it will be appreciated by those skilled in the art that switch 5 can be configured to dynamically adjust values for &#34;K&#34; of each cluster module. For example, a bus based switching network can be configured with a maximum speedup of K defined for each cluster module that can vary in a similar manner as the maximum speedup of k defined per port. 
     C. Limited Bandwidth Switching Networks 
     FIGS. 8, 9, and 10 illustrate three examples of limited bandwidth switching networks. The switching network 10 of switch 5 is defined herein to be a limited bandwidth switching network. By definition, the limited bandwidth switching network 10 has a set of output ports (or channels) to which the switching network can only transmit a limited number of cells per switching cycle. Consequently, the switch is unable to generate all possible one-to-one input channel 12 to output channel 13 mappings each switch cycle. In addition, a switch with a limited bandwidth switching network may be blocking during a switch cycle. In many situations, a limited bandwidth switching network operates with a bandwidth that is less than the aggregate rate at which the switch 5 can receive cells. In this case, the switching network may block during a switch cycle since the switch is unable to operate at a bandwidth that is equal to the aggregate bandwidth of the ports 16. 
     The advantage of restricting the bandwidth of the intercluster switching network 10 to &#34;B&#34;, is that the overall cost of switch 5 is reduced. Generally, the bandwidth of a switching network can be limited when it is known that some number of ports 16 of the switch will not receive cells at the maximum allowable link rate. Limiting switching network bandwidth, however, will typically increase contention for the switching network. In the event the limited switching network bandwidth &#34;B&#34; is exceeded during a switch cycle, input buffers 50 (shown in FIG. 3) provide temporary buffering at each cluster module 8 to avoid dropping cells when the momentary sum of the link rates of ports 16 is greater than the bandwidth at which the switching network 10 can operate. 
     FIG. 8 illustrates an example of a limited bandwidth switching network 10 that has one bus 47 coupled to four input channels 12 and four output channels 13. The bus-based switching network operates with limited bandwidth &#34;B&#34; which is less than the aggregate rate at which input channels 12 can receive cells. The bus-based switching network 47 operates with a limited bandwidth &#34;B&#34; when the bus transmits fewer than four cells over the bus during a switch cycle. For example, when each switch cycle of the bus 47 shown in FIG. 8 has three time slots, the bus 47 may be blocking because it is unable to generate all possible one-to-one input channel 12 to output channel 13 mappings during a switch cycle. That is, only three of four input channels are capable of transmitting cell data to the output channels 13 during a switch cycle even though each input channel 12 may receive a cell each switch cycle. 
     FIG. 9 illustrates another example of a limited bandwidth switching network 10 that has two busses 47 that are coupled to four input channels 12 and four output channels 13. The limited bandwidth switching network 10 shown in FIG. 9 operates at a bandwidth &#34;B&#34; that is defined by the bandwidth at which the combination of the buses 47 operate. Bandwidth &#34;B&#34; for the switching network of FIG. 9 can therefore be represented by summing &#34;B 1  &#34; and &#34;B 2  &#34;, where each &#34;B n  &#34; represents the number of bus slots per switch cycle on a given bus &#34;n&#34;. Unlike the limited bandwidth switching network shown in FIG. 9, input channel to output channel mappings can be made using either of the two busses. Consequently, the switching network 10 shown in FIG. 9 has a limited bandwidth when the combination of slots for both buses is unable to generate all possible one-to-one input channel 12 to output channel 13 mappings each switch cycle. For example, the switching network 10 shown in FIG. 9 has limited bandwidth if one of the two buses has one slot per switch cycle and the other of the two buses has two slots per switch cycle. It will be understood by those skilled in art that this is an example of time and space division multiplexing. Thus, the limited switching network 10 shown in FIG. 9 can be limited by either time or space, or a combination of both time and space. 
     FIG. 10 illustrates yet another limited bandwidth switching network 10 which has four internal switching connections 48 that have limited bandwidth. The switching network 10 shown in FIG. 10 is an example of a cross-point network with a limited number of transmission connections that each operate at a bandwidth &#34;B n  &#34;. The limited bandwidth &#34;B&#34; of the switching network 10 is defined by the set of transmission connection bandwidths &#34;B n  &#34;. For example, switching network 10 can be defined by the set of &#34;B 1  &#34;, &#34;B 2  &#34;, &#34;B 3  &#34;, and &#34;B 4  &#34;where &#34;B n  &#34; is the allowable number of cells that can be routed through a given transmission connection &#34;n&#34; during each switch cycle. As with the switching network shown in FIGS. 8 and 9, the switching network 10 shown in FIG. 10 is a limited bandwidth switching network because the set switching connections 48 is unable to provide any one-to-one input channel 12 to output channel 13 mappings in a switch cycle. 
     D. Reservation Ring For Arbitrating Access To Multiple Network Resources 
     FIG. 11 illustrates a reservation ring 14 that provides distributed arbitration of shared network resources, which include switching network bandwidth, and access to output channels 13 and output ports 16. The reservation ring 14 is made up of a plurality of arbitration units 15 that resolve contention for network resources during an arbitration cycle. For example, the reservation ring 14 resolves contention for the output channels 13 of intercluster switching network 10 (denoted herein as &#34;K&#34; contention) and the contention for limited switching network bandwidth (denoted herein as &#34;B&#34; contention). At the start of an arbitration cycle, arbitration requests for access to an output channel(s) are submitted to arbitration units 15. The arbitration requests are shifted around the ring 14 over a set of lines 17 using a central clocking mechanism, such as controller 58. In an alternate embodiment that requires a fewer number of pins of integrated circuits, arbitration request signals are time multiplexed (or pipelined) around the ring using a smaller set of lines 17. 
     Arbitration units 15 arbitrate during an arbitration cycle for access to network resources which include output ports 16, output channels 13, and bandwidth of switching network 10. As arbitration requests submitted to arbitration units 15 are shifted around the reservation ring 14 during an arbitration cycle, each arbitration unit compares incoming arbitration requests with its resident arbitration request (i.e., its own arbitration request being shifted around the reservation ring). This comparison is made by each arbitration unit at each stage of arbitration during an arbitration cycle. If an arbitration unit identifies a network resource conflict, the arbitration unit determines which arbitration request (i.e., the shifted request or the resident request) has a higher priority for the network resource. Because there are a plurality of network resources, arbitration for access to the network resources may require multiple arbitration rounds (i.e., an arbitration request is shifted around the reservation ring once during an arbitration round) to complete an arbitration cycle. Whether one or more arbitration rounds is required to complete an arbitration cycle depends on the relationship between the network resources during arbitration (i.e., whether arbitration for one network resource is inter-dependent or independent on the arbitration of another resource). 
     Arbitration for multiple network resources may be performed in parallel during a single arbitration round whenever arbitration for each of the network resources is performed independently from the other network resources. For example, if the peak number of cells that each output port 16 of a cluster module 8 can receive (i.e., k --  alloc) sum to no more than the number of cells a cluster module 8 can receive (K) (i.e., the sum of the k --  allocs is equal to K), then arbitration for access to output ports 16 and output channels 13 is independent. Consequently in this example, arbitration can be performed in parallel during a single arbitration round (i.e., a single pass around the reservation ring 14). Switching network access in this instance is granted whenever an arbitration unit wins arbitration for both the requested output port(s) and output channel(s). 
     Arbitration requests for multiple network resources, however, are not performed independently when the number of cells that each output port of a cluster module can receive sum to more than the number of cells a cluster module can receive (i.e., the sum of the k --  allocs is greater than K). Performing inter-dependent arbitration for these network resources results in greater utilization of the network resources. For example, greater utilization of network resources occurs if an arbitration unit only arbitrates for access to an output channel 13 if it has won access to an output port 16. Similarly, if the switching network bandwidth is limited, greater utilization of the network resources occurs if an arbitration unit only arbitrates for switching network bandwidth if it has won access to both an output port and an output channel. 
     Where inter-dependent arbitration for network resources is performed, maximum switch throughput can be achieved by shifting arbitration requests around the reservation ring multiple times. During each pass around the reservation ring, an arbitration unit determines which arbitration requests have higher priority for the network resources. Arbitration units eliminate themselves from any later rounds once they lose a round of arbitration (i.e., if an arbitration unit loses in a round of arbitration, it will not submit a request during later rounds of arbitration). An example of inter-dependent arbitrating for multiple network resources is described in detail below. 
     D.1 Example Of Inter-Dependent Arbitration For Access To Multiple Network Resources Over The Reservation Ring 
     In this example of inter-dependent arbitration for network resources, it is assumed that access to output ports 16 and output channels 13 can be performed in parallel (i.e., the sum of the k --  allocs for each port of a cluster module is no more than K) and the switching network 10 of switch 5 has limited bandwidth. Arbitration for access to output channels 13 takes place during one or more arbitration cycles. Each arbitration cycle decomposes into two rounds of arbitration. During the first round of arbitration output channel contention is settled, and during the second round of arbitration intercluster switching network bandwidth contention is settled. In addition, each arbitration cycle can take place during one or more switch cycles. For example, in the bus-based switching network shown in FIG. 6, an arbitration cycle for multiple bus slots takes place during a bus frame time. By arbitrating for more than one bus slot during a bus frame time, the time available for arbitration over the reservation ring 14 is advantageously increased. 
     In accordance with the teachings set forth in U.S. Pat. No. 5,519,698 to Lyles et al., the disclosure of which is incorporated herein by reference, reservation ring 14 is implemented as a linear systolic array of finite state machines or arbitration units 15, each of which only communicates with its immediate neighbor. Reservation ring 14 provides scheduling for cells requesting access to intercluster switching network 10 such that no more than &#34;K&#34; cells are routed to a single output channel 13 during a switch cycle and no more than &#34;B&#34; cells are input into the switching network during a switch cycle. The values for K assigned to each arbitration unit 15 can either be constant across all output channels or vary between output channels 13. Similarly, if there are multiple switching resources that limit the ability of the switch to route any one-to-one mappings, each value of K associated with each resource may have a common value or a value that may differ. Each cluster module 8 includes a finite state machine or arbitration unit 15 that determines whether a cell appearing at the head of input queues 50 (shown in FIG. 3) should be transmitted during a subsequent switch cycle of the intercluster switching network 10. More specifically, each arbitration unit 15 of reservation ring 14 is a finite state machine that examines the highest priority cell its associated cluster module 8 is ready to send and determines how many other cluster modules have cells of higher priority at the head of their input queues 50. 
     State information for each arbitration unit 15 is stored in internal registers 73. Information that is passed to each arbitration unit is stored in interface shift registers 74. Assuming the reservation ring 14 has &#34;m&#34; arbitration units, the state information for each arbitration unit 15 that propagates around the ring 14 once is shifted &#34;m&#34; times during an arbitration round. An arbitration cycle, can be composed of one or more arbitration rounds. Each of the &#34;m&#34; shifts in an arbitration round is defined herein as an &#34;arbitration stage&#34;. The state information stored in each interface shift register 74 includes an &#34;R (i.e., resident)-Destination Vector&#34; that is stored internal to each arbitration unit 15 and contains information that indicates the desired destination output port 16 of a particular cell. In one embodiment, an array of bits is used to represent each possible output port 16 in the resident destination vectors. In the event a cell is multicast to more than one output port 16, more than one of the bits in its destination vector is set. In an alternate embodiment, pre-defined sequences of bits can be used to define a particular set of output channels 13. In this alternate embodiment, each destination vector is made up of pre-defined sequences of bits to indicate one or several output ports 16. At the start of an arbitration cycle, the &#34;R-destination vector&#34; of each arbitration unit 15 on the ring is copied into its &#34;S (i.e., shift)-Destination Vector&#34;. Each of these &#34;S-Destination Vectors&#34; are shifted around the arbitration ring during an arbitration round. 
     In addition, each interface shift register 74 and internal register 73 include a &#34;valid&#34; bit. The &#34;valid&#34; bit indicates whether an arbitration request is valid for a given arbitration cycle. Also, each interface shift register 74 includes information that indicates the priority of a cell being arbitrated. Priority of cells is both intrinsic and extrinsic. Intrinsic priority is a priority that is associated with a cell (e.g., whether a cell is a multicast cell or whether a cell is reserved or unreserved traffic). Extrinsic priority is priority that is generated by the arbitration ring (e.g., the token or &#34;T&#34; bit). Part of this priority information of a cell is duplicated in internal registers 73. Specifically, priority is defined using a &#34;token&#34; bit, a &#34;Rsv&#34; bit, an &#34;MCast&#34; bit, and an &#34;in --  session&#34; bit. These priority bits are used to determine whether an arbitration unit 15 will win or lose an arbitration round with another arbitration unit. Briefly, the &#34;token&#34; or &#34;T&#34; bit is a tie-breaking bit that indicates whether another arbitration unit has a higher priority, the &#34;MCast&#34; bit indicates whether a cell is multicast or unicast, the &#34;Rsv&#34; bit indicates whether a cell is reserved or unreserved traffic, and the &#34;in --  session&#34; bit indicates whether a cell has been blocked during a prior arbitration cycle. 
     FIG. 12 illustrates in detail the control state 76 of an arbitration unit 15. In operation, the control state 76 stored in each internal registers 73 is accessed by arbitration units 15 during an arbitration round. Detailed descriptions of each state variable in control state 76 is set forth in the Appendix under the &#34;Arbitration unit State per Port&#34; heading. In addition, the Appendix sets forth a pseudo code description that illustrates operations performed by each arbitration unit 15 during an arbitration cycle, the general steps of which are described below and set forth in FIGS. 13-16. Generally, control state 76 is used by an arbitration unit to record state information during an arbitration &#34;session&#34;. An arbitration session may include several arbitration cycles. The length of an arbitration session depends on whether a cell successfully gains access to one or more desired output channels 13. As will be seen, cells that are destined to the same output destination during any given arbitration session form a closed set against subsequent arrivals until all of the cells that are participating in the given session have been routed to their common destination. In an alternative embodiment, these requirements may be relaxed to allow cells not part of the closed set to participate in the given session. Thus, in the alternate embodiment an arbitration request in a new arbitration session may participate so long as it does not interfere with a preexisting arbitration session. Details of an arbitration ring with relaxed session requirements is set forth in U.S. Pat. 5,305,311, the disclosure of which is incorporated by reference. 
     D.2 Method For Arbitrating Access To Limited Bandwidth Switching Networks And/Or Multi-Port Clusters With Speedup Consolidation 
     FIG. 13 is a flow chart depicting the general steps performed by each arbitration unit 15 during an arbitration session. A cluster module 8 initiates or joins an arbitration session by submitting an arbitration request to its arbitration unit 15. The arbitration request specifies where to send a data packet or cell and identifies the priority level of the data packet. For example, since a multicast cell may require access to one or more output channels 13, an arbitration session may take one or more arbitration &#34;cycles&#34; to satisfy the arbitration request. At the end of an arbitration cycle, the routing of cells from certain input channels 12 to certain output channels 13 of switching network 20 is defined for the next switch cycle. As set forth above, each arbitration &#34;cycle&#34; includes two arbitration &#34;rounds&#34;. During each arbitration &#34;round&#34; an arbitration request from a cluster module (or input channel 12) propagates around the reservation ring 14. During the first arbitration round, any contention for output channels 13 between any input channels 12 is settled. And during the second round, any contention for the bandwidth &#34;B&#34; of the switching fabric between any input channels 12 is settled. As will be recalled, during each arbitration round, an arbitration request is shifted to each arbitration unit 15 around the ring 14, and each shift is defined as a &#34;stage&#34; of an arbitration round. 
     During an arbitration cycle, each arbitration unit 15 forming reservation ring 14 arbitrates for access to intercluster switching network 20. An &#34;arbitration session&#34; is associated with a destination and remains active when the arbitration session is extended into the next arbitration cycle. An arbitration session is extended whenever any arbitration unit has unsuccessfully arbitrated for access to the associated destination channel 13. In the event an arbitration session is extended, no additional request can join the session and the arbitration requests that are part of the session have priority over any arbitration requests later submitted for the destination associated with the session. Thus, while an arbitration session is active, arbitration units can re-submit previously blocked requests or new requests, however, no arbitration unit 15 can begin a new arbitration session for the associated destination because requests that are part of the session are satisfied before any new requests win arbitration. Using an arbitration sessions to insure that cells are not indefinitely blocked is known, the details of which are disclosed in U.S. Pat. No. 5,519,698. 
     At step 101, state variables in each arbitration unit 15 on reservation ring 14 are reset at power up. More specifically, all variables in the internal registers 73 and interface shift registers 74 are cleared. For example, a &#34;my --  in --  session&#34; variable stored in the control state 76 is reset to &#34;FALSE&#34;. At step 102, arbitration requests are received by arbitration units 15 over request lines 78. An arbitration request with a &#34;Valid&#34; bit set to TRUE indicates that the arbitration unit 15 has a cell to submit to the network for routing. At step 104, the state information in the control state 76 of each arbitration unit 15 is reset at the start of a new arbitration &#34;cycle&#34;. The state information in the control state 76 is shown in detail in FIG. 12. 
     Arbitrating for access to one or more output channels 13 during an arbitration session requires that an arbitration unit 15 participate in each round of an arbitration cycle. During a first arbitration round, each arbitration unit 15 arbitrates for access to one or more output channels 13 of switching network 10 and one or more output ports 16 of cluster module 8, at step 106. Each output channel 13 of switching network 10 is limited to receiving at most &#34;K&#34; cells during a subsequent switch cycle, and at the same time, each output port 16 is limited to receiving at most &#34;k --  alloc&#34; cells during the subsequent switch cycle. The method for enforcing the limit of &#34;K&#34; cells per output channel 13 and &#34;k --  alloc&#34; cells per output port 8 is described in detail below. At step 108, the arbitration request for each arbitration unit is shifted to a neighboring arbitration unit and step 106 is repeated until each stage of the first round of arbitration has completed. During a second arbitration round, bandwidth of the intercluster switching network 10 is arbitrated for by each of the arbitration units 15 at step 110. The total bandwidth available on the switching network 10 is limited to &#34;B&#34;, where &#34;B&#34; is less than the aggregate link rate of the ports 16. Step 110 is repeated for each arbitration unit 15 on reservation ring 14 at step 112, until each stage of the second round of arbitration has completed. 
     At step 114, each arbitration unit determines whether arbitration for switching network bandwidth was successful for any requested output channels 13. Arbitration is successful when a cell is granted a reservation to be switched during the next switch cycle of the switching network 10. At step 116, if a current arbitration session has successfully completed then step 102 is repeated, otherwise step 117 is executed. At step 117, an arbitration request is either fully or partially reissued. An arbitration request is partially reissued when access to part of a set of requested output channels has been granted for a subsequent switch cycle of the switching network 10. Arbitration requests that are either fully or partially granted are output from grant lines 79 and 83 to cluster channel control unit 24 or switching network interface 18, respectively. Partial grants are more fully discussed hereinbelow in connection with arbitration for multicast cells. Thus, whenever part or all of an arbitration request is granted, the cell pending in buffer 33 (shown in FIG. 2) is shifted to buffer 39 for routing through intercluster switching network 10. 
     D.3 Arbitrating Access For To A Switching Network With Limited Bandwidth 
     FIG. 14 illustrates a flow chart detailing steps 106 and 108 shown in FIG. 13 that concern arbitration for one or more output channels 13 of switching network 10 during an arbitration stage. Initially at step 120, each arbitration unit 15 shifts its &#34;S-Destination Vector&#34; onto the reservation ring 14. As discussed above, each bit of an &#34;S-Destination Vector&#34; define which destination output channels are being arbitrated for during the arbitration cycle. In addition, at step 120, the &#34;counter&#34; variable is reset to zero to indicate that a first round of an arbitration cycle has begun (i.e., a first stage of reservation ring 14 has begun). At step 122, an incoming request from the reservation ring 14 is received in the interface shift register 74 (shown in FIG. 11) from a neighboring arbitration unit 15. 
     At step 124, the tie-breaker &#34;token&#34; received from an incoming arbitration request from the ring is evaluated so that priority can be assigned to an arbitration request when there is a tie between two arbitration units. A &#34;token&#34; or &#34;T&#34; bit which is shifted around the ring to break arbitration ties, is updated by each arbitration unit using a &#34;current --  ring --  tail&#34; and a &#34;nxt --  ring --  tail&#34; variable. These variables insures fair tie-breaking between arbitration units by defining a priority ranking at each stage of an arbitration round. Conceptually, the ring is broken into an ordered list of arbitration units. Arbitration units that are higher in the list are given priority over arbitration units that are lower in the list. To increase fairness, the starting arbitration unit in the list is not static but instead is rotated around the ring. This advantageously increases fairness across ports by breaking arbitration ties with rotating priorities that are not static. For example, initially each arbitration unit 15 sets its &#34;token&#34; variable to HIGHER (priority) before outputting an arbitration request on the ring. A designated arbitration unit is assigned to be the tail of the list at power up. The arbitration unit that is designated as the tail of the list flips the &#34;token&#34; variable to LOWER (priority) before outputting it onto the ring. An arbitration unit that receives a LOWER (priority) token assigns a lower priority to the shifted arbitration request than the resident arbitration request. However, when a HIGHER (priority) token is received by an arbitration unit, the shifted arbitration request is assigned a higher priority than the resident arbitration request. The next arbitration unit in the ordered list that is first to receive a LOWER token at the start of an arbitration round is the next tail of the ordered list during the next arbitration round. 
     At step 126, the destination &#34;K --  counter&#34; vector is updated by each arbitration unit. This requires that each arbitration unit determine whether there is contention for requested output channels 13 of switching network 10. The number of cells delivered to an output channel 13 during a switch cycle of the switching network 10 is limited to &#34;dest --  K --  max&#34;. For example, &#34;dest --  K --  max&#34; may limit the number of slots in a bus frame as described above and shown in FIG. 6. Alternatively, &#34;dest --  K --  max&#34; may limit the number of output channels of &#34;K&#34; routing networks as described above and shown in FIG. 7. During an arbitration stage, each arbitration unit determines whether there is contention for an output channel 13 of the switching network 10 by comparing the &#34;resident(R)-destination vector&#34; with the &#34;shifted(S)-destination vector&#34;. Contention between two arbitration units for a similar output channel 13 is settled by determining which arbitration unit has priority. 
     More specifically at step 126, when two arbitration units are contending for the same output channel 13 during an arbitration stage, the arbitration unit with the lower priority increments its destination K --  counter corresponding to that output channel in its destination K --  counter vector. Priority for an arbitration request is defined using a combination of factors that include the tie-breaker &#34;token&#34; (T bit), the &#34;valid&#34; bit, the &#34;rsv&#34; (i.e., reserved) traffic bit, and the &#34;mcast&#34; (i.e., multicast) bit. The &#34;valid&#34; bit indicates whether an arbitration request is valid in the current arbitration round. Higher priority is given to cells with a valid bit set to TRUE. The &#34;rsv&#34; traffic bit indicates whether a cell is reserved or unreserved traffic. Higher priority is given to reserved traffic. The &#34;mcast&#34; bit indicates whether the cell is multicast or unicast. Multicast cells are given higher priority because it is more efficient to satisfy all of a cell&#39;s output channels 13 than have to re-transmit part of a multicast request on a subsequent switch cycle. 
     At step 127, the destination &#34;k --  alloc --  ct&#34; counter for a particular port is incremented when an arbitration unit has unsuccessfully contended with another arbitration unit for an output port 16 during an arbitration stage. The k --  alloc --  ct vector of each arbitration unit 15 includes one k --  alloc --  ct counter for each port of the switch 5. Contention between two arbitration units for an output port 16 is settled using the priorities described above for settling output channel contention. In this embodiment, the number of cells delivered to any output port of switch 5 is limited to a specified value in the dest --  k --  alloc --  max vector. Consequently, when more than dest --  k --  alloc --  max cells contend for a single output port, only dest --  k --  alloc --  max cells are granted a reservation on the switching network. In an alternate embodiment in which a &#34;k --  alloc&#34; counter is not defined for each output port 16 and only a K --  count is defined for each output channel 13, each arbitration unit 15 performs step 126 and omits step 127. 
     At step 128, the &#34;session --  active&#34; variable for an arbitration unit is updated. The &#34;session --  active&#34; variable, which is stored in the control state 76 of an arbitration unit, indicates whether a previous session is still active for an output channel 13 of the switching network 10. An arbitration session is associated with a single destination output channel 13 and is completed when each of the cells participating in the session have been transmitted to the single destination output channel 13. If a session is still active for an output channel 13, then any new arbitration request for that output channel 13, which is indicated by having an in --  session bit set to false, is postponed until the next arbitration session. In other words, once an arbitration session for any destination output channel 13 is started, additional request for that channel are not added to the arbitration session. Thus, when a session completes, all waiting requests for that channel at head of queues 50 which are qualified to participate in the next subsequent arbitration session are allowed to do so. By arbitrating for destination output channels 13 over a session of one or more arbitration cycles, the possibility of an input channel being indefinitely blocked is prevented. 
     At step 130, the &#34;counter&#34; variable in the control state 76 of each arbitration unit is evaluated to determine whether the arbitration request for each arbitration unit has been shifted to each arbitration unit around the ring. Once each arbitration request has been shifted around the ring, step 136 is executed; otherwise, step 132 is executed. At step 132, the &#34;counter&#34; variable is incremented. At step 134, the last incoming request received by an arbitration unit is shifted out onto the ring 14, and step 122 is repeated. 
     Step 136 is executed once content of arbitration requests of each arbitration unit has successfully shifted around the arbitration ring 14. At step 136, each arbitration unit on the ring determines whether its K --  counter in its destination K --  counter vector for each requested destination output channel 13 defined in the &#34;R-destination vector&#34;, exceeds &#34;dest --  K --  max&#34;. This determination is made using the &#34;destination K --  counter vector&#34; stored in the state control logic of each arbitration unit. When the number of times an arbitration unit 15 deferred to another arbitration unit, at step 126, does not exceed dest --  K --  max 15, and the number of times an arbitration unit 15 deferred to another arbitration unit 15, at step 127, does not exceed dest --  k --  alloc --  max, then the corresponding output port 16 is recorded in the &#34;ok --  to --  send-destination vector&#34;. In other words, bits are set in the &#34;ok --  to --  send-destination vector&#34; only if the K --  counter in the destination K --  counter vector is not exceeded for a particular destination output channel 13, and the k --  alloc --  ct in the destination k --  alloc --  ct vector is not exceeded for a particular destination port 16. After the first arbitration round, each bit that is set in the &#34;ok --  to --  send destination vector&#34; indicates which destination output channels 13 may receive a data packet during the next switch cycle. These bits set in the &#34;ok --  to --  send destination vector&#34; satisfy the constraint of sending no more than &#34;dest --  K --  max&#34; cells per destination output channel 13, and no more than &#34;k --  alloc --  max&#34; cells per destination output port 16 during a switch cycle. At this point in the arbitration cycle, however, the &#34;ok --  to --  send-destination vector&#34; does not indicate whether the bandwidth limit of &#34;B&#34; is exceeded for the switching network 10. 
     In an alternate embodiment in which the speedup of K per channel and the speedup of k per port is dynamically set for each cluster module, the values defined for each dest --  K --  max or each dest --  k --  alloc --  max vector must be know at each arbitration unit 15 on the reservation ring 14. That is, each arbitration unit 15 must know the maximum allowable speedup of K per channel and speedup of k per port of every arbitration unit 15 on the reservation ring 14 in order to perform steps 126, 127, and 136. As set forth above, a consistent view of the speedup of K per channel and k per port of every arbitration unit on a ring can be dynamically set at system initialization. 
     D.4 Arbitrating For Access To Multi-Port Clusters With Speedup Consolidation 
     FIG. 15 illustrates a flow chart detailing steps 110 and 112 shown in FIG. 13 that concern arbitration by an arbitration unit for limited bandwidth &#34;B&#34; of the switching network 10 during an arbitration stage. At step 138, the counter for each arbitration unit is reset to zero to indicate that the second round of arbitration has begun. At step 138, each arbitration unit 15 with a non-zero ok --  to --  send destination vector shifts its request for bus bandwidth onto the ring 14. Step 138 entails shifting the arbitration request of each arbitration unit to its immediate neighboring arbitration unit. At step 140, an incoming arbitration request is received in the interface shift register 74 (shown in FIG. 11) from a neighboring arbitration unit 15. At step 142, the tie-breaker token is updated in a similar manner as performed in step 124 described above. 
     At step 144, each arbitration unit contends for bandwidth of the intercluster switching network 10. As described above, intercluster switching network 10 is a limited bandwidth switching network. Accordingly, the switching network 10 does not have a one-to-one mapping between its input channels 12 and its output channels 13 during a switch cycle. This bandwidth limitation is represented using the &#34;B --  max&#34; variable recorded in the control state 76 of each arbitration unit 15. In addition, the control state 76 records a &#34;B --  count&#34; vector with one or more B --  count variables. For example, a switching network 10 similar to that shown in FIG. 8 has a single B --  count variable in the B --  count vector. Specifically, at step 144, the B --  counter(s) in the B --  count vector corresponding to the switching network(s) of the switch 5 is incremented if the priority of the shifted incoming arbitration request exceeds the priority of the resident arbitration request. This determination of priority is similar to the determination of priority made at step 126 described above. 
     At step 146, the &#34;counter&#34; is evaluated to determine whether each request for bus bandwidth &#34;B&#34; set forth during the current arbitration cycle has shifted around the ring to each of the arbitration units on the ring. If each interface shift register 74 has successfully shifted around the ring, step 152 is executed; otherwise, step 148 is executed. At step 148, the &#34;counter&#34; is incremented to indicate an additional shift of arbitration requests around the ring. Subsequently at step 134, the most recent incoming arbitration request of an arbitration unit is shifted onto the ring 14. Executing step 152 indicates that the second round of arbitration for bus bandwidth has completed. 
     D.5 Allocating Bandwidth Among Successful Contenders 
     FIG. 16 illustrates a flow chart detailing steps 114, 116, and 117 shown in FIG. 13 for determining which arbitration units have won a current arbitration cycle. Initially at step 152, a first determination is made as to whether a cell can be sent during the next switch cycle to at least one requested destination output channel 13 of the switching network 10. This first determination is made by each arbitration unit by testing whether at least one bit in the ok --  to --  send destination vector was set for an output port 16 at step 136. In addition, a second determination is made by each arbitration unit whether the B --  count in the B --  count vector relating to the destination output port corresponding to the bit set in the ok --  to --  send-destination vector is less than B --  max. If a cell of an arbitration unit is not scheduled to be sent during the next switch cycle, step 158 is executed; otherwise, step 154 is executed. 
     At step 154, the &#34;sending&#34; flag is set to TRUE when both rounds of arbitration have successfully arbitrated for access to the switching network 10. The &#34;sending&#34; flag is transmitted at the close of an arbitration cycle by an arbitration unit 15 to its cluster controller 24. Upon receipt of a sending flag set to TRUE, a cluster controller 24 prepares to transmit a cell on switching network 10 during the next switch cycle. 
     At step 156, shared switching network bandwidth is scheduled among successful contenders using the B --  count vector. Resources are properly distributed if the successful contenders do not interfere with each other when accessing the shared switching network bandwidth. For example, in the bus based switching network shown in FIGS. 6 and 8, bus slots are allocated to each cell that successfully arbitrated for access to an output port 16 during the next switch cycle. However, an indication that a cell has successfully contended for an output port does not schedule a bus slot for transmitting that cell over the switching network to the output port during the next switch cycle. 
     In the bus-based switching network, time slots of the bus bandwidth are allocated using the &#34;B --  counter&#34; of each successfully contending arbitration unit 15. (As set forth above, the B --  counter is incremented during an arbitration cycle each time an arbitration unit 15 defers to another arbitration unit during an arbitration stage.) The value for the &#34;B --  counter&#34; of a successfully contending arbitration unit is stored in a time &#34;slot vector&#34; which is output from the arbitration unit 15. More specifically, the time slot for a given cell is specified using the &#34;B --  counter&#34; for the bus since the value for each counter is unique for each arbitration unit. This principle also holds true when the B --  counter vector contains more than one counter, since each B --  count in the vector is unique for each &#34;B n  &#34;. In an alternate embodiment, the &#34;B --  counter&#34; is used with parallel networks or fabric-based networks that are space multiplexed instead of time multiplexed. For example, in this alternate embodiment every &#34;time&#34; slot can be used to represent a unique routing network. Accordingly, the &#34;B --  counter&#34; can be used to direct multiple input ports to output cells to unique routing networks at the end of an arbitration cycle. 
     At step 158, a determination is made by each arbitration unit whether an input channel 12 is blocked from transmitting cell data destined to an output channel(s) 13. If no destination input channel 12 is blocked then step 102 is executed; otherwise, steps 160 and 162 are executed. 
     At step 160, the &#34;in --  session&#34; flag of an arbitration unit is set to TRUE to indicate to the cluster controller 24 that the current arbitration session did not complete during the current arbitration cycle. An arbitration unit 15 must resubmit in one or more subsequent arbitration cycles an arbitration request for a destination output port(s) for which the arbitration unit was not granted a reservation during the current arbitration cycle. In resubmitting an arbitration request, the intrinsic priority of the cell data may be updated to reflect a prior unsuccessful arbitration cycle(s). In addition, the &#34;in --  session&#34; flag is set to TRUE to indicate that the current arbitration session is to continue into the next arbitration cycle. At step 162, the destination vector is updated with output port requests that must be reissued during a subsequent arbitration cycle. Reissued arbitration requests are requests that have not won arbitration during the current arbitration cycle. These requests may include a subset of the destination output channels 13 of a multicast cell. 
     E. Reservation Ring Arbitration For Multicast Cells 
     McKeown et al. discloses in &#34;Scheduling Multicast Cells In An Input-Queued Switch&#34;, IEEE InfoCom, published in March, 1996, (ISSN 0743-166X), a work-conserving policy for scheduling cells in an input-queued multicast ATM switch. The work-conserving policy permits a multicast cell to be copied to its specified destination ports over several switch cycles (i.e., cell times). 
     Switch 5 shown in FIG. 1 efficiently manages multicast or broadcast operations over the intercluster switching network 10 in one pass. When a cluster module 8 identifies a cell as multicast traffic, as opposed to unicast traffic, the multicast cell is directed to an input queue 50 so that it is later transferred over the switching network. In an alternate embodiment which reduces switch latency and the load on the switching network, multicast traffic destined to ports within a cluster module is not directed to an input queue but instead is directed to an output queue within the cluster module thereby avoiding transfer over the switching network. 
     As described previously, FIG. 13 illustrates a flow chart depicting the general steps performed by each arbitration unit 15. As defined above an arbitration &#34;cycle&#34; includes a first arbitration round for arbitrating for output channels (steps 106 and 108), and a second arbitration round for arbitrating for switching network bandwidth (steps 110 and 112). An arbitration unit 15 may not successfully arbitrate for each destination channel 13 of a multicast cell during an arbitration cycle because of either output channel contention or switching bandwidth contention. If a reservation is granted for any output destinations of a multicast cell, then the multicast cell is output onto the switching network during the next switching cycle with its ok --  to --  send destination vector set to those output destinations. However, if a reservation is not granted for any output destinations of the multicast cell then the multicast cell is reissued during the next arbitration cycle for those output destinations. An arbitration session is complete only when all requests that are part of the session are granted reservations. Typically, an arbitration session that extends over more than one arbitration cycle, extends over consecutive arbitration cycles. However, an arbitration session may result in transmitting a multicast cell over multiple non-consecutive switch cycles. output port for which a reservation was granted is recorded in the ok --  to --  send-destination vector stored in the state logic of each arbitration unit 15. Each bit in the ok --  to --  send-destination vector corresponds to a destination port of the switch 5. At the end of an arbitration cycle, the ok --  to --  send-destination vector is output on grant line 83 to switching network interface 18. In an alternate embodiment which reduces the number of pins in an integrated circuit, bits in the ok --  to --  send-destination vector are replaced with output port identifiers. This implementation requires that the destination field specify a set of destination ports. 
     FIGS. 17A-17C schematically illustrate the reservation ring 14 performing multicast arbitration. The reservation ring shown in FIGS. 17A-17C includes three arbitration units 15. The internal registers of each arbitration unit are indicated generally by reference numeral 73, and the interface shift registers are indicated generally by reference numeral 74. Each arbitration unit has a resident destination vector 84, a resident priority value 85, a shifted destination vector 86, and a shifted priority value 87. The resident and the shifted destination vectors 84 and 86 each have three bits P1, P2, and P3, respectively. These three bits P1, P2, and P3 correspond to three output channels 13 of a switching network 10. Forming part of each cluster module 15 are comparators 88 that determine whether two values are equal and comparators 89 that determine whether one value is greater than another value. In addition, each cluster module has an array of destination K --  counter vectors 82 that records one K --  counter for each bit representing an output channel 13 defined in the resident destination vector 84. As defined above, each output channel 13 is associated with one or more destination output ports 16. 
     Each arbitration round of the reservation ring 14 shown in FIGS. 17A-17C has three arbitration stages. During the first arbitration stage, each arbitration unit copies its resident destination vector 84 into its shifted destination vector 86. Also, during the first arbitration stage, each arbitration unit resets to zero each K counter in its K --  counter vector 82. Before starting the second and third arbitration stages, the reservation ring shifts the interface shift register vector 74 onto arbitration ring lines 17. During the second and third arbitration stages, each arbitration unit 15 determines whether each bit P1, P2, and P3 in the resident destination vector 84 is equal to each bit P1, P2, and P3 in the shifted destination vector 86, respectively. If any of the comparators 88 for each of the three bits P1, P2, or P3 indicate that the resident and shifted destination vectors are requesting the same output channel 13, then comparators 89 evaluate whether the resident or shifted destination vector has priority. The resident and destination priorities 85 and 87 include the priority booleans, &#34;valid&#34;, &#34;T&#34;, &#34;Rsv&#34;, &#34;MCast&#34;, and &#34;in --  session&#34; that are described above and shown in FIG. 12. If the shifted priority is greater than the resident priority then K --  counter corresponding to that destination bit is incremented. 
     If any of the K --  counters in the K --  counter vector 82 have reached a maximum value (e.g. dest --  K --  max-shown in FIG. 12) then the cell being arbitrated is arbitrated again during the next arbitration cycle with the associated destination bit(s) set. Because each arbitration stage uniquely defines a priority for each arbitration unit, the value of the K --  counters can be used to define an exact input to output mapping of the switching network 10. Since more than one K --  counter may be less than dest --  K --  max for one arbitration unit 15, it is possible to for multiple output channels 13 to receive a data packet from a single input channel 12. In an embodiment in which the switching fabric is a crossbar fabric, multiple crossbar output channels may receive a cell from a single input channel. This acts as a copy mechanism for multicast cells. In the embodiment in which the switching network is a bus, copying of multicast cells is achieved by multiple output channels reading from the bus at once. 
     In an alternate embodiment, an arbitration request is terminated before every output destination of a multicast packet has been issued at step 116 (FIG. 13) to avoid prolonged blocking by the multicast cell. In this embodiment, the arbitration unit 15 returns an unsuccessful arbitration request to the cluster controller 24. At which point, the cluster controller decides whether to resubmit the returned arbitration request or submit a new arbitration request to the arbitration unit 15, at step 102. 
     F. Automatic Sizing of Reservation Rings 
     The modular hierarchical switch architecture described above can be used to implement switches 5 having either a large or a small number of ports 16. The number of ports 16 can be increased by increasing the number of cluster modules coupled to intercluster switching network 10 or by increasing the number of ports per cluster module. Accordingly, an intercluster switching network 10 that is readily expandable or contractible permits the number of cluster modules 8 coupled to input channels 12 and output channels 13 of the intercluster switching network 10 to vary. A switching network that is fully populated has a cluster module 8 associated with each input channel 12 and output channel 13 combination. A switching network 10 that does not have each of its channels 12 and 13 coupled to a cluster module are defined herein as partially populated switching networks. In other words, a switching network with any input channels that have not been populated to receive data packets is a partially populated switching network. 
     Switches that are partially populated permit incremental expansion and contraction of reservation ring 80 without modifying the original configuration of the system. In addition, switches that can be partially populated permit deploying multiple versions of the switch using identical printed circuit boards, thereby reducing manufacturing costs. Also, automatically determining the number of channels populating a switching network does not permit resource conflicts to occur that may result in damaged network hardware if ring arbitration units were to have inconsistent views of the size of the reservation ring. Network hardware may be damaged when inconsistent views of the size of the reservation ring permit too many input channels to access the switching network at once. The methods described below advantageously eliminate this potential error condition. 
     F.1 Automatic Sizing Using Dual Tokens 
     FIG. 18 illustrates a first embodiment for automatically determining the size of a reservation ring 80 to permit configuration of partially populated rings. In this first embodiment, each arbitration unit 81 on the arbitration ring 80 automatically detects when an arbitration cycle has completed. Accordingly, the reservation ring 80 can be used to provide partially populated communication switches. Generally, the reservation ring 80 is similar to the reservation ring 14 described above and shown in FIGS. 11 and 12. Arbitration for shared network resources (e.g. network bandwidth) is distributed between a plurality of arbitration units 81. Each arbitration unit 81 is coupled by wires 17 to form communication ring 80. During an arbitration cycle, arbitration requests from each arbitration unit 81 are shifted to each arbitration unit on the ring 80. As an arbitration request is shifted from one arbitration unit to the next during an arbitration cycle, each arbitration unit compares the shifted arbitration request in the &#34;S-Destination Vector&#34; with the arbitration unit&#39;s request in the resident &#34;R-Destination Vector&#34;. During each shift in the arbitration cycle, each arbitration unit updates its local state stored in the control state 76. At the end of an arbitration cycle, all the arbitration units 81 on the ring 80 have computed consistent arbitration results for network access. 
     In contrast with the reservation ring 14 shown in FIGS. 11 and 12, the boolean variables &#34;first token received&#34; (FTR) and &#34;second token received&#34; (STR) are substituted for the &#34;length&#34; variable in the control state 76 (shown in FIG. 12) of the reservation ring 80. In addition, the reservation ring 80 has an additional Top Token bit (TT) and an additional Bottom Token bit (BT) as shown in FIG. 18. The Bottom Token bit (BT) is shifted in the opposite direction of all other data in the interface shift register 74. It will be understood by those skilled in the art, however, that for the purpose of this embodiment all that is required is that the Bottom Token bit (BT) and the Top Token bit (TT) are shifted in opposite directions around the reservation ring 80. 
     FIGS. 19 and 20 illustrate a flow chart depicting the general steps performed by each arbitration unit 81 of ring 80 to determine the length of the ring during an arbitration round. An arbitration round is complete when each arbitration unit 81 receives its arbitration request after traveling once around the ring. For example, assuming that there are four arbitration units 81 on ring 80, an arbitration round completes when each arbitration request has shifted four times. An arbitration cycle includes two arbitration rounds as described in the arbitration method shown in FIG. 13. An arbitration session which may include one or more arbitration cycles is defined with respect to a particular destination channel. An arbitration session starts once a set of concurrent arbitration requests requesting a particular destination are issued to the arbitration units on the ring. An arbitration session is concluded when the set of concurrent arbitration requests have been successfully issued into the switching network 13. 
     At step 200, one of the arbitration units 81 in the ring 80 is identified as a designated arbitration unit at the start of an arbitration cycle or during system power up or reset. The method for identifying a designated arbitration unit is independent from the method for automatically sizing the reservation ring. In addition, neither the particular method used to assign a designated arbitration unit, nor the method for automatically sizing the reservation ring require that the designated arbitration unit be the same during each arbitration cycle. Identification of a designated arbitration unit can be performed in a number of ways and at different times. 
     A first method for identifying a designated arbitration unit requires that each arbitration unit be assigned a unique identification number. These identification numbers are assigned to each arbitration unit in a monatomic increasing order around the ring 80. At either system power up or during an arbitration cycle reset, each arbitration unit shifts its identification number onto the ring. Subsequently, each arbitration unit compares its own identification number with the identification number it received off the ring. The arbitration unit on the ring that finds the identification number it received off the ring to be greater than its own identification number becomes the designated arbitration unit. A second method for identifying a designated arbitration unit is to dynamically assign the designated arbitration unit in a round robin manner between arbitration cycles (as described above using current --  ring --  tail and nxt --  ring --  tail). Generally, the designated arbitration unit can be any arbitration unit on ring 80 that is guaranteed to be present during the associated arbitration cycle. 
     At step 202, each arbitration unit 81 on ring 80 is reset for a new arbitration round (where step 201 is analogous to step 104 shown in FIG. 13). Specifically, at step 202, the state variable &#34;counter&#34;, &#34;first token received&#34; (FTR), and &#34;second token received&#34; in each arbitration unit 81 are reset to 0, FALSE, and FALSE, respectively. In addition, the &#34;top token&#34; (TT) and &#34;bottom token&#34; (BT) bits of the designated arbitration unit, identified at step 200, are both set to TRUE. In contrast, the &#34;top token&#34; (TT) and &#34;bottom token&#34; (BT) bits of other arbitration units on ring 80 that are not the designated arbitration unit are both reset to FALSE. 
     At step 204, each arbitration unit 81 shifts an arbitration request onto the ring 80. All parts of each arbitration request are shifted in one direction around the ring except for the &#34;bottom token&#34; (BT) bit which is shifted in the opposite direction, as shown in FIG. 18. 
     At step 206, each arbitration unit 81 tests whether &#34;first token received&#34; (FTR) and &#34;second token received&#34; (STR) are both set to FALSE. If both tokens are set to FALSE at step 206, then the state variable &#34;counter&#34; is incremented by one at step 208. At step 210, each arbitration unit tests whether both tokens (i.e., FTR and STR) are both set to TRUE. If both tokens are set to TRUE at step 210, then the state variable &#34;counter&#34; is decremented by one at step 212. Steps 206-212 are not performed by the designated arbitration unit as will become evident below. 
     At step 214, each arbitration unit 81 receives an incoming arbitration request from the ring 80. Each incoming arbitration request includes an &#34;S-Destination Vector&#34;, a &#34;valid&#34; bit, a &#34;Priority Vector&#34;, a TT token, and a BT token. The priority vector may include the priority booleans &#34;T&#34; (or Token bit), &#34;Rsv&#34;, &#34;MCast&#34;, and &#34;in --  session&#34; that are described above and shown in FIG. 12. 
     After receiving a shifted arbitration request from the ring, each arbitration unit tests whether the &#34;top token&#34; in the request is TRUE, at step 216. At step 218, if &#34;top token&#34; is TRUE then the state variable &#34;first token received&#34; (FTR) is set to TRUE if it was not previously set to TRUE, otherwise the state variable &#34;second token received&#34; (STR) is set to TRUE. Similarly, steps 216 and 218, are repeated for &#34;bottom token&#34; at steps 220 and 222, respectively. 
     At step 224, the designated and the non-designated arbitration units test whether the arbitration round has completed. Specifically, the designated arbitration unit tests whether both the &#34;first token received&#34; (FTR) and the &#34;second token received&#34; (STR) are both set to TRUE. If this condition is true for the designated arbitration unit, then the designated arbitration unit identifies that the arbitration round has completed at step 226. In contrast, the non-designated arbitration units test whether the &#34;counter&#34; variable is equal to zero. If the &#34;counter&#34; variable is equal to zero, then each of the non-designated arbitration units know that an arbitration round has completed at step 226. Otherwise, when the conditions at step 224 are not met, step 204 is repeated. 
     FIGS. 21 and 22 illustrate an example of how the reservation ring 80 shown in FIG. 18 and described in FIGS. 19 and 20, operates. FIG. 21 illustrates the physical makeup of the ring used in this example. The ring 80 includes four arbitration units, with arbitration unit 1 being a designated (D) arbitration unit, and arbitration units 2, 3, and 4 being non-designated (ND) arbitration units. FIG. 21 also illustrates that a &#34;top token&#34; (TT) is shifted in the clockwise direction around the ring 80, while a &#34;bottom token&#34; (BT) is shifted around the ring 80 in the counter-clockwise direction. FIG. 22 is a table that indicates the values of the variable &#34;counter&#34;, &#34;first token received&#34; (FTR), &#34;second token received&#34; (STR), &#34;top token&#34; (TT), and &#34;bottom token&#34; (BT) at each stage of an arbitration round. Because the ring 80 shown in FIG. 21 is made up of M=4 arbitration units, there are four stages in an arbitration round. 
     Referring now to the Table shown in FIG. 22 and the flow charts shown in FIGS. 19 and 20, at the beginning of each arbitration stage the variables shown in the table are initialized as set forth in step 202 in FIG. 20. The table in FIG. 22 shows that for all non-designated nodes (ND), the amount of time it takes for the top token (TT) to reach a particular arbitration unit (e.g. arbitration unit 2) is the same amount of time required for the bottom token (BT) to finish traveling around the ring after reaching the particular arbitration unit. At the beginning of each arbitration stage, each arbitration unit passes its top token (TT) in one direction and its bottom token in the opposite direction. 
     After the first stage of arbitration, the top token (TT) of the designated arbitration unit 1 is shifted to the non-designated arbitration unit 2, and the bottom token (BT) of the designated arbitration unit 1 is shifted to the non-designated arbitration unit 4. The counter control (C-Control) column indicates what operation is being performed on the counter variable during each stage (i.e., &#34;+&#34; indicates that the counter is incremented by one, &#34;-&#34; indicates the counter is decremented by one, and &#34;#&#34;indicates the counter is not changed). Thus, at completion of stage 1 each counter of arbitration units 2, 3, and 4 have been incremented by one. 
     At completion of stage 2, arbitration unit 3 receives a top token (TT) and a bottom token (BT) that are both TRUE. The counter of arbitration unit 2 is the only counter that is incremented in stage 2. At completion of stage 3, each of the non-designated arbitration units 2, 3 and 4 have each received a first token and a second token as indicated by the first token receive d (FTR) and the second token received (STR) variables being set to true. During stage 4, the final stage, the non-designated arbitration units 2, 3, and 4 know that the arbitration round has completed because each counter variable is set to zero (i.e., step 224 in FIG. 20). The designated arbitration unit 1, on the other hand, knows th e arbitration round has completed because both the top token (TT) and the bottom token (BT) are set to TRUE. 
     An advantage of this method for automatically detecting the size of an arbitration ring is that the overhead to add this detection method to a ring is small. For example, the size of a request is increased by two bits. Also, each channel is not required to detect its own request before determining the size of the arbitration ring 80. 
     F.2 Automatic Sizing Using One Token And A Length Determination Arbitration Unit 
     FIGS. 23 a nd 24 illustrate a flow chart detailing another method for automatically sizing the length of a reservation ring. In this embodiment, a length determination arbitration unit calculates the length of the ring each arbitration cycle by observing a &#34;token&#34; or &#34;T&#34; bit shifted around the ring each arbitration round. Once the length of a reservation ring is determined by a designated arbitration unit, the determined length is passed to the rest of the arbitration units on the ring. Unlike the first embodiment of an automatic sizing method described above, this second automatic sizing method uses an additional stage of arbitration. For example, if a reservation ring normally requires &#34;n&#34; stages to complete an arbitration round, this embodiment uses n+1 stages. However, this automatic sizing method requires two less tokens than the first automatic sizing method described above. Consequently, the reservation ring in FIG. 11, which advantageously requires two less wires than the reservation ring shown in FIG. 18, can be used to perform this embodiment for automatically determining the length of a partially populated reservation ring. 
     What differentiates this embodiment from the previous embodiment described above is that the distinguished arbitration unit in this embodiment includes a length determination arbitration unit. An additional distinction is that only one token bit &#34;T&#34; is shifted around the ring during an arbitration round. For example, a designated arbitration unit &#34;UNIT 1:D&#34; operates in conjunction with a length determination arbitration unit &#34;UNIT 0:P&#34; as indicated by reference number 98 in FIG. 25. However, the addition of a length determination arbitration unit results in an additional arbitration stage each arbitration round. For example, FIG. 25 shows a ring with four arbitration units plus a length determination arbitration unit, thereby using five arbitration stages to completely shift an arbitration request around the ring. 
     A reservation ring using a single &#34;T&#34; or &#34;token&#34; bit is described in U.S. Pat. No. 5,519,698. As disclosed in U.S. Pat. No. 5,519,698, the &#34;T&#34; bit is set to one by the distinguished arbitration unit at the start of an arbitration session. This &#34;T&#34; bit is used to break ties between arbitration units during a stage of arbitration by indicating one arbitration unit has priority over another. Unlike the &#34;T&#34; bit in U.S. Pat. No. 5,519,698, the &#34;T&#34; bit in the present invention is returned to the designated arbitration unit as is illustrated in FIG. 11. Since the designated arbitration unit is the only arbitration unit that can set the &#34;T&#34; bit, the designated arbitration unit knows when the &#34;T&#34; bit has traveled once around the ring. During an arbitration round, the designated arbitration unit counts the number of arbitration stages before receiving a &#34;T&#34; bit equal to one. The resulting count is used to define the length of the ring. This count is subsequently distributed to the other non-designated arbitration units on the ring. 
     Similar to the first embodiment, this embodiment enables reservation rings to be readily increased or decreased in size without requiring a hardware configuration change. Also, this embodiment, similar to the previous embodiment, requires the identification of a designated arbitration unit as set forth at step 200 in FIG. 19. As described above the designated arbitration unit can be selected in a number of ways. Once the designated arbitration unit is selected, the length determination arbitration unit which forms part of the designated arbitration unit performs the steps set forth in FIG. 23, while the non-designated arbitration units and the designated arbitration unit, perform the steps set forth in FIG. 24. The length determination arbitration unit unlike every other unit on the ring outputs onto the ring the length of the ring in place of an arbitration request. 
     FIG. 23 illustrates the steps performed by the length determination arbitration unit (i.e., UNIT 0:P) shown in FIG. 25. These steps are performed to automatically determine how many arbitration units populate a reservation ring of an unknown length so that a partially populated arbitration ring can operate efficiently. In addition, this method for automatically determining ring length ensures that switching network hardware operates safely. Switching network hardware operates safely when no more than a defined number of input channels access the switching network at once. 
     Initially at step 240, the length determination arbitration unit assumes that the length of the ring is the maximum length when hardware of the ring is fully populated. This step is performed at system power up or arbitration cycle reset when the length determination arbitration unit has not yet determined the number of arbitration units defining the ring. The number of arbitration units on the ring is assumed to be the maximum number of arbitration units that the ring can sustain in order to insure that the ring hardware operates safely during the initial arbitration round. By overestimating the length of a ring instead of underestimating it, arbitration units will be less likely to win an arbitration round. In accordance with this assumption, at step 240, the &#34;new --  length&#34; variable is set to the maximum ring length. 
     At step 242, the length determination arbitration unit resets its state variables before initiating a new arbitration round. These state variables are stored in the control state 76 of the length determination arbitration unit. Specifically, at step 242, a &#34;length&#34; variable which indicates the length of the ring during an arbitration round is set to new --  length. Also, &#34;counter&#34; is reset to zero. The counter variable counts the number of stages as an arbitration round progresses. The state variables &#34;T --  out&#34; is set to TRUE and &#34;last --  T --  in&#34; is set to FALSE. Also, &#34;req --  out&#34; is set to equal the length variable, and the p --  cnt variable, which is records the number of arbitration units on the ring, is set to zero. 
     At step 244, the &#34;pseudo&#34; arbitration request of the length determination arbitration unit is shifted onto the ring. The pseudo arbitration request is stored in the state variables T --  out and req --  out. The T --  out or token variable is set to TRUE so that the length determination arbitration unit will be able to determine when an arbitration round terminates. The req --  out variable is used to store the length of the ring, which in the initial round is maximum length of the ring but in subsequent rounds is the length of the ring determined by the length determination arbitration unit after each arbitration round. At step 246, an arbitration request is received from the ring and stored in state variables &#34;T --  in&#34; and &#34;req --  in&#34;. Subsequently at step 248, the counter state variable is incremented by one to indicate a stage of the arbitration round is about to begin. 
     At step 250, the T --  in bit or token bit from the incoming arbitration request, and the last --  T --  in bit are tested to determine whether the length determination arbitration unit received its own pseudo arbitration request from the ring. If the T --  in bit is TRUE and the last --  T --  in bit is FALSE then step 252 is executed; otherwise, step 254 is executed. At step 252, the next arbitration request to be put out on the ring at step 244 (i.e., req --  out) is set to equal the determined length of the arbitration ring (i.e., p --  cnt). In addition, the new --  length variable is set to record the new length of the ring for the start of the next arbitration round. At step 253, the next arbitration request sent out on the reservation ring is set to equal the last request in (i.e., req --  out=req --  in). 
     At step 254, the length determination arbitration unit determines whether it has to re-broadcast the correct ring size since depending on the initial size of the ring requests may go around the ring multiple times. Specifically, at step 254, when the state variable T --  in is FALSE and the state variable last --  T --  in is TRUE, then step 255 is executed; otherwise, step 256 is executed. At step 255, the variable p --  cnt is reset to zero. At step 256, the variable p --  cnt is incremented to record the presence of an additional arbitration unit on the ring. 
     At step 257, the last token received variable (i.e., last --  T --  in) is set to equal T --  in, and the T --  out variable is set to equal the inverse of the token received variable (i.e., T --  in). Subsequently, at step 258, the counter variable is tested to determine whether it equals the length variable. If the counter variable equals the length variable then an arbitration round with the previously set length has completed and step 242 is repeated; otherwise, step 244 is repeated. When a new arbitration round starts at step 242, the length variable is updated with the value of the new --  length variable which is set at step 252. 
     In another embodiment, the length determination unit sets the &#34;valid&#34; bit of each arbitration request to zero once a determination has been made that it has received its own pseudo arbitration request from the ring. As set forth above, the &#34;valid&#34; bit indicates whether an arbitration unit is participating in a current arbitration session. Thus, by setting the &#34;valid&#34; bit of each arbitration request to zero once each arbitration request has already traveled around the ring, no arbitration takes place by the designated and non-designated arbitration units during each subsequent arbitration stage for that arbitration request. In this embodiment, the &#34;valid&#34; bit is set to zero to ensure that each arbitration unit does not re-arbitrate with requests from other arbitration units or contend with its own arbitration request being shifted around the ring a second time. 
     FIG. 24 illustrates the steps performed by the designated arbitration unit and the non-designated arbitration units during an arbitration round, such as the arbitration units UNIT 1 :D, UNIT 2:ND, UNIT 3:ND, and UNIT 4:ND, shown in FIG. 25. Similar to the length determination arbitration unit at step 240, the designated and the non-designated arbitration units initially set the state variable &#34;new --  length&#34; to equal the maximum allowable ring length at step 260. At step 262, the state variables, which are stored in the control state 76 (shown in FIG. 11), are reset at the start of a new arbitration round. Specifically, at step 262, the state variables &#34;length&#34;, &#34;counter&#34;, &#34;T --  out&#34;, &#34;last --  T --  in&#34;, and &#34;req --  out&#34; are set to new --  length, 0, FALSE, FALSE, and network request, respectively. 
     At step 264, a new arbitration request is shifted out onto the ring, and at step 266 a new arbitration request is received from the ring. At step 268, the counter variable is incremented to indicate the beginning of another stage of arbitration in an arbitration round. At step 270, each arbitration unit determines whether the arbitration request of the length determination arbitration unit has been received. This determination is made by testing whether T --  in equals FALSE and last --  T --  in equals TRUE. If the arbitration request is determined to be from the length determination arbitration unit at 270 then step 272 is executed; otherwise, step 274 is executed. At step 272, the new --  length variable is updated to equal the length of the ring which is stored in the pseudo arbitration request of the length determination arbitration unit. At step 274, the state variables req --  out, T --  out, and last --  T --  in are updated using the variables req --  in, T --  in, and T --  in, respectively. If the counter variable is equal to the length variable at step 276, then the arbitration round is completed and step 262 is repeated; otherwise step 264 is repeated. 
     FIGS. 25, 26, 27, and 28 illustrate a manner of operating the method for automatically sizing a reservation ring shown in FIGS. 22 and 23. FIG. 25 schematically illustrates a reservation ring with four arbitration units and one length determination arbitration unit. FIGS. 26 and 27 show tables that record the values of the state variables in each arbitration unit shown in FIG. 25 during an arbitration round. More specifically, FIGS. 26 and 27 illustrate the values for the state variable when the reservation ring shown in FIG. 25 is only populated with four arbitration units, and the ring has a maximum number of eight arbitration units on the ring at one time. FIGS. 26 and 27 show that the first arbitration round will have nine stages (e.g., 0-8) when the maximum length of the arbitration ring is eight. Also, FIGS. 26 and 27 show that at the end of the arbitration round, the new --  length variable is updated to indicate the current population of the ring. FIG. 28 is a table of the values of the state variables of each arbitration unit after completing the arbitration round shown in FIGS. 26 and 27. 
     In an alternate embodiment, the method for automatically sizing a reservation ring as shown in FIGS. 22 and 23 is executed once at power up to determine the length of the ring. In this alternate embodiment, two arbitration rounds are performed in which no arbitration for bandwidth of intercluster switching network takes place. The first arbitration round is performed to record the number of arbitration units on the ring and the second arbitration round insures that each arbitration unit has received an indication from the length determination arbitration unit of the length of the ring. After the length of the ring has been propagated to each of the arbitration units, the length determination arbitration unit can be disabled so that subsequent arbitration rounds do not include the length determination arbitration unit. This reduces the number of arbitration stages in an arbitration round by one (i.e., from n+1 to n). 
     In another alternate embodiment of the automatic ring sizing method described in FIGS. 22 and 23, an extra stage of arbitration is not required as described above. In this alternate embodiment, the length determination unit and the designated arbitration unit function together so that only one of the two is operating on the reservation ring at one time, thereby requiring only one arbitration stage between each of them. During arbitration cycles in which the length determination unit must communicate the length of the ring to non-designated arbitration units, the length determination unit is active and the designated arbitration unit becomes inactive. Conversely, when the length of the ring has already been updated in each length register of the non-designated arbitration units, the designated arbitration unit is active while the length determination unit is inactive. More specifically, the length determination unit operates during the first two rounds of arbitration. During the first round of arbitration, the length determination unit records the length of the ring. During the second round of arbitration, the length determination communicates the recorded length of the ring to the non-designated arbitration units. Subsequent rounds of arbitration are performed only by the designated arbitration unit unless the length determination unit detects that the reservation ring has been dynamically adjusted in length (i.e., one or more arbitration units have been added or removed from the ring). If the length determination unit has detected that the reservation ring has been dynamically adjusted, the length determination unit becomes active and communicates the new length of the ring to the non-designated arbitration units. 
     F.3 Automatic Ring Sizing Using A Configuration Mask Register 
     FIG. 29 illustrates yet another embodiment for automatically sizing the length of a reservation ring using a configuration mask register. At power up or system reset, step 280 shown in FIG. 29 is executed. At step 280, control software of the switch 5 (shown in FIG. 1) sets the configuration mask register of each arbitration unit during a system start-up sequence. The configuration mask register contains a sequence of bits. Each bit that is set in the configuration mask register corresponds to an arbitration unit on the ring. At step 282, each arbitration unit on the ring compares the configuration mask set at step 280 with the configuration mask register of its neighboring (i.e., right or left) arbitration unit. An error condition is triggered at step 284 when an arbitration unit determines at step 282 that its configuration mask register does not match its neighboring arbitration unit&#39;s configuration mask register. When an error condition is triggered at step 284, the control software of the switch is notified and step 280 is repeated. If no error condition is triggered at step 284, then the reservation ring is free to operate safely. 
     F.4 Automatic Ring Sizing Using A Detection Circuit 
     FIG. 30 illustrates again yet another embodiment for automatically sizing the length of a reservation ring using a detection circuit 92. In FIG. 30, the detection circuit 92 detects when more than a predetermined number of input channels 12 of cluster modules 8 attempt to write at one time to switching network 10 (e.g. a bus). Each input channel is provided with a corresponding current sink 90. The current sinks 90 of the input channels 12 are coupled to line 95. When an input channel 12 attempts to write to switching network 10, its corresponding current sink 90 pulls down a signal sent to detection circuit 92. The detection circuit 92 outputs a signal 94 to notify the control software when the number of input channels 12 attempting to access switching network 10 exceeds a predetermined number of input channels at which switching network 10 can safely operate. Besides outputting a notify controller signal 94, detection circuit outputs a stop sending signal 96 to notify each input channel 12 in the switch to stop accessing switching network 1 0. 
     In one instance of this embodiment, detection circuit 90 is a voltage comparator. One of the inputs of the voltage comparator receives a signal from a reference voltage and the other receives a signal from line 95. The line 95 is coupled to current sinks 90 which can be implemented using open collector logic. The accuracy or resolution of detection circuit 92 is a function of the number of detection circuits 90 that are coupled to line 95. If the number of detection circuits 90 is too large then the detection circuit 92 may be unable to detect when the allowed number of input channels 12 attempting to write to switching network 10 exceeds the predetermined safe number of input channels. 
     G. Summary 
     Parts of the disclosed switch may be readily implemented in software using software development environments that provide portable source code that can be used on a variety of hardware platforms. Alternatively, the disclosed switch may be implemented partially or fully in hardware using standard logic circuits. Whether software or hardware is used to implement the switch varies depending on the speed and efficiency requirements of the switch and also the particular function and the particular software or hardware systems and the particular microprocessor or microcomputer systems being utilized. The switch, however, can be readily developed by those skilled in the applicable arts without undue experimentation from the functional description provided herein together with a general knowledge of the computer arts. 
     The invention has been described with reference to a particular embodiment. Modifications and alterations will occur to others upon reading and understanding this specification taken together with the drawings. The embodiments are but examples, and various alternatives, modifications, variations or improvements may be made by those skilled in the art from this teaching which are intended to be encompassed by the following claims. 
     
         __________________________________________________________________________
// Arbitration Pseudo Code Example:                                       
// example includes:                                                      
//  cluster of just one port                                              
//  slotted global bus in which every port has a statically               
//      allocated bus slot in which to send data                          
// Defininitions (constants in all caps)                                  
// arbitration ring signals                                               
// note the general arb alg can be used with different request encoding   
// note here destination is represented in a bit vector                   
// note priority is a bit vector interpreted as an integer.               
// the arb alg is independent of the priority policy.                     
// here we implemented a policy where:                                    
//  in.sub.-- session gets highests (so never block traffic               
indefinitely)                                                             
//  reserved traffic gets next highests (priority of traffic class)       
//  multicast traffic gets next highests (may get more efficient use of   
network)                                                                  
//  a near full input buffer gets next highest (try to avoid cell loss)   
//  a cell that has been waiting longer gets next highest (lower avg      
latency)                                                                  
//  tie breaker token used to get a unique winner (for consistent         
evaluation)                                                               
struct RingInterface                                                      
boolean    valid        // TRUE if valid request                          
boolean    dest  PORT.sub.-- COUNT-1:0!                                   
                        // bit true if sending to assoc dest              
struct   priority       //&lt;session, full-Q, rsv, mcast,token&gt;             
         boolean in.sub.-- session                                        
                        // TRUE if high priority blocked cell             
         boolean rsv    // TRUE if cell reserved traffic                  
         boolean mcast  // TRUE if cell mulitcast data                    
         boolean buf.sub.-- near.sub.-- full                              
                        // TRUE if input buffer near overflow             
         integer age    // inc at each retry                              
         boolean token  // TRUE if port higher priority than next port    
// Request From Port                                                      
struct PortRequest                                                        
boolean    dest  PORT.sub.-- COUNT-1:0)                                   
                        // bit true if sending to assoc dest              
boolean    valid        // TRUE if valid request                          
boolean    rsv          // TRUE if cell reserved traffic                  
boolean    mcast        // TRUE if cell mulitcast data                    
boolean    buf.sub.-- near.sub.-- full                                    
                        // TRUE if input buffer near overflow             
// Note: arbitration frame steps are counted via frame.sub.-- step. The   
first step is indicated                                                   
// by the constant INITIAL, the following set of steps make up the time   
required for a single                                                     
// round trip around the ring and belong in the set ROUND.sub.-- K, the   
next set of steps                                                         
// make up the time required for a second trip around the ring and are in 
the set                                                                   
// ROUND.sub.-- B. The laststep is used to finalize the request and slot  
allocation and is                                                         
// step FINISH.sub.-- ARB.                                                
// Inputs and Outputs to Arbitration Unit                                 
struct PortRequest                                                        
             port.sub.-- in                                               
                          // local port&#39;s request input                   
struct RingInterface                                                      
             ring.sub.-- in.sub.-- input                                  
                          // incoming request on ring                     
struct RingInterface                                                      
             ring.sub.-- out.sub.-- output                                
                          // outgoing request on ring                     
// Arbiter State per Port                                                 
// need k counter per port to arb for mcast dests                         
// need K counter per cluster to arb for mcast dests                      
struct PortRequest                                                        
             my.sub.-- req                                                
                          // new request from port                        
struct PortRequest                                                        
             retry.sub.-- req                                             
                          // residue request set from arb unit            
struct RingInterface                                                      
             ring.sub.-- in                                               
                          // incoming req                                 
struct RingInterface                                                      
             ring.sub.-- in.sub.-- reg                                    
                          // incoming req                                 
struct RingInterface                                                      
             ring.sub.-- out                                              
                          // outgoing req                                 
integer frame.sub.-- step                                                 
                       // arbitration function step (bus frame step)      
integer dest.sub.-- k.sub.-- cnt  PORT.sub.-- COUNT-1:0!                  
                       // counter per port for port contention            
integer dest.sub.-- k.sub.-- max  PORT.sub.-- COUNT-1:0!                  
                       // max cells sent to one dest port                 
integer dest.sub.-- K.sub.-- cnt  CLUSTER.sub.-- COUNT-1:0!               
                       // counter per port for cluster contention         
integer dest.sub.-- K.sub.-- max  CLUSTER.sub.-- COUNT-1:0!               
                       // max cells sent to one dest cluster              
integer bus.sub.-- B.sub.-- cnt BUS.sub.-- COUNT-1:0!                     
                       // single counter for bus contention               
integer                                                                   
    bus.sub.-- B.sub.-- max                                               
                       // max cells sent over bus (e.g. # bus             
                       slots)(could be array)                             
integer                                                                   
    bus.sub.-- index   // identifier for bus will use                     
boolean                                                                   
    session.sub.-- active                                                 
                       // TRUE if closed arbitration session active       
boolean                                                                   
    my.sub.-- in.sub.-- session                                           
                       // TRUE if port included in current session        
boolean                                                                   
    nxt.sub.-- tail.sub.-- of.sub.-- ring                                 
                       // if TRUE, logical head of ring                   
boolean                                                                   
    current.sub.-- tail.sub.-- of.sub.-- ring                             
                       // if TRUE logical tail and flip token             
boolean                                                                   
    my.sub.-- okay.sub.-- k  PORT.sub.-- COUNT-1:0!                       
                       // port destination(s) okay to send to             
boolean                                                                   
    my.sub.-- okay.sub.-- K  CLUSTER.sub.-- COUNT-1:0!                    
                         // cluster destination(s) okay to send to        
boolean                                                                   
    Ks.sub.-- okay     // won arb for some port and cluster               
integer                                                                   
    bus.sub.-- slot    // bus slot allocated to port for sending          
integer                                                                   
    my.sub.-- bus.sub.-- slot                                             
                       // slot will use if do send                        
integer                                                                   
    sending            // port will send during next bus frame            
integer                                                                   
    retry              // must re-arb for some destinations               
integer                                                                   
    lost.sub.-- arbitration                                               
                       // blocked from any send                           
// Reset at Power Up                                                      
my.sub.-- in.sub.-- session = FALSE                                       
retry = FALSE                                                             
if (node is single designated node)                                       
                          // one node starts out as tail                  
  current.sub.-- tail.sub.-- of.sub.-- list = TRUE                        
else                                                                      
  current.sub.-- tail.sub.-- of.sub.-- list = FALSE                       
// set peak bandwidth allocations                                         
for (i=0 to PORT.sub.-- COUNT-1)                                          
  dest.sub.-- k.sub.-- max i! = MAX.sub.-- CELLS.sub.-- PER.sub.-- PORT   
for (i= 0 to CLUSTER.sub.-- COUNT-1)                                      
  dest.sub.-- k.sub.-- max i! = MAX.sub.-- CELLS.sub.-- PER.sub.--        
CLUSTER                                                                   
for (i= 0 to BUS.sub.-- COUNT-1)                                          
  bus.sub.-- B.sub.-- cnt.sub.-- max i! = MAX.sub.-- CELLS.sub.--         
PER.sub.-- BUS                                                            
//Arbitration Function Initialize State                                   
if (frame.sub.-- step == INITIAL)                                         
                          // first step of arbitration                    
dest.sub.-- k.sub.-- cnt = 0                                              
                          // clear per destination port counters          
dest.sub.-- K.sub.-- cnt = 0                                              
                          // clear per destination cluster counters       
bus.sub.-- B.sub.-- cnt = 0                                               
                          // clear per switch routing bus counters        
my.sub.-- okay.sub.-- dest = 0                                            
                          // clear sending vector                         
if retry == FALSE         //                                              
my.sub.-- req = port.sub.-- in                                            
                          // get new port request                         
my.sub.-- req.priority =                                                  
&lt;in.sub.-- session,port.sub.-- in.buf.sub.-- near.sub.-- full,            
port.sub.-- in.rsv, port.sub.-- in.mcast,HIGHER&gt;                          
session.sub.-- active = FALSE                                             
else                                                                      
my.sub.-- req = retry.sub.-- req                                          
                          // unsuccessful part of last request            
// First Trip Around Ring - arbitrate for destination                     
if (frame.sub.-- step in ROUND.sub.-- K)                                  
// Clock inputs and outputs                                               
ring.sub.-- in.sub.-- reg = ring.sub.-- in                                
                          // get new ring.sub.-- in inputs                
if (frame.sub.-- step == ROUND.sub.-- K.sub.-- STEP.sub.-- FIRST)         
                          // if first cycle of transferring info          
ring.sub.-- out = my.sub.-- req                                           
                            //   send my request on ring.sub.-- out       
else                        // else middle of ring xfers                  
ring.sub.-- out = ring.sub.-- in.sub.-- reg                               
                            //   forward last request to ring.sub.-- out  
// Update ring token used to break ties                                   
if (current.sub.-- tail.sub.-- of.sub.-- list)                            
ring.sub.-- in.sub.-- reg.token// current tail flips token                
else                                                                      
ring.sub.-- out.token = ring.sub.-- in.sub.-- reg.token                   
                          // else pass token on                           
// The logical tail of the ring is passed round-robin to give fairness in 
tie-breaker                                                               
if (frame.sub.-- step == ROUND.sub.-- K.sub.-- STEP.sub.-- SECOND)        
                          // if first reception of data                   
if (ring.sub.-- in.sub.-- reg.token == LOWER)                             
                          //   previous port lower priority               
        nxt.sub.-- tail.sub.-- of.sub.-- list = TRUE                      
                          //    port next tail of list                    
// Arbitration step for contending for destination port (limited k)       
// If lose in arbitration, increment count of higher priority cells to    
destination                                                               
for (i=1 to i=N)            // for each possible port dest                
if (ring.sub.-- in.priority &gt; my.sub.-- req.priority) and (ring.sub.--    
in.dest&lt;i&gt;)                                                               
        dest.sub.-- k.sub.-- cnt&lt;i&gt; = dest.sub.-- k.sub.-- cnt&lt;i&gt; + 1     
// Check to see if have any destination in common and session active for  
destination(s)                                                            
// If session already extended, don&#39;t join. Must wait until next          
session.                                                                  
// This prevents any request from being locked out indefinitely if        
session used as priority bit                                              
if ((ring.sub.-- in.dest &amp;&amp; my.sub.-- req.dest) |=0) and (ring.sub.--     
in.priority.in.sub.-- session or session.sub.-- active)                   
session.sub.-- active = TRUE                                              
// check K and k counts with maximums to see if should eliminate self     
from sending                                                              
if (frame.sub.-- step == ROUND.sub.-- K.sub.-- STEP.sub.-- LAST)          
// Set bit vector of destination ports can send to, at which k is not     
exceeded,                                                                 
for (i=1 to i=PORT.sub.-- COUNT)                                          
 if(my.sub.-- req.dest&lt;i&gt; and (dest.sub.-- k.sub.-- cnt&lt;i&gt; &gt; dest.sub.--  
k.sub.-- max&lt;i&gt;))                                                         
 my.sub.-- okay.sub.-- k&lt;i&gt; = FALSE                                       
                          //  lost arb at this port                       
else                                                                      
 my.sub.-- okay.sub.-- k&lt;i&gt; = TRUE                                        
                          //  won arb at this port                        
// Set bit vector of destinations clusters can send to, at which K is not 
exceeded,                                                                 
// only need these counters if cluster has more than one port             
for (i=1 to i=CLUSTER.sub.-- COUNT)                                       
 if(my.sub.-- req.cluster&lt;i&gt; and (dest.sub.-- K.sub.-- cnt&lt;i&gt; &gt; dest.sub.-
- K.sub.-- max&lt;i&gt;))                                                       
        my.sub.-- okay.sub.-- K&lt;i&gt; = FALSE                                
                          // lost arb at this cluster                     
 else                                                                     
        my.sub.-- okay.sub.-- K&lt;i&gt; = TRUE                                 
                          // won arb at this cluster                      
// also eliminate self from arbitration if k or K is exceeded at all      
destinations                                                              
// (note that high bits of port destination can be used index cluster (i) 
and                                                                       
// low bits can be used to index port within a cluster (j))               
Ks.sub.-- okay = FALSE    // assume not sending                           
for (i=1 to CLUSTER.sub.-- COUNT)                                         
                          // check K cnt for each cluster                 
 for (j = 1 to CLUSTER.sub.-- PORT.sub.-- COUNT)                          
                          // check k cnt for each port in cluster         
  p = portindex(i,j)    // get id of dest port (might be just concat of   
                        i,j)                                              
  if (my.sub.-- okay.sub.-- k&lt;p&gt; == FALSE)                                
                          // check if okay to send to port                
   my.sub.-- okay.sub.-- K&lt;i&gt; = FALSE                                     
                          // if can&#39;t send to port, can&#39;t sent to         
                          cluster                                         
  if ((my.sub.-- okay.sub.-- K&lt;i&gt; == TRUE) and (my.sub.-- okay.sub.--     
k&lt;p&gt; == TRUE))                                                            
   Ks.sub.-- okay = TRUE  // won arb for some port and cluster            
// Increment step counter                                                 
frame.sub.-- step = frame.sub.-- step + 1                                 
// Second Trip Around Ring - arbitrate for bus (or network)               
if (frame.sub.-- step in ROUND.sub.-- B)                                  
// Clock inputs and outputs                                               
if (frame.sub.-- step == ROUND.sub.-- B.sub.-- STEP.sub.-- FIRST) //      
first cycle of transferring info                                          
ring.sub.-- out = my.sub.-- req                                           
                          //   send my request on ring.sub.-- out         
else                      // else middle of ring xfers                    
ring.sub.-- out = ring.sub.-- in.sub.-- reg                               
                          //   forward last request to ring.sub.-- out    
ring.sub.-- in.sub.-- reg = ring.sub.-- in                                
                          //   get new ring.sub.-- in                     
// Update ring token used to break ties: the tail of the ring flips the   
token                                                                     
if (current tail.sub.-- of.sub.-- list)                                   
ring.sub.-- out.token = ˜ring.sub.-- in.sub.-- reg.token            
else                                                                      
ring.sub.-- out.token = ring.sub.-- in.sub.-- reg.token                   
// Arbitration step for contending for bus slot (limited B)               
// If ring cell of higher priority, increment count of higher priority    
cells                                                                     
// Note bus.sub.-- index is index to required limited switching fabric    
resource,                                                                 
//  e.g., could be low bits of dest address to index particular bus or    
//  channel internal to fabric for fabric sub-network interconnect        
// bus.sub.-- index id for limited network resource --                    
// e.g. could be one of several busses or a routing channel internal to   
fabric                                                                    
// Typically, it would be a simple function of the destination(s)(e.g.    
high bits).                                                               
bus.sub.-- index = GetBusIndex(destination bits)                          
                          // for resource that depends on route           
bus.sub.-- index = 1      // for single global bus                        
// count number of other req that req resource that have higher priority  
if(ring.sub.-- in.sub.-- reg.priority &gt; my.sub.-- req.priority)           
bus.sub.-- B.sub.-- cnt bus.sub.-- index! = bus.sub.-- B.sub.-- cnt bus.su
b.-- index! + 1                                                           
// Increment step counter                                                 
frame.sub.-- step = frame.sub.-- step + 1                                 
// Last Step -- determine slot allocation and destinations to send to     
if (frame.sub.-- step == FINISH.sub.-- ARB)                               
// my.sub.-- okay.sub.-- dest is bit vector of destinations won K         
arbitration at                                                            
my.sub.-- bus.sub.-- slot = bus.sub.-- B.sub.-- cnt bus.sub.-- index!     
                          // slot to send if send                         
send.sub.-- dest = Ks.sub.-- okay                                         
                          // send cluster dests (use my.sub.-- okay.sub.--
                           k if no clusters)                              
// lose arbitration if K, k, or B exceeded                                
if ((send.sub.-- dest == 0) or (my.sub.-- bus.sub.-- slot &gt; bus.sub.--    
B.sub.-- max)) and (my.sub.-- req.valid)                                  
lost.sub.-- arbitration = TRUE                                            
                          // blocked from any send                        
else                                                                      
lost.sub.-- arbitration = FALSE                                           
                          // won some dest or no request                  
// okay to send if had valid request and won arbitration at some dest(s)  
sending = my.sub.-- req.valid and not lost.sub.-- arbitration             
// Extend session if blocked from any send and session not in progress    
// If not in session and session already extended, can&#39;t join. Must wait  
until next session.                                                       
// This prevents any request from being locked out indefinitely if        
session used as priority bit                                              
// (If want to allow high priority traffic to indefinitely block low      
priority traffic,                                                         
// adjust use of priority bits according.)                                
if (((send.sub.-- dest |= my.sub.-- req.dest) and (not session.sub.--     
active)) or my.sub.-- req.in.sub.-- session)                              
my.sub.-- in.sub.-- session = TRUE                                        
                          // join or extend session                       
// if won arbitration and op will complete, reset in.sub.-- session so    
nxt req not in session                                                    
if (not lost.sub.-- arbitration) and (send.sub.-- dest == my.sub.--       
req.dest)                                                                 
my.sub.-- in.sub.-- session = FALSE                                       
                          // reset session                                
// check to see if will be done with request or if must re-submit         
residue                                                                   
if (my.sub.-- req.valid and (send.sub.-- dest |= my.sub.-- req.dest))     
                          // if valid req not completed                   
retry = TRUE              // will residue                                 
retry.sub.-- req = my.sub.-- req                                          
                          // default values                               
  retry.sub.-- req.priority.in.sub.-- session = my.sub.-- in.sub.--       
session                   // new session bit                              
  retry.sub.-- req.priority.age = retry.sub.-- req.priority.age           
                          // some aging function                          
for (i=1 to PORT.sub.-- COUNT)                                            
                          // retry dest(s) lost arb at                    
 if (my.sub.-- req&lt;i&gt; and not send.sub.-- dest&lt;i&gt;)                        
                          // failed request                               
retry.sub.-- req.dest&lt;i&gt; = TRUE                                           
                          // new dest bit                                 
 else                                                                     
retry.sub.-- req.dest&lt;i&gt; = FALSE                                          
else                                                                      
retry = FALSE             // can accept new port req                      
// Increment step counter                                                 
frame.sub.-- step = frame.sub.-- step + 1                                 
// Note, if not blocked from sending, will send with send.sub.-- dest as  
destination bit vector                                                    
// in next bus.sub.-- index bus frame&#39;s time slot B. Once in an extended  
session, an operation will                                                
// remain in the extended session until it completes sending to all of    
its destinations.                                                         
__________________________________________________________________________