Abstract:
Bandwidth is assigned to subscribers of a data network by applying logic of one or more network devices to sample bits of information communicated over a network communication medium to identify if there is a network congestion condition or an extremely lightly loaded condition. The maximum bandwidth assigned to a subscriber is below a normative maximum bandwidth assigned to the subscriber if the network is congested and the logic of the one or more network devices identifies the subscriber as a heavy bandwidth user. The maximum bandwidth assigned to a subscriber is above the normative maximum bandwidth if the network is extremely lightly loaded and the subscriber is a heavy bandwidth user.

Description:
PRIORITY CLAIM 
     This application claims priority under 35 USC 119 to USA application No. 61/046,265 filed on Friday, Apr. 18, 2008, which is incorporated herein by reference in its entirety. 
    
    
     BACKGROUND 
     Multiple System Operators (MSOs) have found that a small percentage of subscribers consume a large percentage of the channel data bandwidth, causing network congestion that affects the quality of service offered to other subscribers. MSOs cannot use application-aware equipment to limit the traffic of heavy users due to network neutrality issues. The heavy users are also complaining that MSOs limit their traffic during congestion periods. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       In the drawings, the same reference numbers and acronyms identify elements or acts with the same or similar functionality for ease of understanding and convenience. To easily identify the discussion of any particular element or act, the most significant digit or digits in a reference number refer to the figure number in which that element is first introduced. 
         FIG. 1  is an illustration of an embodiment of state machine logic that may be applied to identify whether a channel is congested or not. 
         FIG. 2  is an illustration of an embodiment of a bucket model where the bucket size is large to allow for bursting. 
         FIG. 3  is a flow chart of an embodiment of a process in which the ITO limits the usage of heavy subscribers at congestion periods and also speeds up service to heavy subscribers when the channel is extremely lightly utilized. 
         FIG. 4  is a flow chart of an embodiment of a process of classifying a subscriber as heavy or light. 
     
    
    
     DETAILED DESCRIPTION 
     References to “one embodiment” or “an embodiment” do not necessarily refer to the same embodiment, although they may. 
     Unless the context clearly requires otherwise, throughout the description and the claims, the words “comprise,” “comprising,” and the like are to be construed in an inclusive sense as opposed to an exclusive or exhaustive sense; that is to say, in the sense of “including, but not limited to.” Words using the singular or plural number also include the plural or singular number respectively. Additionally, the words “herein,” “above,” “below” and words of similar import, when used in this application, refer to this application as a whole and not to any particular portions of this application. When the claims use the word “or” in reference to a list of two or more items, that word covers all of the following interpretations of the word: any of the items in the list, all of the items in the list and any combination of the items in the list. 
     “Logic” refers to signals and/or information that may be applied to influence the operation of a device. Software, hardware, and firmware are examples of logic. Hardware logic may be embodied in circuits. In general, logic may comprise combinations of software, hardware, and/or firmware. 
     Those skilled in the art will appreciate that logic may be distributed throughout one or more devices, and/or may be comprised of combinations of instructions in memory, processing capability, circuits, and so on. Therefore, in the interest of clarity and correctness logic may not always be distinctly illustrated in drawings of devices and systems, although it is inherently present therein. 
     The techniques and procedures described herein may be implemented via logic distributed in one or more computing devices. The particular distribution and choice of logic is a design decision that will vary according to implementation. 
     An Intelligent Traffic Optimizer (ITO) may be used to limit the usage of heavy subscribers only when network congestion is present. Subscribers are allowed to use as much bandwidth as they desire (less than or equal to SLA Tmax) when the network is lightly loaded. SLA Tmax refers to the Service Level Agreement maximum rate given to the subscriber (i.e., the subscribed rate). This feature applies in both upstream and downstream directions. 
     The ITO limits the usage of heavy subscribers at congestion periods through assigning them a new Tmax (Tnew), which is a fractional value of the SLA Tmax. The ITO also speeds up service to heavy subscribers through assigning them a higher Tmax (Thi) when the channel is extremely lightly utilized. The process embodiment described below may be applied in some embodiments of the ITO (See  FIG. 3 ). 
       302  Measure channel utilization every CH_sample minutes (e.g., 5 minutes). 
       304  Identify congestion if present. 
       306  Sample SF byte counts every BKT_sample minutes (e.g., 60 minutes) to estimate usage of the subscriber. All SF&#39;s counts need not be sampled simultaneously, sampling counts for all SF&#39;s may be done sequentially over BKT_sample minutes. 
       308  Identify whether SF is heavy or not. 
       310 ,  312  If the subscriber is heavy, and there is congestion, assign the subscriber a new Tmax value (Tnew), given by
 
 T new=Hvnss_level* T max,
 
     Where the fraction, Hvnss_level, may be evaluated as described below. In the upstream (US) direction, the Tnew value is used by the mapper, while in the downstream (DS) direction, Tnew is used by the traffic shaper. 
       314 ,  316  If the network is extremely lightly utilized, speed up heavy users through assigning them a higher Tmax value (Thi) given by
 
