FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/cmd/arcstat.in

     #!/usr/bin/env @PYTHON_SHEBANG@
     #
     # Print out ZFS ARC Statistics exported via kstat(1)
     # For a definition of fields, or usage, use arcstat -v
     #
     # This script was originally a fork of the original arcstat.pl (0.1)
     # by Neelakanth Nadgir, originally published on his Sun blog on
     # 09/18/2007
     #     http://blogs.sun.com/realneel/entry/zfs_arc_statistics
    #
    # A new version aimed to improve upon the original by adding features
    # and fixing bugs as needed.  This version was maintained by Mike
    # Harsch and was hosted in a public open source repository:
    #    http://github.com/mharsch/arcstat
    #
    # but has since moved to the illumos-gate repository.
    #
    # This Python port was written by John Hixson for FreeNAS, introduced
    # in commit e2c29f:
    #    https://github.com/freenas/freenas
    #
    # and has been improved by many people since.
    #
    # CDDL HEADER START
    #
    # The contents of this file are subject to the terms of the
    # Common Development and Distribution License, Version 1.0 only
    # (the "License").  You may not use this file except in compliance
    # with the License.
    #
    # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
    # or https://opensource.org/licenses/CDDL-1.0.
    # See the License for the specific language governing permissions
    # and limitations under the License.
    #
    # When distributing Covered Code, include this CDDL HEADER in each
    # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
    # If applicable, add the following below this CDDL HEADER, with the
    # fields enclosed by brackets "[]" replaced with your own identifying
    # information: Portions Copyright [yyyy] [name of copyright owner]
    #
    # CDDL HEADER END
    #
    #
    # Fields have a fixed width. Every interval, we fill the "v"
    # hash with its corresponding value (v[field]=value) using calculate().
    # @hdr is the array of fields that needs to be printed, so we
    # just iterate over this array and print the values using our pretty printer.
    #
    # This script must remain compatible with Python 3.6+.
    #
    
    import sys
    import time
    import getopt
    import re
    import copy
    
    from signal import signal, SIGINT, SIGWINCH, SIG_DFL
    
    
    cols = {
        # HDR:        [Size, Scale, Description]
        "time":       [8, -1, "Time"],
        "hits":       [4, 1000, "ARC hits per second"],
        "iohs":       [4, 1000, "ARC I/O hits per second"],
        "miss":       [4, 1000, "ARC misses per second"],
        "read":       [4, 1000, "Total ARC accesses per second"],
        "hit%":       [4, 100, "ARC hit percentage"],
        "ioh%":       [4, 100, "ARC I/O hit percentage"],
        "miss%":      [5, 100, "ARC miss percentage"],
        "dhit":       [4, 1000, "Demand hits per second"],
        "dioh":       [4, 1000, "Demand I/O hits per second"],
        "dmis":       [4, 1000, "Demand misses per second"],
        "dh%":        [3, 100, "Demand hit percentage"],
        "di%":        [3, 100, "Demand I/O hit percentage"],
        "dm%":        [3, 100, "Demand miss percentage"],
        "ddhit":      [5, 1000, "Demand data hits per second"],
        "ddioh":      [5, 1000, "Demand data I/O hits per second"],
        "ddmis":      [5, 1000, "Demand data misses per second"],
        "ddh%":       [4, 100, "Demand data hit percentage"],
        "ddi%":       [4, 100, "Demand data I/O hit percentage"],
        "ddm%":       [4, 100, "Demand data miss percentage"],
        "dmhit":      [5, 1000, "Demand metadata hits per second"],
        "dmioh":      [5, 1000, "Demand metadata I/O hits per second"],
        "dmmis":      [5, 1000, "Demand metadata misses per second"],
        "dmh%":       [4, 100, "Demand metadata hit percentage"],
        "dmi%":       [4, 100, "Demand metadata I/O hit percentage"],
        "dmm%":       [4, 100, "Demand metadata miss percentage"],
        "phit":       [4, 1000, "Prefetch hits per second"],
        "pioh":       [4, 1000, "Prefetch I/O hits per second"],
        "pmis":       [4, 1000, "Prefetch misses per second"],
        "ph%":        [3, 100, "Prefetch hits percentage"],
        "pi%":        [3, 100, "Prefetch I/O hits percentage"],
        "pm%":        [3, 100, "Prefetch miss percentage"],
        "pdhit":      [5, 1000, "Prefetch data hits per second"],
        "pdioh":      [5, 1000, "Prefetch data I/O hits per second"],
        "pdmis":      [5, 1000, "Prefetch data misses per second"],
        "pdh%":       [4, 100, "Prefetch data hits percentage"],
       "pdi%":       [4, 100, "Prefetch data I/O hits percentage"],
       "pdm%":       [4, 100, "Prefetch data miss percentage"],
       "pmhit":      [5, 1000, "Prefetch metadata hits per second"],
       "pmioh":      [5, 1000, "Prefetch metadata I/O hits per second"],
       "pmmis":      [5, 1000, "Prefetch metadata misses per second"],
       "pmh%":       [4, 100, "Prefetch metadata hits percentage"],
       "pmi%":       [4, 100, "Prefetch metadata I/O hits percentage"],
       "pmm%":       [4, 100, "Prefetch metadata miss percentage"],
       "mhit":       [4, 1000, "Metadata hits per second"],
       "mioh":       [4, 1000, "Metadata I/O hits per second"],
       "mmis":       [4, 1000, "Metadata misses per second"],
       "mread":      [5, 1000, "Metadata accesses per second"],
       "mh%":        [3, 100, "Metadata hit percentage"],
       "mi%":        [3, 100, "Metadata I/O hit percentage"],
       "mm%":        [3, 100, "Metadata miss percentage"],
       "arcsz":      [5, 1024, "ARC size"],
       "size":       [5, 1024, "ARC size"],
       "c":          [5, 1024, "ARC target size"],
       "mfu":        [4, 1000, "MFU list hits per second"],
       "mru":        [4, 1000, "MRU list hits per second"],
       "mfug":       [4, 1000, "MFU ghost list hits per second"],
       "mrug":       [4, 1000, "MRU ghost list hits per second"],
       "unc":        [4, 1000, "Uncached list hits per second"],
       "eskip":      [5, 1000, "evict_skip per second"],
       "el2skip":    [7, 1000, "evict skip, due to l2 writes, per second"],
       "el2cach":    [7, 1024, "Size of L2 cached evictions per second"],
       "el2el":      [5, 1024, "Size of L2 eligible evictions per second"],
       "el2mfu":     [6, 1024, "Size of L2 eligible MFU evictions per second"],
       "el2mru":     [6, 1024, "Size of L2 eligible MRU evictions per second"],
       "el2inel":    [7, 1024, "Size of L2 ineligible evictions per second"],
       "mtxmis":     [6, 1000, "mutex_miss per second"],
       "dread":      [5, 1000, "Demand accesses per second"],
       "ddread":     [6, 1000, "Demand data accesses per second"],
       "dmread":     [6, 1000, "Demand metadata accesses per second"],
       "pread":      [5, 1000, "Prefetch accesses per second"],
       "pdread":     [6, 1000, "Prefetch data accesses per second"],
       "pmread":     [6, 1000, "Prefetch metadata accesses per second"],
       "l2hits":     [6, 1000, "L2ARC hits per second"],
       "l2miss":     [6, 1000, "L2ARC misses per second"],
       "l2read":     [6, 1000, "Total L2ARC accesses per second"],
       "l2hit%":     [6, 100, "L2ARC access hit percentage"],
       "l2miss%":    [7, 100, "L2ARC access miss percentage"],
       "l2pref":     [6, 1024, "L2ARC prefetch allocated size"],
       "l2mfu":      [5, 1024, "L2ARC MFU allocated size"],
       "l2mru":      [5, 1024, "L2ARC MRU allocated size"],
       "l2data":     [6, 1024, "L2ARC data allocated size"],
       "l2meta":     [6, 1024, "L2ARC metadata allocated size"],
       "l2pref%":    [7, 100, "L2ARC prefetch percentage"],
       "l2mfu%":     [6, 100, "L2ARC MFU percentage"],
       "l2mru%":     [6, 100, "L2ARC MRU percentage"],
       "l2data%":    [7, 100, "L2ARC data percentage"],
       "l2meta%":    [7, 100, "L2ARC metadata percentage"],
       "l2asize":    [7, 1024, "Actual (compressed) size of the L2ARC"],
       "l2size":     [6, 1024, "Size of the L2ARC"],
       "l2bytes":    [7, 1024, "Bytes read per second from the L2ARC"],
       "grow":       [4, 1000, "ARC grow disabled"],
       "need":       [5, 1024, "ARC reclaim need"],
       "free":       [5, 1024, "ARC free memory"],
       "avail":      [5, 1024, "ARC available memory"],
       "waste":      [5, 1024, "Wasted memory due to round up to pagesize"],
   }
   
   v = {}
   hdr = ["time", "read", "ddread", "ddh%", "dmread", "dmh%", "pread", "ph%",
          "size", "c", "avail"]
   xhdr = ["time", "mfu", "mru", "mfug", "mrug", "unc", "eskip", "mtxmis",
           "dread", "pread", "read"]
   sint = 1               # Default interval is 1 second
   count = 1              # Default count is 1
   hdr_intr = 20          # Print header every 20 lines of output
   opfile = None
   sep = "  "              # Default separator is 2 spaces
   l2exist = False
   cmd = ("Usage: arcstat [-havxp] [-f fields] [-o file] [-s string] [interval "
          "[count]]\n")
   cur = {}
   d = {}
   out = None
   kstat = None
   pretty_print = True
   
   
   if sys.platform.startswith('freebsd'):
       # Requires py-sysctl on FreeBSD
       import sysctl
   
       def kstat_update():
           global kstat
   
           k = [ctl for ctl in sysctl.filter('kstat.zfs.misc.arcstats')
                if ctl.type != sysctl.CTLTYPE_NODE]
   
           if not k:
               sys.exit(1)
   
           kstat = {}
   
           for s in k:
               if not s:
                   continue
   
               name, value = s.name, s.value
               # Trims 'kstat.zfs.misc.arcstats' from the name
               kstat[name[24:]] = int(value)
   
   elif sys.platform.startswith('linux'):
       def kstat_update():
           global kstat
   
           k = [line.strip() for line in open('/proc/spl/kstat/zfs/arcstats')]
   
           if not k:
               sys.exit(1)
   
           del k[0:2]
           kstat = {}
   
           for s in k:
               if not s:
                   continue
   
               name, unused, value = s.split()
               kstat[name] = int(value)
   
   
   def detailed_usage():
       sys.stderr.write("%s\n" % cmd)
       sys.stderr.write("Field definitions are as follows:\n")
       for key in cols:
           sys.stderr.write("%11s : %s\n" % (key, cols[key][2]))
       sys.stderr.write("\n")
   
       sys.exit(0)
   
   
   def usage():
       sys.stderr.write("%s\n" % cmd)
       sys.stderr.write("\t -h : Print this help message\n")
       sys.stderr.write("\t -a : Print all possible stats\n")
       sys.stderr.write("\t -v : List all possible field headers and definitions"
                        "\n")
       sys.stderr.write("\t -x : Print extended stats\n")
       sys.stderr.write("\t -f : Specify specific fields to print (see -v)\n")
       sys.stderr.write("\t -o : Redirect output to the specified file\n")
       sys.stderr.write("\t -s : Override default field separator with custom "
                        "character or string\n")
       sys.stderr.write("\t -p : Disable auto-scaling of numerical fields\n")
       sys.stderr.write("\nExamples:\n")
       sys.stderr.write("\tarcstat -o /tmp/a.log 2 10\n")
       sys.stderr.write("\tarcstat -s \",\" -o /tmp/a.log 2 10\n")
       sys.stderr.write("\tarcstat -v\n")
       sys.stderr.write("\tarcstat -f time,hit%,dh%,ph%,mh% 1\n")
       sys.stderr.write("\n")
   
       sys.exit(1)
   
   
   def snap_stats():
       global cur
       global kstat
   
       prev = copy.deepcopy(cur)
       kstat_update()
   
       cur = kstat
       for key in cur:
           if re.match(key, "class"):
               continue
           if key in prev:
               d[key] = cur[key] - prev[key]
           else:
               d[key] = cur[key]
   
   
   def prettynum(sz, scale, num=0):
       suffix = [' ', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']
       index = 0
       save = 0
   
       # Special case for date field
       if scale == -1:
           return "%s" % num
   
       # Rounding error, return 0
       elif 0 < num < 1:
           num = 0
   
       while abs(num) > scale and index < 5:
           save = num
           num = num / scale
           index += 1
   
       if index == 0:
           return "%*d" % (sz, num)
   
       if abs(save / scale) < 10:
           return "%*.1f%s" % (sz - 1, num, suffix[index])
       else:
           return "%*d%s" % (sz - 1, num, suffix[index])
   
   
   def print_values():
       global hdr
       global sep
       global v
       global pretty_print
   
       if pretty_print:
           fmt = lambda col: prettynum(cols[col][0], cols[col][1], v[col])
       else:
           fmt = lambda col: str(v[col])
   
       sys.stdout.write(sep.join(fmt(col) for col in hdr))
       sys.stdout.write("\n")
       sys.stdout.flush()
   
   
   def print_header():
       global hdr
       global sep
       global pretty_print
   
       if pretty_print:
           fmt = lambda col: "%*s" % (cols[col][0], col)
       else:
           fmt = lambda col: col
   
       sys.stdout.write(sep.join(fmt(col) for col in hdr))
       sys.stdout.write("\n")
   
   
   def get_terminal_lines():
       try:
           import fcntl
           import termios
           import struct
           data = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, '1234')
           sz = struct.unpack('hh', data)
           return sz[0]
       except Exception:
           pass
   
   
   def update_hdr_intr():
       global hdr_intr
   
       lines = get_terminal_lines()
       if lines and lines > 3:
           hdr_intr = lines - 3
   
   
   def resize_handler(signum, frame):
       update_hdr_intr()
   
   
   def init():
       global sint
       global count
       global hdr
       global xhdr
       global opfile
       global sep
       global out
       global l2exist
       global pretty_print
   
       desired_cols = None
       aflag = False
       xflag = False
       hflag = False
       vflag = False
       i = 1
   
       try:
           opts, args = getopt.getopt(
               sys.argv[1:],
               "axo:hvs:f:p",
               [
                   "all",
                   "extended",
                   "outfile",
                   "help",
                   "verbose",
                   "separator",
                   "columns",
                   "parsable"
               ]
           )
       except getopt.error as msg:
           sys.stderr.write("Error: %s\n" % str(msg))
           usage()
           opts = None
   
       for opt, arg in opts:
           if opt in ('-a', '--all'):
               aflag = True
           if opt in ('-x', '--extended'):
               xflag = True
           if opt in ('-o', '--outfile'):
               opfile = arg
               i += 1
           if opt in ('-h', '--help'):
               hflag = True
           if opt in ('-v', '--verbose'):
               vflag = True
           if opt in ('-s', '--separator'):
               sep = arg
               i += 1
           if opt in ('-f', '--columns'):
               desired_cols = arg
               i += 1
           if opt in ('-p', '--parsable'):
               pretty_print = False
           i += 1
   
       argv = sys.argv[i:]
       sint = int(argv[0]) if argv else sint
       count = int(argv[1]) if len(argv) > 1 else (0 if len(argv) > 0 else 1)
   
       if hflag or (xflag and desired_cols):
           usage()
   
       if vflag:
           detailed_usage()
   
       if xflag:
           hdr = xhdr
   
       update_hdr_intr()
   
       # check if L2ARC exists
       snap_stats()
       l2_size = cur.get("l2_size")
       if l2_size:
           l2exist = True
   
       if desired_cols:
           hdr = desired_cols.split(",")
   
           invalid = []
           incompat = []
           for ele in hdr:
               if ele not in cols:
                   invalid.append(ele)
               elif not l2exist and ele.startswith("l2"):
                   sys.stdout.write("No L2ARC Here\n%s\n" % ele)
                   incompat.append(ele)
   
           if len(invalid) > 0:
               sys.stderr.write("Invalid column definition! -- %s\n" % invalid)
               usage()
   
           if len(incompat) > 0:
               sys.stderr.write("Incompatible field specified! -- %s\n" %
                                incompat)
               usage()
   
       if aflag:
           if l2exist:
               hdr = cols.keys()
           else:
               hdr = [col for col in cols.keys() if not col.startswith("l2")]
   
       if opfile:
           try:
               out = open(opfile, "w")
               sys.stdout = out
   
           except IOError:
               sys.stderr.write("Cannot open %s for writing\n" % opfile)
               sys.exit(1)
   
   
   def calculate():
       global d
       global v
       global l2exist
   
       v = dict()
       v["time"] = time.strftime("%H:%M:%S", time.localtime())
       v["hits"] = d["hits"] // sint
       v["iohs"] = d["iohits"] // sint
       v["miss"] = d["misses"] // sint
       v["read"] = v["hits"] + v["iohs"] + v["miss"]
       v["hit%"] = 100 * v["hits"] // v["read"] if v["read"] > 0 else 0
       v["ioh%"] = 100 * v["iohs"] // v["read"] if v["read"] > 0 else 0
       v["miss%"] = 100 - v["hit%"] - v["ioh%"] if v["read"] > 0 else 0
   
       v["dhit"] = (d["demand_data_hits"] + d["demand_metadata_hits"]) // sint
       v["dioh"] = (d["demand_data_iohits"] + d["demand_metadata_iohits"]) // sint
       v["dmis"] = (d["demand_data_misses"] + d["demand_metadata_misses"]) // sint
   
       v["dread"] = v["dhit"] + v["dioh"] + v["dmis"]
       v["dh%"] = 100 * v["dhit"] // v["dread"] if v["dread"] > 0 else 0
       v["di%"] = 100 * v["dioh"] // v["dread"] if v["dread"] > 0 else 0
       v["dm%"] = 100 - v["dh%"] - v["di%"] if v["dread"] > 0 else 0
   
       v["ddhit"] = d["demand_data_hits"] // sint
       v["ddioh"] = d["demand_data_iohits"] // sint
       v["ddmis"] = d["demand_data_misses"] // sint
   
       v["ddread"] = v["ddhit"] + v["ddioh"] + v["ddmis"]
       v["ddh%"] = 100 * v["ddhit"] // v["ddread"] if v["ddread"] > 0 else 0
       v["ddi%"] = 100 * v["ddioh"] // v["ddread"] if v["ddread"] > 0 else 0
       v["ddm%"] = 100 - v["ddh%"] - v["ddi%"] if v["ddread"] > 0 else 0
   
       v["dmhit"] = d["demand_metadata_hits"] // sint
       v["dmioh"] = d["demand_metadata_iohits"] // sint
       v["dmmis"] = d["demand_metadata_misses"] // sint
   
       v["dmread"] = v["dmhit"] + v["dmioh"] + v["dmmis"]
       v["dmh%"] = 100 * v["dmhit"] // v["dmread"] if v["dmread"] > 0 else 0
       v["dmi%"] = 100 * v["dmioh"] // v["dmread"] if v["dmread"] > 0 else 0
       v["dmm%"] = 100 - v["dmh%"] - v["dmi%"] if v["dmread"] > 0 else 0
   
       v["phit"] = (d["prefetch_data_hits"] + d["prefetch_metadata_hits"]) // sint
       v["pioh"] = (d["prefetch_data_iohits"] +
                    d["prefetch_metadata_iohits"]) // sint
       v["pmis"] = (d["prefetch_data_misses"] +
                    d["prefetch_metadata_misses"]) // sint
   
       v["pread"] = v["phit"] + v["pioh"] + v["pmis"]
       v["ph%"] = 100 * v["phit"] // v["pread"] if v["pread"] > 0 else 0
       v["pi%"] = 100 * v["pioh"] // v["pread"] if v["pread"] > 0 else 0
       v["pm%"] = 100 - v["ph%"] - v["pi%"] if v["pread"] > 0 else 0
   
       v["pdhit"] = d["prefetch_data_hits"] // sint
       v["pdioh"] = d["prefetch_data_iohits"] // sint
       v["pdmis"] = d["prefetch_data_misses"] // sint
   
       v["pdread"] = v["pdhit"] + v["pdioh"] + v["pdmis"]
       v["pdh%"] = 100 * v["pdhit"] // v["pdread"] if v["pdread"] > 0 else 0
       v["pdi%"] = 100 * v["pdioh"] // v["pdread"] if v["pdread"] > 0 else 0
       v["pdm%"] = 100 - v["pdh%"] - v["pdi%"] if v["pdread"] > 0 else 0
   
       v["pmhit"] = d["prefetch_metadata_hits"] // sint
       v["pmioh"] = d["prefetch_metadata_iohits"] // sint
       v["pmmis"] = d["prefetch_metadata_misses"] // sint
   
       v["pmread"] = v["pmhit"] + v["pmioh"] + v["pmmis"]
       v["pmh%"] = 100 * v["pmhit"] // v["pmread"] if v["pmread"] > 0 else 0
       v["pmi%"] = 100 * v["pmioh"] // v["pmread"] if v["pmread"] > 0 else 0
       v["pmm%"] = 100 - v["pmh%"] - v["pmi%"] if v["pmread"] > 0 else 0
   
       v["mhit"] = (d["prefetch_metadata_hits"] +
                    d["demand_metadata_hits"]) // sint
       v["mioh"] = (d["prefetch_metadata_iohits"] +
                    d["demand_metadata_iohits"]) // sint
       v["mmis"] = (d["prefetch_metadata_misses"] +
                    d["demand_metadata_misses"]) // sint
   
       v["mread"] = v["mhit"] + v["mioh"] + v["mmis"]
       v["mh%"] = 100 * v["mhit"] // v["mread"] if v["mread"] > 0 else 0
       v["mi%"] = 100 * v["mioh"] // v["mread"] if v["mread"] > 0 else 0
       v["mm%"] = 100 - v["mh%"] - v["mi%"] if v["mread"] > 0 else 0
   
       v["arcsz"] = cur["size"]
       v["size"] = cur["size"]
       v["c"] = cur["c"]
       v["mfu"] = d["mfu_hits"] // sint
       v["mru"] = d["mru_hits"] // sint
       v["mrug"] = d["mru_ghost_hits"] // sint
       v["mfug"] = d["mfu_ghost_hits"] // sint
       v["unc"] = d["uncached_hits"] // sint
       v["eskip"] = d["evict_skip"] // sint
       v["el2skip"] = d["evict_l2_skip"] // sint
       v["el2cach"] = d["evict_l2_cached"] // sint
       v["el2el"] = d["evict_l2_eligible"] // sint
       v["el2mfu"] = d["evict_l2_eligible_mfu"] // sint
       v["el2mru"] = d["evict_l2_eligible_mru"] // sint
       v["el2inel"] = d["evict_l2_ineligible"] // sint
       v["mtxmis"] = d["mutex_miss"] // sint
   
       if l2exist:
           v["l2hits"] = d["l2_hits"] // sint
           v["l2miss"] = d["l2_misses"] // sint
           v["l2read"] = v["l2hits"] + v["l2miss"]
           v["l2hit%"] = 100 * v["l2hits"] // v["l2read"] if v["l2read"] > 0 else 0
   
           v["l2miss%"] = 100 - v["l2hit%"] if v["l2read"] > 0 else 0
           v["l2asize"] = cur["l2_asize"]
           v["l2size"] = cur["l2_size"]
           v["l2bytes"] = d["l2_read_bytes"] // sint
   
           v["l2pref"] = cur["l2_prefetch_asize"]
           v["l2mfu"] = cur["l2_mfu_asize"]
           v["l2mru"] = cur["l2_mru_asize"]
           v["l2data"] = cur["l2_bufc_data_asize"]
           v["l2meta"] = cur["l2_bufc_metadata_asize"]
           v["l2pref%"] = 100 * v["l2pref"] // v["l2asize"]
           v["l2mfu%"] = 100 * v["l2mfu"] // v["l2asize"]
           v["l2mru%"] = 100 * v["l2mru"] // v["l2asize"]
           v["l2data%"] = 100 * v["l2data"] // v["l2asize"]
           v["l2meta%"] = 100 * v["l2meta"] // v["l2asize"]
   
       v["grow"] = 0 if cur["arc_no_grow"] else 1
       v["need"] = cur["arc_need_free"]
       v["free"] = cur["memory_free_bytes"]
       v["avail"] = cur["memory_available_bytes"]
       v["waste"] = cur["abd_chunk_waste_size"]
   
   
   def main():
       global sint
       global count
       global hdr_intr
   
       i = 0
       count_flag = 0
   
       init()
       if count > 0:
           count_flag = 1
   
       signal(SIGINT, SIG_DFL)
       signal(SIGWINCH, resize_handler)
       while True:
           if i == 0:
               print_header()
   
           snap_stats()
           calculate()
           print_values()
   
           if count_flag == 1:
               if count <= 1:
                   break
               count -= 1
   
           i = 0 if i >= hdr_intr else i + 1
           time.sleep(sint)
   
       if out:
           out.close()
   
   
   if __name__ == '__main__':
       main()

Cache object: 2637417c12e4a26fe49e921bc6aa4ab7