1#!/usr/bin/env python
  2from __future__ import print_function
  3import argparse
  4import csv
  5import os
  6import shlex
  7import signal
  8import socket
  9import subprocess
 10import sys
 11import time
 12
 13class PerfTest(object):
 14    EXECUTABLE = 'mgba-perf'
 15
 16    def __init__(self, rom, renderer='software'):
 17        self.rom = rom
 18        self.renderer = renderer
 19        self.results = None
 20        self.name = 'Perf Test: {}'.format(rom)
 21
 22    def get_args(self):
 23        return []
 24
 25    def wait(self, proc):
 26        pass
 27
 28    def run(self, cwd):
 29        args = [os.path.join(os.getcwd(), self.EXECUTABLE), '-P']
 30        args.extend(self.get_args())
 31        if not self.renderer:
 32            args.append('-N')
 33        elif self.renderer == 'threaded-software':
 34            args.append('-T')
 35        args.append(self.rom)
 36        env = {}
 37        if 'LD_LIBRARY_PATH' in os.environ:
 38            env['LD_LIBRARY_PATH'] = os.path.abspath(os.environ['LD_LIBRARY_PATH'])
 39            env['DYLD_LIBRARY_PATH'] = env['LD_LIBRARY_PATH'] # Fake it on OS X
 40        proc = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd, universal_newlines=True, env=env)
 41        try:
 42            self.wait(proc)
 43            proc.wait()
 44        except:
 45            proc.kill()
 46            raise
 47        if proc.returncode:
 48            print('Game crashed!', file=sys.stderr)
 49            return
 50        reader = csv.DictReader(proc.stdout)
 51        self.results = next(reader)
 52
 53class WallClockTest(PerfTest):
 54    def __init__(self, rom, duration, renderer='software'):
 55        super(WallClockTest, self).__init__(rom, renderer)
 56        self.duration = duration
 57        self.name = 'Wall-Clock Test ({} seconds, {} renderer): {}'.format(duration, renderer, rom)
 58
 59    def wait(self, proc):
 60        time.sleep(self.duration)
 61        proc.send_signal(signal.SIGINT)
 62
 63class GameClockTest(PerfTest):
 64    def __init__(self, rom, frames, renderer='software'):
 65        super(GameClockTest, self).__init__(rom, renderer)
 66        self.frames = frames
 67        self.name = 'Game-Clock Test ({} frames, {} renderer): {}'.format(frames, renderer, rom)
 68
 69    def get_args(self):
 70        return ['-F', str(self.frames)]
 71
 72class PerfServer(object):
 73    ITERATIONS_PER_INSTANCE = 50
 74
 75    def __init__(self, address, root='/', command=None):
 76        s = address.rsplit(':', 1)
 77        if len(s) == 1:
 78            self.address = (s[0], 7216)
 79        else:
 80            self.address = (s[0], s[1])
 81        self.command = None
 82        if command:
 83            self.command = shlex.split(command)
 84        self.iterations = self.ITERATIONS_PER_INSTANCE
 85        self.socket = None
 86        self.results = []
 87        self.reader = None
 88        self.root = root
 89
 90    def _start(self, test):
 91        if self.command:
 92            server_command = list(self.command)
 93        else:
 94            server_command = [os.path.join(os.getcwd(), PerfTest.EXECUTABLE)]
 95        server_command.extend(['-PD'])
 96        if hasattr(test, "frames"):
 97            server_command.extend(['-F', str(test.frames)])
 98        if not test.renderer:
 99            server_command.append('-N')
100        elif test.renderer == 'threaded-software':
101            server_command.append('-T')
102        subprocess.check_call(server_command)
103        time.sleep(4)
104        self.socket = socket.create_connection(self.address, timeout=1000)
105        kwargs = {}
106        if sys.version_info[0] >= 3:
107            kwargs["encoding"] = "utf-8"
108        self.reader = csv.DictReader(self.socket.makefile(**kwargs))
109
110    def run(self, test):
111        if not self.socket:
112            self._start(test)
113        self.socket.send(os.path.join(self.root, test.rom).encode("utf-8"))
114        self.results.append(next(self.reader))
115        self.iterations -= 1
116        if self.iterations == 0:
117            self.finish()
118            self.iterations = self.ITERATIONS_PER_INSTANCE
119
120    def finish(self):
121        self.socket.send(b"\n");
122        self.reader = None
123        self.socket.close()
124        time.sleep(5)
125        self.socket = None
126
127class Suite(object):
128    def __init__(self, cwd, wall=None, game=None, renderer='software'):
129        self.cwd = cwd
130        self.tests = []
131        self.wall = wall
132        self.game = game
133        self.renderer = renderer
134        self.server = None
135
136    def set_server(self, server):
137        self.server = server
138
139    def collect_tests(self):
140        roms = []
141        for f in os.listdir(self.cwd):
142            if f.endswith('.gba') or f.endswith('.zip') or f.endswith('.gbc') or f.endswith('.gb'):
143                roms.append(f)
144        roms.sort()
145        for rom in roms:
146            self.add_tests(rom)
147
148    def add_tests(self, rom):
149        if self.wall:
150            self.tests.append(WallClockTest(rom, self.wall, renderer=self.renderer))
151        if self.game:
152            self.tests.append(GameClockTest(rom, self.game, renderer=self.renderer))
153
154    def run(self):
155        results = []
156        sock = None
157        for test in self.tests:
158            print('Running test {}'.format(test.name), file=sys.stderr)
159            if self.server:
160                self.server.run(test)
161            else:
162                try:
163                    test.run(self.cwd)
164                except KeyboardInterrupt:
165                    print('Interrupted, returning early...', file=sys.stderr)
166                    return results
167                if test.results:
168                    results.append(test.results)
169        if self.server:
170            self.server.finish()
171            results.extend(self.server.results)
172        return results
173
174if __name__ == '__main__':
175    parser = argparse.ArgumentParser()
176    parser.add_argument('-w', '--wall-time', type=float, default=0, metavar='TIME', help='wall-clock time')
177    parser.add_argument('-g', '--game-frames', type=int, default=0, metavar='FRAMES', help='game-clock frames')
178    parser.add_argument('-N', '--disable-renderer', action='store_const', const=True, help='disable video rendering')
179    parser.add_argument('-T', '--threaded-renderer', action='store_const', const=True, help='threaded video rendering')
180    parser.add_argument('-s', '--server', metavar='ADDRESS', help='run on server')
181    parser.add_argument('-S', '--server-command', metavar='COMMAND', help='command to launch server')
182    parser.add_argument('-o', '--out', metavar='FILE', help='output file path')
183    parser.add_argument('-r', '--root', metavar='PATH', type=str, default='/perfroms', help='root path for server mode')
184    parser.add_argument('directory', help='directory containing ROM files')
185    args = parser.parse_args()
186
187    renderer = 'software'
188    if args.disable_renderer:
189        renderer = None
190    elif args.threaded_renderer:
191        renderer = 'threaded-software'
192    s = Suite(args.directory, wall=args.wall_time, game=args.game_frames, renderer=renderer)
193    if args.server:
194        if args.server_command:
195            server = PerfServer(args.server, args.root, args.server_command)
196        else:
197            server = PerfServer(args.server, args.root)
198        s.set_server(server)
199    s.collect_tests()
200    results = s.run()
201    fout = sys.stdout
202    if args.out:
203        fout = open(args.out, 'w')
204    writer = csv.DictWriter(fout, results[0].keys())
205    writer.writeheader()
206    writer.writerows(results)
207    if fout is not sys.stdout:
208        fout.close()