Thi=accl_factr* T max,
 
     Where the acceleration factor (accl_factr) is evaluated as described below. 
     Repeat. 
     The congestion in both the upstream and downstream is evaluated similarly. One possible difference is in choosing the threshold values used to declare a congestion state or the clearance of a congestion state. The following process embodiment may be applied to determine whether the channel is congested or not: 
     The threshold when the congestion starts is Util_cong_start (Tcs). 
     The threshold when the congestion ends is Util_cong_end (Tc E ). 
     The threshold that represents the start of the normal state is Util_norm_start (T NS ). 
     The threshold that represents the end of the normal state is Util_norm_end (T NE ) 
     The measured channel utilization is Util_current (C). 
     The values Util_cong, Util_clear, and Util_current may be applied to identify whether the channel is congested or not every CH_sample minutes according to the state-machine shown in  FIG. 1 . 
     Two different threshold values may be utilized to declare the presence/clearance of the congestion. Identification of the congestion state may be modeled as a hysteresis process. 
     A leaky bucket model may be utilized to identify whether a subscriber (SF) is heavy or not (e.g. once every BKT_sample minutes for each SF). Each SF will have an allowed average rate (Tavg), which is a small value compared to Tmax (e.g., 150 kbps). It is small because it is averaged over a long time, assuming that well-behaved subscribers will be quiet for some time. 
     One embodiment of a bucket model is shown in  FIG. 2 , where the bucket size (BKT_capacity) is a large value to allow for bursting. In one embodiment, every BKT_sample minutes, do the following for each SF (see  FIG. 4 ): 
       402  Tokens_add bytes are added to the bucket (tokens) as
 
