// ===================================================================
// Title:       Network Quality of Service 2.7.0
// Filename:    Network27_QoS.mof
// Version:     2.7.0
// Status:      Final
// Date:        April 18, 2003
// ===================================================================
// Copyright 1998-2003 Distributed Management Task Force, Inc. (DMTF).
// All rights reserved.  
// DMTF is a not-for-profit association of industry members dedicated 
// to promoting enterprise and systems management and interoperability. 
// DMTF specifications and documents may be reproduced for uses
// consistent with this purpose by members and non-members, 
// provided that correct attribution is given. 
// As DMTF specifications may be revised from time to time, 
// the particular version and release date should always be noted.
//
// Implementation of certain elements of this standard or proposed 
// standard may be subject to third party patent rights, including 
// provisional patent rights (herein "patent rights"). DMTF makes 
// no representations to users of the standard as to the existence 
// of such rights, and is not responsible to recognize, disclose, or
// identify any or all such third party patent right, owners or 
// claimants, nor for any incomplete or inaccurate identification or 
// disclosure of such rights, owners or claimants. DMTF shall have no 
// liability to any party, in any manner or circumstance, under any 
// legal theory whatsoever, for failure to recognize, disclose, or 
// identify any such third party patent rights, or for such party's
// reliance on the standard or incorporation thereof in its product, 
// protocols or testing procedures. DMTF shall have no liability to 
// any party implementing such standard, whether such implementation 
// is foreseeable or not, nor to any patent owner or claimant, and shall 
// have no liability or responsibility for costs or losses incurred if 
// a standard is withdrawn or modified after publication, and shall be
// indemnified and held harmless by any party implementing the 
// standard from any and all claims of infringement by a patent owner 
// for such implementations.
//
// For information about patents held by third-parties which have 
// notified the DMTF that, in their opinion, such patent may relate to 
// or impact implementations of DMTF standards, visit 
// http://www.dmtf.org/about/policies/disclosures.php.
// ===================================================================
// Description: The Network Model extends the management concepts to
//              represent protocol interfaces and network/protocol 
//              services.  This file defines classes to manage   
//              DiffServ/IntServ quality of service.  
//
//              The object classes below are listed in an order that
//              avoids forward references. Required objects, defined 
//              by other working groups, are omitted.
// ==================================================================
// Change Log for v2.7
// CR662 - Modify Description of QoSService to indicate that 
//         NetworkService has been deprecated 
// CR794 - Updates to PacketSchedulingService:
//       - Update description
//       - Change subclassing from ForwardingService to 
//         ConditioningService
//       (ERRATA) - Change the enumeration for SchedulerType
//       - Update description for OtherSchedulerType
//       - Add NextScheduler Association
//       - Add NonWorkConservingSchedulingService and FailNextScheduler  
//       (ERRATA) - Remove PrioritySchedulingService, 
//         PriorityBandwidthSchedulingService, 
//         BandwidthSchedulingService, 
//         RoundRobinPacketSchedulingService and 
//         WeightedRoundRobinPacketSchedulingService
//       - Deprecate SchedulerUsed
// CR795 - Updates to DropperService:
//       - Update description
//       (ERRATA) - Change the enumeration for DropperType
//       - Deprecate AlwaysDrop property
//       - Add DropFrom property
//       - Changes to REDDropperService to update description, update 
//         description of MinQueueThreshold and MaxQueueThreshold 
//         properties, and add ThresholdUnits property
//       (ERRATA) - In REDDropperService, change the datatype of the 
//         StartProbability and StopProbability properties
//       - Add HeadTrailDropper
//       - Deprecate WeightedREDDropperService
// CR795 (Continued) - Updates to QueuingService:
//       - Update description 
//       - Add CurrentQueueDepth and DepthUnits properties
//       (ERRATA) - Remove the SmoothingWeight, TimeInterval, and 
//         GiveExcessCapacity properties
//       - Add DropThresholdCalculationService     
//       - Add QueueAllocation.AllocationPercentage     
//       - Deprecate QueueHierarchy     
//       - Add CalculationServiceForDropper, CalculationBasedOnQueue
//         and HeadTailDropQueueBinding     
// CR796 - Updates to MarkerService:
//       - Update description
//       - Remove the CanRemark, RemarkType, OtherRemarkType, 
//         and RemarkValue properties
//       - Add PreambleMarkerService, ToSMarkerService, 
//         DSCPMarkerService and 8021QMarkerService
// CR797 - Update description for MeterService and expand the 
//         abbreviations for MeterType
//       - Update description for AverageRateMeterService
//       (ERRATA) - Change the datatype for AverageRateMeterService.
//         AverageRate from real32 to uint32 and change the 
//         units for AverageRateMeterService.DeltaInterval 
//       - Update the description for EWMAMeterService
//       (ERRATA) - Change the datatype for EWMAMeterService 
//         .AverageRate and.Gain from real32 to uint32
//       (ERRATA) - Change the Units of EWMAMeterService.DeltaIntervals 
//       - Update the description for TokenBucketMeterService
//       - Change the datatype for TokenBucketMeterService
//         .AverageRate, .PeakRate, .BurstSize, and
//         .ExcessBurstSize from real32 to uint32
//       (ERRATA) - Fix subclassing of NextServiceAfterMeter, fix
//         misspelled property name, and update the enum values for 
//         MeterResult
// CR798 - Updates to ClassifierService:
//       - Update description
//       - Remove ClassifierType, OtherClassifierType, and 
//         HaveClassifiedPacket properties
//       - Add ClassifierElement, ClassifierElementInClassifierService,
//         ClassifierElementUsesFilterList, and 
//         NextServiceAfterClassifierElement
//       - Deprecate ClassifierFilterSet       
// CR799 - Updates to QoSService:       
//       - Update the description
//       (ERRATA) - Change the subclassing 
//       - Add Composition qualifier to QoSSubService     
//       - Update description for QoSConditioningSubService and 
//         remove the Max (1) from the "Group" ref
//       - Update the description for DiffServService
//       - Deprecate DiffServService.DSCP
//       - Add DiffServService.PHBID  
//       - Update the description for AFService and its ClassNumber
//         and DropperNumber properties
//       - Add FlowService     
//       - Deprecate PrecedenceService, 8021PService and EFService    
// CR800 - Updates to ConditioningService:
//       - Update the class description
//       - Deprecate the Enabled property
//       (ERRATA) - Change the subclassing
//       - Deprecate ConditioningServiceOnEndpoint
//       - Add IngressConditioningServiceOnEndpoint and        
//         EgressConditioningServiceOnEndpoint        
// CR800 (Continued) - Updates for NextService:
//       - Update the class description
//       (ERRATA) - Remove the TrafficClass property
//       - Fix spelling of reference (Preceeding, should be Preceding)
// CR849 - Define InstanceID as the Key of SchedulingElement
// CR914 - Change inheritance of the deprecated association,
//         ConditioningServiceOnEndpoint (from ForwardsAmong to its
//         superclass, Dependency). Remove the ValueMap qualifier
//         from the properties, WRRSchedulingElement.WorkConserving,
//         PrioritySchedulingElement.WorkConserving, and
//         BoundedPrioritySchedulingElement.WorkConserving
// CR920 - Remove the Key qualifier from NextScheduler.FollowingService
//         since its superclass defines the key; Add missing parenthesis
//         to the Description of AFService
// CR961 - Update the reference to EnabledLogicalElement.EnabledState
// CR982 - Removal of Experimental for preliminary to final
// CR983 - v2.7 Deprecations promoted to final
// CR994 - Update the InstanceID property Description
// ===================================================================
 
#pragma Locale ("en_US")


// ===================================================================
// QoSService
// ===================================================================
   [Version ("2.7.0"), Description (
      "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. \n"
      "\n"
      "This class has two main purposes. First, it serves as a "
      "common base class for defining various sub-services that "
      "are needed to build higher-level QoS services. Second, it "
      "serves as a way to consolidate relationships between "
      "different types of QoS services and different types of "
      "ConditioningServices. \n"
      "\n"
      "For example, Gold Service may be defined as a QoSService "
      "which aggregates two other QoSServices together. Each of "
      "these 'other' QoSServices could be DiffServServices - one "
      "representing the servicing of very high demand packets "
      "(instantiated as a DiffServService directly), and one "
      "representing the service given to most of the packets "
      "(instantiated as an AFService).  The high demand "
      "DiffServService instance would use QoSConditioning"
      "SubService to aggregate together the necessary classifiers "
      "to indicate which traffic it applies to, the appropriate "
      "meters for contract limits, the marker to mark the EF PHB "
      "in the packets, and the queuing-related services. The "
      "AFService instance would similarly use QoSConditioning"
      "SubService to aggregate its classifiers, meters, the several "
      "markers used to mark the different AF PHBs in the packets, "
      "and the queuing-related services needed to deliver the packet "
      "treatment.") ]
class CIM_QoSService : CIM_Service {
};


// ==================================================================
// QoSSubService
// ==================================================================
   [Association, Aggregation, Composition, Version ("2.7.0"), 
    Description (
      "The associations - QoSSubService and QoSConditioningSub"
      "Service - operate in conjunction. High level QoS "
      "definitions, such as 'John gets Gold Service', map to "
      "lower level, more concrete QoSServices (the subclasses "
      "of QoSService). This is described by the QoSSubService "
      "association. In turn, each of the SubServices may require "
      "their own conditioning. This is modeled using the "
      "QoSConditioningSubService aggregation. \n"
      "\n"
      "Note that a more concrete QoSService may only be "
      "aggregated into one higher level Service, using this "
      "association. The cardinality on the GroupComponent "
      "reference is Max (1).") ]
