Call-graph from samples, initial pprof support

PProf importer
Call graphs generation from samples
Kernel stacks collection of Mac
Better java detection
Suspending the execution to make collectors time to ramp up (Mac and Linux)
Better process naming on Mac
More effective handling of ITT strings
Multi-counter support for other formats

Author: araud

InstrumentationExample.cpp

@@ -131,7 +131,7 @@ void workerthread(int data)
 
         if (rand() % 5 == 1)
         {
-            ITT_SCOPE_TRACK(nullptr, "GPU");
+            ITT_SCOPE_TRACK(nullptr, "USER_SCOPE");
             unsigned long long end = TClock::now().time_since_epoch().count();
             unsigned long long length = end - start;
             __itt_task_begin_ex(g_domain, clock_domain, start + length / 4, __itt_null, id, handle_gpu);

buildall.py

@@ -107,6 +107,11 @@ def enum_nodes(curpath, level):
         return enum_nodes(path, depth)
 
 
+def locate_exact(what):
+    items = subprocess.check_output(['locate', what]).decode("utf-8").split('\n')
+    return [item for item in items if item.endswith(what)]
+
+
 def GetJDKPath():
     if sys.platform == 'win32':
         bush = read_registry(r'HKLM\SOFTWARE\JavaSoft\Java Development Kit')
@@ -119,8 +124,21 @@ def GetJDKPath():
         if err or not path:
             return None
         if sys.platform == 'darwin':
-            path = subprocess.check_output("/usr/libexec/java_home").decode("utf-8").split('\n')[0]
-            return path if os.path.exists(path) else None
+            javacs = locate_exact('javac')
+            if not javacs:
+                return None
+            jnis = locate_exact('jni.h')
+            if jnis:
+                longest = {'prefix': '', 'jni': '', 'java': ''}
+                for jni in jnis:
+                    for java in javacs:
+                        prefix = os.path.commonprefix([jni, java])
+                        if len(prefix) > len(longest['prefix']):
+                            longest = {'prefix': prefix, 'jni': jni, 'java': java}
+                return longest['prefix'].rstrip('/')
+            else:
+                path = subprocess.check_output("/usr/libexec/java_home").decode("utf-8").split('\n')[0]
+                return path if os.path.exists(path) else None
         else:
             matches = []
             for root, dirnames, filenames in os.walk('/usr/lib/jvm'):

main.cpp

@@ -271,9 +271,9 @@ int main(int argc, char* argv[])
     const char* api_ver = __itt_api_version();
     VerbosePrint("ITT Version: %s\n", api_ver ? api_ver : "Not loaded");
 
-    std::thread thrd(ChangePaths);
+    //std::thread thrd(ChangePaths); //only for stress testing
     Main(work_seconds);
-    thrd.join();
+    //thrd.join();
     return 0;
 }
 

runtool/collectors/osx.py

@@ -29,8 +29,14 @@
 """
 
 OFF_CPU_STACKS = r"""
-    printf("%x\tstack\t%x\t%x:", machtimestamp, pid, tid);
+    printf("%x\tkstack\t%x\t%x:", machtimestamp, pid, tid);
+    stack();
+    printf("\n%x\tustack\t%x\t%x:", machtimestamp, pid, tid);
     ustack();
+    /*
+    printf("\n%x\tjstack\t%x\t%x:", machtimestamp, pid, tid);
+    jstack(); //TODO: enable better support for jstack-s
+    */
     printf("\n");
 """
 
@@ -70,7 +76,9 @@
 
 """
 
+
 class DTraceCollector(Collector):
+
     def __init__(self, args):
         Collector.__init__(self, args)
         self.pid = None
@@ -142,6 +150,7 @@ def start(self):
                 ('bufresize', 'auto'),
                 ('bufsize', '%dm' % (self.args.ring * 10))
             ]))
+
         dtrace_script.append(dtrace_context_switch)
         dtrace_script.append(self.gen_gpu_hooks(probes))
 
@@ -157,7 +166,7 @@ def start(self):
         with open(script, 'w') as file:
             file.write(dtrace_script)
 
