Debian Codegraph @

boottime_tools/io_analysis/check_verity.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 dm_verity trace"""
18 import collections
19 import math
20 import os
21 import re
22 import string
23 import sys
24
25 RE_VERITY = r'.+\s+([0-9]+\.[0-9]+):\s+block_verity_msg:\s+(\S+)\s+([0-9]+)\,([0-9]+)\s+([0-9]+)\s+([0-9]+)'
26
27 def get_average_and_std_dev(l):
28 sum_io = 0.0
29 sum_verity = 0.0
30 sum_total = 0.0
31 N = len(l)
32 sum_blocks = 0.0
33 for e in l:
34 sum_io += e.io_latency
35 sum_verity += e.verity_latency
36 sum_total += e.total_latency
37 sum_blocks += e.size
38 average_io = sum_io / N
39 average_verity = sum_verity / N
40 average_total = sum_total / N
41 var_io = 0.0
42 var_verity = 0.0
43 var_total = 0.0
44 for e in l:
45 var_io += (e.io_latency - average_io)**2
46 var_verity += (e.verity_latency - average_verity)**2
47 var_total += (e.total_latency - average_total)**2
48 sigma_io = math.sqrt(var_io / N)
49 sigma_verity = math.sqrt(var_verity / N)
50 sigma_total = math.sqrt(var_total / N)
51 return (average_io, sigma_io, sum_io), (average_verity, sigma_verity, sum_verity), \
52 (average_total, sigma_total, sum_total), sum_blocks
53
54
55 class Event:
56 def __init__(self, start_time, block_num, size):
57 self.block_num = block_num
58 self.start_time = start_time
59 self.io_end_time = 0
60 self.finish_time = 0
61 self.size = size
62 self.total_latency = 0
63 self.io_latency = 0
64 self.verity_latency = 0
65
66 def set_io_end_time(self, io_end_time):
67 self.io_end_time = io_end_time
68 self.io_latency = io_end_time - self.start_time
69
70 def set_finish_time(self, finish_time):
71 self.finish_time = finish_time
72 self.verity_latency = finish_time - self.io_end_time
73 self.total_latency = finish_time - self.start_time
74
75 class VerityTrace:
76 def __init__(self):
77 self.reads = [] # all events in start time
78 self.block_size_vs_reads_histogram = {} # key: size, value: list of events
79 self.recents = {} # not finished, key: block_nr, value: event
80 self.re = re.compile(RE_VERITY)
81
82 def handle_line(self, line):
83 match = self.re.match(line)
84 if not match:
85 return
86 time = int(float(match.group(1))*1000000) #us
87 step = match.group(2)
88 block_nr = int(match.group(5))
89 size = int(match.group(6))
90 recent_key = block_nr * 1000 + size
91 if step == "map":
92 event = Event(time, block_nr, size)
93 self.recents[recent_key] = event
94 self.reads.append(event)
95 per_size_list = self.block_size_vs_reads_histogram.get(size)
96 if not per_size_list:
97 per_size_list = []
98 self.block_size_vs_reads_histogram[size] = per_size_list
99 per_size_list.append(event)
100 elif step == "end_io":
101 event = self.recents[recent_key]
102 event.set_io_end_time(time)
103 elif step == "finish_io":
104 event = self.recents[recent_key]
105 event.set_finish_time(time)
106 del self.recents[recent_key]
107
108 def dump_list(self, msg, l):
109 io, verity, total, blocks = get_average_and_std_dev(l)
110 print msg, "counts:", len(l), "io latency:", io[0], io[1], io[2], "verity latency:", \
111 verity[0], verity[1], verity[2], "total:", total[0], total[1], total[2]
112 return io, verity, total, blocks
113
114 def dump(self):
115 print "Numbers: average (us), stddev (us), total (us)"
116 io, verity, total, blocks = self.dump_list ("total,", self.reads)
117 io_latency_per_1024KB = io[2] / blocks * (1024 / 4)
118 verity_latency_per_1024KB = verity[2] / blocks * (1024 / 4)
119 total_latency_per_1024KB = io_latency_per_1024KB + verity_latency_per_1024KB
120 print "Average latency for 1024KB (us), IO:", io_latency_per_1024KB, \
121 "Verity:", verity_latency_per_1024KB, "Total:", total_latency_per_1024KB
122 sizes = sorted(self.block_size_vs_reads_histogram.keys())
123 print "Latency per read size"
124 for s in sizes:
125 self.dump_list ("size " + str(s), self.block_size_vs_reads_histogram[s])
126
127 def main(argv):
128 if (len(argv) < 2):
129 print "check_io_trace.py filename"
130 return
131 filename = argv[1]
132 trace = VerityTrace()
133 with open(filename) as f:
134 for l in f:
135 trace.handle_line(l)
136 trace.dump()
137
138 if __name__ == '__main__':
139 main(sys.argv)