class CIM_QoSSubService : CIM_ServiceComponent  {

        [Override ("GroupComponent"), Aggregate, Max (1), 
         Description (
         "The higher level QoSService that is constructed by "
         "aggregating one or more lower-level QoSServices.") ]
    CIM_QoSService REF GroupComponent;

        [Override ("PartComponent"), Description (
         "The more concrete QoSService that is used to provide "
         "the higher level Service.") ]
    CIM_QoSService REF PartComponent; 
};


// ===================================================================
// PrecedenceService
// ===================================================================
   [Version ("2.7.0"), Deprecated {"CIM_QoSService"}, 
    Description (
      "This class represents a specialization of the general "
      "concept of forwarding network traffic by adding specific "
      "semantics that define how traffic is forwarded based on "
      "the value of the ToS byte of a packet. \n"
      "\n"
      "This class is used to enable DiffServ devices and non-"
      "DiffServ devices to exchange traffic. This is done by "
      "defining a sibling class, DiffServService, to represent "
      "devices that forward traffic based on the DiffServ code "
      "point. This enables the administrator to define mappings "
      "between devices that do not support DiffServ (and instead "
      "use IP Precedence) and those that do support DiffServ. \n"
      "\n"
      "PrecedenceService is deprecated since forwarding based on the "
      "value of the ToS byte is specified using a FilterList, which "
      "is associated with a ClassifierElement. If there is a need to "
      "distinguish a higher-level set of coordinated QoS services, "
      "the QoSService class can be instantiated directly.") ]
class CIM_PrecedenceService : CIM_QoSService {

        [Deprecated {"CIM_IPHeadersFilter.HdrDSCP"}, 
         Description (
         "This property is an 8-bit unsigned integer that defines the "
         "notion of precedence for different types of traffic.") ]
    uint8 PrecedenceValue;
};


// ===================================================================
// DiffServService
// ===================================================================
   [Version ("2.7.0"), Description (
      "DiffServService represents the use of standard or custom "
      "DiffServ services (associated with particular Per Hop "
      "Behaviors, PHBs) to implement a (higher-level) QoSService. "
      "Note that the DiffServService may be just one of a set "
      "of coordinated QoSSubServices that together implement a "
      "higher-level QoSService. The relationship between the "
      "QoSServices is described using the association, "
      "QoSSubService.") ]
class CIM_DiffServService : CIM_QoSService {

        [Deprecated {"CIM_DiffServService.PHBID"}, 
         Description (
         "This property is an unsigned 8-bit integer, and defines the "
         "Differentiated Services Code Point (DSCP) that this link "
         "uses to represent various types of differentiated "
         "services through device-specific configuration commands. It"
         "is deprecated since this information is conveyed via "
         "filter lists, associated with ClassifierElements. The "
         "DiffServService is better represented as a Per Hop "
         "Behavior.") ]
    uint8 DSCP;

        [Description (
         "A 16-bit unsigned integer which identifies a particular "
         "per hop behavior, or family of per hop behaviors. The "
         "value 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 "
         "domain-dependent. The ability to indicate the PHB "
         "Identification Code associated with a DiffServService is "
         "helpful when tying the QoSService to reference documents, "
         "and for inter-domain coordination and operation.") ]
    uint16 PHBID;
};


// ===================================================================
// 8021PService
// ===================================================================
   [Version ("2.7.0"), Deprecated {"CIM_QoSService"}, 
    Description (
      "This class represents a specialization of the general "
      "concept of forwarding network traffic by adding specific "
      "semantics that define how traffic is forwarded based on "
      "the value of the Priority field in the 802.1P header. \n"
      "\n"
      "This class is used to enable DiffServ domains and domains "
      "that support 802.1P only to exchange traffic. It represents "
      "the mapping between implementations that only support "
      "802.1P priority marking to be mapped to implementations "
      "that support DiffServ, which use DSCPs. \n"
      "\n"
      "8021PService is deprecated since forwarding based on the "
      "value of the Priority field in the 802.1P header is "
      "specified using a FilterList, which is associated with "
      "a ClassifierElement. If there is a need to distinguish "
      "a higher-level set of coordinated QoS services, the "
      "QoSService class can be instantiated directly.") ]
class CIM_8021PService : CIM_QoSService {

        [Deprecated {"CIM_8021Filter.8021HdrPriorityValue"}, 
         Description (
         "This property is an 8-bit unsigned integer that defines "
         "the notion of priority as specified in 802.1P "
         "implementations.") ]
    uint8 PriorityValue;
};


// ===================================================================
// AFService
// ===================================================================
   [Version ("2.7.0"), Description (
      "This class represents a specialization to the general "
      "concept of forwarding network traffic by adding specific "
      "semantics that characterize the operation of the Assured "
      "Forwarding (AF) Service (RFC2597). This RFC defines four "
      "different AF classes to represent four different treatments "
      "of traffic (e.g., a different amount of forwarding "
      "resources, such as buffer space and bandwidth, are "
      "allocated). 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 with a lower "
      "drop precedence value by instead discarding packets with a "
      "higher drop precedence value. \n"
      "\n"
      "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). \n"
      "\n"
      "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 QoSServices, as "
      "well as to lower-level conditioning sub-services (e.g., "
      "classification, metering, dropping, queuing, and others).") ]
class CIM_AFService : CIM_DiffServService {

        [Description (
         "This property is an 8-bit unsigned integer that indicates "
         "the number of AF classes that this AF implementation uses. "
         "Among the instances aggregated into AFService (using "
         "QoSConditioningSubService), one SHOULD find markers with "
         "as many distinct values as is indicated by ClassNumber.") ]
    uint8 ClassNumber;

        [Description (
         "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 are "
         "found in the collection of ConditioningServices aggregated "
         "by QoSConditioningSubService.") ]
    uint8 DropperNumber;
};


// ===================================================================
// FlowService
// ===================================================================
   [Version ("2.7.0"), Description (
      "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.") ]
class CIM_FlowService : CIM_QoSService {

        [Description (
         "This property is a string containing an identifier for a "
         "microflow.") ]
    string FlowID;
};


// ===================================================================
// EFService
// ===================================================================
   [Version ("2.7.0"), Deprecated {"CIM_DiffServService"}, 
    Description (
      "This class represents a specialization of the general "
      "concept of forwarding network traffic by adding specific "
      "semantics that characterize the operation of the "
      "Expedited Forwarding (EF) Service (defined in RFC 2598). \n"
      "\n"
      "The EF PHB can be used to build a low loss, low latency, "
      "low jitter, assured bandwidth, end-to-end service through "
      "DiffServ domains. Such a service appears to the endpoints "
      "like a point-to-point connection or a virtual leased line. "
      "This service has also been described as Premium service in "
      "the IETF literature. \n"
      "\n"
      "RFC 2598 defines one DSCP for the EF service. Thus, there "
      "is no need to define any attributes in this class, since an "
      "instance of the EFService class, by definition, means that "
      "this particular DSCP is used. \n"
      "\n"
      "EFService is deprecated since forwarding based on the "
      "value of the DiffServ Code Point is specified using a "
      "FilterList, which is associated with a ClassifierElement. "
      "If there is a need to distinguish a higher-level set of "
      "coordinated QoS services, the DiffServService class can "
      "be instantiated directly.") ]
class CIM_EFService : CIM_DiffServService {
};


// ==================================================================
// AFRelatedServices
// ==================================================================
   [Association, Version ("2.6.0"), Description (
      "The IETF's RFC2597 describes a Differentiated Services "
      "Per-Hop-Behavior (PHB) Group called Assured Forwarding "
      "(AF). Quoting from the RFC, 'The AF PHB group provides "
      "delivery of IP packets in four independently forwarded "
      "AF classes. Within each AF class, an IP packet can be "
      "assigned one of three different levels of drop "
      "precedence.' The AFRelatedServices association describes "
      "the precedence of the individual AF drop-related "
      "Services within an AF IP packet-forwarding class.") ]
class CIM_AFRelatedServices {

        [Key, Max (1), Description (  
         "The AFService with a lower drop precedence (ie, lower "
         "probability of dropping packets).") ]
    CIM_AFService REF AFLowerDropPrecedence;

        [Key, Description (  
         "An AFService at the same IP packet-forwarding class level, "
         "but at a higher drop precedence.") ]
    CIM_AFService REF AFHigherDropPrecedence;
};


// ===================================================================
// ConditioningService
// ===================================================================
   [Version ("2.7.0"), Description (
      "ConditioningService 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. 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 the "
      "future. \n" 
      "\n"
      "ConditioningService is a concrete class because its "
      "superclass (ForwardingService) is concrete. While " 
      "this class can be instantiated, an instance of it "
      "does not accomplish anything, because the nature of the "
      "conditioning, and the parameters that control it, are "
      "specified only in the subclasses of ConditioningService. \n" 
      "\n"
      "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 QoSService in a particular device. NextService "
      "indicates the subsequent conditioning service(s) for "
      "different traffic streams.") ]
class CIM_ConditioningService : CIM_Service {

        [Deprecated {"CIM_EnabledLogicalElement.EnabledState"}, 
         Description (
         "This property is a boolean that, if TRUE, signifies that "
         "one or more conditioning functions can be performed on "
         "traffic encountered by this ConditioningService. This "
         "allows one or more ConditioningServices to be enabled or "
         "disabled to provide different types of conditioning for "
         "traffic. Enabled is deprecated in lieu of a similar "
         "(but more generally and completely defined) property "
         "which is inherited.") ]
    boolean Enabled;
};