Tokens_add= T avg(b/s)*BKT_sample(min)*60(s/min)/8(b/byte)= T avg*BKT_sample*60/8 Bytes
 
       404  Tokens_sub bytes are subtracted (subscriber usage equivalent to lost tokens as Tokens_sub=current byte count−last byte count (Byte_last) 
       406 ,  408 ,  410  If the number tokens in the bucket (current bucket depth, BKT_depth) is 0 or negative, then the user is heavy. Otherwise, he is light. Note that the bucket is allowed to go negative. 
     When a subscriber is identified as heavy and when the channel is congested, the subscriber is assigned a new Tmax value given by Tnew=Hvnss_level*Tmax, where Hvnss_level is a fraction to be determined based on how heavy the subscriber is. 
     A subscriber is identified as heavy if his leaky bucket has 0 or negative tokens. In one embodiment Hvnss_level is determined by how negative the bucket is (i.e., how heavy the subscriber is) according to Table 1 shown below, where T 1  through T 3  are adjustable numbers. 
     
       
         
               
             
               
               
               
             
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Estimating the fraction Hvnss_level 
               
               
                 needed to calculated Tnew 
               
             
          
           
               
                   
                 Tokens in 
                   
               
               
                   
                 bucket 
                 Hvnss_level 
               
               
                   
                   
               
             
          
           
               
                   
                    0 to −T1 
                 0.5 
               
               
                   
                 −T1 to −T2 
                 0.25 
               
               
                   
                 −T2 to −T3 
                 0.125 
               
               
                   
                 −T3 or less 
                 0.05 
               
               
                   
                   
               
             
          
         
       
     
     When a subscriber is identified as heavy and when the channel is lightly or extremely lightly utilized, the subscriber is assigned a higher Tmax value given by Thi=accl_factr*Tmax, where accl_factr is a value greater than 1 to be determined based on how lightly the channel is utilized. A subscriber is identified as heavy if his leaky bucket has 0 or negative tokens. In one embodiment, accl_factr is determined based on the utilization of the channel according to Table 2 shown below, where X 1  (e.g., 5%) through X 3  (e.g., 15%) are adjustable numbers. 
     
       
         
               
             
               
               
               
             
               
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 Estimating the factor 
               
               
                 accl_factr needed to calculated Thi 
               
             
          
           
               
                   
                 Utilization (%) 
                 accl_factr 
               
               
                   
                   
               
             
          
           
               
                   
                   0 to X1 
                 3 
               
               
                   
                 X1 to X2 
                 2.0 
               
               
                   
                 X2 to X3 
                 1.5 
               
               
                   
                   
               
             
          
         
       
     
     The following are parameters that may be controlled and/or adjusted by the customers/vendor before employing the ITO feature: 
     CH_sample: Time in minutes between successive samples for the channel utilization counts. 
     BKT_sample: Time in minutes between successive token bucket updates for each SF. 
     Util_cong_start, Util_cong_stop, Util_norm_low, and Util_lite_end. 
     Tavg: The allowed average rate. 
     T 1 , T 2 , and T 3 : Positive numbers used to set ranges corresponding to different heaviness levels. 
     X 1 , X 2 , and X 3 : Positive numbers used to set ranges corresponding to different acceleration factors. 
     The following parameters are maintained for each SF: 
     BKT_capacity: The capacity of the token bucket. 
     Tavg: The allowed average rate. 
     BKT_depth: the current depth of the token bucket. 
     Byte_last: The last byte count reading. 
     It may also be desirable to maintain the previous state of the channel of being congested or not because the next state depends on the previous one according to the state machine. 
     It may be desirable for the operator to have a document trail for any actions taken to alter a user&#39;s broadband experience. Each time the state machines alter a user&#39;s Tmax value, the operator may have the option of recording that service change in a log, billing record, or other interface for later retrieval. This would allow the operator to document actual actions taken if the need arose at some later time. 
     The granularity of the ITO may be improved to render a more seamless user experience. For example, instead of a single set of fixed thresholds, the thresholds could retain more historical information so that a user who had not been a heavy user usually, would not have his service impacted as much as a user who was chronically a heavy user. This could be done by allowing the BKT_capacity to vary with time. The Hvnss_level could also be adjusted per user in light of past behavior. 
     A more intelligent algorithm could also update the Hvnss_level and BKT_capacity values more or less continually to attempt to provide best possible service levels for as many users as possible. For example, if the channel is just barely in congestion, only making small adjustments to the very heaviest users may be enough to ensure adequate quality of service. Alternately, if there are many users all with reasonably traffic levels, but the channel is still being forced into congestion, service level adjustments may be necessary for a large number of users to improve the quality of experience for everyone. 
     Those having skill in the art will appreciate that there are various logic implementations by which processes and/or systems described herein can be effected (e.g., hardware, software, and/or firmware), and that the preferred vehicle will vary with the context in which the processes are deployed. For example, if an implementer determines that speed and accuracy are paramount, the implementer may opt for a hardware and/or firmware vehicle; alternatively, if flexibility is paramount, the implementer may opt for a solely software implementation; or, yet again alternatively, the implementer may opt for some combination of hardware, software, and/or firmware. Hence, there are several possible vehicles by which the processes described herein may be effected, none of which is inherently superior to the other in that any vehicle to be utilized is a choice dependent upon the context in which the vehicle will be deployed and the specific concerns (e.g., speed, flexibility, or predictability) of the implementer, any of which may vary. Those skilled in the art will recognize that optical aspects of implementations may involve optically-oriented hardware, software, and or firmware. 
     The foregoing detailed description has set forth various embodiments of the devices and/or processes via the use of block diagrams, flowcharts, and/or examples. Insofar as such block diagrams, flowcharts, and/or examples contain one or more functions and/or operations, it will be understood as notorious by those within the art that each function and/or operation within such block diagrams, flowcharts, or examples can be implemented, individually and/or collectively, by a wide range of hardware, software, firmware, or virtually any combination thereof. Several portions of the subject matter described herein may be implemented via Application Specific Integrated Circuits (ASICs), Field Programmable Gate Arrays (FPGAs), digital signal processors (DSPs), or other integrated formats. However, those skilled in the art will recognize that some aspects of the embodiments disclosed herein, in whole or in part, can be equivalently implemented in standard integrated circuits, as one or more computer programs running on one or more computers (e.g., as one or more programs running on one or more computer systems), as one or more programs running on one or more processors (e.g., as one or more programs running on one or more microprocessors), as firmware, or as virtually any combination thereof, and that designing the circuitry and/or writing the code for the software and/or firmware would be well within the skill of one of skill in the art in light of this disclosure. In addition, those skilled in the art will appreciate that the mechanisms of the subject matter described herein are capable of being distributed as a program product in a variety of forms, and that an illustrative embodiment of the subject matter described herein applies equally regardless of the particular type of signal bearing media used to actually carry out the distribution. Examples of a signal bearing media include, but are not limited to, the following: recordable type media such as floppy disks, hard disk drives, CD ROMs, digital tape, and computer memory; and transmission type media such as digital and analog communication links using TDM or IP based communication links (e.g., packet links). 
     In a general sense, those skilled in the art will recognize that the various aspects described herein which can be implemented, individually and/or collectively, by a wide range of hardware, software, firmware, or any combination thereof can be viewed as being composed of various types of “electrical circuitry.” Consequently, as used herein “electrical circuitry” includes, but is not limited to, electrical circuitry having at least one discrete electrical circuit, electrical circuitry having at least one integrated circuit, electrical circuitry having at least one application specific integrated circuit, electrical circuitry forming a general purpose computing device configured by a computer program (e.g., a general purpose computer configured by a computer program which at least partially carries out processes and/or devices described herein, or a microprocessor configured by a computer program which at least partially carries out processes and/or devices described herein), electrical circuitry forming a memory device (e.g., forms of random access memory), and/or electrical circuitry forming a communications device (e.g., a modem, communications switch, or optical-electrical equipment). 
     Those skilled in the art will recognize that it is common within the art to describe devices and/or processes in the fashion set forth herein, and thereafter use standard engineering practices to integrate such described devices and/or processes into larger systems. That is, at least a portion of the devices and/or processes described herein can be integrated into a network processing system via a reasonable amount of experimentation. 
     The foregoing described aspects depict different components contained within, or connected with, different other components. It is to be understood that such depicted architectures are merely exemplary, and that in fact many other architectures can be implemented which achieve the same functionality. In a conceptual sense, any arrangement of components to achieve the same functionality is effectively “associated” such that the desired functionality is achieved. Hence, any two components herein combined to achieve a particular functionality can be seen as “associated with” each other such that the desired functionality is achieved, irrespective of architectures or intermedial components. Likewise, any two components so associated can also be viewed as being “operably connected”, or “operably coupled”, to each other to achieve the desired functionality.