1/* Copyright (c) 2013-2015 Jeffrey Pfau
  2 *
  3 * This Source Code Form is subject to the terms of the Mozilla Public
  4 * License, v. 2.0. If a copy of the MPL was not distributed with this
  5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  6#include "core/config.h"
  7#include "gba/core.h"
  8#include "gba/gba.h"
  9#include "gba/renderers/video-software.h"
 10#include "gba/serialize.h"
 11
 12#include "feature/commandline.h"
 13#include "util/socket.h"
 14#include "util/string.h"
 15#include "util/vfs.h"
 16
 17#ifdef _3DS
 18#include <3ds.h>
 19#endif
 20
 21#include <errno.h>
 22#include <fcntl.h>
 23#include <signal.h>
 24#include <inttypes.h>
 25#include <sys/time.h>
 26
 27#define PERF_OPTIONS "DF:L:NPS:"
 28#define PERF_USAGE \
 29	"\nBenchmark options:\n" \
 30	"  -F FRAMES        Run for the specified number of FRAMES before exiting\n" \
 31	"  -N               Disable video rendering entirely\n" \
 32	"  -P               CSV output, useful for parsing\n" \
 33	"  -S SEC           Run for SEC in-game seconds before exiting\n" \
 34	"  -L FILE          Load a savestate when starting the test\n" \
 35	"  -D               Act as a server"
 36
 37struct PerfOpts {
 38	bool noVideo;
 39	bool csv;
 40	unsigned duration;
 41	unsigned frames;
 42	char* savestate;
 43	bool server;
 44};
 45
 46#ifdef _3DS
 47extern bool allocateRomBuffer(void);
 48FS_Archive sdmcArchive;
 49#endif
 50
 51static void _mPerfRunloop(struct mCore* context, int* frames, bool quiet);
 52static void _mPerfShutdown(int signal);
 53static bool _parsePerfOpts(struct mSubParser* parser, int option, const char* arg);
 54static void _log(struct mLogger*, int, enum mLogLevel, const char*, va_list);
 55static bool _mPerfRunCore(const char* fname, const struct mArguments*, const struct PerfOpts*);
 56static bool _mPerfRunServer(const char* listen, const struct mArguments*, const struct PerfOpts*);
 57
 58static bool _dispatchExiting = false;
 59static struct VFile* _savestate = 0;
 60static void* _outputBuffer = NULL;
 61static Socket _socket = INVALID_SOCKET;
 62
 63int main(int argc, char** argv) {
 64#ifdef _3DS
 65	UNUSED(_mPerfShutdown);
 66    gfxInitDefault();
 67    osSetSpeedupEnable(true);
 68	consoleInit(GFX_BOTTOM, NULL);
 69	if (!allocateRomBuffer()) {
 70		return 1;
 71	}
 72	sdmcArchive = (FS_Archive) {
 73		ARCHIVE_SDMC,
 74		(FS_Path) { PATH_EMPTY, 1, "" },
 75		0
 76	};
 77	FSUSER_OpenArchive(&sdmcArchive);
 78#else
 79	signal(SIGINT, _mPerfShutdown);
 80#endif
 81	int didFail = 0;
 82
 83	struct mLogger logger = { .log = _log };
 84	mLogSetDefaultLogger(&logger);
 85
 86	struct PerfOpts perfOpts = { false, false, 0, 0, 0, false };
 87	struct mSubParser subparser = {
 88		.usage = PERF_USAGE,
 89		.parse = _parsePerfOpts,
 90		.extraOptions = PERF_OPTIONS,
 91		.opts = &perfOpts
 92	};
 93
 94	struct mArguments args = {};
 95	bool parsed = parseArguments(&args, argc, argv, &subparser);
 96	if (!args.fname) {
 97		parsed = false;
 98	}
 99	if (!parsed || args.showHelp) {
100		usage(argv[0], PERF_USAGE);
101		didFail = !parsed;
102		goto cleanup;
103	}
104
105	if (args.showVersion) {
106		version(argv[0]);
107		goto cleanup;
108	}
109
110	if (perfOpts.savestate) {
111		_savestate = VFileOpen(perfOpts.savestate, O_RDONLY);
112		free(perfOpts.savestate);
113	}
114
115	_outputBuffer = malloc(256 * 256 * 4);
116	if (perfOpts.csv) {
117		puts("game_code,frames,duration,renderer");
118	}
119	if (perfOpts.server) {
120		didFail = !_mPerfRunServer(args.fname, &args, &perfOpts);
121	} else {
122		didFail = !_mPerfRunCore(args.fname, &args, &perfOpts);
123	}
124	free(_outputBuffer);
125
126	if (_savestate) {
127		_savestate->close(_savestate);
128	}
129	cleanup:
130	freeArguments(&args);
131
132#ifdef _3DS
133	gfxExit();
134	acExit();
135#endif
136
137	return didFail;
138}
139
140bool _mPerfRunCore(const char* fname, const struct mArguments* args, const struct PerfOpts* perfOpts) {
141	struct mCore* core = mCoreFind(fname);
142	if (!core) {
143		return false;
144	}
145
146	// TODO: Put back debugger
147	char gameCode[9] = { 0 };
148
149	core->init(core);
150	if (!perfOpts->noVideo) {
151		core->setVideoBuffer(core, _outputBuffer, 256);
152	}
153	mCoreLoadFile(core, fname);
154	mCoreConfigInit(&core->config, "perf");
155	mCoreConfigLoad(&core->config);
156
157	struct mCoreOptions opts = {};
158	mCoreConfigMap(&core->config, &opts);
159	opts.audioSync = false;
160	opts.videoSync = false;
161	applyArguments(args, NULL, &core->config);
162	mCoreConfigLoadDefaults(&core->config, &opts);
163	mCoreConfigSetDefaultValue(&core->config, "idleOptimization", "detect");
164	mCoreLoadConfig(core);
165
166	core->reset(core);
167	if (_savestate) {
168		mCoreLoadStateNamed(core, _savestate, 0);
169	}
170
171	core->getGameCode(core, gameCode);
172
173	int frames = perfOpts->frames;
174	if (!frames) {
175		frames = perfOpts->duration * 60;
176	}
177	struct timeval tv;
178	gettimeofday(&tv, 0);
179	uint64_t start = 1000000LL * tv.tv_sec + tv.tv_usec;
180	_mPerfRunloop(core, &frames, perfOpts->csv);
181	gettimeofday(&tv, 0);
182	uint64_t end = 1000000LL * tv.tv_sec + tv.tv_usec;
183	uint64_t duration = end - start;
184
185	core->deinit(core);
186
187	float scaledFrames = frames * 1000000.f;
188	if (perfOpts->csv) {
189		char buffer[256];
190		const char* rendererName;
191		if (perfOpts->noVideo) {
192			rendererName = "none";
193		} else {
194			rendererName = "software";
195		}
196		snprintf(buffer, sizeof(buffer), "%s,%i,%" PRIu64 ",%s\n", gameCode, frames, duration, rendererName);
197		printf("%s", buffer);
198		if (_socket != INVALID_SOCKET) {
199			SocketSend(_socket, buffer, strlen(buffer));
200		}
201	} else {
202		printf("%u frames in %" PRIu64 " microseconds: %g fps (%gx)\n", frames, duration, scaledFrames / duration, scaledFrames / (duration * 60.f));
203	}
204
205	mCoreConfigFreeOpts(&opts);
206	mCoreConfigDeinit(&core->config);
207	return true;
208}
209
210static void _mPerfRunloop(struct mCore* core, int* frames, bool quiet) {
211	struct timeval lastEcho;
212	gettimeofday(&lastEcho, 0);
213	int duration = *frames;
214	*frames = 0;
215	int lastFrames = 0;
216	while (!_dispatchExiting) {
217		core->runFrame(core);
218		++*frames;
219		++lastFrames;
220		if (!quiet) {
221			struct timeval currentTime;
222			long timeDiff;
223			gettimeofday(&currentTime, 0);
224			timeDiff = currentTime.tv_sec - lastEcho.tv_sec;
225			timeDiff *= 1000;
226			timeDiff += (currentTime.tv_usec - lastEcho.tv_usec) / 1000;
227			if (timeDiff >= 1000) {
228				printf("\033[2K\rCurrent FPS: %g (%gx)", lastFrames / (timeDiff / 1000.0f), lastFrames / (float) (60 * (timeDiff / 1000.0f)));
229				fflush(stdout);
230				lastEcho = currentTime;
231				lastFrames = 0;
232			}
233		}
234		if (duration > 0 && *frames == duration) {
235			break;
236		}
237	}
238	if (!quiet) {
239		printf("\033[2K\r");
240	}
241}
242
243static bool _mPerfRunServer(const char* listen, const struct mArguments* args, const struct PerfOpts* perfOpts) {
244	SocketSubsystemInit();
245	Socket server = SocketOpenTCP(7216, NULL);
246	if (SOCKET_FAILED(server)) {
247		SocketSubsystemDeinit();
248		return false;
249	}
250	if (SOCKET_FAILED(SocketListen(server, 0))) {
251		SocketClose(server);
252		SocketSubsystemDeinit();
253		return false;
254	}
255	_socket = SocketAccept(server, NULL);
256	if (perfOpts->csv) {
257		const char* header = "game_code,frames,duration,renderer\n";
258		SocketSend(_socket, header, strlen(header));
259	}
260	char path[PATH_MAX];
261	while (SocketRecv(_socket, path, sizeof(path)) > 0) {
262		char* nl = strchr(path, '\n');
263		if (nl == path) {
264			break;
265		}
266		if (nl) {
267			nl[0] = '\0';
268		}
269		if (!_mPerfRunCore(path, args, perfOpts)) {
270			break;
271		}
272	}
273	SocketClose(_socket);
274	SocketClose(server);
275	SocketSubsystemDeinit();
276	return true;
277}
278
279static void _mPerfShutdown(int signal) {
280	UNUSED(signal);
281	_dispatchExiting = true;
282	SocketClose(_socket);
283}
284
285static bool _parsePerfOpts(struct mSubParser* parser, int option, const char* arg) {
286	struct PerfOpts* opts = parser->opts;
287	errno = 0;
288	switch (option) {
289	case 'D':
290		opts->server = true;
291		return true;
292	case 'F':
293		opts->frames = strtoul(arg, 0, 10);
294		return !errno;
295	case 'N':
296		opts->noVideo = true;
297		return true;
298	case 'P':
299		opts->csv = true;
300		return true;
301	case 'S':
302		opts->duration = strtoul(arg, 0, 10);
303		return !errno;
304	case 'L':
305		opts->savestate = strdup(arg);
306		return true;
307	default:
308		return false;
309	}
310}
311
312static void _log(struct mLogger* log, int category, enum mLogLevel level, const char* format, va_list args) {
313	UNUSED(log);
314	UNUSED(category);
315	UNUSED(level);
316	UNUSED(format);
317	UNUSED(args);
318}