// ==================================================================
// QoSConditioningSubService
// ==================================================================
   [Association, Aggregation, Version ("2.7.0"), 
    Description (
      "A QoSService utilizes underlying ConditioningServices as "
      "part of its overall functionality. This is modeled using "
      "the QoSConditioningSubService association. Note that "
      "a ConditioningService may only be part of a single "
      "QoSService - the cardinality on the QoSService "
      "reference is Max (1).") ] 
class CIM_QoSConditioningSubService : CIM_ServiceComponent {

        [Override ("GroupComponent"), Aggregate, 
         Description (
         "This aggregation identifies the set of ConditioningServices "
         "that together condition traffic for a particular "
         "QoSService.") ]
    CIM_QoSService REF GroupComponent;

        [Override ("PartComponent"), 
         Description ("The ConditioningService.") ]
    CIM_ConditioningService REF PartComponent; 
};


// ==================================================================
// ConditioningServiceOnEndpoint
// ==================================================================
   [Association, Version ("2.7.0"), 
    Deprecated {"CIM_IngressConditioningServiceOnEndpoint",
      "CIM_EgressConditioningServiceOnEndpoint"}, 
    Description (
      "The QoS Model describes the traffic conditioning functions "
      "in place for a network device. In order to 'be "
      "conditioned', a packet is received at a ProtocolEndpoint. "
      "After 'conditioning', a packet is dropped or leaves the "
      "device via a ProtocolEndpoint. This dependency on "
      "ProtocolEndpoints is defined by the ConditioningServiceOn"
      "Endpoint association. A property of the association, "
      "ServiceType, indicates whether the ConditioningService "
      "handles incoming (\"Ingress\") or out-going (\"Egress\") "
      "packets. This association is deprecated since different "
      "cardinalities are needed on the ingress and egress "
      "classes. This cannot be done using a single association.") ]
class CIM_ConditioningServiceOnEndpoint : CIM_Dependency {

        [Deprecated {
            "CIM_IngressConditioningServiceOnEndpoint.Antecedent",
            "CIM_EgressConditioningServiceOnEndpoint.Antecedent "}, 
         Override ("Antecedent"), Max (1), Description (
         "The ProtocolEndpoint through which traffic arrives at or "
         "leaves from a network device.") ]
    CIM_ProtocolEndpoint REF Antecedent;

        [Deprecated {
            "CIM_IngressConditioningServiceOnEndpoint.Dependent",
            "CIM_EgressConditioningServiceOnEndpoint.Dependent"}, 
         Override ("Dependent"), Description (
         "The ConditioningService which begins or ends the traffic "
         "conditioning processing within a network device.") ]
    CIM_ConditioningService REF Dependent;

        [Deprecated {"CIM_IngressConditioningServiceOnEndpoint",
            "CIM_EgressConditioningServiceOnEndpoint"}, 
         Description (
         "Indicates whether a packet is incoming (value = 1, "
         "\"Ingress\") or out-going (value = 2, \"Egress\") at the "
         "ProtocolEndpoint, relative to the ConditioningService."),
         ValueMap {"0", "1", "2"},  
         Values {"Unknown", "Ingress", "Egress"} ]
    uint16 ServiceType; 
};


// ==================================================================
// IngressConditioningServiceOnEndpoint
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This association represents the binding, in the ingress "
      "direction, between a ProtocolEndpoint and the first "
      "ConditioningService that processes packets received via "
      "that Endpoint.  Since there can only be one 'first' "
      "ConditioningService for a ProtocolEndpoint, the cardinality "
      "for the Dependent object reference is narrowed from 0..n "
      "to 0..1. On the other hand, a single ConditioningService "
      "can be the first to process packets received via multiple "
      "ProtocolEndpoints. So, the cardinality of the "
      "Antecedent object reference remains 0..n.") ]
class CIM_IngressConditioningServiceOnEndpoint : 
 CIM_ServiceSAPDependency {

        [Override ("Antecedent"), Description (
         "The ProtocolEndpoint through which traffic arrives at "
         "a network device.") ]
    CIM_ProtocolEndpoint REF Antecedent;

        [Override ("Dependent"), Max (1), Description (
         "The ConditioningService which begins the traffic "
         "conditioning processing within a network device.") ]
    CIM_ConditioningService REF Dependent;
};


// ==================================================================
// EgressConditioningServiceOnEndpoint
// ==================================================================
   [Association,  Version ("2.7.0"), 
    Description (
      "This association represents the binding, in the egress "
      "direction, between a ProtocolEndpoint and the last "
      "ConditioningService that processes packets before they "
      "leave a network device (via that ProtocolEndpoint). This "
      "'last' ConditioningService is ordinarily a scheduler, "
      "but it does not have to be. There can be multiple "
      "'last' ConditioningServices for an Endpoint (for example, "
      "in the case of a fallback scheduler). Therefore, the "
      "cardinality for the Dependent object reference remains "
      "0..n. On the other hand, a single ConditioningService "
      "cannot be the last one to process packets for multiple "
      "Endpoints. So, the cardinality of the Antecedent object "
      "reference is narrowed from 0..n to 0..1.") ]
class CIM_EgressConditioningServiceOnEndpoint : 
 CIM_ServiceSAPDependency {

        [Override ("Antecedent"), Max (1), Description (
         "The ProtocolEndpoint through which traffic leaves "
         "a network device.") ]
    CIM_ProtocolEndpoint REF Antecedent;

        [Override ("Dependent"), Description (
         "The ConditioningService which ends the traffic "
         "conditioning processing within a network device.") ]
    CIM_ConditioningService REF Dependent;
};


// ==================================================================
// NextService
// ==================================================================
   [Association, Version ("2.7.0"), Description (
      "NextService establishes a predecessor-successor "
      "relationship between two ConditioningService objects. This "
      "association is used to indicate the sequence of "
      "ConditioningServices required to process a particular type "
      "of traffic. \n"
      "\n"
      "Instances describe the various relationships between "
      "different ConditioningServices (such as classifiers, meters, "
      "droppers, etc.) that are used collectively to condition "
      "traffic. Both one-to-one and more complicated fan-in and/or "
      "fan-out relationships can be described. The Conditioning"
      "Services may feed one another directly, or they may be "
      "mapped to multiple 'next' Services based on the "
      "characteristics of the packet." ) ] 
class CIM_NextService {

        [Key, Description (
         "The preceding ConditioningService, 'earlier' in the "
         "processing sequence for a packet.") ]
    CIM_ConditioningService REF PrecedingService;

        [Key, Description (
         "The 'next' or following ConditioningService.") ]
    CIM_ConditioningService REF FollowingService;
};


// ===================================================================
// ClassifierService
// ===================================================================
   [Version ("2.7.0"), Description (
      "ClassifierService represents a logical entity associated "
      "with 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. \n"
      "\n"
      "Rather than being linked directly to its filters (instantiated "
      "as FilterLists), a classifier is modeled as an aggregation "
      "of ClassifierElements.  Each of these ClassifierElements is "
      "linked to a single FilterList, by the association "
      "ClassifierElementUsesFilterList. Note that ClassifierServices "
      "are designed to allow hierarchical classification. When "
      "hierarchical classification is used, a ClassifierElement may "
      "point to another ClassifierService (via the association, "
      "NextServiceAfterClassifierElement). When this is true, the "
      "ClassifierElement MUST NOT use the ClassifierElementUses"
      "FilterList association. \n"
      "\n"
      "A classifier is modeled as a ConditioningService so that it "
      "can be aggregated into a QoSService (using the "
      "QoSConditioningSubService aggregation), and can use the "
      "NextService association to identify the subsequent "
      "ConditioningServices for different traffic streams.") ]
class CIM_ClassifierService : CIM_ConditioningService {
};


// ===================================================================
// ClassifierElement
// ===================================================================
   [Version ("2.7.0"), Description (
      "ClassifierElement represents the linkage, within a single "
      "ClassifierService, between a FilterList (that defines the "
      "criteria to select packets from the stream of packets "
      "coming into the Service) 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 an aggregated entity "
      "into ClassifierService (using the ClassifierElementIn"
      "ClassifierService association), and for associations with its "
      "FilterList (ClassifierElementUsesFilterList) and its next "
      "ConditioningService (NextServiceAfterClassifierElement). \n"
      "\n"
      "Note that a ClassifierElement may be associated with a "
      "ClassifierService through the NextServiceAfterClassifier"
      "Element association. This will occur when implementing "
      "hierarchical classification. In this case, the "
      "ClassifierElement MUST NOT instantiate the ClassifierElement"
      "UsesFilterList 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.") ]
class CIM_ClassifierElement : CIM_ClassifierService {
};


// ===================================================================
// ClassifierElementInClassifierService
// ===================================================================
   [Association, Aggregation, Composition,  
    Version ("2.7.0"), Description (
      "This aggregation represents the relationship between "
      "a ClassifierService and the ClassifierElements that provide "
      "its fan-out function. ClassifierElements represent "
      "the traffic selectors for the Service. A ClassifierService "
      "typically aggregates multiple ClassifierElements. An "
      "individual Element, however, is aggregated only by a single "
      "ClassifierService.") ]
class CIM_ClassifierElementInClassifierService : CIM_ServiceComponent {

