4.3.  Class Definitions

   This section presents the classes and properties that make up the
   Information Model for describing QoS-related functionality in network
   devices, including hosts.  These definitions are derived from
   definitions in the CIM Core model [CIM].  Only the QoS-related
   classes are defined in this document.  However, other classes drawn
   from the CIM Core model, as well as from [PCIME], are described
   briefly.  The reader is encouraged to look at [CIM] and at [PCIME]
   for further information.  Associations and aggregations are defined
   in Section 4.4.

4.3.1.  The Abstract Class ManagedElement

   This is an abstract class defined in the Core Model of CIM.  It is
   the root of the entire class inheritance hierarchy in CIM. Among the
   associations that refer to it are two that are subclassed in this
   document: Dependency and MemberOfCollection, which is an aggregation.
   ManagedElement's properties are Caption and Description.  Both are
   free-form strings to describe an instantiated object.  Please refer
   to [CIM] for the full definition of this class.

4.3.2.  The Abstract Class ManagedSystemElement

   This is an abstract class defined in the Core Model of CIM; it is a
   subclass of ManagedElement.  ManagedSystemElement serves as the base
   class for the PhysicalElement and LogicalElement class hierarchies.
   LogicalElement, in turn, is the base class for a number of important
   CIM hierarchies, including System.  Any distinguishable component of
   a System is a candidate for inclusion in this class hierarchy,
   including physical components (e.g., chips and cards) and logical
   components (e.g., software components, services, and other objects).

   None of the associations in which this class participates is used
   directly in the QoS device state model.  However, the aggregation
   Component, which relates one ManagedSystemElement to another, is the
   base class for the two aggregations that form the core of the QoS
   device state model: QoSSubService and QoSConditioningSubService.
   Similarly, the association ProvidesServiceToElement, which relates a
   ManagedSystemElement to a Service, is the base class for the model's
   CalculationServiceForDropper association.

   Please refer to [CIM] for the full definition of this class.

4.3.3.  The Abstract Class LogicalElement

   This is an abstract class defined in the Core Model of CIM.  It is a
   subclass of the ManagedSystemElement class, and is the base class for
   all logical components of a managed System, such as Files, Processes,
   or system capabilities in the form of Logical Devices and Services.
   None of the associations in which this class participates is relevant
   to the QoS device state model. Please refer to [CIM] for the full
   definition of this class.

4.3.4.  The Abstract Class Service

   This is an abstract class defined in the Core Model of CIM.  It is a
   subclass of the LogicalElement class, and is the base class for all
   objects that represent a "service" or functionality in a System.  A
   Service is a general-purpose object that is used to configure and
   manage the implementation of functionality.  As noted above in
   section 4.3.2, this class participates in the
   ProvidesServiceToElement association.  Please refer to [CIM] for the
   full definition of this class.

4.3.5.  The Class ConditioningService

   This is a concrete subclass of the CIM Core class Service; it
   represents the ability to define how traffic is conditioned in the
   data-forwarding path of a device.  The subclasses of

   ConditioningService define the particular types of conditioning that
   are done.  Six fundamental types of conditioning are defined in this
   document.  These are the services performed by a classifier, a meter,
   a marker, a dropper, a queue, and a scheduler.  Other, more
   sophisticated types of conditioning may be defined in future
   documents.

   ConditioningService is a concrete class because at the time it was
   defined in CIM, its superclass was concrete.  While this class can be
   instantiated, an instance of it would not accomplish anything,
   because the nature of the conditioning, and the parameters that
   control it, are specified only in the subclasses of
   ConditioningService.

   Two associations in which ConditioningService participates are
   critical to its usage in QoS - QoSConditioningSubService and
   NextService.  QoSConditioningSubService aggregates
   ConditioningServices into a particular QoS service (such as AF), to
   describe the specific conditioning functionality that underlies that
   QoS service in a particular device.  NextService indicates the
   subsequent conditioning service(s) for different traffic streams.

   The class definition is as follows:

      NAME                ConditioningService
      DESCRIPTION         A concrete class to define how traffic
                          is conditioned in the data forwarding
                          path of a host or network device.
      DERIVED FROM        Service
      TYPE                Concrete
      PROPERTIES          (none)

4.3.6.  The Class ClassifierService

   The concept of a Classifier comes from [DSMODEL]. ClassifierService
   is a concrete class that represents a logical entity in an ingress or
   egress interface of a device, that takes a single input stream, and
   sorts it into one or more output streams.  The sorting is done by a
   set of filters that select packets based on the packet contents, or
   possibly based on other attributes associated with the packet.  Each
   output stream is the result of matching a particular filter.

   The representation of classifiers in QDDIM is closely related to that
   presented in [DSMIB] and [DSMODEL].  Rather than being linked
   directly to its FilterLists, a classifier is modeled here as an
   aggregation of ClassifierElements.  Each of these ClassifierElements
   is then linked to a single FilterList, by the association
   ClassifierElementUsesFilterList.

   A Classifier is modeled as a subclass of ConditioningService so that
   it can be aggregated into a QoSService (using the
   QoSConditioningSubService aggregation), and can use the NextService
   association to identify the subsequent ConditioningService objects
   for the different traffic streams.

   ClassifierService is designed to allow hierarchical classification.
   When hierarchical classification is used, a ClassifierElement may
   point to another ClassifierService.  When used for this purpose, the
   ClassifierElement must not use the ClassifierElementUsesFilterList
   association.

   The class definition is as follows:

      NAME                ClassifierService
      DESCRIPTION         A concrete class describing how an input
                          traffic stream is sorted into multiple
                          output streams using one or more
                          filters.
      DERIVED FROM        ConditioningService
      TYPE                Concrete
      PROPERTIES          (none)

