Merge lp:~afrantzis/mir/touch-event-latency-benchmark into lp:mir

[Alexandros Frantzis]

benchmarks: Add touch event latency benchmark

Also, enhance the perfomance framework to support the touch event latency benchmark.

benchmarks: Add touch event latency benchmark

Also, enhance the perfomance framework to support the touch event latency benchmark.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2722
http://jenkins.qa.ubuntu.com/job/mir-ci/4242/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3066
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/587
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3014
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/398
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/398/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3014
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3014/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5824
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21595

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/4242/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

41 + time.sleep(0.25)
could we monitor for some rpc startup lttng messages perhaps?

[Kevin DuBois (kdub)]

review: Needs Information

[Alexandros Frantzis (afrantzis)]

> 41 + time.sleep(0.25)
> could we monitor for some rpc startup lttng messages perhaps?

That was my first thought, but I haven't found a reliable way to do that without stopping the session, which is problematic since we then may miss other interesting events (until we restart).

I am still investigating if there is reliable way to read information without stopping, but since the workaround seems to work reasonably well, I decided to propose this MP as is for now.

[Alexandros Frantzis (afrantzis)]

FWIW, a possible solution I am investigating is using 'relayd' live tracing feature of LTTng, but need to experiment more with it.

[Kevin DuBois (kdub)]

I'm okay with the todo, lgtm

review: Approve

[Andreas Pokorny (andreas-pokorny)]

ok looks good.

review: Approve

=== modified file 'benchmarks/mir_perf_framework/client.py'
--- benchmarks/mir_perf_framework/client.py	2015-06-26 11:31:44 +0000
+++ benchmarks/mir_perf_framework/client.py	2015-07-01 11:34:29 +0000
@@ -1,10 +1,11 @@
 import os
 import subprocess
 import shutil
+import time
 from .common import env_variable_for_client_report
 
 class Client:
-    def __init__(self, executable=shutil.which("mir_demo_client_egltriangle"), server=None, reports=[], options=[]):
+    def __init__(self, executable=shutil.which("mir_demo_client_egltriangle"), server=None, reports=[], options=[], env={}):
         """ Creates a Client object.
 
         The client is not run until it is passed to a PerformanceTest and the
@@ -16,11 +17,13 @@
             reports (list of str): The lttng reports to enable. Use the 'client-' prefix to
                                    enable a client report.
             options (list of str): Command-line options to use when running the client.
+            env (dict of str=>str): Extra environment variables to set when running the client
         """
         self.executable = executable
         self.server = server
         self.reports = reports
         self.options = options
+        self.env = env
         self.process = None
 
     def start(self):
@@ -31,8 +34,13 @@
         env["LTTNG_UST_WITHOUT_BADDR_STATEDUMP"] = "1"
         for report in self.reports:
             env[env_variable_for_client_report(report)] = "lttng"
+        for name,value in self.env.items():
+            env[name] = value
 
         self.process = subprocess.Popen(cmdline, env=env)
+        # Wait for client to start
+        # TODO: Find a better way to wait for client readiness
+        time.sleep(0.25)
 
     def stop(self):
         self.process.terminate()
 
=== modified file 'benchmarks/mir_perf_framework/server.py'
--- benchmarks/mir_perf_framework/server.py	2015-06-26 11:31:44 +0000
+++ benchmarks/mir_perf_framework/server.py	2015-07-01 11:34:29 +0000
@@ -5,7 +5,7 @@
 from .common import env_variable_for_client_report, unique_server_socket_path
 
 class Server:
-    def __init__(self, executable=shutil.which("mir_demo_server"), host=None, reports=[], options=[]):
+    def __init__(self, executable=shutil.which("mir_demo_server"), host=None, reports=[], options=[], env={}):
         """ Creates a Server object.
 
         The server is not run until it is passed to a PerformanceTest and the
@@ -17,12 +17,14 @@
             reports (list of str): The lttng reports to enable. Use the 'client-' prefix to
                                    enable a client report.
             options (list of str): Command-line options to use when running the server.
+            env (dict of str=>str): Extra environment variables to set when running the server
         """
         self.executable = executable
         self.host = host
         self.reports = reports
         self.socket_path = unique_server_socket_path()
         self.options = options
+        self.env = env
         self.process = None
 
     def start(self):
@@ -32,6 +34,8 @@
 
         env = os.environ.copy()
         env["LTTNG_UST_WITHOUT_BADDR_STATEDUMP"] = "1"
+        for name,value in self.env.items():
+            env[name] = value
 
         for report in self.reports:
             if report.startswith("client-"):
 
