Notable upstream pull request merges:
#13805 Configure zed's diagnosis engine with vdev properties
#14110 zfs list: Allow more fields in ZFS_ITER_SIMPLE mode
#14121 Batch enqueue/dequeue for bqueue
#14123 arc_read()/arc_access() refactoring and cleanup
#14159 Bypass metaslab throttle for removal allocations
#14243 Implement uncached prefetch
#14251 Cache dbuf_hash() calculation
#14253 Allow reciever to override encryption property in case of replication
#14254 Restrict visibility of per-dataset kstats inside FreeBSD jails
#14255 Zero end of embedded block buffer in dump_write_embedded()
#14263 Cleanups identified by CodeQL and Coverity
#14264 Miscellaneous fixes
#14272 Change ZEVENT_POOL_GUID to ZEVENT_POOL to display pool names
#14287 FreeBSD: Remove stray debug printf
#14288 Colorize zfs diff output
#14289 deadlock between spa_errlog_lock and dp_config_rwlock
#14291 FreeBSD: Fix potential boot panic with bad label
#14292 Add tunable to allow changing micro ZAP's max size
#14293 Turn default_bs and default_ibs into ZFS_MODULE_PARAMs
#14295 zed: add hotplug support for spare vdevs
#14304 Activate filesystem features only in syncing context
#14311 zpool: do guid-based comparison in is_vdev_cb()
#14317 Pack zrlock_t by 8 bytes
#14320 Update arc_summary and arcstat outputs
#14328 FreeBSD: catch up to 1400077
#14376 Use setproctitle to report progress of zfs send
#14340 Remove some dead ARC code
#14358 Wait for txg sync if the last DRR_FREEOBJECTS might result in a hole
#14360 libzpool: fix ddi_strtoull to update nptr
#14364 Fix unprotected zfs_znode_dmu_fini
#14379 zfs_receive_one: Check for the more likely error first
#14380 Cleanup of dead code suggested by Clang Static Analyzer
#14397 Avoid passing an uninitialized index to dsl_prop_known_index
#14404 Fix reading uninitialized variable in receive_read
#14407 free_blocks(): Fix reports from 2016 PVS Studio FreeBSD report
#14418 Introduce minimal ZIL block commit delay
#14422 x86 assembly: fix .size placement and replace .align with .balign
Obtained from: OpenZFS
OpenZFS commit: 9cd71c8604
638 lines
21 KiB
Plaintext
Executable File
638 lines
21 KiB
Plaintext
Executable File
#!/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()
|