Abstract:
An available bit rate scheduling method and apparatus for asynchronous transfer mode communication of a plurality of cells over a network characterized by a system clock frequency f and an allowed cell rate ACR. Each cell belongs to an assigned virtual circuit communication channel which is defined by a set of negotiated traffic parameters. The invention partitions the ACR&#39;s of the virtual circuits into a smaller subset of profiles/sub-profiles and conducts a deterministic search to service them. The scheduler incorporates a profile generator for iteratively generating a number p of the profiles by (i) outputting a k*modulo 2 i  th one of the profiles during each kth iteration of the profile generator, where 1≦i≦p and 1≦k≦p-1; (ii) outputting a null profile during each 2 p  th one of the iterations; and, (iii) dispatching the profiles from the profile generator to the profile queue such that a particular profile is dispatched at a time T=T 0  +(1/ACR)*f, where T 0  is the dispatch time of a profile dispatched immediately prior to the particular profile. A profile queue coupled to the profile generator receives and sequentially stores the generated profiles. A virtual circuit processor sequentially receives the profiles from the profile queue and, for each one of the received profiles, dispatches to an output queue all virtual circuits which are characterized by the one received profile.

Description:
FIELD OF THE INVENTION 
     This application pertains to an available bit rate (ABR) scheduler for use in asynchronous transfer mode (ATM) communications. 
     BACKGROUND OF THE INVENTION 
     ATM is a networking protocol which supports a variety of applications having distinct bandwidth requirements and distinct tolerances for delay, jitter, cell loss, etc. ATM networks provide different &#34;service classes&#34; at different prices which reflect the differing quality of service (QoS) provided by each class. The QoS can define minimum levels of available bandwidth, and place bounds on parameters such as cell loss and delay. The user informs the network, upon connection set-up, of the expected nature of the traffic to be sent by the user along the connection, and of the QoS required for such connection. 
     The available bit rate (ABR) service class supports variable rate data transmissions without preserving timing relationships between source and destination. ABR users are provided guaranteed service with respect to cell loss, and &#34;fair&#34; access to available bandwidth as determined by predefined fairness criteria. The user receives only the network&#39;s best attempt to maximize the user&#39;s available bandwidth or allowed cell rate (ACR), through the use of feedback flow control mechanisms. Such mechanisms facilitate control over the amount of traffic allowed into the network, and hence minimization of cell loss due to congestion. A traffic shaping algorithm, controlling the ACR, is used at the source to control the traffic rate into the network, based upon a congestion indicator in the received cells. 
     A pre-defined set of traffic parameters characterize the traffic sent over an ATM connection. Parameters such as minimum cell rate (MCR), peak cell rate (PCR), cell delay variation tolerance (CDVT), sustainable cell rate (SCR) and burst tolerance (BT) characterize the traffic stream in general, although not all parameters are meaningful for all service classes. For example, in ABR service, the PCR determines the maximum value of the ACR, which is dynamically controlled by the ATM network, using congestion control mechanisms, to vary between the MCR and PCR. 
     When setting up a connection, the requesting node informs the network of the required service class, the traffic parameters of the data to be passed in each direction along the connection, and the QoS requested for each direction. Establishment of an ATM connection having specified traffic descriptors constitutes a traffic &#34;contract&#34; between the user and the network. The network offers a QoS guarantee appropriate to the service class requested by the user. In return, the user must confine traffic sent over the connection in compliance with the attributes of the traffic contract for the requested service class. ATM network switches police the user&#39;s traffic via algorithms which determine whether the cell stream is compliant with the traffic contract. 
     An ABR scheduler is an essential and integral part of any ATM implementation offering ABR service. Its purpose is to determine when cells are ready to be transmitted in a fair and efficient manner. In this context, &#34;fairness&#34; means that all service classes should be given an equal opportunity; &#34;efficiency&#34; means that cells should be transmitted at or near their specified rates. The present invention implements an ABR scheduler having the necessary attributes of fairness and efficiency. 
     SUMMARY OF THE INVENTION 
     In accordance with the preferred embodiment, the invention provides an available bit rate scheduling method and apparatus for asynchronous transfer mode communication of a plurality of cells over a network characterized by a system clock frequency f and an allowed cell rate ACR. Each cell belongs to an assigned virtual circuit communication channel which is defined by a set of negotiated traffic parameters. The invention partitions the ACR&#39;s of the virtual circuits into a smaller subset of profiles/sub-profiles and conducts a deterministic search to service them. The scheduler incorporates a profile generator for iteratively generating a number p of the profiles by (i) outputting a k*modulo 2 i  th one of the profiles during each kth iteration of the profile generator, where 1≦i≦p and 1≦k≦p-1; (ii) outputting a null profile during each 2 p  th one of the iterations; and, (iii) dispatching the profiles from the profile generator to the profile queue such that a particular profile is dispatched at a time T=T 0  +(1/ACR)*f, where T 0  is the dispatch time of a profile dispatched immediately prior to the particular profile. A profile queue coupled to the profile generator receives and sequentially stores the generated profiles. A virtual circuit processor sequentially receives the profiles from the profile queue and, for each one of the received profiles, dispatches to an output queue all virtual circuits which are characterized by the one received profile. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a block diagram of an Available Bit Rate scheduler in accordance with the invention. 
     FIG. 2 is a block diagram depiction of the profile generator component of the FIG. 1 scheduler. 
     FIG. 3 illustrates servicing of profiles in accordance with a &#34;ping-pong&#34; algorithm. 
     FIG. 4 illustrates one complete cycle of a binary tree pattern for servicing four profiles in accordance with the ping-pong algorithm of FIG. 3. 
     FIG. 5 is similar to FIG. 4, but shows two complete cycles. 
     FIG. 6 is a pseudo-code listing representative of an algorithm for implementing the virtual time dispatcher component of the FIG. 2 profile generator. 
     FIG. 7 is a pseudo-code listing representative of an algorithm for implementing a profile generator in accordance with FIG. 2. 
     FIG. 8 is a pseudo-code listing representative of a virtual circuit preprocessor algorithm for translating a profile queue to a slower sampling rate. 
     FIG. 9 illustrates implementation of the FIG. 8 algorithm to translate from a rate of 32 cells per second to a rate of 16 cells per second. 
     FIG. 10 depicts a virtual time sequence in which sub-profiles are scheduled simultaneously in a given time slot. 
     FIG. 11 illustrates sequential scheduling of a profile queue in accordance with the invention. 
     FIGS. 12(a)-20(a) and 12(b)-20(b) are respectively tabular and graphical depictions of nine case studies of a sequential scheduling implementation of the invention. 
     FIG. 21 illustrates parallel scheduling of a profile queue in accordance with the invention. 
     FIGS. 22-30 are tabular depictions of nine case studies (corresponding to the FIGS. 12-20 case studies) of a parallel scheduling implementation of the invention. 
     FIGS. 31(a) and 31(b) are tabular depictions of additional case studies extended to include multiple virtual circuits. 
     FIG. 32 illustrates a counter overflow problem by comparing an &#34;ideal&#34; implementation with a hardware implementation incorporating an 8 bit counter. 
     FIGS. 33(a), 33(b) and 34 are pseudo-code listings similar to those of FIGS. 6 and 7 respectively, but incorporate modifications for dealing with the counter overflow problem illustrated in FIG. 32. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     Introduction 
     In an ATM network, a communication channel may be characterized by a virtual circuit (VC) defined by pre-selected traffic and QoS parameters. The problem, in providing ABR service, is to efficiently manage transmission of cells pertaining to different VCs. The allowed cell rate (ACR) at which a cell belonging to a given VC is transmitted varies between the minimum cell rate (MCR) and the peak cell rate (PCR) which are negotiated when the VC is established. The ACR is a floating point number as defined in the ATM Forum specifications, and expressed as ##EQU1## where 0≦e≦31 and 0≦m≦511. As can be seen, ACR covers a wide dynamic range between 1 cell/sec to 32 Gigacells/sec. 
     In order to permit efficient scheduling of VCs in an ABR service, the present invention introduces a classification scheme in which VCs are indexed according to their exponents and mantissa to form groups of &#34;profiles&#34; and &#34;subprofiles&#34;. More particularly, a profile i, 1≦i≦p is a collection of VCs whose ACRs fall within a closed range: ##EQU2## where p is the number of profiles, sp is the number of subprofiles, and 0≦x&lt;1/sp such that the effective profile rate is then given by 2 p-i . A subprofile j, 1≦j≦sp is a subset of VCs belonging to profile i, 1≦i≦p such that their ACRs default to the nearest and smaller rate given by: ##EQU3## For example, if p=sp=4 then the subprofile rates conforming to the above definition are summarized in Table 1. 
     
                       TABLE 1______________________________________     Subprofile rates (cells/second)Profile     1     2          3    4______________________________________1           8     7          6    52           4     3.5        3    2.53           2     1.75       1.50 1.254           1     0.875      0.750                             0.625______________________________________ 
    
     Note that rates of subprofile 1 in each of the 4 profiles are identical to the profile rates of 8, 4, 2 and 1 respectively. It can be seen that the larger the number of subprofiles, the finer is the granularity and therefore the VCs will be scheduled closer to their ACRs, consequently increasing hardware and computational requirements. 
     Whenever a VC is provisioned (i.e. allocated), the ACR of the corresponding VC is uniquely mapped to one of the closest and smallest profile/subprofile rates. The smaller rate is chosen since otherwise the negotiated traffic contract may be violated by scheduling a cell a rate faster than ACR. 
     By quantizing VCs based on the exponent values of their rates, a fast deterministic search can be performed to service the profiles. A linear search on the subprofiles is then conducted and, using a virtual time algorithm wherein the next cell time is calculated based on its ACR, the system clock frequency and the number of profiles, it can be uniquely determined whether the chosen VCs are ready for transmission by comparing with the current cell time. 
     The ABR scheduler of the present invention also maintains a table (in memory) in which VCs are stored along with negotiated traffic contract parameters such as PCR, MCR, etc. A linked list of VCs is attached to each profile/subprofile. When a particular profile/subprofile is ready to be transmitted (as determined by the scheduler algorithm summarized above), the entire list linked to that profile/subprofile is serviced and the ATM cells are placed in the ABR output queue for transmission. 
     The scheduler also interacts with an ABR contract module which implements source/destination behaviour functions in accordance with ATM Forum-defined congestion management protocols and links/delinks the VCs to the various profiles/subprofiles in the table dynamically, depending on its state. For example, if congestion is detected in the network, then the ACR for a particular VC is reduced by a predetermined amount and accordingly the VC&#39;s link to a profile/subprofile needs to be updated. 
     Profile Generator 
     FIG. 1 depicts an available bit rate scheduler in block diagram form. The three principal functional components of the scheduler are profile generator 10, profile queue 12 and virtual circuit processor 14. Memory 13 stores updated values of each VC&#39;s next cell time (NCT) together with information pertaining to the provisioning/unprovisioning status of each VC and other ABR service scheduling parameters. Profile generator 10 outputs a sequence of profiles and subprofiles to be serviced, based on a deterministic pattern conforming to a performance metric which represents predefined criteria of fairness and efficiency. Profiles and subprofiles output by profile generator 10 are stored in profile queue 12, which is a first-in-first-out (FIFO) buffer. Virtual circuit processor 14 ensures that all VCs attached to a particular profile (as a link list) are dispatched to ABR output queue 15 for transmission. 
     As shown in FIG. 2, profile generator 10 has two principal functional components, namely &#34;ping-pong&#34; unit 16 and virtual time dispatcher 18. As explained below, ping-pong unit 16 employs a so-called &#34;ping-pong&#34; algorithm to produce a profile trace which is utilized by virtual time dispatcher 18 to determine whether the particular profile is ready to be sent to profile queue 12. Virtual time dispatcher 18 is conceptually analogous to a virtual clock, in that decisions are effected by comparing the current cell time (CCT) to the next cell time (NCT), as hereinafter explained. 
     Ping-Pong Algorithm 
     The objective of the &#34;ping-pong&#34; algorithm employed by ping-pong unit 16 is to service the profiles based on their exponent values. FIG. 3 shows a typical arrangement of a set of p profiles and their exponent values. The exponent value of profile i, where 1≦i≦p, is 2 p-i . Since the exponent value of a given profile is twice the exponent value of the next lowest profile, servicing should be commensurate with exponent to guarantee fairness to all available profiles. Each profile may be subdivided into several subprofiles, depending on the selected granularity (either a linear or non-linear scale can be adopted). However, because the subprofiles are not essential to the basic ping-pong algorithm they are dealt with later. 
     The ping-pong algorithm operates on the basis that the service time (i.e. the time for each visit) is twice as fast as the rate of the highest profile. In other words, the visiting rate is 2 p . Thus, the first (highest) profile is visited every 2 steps, the second profile is visited every 4 steps, the ith profile is visited every 2 i  steps and the pth (lowest) profile is visited every 2 p  steps. The ping-pong algorithm therefore generates an address trace whose pattern follows a complete binary tree. If p is the number of profiles, then one complete traversal produces 2 p  -1 addresses. One empty address slot is generated at the 2 p  th step to maintain consistency and to ensure that the service class of any of the profiles is not violated. An example is shown in FIG. 4 for p=4. After 15 slots, an empty slot is added to make up a full cycle of 2 4  =16 slots and the pattern repeats as illustrated in FIG. 5 for two 16-slot cycles. 
     The slot utilization, χ i  which is the service rendered to each profile, is given by ##EQU4## Thus asymptotically, when p→∞ the total slot utilization ##EQU5## reaches 100%. However, even for small values of p, the efficiency is quite acceptable, as shown in Table 2. 
     
                       TABLE 2______________________________________Number of Profiles p           Total Slot Utilization γ______________________________________2               75.00%4               93.75%8               99.61%12              99.98%16               99.998%______________________________________ 
    
     The complete binary tree and the empty slot are easily generated by a counter whose size is at least p bits, and a comparator block. If count is the output of a standard binary counter p bits wide, then profiles are output as follows: 
     If count=0, output profile 0. (Profile 0 is the null or empty slot). 
     If count=(1,3,5,7, . . . , 2 p  -1), output profile 1. 
     If count=(2,6,10,14, . . . , 2 p  -2), output profile 2. 
     If count=(4,12,20,28, . . . , 2 p  -4), output profile 3. 
     If count=2 p-1 , output profile p. 
     The above conditions are easily deciphered with modulo 2 i  arithmetic, such that if (count % 2 i  ==2 i-1 ), then profile i can be sent to the output for 1≦i≦p where % indicates modulo operation. count % 2 i  is equivalent to extracting the least significant i bits of count and hence can be easily calculated (see R. Sivakumar and N. J. Dimopoulos, &#34;VLSI Architectures for computing X mod m&#34;, IEE Proceedings--Circuits, Devices and Systems, Part G, vol. 142, no. 5, pp. 313-320, October 1995). 
     Virtual Time Dispatcher 
     Virtual time dispatcher 18 uses the concept of virtual time to arbitrate and ensure that profiles do not violate their assigned cell rates (over the long term) and thereby statistically maintain the average transmission rate of each profile/subprofile closer to their marked rates. The virtual time dispatcher employs a modified version of a prior art virtual clock scheme (see L. Zhang, &#34;Virtual Clock: A New traffic Control Algorithm for Packet Switching Networks&#34;, ACM SIGCOMM90, pp. 19-29, Philadelphia, September 1990). The modified implementation does not require expensive sorters and uses a simpler linear search scheme to schedule the subprofiles from the highest to the lowest rates. 
     It is convenient to define the following terms, which are hereafter employed in order to assist those skilled in the art in comprehending the invention. 
     Cell --  delay: a fixed number of system clock cycles during which a subprofile address is sent to the profile queue, i.e. a fixed quantum of time devoted to servicing a given subprofile. Cell --  delay is calculated as the reciprocal of twice the rate of the highest profile, scaled by the system clock frequency f. Thus: ##EQU6## since ping-pong unit 16 runs at twice the highest rate. Obviously, the higher the system clock frequency, the greater the number of cycles available per Cell --  delay. For implementation purposes, Cell --  delay is easier to calculate if the system clock frequency is a power of 2. In this case, we have: 
     
         Cell-delay=2.sup.f.sbsp.e.sup.-p where f.sub.e =log.sub.2 f (7) 
    
     Current --  Cell --  time (CCT): a variable used to keep track of virtual time and as a reference for scheduling cells of a profile. It is updated every time a profile is visited, irrespective of whether a valid subprofile exists or not. The new value of CCT is given by: 
     Current --  cell --  time=Current --  cell --  time+Cell --  delay CCT is virtual in the sense that whenever a profile is visited by ping-pong unit 16, although several valid subprofiles may be ready for dispatch, CCT is incremented only once for that profile visit. This has the advantage of avoiding aliasing (i.e different profiles being sent at the same (lower) rate) and maintaining an efficient spread of the rates. 
     Next --  Cell --  time (NCT): an important variable used to calculate the exact time when a particular subprofile is to be transmitted next to the profile queue. The calculation is based on the current value of NCT and the reciprocal of the actual cell rate (ACR) of the subprofile (determined by table lookup, or other suitable means), normalized to the appropriate system clock frequency f. In other words, the time domain is converted to an arbitrary count of the system clock for the purpose of simple hardware implementation. Therefore, the recurrence relation for NCT is given by: ##EQU7## where ACR is expressed as a 14-bit Floating point number. The initial value of Next --  cell --  time 0! is 0 for all subprofiles. 
     FIG. 6 is a pseudo-code listing of the algorithm performed by virtual time dispatcher 18. Initially, it is assumed that each profile has a vector in memory which holds the following entries for each subprofile: (1) Next --  cell --  time (NCT)--for scheduling; and, (2) Availability--indicates whether a VC is attached or not. If the availability bit for a particular subprofile is 0, this implies that no VCs are attached and that the corresponding subprofile is empty. At FIG. 6, line (1) a selected profile p is tested to ensure that it is non-zero. At lines (2)-(4), that profile&#39;s availability vector is retrieved and, starting from the highest rate for each available subprofile (line (6)), a linear scan is initiated. The NCT value is retrieved from memory at Line (8) and compared with the current value of cell --  time. If the current cell --  time is greater than or equal to NCT then the particular subprofile number is dispatched to the profile queue (line (9)) and the new value of NCT is calculated at line (10) and written back into the memory (line (12)) for later use. If the current cell --  time is less than NCT then a null pointer is output if the following conditions are satisfied: 
     1. All valid subprofiles (lines (15)-(17)) fail the NCT test (i.e. current cell --  time is less than NCT for all valid subprofiles). 
     2. The availability vector is empty for the selected profile p --  num (i.e. no VCs are attach-ed), (lines (20)-(22)). 
     3. Profile p --  num is zero (line (23)-(26)). 
     NCT is updated at lines (18), (21) &amp; (25) to compute the next virtual time for each profile visit, as the case may be. Note that a null pointer may be interpreted as a state where a predefined value is written to the queue. Also note that the foregoing discussion assumes an infinite queue, whereas the queue will be of finite length in any practical embodiment. This raises the classical reader-writers problem between profile generator 10 and the virtual circuit processor 14, necessitating proper synchronization of the two. 
     It is also noteworthy that the counter used to track the cell --  time will have a finite word length and thus comparison problems (see FIG. 6, line 10) will surface when the counter value rolls over. As explained below in the section headed &#34;Counter Overflow&#34;, these problems are solved by deriving bounds on the CCT and NCT word lengths for a given system clock frequency f and performing simple arithmetic modulo operations. 
     Based upon the foregoing discussion, it will be understood that profile generator 10 can be synthesized with the pingpong and virtual --  time --  dispatcher modules shown in FIG. 7. The input to the Profile --  generator() procedure includes the NCT and the availability vectors for all profiles. A stop signal stored in memory 13 indicates that ABR output queue 15 is full and is used to terminate the Profile --  generator() procedure. Otherwise, the Profile --  generator() procedure is repeated indefinitely. 
     Virtual Circuit Processor 
     The foregoing discussion assumes that profile generator 10 produces a sequence of profile addresses by sampling at twice the rate of the highest profile. In other words, each cell time is proportional to the reciprocal of 2 p  where the total available bandwidth is equal to the highest rate i.e, 2 p-1 . Therefore, before virtual circuit processor 14 can place the VCs on the ABR queue where each slot corresponds to 1/2 p-1 , it must preprocess profile queue 12 to effect the translation such that the cells are spaced at the Line rate (2 p-1 ). The Virtual --  Circuit --  Preprocessor algorithm (FIG. 8) summarizes this translation procedure. The profile queue is scanned, two entries at a time, and a check is made to determine whether the scanned entries are empty or not. The following case scenarios are possible: 
     Case 1: both entries are null (lines (6)-(10)). 
     Case 2: one entry is null and the other is not (lines (11)-13) &amp; Lines (15-17)). 
     Case 3: both entries are non-null (i.e. contain valid profiles) (lines (18)-(21)). 
     For Case 1, the two null (i.e. empty) slots each corresponding to a period of 1/2 p  are merged into a single time slot of period 1/2 p-1 . For Case 2, the non-null profile is scheduled to occupy a time slot of period 1/2 p-1 . For Case 3, both entries are valid and hence must be scheduled in two successive periods. Consequently, one period is lost for every two profiles sent in this fashion. By using a variable lag, the number of such occurrences can be tracked so that if an empty slot is found (as in Case 1), that time slot can be effectively utilized (see FIG. 8, lines (6)-(10)). Use of the lag variable accordingly improves the effective throughput, particularly for under-provisioned cases (hereinafter defined). 
     FIG. 9 illustrates implementation of the FIG. 8 preprocessing algorithm. In FIG. 9, a basic cell --  time corresponding to a rate of 32 cells/sec (left side) is merged to create a cell rate of 16 cells/sec on the right. Observe that subprofiles 3 2  and 3 3  consume 2 cell --  times each on the right side, implying a loss of one 2 cell --  time period which is recovered when empty profiles (2 o  and 1 0 ) are visited subsequently. 
     ATM Cell Transmission 
     The &#34;line rate&#34; is the rate at which a physical transmission medium such as a fiber-optic network transports data. e.g. SONET STS-3c provides a line rate of 155 Mbps. The &#34;payload rate&#34; (PR) is the rate at which useful information (e.g. ATM cells) is carried over a transmission medium. For the SONET STS-3C example, a typical PR is approximately 150 Mbps. The maximum ATM cell rate is thus PR/(53×8)=PR/424 cells per second, which consequently sets an upper bound on the PCR for a given implementation. 
     In the context of the present application&#39;s definition of profiles and subprofiles, the maximum ATM cell rate constitutes the cell rate of subprofile 1 of profile 1 and therefore any VCs attached to this subprofile will occupy the maximum bandwidth in an ATM connection. Preferably, profile generator 10 runs at μ times the maximum ATM cell rate and fills profile queue 12 with subprofile entries. Virtual circuit processor 14 dispatches VCs to ABR output queue 16 at a rate equal to 1/μ of the rate of profile generator 10, thereby achieving the maximum ATM cell rate. 
     In implementing the pingpong algorithm, a speed-up factor of μ=2 is selected. A higher value of μ could be selected, but the number of profile entries would then have to be increased, thereby increasing the memory overhead and reducing the number of system clock cycles available for servicing each subprofile. 
     Simulation 
     To characterize the performance of the FIG. 7 profile --  generator algorithm, a Matlab program was written and several case studies were simulated, as hereafter summarized. For the sake of tractability and computational simplicity, the number of profiles p=5 and subprofiles sp=4 were chosen, for a total of 20 entries. The system clock frequency was set at 256 hz (2 8 ). In this example, each cell --  time corresponds to 8 cycles at a rate of 32 cells per second. Profile 1 has the largest exponent since its ACR is 16. This also corresponds to the maximum bandwidth available. It is useful to define the terms &#34;over-provisioned&#34;, &#34;under-provisioned&#34; and exact-provisioned&#34; as follows: if the sum of the bandwidths of the available subprofiles exceeds the peak rate (16 in this case), then we have an &#34;over-provisioned&#34; case; if the sum of the bandwidths of the available subprofiles is less than the peak rate we have an &#34;under-provisioned&#34; case; and, if the sum of the bandwidths of the available subprofiles equals the peak rate we have an &#34;exact-provisioned&#34; case. The effective rate for each profile/subprofile was measured and the resultant bandwidth was compared with the specified rates for a simulation run consisting of 4096 profile visits. 
     It is convenient to define the following terms, which are hereafter employed in order to assist those skilled in the art in comprehending the invention. 
     Virtual time: the time required to service all subprofiles (within a profile) in one cell --  time. 
     Virtual time sequence: a sequence of profiles scheduled in virtual time. FIG. 10 shows a virtual time sequence in which sub-profiles are scheduled simultaneously in the same time slot. 
     Virtual throughput: measures the rate of the various profiles as if cells scheduled in the same time slot by the profile generator are dispatched simultaneously. Note that the sampling frequency is twice as fast as the highest profile&#39;s rate. 
     Real time sequence: a sequence of subprofiles (or empty profiles) which are scheduled one cell --  time each successively in real time. 
     Real throughput: measures the actual throughput, assuming that the VCs in the profile queue are dispatched by the virtual --  circuit --  preprocessor as a real time sequence. 
     The ratio of the measured rate to the desired (specified) rate given by the quantity λ illustrates the proximity of the scheduled rate to the ideal. Performance improves as the value of λ increases. 
     Bandwidth utilization: the relative bandwidth used by each profile/subprofile with respect to the maximum bandwidth. 
     Two different methods for implementing the scheduler algorithm will now be discussed; namely, sequential scheduling and parallel scheduling. 
     Sequential Scheduling 
     In this method, all subprofiles that are ready on a given virtual time slot t, as arbitrated by virtual time dispatcher 18, are dispatched in sequence one at a time to profile queue 12, as shown in FIG. 11. When the next profile is serviced at virtual time t+1, any valid subprofiles are dispatched by incrementing the sequence number as appropriate. If the profile is empty, then a null slot is generated at that point. As seen in FIG. 11, subprofile 1 1  has a sequence number n+4 which follows subprofile 4 4 , where the subscripts denote the subprofile numbers. 
     Nine test cases were selected to study the performance of the scheduler algorithm. The simulation results are summarized in FIGS. 12-20 and represent the actual profile/subprofile numbers output by the virtual circuit preprocessor as per the FIG. 8 algorithm. 
     Parallel Scheduling 
     The sequential scheduling method discussed above tends to degrade performance when the higher profiles are empty. This typically occurs in under-provisioned cases and to some extent in over-provisioned cases, since when a given profile is serviced, all of the subprofiles that are ready to be sent are allocated one cell time each. Then, when a next higher profile is subsequently visited by ping-pong unit 16, and assuming such profile to be empty, the algorithm schedules an empty slot following the last subprofile slot. This reduces throughput, even though there is unutilized bandwidth. One may attempt to improve bandwidth allocation by performing a lookahead search of the succeeding profile and if it is empty, merging its time slot with that of the previous subprofile, giving a spacing of at least 1 cell --  time to maintain virtual time integrity. In other words, an empty (succeeding) subprofile is overlapped on an occupied subprofile&#39;s time slot, such that the minimum gap is 1 cell time, since virtual time (t+1)-t=1. This increases the effective throughput of the profiles since the relative slot distribution is shorter in duration compared to the sequential case. 
     FIG. 21 provides a clarifying example in which profiles 1, 2, and 3 are empty and in which profile 4 has four subprofiles 4 1 , 4 2 , 4 3 , 4 4 . At virtual cell --  time t, the profile generator determines that profile 4 needs servicing and all four of its sub profiles are ready for dispatch to the profile queue starting at real time sequence n. Each of the four dispatched subprofiles consumes one cell --  time. Subprofile 4 1  is sent at time sequence n, subprofile 4 2  at time sequence n+1, subprofile 4 3  at time sequence n+2 and finally subprofile 4 4  at time sequence n+3. Next, the profile generator visits profile 1 at virtual cell time t+1, as determined by the ping-pong algorithm. Since profile 1 is empty, this time slot can be overlapped with the one allocated to subprofile 4, starting from the second sub-profile 4 2  at time sequence n+1. In this example, 3 cell --  time slots are saved, or equivalently the effective throughput can be expected to be greater compared to the sequential case where profile 1 will be sent only at time sequence n+4. 
     The performance of the parallel scheduling method depends very much on the profile distribution and on which slots are empty. In the worst case, its performance defaults to that of the sequential scheduling method, while in the best case, the effective throughput will be closer to the virtual throughput. The aforementioned simulation was repeated, in relation to the parallel scheduling method, for the 9 case studies presented previously. The case study results, tabulated in FIGS. 22-30, reveal the performance of the parallel scheduling method to be better than or equal to that of the sequential scheduling method, including the over-provisioned case. 
     The case study results tabulated in FIGS. 22-30 assume that only one VC is linked to each subprofile. FIGS. 31(a) and 31(b) tabulate the results of additional case studies representative of the more general case in which multiple VCs may be linked to each subprofile. For clarity, only valid subprofiles are depicted. It can be inferred from the over-provisioned case study results tabulated in FIG. 31(a) that the effective bandwidth allocated to all VCs (including those in the linked list) is scaled down by a factor of R=65/16=4.0625. For the underprovisioned case (FIG. 31(b)), the algorithm achieves very high efficiency (close to 100%) in bandwidth distribution and none of the VCs in the link list are deprived of their respective desired bandwidth allocations. 
     Congestion Management 
     Congestion may also occur when the sum of the bandwidths of the allocated connections exceeds the maximum bandwidth supported by the network. In such a situation, a given fairness criteria has to be applied such that the bandwidth is shared effectively and efficiently by all users. The present invention implements a rate weighted bandwidth allocation scheme wherein the available bandwidth is shared depending on the ACRs of the profiles and excess bandwidth. For example, if the maximum bandwidth is 16 and the total bandwidth required is 32, then all of the allocated profiles have their ACRs (which are weighted on their rates) reduced by 50%. 
     Assume that B max  is the maximum physical bandwidth available, and that there are l(i,j) VCs attached to subprofile j of profile i, where 1≦i≦p, and 1≦j≦sp. Also, let B i ,j k  be the desired bandwidth of the k th  VC in subprofile j of profile i as indicated by the weighted ACR values to which they are attached. Then the effective bandwidth achieved is: ##EQU8## Observe that if R=1, then B i ,j k  =B i ,j k  and 100% efficiency is achieved. 
     Counter Overflow 
     A technique for solving the aforementioned counter overflow problem will now be discussed. 
     The current --  cell --  time (CCT) and next --  cell --  time (NCT) variables are incremented by profile generator 10 from the start (i.e. from time=0) and theoretically can extend up to infinity (or to a very large number, until execution is terminated). In a typical hardware implementation, the CCT and NCT parameters are usually embodied in finite length counters. If such counters are f e  -bits in length, the maximum count attainable is 2 fe  -1, after which the counter overflows and counting recommences from 0 due to the inherent modulo 2 fe  arithmetic operation of the counter. Such overflow could result in incorrect operation of profile generator 10 as it compares successive values of CCT and NCT. FIG. 32 illustrates the problem by comparing an &#34;ideal&#34; implementation in which NCT=518, with a hardware implementation incorporating an 8 bit counter which, due to overflow of the counter, outputs a value of NCT=518 mod 512=6, which in turn produces incorrect results upon comparison with a value CCT=504. 
     The first step in solving the overflow problem is to calculate the maximum size of the NCT counter. As explained above (see equation (9) if f is the system clock frequency, then NCT is given by: ##EQU9## where f e  =log 2  f. For ease of implementation, assume f to be a power of 2. Note that when ACR=1, (i.e the slowest profile), the scaled 1/ACR factor will be a maximum such that 2 fe  /ACR=2 fe . Consequently, for other higher ACR rates, f e  -bits are sufficient to accommodate the scaled 1/ACR factor, since: ##EQU10## Observe that for the fastest profile, ACR=2 p-1  and we have: ##EQU11## As explained above, the pingpong algorithm ensures that profile i is visited 2 p-i  times during one cycle, where 1≦i≦p. Hence all subprofiles within profile i whose ACR is an integral power of 2 will be serviced 2 p-i  times, while the other subprofiles in i (whose ACRs are not a power of 2) will be serviced in proportion to their respective rates. In other words, number of visits is roughly proportional to 1.xxxx×2 p-i-1  where xxxx is non zero. Therefore, if an f e  -bit counter is used, the NCTs for all subprofiles whose ACRs are powers of 2 will be updated as follows for each cycle. 
     NCT=1×2 fe  =2 fe  for ACR=1 since the slowest profile occurs once in one cycle. (A cycle is equal to 2 p  visits.) 
     NCT=2×2 fe-1  =2 fe  for ACR=2 since the next slowest profile occurs twice in one cycle. 
     NCT=2 p-1  ×2 fe-p+1  =2 fe  for ACR=2 p-1  since the fastest profile occurs 2 p-1  times in one cycle. 
     If a counter of length=f e  bits is used to represent NCT, then due to the modulo operation of the counter, all subprofiles which are integral powers of 2 will become 0. 
     For the case in which the subprofiles are not integral powers of 2, the NCT value is approximately given by: 
     To determine an upper bound on the above equation, consider a subprofile whose ACR is 1.xxxx×2 p-i-1 , i=1, . . . , p. Since ##EQU12## this falls in to the profile belonging to a higher rate, i.e. 2 p-i , it will be visited 2 p-i  times. Hence, the 1/ACR factor is given as: ##EQU13## and its NCT will be bounded from above by 
     
         NCT&lt;2.sup.p-i ×2.sup.f.sbsp.e.sup.-p+i+1 =2.sup.f.sbsp.e.sup.+1 (16) 
    
     The significance of the foregoing analysis is that for each cycle, the NCT values are bounded and the counter does not overflow more than twice. Hence the values can be represented by f e  +1 bits. The width of the CCT counter is determined in the same manner. Note that for one full length cycle of 2 p  visits, the total increment in CCT is given by: ##EQU14## As explained above, the Cell --  delay is a fixed number of clock cycles attached to each profile. It is equal to f/2 p . 
     Thus, CCT is bounded by f e  bits. Consequently, the CCT value overflows (rolls over) for every cycle, while the accumulated NCT value may overflow within a cycle depending on the ACR value of the associated profile. As a matter of fact, subprofiles having a smaller ACR value within a given profile will tend to overflow due to its higher 1/ACR factor. The NCTs of the respective subprofiles overflow their values during a given cycle only on their last service visit and are not compared again in the same cycle. If NCT is expressed with f e  bits, then an extra flag bit can be added to record the cycle overflow. Similarly, an overflow bit can be used to track the CCT overflow. 
     Although the foregoing discussion shows that the storage requirements for CCT and NCT can be limited to f e  +1 bits, the problem in comparison mismatch between NCT and CCT remains. To solve this problem, it must be determined if there is difference in the most significant bits of the CCT and NCT values (i.e., the overflow flag bits). For clarity, the following variables are introduced: 
     1. CCT --  global --  overflow --  bit: a variable having two possible states (viz. 0 and 1) such that on the completion of every full length cycle the value of CCT --  global --  overflow --  bit toggles; thus CCT --  global --  overflow --  bit=CCT --  global --  overflow --  bit if CCT=2 fe . The CCT --  global --  overflow --  bit thus signifies the cycle boundaries. 
     2. NCT overflow bit (for each subprofile): when NCT is added to the scaled 1/ACR value as in Equation (11), NCT may overflow. NCT --  overflow --  bit is toggled if such overflow occurs; thus: ##EQU15## 
     3. Total --  current --  cell --  time: a global variable that defines the value of the accumulated CCT for 1 cycle and is equal to 2 fe . This value is used for the arithmetic modulo operation while computing the updated values of the NCT and CCT. 
     4. Cycle --  bit: a flag which indicates whether the NCT has been updated during the current cycle or was last updated during a previous cycle. 
     The CCT --  global --  overflow --  bit and the CCT --  overflow --  bits of all subprofiles are initially cleared. When a valid subprofile is visited, the NCT --  overflow --  bits and CCT --  overflow --  bits are retrieved from memory. Before a (NCT≧CCT) comparison check is made, the following conditions must be verified: 
     A. If, during a given cycle, CCT --  global --  overflow --  bit=Cycle --  bit then the following checks are made: 
     (1) If CCT --  global --  overflow --  bit=NCT --  overflow --  bit of a given subprofile, then the CCT and NCT for a given profile lie within the same cycle boundary. In other words, both may be in the 0 or 1 state and the algorithm proceeds with the NCT≧CCT comparison, with the NCT and CCT values unchanged. 
     (2) If CCT --  global --  overflow --  bit≠NCT --  overflow --  bit for a given subprofile, an NCT overflow is implied and the new value of NCT is given by: 
     
         NCT.sub.-- new=NCT.sub.-- old+total.sub.-- current.sub.-- cell.sub.-- time 
    
     B. If, during a given cycle, CCT --  global --  overflow --  bit≠Cycle --  bit then the following checks are made: 
     (1) If CCT --  global --  overflow --  bit=NCT --  overflow --  bit of a given subprofile, then the CCT and NCT for a given profile lie within the same cycle boundary. In other words, both may be in the 0 or 1 state and the algorithm proceeds with the NCT≧CCT comparison, with the NCT and CCT values unchanged. 
     (2) If CCT --  global --  overflow --  bit≠NCT --  overflow --  bit for a given subprofile, then CCT and the last recorded state of NCT differ by 1 cycle. If CCT --  overflow --  bit=1 (0) and NCT --  overflow --  bit=0 (1), then CCT has crossed a cycle boundary, while NCT has not. Therefore, before the NCT≧CCT comparison is made, the CCT value must be appropriately scaled because the NCT value would have a different overflow status in the previous cycle compared to CCT. Hence, the new value for CCT is given as: 
     
         CCT.sub.-- new=CCT.sub.-- old+total.sub.-- current.sub.-- cell.sub.-- time 
    
     FIGS. 33(a), 33(b) and 34 are pseudo-code listings of the Virtual --  time --  dispatcher and Profile generator algorithms, incorporating the necessary modifications for dealing with the counter overflow problem in accordance with the solution presented above. In terms of implementation complexity, two extra bits per subprofile are required to store the nct --  overflow --  bit and Cycle --  bit parameters. Therefore for a circuit with p profiles and sp subprofiles, the total number of storage locations required is p×spx(f e  +2). Furthermore, the CCT --  global --  overflow --  bit requires 1 extra bit for the entire profile/subprofile set. Hence, total storage complexity is  (f e  +2)xp×sp!+f e  +1. The modulo operations and comparisons are easily handled since total --  current --  cell --  time is a power of two. The above algorithm with bounded values of counters was simulated in the case studies outlined above. The output of the program was found to be identical to that obtained where counters of infinite length are used. 
     As will be apparent to those skilled in the art in the light of the foregoing disclosure, many alterations and modifications are possible in the practice of this invention without departing from the spirit or scope thereof. For example, the sequential scheduling method is simpler and does not require much resource management such as lookahead, pipelining and buffering capabilities, in comparison to the parallel scheduling method. Accordingly, the scope of the invention is to be construed in accordance with the substance defined by the following claims.