4.3.7.  The Class ClassifierElement

   The concept of a ClassifierElement comes from [DSMIB].  This concrete
   class represents the linkage, within a single ClassifierService,
   between a FilterList that specifies a set of criteria for selecting
   packets from the stream of packets coming into the ClassifierService,
   and the next ConditioningService to which the selected packets go
   after they leave the ClassifierService.  ClassifierElement has no
   properties of its own.  It is present to serve as the anchor for an
   aggregation with its classifier, and for associations with its
   FilterList and its next ConditioningService.

   When a ClassifierElement is associated with a ClassifierService
   through the NextServiceAfterClassifierElement association, the
   ClassifierElement may not use the ClassifierElementUsesFilterList
   association.  Further, when a ClassifierElement is associated with a
   ClassifierService as described above, the order of processing of the
   associated ClassifierService is a function of the ClassifierOrder
   property of the ClassifierElementInClassifierService aggregation.
   For example, lets assume the following:

   1. ClassifierService (C1) aggregates ClassifierElements (E1), (E2)
      and (E3), with relative ClassifierOrder values of 1, 2, and 3.

   2. ClassifierElements (E1) and (E3) associations to FilterLists (F1)
      and (F3) respectively using the ClassifierElementUsesFilterList
      association.

   3. (E1) & (E3) are associated with Meters (M1) and (M3) through their
      respective NextServiceAfterClassifierElement associations.

   4. (E2) is associated with ClassifierService (C2) through its
      NextServiceAfterClassifierElement association.

   5. ClassifierService (C2) aggregates ClassifierElements (E4) and (E5)
      with relative ClassifierOrder values of 1 and 2.

   6. ClassifierElements (E4) and (E5) have associations to FilterLists
      (F4) and (F5) respectively using the
      ClassifierElementUsesFilterList association.

   In this example, packet processing would match FilterLists in the
   order of (F1), (F4), (F5), and (F3).

   The class definition is as follows:

      NAME                ClassifierElement
      DESCRIPTION         A concrete class representing
                          the process by which a classifier
                          uses a filter to select packets
                          to forward to a specific next
                          conditioning service.
      DERIVED FROM        ClassifierService
      TYPE                Concrete
      PROPERTIES          (none)

4.3.8.  The Class MeterService

   This is a concrete class that represents the metering of network
   traffic.  Metering is the function of monitoring the arrival times of
   packets of a traffic stream, and determining the level of conformance
   of each packet with respect to a pre-established traffic profile.  A
   meter has the ability to invoke different ConditioningServices for
   conforming and non-conforming traffic. Traffic leaving a meter may be
   further conditioned (e.g., dropped or queued) by routing the packet
   to another conditioning element. Please see [DSMODEL] for more
   information on metering.

   This class is the base class for defining different types of meters.
   As such, it contains common properties that all meter subclasses
   share.  It is modeled as a ConditioningService so that it can be
   aggregated into a QoSService (using the QoSConditioningSubService

   association), to indicate that its functionality underlies that QoS
   service.  MeterService also participates in the NextServiceAfterMeter
   association, to identify the subsequent ConditioningService objects
   for conforming and non-conforming traffic.

   The class definition is as follows:

      NAME                MeterService
      DESCRIPTION         A concrete class describing the
                          monitoring of traffic with respect to a
                          pre-established traffic profile.
      DERIVED FROM        ConditioningService
      TYPE                Concrete
      PROPERTIES          MeterType, OtherMeterType,
                          ConformanceLevels

   Note: The MeterType property and the MeterService subclasses provide
   similar information.  The MeterType property is defined for query
   purposes and for future expansion.  It is possible that not all
   MeterServices will require a subclass to define them.  In these
   cases, MeterService will be instantiated directly, and the MeterType
   property will provide the only way of identifying the type of the
   meter.

4.3.8.1.  The Property MeterType

   This property is an enumerated 16-bit unsigned integer that is used
   to specify the particular type of meter represented by an instance of
   MeterService.  The following enumeration values are defined:

      1 - Other
      2 - Average Rate Meter
      3 - Exponentially Weighted Moving Average Meter
      4 - Token Bucket Meter

   Note: if the value of MeterType is not one of these four values, it
   SHOULD be interpreted as if it had the value '1' (Other).

4.3.8.2.  The Property OtherMeterType

   This is a string property that defines a vendor-specific description
   of a type of meter.  It is used when the value of the MeterType
   property in the instance is equal to 1.

4.3.8.3.  The Property ConformanceLevels

   This property is a 16-bit unsigned integer.  It indicates the number
   of conformance levels supported by the meter.  For example, when only
   "in profile" versus "out of profile" metering is supported,
   ConformanceLevels is equal to 2.

4.3.9.  The Class AverageRateMeterService

   This is a concrete subclass of MeterService that represents a simple
   meter, called an Average Rate Meter.  This type of meter measures the
   average rate at which packets are submitted to it over a specified
   time.  Packets are defined as conformant if their average arrival
   rate does not exceed the specified measuring rate of the meter.  Any
   packet that causes the specified measuring rate to be exceeded is
   defined to be non-conforming.  For more information, please see
   [DSMODEL].

   The class definition is as follows:

      NAME                AverageRateMeterService
      DESCRIPTION         A concrete class classifying traffic as
                          either conforming or non-conforming,
                          depending on whether the arrival of a
                          packet causes the average arrival rate
                          to exceed a pre-determined value.
      DERIVED FROM        MeterService
      TYPE                Concrete
      PROPERTIES          AverageRate, DeltaInterval

4.3.9.1.  The Property AverageRate

   This is an unsigned 32-bit integer that defines the rate used to
   determine whether admitted packets are in conformance or not. The
   value is specified in kilobits per second.

4.3.9.2.  The Property DeltaInterval

   This is an unsigned 64-bit integer that defines the time period over
   which the average measurement should be taken.  The value is
   specified in microseconds.

4.3.10.  The Class EWMAMeterService

   This is a concrete subclass of the MeterService class that represents
   an exponentially weighted moving average meter.  This meter is a
   simple low-pass filter that measures the rate of incoming packets

   over a small, fixed sampling interval.  Any admitted packet that
   pushes the average rate over a pre-defined limit is defined to be
   non-conforming.  Please see [DSMODEL] for more information.

   The class definition is as follows:

      NAME                EWMAMeterService
      DESCRIPTION         A concrete class classifying admitted
                          traffic as either conforming or non-
                          conforming, depending on whether the
                          arrival of a packet causes the average
                          arrival rate in a small fixed
                          sampling interval to exceed a
                          pre-determined value or not.
      DERIVED FROM        MeterService
      TYPE                Concrete
      PROPERTIES          AverageRate, DeltaInterval, Gain

4.3.10.1.  The Property AverageRate

   This property is an unsigned 32-bit integer that defines the average
   rate against which the sampled arrival rate of packets should be
   measured.  Any packet that causes the sampled rate to exceed this
   rate is deemed non-conforming.  The value is specified in kilobits
   per second.

4.3.10.2.  The Property DeltaInterval

   This property is an unsigned 64-bit integer that defines the sampling
   interval used to measure the arrival rate.  The calculated rate is
   averaged over this interval and checked against the AverageRate
   property.  All packets whose computed average arrival rate is less
   than the AverageRate are deemed conforming.

   The value is specified in microseconds.

4.3.10.3.  The Property Gain

   This property is an unsigned 32-bit integer representing the
   reciprocal of the time constant (e.g., frequency response) of what is
   essentially a simple low-pass filter.  For example, the value 64 for
   this property represents a time constant value of 1/64.