        [Override ("GroupComponent"), Aggregate, Min (1), Max (1),
         Description (
         "The ClassifierService which aggregates ClassifierElements.") ]
    CIM_ClassifierService REF GroupComponent;

        [Override ("PartComponent"), Description (
         "The aggregated ClassifierElement, defined in the context of one "
         "ClassifierService.") ] 
    CIM_ClassifierElement REF PartComponent;

        [Description (
         "Because the filters for a classifier can overlap, it is "
         "necessary to specify the order in which the ClassifierElements "
         "are aggregated by a ClassifierService. This then dictates the "
         "order in which packets coming into the classifier are presented. "
         "Values are represented in ascending order: first '1', then '2', "
         "and so on. Different values MUST be assigned for each of the "
         "ClassifierElements aggregated by a given ClassifierService.") ]
    uint32 ClassifierOrder;
};


// ===================================================================
// ClassifierElementUsesFilterList
// ===================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This association relates one or more ClassifierElements "
      "with a FilterList that defines the criteria to select packets "
      "for the classifier to process. Note that a classifier is "
      "always modeled as a ClassifierService that aggregates a set "
      "of ClassifierElements. Each of these ClassifierElements is "
      "EITHER associated with a single FilterList OR associated to "
      "another ClassifierService (via NextServiceAfterClassifier"
      "Element to describe hierarchical classification).") ]
class CIM_ClassifierElementUsesFilterList : CIM_Dependency {

        [Override ("Antecedent"), Max (1),
         Description (
         "The FilterList that specifies the traffic criteria for a "
         "ClassifierElement.") ]
    CIM_FilterList REF Antecedent;

        [Override ("Dependent"), Description (
         "The ClassifierElement that depends on the FilterList for "
         "its traffic criteria.") ] 
    CIM_ClassifierElement REF Dependent;
};


// ===================================================================
// NextServiceAfterClassifierElement
// ===================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "An association used to establish a predecessor-successor "
      "relationship between a single ClassifierElement (within a "
      "ClassifierService) and the next ConditioningService object "
      "that further processes the selected traffic. Note that the "
      "cardinalities indicate that a FollowingService MUST be "
      "defined, after the ClassifierElement. This is because there "
      "is no reason to classify traffic unless further processing "
      "will be done.") ]
class CIM_NextServiceAfterClassifierElement : CIM_NextService {

        [Override ("PrecedingService"), Description (
         "The ClassifierElement that selects traffic to be passed "
         "to the FollowingService.") ]
    CIM_ClassifierElement REF PrecedingService;

        [Override ("FollowingService"), Min (1), Max (1), 
         Description (
         "The ConditioningService that follows the ClassifierElement.") ] 
    CIM_ConditioningService REF FollowingService;
};


// ==================================================================
// ClassifierFilterSet
// ==================================================================
   [Association, 
    Deprecated {"CIM_ClassifierElementUsesFilterList",
      "ClassifierElementInClassifierService"}, 
    Version ("2.7.0"), Description (
      "In order for a ClassifierService to correctly identify and "
      "process network traffic, that traffic must be described by "
      "FilterEntries, which are aggregated into FilterLists. This "
      "association defines the Dependency of the ClassifierService "
      "on FilterLists (and therefore, their FilterEntries). The "
      "cardinality of the association requires that the Classifier"
      "Service operate against at least one FilterList. \n"
      "\n"
      "The association is deprecated in lieu of associating Filter"
      "Lists to ClassifierElements, and ClassifierElements into "
      "ClassifierServices. The latter approach is very flexible "
      "regarding the implementations that can be modeled, and removes "
      "the need to track individual traffic streams using an "
      "artificial model property, TrafficClass. Using "
      "ClassifierElements, each stream is processed beginning with "
      "a single FilterList and progressing through various "
      "ConditioningServices, associated via instances of "
      "NextService.") ] 
class CIM_ClassifierFilterSet : CIM_Dependency {

        [Deprecated {"CIM_ClassifierElementUsesFilterList.Antecedent"}, 
         Override ("Antecedent"), Description (
         "The FilterList aggregating FilterEntries, these in turn "
         "describe how traffic is identified and processed by the "
         "ClassifierService.") ]
    CIM_FilterList REF Antecedent;

        [Deprecated {"CIM_ClassifierElementUsesFilterList.Dependent"}, 
         Override ("Dependent"), Description (
         "The ClassifierService which uses the FilterList and its "
         "aggregated FilterEntries.") ]
    CIM_ClassifierService REF Dependent;

        [Deprecated {
            "CIM_ClassifierElementInClassifierService.ClassifierOrder"}, 
         Description (
         "The ordering of the FilterLists used in the classification "
         "and forwarding functions of the ClassifierService.") ]
    uint16 FilterListPosition; 
};


// ===================================================================
// MeterService
// ===================================================================
   [Version ("2.7.0"), Description (
      "This class 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. \n"
      "\n"
      "This class 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 a subclass of the NextService association, "
      "to identify the subsequent ConditioningServices for conforming "
      "and non-conforming traffic.") ]
class CIM_MeterService : CIM_ConditioningService {

        [Description (
         "This property is an enumerated 16-bit unsigned integer "
         "that is used to specify the particular type of meter. "
         "Defined values of the enumeration are: \n"
         "\n"
         "   1: Other \n"
         "   2: Average Rate Meter \n"
         "   3: Exponentially Weighted Moving Average Meter \n"
         "   4: Token Bucket Meter \n"
         "\n"
         "Note: The MeterType property and the MeterService "
         "subclasses provide similar information. This property is "
         "defined for query purposes and for future expansion. It "
         "is assumed that not all MeterServices will require a "
         "subclass to define them.  Therefore, MeterService will "
         "be instantiated directly and the Type property is "
         "needed."),
         ValueMap {"1", "2", "3", "4"}, 
         Values {"Other", "Average Rate Meter", 
            "Exponentially Weighted Moving Average Meter", 
            "Token Bucket Meter"}, 
         ModelCorrespondence {"CIM_MeterService.OtherMeterType"} ]
    uint16 MeterType;

        [Description (
         "This property is a string used in conjunction with "
         "the MeterType property. When the value of MeterType "
         "is 1 (i.e., \"Other\"), then the name of the conformance "
         "level for this meter is defined in this property."),
         ModelCorrespondence {"CIM_MeterService.MeterType"} ]
    string OtherMeterType;

        [Description (
         "An unsigned integer indicating the number of conformance "
         "levels supported by the Meter. For example, when only " 
         "'in-profile' or 'out of profile' metering is supported. "
         "ConformanceLevels is set to 2.") ]
    uint16 ConformanceLevels;
};


// ===================================================================
// AverageRateMeterService
// ===================================================================
   [Version ("2.7.0"), Description (
      "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.") ]
class CIM_AverageRateMeterService : CIM_MeterService {

        [Description (
         "This property is a 32-bit unsigned integer that defines the "
         "rate used to determine whether admitted packets are in "
         "conformance or not. The value is specified in kilobits per "
         "second."),
         Units ("KiloBits per Second") ]
    uint32 AverageRate;

       [Description ( 
        "This property is a 64-bit unsigned integer that defines " 
        "the time period over which the average measurement should " 
        "be taken. The value is specified in microseconds."), 
        Units ("MicroSeconds") ] 
    uint64 DeltaInterval; 
};


// ===================================================================
// EWMAMeterService
// ===================================================================
   [Version ("2.7.0"), Description (
      "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.") ]
class CIM_EWMAMeterService : CIM_MeterService {

        [Description (
         "This property is a 32-bit unsigned 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."),
         Units ("KiloBits Per Second") ]
    uint32 AverageRate;

       [Description ( 
        "This property is a 64-bit unsigned 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."), 
        Units ("MicroSeconds") ] 
    uint64 DeltaInterval;

        [Description (
         "This property is a 32-bit unsigned 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.") ]
    uint32 Gain;
};


// ===================================================================
// TokenBucketMeterService
// ===================================================================
   [Version ("2.7.0"), Description (
      "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. \n"
      "\n"
      "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.") ]
class CIM_TokenBucketMeterService : CIM_MeterService {

        [Description (
         "This property is a 32-bit unsigned integer that is used to "
         "define the committed rate of the meter. The value is "
         "expressed in kilobits per second."),
         Units ("KiloBits per Second") ]
    uint32 AverageRate;

        [Description (
         "This attribute is a 32-bit unsigned integer that is used to "
         "define the peak rate of the meter. The value is "
         "expressed in kilobits per second."), 
         Units ("KiloBits per Second") ]
    uint32 PeakRate;

        [Description (
         "This property is a 32-bit unsigned integer that is used to "
         "define the maximum number of tokens available for the "
         "committed rate (specified by the AverageRate property). The "
         "value is specified in kilobytes."),
         Units ("KiloBytes") ]
    uint32 BurstSize;

        [Description (
         "This property is a 32-bit unsigned integer that is used to "
         "define the maximum number of tokens available for the "
         "peak rate (specified by the PeakRate property). The "
         "value is specified in kilobytes."),
         Units ("KiloBytes") ]
    uint32 ExcessBurstSize;
};


