1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
#
# hackbench.py - class to manage an instance of hackbench load
#
# Copyright 2009,2010 Clark Williams <williams@redhat.com>
# Copyright 2009,2010 David Sommerseth <davids@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# For the avoidance of doubt the "preferred form" of this code is one which
# is in an open unpatent encumbered format. Where cryptographic key signing
# forms part of the process of creating an executable the information
# including keys needed to generate an equivalently functional executable
# are deemed to be part of the source code.
#
import sys
import os
import time
import glob
import subprocess
import errno
from signal import SIGTERM
from signal import SIGKILL
sys.pathconf = "."
import load
class Hackbench(load.Load):
def __init__(self, params={}):
load.Load.__init__(self, "hackbench", params)
def __del__(self):
null = open("/dev/null", "w")
subprocess.call(['killall', '-9', 'hackbench'],
stdout=null, stderr=null)
os.close(null)
def setup(self):
'calculate arguments based on input parameters'
(mem, units) = self.memsize
if units == 'KB':
mem = mem / (1024.0 * 1024.0)
elif units == 'MB':
mem = mem / 1024.0
elif units == 'TB':
mem = mem * 1024
ratio = float(mem) / float(self.num_cpus)
if ratio >= 1.0:
mult = int(self.params.setdefault('jobspercore', 2))
else:
print "hackbench: low memory system (%f GB/core)! Not running\n" % ratio
mult = 0
self.jobs = self.num_cpus * mult
self.args = ['hackbench', '-P',
'-g', str(self.jobs),
'-l', str(self.params.setdefault('loops', '100')),
'-s', str(self.params.setdefault('datasize', '100'))
]
self.err_sleep = 5.0
def build(self):
self.ready = True
def runload(self):
# if we don't have any jobs just wait for the stop event and return
if self.jobs == 0:
self.stopevent.wait()
return
null = os.open("/dev/null", os.O_RDWR)
if self.logging:
out = self.open_logfile("hackbench.stdout")
err = self.open_logfile("hackbench.stderr")
else:
out = err = null
self.debug("starting loop (jobs: %d)" % self.jobs)
while not self.stopevent.isSet():
try:
p = subprocess.Popen(self.args, stdin=out, stdout=out, stderr=err)
time.sleep(1.0)
if p.poll() != None:
p.wait()
except OSError, e:
if e.errno != errno.ENOMEM:
raise
# Catch out-of-memory errors and wait a bit to (hopefully)
# ease memory pressure
print "hackbench: %s, sleeping for %f seconds" % (e.strerror, self.err_sleep)
time.sleep(self.err_sleep)
if self.err_sleep < 60.0:
self.err_sleep *= 2.0
if self.err_sleep > 60.0:
self.err_sleep = 60.0
self.debug("stopping")
if p.poll() == None:
os.kill(p.pid, SIGKILL)
p.wait()
self.debug("returning from runload()")
os.close(null)
if self.logging:
os.close(out)
os.close(err)
def genxml(self, x):
x.taggedvalue('command_line', self.jobs and ' '.join(self.args) or None,
{'name':'hackbench', 'run': self.jobs and '1' or '0'})
def create(params = {}):
return Hackbench(params)
if __name__ == '__main__':
h = Hackbench(params={'debugging':True, 'verbose':True})
h.run()
|