4.3.11.  The Class TokenBucketMeterService

   This is a concrete subclass of the MeterService class that represents
   the metering of network traffic using a token bucket meter.  Two
   types of token bucket meters are defined using this class - a simple,
   two-parameter bucket meter, and a multi-stage meter.

   A simple token bucket usually has two parameters, an average token
   rate and a burst size, and has two conformance levels: "conforming"
   and "non-conforming".  This class also defines an excess burst size,
   which enables the meter to have three conformance levels
   ("conforming", "partially conforming", and "non-conforming").  In
   this case, packets that exceed the excess burst size are deemed non-
   conforming, while packets that exceed the smaller burst size but are
   less than the excess burst size are deemed partially conforming.
   Operation of these meters is described in [DSMODEL].

   The class definition is as follows:

      NAME                TokenBucketMeterService
      DESCRIPTION         A concrete class classifying admitted
                          traffic with respect to a token bucket.
                          Either two or three levels of
                          conformance can be defined.
      DERIVED FROM        MeterService
      TYPE                Concrete
      PROPERTIES          AverageRate, PeakRate,
                          BurstSize, ExcessBurstSize

4.3.11.1.  The Property AverageRate

   This property is an unsigned 32-bit integer that specifies the
   committed rate of the meter.  The value is expressed in kilobits per
   second.

4.3.11.2.  The Property PeakRate

   This property is an unsigned 32-bit integer that specifies the peak
   rate of the meter.  The value is expressed in kilobits per second.

4.3.11.3.  The Property BurstSize

   This property is an unsigned 32-bit integer that specifies the
   maximum number of tokens available for the committed rate (specified
   by the AverageRate property).  The value is expressed in kilobytes.

4.3.11.4.  The Property ExcessBurstSize

   This property is an unsigned 32-bit integer that specifies the
   maximum number of tokens available for the peak rate (specified by
   the PeakRate property).  The value is expressed in kilobytes.

4.3.12.  The Class MarkerService

   This is a concrete class that represents the general process of
   marking some field in a network packet with some value. Subclasses of
   MarkerService identify particular fields to be marked, and introduce
   properties to represent the values to be used in marking these
   fields.  Markers are usually invoked as a result of a preceding
   classifier match.  Operation of markers of various types is described
   in [DSMODEL].

   MarkerService is a concrete class because at the time it was defined
   in CIM, its superclass was concrete.  While this class can be
   instantiated, an instance of it would not accomplish anything,
   because both the field to be marked and the value to be used to mark
   it are specified only in subclasses of MarkerService.

   MarkerService is modeled as a ConditioningService so that it can be
   aggregated into a QoSService (using the QoSConditioningSubService
   association) to indicate that its functionality underlies that QoS
   service.  It participates in the NextService association to identify
   the subsequent ConditioningService object that acts on traffic after
   it has been marked by the marker.

   The class definition is as follows:

      NAME                MarkerService
      DESCRIPTION         A concrete class representing the
                          general process of marking a selected
                          field in a packet with a specified
                          value.  Packets are marked in order
                          to control the conditioning that
                          they will subsequently receive.
      DERIVED FROM        ConditioningService
      TYPE                Concrete
      PROPERTIES          (none)

4.3.13.  The Class PreambleMarkerService

   This is a concrete class that models the storing of traffic-
   conditioning results in a packet preamble.  See Section 3.8.3 for a
   discussion of how, and why, QDDIM models the capability to store
   these results in a packet preamble.  An instance of

   PreambleMarkerService appends to a packet preamble a two-part string
   of the form "<type>,<value>".  Section 3.8.3 provides a list of the
   <type> strings defined by QDDIM.  Implementations may support other
   <type>'s in addition to these.

   The class definition is as follows:

      NAME                PreambleMarkerService
      DESCRIPTION         A concrete class representing the saving
                          of traffic-conditioning results in a
                          packet preamble.
      DERIVED FROM        MarkerService
      TYPE                Concrete
      PROPERTIES          FilterItemList[ ]

4.3.13.1.  The Multi-valued Property FilterItemList

   This property is an ordered list of strings, where each string has
   the format "<type>,<value>".  See Section 3.8.3 for a list of
   <type>'s defined in QDDIM, and the nature of the associated <value>
   for each of these types.

4.3.14.  The Class ToSMarkerService

   This is a concrete class that represents the marking of the ToS field
   in the IPv4 packet header [R791].  Following common practice, the
   value to be written into the field is represented as an unsigned 8-
   bit integer.

   The class definition is as follows:

      NAME                ToSMarkerService
      DESCRIPTION         A concrete class representing the
                          process of marking the type of service
                          (ToS) field in the IPv4 packet header
                          with a specified value.  Packets are
                          marked in order to control the
                          conditioning that they will subsequently
                          receive.
      DERIVED FROM        MarkerService
      TYPE                Concrete
      PROPERTIES          ToSValue

4.3.14.1.  The Property ToSValue

   This property is an unsigned 8-bit integer, representing a value to
   be used for marking the type of service (ToS) field in the IPv4
   packet header.  The ToS field is defined to be a complete octet, so
   the range for this property is 0..255.  Some implementations,
   however, require that the lowest-order bit in the ToS field always be
   '0'.  Such an implementation is consequently unable to support an odd
   TosValue.

4.3.15.  The Class DSCPMarkerService

   This is a concrete class that represents the marking of the
   differentiated services codepoint (DSCP) within the DS field in the
   IPv4 and IPv6 packet headers, as defined in [R2474]. Following common
   practice, the value to be written into the field is represented as an
   unsigned 8-bit integer.

   The class definition is as follows:

      NAME                DSCPMarkerService
      DESCRIPTION         A concrete class representing the
                          process of marking the DSCP field
                          in a packet with a specified
                          value.  Packets are marked in order
                          to control the conditioning that
                          they will subsequently receive.
      DERIVED FROM        MarkerService
      TYPE                Concrete
      PROPERTIES          DSCPValue

4.3.15.1.  The Property DSCPValue

   This property is an unsigned 8-bit integer, representing a value to
   be used for marking the DSCP within the DS field in an IPv4 or IPv6
   packet header.  Since the DSCP consists of 6 bits, the values for
   this property are limited to the range 0..63.  When the DSCP is
   marked, the remaining two bit in the DS field are left unchanged.

4.3.16.  The Class 8021QMarkerService

   This is a concrete class that represents the marking of the user
   priority field defined in the IEEE 802.1Q specification [IEEE802Q].
   Following common practice, the value to be written into the field is
   represented as an unsigned 8-bit integer.

   The class definition is as follows:

      NAME                8021QMarkerService
      DESCRIPTION         A concrete class representing the
                          process of marking the Priority
                          field in an 802.1Q-compliant frame
                          with a specified value.  Frames are
                          marked in order to control the
                          conditioning that they will
                          subsequently receive.
      DERIVED FROM        MarkerService
      TYPE                Concrete
      PROPERTIES          PriorityValue