-        proc = subprocess.Popen(cmd, shell=True, stdin=None, stdout=sys.stdout, stderr=sys.stderr, env=os.environ)
+        proc = subprocess.Popen(cmd, shell=True, stdin=None, stdout=self.output, stderr=self.output, env=os.environ)
         self.pid = proc.pid
         self.log(cmd)
         self.log("pid: %d" % proc.pid)

runtool/decoders/SteamVR.py

@@ -126,7 +126,12 @@ def finish_task(self, events, call_data, data, id):
         call_data.update({'str': data, 'type': 0})
         call_data['time'] = self.parser.convert_time(events[id])
         end_data['type'] = 1
-        self.callbacks.complete_task('task', call_data, end_data)
+
+        lane_task = self.callbacks.process(call_data['pid']).\
+            thread(call_data['tid']).lane(call_data['str'], call_data['domain']).\
+            frame_begin(call_data['time'], call_data['str'])
+        lane_task.end(end_data['time'])
+
         del events[id]
 
     @classmethod

runtool/exporters/ChromeTracing.py

@@ -18,7 +18,7 @@ class GoogleTrace(TaskCombiner):
     class ContextSwitch:
         def __init__(self, parent, file):
             self.parent = parent
-            self.file = file
+            self.file = file + '.ftrace'
             self.ftrace = None
 
         def write(self, time, cpu, prev_tid, prev_state, next_tid, prev_prio=0, next_prio=0, prev_name=None, next_name=None):

runtool/exporters/QtCreatorProfiler.py

@@ -70,7 +70,10 @@ def complete_task(self, type, begin, end):
 
         args = {}
         if type == "counter":
-            args['value'] = begin['delta']
+            if 'delta' in begin:
+                args['value'] = begin['delta']
+            else:  # TODO: add multi-value support
+                return
         if begin.has_key('args'):
             args = begin['args']
             if end.has_key('args'):

runtool/importers/etw.py

