Fix alignment DCP names.

[dcpomatic.git] / hacks / analog.py

diff --git a/hacks/analog.py b/hacks/analog.py
index 4fc1dda843bbc14f118991c1bc64ac9c6d785b84..51d8a96390577638a36e36c447d997041b4247bb 100644 (file)
--- a/hacks/analog.py
+++ b/hacks/analog.py
@@ -54,19 +54,31 @@ class Time:
         else:
             return Time(self.seconds - x.seconds, m)
 
+class EncoderThread:
+    def __init__(self, id):
+        self.id = id
+        self.events = []
+        self.server = None
+
+    def add_event(self, time, message, values):
+        self.events.append((time, message, values))
+
 queue_size = []
 general_events = []
 encoder_threads = []
-encoder_thread_events = dict()
 
-def add_encoder_thread_event(thread, time, event):
+def find_encoder_thread(id):
     global encoder_threads
-    global encoder_thread_events
-    if not thread in encoder_threads:
+    thread = None
+    for t in encoder_threads:
+        if t.id == id:
+            thread = t
+
+    if thread is None:
+        thread = EncoderThread(id)
         encoder_threads.append(thread)
-        encoder_thread_events[thread] = [(time, event)]
-    else:
-        encoder_thread_events[thread].append((time, event))
+
+    return thread
 
 def add_general_event(time, event):
     global general_events
@@ -109,8 +121,8 @@ while True:
     # Not-so-human-readable log messages (LOG_TIMING)
     if message == 'add-frame-to-queue':
         queue_size.append((T, values['queue']))
-    elif message in ['encoder-sleep', 'encoder-wake', 'start-local-encode', 'finish-local-encode', 'start-remote-send', 'finish-remote-send', 'start-remote-encode-and-receive', 'finish-remote-encode-and-receive']:
-        add_encoder_thread_event(values['thread'], T, message)
+    elif message in ['encoder-sleep', 'encoder-wake', 'start-local-encode', 'finish-local-encode', 'start-remote-send', 'start-remote-encode', 'start-remote-receive', 'finish-remote-receive', 'start-encoder-thread']:
+        find_encoder_thread(values['thread']).add_event(T, message, values)
     # Human-readable log message (other LOG_*)
     elif message.startswith('Finished locally-encoded'):
         add_general_event(T, 'end_local_encode')
@@ -141,12 +153,12 @@ elif args.encoder_threads:
     plt.figure()
     N = len(encoder_thread_events)
     n = 1
-    for thread, events in encoder_thread_events.iteritems():
+    for thread in encoder_threads:
         plt.subplot(N, 1, n)
         x = []
         y = []
         previous = 0
-        for e in events:
+        for e in thread.events:
             if args.from_time is not None and e[0].float_seconds() <= args.from_time:
                 continue
             if args.to_time is not None and e[0].float_seconds() >= args.to_time:
@@ -172,9 +184,9 @@ elif args.encoder_threads:
 
 elif args.plot_first_encoder:
     plt.figure()
-    N = len(encoder_thread_events)
+    N = len(encoder_threads)
     n = 1
-    events = encoder_thread_events.itervalues().next()
+    events = encoder_threads[0].events
 
     N = 6
     n = 1
@@ -234,24 +246,51 @@ elif args.fps_stats:
     print '%.2f fps local and %.2f fps remote' % (local / duration.float_seconds(), remote / duration.float_seconds())
 
 elif args.encoder_stats:
-
+    # Broad stats on what encoder threads spent their time doing
     for t in encoder_threads:
         last = None
         asleep = Time()
-        encoding = Time()
+        local_encoding = Time()
+        sending = Time()
+        remote_encoding = Time()
+        receiving = Time()
         wakes = 0
-        for e in encoder_thread_events[t]:
-            if e[1] == 'encoder-sleep':
-                if last is not None:
-                    encoding += e[0] - last
-                last = e[0]
-            elif e[1] == 'encoder-wake':
-                wakes += 1
-                asleep += e[0] - last
-                last = e[0]
-
-        print '-- Encoder thread %s' % t
-        print 'Awoken %d times' % wakes
-        total = asleep.float_seconds() + encoding.float_seconds()
-        print 'Asleep: %s (%s%%)' % (asleep, asleep.float_seconds() * 100 / total)
-        print 'Encoding: %s (%s%%)' % (encoding, encoding.float_seconds() * 100 / total)
+        for e in t.events:
+            if last is not None:
+                if last[1] == 'encoder-sleep':
+                    asleep += e[0] - last[0]
+                elif last[1] == 'encoder-wake':
+                    wakes += 1
+                elif last[1] == 'start-local-encode':
+                    local_encoding += e[0] - last[0]
+                elif last[1] == 'start-remote-send':
+                    sending += e[0] - last[0]
+                elif last[1] == 'start-remote-encode':
+                    remote_encoding += e[0] - last[0]
+                elif last[1] == 'start-remote-receive':
+                    receiving += e[0] - last[0]
+                elif last[1] == 'start-encoder-thread':
+                    find_encoder_thread(last[2]['thread']).server = last[2]['server']
+
+            last = e
+
+        print '-- Encoder thread %s (%s)' % (t.server, t.id)
+        print '\tAwoken %d times' % wakes
+
+        total = asleep.float_seconds() + local_encoding.float_seconds() + sending.float_seconds() + remote_encoding.float_seconds() + receiving.float_seconds()
+        if total == 0:
+            continue
+
+        print '\t%s: %2.f%%' % ('Asleep'.ljust(16), asleep.float_seconds() * 100 / total)
+
+        def print_with_fps(v, name, total, frames):
+            if v.float_seconds() > 1:
+                print '\t%s: %2.f%% %.2ffps' % (name.ljust(16), v.float_seconds() * 100 / total, frames / v.float_seconds())
+
+        print_with_fps(local_encoding, 'Local encoding', total, wakes)
+        if sending.float_seconds() > 0:
+            print '\t%s: %2.f%%' % ('Sending'.ljust(16), sending.float_seconds() * 100 / total)
+        print_with_fps(remote_encoding, 'Remote encoding', total, wakes)
+        if receiving.float_seconds() > 0:
+            print '\t%s: %2.f%%' % ('Receiving'.ljust(16), receiving.float_seconds() * 100 / total)
+        print ''