4.3.16.1.  The Property PriorityValue

   This property is an unsigned 8-bit integer, representing a value to
   be used for marking the Priority field in the 802.1Q header. Since
   the Priority field consists of 3 bits, the values for this property
   are limited to the range 0..7.  When the Priority field is marked,
   the remaining bits in its octet are left unchanged.

4.3.17.  The Class DropperService

   This is a concrete class that represents the ability to selectively
   drop network traffic, or to invoke another ConditioningService for
   further processing of traffic that is not dropped.  This is the base
   class for different types of droppers. Droppers are distinguished by
   the algorithm that they use to drop traffic.  Please see [DSMODEL]
   for more information about the various types of droppers.  Note that
   this class encompasses both Absolute Droppers and Algorithmic
   Droppers from [DSMODEL].

   DropperService is modeled as a ConditioningService so that it can be
   aggregated into a QoSService (using the QoSConditioningSubService
   association) to indicate that its functionality underlies that QoS
   service.  It participates in the NextService association to identify
   the subsequent ConditioningService object that acts on any remaining
   traffic that is not dropped.

   NextService has special semantics for droppers, in addition to the
   general "what happens next" semantics that apply to all
   ConditioningServices.  The queue(s) from which a particular dropper
   drops packets are identified by following chain(s) of NextService
   associations "rightwards" from the dropper until they reach a queue.

   The class definition is as follows:

      NAME                DropperService
      DESCRIPTION         A concrete base class describing the
                          common characteristics of droppers.
      DERIVED FROM        ConditioningService
      TYPE                Concrete
      PROPERTIES          DropperType, OtherDropperType, DropFrom

   Note: The DropperType property and the DropperService subclasses
   provide similar information.  The DropperType property is defined for
   query purposes, as well as for those cases where a subclass of
   DropperService is not needed to model a particular type of dropper.
   For example, the Absolute Dropper defined in [DSMODEL] is modeled as
   an instance of the DropperService class with its DropperType set to
   '4' ("Absolute Dropper").

4.3.17.1.  The Property DropperType

   This is an enumerated 16-bit unsigned integer that defines the type
   of dropper.  Values include:

      1 - Other
      2 - Random
      3 - HeadTail
      4 - Absolute Dropper

   Note: if the value of DropperType is not one of these four values, it
   SHOULD be interpreted as if it had the value '1' (Other).

4.3.17.2.  The Property OtherDropperType

   This string property is used in conjunction with the DropperType
   property.  When the value of DropperType is '1' (i.e., Other), then
   the name of the type of dropper appears in this property.

4.3.17.3.  The Property DropFrom

   This is an unsigned 16-bit integer enumeration that indicates the
   point in the associated queue from which packets should be dropped.
   Defined enumeration values are:

      o  unknown(0)
      o  head(1)
      o  tail(2)

   Note: if the value of DropFrom is '0' (unknown), or if it is not one
   of the three values listed here, then packets MAY be dropped from any
   location in the associated queue.

4.3.18.  The Class HeadTailDropperService

   This is a concrete class that represents the threshold information of
   a head or tail dropper.  The inherited property DropFrom indicates
   whether a particular instance of this class represents a head dropper
   or a tail dropper.

   A head dropper always examines the same queue from which it drops
   packets, and this queue is always related to the dropper as the
   following service in the NextService association.

   The class definition is as follows:

      NAME                HeadTailDropperService
      DESCRIPTION         A concrete class used to describe
                          a head or tail dropper.
      DERIVED FROM        DropperService
      TYPE                Concrete
      PROPERTIES          QueueThreshold

4.3.18.1.  The Property QueueThreshold

   This is an unsigned 32-bit integer that indicates the queue depth at
   which traffic will be dropped.  For a tail dropper, all newly
   arriving traffic is dropped.  For a head dropper, packets at the
   front of the queue are dropped to make room for new packets, which
   are added at the end.  The value is expressed in bytes.

4.3.19.  The Class REDDropperService

   This is a concrete class that represents the ability to drop network
   traffic using a Random Early Detection (RED) algorithm. This
   algorithm is described in [RED].  The purpose of a RED algorithm is
   to avoid congestion (as opposed to managing congestion).  Instead of
   waiting for the queues to fill up, and then dropping large numbers of
   packets, RED works by monitoring the average queue depth.  When the
   queue depth exceeds a minimum threshold, packets are randomly
   discarded.  These discards cause TCP to slow its transmission rate
   for those connections that experienced the packet discards.  Other
   TCP connections are not affected by these discards.  Please see
   [DSMODEL] for more information about a dropper.

   A RED dropper always drops packets from a single queue, which is
   related to the dropper as the following service in the NextService
   association.  The queue(s) examined by the drop algorithm are found
   by following the CalculationServiceForDropper association to find the
   dropper's DropThresholdCalculationService, and then following the
   CalculationBasedOnQueue association(s) to find the queue(s) being
   watched.

   The class definition is as follows:

      NAME                REDDropperService
      DESCRIPTION         A concrete class used to describe
                          dropping using the RED algorithm (or
                          one of its variants).
      DERIVED FROM        DropperService
      TYPE                Concrete
      PROPERTIES          MinQueueThreshold, MaxQueueThreshold,
                          ThresholdUnits, StartProbability,
                          StopProbability

   NOTE:  In [DSMIB], there is a single diffServRandomDropTable, which
   represents the general category of random dropping.  (RED is one type
   of random dropping, but there are also types of random dropping
   distinct from RED.)  The REDDropperService class corresponds to the
   columns in the table that apply to the RED algorithm in particular.

4.3.19.1.  The Property MinQueueThreshold

   This is an unsigned 32-bit integer that defines the minimum average
   queue depth at which packets are subject to being dropped.  The units
   are identified by the ThresholdUnits property.  The slope of the drop
   probability function is described by the Start/StopProbability
   properties.

4.3.19.2.  The Property MaxQueueThreshold

   This is an unsigned 32-bit integer that defines the maximum average
   queue length at which packets are subject to always being dropped,
   regardless of the dropping algorithm and probabilities being used.
   The units are identified by the ThresholdUnits property.

4.3.19.3.  The Property ThresholdUnits

   This is an unsigned 16-bit integer enumeration that identifies the
   units for the MinQueueThreshold and MaxQueueThreshold properties.
   Defined enumeration values are:

      o    bytes(1)
      o    packets(2)

   Note: if the value of ThresholdUnits is not one of these two values,
   it SHOULD be interpreted as if it had the value '1' (bytes).