@@ -876,6 +876,8 @@ def on_event(self, system, data, info):
                 if 'Info' in opcode: return
                 call_data['id'] = int(data['Handle'], 16)
             """
+        elif call_data['str'] in ['AdapterAllocation', 'DeviceAllocation']:  # Microsoft-Windows-DxgKrnl
+            return  # TODO: it might have important information for building memory charts
         else:
             if 'Start' in opcode or 'Stop' in opcode:
                 call_data['id'] = hash(call_data['str'])

runtool/importers/osx.py

@@ -17,11 +17,17 @@ def __init__(self, args, gt, callbacks):
         self.gpu_transition = {}
         self.gpu_frame = {'catch': [0, 0], 'task': None}
         self.prepares = {}
+        self.pid_names = {}
+        self.tid_map = {}
         for callback in self.callbacks.callbacks:
             if 'ContextSwitch' in dir(callback):
                 self.cs = callback.ContextSwitch(callback, args.input + '.ftrace')
             callback("metadata_add", {'domain': 'GPU', 'str': '__process__', 'pid': -1, 'tid': -1, 'data': 'GPU Engines', 'time': 0, 'delta': -2})
 
+    def add_tid_name(self, tid, name):
+        if tid in self.tid_map:
+            self.pid_names[self.tid_map[tid]] = name
+
     def handle_record(self, time, cmd, args):
         if cmd == 'off':
             if not self.cs or not self.callbacks.check_time_in_limits(time):
@@ -33,13 +39,16 @@ def handle_record(self, time, cmd, args):
                 prev_tid = '0'
             if next_prio == '0' and next_name == 'kernel_task':
                 next_tid = '0'
-
+            prev_tid = int(prev_tid, 16)
+            next_tid = int(next_tid, 16)
             self.cs.write(
                 time=time, cpu=int(cpu, 16),
-                prev_tid=int(prev_tid, 16), prev_state='S', next_tid=int(next_tid, 16),
+                prev_tid=prev_tid, prev_state='S', next_tid=next_tid,
                 prev_prio=int(prev_prio, 16), next_prio=int(next_prio, 16),
                 prev_name=prev_name.replace(' ', '_'), next_name=next_name.replace(' ', '_')
             )
+            self.add_tid_name(prev_tid, prev_name)
+            self.add_tid_name(next_tid, next_name)
         elif cmd.startswith('dtHook'):
             if not self.ignore_gpu:
                 pid, tid = args[0:2]
@@ -52,8 +61,10 @@ def handle_record(self, time, cmd, args):
         else:
             print "unsupported cmd:", cmd, args
 
-    def handle_stack(self, time, pid, tid, stack):
+    def handle_stack(self, kind, time, pid, tid, stack):
         pid = int(pid, 16)
+        tid = int(tid, 16)
+        self.tid_map[tid] = pid
         if not self.callbacks.check_time_in_limits(time) or not self.callbacks.check_pid_allowed(pid):
             return
         parsed = []
@@ -63,9 +74,10 @@ def handle_stack(self, time, pid, tid, stack):
                 parsed.append({'ptr': hash(name), 'module': module, 'str': name})
             else:
                 parsed.append({'ptr': int(frame, 16), 'module': '', 'str': ''})
-        self.callbacks.handle_stack(pid, int(tid, 16), time, parsed)
+        self.callbacks.handle_stack(pid, tid, time, parsed, kind)
 
     def task(self, time, pid, tid, starts, domain, name, args):
+        self.tid_map[tid] = pid
         if name in ['IGAccelGLContext::BlitFramebuffer', 'CGLFlushDrawable']:
             self.gpu_frame['catch'][0 if starts else 1] = time
             if name == 'CGLFlushDrawable':
@@ -184,8 +196,10 @@ def gpu_call(self, time, cmd, pid, tid, args):
             pass
         elif 'WriteStamp' == cmd:
             pass
+        elif 'DidFlip' == cmd:
+            pass
         else:
-            print cmd
+            print "Unhandled gpu_call:", cmd
 
     def on_gpu_frame(self, time, pid, tid):
         self.callbacks.on_event("marker", {'pid': pid, 'tid': tid, 'domain': 'gits', 'time': time, 'str': "GPU Frame", 'type': 5, 'data': 'task'})
@@ -195,6 +209,9 @@ def finalize(self):
             for callback in self.callbacks.callbacks:
                 thread_name = name.replace('\\"', '').replace('"', '')
                 callback("metadata_add", {'domain': 'IntelSEAPI', 'str': '__thread__', 'pid': pid, 'tid': tid, 'data': '%s (%d)' % (thread_name, tid)})
+        for pid, name in self.pid_names.iteritems():
+            self.callbacks.set_process_name(pid, name)
+            self.callbacks.set_process_name(-pid, 'Sampling: ' + name)
 
 
 def transform_dtrace(args):
@@ -212,6 +229,8 @@ def transform_dtrace(args):
                 reading_stack = None
                 stack = []
                 for line in file:
+                    count += 1
+                    ends_with_vt = (11 == ord(line[-1])) if len(line) else False
                     line = line.strip()
                     if not line:
                         if reading_stack:
@@ -220,16 +239,19 @@ def transform_dtrace(args):
                             stack = []
                         continue
                     if reading_stack:
-                        stack.append(line)
+                        if ends_with_vt:  # Vertical Tab signifies too long stack frame description
+                            line += '...'
+                            end_of_line = file.readline()  # it is also treated as line end by codecs.open
+                            line += end_of_line.strip()
+                        stack.append(line.replace('\t', ' '))
                         continue
                     parts = line.split('\t')
-                    if parts[1] == 'stack':
-                        reading_stack = [int(parts[0], 16), parts[2], parts[3].rstrip(':')]
+                    if parts[1] in ['ustack', 'kstack', 'jstack']:
+                        reading_stack = [parts[1], int(parts[0], 16), parts[2], parts[3].rstrip(':')]
                         continue
                     dtrace.handle_record(int(parts[0], 16), parts[1], parts[2:])
                     if not count % 1000:
                         progress.tick(file.tell())
-                    count += 1
             dtrace.finalize()
     return callbacks.get_result()