#!/usr/bin/python
|
# Copyright (C) 2019 The Android Open Source Project
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
|
|
# This synthetic trace is designed to test the process tracking logic. It
|
# synthesizes a combination of sched_switch, task_newtask, and process tree
|
# packets (i.e. the result of the userspace /proc/pid scraper).
|
|
from synth_common import CLONE_THREAD
|
import synth_common
|
from os import sys, path
|
|
sys.path.append(path.dirname(path.abspath(__file__)))
|
|
trace = synth_common.create_trace()
|
|
|
# Create the first process (pid=10) with three threads(tids=10,11,12).
|
# In this synthetic trace we will pretend we never saw the start of this threads
|
# (i.e. the task_newtask event). Process association for these threads will
|
# leverage only the /proc/pid scraper.
|
trace.add_ftrace_packet(0)
|
trace.add_sched(ts=1, prev_pid=0, next_pid=10, next_comm='p1-t0')
|
trace.add_sched(ts=2, prev_pid=10, next_pid=11,
|
prev_comm='p1-t0', next_comm='p1-t1')
|
trace.add_sched(ts=3, prev_pid=11, next_pid=12,
|
prev_comm='p1-t1', next_comm='p1-t2')
|
trace.add_sched(ts=4, prev_pid=12, next_pid=0, prev_comm='p1-t2')
|
|
# In the synthetic /proc/pic scraper packet, we pretend we missed p1-1. At the
|
# SQL level we should be able to tell that p1-t0 and p1-t2 belong to 'process1'
|
# but p1-t1 should be left unjoinable.
|
trace.add_process_tree_packet(ts=5)
|
trace.add_process(10, 0, "process1")
|
trace.add_thread(12, 10, "p1-t2")
|
|
# Now create another process (pid=20) with three threads(tids=20,21,22).
|
# This will be slightly more complicated. We'll pretend that tids=20,21 were
|
# created before the start of the trace, and 22 is created only later.
|
trace.add_ftrace_packet(0)
|
trace.add_sched(ts=10, prev_pid=0, next_pid=20, next_comm='p2-t0')
|
trace.add_sched(ts=11, prev_pid=20, next_pid=21,
|
prev_comm='p2-t0', next_comm='p2-t1')
|
trace.add_newtask(ts=12, tid=21, new_tid=22,
|
new_comm='p2-t2', flags=CLONE_THREAD)
|
trace.add_sched(ts=13, prev_pid=21, next_pid=22,
|
prev_comm='p2-t1', next_comm='p2-t2')
|
trace.add_sched(ts=14, prev_pid=22, next_pid=0, prev_comm='p2-t2')
|
|
# From the process tracker viewpoint we pretend we only scraped tids=20,21.
|
trace.add_process_tree_packet(ts=15)
|
trace.add_process(20, 0, "process_2")
|
trace.add_thread(21, 20, "p2-t1")
|
|
# Finally the very complex case: a third process (pid=30) which spawns threads
|
# in the following order (notation: A->B means thread A spawns thread B).
|
# 31->32, 31->33, 32->34.
|
# Last but not least we spawn a further process (pid=40) which spawns a thread
|
# which, unluckily, recycles TID=34. We expect a new UTID for TID=34 then.
|
trace.add_ftrace_packet(0)
|
trace.add_sched(ts=20, prev_pid=0, next_pid=30, next_comm='p3-t0')
|
trace.add_sched(ts=21, prev_pid=30, next_pid=31,
|
prev_comm='p3-t0', next_comm='p3-t1')
|
trace.add_newtask(ts=22, tid=31, new_tid=32,
|
new_comm='p3-t2', flags=CLONE_THREAD)
|
trace.add_newtask(ts=23, tid=31, new_tid=33,
|
new_comm='p3-t3', flags=CLONE_THREAD)
|
trace.add_sched(ts=24, prev_pid=31, next_pid=32,
|
prev_comm='p3-t1', next_comm='p3-t2')
|
trace.add_newtask(ts=25, tid=32, new_tid=34,
|
new_comm='p3-t4', flags=CLONE_THREAD)
|
trace.add_process_tree_packet(ts=26)
|
trace.add_process(30, 0, "process_3")
|
trace.add_thread(31, 30, "p3-t1")
|
|
# This event pretends that TID=32 forks() a new process 40 (note the absence of
|
# CLONE_THREAD in the add_newtask flags).
|
trace.add_ftrace_packet(0)
|
trace.add_newtask(ts=27, tid=32, new_tid=40, new_comm='p4-t0', flags=0)
|
trace.add_sched(ts=28, prev_pid=32, next_pid=40,
|
prev_comm='p3-t2', next_comm='p4-t0')
|
|
trace.add_process_tree_packet(ts=29)
|
trace.add_process(40, 0, "process_4")
|
|
# And now, this new process starts a new thread that recycles TID=31 (previously
|
# used as p3-t1, now becomes p4-t1).
|
trace.add_ftrace_packet(0)
|
trace.add_newtask(ts=30, tid=40, new_tid=31,
|
new_comm='p4-t1', flags=CLONE_THREAD)
|
trace.add_sched(ts=31, prev_pid=40, next_pid=31,
|
prev_comm='p4-t0', next_comm='p4-t1')
|
|
|
print(trace.trace.SerializeToString())
|