4.3.19.4.  The Property StartProbability

   This is an unsigned 32-bit integer; in conjunction with the
   StopProbability property, it defines the slope of the drop
   probability function.  This function governs the rate at which
   packets are subject to being dropped, as a function of the queue
   length.

   This property expresses a drop probability in drops per thousand
   packets.  For example, the value 100 indicates a drop probability of
   100 per 1000 packets, that is, 10%.  Min and max values are 0 to
   1000.

4.3.19.5.  The Property StopProbability

   This is an unsigned 32-bit integer; in conjunction with the
   StartProbability property, it defines the slope of the drop
   probability function.  This function governs the rate at which
   packets are subject to being dropped, as a function of the queue
   length.

   This property expresses a drop probability in drops per thousand
   packets.  For example, the value 100 indicates a drop probability of
   100 per 1000 packets, that is, 10%.  Min and max values are 0 to
   1000.

4.3.20.  The Class QueuingService

   This is a concrete class that represents the ability to queue network
   traffic, and to specify the characteristics for determining long-term
   congestion.  Please see [DSMODEL] for more information about queuing
   functionality.

   QueuingService is modeled as a ConditioningService so that it can be
   aggregated into a QoSService (using the QoSConditioningSubService
   association) to indicate that its functionality underlies that QoS
   service.

   The class definition is as follows:

      NAME                QueuingService
      DESCRIPTION         A concrete class describing the ability
                          to queue network traffic and to specify
                          the characteristics for determining
                          long-term congestion.
      DERIVED FROM        ConditioningService
      TYPE                Concrete
      PROPERTIES          CurrentQueueDepth, DepthUnits

4.3.20.1.  The Property CurrentQueueDepth

   This is an unsigned 32-bit integer, which functions as a (read-only)
   gauge representing the current depth of this one queue.  This value
   may be important in diagnosing unexpected behavior by a
   DropThresholdCalculationService.

4.3.20.2.  The Property DepthUnits

   This is an unsigned 16-bit integer enumeration that identifies the
   units for the CurrentQueueDepth property.  Defined enumeration values
   are:

      o    bytes(1)
      o    packets(2)

   Note: if the value of DepthUnits is not one of these two values, it
   SHOULD be interpreted as if it had the value '1' (bytes).  The

4.3.21.  The Class PacketSchedulingService

   This is a concrete class that represents a scheduling service, which
   is a process that determines when a queued packet should be removed
   from a queue and sent to an output interface.  Note that output
   interfaces can be physical network interfaces or interfaces to
   components internal to systems, such as crossbars or back planes.  In
   either case, if multiple queues are involved, schedulers are used to
   provide access to the interface.

   Each instance of a PacketSchedulingService describes a scheduler from
   the perspective of the queues that it is servicing.  Please see
   [DSMODEL] for more information about a scheduler.

   PacketSchedulingService is modeled as a ConditioningService so that
   it can be aggregated into a QoSService (using the
   QoSConditioningSubService association) to indicate that its
   functionality underlies that QoS service.  It participates in the

   NextService association to identify the subsequent
   ConditioningService object, if any, that acts on traffic after it has
   been processed by the scheduler.

   The class definition is as follows:

      NAME                PacketSchedulingService
      DESCRIPTION         A concrete class used to determine when
                          a packet should be removed from a
                          queue and sent to an output interface.
      DERIVED FROM        ConditioningService
      TYPE                Concrete
      PROPERTIES          SchedulerType, OtherSchedulerType

4.3.21.1.  The Property SchedulerType

   This property is an enumerated 16-bit unsigned integer, and defines
   the type of scheduler.  Values are:

      1 - Other
      2 - FIFO
      3 - Priority
      4 - Allocation
      5 - Bounded Priority
      6 - Weighted Round Robin Packet

   Note: if the value of SchedulerType is not one of these six values,
   it SHOULD be interpreted as if it had the value '2' (FIFO).

4.3.21.2.  The Property OtherSchedulerType

   This string property is used in conjunction with the SchedulerType
   property.  When the value of SchedulerType is 1 (i.e., Other), then
   the type of scheduler is specified in this property.

4.3.22.  The Class NonWorkConservingSchedulingService

   This class does not add any properties beyond those it inherits from
   its superclass, PacketSchedulingService.  It does, however,
   participate in one additional association, FailNextScheduler.

   The class definition is as follows:

      NAME                NonWorkConservingSchedulingService
      DESCRIPTION         A concrete class representing a
                          scheduler that is capable of operating
                          in a non-work conserving manner.
      DERIVED FROM        PacketSchedulingService
      TYPE                Concrete
      PROPERTIES          (none)

4.3.23.  The Class QoSService

   This is a concrete class that represents the ability to conceptualize
   a QoS service as a set of coordinated sub-services. This enables the
   network administrator to map business rules to the network, and the
   network designer to engineer the network such that it can provide
   different functions for different traffic streams.

   This class has two main purposes.  First, it serves as a common base
   class for defining the various sub-services needed to build higher-
   level QoS services.  Second, it serves as a way to consolidate the
   relationships between different types of QoS services and different
   types of ConditioningServices.

   For example, Gold Service may be defined as a QoSService which
   aggregates two QoS services together.  Each of these QoS services
   could be represented by an instance of the class DiffServService, one
   for servicing of very high demand packets (represented by an instance
   of DiffServService itself), and one for the service given to most of
   the packets, represented by an instance of AFService, which is a
   subclass of DiffServService.  The high demand DiffServService
   instance will then use the QoSConditioningSubService aggregation to
   aggregate together the necessary classifiers to indicate which
   traffic it applies to, and the appropriate meters for contract
   limits, the marker to mark the EF PHB in the packets, and the
   queuing-related conditioning services.  The AFService instance will
   also use the QoSConditioningSubService aggregation, to aggregate its
   classifiers and meters, the several markers used to mark the
   different AF PHBs in the packets, and the queuing-related
   conditioning services needed to deliver the packet treatment.

   QoSService is modeled as a type of Service, which is used as the
   anchor point for defining a set of sub-services that implement the
   desired conditioning characteristics for different types of flows.
   It will direct the specific type of conditioning services to be used
   in order to implement this service.

   The class definition is as follows:

      NAME                QoSService
      DESCRIPTION         A concrete class used to represent a QoS
                          service or set of services, as defined
                          by a network administrator.
      DERIVED FROM        Service
      TYPE                Concrete
      PROPERTIES          (none)

4.3.24.  The Class DiffServService

   This is a concrete class representing the use of standard or custom
   DiffServ services to implement a (higher-level) QoS service.  Note
   that a DiffServService object may be just one of a set of coordinated
   QoSSubServices objects that together implement a higher-level QoS
   service.

   DiffServService is modeled as a subclass of QoSService.  This enables
   it to be related to a higher-level QoS service via QoSSubService, as
   well as to specific ConditioningService objects (e.g., metering,
   dropping, queuing, and others) via QoSConditioningSubService.

   The class definition is as follows:

      NAME                DiffServService
      DESCRIPTION         A concrete class used to represent a
                          DiffServ service associated with a
                          particular Per Hop Behavior.
      DERIVED FROM        QoSService
      TYPE                Concrete
      PROPERTIES          PHBID