// ==================================================================
// NextServiceAfterMeter
// ==================================================================
   [Association, Version ("2.7.0"), Description (
      "This association describes a predecessor-successor "
      "relationship between a MeterService and one or more "
      "ConditioningService objects that process traffic from the "
      "meter. For example, for devices that implement preamble "
      "marking, the FollowingService reference (after the meter) "
      "is a PreambleMarkerService - to record the results of the "
      "metering in the preamble. \n"
      "\n"
      "It might be expected that the NextServiceAfterMeter "
      "association would subclass from NextService. However, "
      "meters are 1:n fan-out elements, and require a mechanism "
      "to distinguish between the different results/outputs of "
      "the meter. Therefore, this association defines a new key "
      "property, MeterResult, which is used to record the result "
      "and identify the output through which this traffic left "
      "the meter.") ]
class CIM_NextServiceAfterMeter {

        [Key, Description (
         "The preceding MeterService, 'earlier' in the "
         "processing sequence for a packet.") ]
    CIM_MeterService REF PrecedingService;

        [Key, Description (
         "The 'next' or following ConditioningService.") ]
    CIM_ConditioningService REF FollowingService;

        [Key, Description (
         "Information on the result of the metering. Traffic "
         "is distinguished as being conforming, non-conforming, or "
         "partially conforming. More complicated metering can be "
         "built either by extending the enumeration or by "
         "cascading meters."), 
         ValueMap {"0", "1", "2", "3"}, 
         Values {"Unknown", "Conforming", "Partially Conforming", 
            "Non-Conforming"} ]
    uint16 MeterResult;
};


// ===================================================================
// MarkerService
// ===================================================================
   [Version ("2.6.0"), Description (
      "MarkerService represents the general process of "
      "marking a selected field in a network packet with "
      "a specified value. Packets are marked in order to "
      "control the conditioning that they will subsequently "
      "receive. Subclasses of MarkerService identify the "
      "specific fields to be marked, and introduce properties "
      "to represent the values used in marking these fields. "
      "Markers are usually invoked as a result of a "
      "preceding classifier match. \n"
      "\n"
      "MarkerService is a concrete class because its "
      "superclass (ConditioningService) is concrete. While "
      "this class can be instantiated, an instance of it "
      "does not accomplish anything, because both the field "
      "to be marked and the value used to mark it are defined "
      "in subclasses. \n"
      "\n"
      "MarkerService is modeled as a ConditioningService so "
      "that it can be aggregated into a QoSService (using the "
      "QoSConditioningSubService association). This association "
      "indicates that the MarkerService's functionality "
      "underlies the QoSService. MarkerService also "
      "participates in the NextService association to identify "
      "the subsequent ConditioningService(s) that act on packets "
      "after they have been marked.") ]
class CIM_MarkerService : CIM_ConditioningService {
};


// ===================================================================
// PreambleMarkerService
// ===================================================================
   [Version ("2.7.0"), Description (
      "PreambleMarkerService models the storing of traffic-"
      "conditioning results in a packet preamble. An instance "
      "appends a two-part string of the form '<type>,<value>' to "
      "the packet preamble. The concept of 'type's is discussed "
      "more fully in the Description of the class' "
      "FilterItemList property.") ]
class CIM_PreambleMarkerService : CIM_MarkerService {

        [Description (
         "To foster interoperability, the basic format of the "
         "information captured by a PreambleMarker is specified. "
         "That information is contained in the FilterItemList "
         "property (an ordered, string array). Each entry in the "
         "array takes the form 'type,value'. When entries are added, "
         "they are appended to the end of the list. \n"
         "\n"
         "A limited set of standardized 'type's exist. They are: \n"
         "   - ConformingFromMeter, NonConformingFromMeter and "
         "PartConformingFromMeter to convey metering results "
         "(where the 'value' is the name of the meter) \n"
         "   - VlanId to describe the traffic's VLAN information "
         "(where the 'value' is the VLAN ID). \n"
         "  An implementation is free to define and use other "
         "preamble 'types'. \n"
         "  Note that a wildcard value of \"any\" is allowed to "
         "indicate that the preamble entry matches for any 'value' "
         "of the specified 'type'. For example, using the wildcard, "
         "an administrator can define a filter to select all "
         "packets that were found to be conforming ('type' = "
         "\"ConformingFromMeter\") without having to name each "
         "meter individually."),
         ArrayType ("Ordered") ]
    string FilterItemList[];
};


// ===================================================================
// ToSMarkerService
// ===================================================================
   [Version ("2.7.0"), Description (
      "ToSMarkerService marks the ToS (type of service) field "
      "in the IPv4 packet header [R791] with a specific value. "
      "Packets are marked in order to control the conditioning "
      "that they will subsequently receive. Following common "
      "practice, the value to be written into the ToS field is "
      "represented as an unsigned 8-bit integer.") ]
class CIM_ToSMarkerService : CIM_MarkerService {

        [Description (
         "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 field is always "
         "0. Such an implementation cannot support an "
         "odd TosValue.") ]
    uint8 ToSValue;
};


// ===================================================================
// DSCPMarkerService
// ===================================================================
   [Version ("2.7.0"), Description (
      "DSCPMarkerService marks the differentiated services "
      "codepoint (DSCP) within the DS field in the IPv4 and IPv6 "
      "packet headers, as defined in [R2474]. It is marked with "
      "the specific value defined in the property, DSCPValue. "
      "Following common practice, the value to be written into "
      "the field is represented as an unsigned 8-bit integer.") ]
class CIM_DSCPMarkerService : CIM_MarkerService {

        [MinValue (0), MaxValue (63), Description (
         "This property is an unsigned 8-bit integer, representing "
         "a value to be used for marking the DSCP 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 bits "
         "in the DS field are left unchanged.") ]  
    uint8 DSCPValue;
};


// ===================================================================
// 8021QMarkerService
// ===================================================================
   [Version ("2.7.0"), Description (
      "8021QMarkerService marks 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. Following common practice, the value "
      "to be written into the field is represented as an unsigned "
      "8-bit integer.") ]
class CIM_8021QMarkerService : CIM_MarkerService {

        [MinValue (0), MaxValue (7), Description (
         "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 two bits in the octet are left unchanged.") ]  
    uint8 PriorityValue;
};


// ===================================================================
// DropperService
// ===================================================================
   [Version ("2.7.0"), Description (
      "DropperService represents the ability to selectively "
      "drop network traffic, and/or to invoke another "
      "ConditioningService (indicated using the NextService "
      "association) for further processing of traffic that is "
      "not dropped. It is the base class for different types "
      "of droppers. Droppers are distinguished by the "
      "algorithm that they use to drop traffic. \n"
      "\n"
      "The NextService association has special semantics for "
      "droppers, in addition to conveying the general information "
      "of 'what happens next' (that apply to all Conditioning"
      "Services). 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.") ]
class CIM_DropperService : CIM_ConditioningService {

        [Description (
         "This property is an enumerated 16-bit unsigned integer "
         "that defines the type of dropper. Its Values are: \n"
         "   1:  Other \n"
         "   2:  Random \n"
         "   3:  HeadTail \n"
         "   4:  Absolute Dropper \n"
         "\n"
         "Note: The DropperType property and the DropperService "
         "subclasses provide similar information. This property is "
         "defined for query purposes and to not require a "
         "subclass for all types of DropperServices (for example, "
         "to describe an Absolute Dropper in today's model). "
         "Therefore, DropperService can be instantiated directly "
         "and the Type property is needed."),
         ValueMap {"1", "2", "3", "4"},
         Values {"Other", "Random", "HeadTail", "Absolute Dropper"},
         ModelCorrespondence { 
            "CIM_DropperService.OtherDropperType"} ]
    uint16 DropperType; 

        [Description (
         "This property contains a vendor-specific value for the "
         "type of dropping that is done. It is used when the value "
         "of the DropperType property is 1 (Other)."),
         ModelCorrespondence {"CIM_DropperService.DropperType"} ]
    string OtherDropperType;

        [Deprecated {
            "CIM_DropperService.TypeOfDropper (=4, Absolute Dropper)"}, 
         Description (
         "This property indicates whether the Dropper will always "
         "drop incoming packets (value=1) regardless of their type. "
         "It is deprecated since its information is conveyed by "
         "the TypeOfDropper property (value=4, 'Absolute Dropper')."), 
         ValueMap {"0", "1", "2"},
         Values {"Unknown", "Always Drop", "Do Not Always Drop"} ]
    uint16 AlwaysDrop;

        [Description (
         "This enumeration indicates the point in the associated "
         "queue (associated via the NextService relationship) "
         "from which packets should be dropped. If the value is "
         "0 \"Unknown\", then packets MAY be dropped from any "
         "location in the queue."), 
         ValueMap {"0", "1", "2"},
         Values {"Unknown", "Head", "Tail"} ]
    uint16 DropFrom;

        [Description (
         "This property is an enumerated unsigned 16-bit integer "
         "that defines the metric used to trigger the start of "
         "dropping packets. This does NOT mean that all packets "
         "will be dropped; it does mean that SOME packets will "
         "start to be dropped. The number and type of packets "
         "dropped is a function of the type of algorithm used by "
         "this Dropper. Values are: \n"
         "\n"
         "   1:  Other \n"
         "   2:  Queue Threshold \n"
         "   3:  Arrival Rate "),
         ValueMap {"1", "2", "3"},
         Values {"Other", "Queue Threshold", "Arrival Rate"} ]
    uint16 DropStartMetric;

        [Description (
         "This property is an enumerated unsigned 16-bit integer "
         "that defines the metric used to determine when ALL "
         "packets will be dropped REGARDLESS of the type of "
         "algorithm used by this Dropper. Values are: \n"
         "\n"
         "   1:  Other \n"
         "   2:  Queue Threshold \n"
         "   3:  Arrival Rate "),
         ValueMap {"1", "2", "3"},
         Values {"Other", "Queue Threshold", "Arrival Rate"} ]
    uint16 DropMaintainMetric;
};


