Cisco-IOS-XE-dre-oper

This module contains a collection of YANG definitions for Data Redundancy Elimination operational data. Copyright (c) 2020-2021 ...

  • Version: 2021-07-01

    Cisco-IOS-XE-dre-oper@2021-07-01


    
      module Cisco-IOS-XE-dre-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XE-dre-oper";
    
        prefix dre-xe-oper;
    
        import ietf-inet-types {
          prefix inet;
        }
        import ietf-yang-types {
          prefix yang;
        }
        import cisco-semver {
          prefix cisco-semver;
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
         Customer Service
    
         Postal: 170 W Tasman Drive
         San Jose, CA 95134
    
         Tel: +1 1800 553-NETS
    
         E-mail: cs-yang@cisco.com";
    
        description
          "This module contains a collection of YANG definitions
         for Data Redundancy Elimination operational data.
         Copyright (c) 2020-2021 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2021-07-01" {
          description
            "Profiles support for Data Redundancy Elimination
           - Added support for DRE statistics brief
           - Deprecated internal fragmentation and buffer usage by module";
          reference
            "1.1.0";
    
        }
    
        revision "2021-03-01" {
          description "Initial revision";
          reference
            "1.0.0";
    
        }
    
        cisco-semver:module-version "1.1.0";
        cisco-semver:module-version "1.0.0";
    
        typedef dre-comp-type {
          type enumeration {
            enum "comp-invalid" {
              value 0;
              description
                "Compression type - invalid";
            }
            enum "comp-dre-only" {
              value 1;
              description
                "Compression type - DRE only";
            }
            enum "comp-lz-only" {
              value 2;
              description
                "Compression type - LZ only";
            }
            enum "comp-dre-lz" {
              value 3;
              description
                "Compression type - DRE + LZ";
            }
          }
          description "DRE comp type";
        }
    
        typedef dre-health-status {
          type enumeration {
            enum "dre-status-unknown" {
              value 0;
              description
                "DRE health status is unknown";
            }
            enum "dre-status-red" {
              value 1;
              description
                "DRE health status is red";
            }
            enum "dre-status-yellow" {
              value 2;
              description
                "DRE health status is yellow";
            }
            enum "dre-status-green" {
              value 3;
              description
                "DRE health status is green";
            }
            enum "dre-status-unavailable" {
              value 4;
              description
                "DRE health status is unavailable";
            }
            enum "dre-status-disabled" {
              value 5;
              description
                "DRE health status is disabled";
            }
          }
          description
            "Data Redundancy Elimination health status";
        }
    
        typedef dre-cache-status {
          type enumeration {
            enum "cache-status-inactive" {
              value 0;
              description "Cache is inactive";
            }
            enum "cache-status-init-in-progress" {
              value 1;
              description "Cache is in progress";
            }
            enum "cache-status-active" {
              value 2;
              description "Cache is active";
            }
            enum "cache-status-temp-failed" {
              value 3;
              description
                "Cache temporarily failed";
            }
            enum "cache-status-failed" {
              value 4;
              description "Cache is failed";
            }
          }
          description "Status of DRE cache";
        }
    
        typedef dre-profile-type {
          type enumeration {
            enum "dre-profile-unknown" {
              value 0;
              description
                "DRE profile type unknown";
            }
            enum "dre-profile-high" {
              value 1;
              description
                "DRE profile type high";
            }
            enum "dre-profile-medium" {
              value 2;
              description
                "DRE profile type medium";
            }
            enum "dre-profile-low" {
              value 3;
              description "DRE profile type low";
            }
            enum "dre-profile-small" {
              value 4;
              description
                "DRE profile type small";
            }
            enum "dre-profile-large" {
              value 5;
              description
                "DRE profile type large";
            }
            enum "dre-profile-extra-large" {
              value 6;
              description
                "DRE profile type extra large";
            }
            enum "dre-profile-extra-extra-large" {
              value 7;
              description
                "DRE profile type extra extra Large";
            }
          }
          description "DRE profile type";
        }
    
        typedef dre-alarms {
          type enumeration {
            enum "almid-dre-none" {
              value 0;
              description "Alarm ID none";
            }
            enum "almid-dre-disk-full" {
              value 1;
              description "Disk full alarm";
            }
            enum "almid-dre-cache-corrupted" {
              value 2;
              description
                "Cache corrupted alarm";
            }
            enum "almid-dre-over-fanout" {
              value 3;
              description "Over fanout alarm";
            }
            enum "almid-dre-disk-overload" {
              value 4;
              description "Disk overload alarm";
            }
            enum "almid-dre-maxconn-threshold" {
              value 5;
              description
                "Maximum connections threshold exceeded alarm";
            }
            enum "almid-dre-cpu-threshold" {
              value 6;
              description
                "CPU threshold exceeded alarm";
            }
            enum "almid-dre-init-failed" {
              value 7;
              description "Init failed alarm";
            }
          }
          description "DRE alarms";
        }
    
        typedef dre-hs-change-reason {
          type enumeration {
            enum "hs-reason-none" {
              value 0;
              description
                "Health status change reason - none";
            }
            enum "hs-reason-init-failed" {
              value 1;
              description
                "Health status reason - init failed";
            }
            enum "hs-reason-not-responding" {
              value 2;
              description
                "Health status reason - no response";
            }
            enum "hs-reason-cache-corrupted" {
              value 3;
              description
                "Health status reason - cache corrupted";
            }
            enum "hs-reason-disk-overload" {
              value 4;
              description
                "Health status change reason - disk overload";
            }
            enum "hs-reason-disk-full" {
              value 5;
              description
                "Health status change reason - disk full";
            }
            enum "hs-reason-cpu-threshold" {
              value 6;
              description
                "Health status change reason - CPU threshold";
            }
            enum "hs-reason-maxconn-threshold" {
              value 7;
              description
                "Health status change  - maximum connections threshold";
            }
            enum "hs-reason-rename-over-fanout" {
              value 8;
              description
                "Health status change reason - over fanout";
            }
          }
          description
            "DRE health status change reason";
        }
    
        typedef lz-algorithm {
          type enumeration {
            enum "lz-algo-unknown" {
              value 0;
              description "LZ LZO algorithm";
            }
            enum "lz-algo-zlib" {
              value 1;
              description "LZ ZLIB algorithm";
            }
            enum "lz-algo-lzo" {
              value 2;
              description "LZ LZO algorithm";
            }
          }
          description "Type of LZ algorithm";
        }
    
        typedef dre-state {
          type enumeration {
            enum "dre-state-unknown" {
              value 0;
              description "DRE state - Unknown";
            }
            enum "dre-state-monitor" {
              value 1;
              description "DRE state - Monitor";
            }
            enum "dre-state-bypass" {
              value 2;
              description "DRE state  - Bypass";
            }
          }
          description "DRE state";
        }
    
        typedef bypass-reason {
          type enumeration {
            enum "bypass-lowmem-bytes" {
              value 0;
              description
                "Bypass reason - Low memory bytes";
            }
            enum "bypass-out-of-sync" {
              value 1;
              description
                "Bypass reason - Out of sync";
            }
            enum "bypass-cache-not-ready" {
              value 2;
              description
                "Bypass reason - Cache not ready";
            }
            enum "bypass-rem-cache-not-ready" {
              value 3;
              description
                "Bypass reason - Remote cache not ready";
            }
            enum "bypass-cache-not-compatible" {
              value 4;
              description
                "Bypass reason - Remote cache not compatible";
            }
            enum "bypass-ackq-cap-exceed" {
              value 5;
              description
                "Bypass reason - Exceed ack-Q cap";
            }
            enum "bypass-remote-waitq-bytes" {
              value 6;
              description
                "Bypass reason - Remote wait-Q due to nack";
            }
            enum "bypass-disk-overld-bytes" {
              value 7;
              description
                "Bypass reason - Local disk overload";
            }
            enum "bytes-rem-disk-overld-bytes" {
              value 8;
              description
                "Bypass reason - Remote disk overload";
            }
            enum "reason-disk-io-err-bytes" {
              value 9;
              description
                "Bypass reason - Local disk IO error";
            }
            enum "bypass-rem-disk-io-err-bytes" {
              value 10;
              description
                "Bypass reason - Remote disk IO error";
            }
            enum
              "bypass-non-dre-comp-type-bytes" {
              value 11;
              description
                "Bypass reason - Non DRE compression type";
            }
            enum "bypass-chunk-bytes" {
              value 12;
              description
                "Bypass reason - Last partial chunk";
            }
            enum "bypass-skip-bytes" {
              value 13;
              description
                "Bypass reason - Skipped frame header";
            }
            enum "bypass-low-comp-bytes" {
              value 14;
              description
                "Bypass reason - DRE low compression auto bypass";
            }
          }
          description "DRE bypass reasons";
        }
    
        container dre-oper-data {
          config false;
          description
            "Data Redundancy Elimination operational data";
          container appqoe-dre-status {
            presence "appqoe-dre-status";
            description
              "Data Redundancy Elimination operational status";
            leaf health-status {
              type dre-health-status;
              description "DRE health status";
            }
    
            container data {
              when
                "(../health-status!='dre-status-unavailable' and ../health-status!='dre-status-disabled')";
              description "DRE status data";
              leaf dre-id {
                type string;
                description "DRE peer ID";
              }
    
              leaf dre-uptime {
                type yang:date-and-time;
                description "Uptime of DRE";
              }
    
              leaf hs-change-reason {
                type dre-hs-change-reason;
                description
                  "DRE health status change reason";
              }
    
              leaf hs-change-time {
                type yang:date-and-time;
                description
                  "Time from last DRE health status change";
              }
    
              leaf last-hs-update {
                type yang:date-and-time;
                description
                  "Last DRE health status time";
              }
    
              leaf cache-status {
                type dre-cache-status;
                description "DRE cache status";
              }
    
              leaf disk-cache-usage {
                type uint8;
                units "percentage";
                description
                  "Percentage of disk cache usage";
              }
    
              leaf disk-latency {
                type uint32;
                units "milliseconds";
                description "DRE disk latency";
              }
    
              list alarm {
                description "Alarms asserted";
                leaf alarms-list {
                  type dre-alarms;
                  description "List of alarms";
                }
              }  // list alarm
    
              container config {
                description
                  "Configuration in detail";
                leaf total-disk {
                  type uint16;
                  units "GB";
                  description
                    "Total available disk space";
                }
    
                leaf max-cons {
                  type uint32;
                  description
                    "Maximum connections configured";
                }
    
                leaf max-fanout {
                  type uint32;
                  description "Maximum fanout";
                }
    
                leaf profile {
                  type dre-profile-type;
                  description "DRE profile type";
                }
    
                leaf total-memory {
                  type uint64;
                  units "MB";
                  description
                    "Total available memory";
                }
    
                leaf cpu-cores {
                  type uint8;
                  description "CPU cores";
                }
    
                leaf disk-encrypt {
                  type boolean;
                  description
                    "DRE disk encryption";
                }
    
                leaf rep-accl-mode {
                  type boolean;
                  description
                    "Replication accelerator mode ON/OFF";
                }
    
                leaf comp-type {
                  type dre-comp-type;
                  description "Compression Type";
                }
    
                leaf plz-mem {
                  type uint32;
                  units "MB";
                  description
                    "Persistent LZ memory";
                }
    
                leaf plz-buffer {
                  type uint32;
                  units "bytes";
                  description
                    "Persistent LZ buffer queue size";
                }
    
                leaf hash-table-mem {
                  type uint32;
                  units "MB";
                  description
                    "DRE hash table memory";
                }
    
                leaf plz-high-wm {
                  type uint32;
                  description
                    "Persistent LZ high-watermark";
                }
    
                leaf plz-low-wm {
                  type uint32;
                  description
                    "Persistent LZ low-watermark";
                }
    
                leaf wait-queue-cap {
                  type uint32;
                  units "MB";
                  description
                    "Wait queue capacity";
                }
    
                leaf max-data-unit {
                  type uint32;
                  description
                    "Maximum data unit number";
                }
    
                leaf sig-read-pool {
                  type uint32;
                  units "bytes";
                  description
                    "Sign block read pool size";
                }
    
                leaf data-read-pool {
                  type uint32;
                  units "bytes";
                  description
                    "Data segment read pool size";
                }
    
                leaf anchor-distance {
                  type uint32;
                  description
                    "Default anchor distance";
                }
    
                leaf section-size {
                  type uint32;
                  units "bytes";
                  description
                    "Default section size";
                }
    
                leaf avg-chunk-size {
                  type uint32;
                  units "bytes";
                  description
                    "Default average chunk size";
                }
    
                leaf min-chunk-size {
                  type uint32;
                  units "bytes";
                  description
                    "Default minimum chunk size";
                }
    
                leaf lookup-on {
                  type boolean;
                  description
                    "Partial lookup ON/OFF";
                }
    
                leaf write-tshld {
                  type uint32;
                  description "Write threshold";
                }
    
                leaf cold-pass-tshld {
                  type uint32;
                  description
                    "Cold pass threshold";
                }
    
                leaf algorithm {
                  type lz-algorithm;
                  description "LZ algorithm";
                }
    
                leaf lz-adaptive {
                  type boolean;
                  description
                    "Adaptive LZ ON/OFF";
                }
    
                leaf lz-comp-level {
                  type uint32;
                  description
                    "LZ compression level";
                }
    
                leaf lz-adaptive-thres {
                  type uint32;
                  description
                    "Adaptive threshold";
                }
    
                leaf use-entropy {
                  type boolean;
                  description
                    "Adaptive LZ uses entropy ON/OFF";
                }
    
                leaf plz-enabled {
                  type boolean;
                  description
                    "Persistent LZ enabled YES/NO";
                }
    
                leaf big-msg-checksum {
                  type boolean;
                  description
                    "Big message checksum ON/OFF";
                }
    
                leaf block-size {
                  type uint32;
                  units "bytes";
                  description
                    "Buffer block size";
                }
              }  // container config
            }  // container data
          }  // container appqoe-dre-status
    
          list appqoe-dre-auto-bypass {
            key "server-ip port";
            description
              "Data Redundancy Elimination auto-bypass details";
            leaf state {
              type dre-state;
              description "DRE state";
            }
    
            leaf dre-lan-bytes {
              type uint64;
              units "bytes";
              description "Total DRE LAN bytes";
            }
    
            leaf dre-wan-bytes {
              type uint64;
              units "bytes";
              description "Total DRE WAN bytes";
            }
    
            leaf dre-comp {
              type decimal64 {
                fraction-digits 2;
              }
              units "percentage";
              description "DRE reduction ratio";
            }
    
            leaf last-update {
              type yang:date-and-time;
              description
                "Last update timestamp";
            }
    
            leaf entry-creation-time {
              type yang:date-and-time;
              description
                "Last entry creation timestamp";
            }
    
            leaf server-ip {
              type inet:ip-address;
              description "Server IP address";
            }
    
            leaf port {
              type uint16;
              description "Server port";
            }
          }  // list appqoe-dre-auto-bypass
    
          container appqoe-dre-stats {
            presence "appqoe-dre-stats";
            description
              "Data Redundancy Elimination operational statistics";
            leaf health-status {
              type dre-health-status;
              description "DRE health status";
            }
    
            container data {
              when
                "(../health-status!='dre-status-unavailable' and ../health-status!='dre-status-disabled')";
              description "DRE statistics data";
              leaf cache-status {
                type dre-cache-status;
                description "Cache status";
              }
    
              leaf cache-oldest-data {
                when
                  "../cache-status='cache-status-active'";
                type yang:date-and-time;
                description
                  "Oldest data in cache";
              }
    
              leaf max-cons {
                type uint32;
                description
                  "Maximum connections configured";
              }
    
              leaf cache-size {
                type uint64;
                units "bytes";
                description "Total cache size";
              }
    
              leaf cache-used-percent {
                type uint16;
                units "percentage";
                description
                  "Percentage of cache used";
              }
    
              leaf data-replaced {
                type uint64;
                description
                  "Data units replaced in last hour";
              }
    
              leaf total-cons {
                type uint64;
                description
                  "Total number of connections";
              }
    
              leaf active-cons {
                type uint64;
                description
                  "Number of active connections";
              }
    
              leaf total-orig-bytes {
                type uint64;
                units "bytes";
                description
                  "Total original bytes";
              }
    
              leaf total-opt-bytes {
                type uint64;
                units "bytes";
                description
                  "Total optimized bytes";
              }
    
              leaf reduction-ratio {
                type uint16;
                units "percentage";
                description "Reduction ratio";
              }
    
              leaf total-usable-disk {
                type uint64;
                units "bytes";
                description
                  "Total usable disk size";
              }
    
              leaf total-usable-disk-usage {
                type uint8;
                units "percentage";
                description
                  "Total usable disk size usage";
              }
    
              leaf hash-tbl-ram-size {
                type uint64;
                units "bytes";
                description
                  "Hash table RAM size";
              }
    
              leaf hash-tbl-ram-usage {
                type uint8;
                units "percentage";
                description
                  "Hash table RAM usage";
              }
    
              leaf sig-block-disk-usage {
                type uint64;
                units "percentage";
                description
                  "Signature block disk usage";
              }
    
              leaf sig-block-mem-usage {
                type uint8;
                units "percentage";
                description
                  "Signature block memory usage";
              }
    
              leaf sig-block-time {
                type yang:date-and-time;
                description
                  "Signature block creation timestamp";
              }
    
              leaf data-unit-disk-usage {
                type uint8;
                units "bytes";
                description
                  "Data unit disk usage";
              }
    
              leaf data-unit-mem-usage {
                type uint8;
                units "percentage";
                description
                  "Data unit memory usage";
              }
    
              leaf data-unit-time {
                type yang:date-and-time;
                description
                  "Data unit creation timestamp";
              }
    
              leaf cache-created-time {
                when
                  "../cache-status='cache-status-active'";
                type yang:date-and-time;
                description
                  "Cache creation timestamp";
              }
    
              leaf evicted-cache {
                type uint64;
                units "bytes";
                description
                  "Evicted cache in loading cache";
              }
    
              leaf sigblock-replaced-size {
                type uint64;
                units "bytes";
                description
                  "Size of signature block replaced in last hour";
              }
    
              leaf sigblock-replaced-sec {
                type uint64;
                description
                  "Sections of signature block replaced in last hour";
              }
    
              leaf data-unit-replaced-size {
                type uint64;
                units "bytes";
                description
                  "Size of data unit replaced in last hour";
              }
    
              leaf data-unit-replaced-sec {
                type uint64;
                description
                  "Section of data unit replaced in last hour";
              }
    
              leaf sigblock-size {
                type uint64;
                units "bytes";
                description "Size of sigblock";
              }
    
              leaf sigblock-count {
                type uint64;
                description
                  "Signature block count";
              }
    
              leaf data-unit-size {
                type uint64;
                units "bytes";
                description "Size of data unit";
              }
    
              leaf data-unit-count {
                type uint64;
                description "Total data units";
              }
    
              leaf data-unit-seg-count {
                type uint64;
                description
                  "Total data unit segments";
              }
    
              leaf data-unit-seg-size {
                type uint64;
                units "bytes";
                description
                  "Data unit segment size";
              }
    
              leaf ng-clock-head {
                type uint64;
                description
                  "Next generation clock head";
              }
    
              leaf ng-clock-tail {
                type uint64;
                description
                  "Next generation clock tail";
              }
    
              leaf total-read-latency {
                type uint64;
                units "milliseconds";
                description "Total read latency";
              }
    
              leaf total-read-count {
                type uint64;
                description
                  "Total number of reads";
              }
    
              leaf total-disk-read-latency {
                type uint64;
                units "milliseconds";
                description
                  "Total disk read latency";
              }
    
              leaf total-disk-read-count {
                type uint64;
                description
                  "Total number of disk reads";
              }
    
              leaf table-full-events {
                type uint64;
                description "Full events";
              }
    
              leaf sig-events {
                type uint64;
                description "Signal events";
              }
    
              leaf type-two-events {
                type uint64;
                description "Type 2 events";
              }
    
              leaf type-three-events {
                type uint64;
                description "Type 3 events";
              }
    
              leaf sigblock-total-chunks {
                type uint64;
                description
                  "Total number of sigblock chunks";
              }
    
              leaf sigblock-total-sec {
                type uint64;
                description
                  "Total number of sigblock sections";
              }
    
              leaf secblock-total-chunks {
                type uint64;
                description
                  "Total number of secblock chunks";
              }
    
              leaf secblock-total-sec {
                type uint64;
                description
                  "Total number of secblock sections";
              }
    
              leaf total-anchor-seen {
                type uint64;
                description
                  "Total number of anchors seen";
              }
    
              leaf total-matches-seen {
                type uint64;
                description
                  "Total number of matches seen";
              }
    
              leaf matches {
                type uint64;
                description
                  "Total number of multiple matches";
              }
    
              container ack-queue {
                description
                  "Acknowledgement queue";
                leaf total-size {
                  type uint64;
                  units "bytes";
                  description
                    "Total size of ACK queue";
                }
    
                leaf used-size {
                  type uint64;
                  units "bytes";
                  description
                    "Used ACK queue size";
                }
    
                leaf wait-queue {
                  type uint64;
                  description
                    "ACK queue wait size";
                }
    
                leaf disk-write {
                  type uint64;
                  description
                    "Total ACK disk writes";
                }
    
                leaf optimized-size {
                  type uint64;
                  units "bytes";
                  description
                    "Size of optimized ACK queue";
                }
    
                leaf object-buff-size {
                  type uint64;
                  units "bytes";
                  description
                    "Size of ACK queue buffer";
                }
    
                leaf numbers {
                  type uint64;
                  description
                    "Total number of ACK queues";
                }
              }  // container ack-queue
    
              container errors {
                description
                  "DRE low memory errors";
                leaf open {
                  type uint64;
                  description "Open errors";
                }
    
                leaf decode {
                  type uint64;
                  description
                    "Total number of decode errors";
                }
    
                leaf malloc {
                  type uint64;
                  description
                    "Total number of malloc errors";
                }
    
                leaf plz-off {
                  type uint64;
                  description
                    "Total number of persistent LZ off errors";
                }
    
                leaf minres {
                  type uint64;
                  description
                    "Total number of minimum resource errors";
                }
              }  // container errors
    
              leaf chunk-mem-used {
                type uint64;
                units "bytes";
                description
                  "Chunk aggregation node memory consumption";
              }
    
              container twin-pool {
                description
                  "Twin pool statistics";
                leaf big-used {
                  type uint64;
                  description "Big used";
                }
    
                leaf big-free {
                  type uint64;
                  description "Big free";
                }
    
                leaf small-used {
                  type uint64;
                  description "Small used";
                }
    
                leaf small-free {
                  type uint64;
                  description "Small free";
                }
    
                leaf defragment {
                  type uint64;
                  description "Defragment";
                }
              }  // container twin-pool
    
              leaf encode-plz-on-conn {
                type uint64;
                description
                  "Encode - Persistent LZ-ON connections";
              }
    
              leaf encode-plz-off-conn {
                type uint64;
                description
                  "Encode - Persistent LZ-OFF connections";
              }
    
              leaf encode-msg-size {
                type uint64;
                units "bytes";
                description
                  "Encode - Average message size";
              }
    
              leaf decode-disk-read {
                type uint64;
                description
                  "Decode - Total disk read";
              }
    
              leaf decode-disk-write {
                type uint64;
                description
                  "Decode - Total disk write";
              }
    
              leaf decode-plz-on-conn {
                type uint64;
                description
                  "Decode - Persistent LZ-ON connections";
              }
    
              leaf decode-plz-off-conn {
                type uint64;
                description
                  "Decode - Persistent LZ-OFF connections";
              }
    
              leaf decode-plz-num-in-disc {
                type uint64;
                description
                  "Decode - Average message size";
              }
    
              container encode {
                description "Encode details";
                container overall {
                  description
                    "Overall compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container overall
    
                container dre {
                  description
                    "DRE compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre
    
                container dre-bypass {
                  description
                    "DRE bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre-bypass
    
                container lz {
                  description
                    "LZ compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz
    
                container lz-bypass {
                  description
                    "LZ bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz-bypass
    
                leaf avg-latency {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  description "Average latency";
                }
    
                leaf avg-msg-size {
                  type uint64;
                  description
                    "Average message size";
                }
    
                container msg-dist {
                  description
                    "Message size distribution";
                  leaf kb-0-1 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 0 to 1 KB ";
                  }
    
                  leaf kb-1-5 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 1 to 5 KB";
                  }
    
                  leaf kb-5-15 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 5 to 15 KB";
                  }
    
                  leaf kb-15-25 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 15 to 25 KB";
                  }
    
                  leaf kb-25-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 25 to 40 KB";
                  }
    
                  leaf kb-above-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size above 40 KB";
                  }
                }  // container msg-dist
              }  // container encode
    
              container decode {
                description "Decode details";
                container overall {
                  description
                    "Overall compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container overall
    
                container dre {
                  description
                    "DRE compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre
    
                container dre-bypass {
                  description
                    "DRE bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre-bypass
    
                container lz {
                  description
                    "LZ compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz
    
                container lz-bypass {
                  description
                    "LZ bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz-bypass
    
                leaf avg-latency {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  description "Average latency";
                }
    
                leaf avg-msg-size {
                  type uint64;
                  description
                    "Average message size";
                }
    
                container msg-dist {
                  description
                    "Message size distribution";
                  leaf kb-0-1 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 0 to 1 KB ";
                  }
    
                  leaf kb-1-5 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 1 to 5 KB";
                  }
    
                  leaf kb-5-15 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 5 to 15 KB";
                  }
    
                  leaf kb-15-25 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 15 to 25 KB";
                  }
    
                  leaf kb-25-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 25 to 40 KB";
                  }
    
                  leaf kb-above-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size above 40 KB";
                  }
                }  // container msg-dist
              }  // container decode
    
              list bypass-reason-list {
                description "Bypass reason";
                leaf reason {
                  type bypass-reason;
                  description "Bypass reason";
                }
    
                leaf bypass-msgs {
                  type uint64;
                  description
                    "Total number of messages bypassed";
                }
    
                leaf bypass-chunks {
                  type uint64;
                  description
                    "Total number of chunks bypassed";
                }
    
                leaf bypass-size {
                  type uint64;
                  units "bytes";
                  description
                    "Total size of bypassed traffic";
                }
              }  // list bypass-reason-list
    
              leaf nack-msgs {
                type uint64;
                description
                  "Total NACK messages";
              }
    
              leaf num-col-nack-msgs {
                type uint64;
                description
                  "Total number of NACK collision messages received";
              }
    
              leaf num-miss-nack-msgs {
                type uint64;
                description
                  "Total number of chunk miss NACK messages received";
              }
    
              leaf cache-not-ready-nack {
                type uint64;
                description
                  "Total number of cache not ready NACK messages received";
              }
    
              leaf rtx-msgs {
                type uint64;
                description
                  "Total number of retransmitted messages";
              }
    
              leaf num-col-rtx-msgs {
                type uint64;
                description
                  "Total number of collision messages received";
              }
    
              leaf num-miss-rtx-msgs {
                type uint64;
                description
                  "Total number of chunk miss messages received";
              }
    
              leaf cache-not-ready-rtx {
                type uint64;
                description
                  "Total number of cache not ready messages received";
              }
    
              container encode-latency {
                description "Latency in encode";
                leaf ms-per-msg {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  units "milliseconds";
                  description
                    "Latency per message in milliseconds";
                }
    
                leaf avg-msg-size {
                  type uint64;
                  units "bytes";
                  description
                    "Average message size";
                }
              }  // container encode-latency
    
              container decode-latency {
                description "Latency in decode";
                leaf ms-per-msg {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  units "milliseconds";
                  description
                    "Latency per message in milliseconds";
                }
    
                leaf avg-msg-size {
                  type uint64;
                  units "bytes";
                  description
                    "Average message size";
                }
              }  // container decode-latency
    
              leaf num-invalid-sections {
                type uint64;
                description
                  "Total number of invalid sections";
              }
    
              leaf convert-invalid-sections {
                type uint64;
                description
                  "Total number of converted invalid sections due to corrupted cache";
              }
    
              leaf disk-space-saving {
                type uint64;
                units "bytes";
                description
                  "Disk size saved due to unidirectional mode";
              }
    
              leaf total-buf-size {
                type uint64;
                units "bytes";
                description
                  "Total buffer pool size";
              }
    
              leaf unit-size {
                type uint64;
                units "bytes";
                description "Unit size";
              }
    
              leaf free-buf-size {
                type uint64;
                units "bytes";
                description
                  "Free buffer size in bytes";
              }
    
              leaf free-buf-units {
                type uint64;
                description
                  "Free buffer size in units";
              }
    
              leaf used-buf-size {
                type uint64;
                units "bytes";
                description
                  "Used buffer size in bytes";
              }
    
              leaf used-buf-units {
                type uint64;
                description
                  "Used buffer size in units";
              }
    
              leaf frag {
                type uint64;
                units "percentage";
                status deprecated;
                description
                  "Percentage of internal fragmentation for used buffers";
              }
    
              list module {
                status deprecated;
                description
                  "Buffer usage by module";
                leaf module-name {
                  type string;
                  status deprecated;
                  description "Module name";
                }
    
                leaf used-units {
                  type uint64;
                  status deprecated;
                  description
                    "Units used by the module";
                }
    
                leaf used-bytes {
                  type uint64;
                  units "bytes";
                  status deprecated;
                  description
                    "Bytes used by the module";
                }
              }  // list module
    
              leaf internal-resets {
                type uint64;
                description
                  "Total number of internal resets generated by DRE";
              }
    
              leaf write-failed {
                type uint64;
                description
                  "Total number of DRE Socket write failures";
              }
    
              leaf read-failed {
                type uint64;
                description
                  "Total number of DRE Socket read failures";
              }
    
              leaf decode-failed {
                type uint64;
                description
                  "Total number of DRE decode failures";
              }
    
              leaf encode-failed {
                type uint64;
                description
                  "Total number of DRE encode failures";
              }
    
              leaf conn-init-failed {
                type uint64;
                description
                  "Total number of DRE Connection init failures";
              }
    
              leaf opt-read-unexp-hup {
                type uint64;
                description
                  "Total number of times WAN socket received unexpected closes while waiting to read";
              }
    
              leaf bufmgr-call-failed {
                type uint64;
                description
                  "Total number of buffer allocation or manipulation failures";
              }
    
              leaf peer-req-reset-close {
                type uint64;
                description
                  "Total number of times peer received reset from end host";
              }
    
              leaf state-invalid {
                type uint64;
                description
                  "Total number of times DRE connection state was out of sync";
              }
    
              leaf bufhead-alloc-failed {
                type uint64;
                description
                  "Total number of times memory allocation failed for buffer heads";
              }
    
              leaf other {
                type uint64;
                description
                  "Total number of other error in connection";
              }
    
              leaf buf-ctrl-pause-ackq {
                type uint64;
                description
                  "Total number of times connection was paused due to ack queue block";
              }
    
              leaf buf-ctrl-pause-buf {
                type uint64;
                description
                  "Total number of times connection was paused due to buffer control";
              }
    
              leaf data-ebp-recvd {
                type uint64;
                description
                  "Total number of data buffers received";
              }
    
              leaf data-ebp-freed {
                type uint64;
                description
                  "Total number of data buffers freed";
              }
    
              leaf data-ebp-alloc {
                type uint64;
                description
                  "Total number of data buffers allocated";
              }
    
              leaf data-ebp-sent {
                type uint64;
                description
                  "Total number of data buffers sent";
              }
    
              leaf data-ebp-send-fail {
                type uint64;
                description
                  "Total number of data buffers send failed";
              }
    
              leaf data-ebp-no-flow-ctx {
                type uint64;
                description
                  "Total number of data buffers received with no flow context";
              }
    
              leaf data-ebp-req-more {
                type uint64;
                description
                  "Total number of data buffers whose requested size was greater than max size";
              }
    
              leaf data-ebp-ret-less {
                type uint64;
                description
                  "Total number of data buffers whose size was less than requested size";
              }
    
              leaf ctrl-ebp-recvd {
                type uint64;
                description
                  "Total number of control buffers received";
              }
    
              leaf ctrl-ebp-freed {
                type uint64;
                description
                  "Total number of control buffers freed";
              }
    
              leaf ctrl-ebp-reused {
                type uint64;
                description
                  "Total number of control buffers reused";
              }
    
              leaf ctrl-ebp-alloc {
                type uint64;
                description
                  "Total number of control buffers allocated";
              }
    
              leaf ctrl-ebp-sent {
                type uint64;
                description
                  "Total number of control buffers sent";
              }
    
              leaf ctrl-ebp-send-fail {
                type uint64;
                description
                  "Total number of control buffers send failed";
              }
    
              leaf ctrl-ebp-no-flow-ctx {
                type uint64;
                description
                  "Total number of control buffers received with no flow context";
              }
    
              leaf ctrl-ebp-req-more {
                type uint64;
                description
                  "Total number of control buffer whose requested size was greater than max size";
              }
    
              leaf ctrl-ebp-ret-less {
                type uint64;
                description
                  "Total number of control buffer size was less than requested size";
              }
    
              leaf conn-alloc {
                type uint64;
                description
                  "Total number of times connection is allocated";
              }
    
              leaf conn-free {
                type uint64;
                description
                  "Total number of times connection is freed";
              }
            }  // container data
          }  // container appqoe-dre-stats
    
          container appqoe-dre-stats-summary {
            presence "appqoe-dre-stats-summary";
            description
              "Data Redundancy Elimination operational statistics brief";
            leaf health-status {
              type dre-health-status;
              description "DRE health status";
            }
    
            container data {
              when
                "(../health-status!='dre-status-unavailable' and ../health-status!='dre-status-disabled')";
              description "DRE statistics data";
              leaf cache-status {
                type dre-cache-status;
                description "Cache status";
              }
    
              leaf cache-oldest-data {
                when
                  "../cache-status='cache-status-active'";
                type yang:date-and-time;
                description
                  "Oldest data in cache";
              }
    
              leaf max-cons {
                type uint32;
                description
                  "Maximum connections configured";
              }
    
              leaf cache-size {
                type uint64;
                units "bytes";
                description "Total cache size";
              }
    
              leaf cache-used-percent {
                type uint16;
                units "percentage";
                description
                  "Percentage of cache used";
              }
    
              leaf data-replaced {
                type uint64;
                description
                  "Data units replaced in last hour";
              }
    
              leaf total-cons {
                type uint64;
                description
                  "Total number of connections";
              }
    
              leaf active-cons {
                type uint64;
                description
                  "Number of active connections";
              }
    
              leaf total-orig-bytes {
                type uint64;
                units "bytes";
                description
                  "Total original bytes";
              }
    
              leaf total-opt-bytes {
                type uint64;
                units "bytes";
                description
                  "Total optimized bytes";
              }
    
              leaf reduction-ratio {
                type uint16;
                units "percentage";
                description "Reduction ratio";
              }
    
              leaf total-usable-disk-usage {
                type uint8;
                units "percentage";
                description
                  "Total usable disk size usage";
              }
    
              leaf internal-resets {
                type uint64;
                description
                  "Total number of internal resets generated by DRE";
              }
            }  // container data
          }  // container appqoe-dre-stats-summary
    
          list appqoe-dre-stats-peer {
            key "system-ip";
            description
              "Data Redundancy Elimination peer data";
            leaf peer-no {
              type uint8;
              description "Peer number";
            }
    
            leaf system-ip {
              type inet:ip-address;
              description "System IP";
            }
    
            leaf hostname {
              type string;
              description "Hostname of peer";
            }
    
            leaf active-cons {
              type uint64;
              description
                "Total number of active connections";
            }
    
            leaf total-cons {
              type uint64;
              description
                "Total number of connections";
            }
          }  // list appqoe-dre-stats-peer
    
          container appqoe-dre-peer-detail {
            presence "appqoe-dre-peer-detail";
            description
              "DRE operation peer data";
            leaf active-cons {
              type uint64;
              description
                "Current number of peers with active connections";
            }
    
            leaf peer-active {
              type uint64;
              description
                "Maximum number of peers with active connections";
            }
    
            list appqoe-dre-peer {
              key "system-ip";
              description
                "List of peers with details";
              leaf total-cons {
                type uint64;
                description
                  "Total number of connections";
              }
    
              leaf active-cons {
                type uint64;
                description
                  "Total number of active connections";
              }
    
              leaf peer-no {
                type uint32;
                description "Peer number";
              }
    
              leaf system-ip {
                type inet:ip-address;
                description "System IP of peer";
              }
    
              leaf hostname {
                type string;
                description "Hostname of peer";
              }
    
              leaf context-number {
                type uint64;
                description
                  "Context number of peer";
              }
    
              leaf peer-id {
                type string;
                description "DRE peer ID";
              }
    
              leaf max-concurrent-cons {
                type uint64;
                description
                  "Maximum concurrent connections";
              }
    
              leaf num-avg-cons {
                type uint64;
                description
                  "Average number of connections";
              }
    
              leaf num-nacks {
                type uint64;
                description
                  "Total NACK messages";
              }
    
              leaf num-rtx {
                type uint64;
                description
                  "Total number of retransmitted messages";
              }
    
              leaf num-ctx-out-of-sync {
                type uint64;
                description
                  "Number of out of sync messages";
              }
    
              leaf cache-used {
                type uint64;
                units "MB";
                description "Total cache used";
              }
    
              container encode {
                description "Encode details";
                container overall {
                  description
                    "Overall compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container overall
    
                container dre {
                  description
                    "DRE compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre
    
                container dre-bypass {
                  description
                    "DRE bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre-bypass
    
                container lz {
                  description
                    "LZ compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz
    
                container lz-bypass {
                  description
                    "LZ bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz-bypass
    
                leaf avg-latency {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  description "Average latency";
                }
    
                leaf avg-msg-size {
                  type uint64;
                  description
                    "Average message size";
                }
    
                container msg-dist {
                  description
                    "Message size distribution";
                  leaf kb-0-1 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 0 to 1 KB ";
                  }
    
                  leaf kb-1-5 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 1 to 5 KB";
                  }
    
                  leaf kb-5-15 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 5 to 15 KB";
                  }
    
                  leaf kb-15-25 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 15 to 25 KB";
                  }
    
                  leaf kb-25-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 25 to 40 KB";
                  }
    
                  leaf kb-above-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size above 40 KB";
                  }
                }  // container msg-dist
              }  // container encode
    
              container decode {
                description "Decode details";
                container overall {
                  description
                    "Overall compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container overall
    
                container dre {
                  description
                    "DRE compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre
    
                container dre-bypass {
                  description
                    "DRE bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container dre-bypass
    
                container lz {
                  description
                    "LZ compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz
    
                container lz-bypass {
                  description
                    "LZ bypass compression details";
                  leaf msg {
                    type uint64;
                    description
                      "Number of messages";
                  }
    
                  leaf in {
                    type uint64;
                    units "bytes";
                    description "Input bytes";
                  }
    
                  leaf out {
                    type uint64;
                    units "bytes";
                    description "Output bytes";
                  }
    
                  leaf ratio {
                    type uint16;
                    units "percentage";
                    description
                      "Reduction ratio";
                  }
                }  // container lz-bypass
    
                leaf avg-latency {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  description "Average latency";
                }
    
                leaf avg-msg-size {
                  type uint64;
                  description
                    "Average message size";
                }
    
                container msg-dist {
                  description
                    "Message size distribution";
                  leaf kb-0-1 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 0 to 1 KB ";
                  }
    
                  leaf kb-1-5 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 1 to 5 KB";
                  }
    
                  leaf kb-5-15 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 5 to 15 KB";
                  }
    
                  leaf kb-15-25 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 15 to 25 KB";
                  }
    
                  leaf kb-25-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size 25 to 40 KB";
                  }
    
                  leaf kb-above-40 {
                    type uint8;
                    units "percentage";
                    description
                      "Total number of messages of size above 40 KB";
                  }
                }  // container msg-dist
              }  // container decode
    
              leaf sig-block-used {
                type uint64;
                units "MB";
                description
                  "Signature block disk used";
              }
    
              leaf sig-block-time {
                type yang:date-and-time;
                description
                  "Signature block creation timestamp";
              }
    
              leaf data-unit-disk-used {
                type uint64;
                units "MB";
                description
                  "Data unit disk used";
              }
    
              leaf data-unit-time {
                type yang:date-and-time;
                description
                  "Data unit creation timestamp";
              }
    
              leaf ack-queue-size {
                type uint64;
                units "bytes";
                description
                  "Acknowledgement queue size";
              }
    
              container delay {
                description
                  "Buffer surge control delay";
                leaf size {
                  type uint64;
                  units "bytes";
                  description "Average size";
                }
    
                leaf conns {
                  type uint64;
                  description
                    "Number of connections";
                }
    
                leaf flush {
                  type uint64;
                  description "Received flush";
                }
              }  // container delay
    
              container agg-ft {
                description
                  "Buffer surge control aggregate and full tree";
                leaf size {
                  type uint64;
                  units "bytes";
                  description "Average size";
                }
    
                leaf conns {
                  type uint64;
                  description
                    "Number of connections";
                }
    
                leaf flush {
                  type uint64;
                  description "Received flush";
                }
              }  // container agg-ft
    
              leaf remote-low-buff {
                type uint64;
                description "Remote low buffer";
              }
    
              leaf received-flush {
                type uint64;
                description
                  "Remote received flush";
              }
    
              leaf usable-cache-size {
                type uint64;
                units "MB";
                description "Usable cache size";
              }
    
              leaf usable-cache-time {
                type yang:date-and-time;
                description
                  "Usable cache creation timestamp";
              }
    
              leaf evicted-cache {
                type uint64;
                units "bytes";
                description "Evicted cache size";
              }
    
              leaf cache-created-time {
                type yang:date-and-time;
                description
                  "Cache creation timestamp";
              }
    
              leaf rtt-max {
                type uint64;
                units "milliseconds";
                description
                  "Round trip time max";
              }
    
              leaf rtt-avg {
                type uint64;
                units "milliseconds";
                description
                  "Round trip time average";
              }
    
              leaf rtt-remote {
                type uint64;
                units "milliseconds";
                description
                  "Round trip time remote";
              }
    
              leaf dre-decode {
                type uint64;
                units "bytes per second";
                description
                  "Per connection decode throughput DRE";
              }
    
              leaf bypass-decode {
                type uint64;
                units "bytes per second";
                description
                  "Per connection decode throughput bypass";
              }
    
              leaf bypass-ratio {
                type uint8;
                units "percentage";
                description "Bypass ratio";
              }
    
              leaf sigblock-write {
                type uint64;
                description
                  "Allocated write sig-block";
              }
    
              leaf data-unit-write {
                type uint64;
                description
                  "Allocated write data-unit";
              }
            }  // list appqoe-dre-peer
          }  // container appqoe-dre-peer-detail
        }  // container dre-oper-data
      }  // module Cisco-IOS-XE-dre-oper
    

© 2023 YumaWorks, Inc. All rights reserved.