Update some benchmark-running scripts
[bluesky.git] / microbench / workload.py
1 #!/usr/bin/python
2 #
3 # A simple benchmark for Blue Sky that will read and/or write a collection of
4 # files with a specified working set size, and measure the response time to do
5 # so.
6
7 import json, math, os, random, sys, threading, time
8
9 THREADS = 1
10
11 def percentile(rank, elements):
12     """Return the value at a fraction rank from the beginning of the list."""
13
14     # Convert a fraction [0.0, 1.0] to a fractional index in elements.
15     rank = rank * (len(elements) - 1)
16
17     # Round the index value to the nearest integer values, then interpolate.
18     prev = int(math.floor(rank))
19     next = int(math.ceil(rank))
20     frac = rank - prev
21
22     return (1.0 - frac) * elements[prev] + frac * elements[next]
23
24 class WorkerThread:
25     """Performs a mix of file system operations and records the performance."""
26
27     PARAMS = ['duration', 'write_fraction', 'wss_count', 'tot_count',
28               'filesize', 'target_ops']
29
30     def __init__(self):
31         self.stats = []
32         self.duration = 1800.0      # Seconds for which to run
33         self.write_fraction = 0.5   # Fraction of operations which are writes
34         self.wss_count = 2048       # Files in the working set
35         self.tot_count = 2048       # Total number of files created
36         self.filesize = 32 * 1024   # Size of files to work with
37         self.target_ops = 40        # Target operations/second/thread
38
39     def get_params(self):
40         params = {}
41         for p in self.PARAMS:
42             params[p] = getattr(self, p)
43         return params
44
45     def setup(self):
46         for i in range(self.tot_count):
47             filename = "file-%d" % (i,)
48             fp = open(filename, 'w')
49             fp.write('\0' * self.filesize)
50             fp.close()
51
52     def run(self):
53         stop_time = time.time() + self.duration
54
55         while True:
56             time1 = time.time()
57             if time1 >= stop_time: break
58             info = self._operation()
59             time2 = time.time()
60             self.stats.append((time1, time2 - time1, info))
61             #print self.stats[-1]
62             delay = time1 + (1.0 / self.target_ops) - time2
63             if delay > 0: time.sleep(delay)
64
65     def _operation(self):
66         """Run a single file system test (i.e., read or write a file)."""
67
68         filename = "file-%d" % (random.randrange(self.wss_count),)
69
70         if random.uniform(0.0, 1.0) < self.write_fraction:
71             fp = open(filename, 'w')
72             fp.write('\0' * self.filesize)
73             fp.close()
74             return ('write', filename)
75         else:
76             fp = open(filename, 'r')
77             fp.read()
78             fp.close()
79             return ('read', filename)
80
81 def print_distribution_stats(stats):
82     stats = sorted(stats)
83     print "  Count:", len(stats)
84     if len(stats) == 0: return
85     print "  Average:", sum(stats) / len(stats)
86     for (s, p) in [("Min", 0.0), ("Med", 0.5), ("90%", 0.9),
87                    ("95%", 0.95), ("Max", 1.0)]:
88         print "  %s: %s" % (s, percentile(p, stats))
89
90 def run_stats(stats):
91     duration = max(x[0] for x in stats) - min(x[0] for x in stats)
92     latencies = [x[1] for x in stats]
93     latencies.sort()
94     print "Experiment duration:", duration
95     print "READS:"
96     print_distribution_stats([x[1] for x in stats if x[2][0] == 'read'])
97     print "WRITES:"
98     print_distribution_stats([x[1] for x in stats if x[2][0] == 'write'])
99
100 fp = open('/tmp/results.json', 'a')
101
102 def run(filecount, writefrac, filesize):
103     workers = []
104     threads = []
105     for i in range(THREADS):
106         w = WorkerThread()
107         w.write_fraction = writefrac
108         w.wss_count = w.tot_count = filecount
109         w.filesize = filesize
110         if i == 0: w.setup()
111         t = threading.Thread(target=w.run)
112         threads.append(t)
113         workers.append(w)
114         t.start()
115
116     print json.dumps(workers[0].get_params(), indent=2)
117
118     for t in threads:
119         t.join()
120
121     results = []
122     for w in workers:
123         results += w.stats
124     results.sort()
125
126     fp.write(json.dumps(workers[0].get_params(), indent=2) + "\n\n")
127     fp.write(json.dumps(results, indent=2))
128     fp.write("\n\n")
129     run_stats(results)
130
131 if __name__ == '__main__':
132     for filesize in [32, 256, 2048]:            # KiB
133         for totsize in [256, 512, 1024]:        # MiB
134             filecount = totsize * 1024 / filesize
135             for writefrac in [0.0, 0.5]:
136                 run(filecount, writefrac, filesize * 1024)
137     fp.close()