// ===================================================================
// REDDropperService
// ===================================================================
   [Version ("2.7.0"), Description (
      "REDDropperService represents the ability to drop "
      "network traffic using a Random Early Detection (RED) "
      "algorithm. 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 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 connections "
      "are not affected by these discards. \n"
      "\n"
      "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(s) to determine the "
      "dropper's DropThresholdCalculationService(s), and then "
      "following the CalculationBasedOnQueue association to "
      "find the queue being watched by each CalculationService.") ]
class CIM_REDDropperService : CIM_DropperService {

        [Description (
         "This is an unsigned 32-bit integer that defines the "
         "minimum average queue depth at which packets are "
         "subject to being dropped. (See the ThresholdUnits "
         "property to determine the units of the threshold.) "
         "The slope of the drop probability function is "
         "described by the Start/StopProbability properties."),
         ModelCorrespondence {"CIM_REDDropperService.ThresholdUnits"} ]
    uint32 MinQueueThreshold;

        [MinValue (0), MaxValue (1000), Description (
         "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. "
         "(See the ThresholdUnits property to determine the "
         "units of the threshold.)"), 
         ModelCorrespondence {"CIM_REDDropperService.ThresholdUnits"} ]
    uint32 MaxQueueThreshold;

        [Description (
         "This is an unsigned 32-bit integer, used in conjunction "
         "with the StopDropProbability property. The start and stop "
         "probabilities define 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. \n"
         "\n"
         "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."), 
         Units ("Per Thousand Packets"), 
         ModelCorrespondence {
            "CIM_REDDropperService.StopProbability"} ]
    uint32 StartProbability;

        [MinValue (0), MaxValue (1000), Description (
         "This is an unsigned 32-bit integer, used in conjunction "
         "with the StartDropProbability property. The start and "
         "stop probabilities define 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. \n"
         "\n"
         "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."), 
         Units ("Per Thousand Packets"), 
         ModelCorrespondence {
            "CIM_REDDropperService.StartProbability"} ]
    uint32 StopProbability;

        [Description (
         "ThresholdUnits is an enumerated integer that identifies "
         "the units for the Min and MaxQueueThreshold properties. "
         "The values are either bytes (1) or packets (2)."), 
         ValueMap {"1", "2"}, 
         Values {"Bytes", "Packets"} ]
    uint16 ThresholdUnits;
};


// ===================================================================
// WeightedREDDropperService
// ===================================================================
   [Version ("2.7.0"), Deprecated {"No value"}, 
    Description (
      "This class represents a logical entity that resides in the "
      "data forwarding path of a network device. It describes the "
      "ability to drop network traffic using a Weighted Random "
      "Early Detection (WRED) algorithm. Like RED, the purpose of "
      "WRED is to avoid congestion (as opposed to managing "
      "congestion). This modification of the basic RED algorithm "
      "enables packets belonging to different traffic classes to "
      "be dropped at different queue depths. This algorithm also "
      "enables discard to be done based on different information "
      "contained in the packet header, such as IP Precedence, "
      "RSVP session parameters, or even on other factors not "
      "directly encoded in the packet header, such as the "
      "queue depth. \n"
      "\n"
      "Implementation of this class has shown that weighting "
      "should not be a property of the class (but on an association "
      "to it), and that there is insufficient data to process the "
      "drop metric. The class is deprecated pending further "
      "definition by the DMTF.") ]
class CIM_WeightedREDDropperService : CIM_DropperService {

        [Deprecated {"No value"}, Description (
         "This property is an enumerated 16-bit unsigned integer, "
         "and defines the type of metric that is used to drop "
         "traffic.  Values are: \n"
         "\n"
         "   1:  Other \n"
         "   2:  IP Precedence \n"
         "   3:  DSCP Value \n"
         "   4:  802.1P Priority Value \n"
         "   5:  RSVP Session \n"
         "   6:  Queue Depth \n"
         "   7:  Packet Arrival Rate "),
         ValueMap {"1", "2", "3", "4", "5", "6", "7"},
         Values {"Other", "IP Precedence", "DSCP Value", 
            "802.1P Priority Value", "RSVP Session", 
            "Queue Depth", "Packet Arrival Rate"},  
         ModelCorrespondence {
            "CIM_WeightedREDDropperService.OtherDropMetric"} ]
    uint16 DropMetric;

        [Deprecated {"No value"}, Description (
         "This string property is used in conjunction with the "
         "DropMetric property. When the value of DropMetric is "
         "1 (i.e., \"Other\"), then the type of metric to be used "
         "is defined in this property."),
         ModelCorrespondence {
            "CIM_WeightedREDDropperService.DropMetric"} ]
    string OtherDropMetric;

        [Deprecated {
           "CIM_DropperThresholdCalculationService.SmoothingWeight"}, 
         MinValue (0), MaxValue (100), Description (
         "This is a 32-bit real number that represents the "
         "weighting factor used to determine which queues "
         "get more service.") ] 
    real32 Weight;
};


// ===================================================================
// HeadTailDropper
// ===================================================================
   [Version ("2.7.0"), Description (
      "HeadTailDropper describes the threshold information "
      "of a head or tail dropper. The inherited property "
      "DropFrom indicates whether a particular instance of "
      "this class is a head dropper or a tail dropper. \n"
      "\n"
      "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.") ]
class CIM_HeadTailDropper : CIM_DropperService {

        [Description (
         "This is an unsigned 32-bit integer that indicates "
         "the queue depth (in bytes) at which traffic is "
         "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."), 
         Units ("Bytes") ]
    uint32 QueueThreshold;
};


// ===================================================================
// QueuingService
// ===================================================================
   [Version ("2.7.0"), Description (
      "QueuingService represents the ability to queue "
      "network traffic, and to specify the characteristics "
      "for determining long-term congestion. It is modeled "
      "as a ConditioningService so that it can be aggregated "
      "into a QoSService (using the QoSConditioningSubService "
      "association). This indicates that its functionality "
      "underlies the QoSService.") ]
class CIM_QueuingService : CIM_ConditioningService {

        [Gauge, Description (
         "Indicates the current depth of this queue in units "
         "specified by DepthUnits. This value may be important "
         "in diagnosing unexpected behavior."),
         ModelCorrespondence {"CIM_QueuingService.DepthUnits"} ]
    uint32 CurrentQueueDepth;

        [Description (
         "DepthUnits is an enumerated integer that identifies "
         "the units for the CurrentQueueDepth property. "
         "The values are either bytes (1) or packets (2)."), 
         ValueMap {"1", "2"}, 
         Values {"Bytes", "Packets"} ]
    uint16 DepthUnits;
};


// ===================================================================
// DropThresholdCalculationService
// ===================================================================
   [Version ("2.7.0"), Description (
      "This class calculates an average 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. The Service does "
      "the calculation on behalf of a RED dropper (as indicated "
      "by the association, CalculationServiceForDroppper). A "
      "DropThresholdCalculationService is always associated to "
      "the single queue that it examines via the Calculation"
      "BasedOnQueue relationship.") ]
class CIM_DropThresholdCalculationService : CIM_Service {

        [MinValue (0), MaxValue (100000), Description (
         "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: \n"
         "average = (old_average*(1-inverse of SmoothingWeight)) \n"
         " + (current_queue_depth*inverse of SmoothingWeight) \n "
         "Implementations may choose to limit the acceptable set of "
         "values to a specified set, such as powers of 2."), 
         Units ("Thousandths") ]
    uint32 SmoothingWeight;

        [Description (
         "This property is a 32-bit unsigned integer, and defines "
         "the number of nanoseconds between each calculation of "
         "average/smoothed queue depth. When this property is not "
         "specified, the CalculationService may determine an "
         "appropriate interval."), 
         Units ("NanoSeconds") ]
    uint32 TimeInterval;
};


// ==================================================================
// QueueHierarchy
// ==================================================================
   [Association, Version ("2.7.0"), Deprecated {"No value"}, 
    Description (
      "Describes the reliance of a QueuingService on other, "
      "supporting queues and their QueuingServices. A given Service "
      "can only act in support of one QueuingService; but a "
      "higher level queue may be supported by many lower level "
      "QueuingServices. \n"
      "\n"
      "The class is deprecated since a queue only stores "
      "network traffic. It does not support other queues, or "
      "manipulate their entries. This type of processing is described "
      "using NextService associations 'rightwards' from the "
      "QueuingService. These associations reference 'other' "
      "ConditioningServices that may send traffic to 'other' "
      "queues).") ] 
class CIM_QueueHierarchy : CIM_ServiceServiceDependency {

        [Override ("Antecedent"), Deprecated {"No value"}, 
         Description (
         "The supporting queue(s) and its QueuingService. This Service "
         "can only support at most one, higher level QueuingService.") ]
    CIM_QueuingService REF Antecedent;

        [Override ("Dependent"), Max (1), Deprecated {"No value"}, 
         Description (
         "The QueuingService dependent on other, supporting Queuing"
         "Services.") ]
    CIM_QueuingService REF Dependent;
};


// ==================================================================
// CalculationServiceForDropper
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This association is a subclass of ServiceServiceDependency, "
      "and represents the reliance of a REDDropperService on one or "
      "more DropThresholdCalculationServices. The latter calculate "
      "average queue depth, based on the observed depths of a "
      "queue. The specific queue examined by each CalculationService "
      "is defined using the CalculationBasedOnQueue association.") ]