4.3.24.1.  The Property PHBID

   This property is a 16-bit unsigned integer, which identifies a
   particular per hop behavior, or family of per hop behaviors.  The
   value here is a Per Hop Behavior Identification Code, as defined in
   [R3140].  Note that as defined, these identification codes use the
   default, recommended, code points for PHBs as part of their
   structure.  These values may well be different from the actual value
   used in the marker, as the marked value is a domain-dependent value.
   The ability to indicate the PHB Identification Code associated with a
   service is helpful for tying the QoS Service to reference documents,
   and for inter-domain coordination and operation.

4.3.25.  The Class AFService

   This is a concrete class that represents a specialization of the
   general concept of forwarding network traffic, by adding specific
   semantics that characterize the operation of the Assured Forwarding
   (AF) Service ([R2597]).

   [R2597] defines four different AF classes, to represent four
   different treatments of traffic.  A different amount of forwarding
   resources, such as buffer space and bandwidth, are allocated to each
   AF class.  Within each AF class, IP packets are marked with one of
   three possible drop precedence values.  The drop precedence of a
   packet determines the relative importance of that packet compared to
   other packets within the same AF class, if congestion occurs.  A
   congested interface will try to avoid dropping packets marked with a
   lower drop precedence value, by instead discarding packets marked
   with a higher drop precedence value.

   Note that [R2597] defines 12 DSCPs that together represent the AF Per
   Hop Behavior (PHB) group.  Implementations are free to extend this
   (e.g., add more classes and/or drop precedences).

   The AFService class is modeled as a specialization of
   DiffServService, which is in turn a specialization of QoSService.
   This enables it to be related to higher-level QoS services, as well
   as to lower-level conditioning sub-services (e.g., classification,
   metering, dropping, queuing, and others).

   The class definition is as follows:

      NAME                AFService
      DESCRIPTION         A concrete class for describing the
                          common characteristics of differentiated
                          services that are used to affect
                          traffic forwarding, using the AF
                          PHB Group.
      DERIVED FROM        DiffServService
      TYPE                Concrete
      PROPERTIES          ClassNumber, DropperNumber

4.3.25.1.  The Property ClassNumber

   This property is an 8-bit unsigned integer that indicates the number
   of AF classes that this AF implementation uses.  Among the instances
   aggregated using the QoSConditioningSubService aggregation with an
   instance of AFService, one SHOULD find markers with as many distinct
   values as the ClassNumber of the AFService instance.

4.3.25.2.  The Property DropperNumber

   This property is an 8-bit unsigned integer that indicates the number
   of drop precedence values that this AF implementation uses.  The
   number of drop precedence values is the number PER AF CLASS.  The
   corresponding droppers will be found in the collection of
   conditioning services aggregated with the QoSConditioningSubService
   aggregation.

4.3.26.  The Class FlowService

   This class represents a service that supports a particular microflow.
   The microflow is identified by the string-valued property FlowID.  In
   some implementations, an instance of this class corresponds to an
   entry in the implementation's flow table.

   The class definition is as follows:

      NAME                FlowService
      DESCRIPTION         A concrete class representing a
                          microflow.
      DERIVED FROM        QoSService
      TYPE                Concrete
      PROPERTIES          FlowID

4.3.26.1.  The Property FlowID

   This property is a string containing an identifier for a microflow.

4.3.27.  The Class DropThresholdCalculationService

   This class represents a logical entity that calculates an average
   queue depth for a queue, based on a smoothing weight and a sampling
   time interval.  It does this calculation on behalf of a RED dropper,
   to allow the dropper to make its decisions whether to drop packets
   based on a smoothed average queue depth for the queue.

   The class definition is as follows:

      NAME                DropThresholdCalculationService
      DESCRIPTION         A concrete class representing a logical
                          entity that calculates an average queue
                          depth for a queue, based on a smoothing
                          weight and a sampling time interval.
                          The latter are properties of this
                          Service, describing how it operates and
                          its necessary parameters.
      DERIVED FROM        Service
      TYPE                Concrete
      PROPERTIES          SmoothingWeight, TimeInterval

4.3.27.1.  The Property SmoothingWeight

   This property is a 32-bit unsigned integer, ranging between 0 and
   100,000 - specified in thousandths.  It defines the weighting of past
   history in affecting the calculation of the current average queue
   depth.  The current queue depth calculation uses the inverse of this
   value as its factor, and one minus that inverse as the factor for the
   historical average.  The calculation takes the form:

      average = (old_average*(1-inverse of SmoothingWeight))
           + (current_queue_depth*inverse of SmoothingWeight)

   Implementations may choose to limit the acceptable set of values to a
   specified set, such as powers of 2.

   Min and max values are 0 and 100000.

4.3.27.2.  The Property TimeInterval

   This property is a 32-bit unsigned integer, defining the number of
   nanoseconds between each calculation of average/smoothed queue depth.
   If this property is not specified, the CalculationService may
   determine an appropriate interval.

4.3.28.  The Abstract Class FilterEntryBase

   FilterEntryBase is the abstract base class from which all filter
   entry classes are derived.  It serves as the endpoint for the
   EntriesInFilterList aggregation, which groups filter entries into
   filter lists.  Its properties include CIM naming properties and an
   IsNegated boolean property (to easily "NOT" the match information
   specified in an instance of one of its subclasses).

   Because FilterEntryBase has general applicability, it is defined in
   [PCIME].  See [PCIME] for the definition of this class.

4.3.29.  The Class IPHeaderFilter

   This concrete class makes it possible to represent an entire IP
   header filter in a single object.  A property IpVersion identifies
   whether the IP addresses in an instance are IPv4 or IPv6 addresses.
   (Since the source and destination IP addresses come from the same
   packet header, they will always be of the same type.)

   See [PCIME] for the definition of this class.

4.3.30.  The Class 8021Filter

   This concrete class allows 802.1.source and destination MAC
   addresses, as well as the 802.1 protocol ID, priority, and VLAN
   identifier fields, to be expressed in a single object

   See [PCIME] for the definition of this class.

