#!/usr/bin/python
#
# Copyright (C) 2010 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import cgi
import csv
import json
import math
import os
import re
import sys
import time
import urllib
"""Interpret output from procstatlog and write an HTML report file."""
# TODO: Rethink dygraph-combined.js source URL?
PAGE_BEGIN = """
%(filename)s
%(filename)s
- stat report generated by %(user)s on %(date)s
"""
CHART = """
| %(label_html)s |
|
"""
SPACER = """
| |
"""
TOTAL_CPU_LABEL = """
Total CPU
jiffies: %(sys)d sys, %(user)d user
"""
CPU_SPEED_LABEL = """
average CPU speed
"""
CONTEXT_LABEL = """
context: %(switches)d switches
"""
FAULTS_LABEL = """
page faults: %(major)d major
"""
BINDER_LABEL = """
binder: %(calls)d calls
"""
PROC_CPU_LABEL = """
%(process)s (%(pid)d)
jiffies: %(sys)d sys, %(user)d user
"""
YAFFS_LABEL = """
yaffs: %(partition)s
pages: %(nPageReads)d read,
%(nPageWrites)d written
blocks: %(nBlockErasures)d erased
"""
DISK_LABEL = """
disk: %(device)s
sectors: %(reads)d read, %(writes)d written
"""
DISK_TIME_LABEL = """
msec: %(msec)d waiting
"""
NET_LABEL = """
net: %(interface)s
bytes: %(tx)d tx,
%(rx)d rx
"""
PAGE_END = """
"""
def WriteChartData(titles, datasets, filename):
writer = csv.writer(file(filename, "w"))
writer.writerow(["Time"] + titles)
merged_rows = {}
for set_num, data in enumerate(datasets):
for when, datum in data.iteritems():
if type(datum) == tuple: datum = "%d/%d" % datum
merged_rows.setdefault(when, {})[set_num] = datum
num_cols = len(datasets)
for when, values in sorted(merged_rows.iteritems()):
msec = "%d" % (when * 1000)
writer.writerow([msec] + [values.get(n, "") for n in range(num_cols)])
def WriteOutput(history, log_filename, filename):
out = []
out.append(PAGE_BEGIN % {
"filename": cgi.escape(log_filename),
"user": cgi.escape(os.environ.get("USER", "unknown")),
"date": cgi.escape(time.ctime()),
})
files_dir = "%s_files" % os.path.splitext(filename)[0]
files_url = os.path.basename(files_dir)
if not os.path.isdir(files_dir): os.makedirs(files_dir)
sorted_history = sorted(history.iteritems())
date_window = [1000 * sorted_history[1][0], 1000 * sorted_history[-1][0]]
#
# Output total CPU statistics
#
sys_jiffies = {}
sys_user_jiffies = {}
all_jiffies = {}
total_sys = total_user = 0
last_state = {}
for when, state in sorted_history:
last = last_state.get("/proc/stat:cpu", "").split()
next = state.get("/proc/stat:cpu", "").split()
if last and next:
stime = sum([int(next[x]) - int(last[x]) for x in [2, 5, 6]])
utime = sum([int(next[x]) - int(last[x]) for x in [0, 1]])
idle = sum([int(next[x]) - int(last[x]) for x in [3, 4]])
all = stime + utime + idle
total_sys += stime
total_user += utime
sys_jiffies[when] = (stime, all)
sys_user_jiffies[when] = (stime + utime, all)
all_jiffies[when] = all
last_state = state
WriteChartData(
["sys", "sys+user"],
[sys_jiffies, sys_user_jiffies],
os.path.join(files_dir, "total_cpu.csv"))
out.append(CHART % {
"id": cgi.escape("total_cpu"),
"id_js": json.write("total_cpu"),
"label_html": TOTAL_CPU_LABEL % {"sys": total_sys, "user": total_user},
"filename_js": json.write(files_url + "/total_cpu.csv"),
"options_js": json.write({
"colors": ["blue", "green"],
"dateWindow": date_window,
"fillGraph": True,
"fractions": True,
"height": 100,
"valueRange": [0, 110],
}),
})
#
# Output CPU speed statistics
#
cpu_speed = {}
speed_key = "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state:"
last_state = {}
for when, state in sorted_history:
total_time = total_cycles = 0
for key in state:
if not key.startswith(speed_key): continue
last = int(last_state.get(key, -1))
next = int(state.get(key, -1))
if last != -1 and next != -1:
speed = int(key[len(speed_key):])
total_time += next - last
total_cycles += (next - last) * speed
if total_time > 0: cpu_speed[when] = total_cycles / total_time
last_state = state
WriteChartData(
["kHz"], [cpu_speed],
os.path.join(files_dir, "cpu_speed.csv"))
out.append(CHART % {
"id": cgi.escape("cpu_speed"),
"id_js": json.write("cpu_speed"),
"label_html": CPU_SPEED_LABEL,
"filename_js": json.write(files_url + "/cpu_speed.csv"),
"options_js": json.write({
"colors": ["navy"],
"dateWindow": date_window,
"fillGraph": True,
"height": 50,
"includeZero": True,
}),
})
#
# Output total context switch statistics
#
context_switches = {}
last_state = {}
for when, state in sorted_history:
last = int(last_state.get("/proc/stat:ctxt", -1))
next = int(state.get("/proc/stat:ctxt", -1))
if last != -1 and next != -1: context_switches[when] = next - last
last_state = state
WriteChartData(
["switches"], [context_switches],
os.path.join(files_dir, "context_switches.csv"))
total_switches = sum(context_switches.values())
out.append(CHART % {
"id": cgi.escape("context_switches"),
"id_js": json.write("context_switches"),
"label_html": CONTEXT_LABEL % {"switches": total_switches},
"filename_js": json.write(files_url + "/context_switches.csv"),
"options_js": json.write({
"colors": ["blue"],
"dateWindow": date_window,
"fillGraph": True,
"height": 50,
"includeZero": True,
}),
})
#
# Collect (no output yet) per-process CPU and major faults
#
process_name = {}
process_start = {}
process_sys = {}
process_sys_user = {}
process_faults = {}
total_faults = {}
max_faults = 0
last_state = {}
zero_stat = "0 (zero) Z 0 0 0 0 0 0 0 0 0 0 0 0"
for when, state in sorted_history:
for key in state:
if not key.endswith("/stat"): continue
last = last_state.get(key, zero_stat).split()
next = state.get(key, "").split()
if not next: continue
pid = int(next[0])
process_start.setdefault(pid, when)
process_name[pid] = next[1][1:-1]
all = all_jiffies.get(when, 0)
if not all: continue
faults = int(next[11]) - int(last[11])
process_faults.setdefault(pid, {})[when] = faults
tf = total_faults[when] = total_faults.get(when, 0) + faults
max_faults = max(max_faults, tf)
stime = int(next[14]) - int(last[14])
utime = int(next[13]) - int(last[13])
process_sys.setdefault(pid, {})[when] = (stime, all)
process_sys_user.setdefault(pid, {})[when] = (stime + utime, all)
last_state = state
#
# Output total major faults (sum over all processes)
#
WriteChartData(
["major"], [total_faults],
os.path.join(files_dir, "total_faults.csv"))
out.append(CHART % {
"id": cgi.escape("total_faults"),
"id_js": json.write("total_faults"),
"label_html": FAULTS_LABEL % {"major": sum(total_faults.values())},
"filename_js": json.write(files_url + "/total_faults.csv"),
"options_js": json.write({
"colors": ["gray"],
"dateWindow": date_window,
"fillGraph": True,
"height": 50,
"valueRange": [0, max_faults * 11 / 10],
}),
})
#
# Output binder transaactions
#
binder_calls = {}
last_state = {}
for when, state in sorted_history:
last = int(last_state.get("/proc/binder/stats:BC_TRANSACTION", -1))
next = int(state.get("/proc/binder/stats:BC_TRANSACTION", -1))
if last != -1 and next != -1: binder_calls[when] = next - last
last_state = state
WriteChartData(
["calls"], [binder_calls],
os.path.join(files_dir, "binder_calls.csv"))
out.append(CHART % {
"id": cgi.escape("binder_calls"),
"id_js": json.write("binder_calls"),
"label_html": BINDER_LABEL % {"calls": sum(binder_calls.values())},
"filename_js": json.write(files_url + "/binder_calls.csv"),
"options_js": json.write({
"colors": ["green"],
"dateWindow": date_window,
"fillGraph": True,
"height": 50,
"includeZero": True,
})
})
#
# Output network interface statistics
#
if out[-1] != SPACER: out.append(SPACER)
interface_rx = {}
interface_tx = {}
max_bytes = 0
last_state = {}
for when, state in sorted_history:
for key in state:
if not key.startswith("/proc/net/dev:"): continue
last = last_state.get(key, "").split()
next = state.get(key, "").split()
if not (last and next): continue
rx = int(next[0]) - int(last[0])
tx = int(next[8]) - int(last[8])
max_bytes = max(max_bytes, rx, tx)
net, interface = key.split(":", 1)
interface_rx.setdefault(interface, {})[when] = rx
interface_tx.setdefault(interface, {})[when] = tx
last_state = state
for num, interface in enumerate(sorted(interface_rx.keys())):
rx, tx = interface_rx[interface], interface_tx[interface]
total_rx, total_tx = sum(rx.values()), sum(tx.values())
if not (total_rx or total_tx): continue
WriteChartData(
["rx", "tx"], [rx, tx],
os.path.join(files_dir, "net%d.csv" % num))
out.append(CHART % {
"id": cgi.escape("net%d" % num),
"id_js": json.write("net%d" % num),
"label_html": NET_LABEL % {
"interface": cgi.escape(interface),
"rx": total_rx,
"tx": total_tx
},
"filename_js": json.write("%s/net%d.csv" % (files_url, num)),
"options_js": json.write({
"colors": ["black", "purple"],
"dateWindow": date_window,
"fillGraph": True,
"height": 75,
"valueRange": [0, max_bytes * 11 / 10],
})
})
#
# Output YAFFS statistics
#
if out[-1] != SPACER: out.append(SPACER)
yaffs_vars = ["nBlockErasures", "nPageReads", "nPageWrites"]
partition_ops = {}
last_state = {}
for when, state in sorted_history:
for key in state:
if not key.startswith("/proc/yaffs:"): continue
last = int(last_state.get(key, -1))
next = int(state.get(key, -1))
if last == -1 or next == -1: continue
value = next - last
yaffs, partition, var = key.split(":", 2)
ops = partition_ops.setdefault(partition, {})
if var in yaffs_vars:
ops.setdefault(var, {})[when] = value
last_state = state
for num, (partition, ops) in enumerate(sorted(partition_ops.iteritems())):
totals = [sum(ops.get(var, {}).values()) for var in yaffs_vars]
if not sum(totals): continue
WriteChartData(
yaffs_vars,
[ops.get(var, {}) for var in yaffs_vars],
os.path.join(files_dir, "yaffs%d.csv" % num))
values = {"partition": partition}
values.update(zip(yaffs_vars, totals))
out.append(CHART % {
"id": cgi.escape("yaffs%d" % num),
"id_js": json.write("yaffs%d" % num),
"label_html": YAFFS_LABEL % values,
"filename_js": json.write("%s/yaffs%d.csv" % (files_url, num)),
"options_js": json.write({
"colors": ["maroon", "gray", "teal"],
"dateWindow": date_window,
"fillGraph": True,
"height": 75,
"includeZero": True,
})
})
#
# Output non-YAFFS statistics
#
disk_reads = {}
disk_writes = {}
disk_msec = {}
total_io = max_io = max_msec = 0
last_state = {}
for when, state in sorted_history:
for key in state:
if not key.startswith("/proc/diskstats:"): continue
last = last_state.get(key, "").split()
next = state.get(key, "").split()
if not (last and next): continue
reads = int(next[2]) - int(last[2])
writes = int(next[6]) - int(last[6])
msec = int(next[10]) - int(last[10])
total_io += reads + writes
max_io = max(max_io, reads, writes)
max_msec = max(max_msec, msec)
diskstats, device = key.split(":", 1)
disk_reads.setdefault(device, {})[when] = reads
disk_writes.setdefault(device, {})[when] = writes
disk_msec.setdefault(device, {})[when] = msec
last_state = state
io_cutoff = total_io / 100
for num, device in enumerate(sorted(disk_reads.keys())):
if [d for d in disk_reads.keys()
if d.startswith(device) and d != device]: continue
reads, writes = disk_reads[device], disk_writes[device]
total_reads, total_writes = sum(reads.values()), sum(writes.values())
if total_reads + total_writes <= io_cutoff: continue
WriteChartData(
["reads", "writes"], [reads, writes],
os.path.join(files_dir, "disk%d.csv" % num))
out.append(CHART % {
"id": cgi.escape("disk%d" % num),
"id_js": json.write("disk%d" % num),
"label_html": DISK_LABEL % {
"device": cgi.escape(device),
"reads": total_reads,
"writes": total_writes,
},
"filename_js": json.write("%s/disk%d.csv" % (files_url, num)),
"options_js": json.write({
"colors": ["gray", "teal"],
"dateWindow": date_window,
"fillGraph": True,
"height": 75,
"valueRange": [0, max_io * 11 / 10],
}),
})
msec = disk_msec[device]
WriteChartData(
["msec"], [msec],
os.path.join(files_dir, "disk%d_time.csv" % num))
out.append(CHART % {
"id": cgi.escape("disk%d_time" % num),
"id_js": json.write("disk%d_time" % num),
"label_html": DISK_TIME_LABEL % {"msec": sum(msec.values())},
"filename_js": json.write("%s/disk%d_time.csv" % (files_url, num)),
"options_js": json.write({
"colors": ["blue"],
"dateWindow": date_window,
"fillGraph": True,
"height": 50,
"valueRange": [0, max_msec * 11 / 10],
}),
})
#
# Output per-process CPU and page faults collected earlier
#
cpu_cutoff = (total_sys + total_user) / 200
faults_cutoff = sum(total_faults.values()) / 100
for start, pid in sorted([(s, p) for p, s in process_start.iteritems()]):
sys = sum([n for n, d in process_sys.get(pid, {}).values()])
sys_user = sum([n for n, d in process_sys_user.get(pid, {}).values()])
if sys_user <= cpu_cutoff: continue
if out[-1] != SPACER: out.append(SPACER)
WriteChartData(
["sys", "sys+user"],
[process_sys.get(pid, {}), process_sys_user.get(pid, {})],
os.path.join(files_dir, "proc%d.csv" % pid))
out.append(CHART % {
"id": cgi.escape("proc%d" % pid),
"id_js": json.write("proc%d" % pid),
"label_html": PROC_CPU_LABEL % {
"pid": pid,
"process": cgi.escape(process_name.get(pid, "(unknown)")),
"sys": sys,
"user": sys_user - sys,
},
"filename_js": json.write("%s/proc%d.csv" % (files_url, pid)),
"options_js": json.write({
"colors": ["blue", "green"],
"dateWindow": date_window,
"fillGraph": True,
"fractions": True,
"height": 75,
"valueRange": [0, 110],
}),
})
faults = sum(process_faults.get(pid, {}).values())
if faults <= faults_cutoff: continue
WriteChartData(
["major"], [process_faults.get(pid, {})],
os.path.join(files_dir, "proc%d_faults.csv" % pid))
out.append(CHART % {
"id": cgi.escape("proc%d_faults" % pid),
"id_js": json.write("proc%d_faults" % pid),
"label_html": FAULTS_LABEL % {"major": faults},
"filename_js": json.write("%s/proc%d_faults.csv" % (files_url, pid)),
"options_js": json.write({
"colors": ["gray"],
"dateWindow": date_window,
"fillGraph": True,
"height": 50,
"valueRange": [0, max_faults * 11 / 10],
}),
})
out.append(PAGE_END)
file(filename, "w").write("\n".join(out))
def main(argv):
if len(argv) != 3:
print >>sys.stderr, "usage: procstatreport.py procstat.log output.html"
return 2
history = {}
current_state = {}
scan_time = 0.0
for line in file(argv[1]):
if not line.endswith("\n"): continue
parts = line.split(None, 2)
if len(parts) < 2 or parts[1] not in "+-=":
print >>sys.stderr, "Invalid input:", line
sys.exit(1)
name, op = parts[:2]
if name == "T" and op == "+": # timestamp: scan about to begin
scan_time = float(line[4:])
continue
if name == "T" and op == "-": # timestamp: scan complete
time = (scan_time + float(line[4:])) / 2.0
history[time] = dict(current_state)
elif op == "-":
if name in current_state: del current_state[name]
else:
current_state[name] = "".join(parts[2:]).strip()
if len(history) < 2:
print >>sys.stderr, "error: insufficient history to chart"
return 1
WriteOutput(history, argv[1], argv[2])
if __name__ == "__main__":
sys.exit(main(sys.argv))