class CIM_CalculationServiceForDropper : CIM_ServiceServiceDependency {

        [Override ("Antecedent"), Min (1), Description (
         "A calculation service for the dropper.") ]
    CIM_DropThresholdCalculationService REF Antecedent;

        [Override ("Dependent"), Description (
         "The RED dropper which is dependent on average queue depth "
         "calculations by the Antecedent Service.") ]
    CIM_REDDropperService REF Dependent;
};


// ==================================================================
// CalculationBasedOnQueue
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This association establishes a dependency relationship "
      "between a QueuingService and an instance of the "
      "DropThresholdCalculationService class. The queue's "
      "current depth is used by the CalculationService in "
      "calculating an average/smoothed queue depth.") ]
class CIM_CalculationBasedOnQueue : CIM_ServiceServiceDependency {

        [Override ("Antecedent"), Min (1), Max (1), 
         Description (
         "The queue examined by the CalculationService.") ]
    CIM_QueuingService REF Antecedent;

        [Override ("Dependent"), Description (
         "The CalculationService that provides an average queue "
         "depth.") ]
    CIM_DropThresholdCalculationService REF Dependent;
};


// ==================================================================
// HeadTailDropQueueBinding
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This association describes the relationship between a "
      "head or tail dropper and the queue that it monitors to "
      "determine when to drop traffic. The referenced queue's "
      "depth is compared against the Dropper's threshold property. "
      "Although the dropper drops from only one queue, the "
      "drop decision may be influenced by the state of several "
      "queues. The rule for combining the multiple inputs is "
      "simple addition: if the sum of the lengths of the "
      "monitored queues exceeds the dropper's QueueThreshold "
      "value, then packets are dropped. Note that this rule for "
      "combining inputs may be overridden.") ]
class CIM_HeadTailDropQueueBinding : CIM_Dependency {

        [Override ("Antecedent"), Min (1),  
         Description (
         "A QueuingService examined by the CalculationService.") ]
    CIM_QueuingService REF Antecedent;

        [Override ("Dependent"), Description (
         "The CalculationService that provides an average queue "
         "depth.") ]
    CIM_HeadTailDropper REF Dependent;
};


// ==================================================================
// QueueAllocation
// ==================================================================
   [Association, Version ("2.6.0"), Description (
      "Describes the reliance of a QueuingService on the "
       "availability of space in a BufferPool.") ] 
class CIM_QueueAllocation : CIM_Dependency {

        [Override ("Antecedent"), Description (
         "The BufferPool supporting packet storage for a "
         "QueuingService.") ]
    CIM_BufferPool REF Antecedent;

        [Override ("Dependent"), Description (
         "The QueuingService dependent on the BufferPool for storage "
         "space.") ]
    CIM_QueuingService REF Dependent;

        [MinValue (0), MaxValue (100), Description (
         "This property is an 8-bit unsigned integer representing "
         "a percentage from 0 to 100. It defines the percentage of "
         "the BufferPool that should be allocated to the referenced "
         "QueuingService. If absolute sizes are desired, this is "
         "accomplished by defining individual BufferPools of the "
         "specified sizes, with QueueAllocation.AllocationPercentages "
         "set to 100."), 
         Units ("Percent") ]
    uint8 AllocationPercentage;
};


// ===================================================================
// PacketSchedulingService
// ===================================================================
   [Version ("2.7.0"), Description (
      "This class represents the scheduling service, which is a "
      "process that determines whether 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 backplanes. 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 the scheduler is servicing. One can describe that "
      "different schedulers support different queues, or that "
      "a scheduler supports several queues. \n"
      "\n"
      "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 a subsequent "
      "ConditioningService, if any, that acts on traffic after it "
      "has been processed by the scheduler.") ]
class CIM_PacketSchedulingService : CIM_ConditioningService {

        [Description (
         "This property is an enumerated 16-bit unsigned integer, and "
         "defines the type of scheduler. Values are: \n"
         "   1:  Other \n"
         "   2:  FIFO \n"
         "   3:  Priority \n"
         "   4:  Allocation \n"
         "   5:  Bounded Priority \n"
         "   6:  Weighted Round Robin Packet \n"
         "If no value is specified, 2 (\"FIFO\") should be assumed."), 
         ValueMap {"1", "2", "3", "4", "5", "6"},
         Values {"Other", "FIFO", "Priority", "Allocation", 
            "Bounded Priority", "Weighted Round Robin Packet"}, 
         ModelCorrespondence {
            "CIM_PacketSchedulingService.OtherSchedulerType"} ]
    uint16 SchedulerType;

        [Description (
         "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 to be used is defined in this attribute."),
         ModelCorrespondence {
           "CIM_ PacketSchedulingService.SchedulerType"} ]
    string OtherSchedulerType;
};


// ==================================================================
// NextScheduler
// ==================================================================
   [Association,  Version ("2.7.0"), Description (
      "This association is a subclass of NextService, and defines "
      "a predecessor-successor relationship between Packet"
      "SchedulingServices.  In a hierarchical queuing "
      "configuration (where a second scheduler treats the output of "
      "a first scheduler as a single, aggregated input), the two "
      "schedulers are related via the NextScheduler association.") ]
class CIM_NextScheduler : CIM_NextService {

        [Override ("PrecedingService"), Description (
         "The PacketSchedulingService whose output is treated as a "
         "single, aggregated input by the FollowingService scheduler. "
         "The [0..n] cardinality indicates that a single "
         "FollowingService scheduler may bring together the aggregated "
         "outputs of multiple prior schedulers.") ]
    CIM_PacketSchedulingService REF PrecedingService;

        [Override ("FollowingService"), Max (1), Description (
         "A scheduler that includes among its inputs the aggregated "
         "outputs of one or more PrecedingService schedulers.") ]
    CIM_PacketSchedulingService REF FollowingService;
};


// ==================================================================
// SchedulerUsed
// ==================================================================
   [Association, Version ("2.7.0"), 
    Deprecated {"CIM_QueueToSchedule", 
       "CIM_SchedulingServiceToSchedule"}, 
    Description (
      "In order to remove queued packets, a process or Service "
      "(identified as a PacketSchedulingService) runs.  This "
      "association describes the Dependency of the queue and its "
      "QueuingService on a SchedulingService, which empties it. \n"
      "\n"
      "The association is deprecated in lieu of associating Queuing"
      "Services to SchedulingElements, and SchedulingElements into "
      "SchedulingServices. The latter approach is very flexible "
      "regarding the implementations that can be modeled, and removes "
      "the need to track individual traffic streams using an "
      "artificial model property, TrafficClass.") ]
class CIM_SchedulerUsed : CIM_ServiceServiceDependency {

        [Override ("Antecedent"), 
         Deprecated {"CIM_QueueToSchedule.Queue"}, 
         Max (1), Description (
         "The PacketSchedulingService which empties the Queuing"
         "Service's queue.") ]
    CIM_PacketSchedulingService REF Antecedent;

        [Override ("Dependent"), 
         Deprecated {"CIM_QueueToSchedule.SchedElement"}, 
         Description (
         "The queue and its QueuingService from which packets "
         "are emptied.") ]
    CIM_QueuingService REF Dependent;
};


// ==================================================================
// NonWorkConservingSchedulingService
// ==================================================================
   [Version ("2.7.0"), Description (
      "A type of packet scheduler, that is capable of "
      "operating in a non-work conserving manner. This class "
      "does not add any properties beyond those it inherits "
      "from PacketSchedulingService.  It does, however, "
      "participate in one additional association, "
      "FailNextScheduler.") ]
class CIM_NonWorkConservingSchedulingService : 
 CIM_PacketSchedulingService {
};


// ==================================================================
// FailNextScheduler
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This association is a subclass of NextScheduler, and defines "
      "a predecessor-successor relationship between a NonWork"
      "ConservingSchedulingService and another PacketScheduling"
      "Service. It indicates that the NonWorkConserving scheduler "
      "may pass up a scheduling opportunity (thereby behaving "
      "in a non-work conserving manner), and make the resulting "
      "bandwidth available to the FollowingService scheduler.") ]
class CIM_FailNextScheduler : CIM_NextScheduler {

        [Override ("PrecedingService"), Description (
         "The NonWorkConservingSchedulingService whose excess "
         "bandwidth is made available to the scheduler identified "
         "by the FollowingService reference. The [0..n] cardinality "
         "indicates that a single FollowingService scheduler may "
         "have the opportunity to use the unused bandwidth of multiple "
         "prior non-work-conserving schedulers.") ]
    CIM_NonWorkConservingSchedulingService REF PrecedingService;

        [Override ("FollowingService"), Max (1), Description (
         "A scheduler that may use the bandwidth available from "
         "the non-work conserving scheduler.") ]
    CIM_PacketSchedulingService REF FollowingService;
};


// ==================================================================
// SchedulingElement
// ==================================================================
   [Abstract, Version ("2.7.0"), Description (
      "SchedulingElement 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 Packet"
      "SchedulingService. \n"
      "\n"
      "Among the subclasses of this class, some are defined in "
      "such a way that all of their instances are work conserving. "
      "Other subclasses, however, 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. Note that WorkConserving is "
      "restricted to TRUE in the subclasses that are inherently "
      "work conserving, since instances of these classes cannot "
      "be anything else.") ]
class CIM_SchedulingElement : CIM_ManagedElement {

