Lalit Maganti | 918fe7a | 2019-04-16 20:21:48 +0100 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | # Copyright (C) 2019 The Android Open Source Project |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | # you may not use this file except in compliance with the License. |
| 6 | # You may obtain a copy of the License at |
| 7 | # |
| 8 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | # |
| 10 | # Unless required by applicable law or agreed to in writing, software |
| 11 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | # See the License for the specific language governing permissions and |
| 14 | # limitations under the License. |
| 15 | |
| 16 | import argparse |
| 17 | import logging |
| 18 | import os |
| 19 | import sys |
| 20 | import subprocess |
| 21 | import tempfile |
| 22 | |
| 23 | ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| 24 | ADB_PATH = os.path.join(ROOT_DIR, 'buildtools/android_sdk/platform-tools/adb') |
| 25 | |
| 26 | TEMPLATED_PERFETTO_CFG = ''' |
| 27 | buffers {{ |
| 28 | size_kb: 65536 |
| 29 | fill_policy: RING_BUFFER |
| 30 | }} |
| 31 | data_sources {{ |
| 32 | config {{ |
| 33 | name: "linux.ftrace" |
| 34 | target_buffer: 0 |
| 35 | ftrace_config {{ |
| 36 | ftrace_events: "sched_switch" |
| 37 | buffer_size_kb: {buffer_size_kb} |
| 38 | drain_period_ms: {drain_period_ms} |
| 39 | }} |
| 40 | }} |
| 41 | }} |
| 42 | duration_ms: 15000 |
| 43 | ''' |
| 44 | |
| 45 | PERFETTO_PER_CPU_BUFFER_SIZE_KB_PARAMS = [ |
| 46 | 128, |
| 47 | 256, |
| 48 | 512, |
| 49 | 1 * 1024, # 1 MB |
| 50 | 2 * 1024, # 2 MB |
| 51 | 4 * 1024, # 4 MB |
| 52 | ] |
| 53 | |
| 54 | PERFETTO_DRAIN_RATE_MS_PARAMS = [ |
| 55 | 100, |
| 56 | 240, |
| 57 | 500, |
| 58 | 1 * 1000, # 1s |
| 59 | 2 * 1000, # 2s |
| 60 | 5 * 1000, # 5s |
| 61 | ] |
| 62 | |
| 63 | BUSY_THREADS_NUM_THREADS_PARAMS = [ |
| 64 | 8, |
| 65 | 32, |
| 66 | 128, |
| 67 | ] |
| 68 | |
| 69 | BUSY_THREADS_DUTY_CYCLE_PARAMS = [ |
| 70 | 10, |
| 71 | 100, |
| 72 | ] |
| 73 | |
| 74 | BUSY_THREADS_PERIOD_US_PARAMS = [ |
| 75 | 500, |
| 76 | 1 * 1000, # 1 ms |
| 77 | 10 * 1000, # 10 ms |
| 78 | ] |
| 79 | |
| 80 | TRACE_PROCESSOR_QUERY = """ |
| 81 | SELECT |
| 82 | a.value as num_sched, |
| 83 | b.value as num_overrun |
| 84 | FROM ( |
| 85 | SELECT COUNT(*) as value |
| 86 | FROM sched |
| 87 | ) as a, ( |
| 88 | SELECT SUM(value) as value |
| 89 | FROM stats |
| 90 | WHERE name = 'ftrace_cpu_overrun_end' |
| 91 | ) as b |
| 92 | """ |
| 93 | |
| 94 | def AdbArgs(*args): |
| 95 | cmd = [ADB_PATH] + list([str(x) for x in args]) |
| 96 | logging.debug('> adb ' + ' '.join([str(x) for x in args])) |
| 97 | return cmd |
| 98 | |
| 99 | def AdbCall(*args): |
| 100 | return subprocess.check_output(AdbArgs(*args)).decode('utf-8').rstrip() |
| 101 | |
| 102 | def SingleTraceRun(out_dir, |
| 103 | prio_name, |
| 104 | buffer_size_kb, |
| 105 | drain_rate_ms, |
| 106 | num_threads, |
| 107 | duty_cycle, |
| 108 | period_us): |
| 109 | busy_threads_args = AdbArgs( |
| 110 | 'shell', |
| 111 | '/data/local/tmp/busy_threads', |
| 112 | '--threads={}'.format(num_threads), |
| 113 | '--duty_cycle={}'.format(duty_cycle), |
| 114 | '--period_us={}'.format(period_us) |
| 115 | ) |
| 116 | perfetto_args = AdbArgs( |
| 117 | 'shell', |
| 118 | 'perfetto', |
| 119 | '--txt', |
| 120 | '-c', |
| 121 | '-', |
| 122 | '-o', |
| 123 | '-' |
| 124 | ) |
| 125 | |
| 126 | # Create a file object to read the trace into. |
| 127 | with tempfile.NamedTemporaryFile() as trace_file: |
| 128 | logging.info("Starting trace with parameters ({}, {}, {}, {}, {}, {})" |
| 129 | .format(prio_name, |
| 130 | buffer_size_kb, |
| 131 | drain_rate_ms, |
| 132 | num_threads, |
| 133 | duty_cycle, |
| 134 | period_us)) |
| 135 | |
| 136 | # Start the busy threads running. |
| 137 | busy_threads_handle = subprocess.Popen(busy_threads_args) |
| 138 | |
| 139 | # Start the Perfetto trace. |
| 140 | perfetto_handle = subprocess.Popen( |
| 141 | perfetto_args, stdin=subprocess.PIPE, stdout=trace_file) |
| 142 | |
| 143 | # Create the config with the parameters |
| 144 | config = TEMPLATED_PERFETTO_CFG.format( |
| 145 | buffer_size_kb=buffer_size_kb, drain_period_ms=drain_rate_ms) |
| 146 | |
| 147 | # Send the config to the Perfetto binary and wait for response. |
| 148 | perfetto_handle.stdin.write(config.encode()) |
| 149 | perfetto_handle.stdin.close() |
| 150 | perfetto_ret = perfetto_handle.wait() |
| 151 | |
| 152 | # Stop busy threads from running. |
| 153 | busy_threads_handle.terminate() |
| 154 | |
| 155 | # Return any errors from Perfetto. |
| 156 | if perfetto_ret: |
| 157 | raise subprocess.CalledProcessError( |
| 158 | cmd=perfetto_args, returncode=perfetto_ret) |
| 159 | |
| 160 | # TODO(lalitm): allow trace processor to take the query file from stdin |
| 161 | # to prevent this hack from being required. |
| 162 | with tempfile.NamedTemporaryFile() as trace_query_file: |
| 163 | trace_query_file.file.write(TRACE_PROCESSOR_QUERY.encode()) |
| 164 | trace_query_file.file.flush() |
| 165 | |
| 166 | # Run the trace processor on the config. |
| 167 | tp_path = os.path.join(out_dir, 'trace_processor_shell') |
| 168 | tp_out = subprocess.check_output( |
| 169 | [tp_path, '-q', trace_query_file.name, trace_file.name]) |
| 170 | |
| 171 | # Get the CSV output from trace processor (stripping the header). |
| 172 | [num_sched, num_overrun] = str(tp_out).split('\n')[1].split(',') |
| 173 | |
| 174 | # Print the row to stdout. |
| 175 | sys.stdout.write('"{}",{},{},{},{},{},{},{}\n' |
| 176 | .format(prio_name, |
| 177 | buffer_size_kb, |
| 178 | drain_rate_ms, |
| 179 | num_threads, |
| 180 | duty_cycle, |
| 181 | period_us, |
| 182 | num_sched, |
| 183 | num_overrun)) |
| 184 | |
| 185 | def SinglePriorityRun(out_dir, prio_name): |
| 186 | for buffer_size_kb in PERFETTO_PER_CPU_BUFFER_SIZE_KB_PARAMS: |
| 187 | for drain_rate_ms in PERFETTO_DRAIN_RATE_MS_PARAMS: |
| 188 | for num_threads in BUSY_THREADS_NUM_THREADS_PARAMS: |
| 189 | for duty_cycle in BUSY_THREADS_DUTY_CYCLE_PARAMS: |
| 190 | for period_us in BUSY_THREADS_PERIOD_US_PARAMS: |
| 191 | SingleTraceRun( |
| 192 | out_dir, |
| 193 | prio_name, |
| 194 | buffer_size_kb, |
| 195 | drain_rate_ms, |
| 196 | num_threads, |
| 197 | duty_cycle, |
| 198 | period_us |
| 199 | ) |
| 200 | |
| 201 | def CycleTracedAndProbes(): |
| 202 | AdbCall('shell', 'stop', 'traced') |
| 203 | AdbCall('shell', 'stop', 'traced_probes') |
| 204 | AdbCall('shell', 'start', 'traced') |
| 205 | AdbCall('shell', 'start', 'traced_probes') |
| 206 | AdbCall('shell', 'sleep', '5') |
| 207 | traced_pid = AdbCall('shell', 'pidof', 'traced') |
| 208 | probes_pid = AdbCall('shell', 'pidof', 'traced_probes') |
| 209 | assert(traced_pid is not None and probes_pid is not None) |
| 210 | return (traced_pid, probes_pid) |
| 211 | |
| 212 | def Main(): |
| 213 | parser = argparse.ArgumentParser() |
| 214 | parser.add_argument('linux_out_dir', help='out/android/') |
| 215 | parser.add_argument('android_out_dir', help='out/android/') |
| 216 | args = parser.parse_args() |
| 217 | |
| 218 | # Root ourselves on the device. |
| 219 | logging.info('Waiting for device and rooting ...') |
| 220 | AdbCall('wait-for-device') |
| 221 | AdbCall('root') |
| 222 | AdbCall('wait-for-device') |
| 223 | |
| 224 | # Push busy threads to device |
| 225 | busy_threads_path = os.path.join(args.android_out_dir, 'busy_threads') |
| 226 | AdbCall('shell', 'rm', '-rf', '/data/local/tmp/perfetto_load_test') |
| 227 | AdbCall('shell', 'mkdir', '/data/local/tmp/perfetto_load_test') |
| 228 | AdbCall('push', busy_threads_path, '/data/local/tmp/perfetto_load_test/') |
| 229 | |
| 230 | # Stop and start traced and traced_probes |
| 231 | (traced_pid, probes_pid) = CycleTracedAndProbes() |
| 232 | |
| 233 | # Print the header for csv. |
| 234 | sys.stdout.write('"{}","{}","{}","{}","{}","{}","{}","{}"\n' |
| 235 | .format('prio_name', |
| 236 | 'buffer_size_kb', |
| 237 | 'drain_rate_ms', |
| 238 | 'num_threads', |
| 239 | 'duty_cycle', |
| 240 | 'period_us', |
| 241 | 'num_sched', |
| 242 | 'num_overrun')) |
| 243 | |
| 244 | # First, do a single run in all configurations without changing prio. |
| 245 | SinglePriorityRun(args.linux_out_dir, 'Default') |
| 246 | |
| 247 | # Stop and start traced and traced_probes |
| 248 | (traced_pid, probes_pid) = CycleTracedAndProbes() |
| 249 | |
| 250 | # Setup the nice values and check them. |
| 251 | AdbCall('shell', 'renice', '-n', '-19', '-p', traced_pid) |
| 252 | AdbCall('shell', 'renice', '-n', '-19', '-p', probes_pid) |
| 253 | logging.debug(AdbCall('shell', 'cat', '/proc/{}/stat'.format(traced_pid))) |
| 254 | logging.debug(AdbCall('shell', 'cat', '/proc/{}/stat'.format(probes_pid))) |
| 255 | |
| 256 | # Do the run. |
| 257 | SinglePriorityRun(args.linux_out_dir, '-19 Nice') |
| 258 | |
| 259 | # Stop and start traced and traced_probes |
| 260 | (traced_pid, probes_pid) = CycleTracedAndProbes() |
| 261 | |
| 262 | # Then do a run with FIFO scheduling for traced and traced_probes. |
| 263 | AdbCall('shell', 'chrt', '-f', '-p', traced_pid, '99') |
| 264 | AdbCall('shell', 'chrt', '-f', '-p', probes_pid, '99') |
| 265 | logging.debug(AdbCall('shell', 'chrt', '-p', traced_pid)) |
| 266 | logging.debug(AdbCall('shell', 'chrt', '-p', probes_pid)) |
| 267 | |
| 268 | # Do the run. |
| 269 | SinglePriorityRun(args.linux_out_dir, 'FIFO') |
| 270 | |
| 271 | # Stop and start traced and traced_probes |
| 272 | (traced_pid, probes_pid) = CycleTracedAndProbes() |
| 273 | |
| 274 | # Cleanup any pushed files, priorities etc. |
| 275 | logging.info("Cleaning up test") |
| 276 | AdbCall('shell', 'rm', '-rf', '/data/local/tmp/perfetto_load_test') |
| 277 | logging.debug(AdbCall('shell', 'cat', '/proc/{}/stat'.format(traced_pid))) |
| 278 | logging.debug(AdbCall('shell', 'cat', '/proc/{}/stat'.format(probes_pid))) |
| 279 | AdbCall('unroot') |
| 280 | |
| 281 | return 0 |
| 282 | |
| 283 | if __name__ == '__main__': |
| 284 | logging.basicConfig(level=logging.INFO) |
| 285 | sys.exit(Main()) |