4.3.31.  The Class PreambleFilter

   This is a concrete class that models classifying packets using
   traffic-conditioning results stored in a packet preamble by a
   PreambleMarkerService.  See Section 3.8.3 for a discussion of how,
   and why, QDDIM models the capability to store these results in a
   packet preamble.  An instance of PreambleFilter is used to select
   packets based on a two-part string identifying a specific result.
   The logic for this match is "at least one".  That is, a packet with
   multiple results in its preamble matches a filter if at least one of
   these results matches the filter.

   The class definition is as follows:

      NAME                PreambleFilter
      DESCRIPTION         A concrete class representing criteria
                          for selecting packets based on prior
                          traffic-conditioning results stored in
                          a packet preamble.
      DERIVED FROM        FilterEntryBase
      TYPE                Concrete
      PROPERTIES          FilterItemList[ ]

4.3.31.1.  The Multi-valued Property FilterItemList

   This property is an ordered list of strings, where each string has
   the format "<type>,<value>".  See Section 3.8.3 for a list of
   <type>'s defined in QDDIM, and the nature of the associated <value>
   for each of these types.

   Note that there are two parallel terminologies for characterizing
   meter results.  The enumeration value "conforming(1)" is sometimes
   described as "in profile," and the value "nonConforming(3)" is
   sometimes described as "out of profile".

4.3.32.  The Class FilterList

   This is a concrete class that aggregates instances of (subclasses of)
   FilterEntryBase via the aggregation EntriesInFilterList.  It is
   possible to aggregate different types of filters into a single
   FilterList - for example, packet header filters (represented by the
   IPHeaderFilter class) and security filters (represented by subclasses
   of FilterEntryBase defined by IPsec).

   The aggregation property EntriesInFilterList.EntrySequence is always
   set to 0, to indicate that the aggregated filter entries are ANDed
   together to form a selector for a class of traffic.

   See [PCIME] for the definition of this class.

4.3.33.  The Abstract Class ServiceAccessPoint

   This is an abstract class defined in the Core Model of CIM.  It is a
   subclass of the LogicalElement class, and is the base class for all
   objects that manage access to CIM_Services.  It represents the
   management of utilizing or invoking a Service. Please refer to [CIM]
   for the full definition of this class.

4.3.34.  The Class ProtocolEndpoint

   This is a concrete class derived from ServiceAccessPoint, which
   describes a communication point from which the services of the
   network or the system's protocol stack may be accessed.  Please refer
   to [CIM] for the full definition of this class.

4.3.35.  The Abstract Class Collection

   This is an abstract class defined in the Core Model of CIM.  It is
   the superclass for all classes that represent groupings or bags, and
   that carry no status or "state".  (The latter would be more correctly
   modeled as ManagedSystemElements.)  Please refer to [CIM] for the
   full definition of this class.

4.3.36.  The Abstract Class CollectionOfMSEs

   This is an abstract class defined in the Core Model of CIM.  It is a
   subclass of the Collection superclass, restricting the contents of
   the Collection to ManagedSystemElements.  Please refer to [CIM] for
   the full definition of this class.

4.3.37.  The Class BufferPool

   This is a concrete class that represents the collection of buffers
   used by a QueuingService.  (The association QueueAllocation
   represents this usage.)  The existence and management of individual
   buffers may be modeled in a future document.  At the current level of
   abstraction, modeling the existence of the BufferPool is necessary.
   Long term, it is not sufficient.

   In implementations where there are multiple buffer sizes, an instance
   of BufferPool should be defined for each set of buffers with
   identical or similar sizes.  These instances of buffer pools can then
   be grouped together using the CollectedBuffersPool aggregation.

   Note that this class is derived from CollectionOfMSEs, and not from
   Forwarding or ConditioningService.  A BufferPool is only a collection
   of storage, and is NOT a Service.

   The class definition is as follows:

      NAME                BufferPool
      DESCRIPTION         A concrete class representing
                          a collection of buffers.
      DERIVED FROM        CollectionOfMSEs
      TYPE                Concrete
      PROPERTIES          Name, BufferSize, TotalBuffers,
                          AvailableBuffers, SharedBuffers

4.3.37.1.  The Property Name

   This property is a string with a maximum length of 256 characters.
   It is the common name or label by which the object is known.

4.3.37.2.  The Property BufferSize

   This property is a 32-bit unsigned integer, identifying the
   approximate number of bytes in each buffer in the buffer pool. An
   implementation will typically group buffers of roughly the same size
   together, to reduce the number of buffer pools it needs to manage.
   This model does not specify the degree to which buffers in the same
   buffer pool may differ in size.

4.3.37.3.  The Property TotalBuffers

   This property is a 32-bit unsigned integer, reporting the total
   number of individual buffers in the pool.

4.3.37.4.  The Property AvailableBuffers

   This property is a 32-bit unsigned integer, reporting the number of
   buffers in the Pool that are currently not allocated to any instance
   of a QueuingService.  Buffers allocated to a QueuingService could
   either be in use (that is, currently contain packet data), or be
   allocated to a queue pending the arrival of new packet data.

4.3.37.5.  The Property SharedBuffers

   This property is a 32-bit unsigned integer, reporting the number of
   buffers in the Pool that have been simultaneously allocated to
   multiple instances of QueuingService.

4.3.38.  The Abstract Class SchedulingElement

   This is an abstract class that represents the configuration
   information that a PacketSchedulingService has for one of the
   elements that it is scheduling.  The scheduled element is either a
   QueuingService or another PacketSchedulingService.

   Among the subclasses of this class, some are defined in such a way
   that all of their instances are work conserving.  Other subclasses,
   however, may have instances that either are or are not work
   conserving.  In this class, the boolean property WorkConserving
   indicates whether an instance is or is not work conserving.  The
   range of values for WorkConserving is restricted to TRUE in the
   subclasses that are inherently work conserving, since instances of
   these classes cannot be anything other than work conserving.

   The class definition is as follows:

      NAME                SchedulingElement
      DESCRIPTION         An abstract class representing the
                          configuration information that a
                          PacketSchedulingService has for one of
                          the elements that it is scheduling.
      DERIVED FROM        ManagedElement
      TYPE                Abstract
      PROPERTIES          WorkConserving

4.3.38.1.  The Property WorkConserving

   This boolean property indicates whether the PacketSchedulingService
   tied to this instance by the ElementInSchedulingService aggregation
   is treating the input tied to this instance by the QueueToSchedule or
   SchedulingServiceToSchedule association in a work-conserving manner.
   Note that this property is writable, indicating that an administrator
   can change the behavior of the SchedulingElement - but only for those
   elements that can operate in a non-workconserving mode.

4.3.39.  The Class AllocationSchedulingElement

   This class is a subclass of the abstract class SchedulingElement. It
   introduces five new properties to support bandwidth-based scheduling.
   As is the case with all subclasses of SchedulingElement, the input
   associated with an instance of AllocationSchedulingElement is of one
   of two types: either a queue, or another scheduler.

   The class definition is as follows:

      NAME                AllocationSchedulingElement
      DESCRIPTION         A concrete class containing parameters
                          for controlling bandwidth-based
                          scheduling.

      DERIVED FROM        SchedulingElement
      TYPE                Concrete
      PROPERTIES          AllocationUnits, BandwidthAllocation,
                          BurstAllocation, CanShare,
                          WorkFlexible