        [Key, Description (
         "Within the scope of the instantiating Namespace, InstanceID " 
         "opaquely and uniquely identifies an instance of this class. "
         "In order to ensure uniqueness within the NameSpace, the "
         "value of InstanceID SHOULD be constructed using the "
         "following 'preferred' algorithm: \n"
         " <OrgID>:<LocalID> \n"
         "Where <OrgID> and <LocalID> are separated by a colon ':', "
         "and where <OrgID> MUST include a copyrighted, trademarked "
         "or otherwise unique name that is owned by the business entity "
         "creating/defining the InstanceID, or is a registered ID that "
         "is assigned to the business entity by a recognized global "
         "authority. (This is similar to the <Schema Name>_<Class Name> "
         "structure of Schema class names.) In addition, to ensure "
         "uniqueness <OrgID> MUST NOT contain a colon (':'). When "
         "using this algorithm, the first colon to appear in "
         "InstanceID MUST appear between <OrgID> and <LocalID>. \n"
         " <LocalID> is chosen by the business entity and SHOULD not be "
         "re-used to identify different underlying (real-world) elements. " 
         "If the above 'preferred' algorithm is not used, the defining "
         "entity MUST assure that the resultant InstanceID is not "
         "re-used across any InstanceIDs produced by this or other "
         "providers for this instance's NameSpace. \n"
         "For DMTF defined instances, the 'preferred' algorithm MUST be "
         "used with the <OrgID> set to 'CIM'.") ] 
    string InstanceID;

        [Write, Description (
         "A boolean property indicating whether the "
         "PacketSchedulingService tied to this instance (by the "
         "ElementInSchedulingService aggregation) is treating the"
         "queue/input tied to this instance, in a work-conserving "
         "manner. The queue/input is indicated by either the "
         "QueueToSchedule or SchedulingServiceToSchedule "
         "association. Note that this property is writeable, "
         "indicating that an administrator can change the behavior "
         "of the SchedulingElement - but only for those elements "
         "that can operate in a non-work conserving mode.") ]
    boolean WorkConserving;
};


// ==================================================================
// AllocationSchedulingElement
// ==================================================================
   [Version ("2.7.0"), Description (
      "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.") ]
class CIM_AllocationSchedulingElement : CIM_SchedulingElement {

        [Description (
         "A 16-bit unsigned integer enumeration that identifies "
         "the units in which the BandwidthAllocation and "
         "BurstAllocation properties are expressed. The following "
         "values are defined: \n"
         " - Bytes(1) \n"
         " - Packets(2) \n"
         " - Cells(3) (fixed-size, for example, ATM) \n"
         "If no value is specified, 1 (\"Bytes\") should be assumed."),
         ValueMap {"1", "2", "3"},
         Values {"Bytes", "Packets", "Cells"} ]
    uint16 AllocationUnits;

        [Description (
         "A 32-bit bit unsigned integer defining the number "
         "of 'units' per second that should be allocated to the "
         "associated input. 'Units' are identified by the "
         "AllocationUnits property."), 
         ModelCorrespondence {
            "CIM_AllocationSchedulingElement.AllocationUnits"} ]
    uint32 BandwidthAllocation;

        [Description (
         "A 32-bit bit unsigned integer specifying 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. 'Units' are "
         "identified by the AllocationUnits property."), 
         ModelCorrespondence {
            "CIM_AllocationSchedulingElement.AllocationUnits"} ]
    uint32 BurstAllocation;

        [Description (
         "A boolean property that, if TRUE, enables unused "
         "bandwidth from the associated input to be allocated "
         "to other inputs serviced by the Scheduler.") ]
    boolean CanShare;

        [Description (
         "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.") ]
    boolean WorkFlexible;
};


// ==================================================================
// WRRSchedulingElement
// ==================================================================
   [Version ("2.7.0"), Description (
      "This class is a subclass of the abstract class "
      "SchedulingElement. It introduces a new property, "
      "WeightingFactor, to give some inputs a higher probability "
      "of being serviced than other inputs. It also introduces "
      "a Priority property, 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 TRUE in this class.") ]
class CIM_WRRSchedulingElement : CIM_SchedulingElement {

        [Override ("WorkConserving") ]
    boolean WorkConserving = TRUE;

        [MinValue (0), MaxValue (100000), Description (
         "A 32-bit bit unsigned integer defining the weighting "
         "factor that offers some inputs a higher probability of "
         "being serviced than other inputs. The property's minimum "
         "value is 0, its maximum value is 100000, and its Units "
         "are thousandths."),
         Units ("Thousandths") ]
    uint32 WeightingFactor;

        [Description (
         "A 16-bit 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. 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 the instances where "
         "this behavior is not necessary or is undesirable, the "
         "property may be left unspecified.") ]
    uint16 Priority;
};


// ==================================================================
// PrioritySchedulingElement
// ==================================================================
   [Version ("2.7.0"), Description (
      "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 "
      "Priority property 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 TRUE "
      "in this class.") ]
class CIM_PrioritySchedulingElement : CIM_SchedulingElement {

        [Override ("WorkConserving") ]
    boolean WorkConserving = TRUE;

        [Description (
         "A 16-bit unsigned integer indicating the priority level "
         "of this SchedulingElement's input, relative to the other "
         "inputs serviced by the SchedulingElement's aggregating "
         "PacketSchedulingService.  A larger value represents a "
         "higher priority.") ]
    uint16 Priority;
};


// ==================================================================
// BoundedPrioritySchedulingElement
// ==================================================================
   [Version ("2.7.0"), Description (
      "This class is a subclass of the class PriorityScheduling"
      "Element, 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. BoundedPriority"
      "SchedulingElement adds an upper bound (BandwidthBound 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. Note that this class inherits from its "
      "superclass the restriction of the inherited boolean "
      "property WorkConserving to TRUE.") ]
class CIM_BoundedPrioritySchedulingElement : 
 CIM_PrioritySchedulingElement {

        [Override ("WorkConserving") ]
    boolean WorkConserving = TRUE;

        [Description (
         "A 32-bit unsigned integer that defines the upper limit "
         "on the amount of traffic that can be handled from the "
         "input (through this SchedulingElement). This is not a "
         "shaped upper bound, since bursts can occur. It is a "
         "strict bound, limiting the impact of the input.  Units "
         "are kilobits per second."), 
         Units ("KiloBits per Second") ]
    uint32 BandwidthBound;
};


// ==================================================================
// QueueToSchedule
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This is a top-level association, representing the "
      "relationship between a queue (QueuingService) and a "
      "SchedulingElement. The SchedulingElement, in turn, "
      "represents the information in a packet scheduling service "
      "that is specific to this queue, such as relative priority "
      "or allocated bandwidth. \n"
      "\n"
      "Although it cannot be expressed formally with the "
      "association cardinalities, there is an additional constraint "
      "on participation in this association. A particular instance "
      "of (a subclass of) SchedulingElement always participates "
      "either in exactly one instance of this association, or in "
      "exactly one instance of the association "
      "SchedulingServiceToSchedule.") ]
class CIM_QueueToSchedule {

        [Key, Max (1), Description (
         "The queue and its QueuingService from which packets "
         "are emptied.") ]
    CIM_QueuingService REF Queue;

        [Key, Description (
         "The SchedulingElement for the input queue.") ]
    CIM_SchedulingElement REF SchedElement;
};


// ==================================================================
// SchedulingServiceToSchedule
// ==================================================================
   [Association, Version ("2.7.0"), 
    Description (
      "This is a top-level association, representing the "
      "relationship between a scheduler (PacketSchedulingService) "
      "and a SchedulingElement, in a configuration involving "
      "cascaded schedulers. The SchedulingElement, in turn, "
      "represents the information in a packet scheduling service "
      "that is specific to this scheduler, such as relative "
      "priority or allocated bandwidth. \n"
      "\n"
      "Although it cannot be expressed formally with the "
      "association cardinalities, there is an additional constraint "
      "on participation in this association. A particular instance "
      "of (a subclass of) SchedulingElement always participates "
      "either in exactly one instance of this association, or in "
      "exactly one instance of the association QueueToSchedule.") ]
class CIM_SchedulingServiceToSchedule {

        [Key, Max (1), Description (
         "The scheduler being cascaded.") ]
    CIM_PacketSchedulingService REF SchedService;

        [Key, Description (
         "A SchedulingElement in the subsequent scheduler.") ]
    CIM_SchedulingElement REF SchedElement;
};


// ==================================================================
// ElementInSchedulingService
// ==================================================================
   [Association, Aggregation, Composition, 
    Version ("2.7.0"), Description (
      "This association represents the relationship between a "
      "PacketSchedulingService and the set of SchedulingElements "
      "that tie it to its inputs (either QueuingServices or other "
      "PacketSchedulingServices).") ]
class CIM_ElementInSchedulingService : CIM_Component {

        [Override ("GroupComponent"), Aggregate, Max (1), 
         Description (
         "The scheduler aggregating the SchedulingElement. A "
         "SchedulingElement can be associated with at most one "
         "SchedulingService.") ]
    CIM_PacketSchedulingService REF GroupComponent;

        [Override ("PartComponent"), Min (1), Description (
         "A SchedulingElement that ties either a queue or another "
         "scheduler to the referenced PacketSchedulingService. Every "
         "PacketSchedulingService MUST have at least one Scheduling"
         "Element/input.") ]
    CIM_SchedulingElement REF PartComponent;
};


// ===================================================================
// end of file
// ===================================================================
