259 lines
8.1 KiB
Python
259 lines
8.1 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
#
|
|
# The contents of this file are subject to the Mozilla Public License Version
|
|
# 1.1 (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.mozilla.org/MPL/
|
|
#
|
|
# Software distributed under the License is distributed on an "AS IS" basis,
|
|
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
# for the specific language governing rights and limitations under the
|
|
# License.
|
|
#
|
|
# The Original Code is standalone Firefox Windows performance test.
|
|
#
|
|
# The Initial Developer of the Original Code is Google Inc.
|
|
# Portions created by the Initial Developer are Copyright (C) 2006
|
|
# the Initial Developer. All Rights Reserved.
|
|
#
|
|
# Contributor(s):
|
|
# Annie Sullivan <annie.sullivan@gmail.com> (original author)
|
|
# Ben Hearsum <bhearsum@wittydomain.com> (ported to linux)
|
|
#
|
|
# Alternatively, the contents of this file may be used under the terms of
|
|
# either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
# in which case the provisions of the GPL or the LGPL are applicable instead
|
|
# of those above. If you wish to allow use of your version of this file only
|
|
# under the terms of either the GPL or the LGPL, and not to allow others to
|
|
# use your version of this file under the terms of the MPL, indicate your
|
|
# decision by deleting the provisions above and replace them with the notice
|
|
# and other provisions required by the GPL or the LGPL. If you do not delete
|
|
# the provisions above, a recipient may use your version of this file under
|
|
# the terms of any one of the MPL, the GPL or the LGPL.
|
|
#
|
|
# ***** END LICENSE BLOCK *****
|
|
|
|
__author__ = 'annie.sullivan@gmail.com (Annie Sullivan)'
|
|
|
|
import subprocess
|
|
import sys
|
|
import os
|
|
import time
|
|
import threading
|
|
|
|
def GetPrivateBytes(pids):
|
|
"""Calculate the amount of private, writeable memory allocated to a process.
|
|
This code was adapted from 'pmap.c', part of the procps project.
|
|
"""
|
|
privateBytes = 0
|
|
for pid in pids:
|
|
mapfile = '/proc/%s/maps' % pid
|
|
maps = open(mapfile)
|
|
|
|
private = 0
|
|
|
|
for line in maps:
|
|
# split up
|
|
(range,line) = line.split(" ", 1)
|
|
|
|
(start,end) = range.split("-")
|
|
flags = line.split(" ", 1)[0]
|
|
|
|
size = int(end, 16) - int(start, 16)
|
|
|
|
if flags.find("p") >= 0:
|
|
if flags.find("w") >= 0:
|
|
private += size
|
|
|
|
privateBytes += private
|
|
maps.close()
|
|
|
|
return privateBytes
|
|
|
|
|
|
def GetResidentSize(pids):
|
|
"""Retrieve the current resident memory for a given process"""
|
|
# for some reason /proc/PID/stat doesn't give accurate information
|
|
# so we use status instead
|
|
|
|
RSS = 0
|
|
for pid in pids:
|
|
file = '/proc/%s/status' % pid
|
|
|
|
status = open(file)
|
|
|
|
for line in status:
|
|
if line.find("VmRSS") >= 0:
|
|
RSS += int(line.split()[1]) * 1024
|
|
|
|
status.close()
|
|
|
|
return RSS
|
|
|
|
def GetCpuTime(pid, sampleTime=1):
|
|
# return all zeros on this platform as per the 7/18/07 perf meeting
|
|
return 0
|
|
|
|
def GetXRes(pids):
|
|
"""Returns the total bytes used by X or raises an error if total bytes is not available"""
|
|
XRes = 0
|
|
for pid in pids:
|
|
try:
|
|
cmdline = "xrestop -m 1 -b | grep -A 15 " + str(pid) + " | tr -d \"\n\" | sed \"s/.*total bytes.*: ~//g\""
|
|
pipe = subprocess.Popen(cmdline, shell=True, stdout=-1).stdout
|
|
data = pipe.read()
|
|
pipe.close()
|
|
except:
|
|
print "Unexpected error:", sys.exc_info()
|
|
raise
|
|
try:
|
|
data = float(data)
|
|
XRes += data
|
|
except:
|
|
print "Invalid data, not a float"
|
|
raise
|
|
|
|
return XRes
|
|
|
|
counterDict = {}
|
|
counterDict["Private Bytes"] = GetPrivateBytes
|
|
counterDict["RSS"] = GetResidentSize
|
|
counterDict["% Processor Time"] = GetCpuTime
|
|
counterDict["XRes"] = GetXRes
|
|
|
|
class CounterManager(threading.Thread):
|
|
"""This class manages the monitoring of a process with any number of
|
|
counters.
|
|
|
|
A counter can be any function that takes an argument of one pid and
|
|
returns a piece of data about that process.
|
|
Some examples are: CalcCPUTime, GetResidentSize, and GetPrivateBytes
|
|
"""
|
|
|
|
pollInterval = .25
|
|
|
|
def __init__(self, ffprocess, process, counters=None, childProcess="mozilla-runtime"):
|
|
"""Args:
|
|
counters: A list of counters to monitor. Any counters whose name does
|
|
not match a key in 'counterDict' will be ignored.
|
|
"""
|
|
self.allCounters = {}
|
|
self.registeredCounters = {}
|
|
self.process = process
|
|
self.childProcess = childProcess
|
|
self.runThread = False
|
|
self.primaryPid = -1
|
|
self.pidList = []
|
|
self.ffprocess = ffprocess
|
|
|
|
self._loadCounters()
|
|
self.registerCounters(counters)
|
|
|
|
threading.Thread.__init__(self)
|
|
|
|
def _loadCounters(self):
|
|
"""Loads all of the counters defined in the counterDict"""
|
|
for counter in counterDict.keys():
|
|
self.allCounters[counter] = counterDict[counter]
|
|
|
|
def registerCounters(self, counters):
|
|
"""Registers a list of counters that will be monitoring.
|
|
Only counters whose names are found in allCounters will be added
|
|
"""
|
|
for counter in counters:
|
|
if counter in self.allCounters:
|
|
self.registeredCounters[counter] = \
|
|
[self.allCounters[counter], []]
|
|
|
|
def unregisterCounters(self, counters):
|
|
"""Unregister a list of counters.
|
|
Only counters whose names are found in registeredCounters will be
|
|
paid attention to
|
|
"""
|
|
for counter in counters:
|
|
if counter in self.registeredCounters:
|
|
del self.registeredCounters[counter]
|
|
|
|
def getRegisteredCounters(self):
|
|
"""Returns a list of the registered counters."""
|
|
return keys(self.registeredCounters)
|
|
|
|
def getCounterValue(self, counterName):
|
|
"""Returns the last value of the counter 'counterName'"""
|
|
try:
|
|
if counterName is "% Processor Time":
|
|
return self._getCounterAverage(counterName)
|
|
else:
|
|
return self.registeredCounters[counterName][1][-1]
|
|
except:
|
|
return None
|
|
|
|
def _getCounterAverage(self, counterName):
|
|
"""Returns the average value of the counter 'counterName'"""
|
|
try:
|
|
total = 0
|
|
for v in self.registeredCounters[counterName][1]:
|
|
total += v
|
|
return total / len(self.registeredCounters[counterName][1])
|
|
except:
|
|
return None
|
|
|
|
def getProcess(self):
|
|
"""Returns the process currently associated with this CounterManager"""
|
|
return self.process
|
|
|
|
def updatePidList(self):
|
|
"""Updates the list of PIDs we're interested in"""
|
|
try:
|
|
self.pidList = [self.primaryPid]
|
|
childPids = self.ffprocess.GetPidsByName(self.childProcess)
|
|
for pid in childPids:
|
|
os.stat('/proc/%s' % pid)
|
|
self.pidList.append(pid)
|
|
except:
|
|
print "WARNING: problem updating child PID's"
|
|
|
|
def startMonitor(self):
|
|
"""Starts the monitoring process.
|
|
Throws an exception if any error occurs
|
|
"""
|
|
# TODO: make this function less ugly
|
|
try:
|
|
# the last process is the useful one
|
|
self.primaryPid = self.ffprocess.GetPidsByName(self.process)[-1]
|
|
os.stat('/proc/%s' % self.primaryPid)
|
|
self.runThread = True
|
|
self.start()
|
|
except:
|
|
print 'WARNING: problem starting counter monitor'
|
|
|
|
def stopMonitor(self):
|
|
"""Stops the monitor"""
|
|
# TODO: should probably wait until we know run() is completely stopped
|
|
# before setting self.pid to None. Use a lock?
|
|
self.runThread = False
|
|
|
|
def run(self):
|
|
"""Performs the actual monitoring of the process. Will keep running
|
|
until stopMonitor() is called
|
|
"""
|
|
while self.runThread:
|
|
self.updatePidList()
|
|
for counter in self.registeredCounters.keys():
|
|
# counter[0] is a function that gets the current value for
|
|
# a counter
|
|
# counter[1] is a list of recorded values
|
|
try:
|
|
self.registeredCounters[counter][1].append(
|
|
self.registeredCounters[counter][0](self.pidList))
|
|
except:
|
|
# if a counter throws an exception, remove it
|
|
#self.unregisterCounters([counter])
|
|
print "Error in collecting counter: " + counter
|
|
|
|
time.sleep(self.pollInterval)
|