4.3.39.1.  The Property AllocationUnits

   This property is a 16-bit unsigned integer enumeration that
   identifies the units in which the BandwidthAllocation and
   BurstAllocation properties are expressed.  The following values are
   defined:

      o bytes(1)
      o packets(2)
      o cells(3)       -- fixed-size, for example, ATM

   Note: if the value of AllocationUnits is not one of these three
   values, it SHOULD be interpreted as if it had the value '1' (bytes).

4.3.39.2.  The Property BandwidthAllocation

   This property is a 32-bit unsigned integer that defines the number of
   units/second that should be allocated to the associated input.  The
   units are identified by the AllocationUnits property.

4.3.39.3.  The Property BurstAllocation

   This property is a 32-bit unsigned integer that specifies the amount
   of temporary or short-term bandwidth (in units per second) that can
   be allocated to an input, beyond the amount of bandwidth allocated
   through the BandwidthAllocation property.  If the maximum actual
   bandwidth allocation for the input were to be measured, it would be
   the sum of the BurstAllocation and the BandwidthAllocation
   properties.  The units are identified by the AllocationUnits
   property.

4.3.39.4.  The Property CanShare

   This is a boolean property that, if TRUE, enables unused bandwidth
   from the associated input to be allocated to other inputs serviced by
   the Scheduler.

4.3.39.5.  The Property WorkFlexible

   This is a boolean property that, if TRUE, indicates that the behavior
   of the scheduler relative to this input can be altered by changing
   the value of the inherited property WorkConserving.

4.3.40.  The Class WRRSchedulingElement

   This class is a subclass of the abstract class SchedulingElement,
   representing a weighted round robin (WRR) scheduling discipline. It
   introduces a new property WeightingFactor, to give some inputs a

   higher probability of being serviced than other inputs.  It also
   introduces a property Priority, to serve as a tiebreaker to be used
   when inputs have equal weighting factors.  As is the case with all
   subclasses of SchedulingElement, the input associated with an
   instance of WRRSchedulingElement is of one of two types: either a
   queue, or another scheduler.

   Because scheduling of this type is always work conserving, the
   inherited boolean property WorkConserving is restricted to the value
   TRUE in this class.

   The class definition is as follows:

      NAME              WRRSchedulingElement
      DESCRIPTION       This class specializes the
                        SchedulingElement class to add
                        a per-input weight.  This is used
                        by a weighted round robin packet
                        scheduler when it handles its
                        associated inputs.  It also adds a
                        second property to serve as a tie-breaker
                        in the case where multiple inputs have
                        been assigned the same weight.
      DERIVED FROM      SchedulingElement
      TYPE              Concrete
      PROPERTIES        WeightingFactor, Priority

4.3.40.1.  The Property WeightingFactor

   This property is a 32-bit unsigned integer, which defines the
   weighting factor that offers some inputs a higher probability of
   being serviced than other inputs.  This property represents this
   probability.  Its minimum value is 0, its maximum value is 100000,
   and its units are in thousandths.

4.3.40.2.  The Property Priority

   This property is a 16-bit unsigned integer, which serves as a
   tiebreaker, in the event that two or more inputs have equal weights.
   A larger value represents a higher priority.  If this property is
   specified for any of the WRRSchedulingElements associated with a
   PacketSchedulingService, then it must be specified for all
   WRRSchedulingElements for that PacketSchedulingService, and the
   property values for these WRRSchedulingElements must all be
   different.

   While this condition may not occur in some implementations of a
   weighted round-robin scheduler, many implementations require a
   priority to resolve an equal-weight condition.  In instances where
   this behavior is not necessary or is undesirable, this property may
   be left unspecified.

4.3.41.  The Class PrioritySchedulingElement

   This class is a subclass of the abstract class SchedulingElement. It
   indicates that a scheduler is taking packets from a set of inputs
   using the priority scheduling discipline.  As is the case with all
   subclasses of SchedulingElement, the input associated with an
   instance of PrioritySchedulingElement is of one of two types: either
   a queue, or another scheduler.  The property Priority in
   PrioritySchedulingElement represents the priority for an input,
   relative to the priorities of all the other inputs to which the
   scheduler that aggregates this PrioritySchedulingElement is
   associated.  Inputs to which the scheduler is related via other
   scheduling disciplines do not figure in this prioritization.

   Because scheduling of this type is always work conserving, the
   inherited boolean property WorkConserving is restricted to the value
   TRUE in this class.

   The class definition is as follows:

      NAME             PrioritySchedulingElement
      DESCRIPTION      A concrete class that specializes the
                       SchedulingElement class to add a
                       Priority property.  This property is
                       used by a SchedulingService that is doing
                       priority scheduling for a set of  inputs.

      DERIVED FROM     SchedulingElement
      TYPE             Concrete
      PROPERTIES       Priority

4.3.41.1.  The Property Priority

   This property is a 16-bit unsigned integer that indicates the
   priority level of a scheduler input relative to the other inputs
   serviced by this PacketSchedulingService.  A larger value represents
   a higher priority.

4.3.42.  The Class BoundedPrioritySchedulingElement

   This class is a subclass of the class PrioritySchedulingElement,
   which is itself derived from the abstract class SchedulingElement.
   As is the case with all subclasses of SchedulingElement, the input
   associated with an instance of BoundedPrioritySchedulingElement is of
   one of two types: either a queue, or another scheduler.
   BoundedPrioritySchedulingElement adds an upper bound (in kilobits per
   second) on how much traffic can be handled from an input.  This data
   is specific to that one input.  It is needed when bounded strict
   priority scheduling is performed.

   This class inherits from its superclass PrioritySchedulingElement the
   restriction of the inherited boolean property WorkConserving to the
   value TRUE.

   The class definition is as follows:

      NAME              BoundedPrioritySchedulingElement
      DESCRIPTION       This concrete class specializes the
                        PrioritySchedulingElement class to add
                        a BandwidthBound property.  This property
                        bounds the rate at which traffic from the
                        associated input can be handled.

      DERIVED FROM      PrioritySchedulingElement
      TYPE              Concrete
      PROPERTIES        BandwidthBound

4.3.42.1.  The Property BandwidthBound

   This property is a 32-bit unsigned integer that defines the upper
   limit on the amount of traffic that can be handled from the input.
   This is not a shaped upper bound, since bursts can occur. It is a
   strict bound, limiting the impact of the input.  The units are
   kilobits per second.