=== added file 'benchmarks/touch_event_latency.py'
--- benchmarks/touch_event_latency.py	1970-01-01 00:00:00 +0000
+++ benchmarks/touch_event_latency.py	2015-07-01 11:34:29 +0000
@@ -0,0 +1,113 @@
+from mir_perf_framework import PerformanceTest, Server, Client
+import time
+import evdev
+import statistics
+import subprocess
+
+###### Helper classes ######
+
+class TouchScreen:
+    def __init__(self):
+        res = self.get_resolution()
+
+        allowed_events = {
+            evdev.ecodes.EV_ABS : (
+                (evdev.ecodes.ABS_MT_POSITION_X, (0, res[0], 0, 0)),
+                (evdev.ecodes.ABS_MT_POSITION_Y, (0, res[1], 0, 0)),
+                (evdev.ecodes.ABS_MT_TOUCH_MAJOR, (0, 30, 0, 0)),
+                (evdev.ecodes.ABS_MT_TRACKING_ID, (0, 65535, 0, 0)),
+                (evdev.ecodes.ABS_MT_PRESSURE, (0, 255, 0, 0)),
+                (evdev.ecodes.ABS_MT_SLOT, (0, 9, 0, 0))
+                ),
+            evdev.ecodes.EV_KEY: [
+                evdev.ecodes.BTN_TOUCH,
+                ]
+        }
+        
+        self.ui = evdev.UInput(events=allowed_events, name="autopilot-finger")
+
+    def get_resolution(self):
+        out = subprocess.check_output(["fbset", "-s"])
+        out_list = out.split()
+        geometry = out_list.index(b"geometry")
+        return (int(out_list[geometry + 1]), int(out_list[geometry + 2]))
+
+    def finger_down_at(self, xy):
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_SLOT, 0)
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_TRACKING_ID, 0)
+        self.ui.write(evdev.ecodes.EV_KEY, evdev.ecodes.BTN_TOUCH, 1)
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_POSITION_X, xy[0])
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_POSITION_Y, xy[1])
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_PRESSURE, 50)
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_TOUCH_MAJOR, 4)
+        self.ui.syn()
+
+    def finger_up(self):
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_TRACKING_ID, -1)
+        self.ui.syn()
+
+    def finger_move_to(self, xy):
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_SLOT, 0)
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_POSITION_X, xy[0])
+        self.ui.write(evdev.ecodes.EV_ABS, evdev.ecodes.ABS_MT_POSITION_Y, xy[1])
+        self.ui.syn()
+
+
+####### TEST #######
+
+# Disable input resampling so that the event_time field of input events,
+# used to calculate latency, is accurate
+no_resampling_env = {"MIR_CLIENT_INPUT_RATE": "0"}
+
+host = Server(reports=["input"])
+nested = Server(host=host, reports=["client-input-receiver"], env=no_resampling_env)
+client = Client(server=nested, reports=["client-input-receiver"], options=["-f"], env=no_resampling_env)
+
+test = PerformanceTest([host, nested, client])
+touch_screen = TouchScreen()
+
+test.start()
+
+# Perform three 1-second drag movements
+for i in range(3):
+    xy = (100,100)
+    touch_screen.finger_down_at(xy)
+    for i in range(100):
+        touch_screen.finger_move_to(xy)
+        xy = (xy[0] + 5, xy[1] + 5)
+        time.sleep(0.01)
+    touch_screen.finger_up()
+
+test.stop()
+
+####### TRACE PARSING #######
+
+trace = test.babeltrace()
+
+pids = {}
+data = {}
+
+for event in trace.events:
+    if event.name == "mir_client_input_receiver:touch_event":
+        pid = event["vpid"]
+        if pid not in pids.values():
+            if "nested" not in pids:
+                pids["nested"] = pid
+            elif "client" not in pids:
+                pids["client"] = pid
+        if pid not in data: data[pid] = []
+
+        data[pid].append((event.timestamp - event["event_time"]) / 1000000.0)
+
+
+print("=== Results ===")
+
+nested_data = data[pids["nested"]]
+print("Nested server received %d events" % len(nested_data))
+print("Kernel to nested server mean: %f ms stdev: %f ms" %
+      (statistics.mean(nested_data), statistics.stdev(nested_data)))
+
+client_data = data[pids["client"]]
+print("Client received %d events" % len(client_data))
+print("Kernel to client mean: %f ms stdev: %f ms" %
+      (statistics.mean(client_data), statistics.stdev(client_data)))
 
=== modified file 'doc/performance_framework.md'
--- doc/performance_framework.md	2015-06-26 11:31:44 +0000
+++ doc/performance_framework.md	2015-07-01 11:34:29 +0000
@@ -12,7 +12,7 @@
 
 To run a test, just execute the python3 script containing it.
 
-You need to ensure that the Mir performance framework can be found by python.
+We need to ensure that the Mir performance framework can be found by python.
 To do so, add the directory containing the mir_perf_framework/ directory (i.e.,
 its parent directory) to the PYTHONPATH env. variable:
 
@@ -35,12 +35,15 @@
 ### Specifying the executable to run
 
 By default the servers use the 'mir_demo_server' executable and the clients the
-'mir_demo_client_egltriangle' executable. You can override this by using the
-'executable' option. You can also set custom command line arguments to use when
-invoking the executable (even the default ones):
+'mir_demo_client_egltriangle' executable. We can override this by using the
+'executable' option. We can also set custom command line arguments to use when
+invoking the executable (even the default ones). Finally we can set extra
+environment variables using the 'env' option, which is a dictionary of variable
+names and values.
 
      server = Server(executable=shutil.which("my_test_server"),
-                     options=["--window-manager", "fullscreen"])
+                     options=["--window-manager", "fullscreen"],
+                     env = {"MIR_SERVER_MY_OPTION": "on"})
 
 ### Specifying the host server a server should connect to
 
@@ -139,4 +142,5 @@
     print(events[i].name) # Random access is OK too!
 
 This is the recommend way of accessing the events, unless you need some
-functionality offered only by the babeltrace APIs.
+functionality offered only by the babeltrace APIs. Note, however, that
+creating the list of events may incur a small delay.