Debian Codegraph @

boottime_tools/io_analysis/check_io_trace.py

raw
1 #!/usr/bin/env python
2 #
3 # Copyright (C) 2016 The Android Open Source Project
4 #
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
8 #
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16 #
17 """Analyze block trace"""
18
19 import collections
20 import os
21 import re
22 import string
23 import sys
24
25 RE_BLOCK = r'.+\s+(block[a-z_]+):\s+'
26 RE_BLOCK_BIO_QUEUE = r'.+\s+([0-9]+\.[0-9]+):\s+block_bio_queue:\s+([0-9]+)\,([0-9]+)\s+([RW]\S*)\s+([0-9]+)\s+\+\s+([0-9]+)\s+\[([^\]]+)'
27
28 # dev_num = major * MULTIPLIER + minor
29 DEV_MAJOR_MULTIPLIER = 1000
30
31 # dm access is remapped to disk access. So account differently
32 DM_MAJOR = 253
33
34 class RwEvent:
35 def __init__(self, block_num, start_time, size):
36 self.block_num = block_num
37 self.start_time = start_time
38 self.size = size
39 self.latency = 0
40 def set_latency(self, latency):
41 self.latency = latency
42
43 def get_string_pos(strings, string_to_find):
44 for i, s in enumerate(strings):
45 if s == string_to_find:
46 return i
47 return -1
48
49
50 class Trace:
51 def __init__(self, process):
52 self.process = process
53 self.reads = [] #(start time, RwEvent)
54 self.writes = [] #(start time, RwEvent)
55 self.recent_reads = {} # K:
56 self.total_latency = 0
57 self.total_reads = 0
58 self.total_writes = 0
59 self.total_dm_reads = {} #K: devnum, V: blocks
60 self.total_dm_writes = {}
61 self.re_block_queue = re.compile(RE_BLOCK_BIO_QUEUE)
62 self.processes = set()
63 if process[-1] == '*':
64 print "Process name starts with", process[:-1]
65 self.process_name_is_prefix = True
66 else:
67 print "Process name", process
68 self.process_name_is_prefix = False
69
70 def parse_bio_queue(self, l):
71 match = self.re_block_queue.match(l)
72 if not match:
73 return
74 start_time = int(float(match.group(1))*1000000) #us
75 major = int(match.group(2))
76 minor = int(match.group(3))
77 operation = match.group(4)
78 block_num = int(match.group(5))
79 size = int(match.group(6))
80 process = match.group(7)
81 if self.process_name_is_prefix:
82 if not process.startswith(self.process[:-1]):
83 return
84 self.processes.add(process)
85 else:
86 if process != self.process:
87 return
88 if major == DM_MAJOR:
89 devNum = major * DEV_MAJOR_MULTIPLIER + minor;
90 if operation[0] == 'R':
91 if devNum not in self.total_dm_reads:
92 self.total_dm_reads[devNum] = 0
93 self.total_dm_reads[devNum] += size
94 elif operation[0] == 'W':
95 if devNum not in self.total_dm_writes:
96 self.total_dm_writes[devNum] = 0
97 self.total_dm_writes[devNum] += size
98 return
99 event = RwEvent(block_num, start_time, size)
100 if operation[0] == 'R':
101 self.reads.append((start_time, event))
102 self.recent_reads[block_num] = event
103 self.total_reads += size
104 elif operation[0] == 'W':
105 self.writes.append((start_time, event))
106 self.total_writes += size
107
108 def parse_rq_complete(self, l):
109 words = string.split(l)
110 cmd_pos = get_string_pos(words, "block_rq_complete:")
111 if cmd_pos == -1:
112 cmd_pos = get_string_pos(words, "block_bio_complete:")
113 block_num = int(words[-4])
114 event = self.recent_reads.get(block_num)
115 if not event:
116 return
117 operation = words[cmd_pos + 2]
118 if not operation.startswith("R"):
119 return
120 end_time = int(float(words[cmd_pos - 1][:-1])*1000000) #us
121 latency = end_time - event.start_time
122 if latency > 20000:
123 print "very bad latency:", latency, l
124 print "start time,", event.start_time
125 event.set_latency(latency)
126 del self.recent_reads[block_num]
127 self.total_latency += latency
128
129 def parse_block_trace(self, l, match):
130 try:
131 cmd = match.group(1)
132 if cmd == "block_bio_queue":
133 self.parse_bio_queue(l)
134 elif cmd == "block_rq_complete" or cmd == "block_bio_complete":
135 self.parse_rq_complete(l)
136 except ValueError:
137 print "cannot parse:", l
138 raise
139
140 def dump(self):
141 if self.process_name_is_prefix:
142 print "Processes:", self.processes
143 print "total read blocks,", self.total_reads
144 print "total write blocks,", self.total_writes
145 if len(self.reads) > 0:
146 total_read_time = self.reads[-1][0] + self.reads[-1][1].latency - self.reads[0][0]
147 else:
148 total_read_time = 0
149 print "Total DM R"
150 for dev,size in self.total_dm_reads.items():
151 print dev, size
152 print "Total DM W"
153 for dev,size in self.total_dm_writes.items():
154 print dev, size
155 print "total read time,",total_read_time
156 read_size_histogram = {}
157 latency_per_read_size = {}
158 for (time, event) in self.reads:
159 if not read_size_histogram.get(event.size):
160 read_size_histogram[event.size] = 0
161 if not latency_per_read_size.get(event.size):
162 latency_per_read_size[event.size] = [ 0, 0] # num events, total latency
163 read_size_histogram[event.size] = read_size_histogram[event.size] + 1
164 latency_sum = latency_per_read_size[event.size]
165 latency_sum[0] += 1
166 latency_sum[1] += event.latency
167 read_size_histogram = collections.OrderedDict(sorted(read_size_histogram.items()))
168 print "read histogram"
169 for k,v in read_size_histogram.iteritems():
170 print k, ',', v
171 print "latency per read size"
172 latency_per_read_size = collections.OrderedDict(sorted(latency_per_read_size.items()))
173 for k,v in latency_per_read_size.iteritems():
174 if v[0] != 0:
175 print k, ',', v[1] / v[0], v[0], v[1]
176
177 def main(argv):
178 if (len(argv) < 3):
179 print "check_io_trace.py processname filename"
180 return
181 keyword = argv[1]
182 filename = argv[2]
183 trace = Trace(keyword)
184 prog = re.compile(RE_BLOCK)
185 with open(filename) as f:
186 for l in f:
187 result = prog.match(l)
188 if result:
189 trace.parse_block_trace(l, result)
190 trace.dump()
191
192 if __name__ == '__main__':
193 main(sys.argv)