Preliminary alternative parallel traversal/benchmarking work

14 files changed, 458 insertions, 232 deletions

diff --git a/ingen/World.hpp b/ingen/World.hpp
index fc77593a..b0e09b34 100644
--- a/ingen/World.hpp
+++ b/ingen/World.hpp
@@ -64,20 +64,20 @@ class URIs;
 class INGEN_API World : public Raul::Noncopyable {
 public:
 	/** Construct a new Ingen world.
-	 * @param argc Argument count (as in C main())
-	 * @param argv Argument vector (as in C main())
 	 * @param map LV2 URID map implementation, or NULL to use internal.
 	 * @param unmap LV2 URID unmap implementation, or NULL to use internal.
 	 * @param log LV2 log implementation, or NULL to use internal.
 	 */
-	World(int&            argc,
-	      char**&         argv,
-	      LV2_URID_Map*   map,
-	      LV2_URID_Unmap* unmap,
-	      LV2_Log_Log*    log);
+	World(LV2_URID_Map* map, LV2_URID_Unmap* unmap, LV2_Log_Log* log);
 
 	virtual ~World();
 
+	/** Load configuration from files and command line.
+	 * @param argc Argument count (as in C main())
+	 * @param argv Argument vector (as in C main())
+	 */
+	virtual void load_configuration(int& argc, char**& argv);
+
 	/** Load an Ingen module by name (e.g. "server", "gui", etc.)
 	 * @return True on success.
 	 */
diff --git a/src/World.cpp b/src/World.cpp
index 38b27a9a..d6a1fc1c 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -98,14 +98,12 @@ ingen_load_module(Log& log, const string& name)
 
 class World::Impl {
 public:
-	Impl(int&            a_argc,
-	     char**&         a_argv,
-	     LV2_URID_Map*   map,
+	Impl(LV2_URID_Map*   map,
 	     LV2_URID_Unmap* unmap,
 	     LV2_Log_Log*    lv2_log)
-		: argc(a_argc)
-		, argv(a_argv)
-		, lv2_features(NULL)
+		: argc(nullptr)
+		, argv(nullptr)
+		, lv2_features(nullptr)
 		, rdf_world(new Sord::World())
 		, lilv_world(lilv_world_new())
 		, uri_map(new URIMap(log, map, unmap))
@@ -114,17 +112,6 @@ public:
 		, conf(*forge)
 		, log(lv2_log, *uris)
 	{
-		// Parse default configuration files
-		std::list<std::string> files = conf.load_default("ingen", "options.ttl");
-		for (const auto& f : files) {
-			log.info(fmt("Loaded configuration %1%\n") % f);
-		}
-
-		// Parse command line options, overriding configuration file values
-		conf.parse(argc, argv);
-		log.set_flush(conf.option("flush-log").get<int32_t>());
-		log.set_trace(conf.option("trace").get<int32_t>());
-
 		lv2_features = new LV2Features();
 		lv2_features->add_feature(uri_map->urid_map_feature());
 		lv2_features->add_feature(uri_map->urid_unmap_feature());
@@ -208,8 +195,8 @@ public:
 	typedef std::map<const std::string, ScriptRunner> ScriptRunners;
 	ScriptRunners script_runners;
 
-	int&             argc;
-	char**&          argv;
+	int*             argc;
+	char***          argv;
 	LV2Features*     lv2_features;
 	Sord::World*     rdf_world;
 	LilvWorld*       lilv_world;
@@ -228,12 +215,8 @@ public:
 	std::string      jack_uuid;
 };
 
-World::World(int&                 argc,
-             char**&              argv,
-             LV2_URID_Map*        map,
-             LV2_URID_Unmap*      unmap,
-             LV2_Log_Log*         log)
-	: _impl(new Impl(argc, argv, map, unmap, log))
+World::World(LV2_URID_Map* map, LV2_URID_Unmap* unmap, LV2_Log_Log* log)
+	: _impl(new Impl(map, unmap, log))
 {
 	_impl->serialiser = SPtr<Serialiser>(new Serialiser(*this));
 	_impl->parser     = SPtr<Parser>(new Parser());
@@ -244,6 +227,24 @@ World::~World()
 	delete _impl;
 }
 
+void
+World::load_configuration(int& argc, char**& argv)
+{
+	_impl->argc = &argc;
+	_impl->argv = &argv;
+
+	// Parse default configuration files
+	const auto files = _impl->conf.load_default("ingen", "options.ttl");
+	for (const auto& f : files) {
+		_impl->log.info(fmt("Loaded configuration %1%\n") % f);
+	}
+
+	// Parse command line options, overriding configuration file values
+	_impl->conf.parse(argc, argv);
+	_impl->log.set_flush(_impl->conf.option("flush-log").get<int32_t>());
+	_impl->log.set_trace(_impl->conf.option("trace").get<int32_t>());
+}
+
 void World::set_engine(SPtr<EngineBase> e)   { _impl->engine     = e; }
 void World::set_interface(SPtr<Interface> i) { _impl->interface  = i; }
 void World::set_store(SPtr<Store> s)         { _impl->store      = s; }
@@ -254,8 +255,8 @@ SPtr<Parser>     World::parser()     { return _impl->parser; }
 SPtr<Serialiser> World::serialiser() { return _impl->serialiser; }
 SPtr<Store>      World::store()      { return _impl->store; }
 
-int&           World::argc() { return _impl->argc; }
-char**&        World::argv() { return _impl->argv; }
+int&           World::argc() { return *_impl->argc; }
+char**&        World::argv() { return *_impl->argv; }
 Configuration& World::conf() { return _impl->conf; }
 Log&           World::log()  { return _impl->log; }
 
diff --git a/src/gui/ingen_gui_lv2.cpp b/src/gui/ingen_gui_lv2.cpp
index 1f950089..005ed270 100644
--- a/src/gui/ingen_gui_lv2.cpp
+++ b/src/gui/ingen_gui_lv2.cpp
@@ -110,10 +110,11 @@ instantiate(const LV2UI_Descriptor*   descriptor,
 		}
 	}
 
-	ui->world = new Ingen::World(ui->argc, ui->argv, map, unmap, log);
-
+	ui->world = new Ingen::World(map, unmap, log);
 	ui->forge = new Ingen::Forge(ui->world->uri_map());
 
+	ui->world->load_configuration(ui->argc, ui->argv);
+
 	if (!ui->world->load_module("client")) {
 		delete ui;
 		return NULL;
diff --git a/src/ingen/ingen.cpp b/src/ingen/ingen.cpp
index 9f939621..e4f0a946 100644
--- a/src/ingen/ingen.cpp
+++ b/src/ingen/ingen.cpp
@@ -90,7 +90,8 @@ main(int argc, char** argv)
 
 	// Create world
 	try {
-		world = new Ingen::World(argc, argv, NULL, NULL, NULL);
+		world = new Ingen::World(NULL, NULL, NULL);
+		world->load_configuration(argc, argv);
 		if (argc <= 1) {
 			world->conf().print_usage("ingen", cout);
 			return EXIT_FAILURE;
diff --git a/src/server/CompiledGraph.cpp b/src/server/CompiledGraph.cpp
index b808cb90..5553140c 100644
--- a/src/server/CompiledGraph.cpp
+++ b/src/server/CompiledGraph.cpp
@@ -1,6 +1,6 @@
 /*
   This file is part of Ingen.
-  Copyright 2015-2016 David Robillard <http://drobilla.net/>
+  Copyright 2015-2017 David Robillard <http://drobilla.net/>
 
   Ingen is free software: you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free
@@ -43,7 +43,7 @@ public:
 CompiledGraph::CompiledGraph(GraphImpl* graph)
 	: _log(graph->engine().log())
 	, _path(graph->path())
-	, _master(Task::Mode::SEQUENTIAL)
+	, _master(new Task(Task::Mode::PARALLEL))
 {
 	compile_graph(graph);
 }
@@ -76,7 +76,7 @@ CompiledGraph::compile_set(const std::set<BlockImpl*>& blocks,
 		// Each block is the start of a new sequential task
 		Task seq(Task::Mode::SEQUENTIAL);
 		compile_block(block, seq, k);
-		task.push_back(seq);
+		task.push_front(std::move(seq));
 	}
 }
 
@@ -91,41 +91,29 @@ CompiledGraph::compile_graph(GraphImpl* graph)
 		// Mark all blocks as unvisited initially
 		b.set_mark(BlockImpl::Mark::UNVISITED);
 
-		if (b.providers().empty()) {
-			// Block has no dependencies, add to initial working set
+		if (b.dependants().empty()) {
+			// Block has no dependants, add to initial working set
 			blocks.insert(&b);
 		}
 	}
 
-	// Compile initial working set into master task
-	Task                 start(Task::Mode::PARALLEL);
-	std::set<BlockImpl*> next;
-	compile_set(blocks, start, next);
-	_master.push_back(start);
-
 	// Keep compiling working set until all connected nodes are visited
-	while (!next.empty()) {
-		blocks.clear();
+	while (!blocks.empty()) {
+        std::set<BlockImpl*> next;
+
 		// The working set is a parallel task...
 		Task par(Task::Mode::PARALLEL);
-		for (BlockImpl* block : next)  {
-			// ... where each block is the start of a new sequential task
+		for (BlockImpl* block : blocks)  {
+			// ... where each block is the tail of a new sequential task
 			Task seq(Task::Mode::SEQUENTIAL);
-			compile_block(block, seq, blocks);
-			par.push_back(seq);
-		}
-		_master.push_back(par);
-		next = blocks;
-	}
-
-	// Compile any nodes that weren't reached (disconnected cycles)
-	for (auto& b : graph->blocks()) {
-		if (b.get_mark() == BlockImpl::Mark::UNVISITED) {
-			compile_block(&b, _master, next);
+			compile_block(block, seq, next);
+			par.push_front(std::move(seq));
 		}
+		_master->push_front(std::move(par));
+		blocks = next;
 	}
 
-	_master.simplify();
+	_master = Task::simplify(std::move(_master));
 
 	if (graph->engine().world()->conf().option("trace").get<int32_t>()) {
 		dump([this](const std::string& msg) {
@@ -160,23 +148,23 @@ check_feedback(const BlockImpl* root, BlockImpl* dependant)
 }
 
 void
-CompiledGraph::compile_dependant(const BlockImpl*      root,
-                                 BlockImpl*            block,
-                                 Task&                 task,
-                                 std::set<BlockImpl*>& k)
+CompiledGraph::compile_provider(const BlockImpl*      root,
+                                BlockImpl*            block,
+                                Task&                 task,
+                                std::set<BlockImpl*>& k)
 {
-	if (block->providers().size() > 1) {
-		/* Dependant has other providers, so this is the start of a sequential task.
-		   Add dependant to future working set and stop traversal. */
+	if (block->dependants().size() > 1) {
+		/* Provider has other dependants, so this is the start of a sequential task.
+		   Add provider to future working set and stop traversal. */
 		check_feedback(root, block);
 		k.insert(block);
 	} else {
-		// Dependant has only this provider, add here
+		// Provider has only this dependant, add here
 		if (task.mode() == Task::Mode::PARALLEL) {
 			// Inside a parallel task, compile into a new sequential child
 			Task seq(Task::Mode::SEQUENTIAL);
 			compile_block(block, seq, k);
-			task.push_back(seq);
+			task.push_front(std::move(seq));
 		} else {
 			// Append to given sequential task
 			compile_block(block, task, k);
@@ -191,21 +179,21 @@ CompiledGraph::compile_block(BlockImpl* n, Task& task, std::set<BlockImpl*>& k)
 	case BlockImpl::Mark::UNVISITED:
 		n->set_mark(BlockImpl::Mark::VISITING);
 
-		// Execute this task before the dependants to follow
-		task.push_back(Task(Task::Mode::SINGLE, n));
+		// Execute this task after the providers to follow
+		task.push_front(Task(Task::Mode::SINGLE, n));
 
-		if (n->dependants().size() < 2) {
-			// Single dependant, append to this sequential task
-			for (auto& d : n->dependants()) {
-				compile_dependant(n, d, task, k);
+		if (n->providers().size() < 2) {
+			// Single provider, append to this sequential task
+			for (auto& d : n->providers()) {
+				compile_provider(n, d, task, k);
 			}
 		} else {
-			// Multiple dependants, create a new parallel task
+			// Multiple providers, create a new parallel task
 			Task par(Task::Mode::PARALLEL);
-			for (auto& d : n->dependants()) {
-				compile_dependant(n, d, par, k);
+			for (auto& d : n->providers()) {
+				compile_provider(n, d, par, k);
 			}
-			task.push_back(par);
+			task.push_front(std::move(par));
 		}
 		n->set_mark(BlockImpl::Mark::VISITED);
 		break;
@@ -221,7 +209,7 @@ CompiledGraph::compile_block(BlockImpl* n, Task& task, std::set<BlockImpl*>& k)
 void
 CompiledGraph::run(RunContext& context)
 {
-	_master.run(context);
+	_master->run(context);
 }
 
 void
@@ -229,7 +217,7 @@ CompiledGraph::dump(std::function<void (const std::string&)> sink) const
 {
 	sink("(compiled-graph ");
 	sink(_path);
-	_master.dump(sink, 2, false);
+	_master->dump(sink, 2, false);
 	sink(")\n");
 }
 
diff --git a/src/server/CompiledGraph.hpp b/src/server/CompiledGraph.hpp
index eeeb6111..db9aa288 100644
--- a/src/server/CompiledGraph.hpp
+++ b/src/server/CompiledGraph.hpp
@@ -1,6 +1,6 @@
 /*
   This file is part of Ingen.
-  Copyright 2007-2016 David Robillard <http://drobilla.net/>
+  Copyright 2007-2017 David Robillard <http://drobilla.net/>
 
   Ingen is free software: you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free
@@ -63,14 +63,14 @@ private:
 	void compile_graph(GraphImpl* graph);
 	void compile_set(const BlockSet& blocks, Task& task, BlockSet& k);
 	void compile_block(BlockImpl* block, Task& task, BlockSet& k);
-	void compile_dependant(const BlockImpl* root,
-	                       BlockImpl*       block,
-	                       Task&            task,
-	                       BlockSet&        k);
-
-	Log&             _log;
-	const Raul::Path _path;
-	Task             _master;
+	void compile_provider(const BlockImpl* root,
+	                      BlockImpl*       block,
+	                      Task&            task,
+	                      BlockSet&        k);
+
+	Log&                  _log;
+	const Raul::Path      _path;
+	std::unique_ptr<Task> _master;
 };
 
 } // namespace Server
diff --git a/src/server/Engine.cpp b/src/server/Engine.cpp
index 794088bc..5561c36e 100644
--- a/src/server/Engine.cpp
+++ b/src/server/Engine.cpp
@@ -102,6 +102,7 @@ Engine::Engine(Ingen::World* world)
 		Raul::RingBuffer* ring = new Raul::RingBuffer(24 * event_queue_size());
 		_notifications.push_back(ring);
 		_run_contexts.push_back(new RunContext(*this, ring, i, i > 0));
+		_run_contexts.back()->set_priority(90); // FIXME
 	}
 
 	_world->lv2_features().add_feature(_worker->schedule_feature());
diff --git a/src/server/Task.cpp b/src/server/Task.cpp
index e19855d3..bf1f5028 100644
--- a/src/server/Task.cpp
+++ b/src/server/Task.cpp
@@ -1,6 +1,6 @@
 /*
   This file is part of Ingen.
-  Copyright 2015-2016 David Robillard <http://drobilla.net/>
+  Copyright 2015-2017 David Robillard <http://drobilla.net/>
 
   Ingen is free software: you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free
@@ -30,14 +30,14 @@ Task::run(RunContext& context)
 		_block->process(context);
 		break;
 	case Mode::SEQUENTIAL:
-		for (Task& task : *this) {
-			task.run(context);
+		for (const auto& task : _children) {
+			task->run(context);
 		}
 		break;
 	case Mode::PARALLEL:
 		// Initialize (not) done state of sub-tasks
-		for (Task& task : *this) {
-			task.set_done(false);
+		for (const auto& task : _children) {
+			task->set_done(false);
 		}
 
 		// Grab the first sub-task
@@ -65,12 +65,12 @@ Task::steal(RunContext& context)
 {
 	if (_mode == Mode::PARALLEL) {
 		const unsigned i = _next++;
-		if (i < size()) {
-			return &(*this)[i];
+		if (i < _children.size()) {
+			return _children[i].get();
 		}
 	}
 
-	return NULL;
+	return nullptr;
 }
 
 Task*
@@ -82,52 +82,65 @@ Task::get_task(RunContext& context)
 		return t;
 	}
 
+   int num_spins = 0;
 	while (true) {
 		// Push done end index as forward as possible
-		for (; _done_end < size() && (*this)[_done_end].done(); ++_done_end) {}
+		while (_done_end < _children.size() && _children[_done_end]->done()) {
+			++_done_end;
+		}
 
-		if (_done_end >= size()) {
-			return NULL;  // All child tasks are finished
+		if (_done_end >= _children.size()) {
+			return nullptr;  // All child tasks are finished
 		}
 
 		// All child tasks claimed, but some are unfinished, steal a task
-		t = context.engine().steal_task(context.id() + 1);
-		if (t) {
+		if ((t = context.engine().steal_task(context.id() + 1))) {
 			return t;
 		}
 
+      ++num_spins;
 		/* All child tasks are claimed, and we failed to steal any tasks.  Spin
 		   to prevent blocking, though it would probably be wiser to wait for a
 		   signal in non-main threads, and maybe even in the main thread
 		   depending on your real-time safe philosophy... more experimentation
 		   here is needed. */
 	}
+
+   if (num_spins > 0) {
+     fprintf(stderr, "Num spins: %u\n", num_spins);
+   }
 }
 
-void
-Task::simplify()
+std::unique_ptr<Task>
+Task::simplify(std::unique_ptr<Task>&& task)
 {
-	if (_mode != Mode::SINGLE) {
-		for (std::vector<Task>::iterator t = begin(); t != end();) {
-			t->simplify();
-			if (t->mode() != Mode::SINGLE && t->empty()) {
-				// Empty task, erase
-				t = erase(t);
-			} else if (t->mode() == _mode) {
-				// Subtask with the same type, fold child into parent
-				const Task child(*t);
-				t = erase(t);
-				t = insert(t, child.begin(), child.end());
-			} else {
-				++t;
-			}
-		}
+	if (task->mode() == Mode::SINGLE) {
+		return std::move(task);
+	}
 
-		if (size() == 1) {
-			const Task t(front());
-			*this = t;
+	for (auto t = task->_children.begin(); t != task->_children.end();) {
+		*t = simplify(std::move(*t));
+		if ((*t)->empty()) {
+			// Empty task, erase
+			t = task->_children.erase(t);
+		} else if ((*t)->mode() == task->_mode) {
+			// Subtask with the same type, fold child into parent
+			std::unique_ptr<Task> child(std::move(*t));
+			t = task->_children.erase(t);
+			t = task->_children.insert(
+				t,
+				std::make_move_iterator(child->_children.begin()),
+				std::make_move_iterator(child->_children.end()));
+		} else {
+			++t;
 		}
 	}
+
+	if (task->_children.size() == 1) {
+		return std::move(task->_children.front());
+	}
+
+	return std::move(task);
 }
 
 void
@@ -144,8 +157,8 @@ Task::dump(std::function<void (const std::string&)> sink, unsigned indent, bool
 		sink(_block->path());
 	} else {
 		sink(((_mode == Mode::SEQUENTIAL) ? "(seq " : "(par "));
-		for (size_t i = 0; i < size(); ++i) {
-			(*this)[i].dump(sink, indent + 5, i == 0);
+		for (size_t i = 0; i < _children.size(); ++i) {
+			_children[i]->dump(sink, indent + 5, i == 0);
 		}
 		sink(")");
 	}
diff --git a/src/server/Task.hpp b/src/server/Task.hpp
index 2c1a0cc2..982a6206 100644
--- a/src/server/Task.hpp
+++ b/src/server/Task.hpp
@@ -1,6 +1,6 @@
 /*
   This file is part of Ingen.
-  Copyright 2007-2016 David Robillard <http://drobilla.net/>
+  Copyright 2007-2017 David Robillard <http://drobilla.net/>
 
   Ingen is free software: you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free
@@ -18,8 +18,9 @@
 #define INGEN_ENGINE_TASK_HPP
 
 #include <cassert>
+#include <deque>
+#include <memory>
 #include <ostream>
-#include <vector>
 
 namespace Ingen {
 namespace Server {
@@ -27,7 +28,7 @@ namespace Server {
 class BlockImpl;
 class RunContext;
 
-class Task : public std::vector<Task> {
+class Task {
 public:
 	enum class Mode {
 		SINGLE,      ///< Single block to run
@@ -35,7 +36,7 @@ public:
 		PARALLEL     ///< Elements may be run in any order in parallel
 	};
 
-	Task(Mode mode, BlockImpl* block=NULL)
+	Task(Mode mode, BlockImpl* block = nullptr)
 		: _block(block)
 		, _mode(mode)
 		, _done_end(0)
@@ -45,23 +46,13 @@ public:
 		assert(!(mode == Mode::SINGLE && !block));
 	}
 
-	Task& operator=(const Task& copy) {
-		*static_cast<std::vector<Task>*>(this) = copy;
-		_block    = copy._block;
-		_mode     = copy._mode;
-		_done_end = copy._done_end;
-		_next     = copy._next.load();
-		_done     = copy._done.load();
-		return *this;
-	}
-
-	Task(const Task& copy)
-		: std::vector<Task>(copy)
-		, _block(copy._block)
-		, _mode(copy._mode)
-		, _done_end(copy._done_end)
-		, _next(copy._next.load())
-		, _done(copy._done.load())
+	Task(Task&& task)
+		: _children(std::move(task._children))
+		, _block(task._block)
+		, _mode(task._mode)
+		, _done_end(task._done_end)
+		, _next(task._next.load())
+		, _done(task._done.load())
 	{}
 
 	/** Run task in the given context. */
@@ -70,12 +61,20 @@ public:
 	/** Pretty print task to the given stream (recursively). */
 	void dump(std::function<void (const std::string&)> sink, unsigned indent, bool first) const;
 
+	/** Return true iff this is an empty task. */
+	bool empty() const { return _mode != Mode::SINGLE && _children.empty(); }
+
 	/** Simplify task expression. */
-	void simplify();
+	static std::unique_ptr<Task> simplify(std::unique_ptr<Task>&& task);
 
 	/** Steal a child task from this task (succeeds for PARALLEL only). */
 	Task* steal(RunContext& context);
 
+	/** Prepend a child to this task. */
+	void push_front(Task&& task) {
+		_children.push_front(std::unique_ptr<Task>(new Task(std::move(task))));
+	}
+
 	Mode       mode()  const { return _mode; }
 	BlockImpl* block() const { return _block; }
 	bool       done()  const { return _done; }
@@ -83,8 +82,14 @@ public:
 	void set_done(bool done) { _done = done; }
 
 private:
+	typedef std::deque<std::unique_ptr<Task>> Children;
+
+	Task(const Task&) = delete;
+	Task& operator=(const Task&) = delete;
+
 	Task* get_task(RunContext& context);
 
+	Children              _children;  ///< Vector of child tasks
 	BlockImpl*            _block;     ///< Used for SINGLE only
 	Mode                  _mode;      ///< Execution mode
 	unsigned              _done_end;  ///< Index of rightmost done sub-task
diff --git a/src/server/ingen_lv2.cpp b/src/server/ingen_lv2.cpp
index 9119ae14..00b59ca7 100644
--- a/src/server/ingen_lv2.cpp
+++ b/src/server/ingen_lv2.cpp
@@ -507,9 +507,9 @@ ingen_instantiate(const LV2_Descriptor*    descriptor,
 	}
 
 	IngenPlugin* plugin = new IngenPlugin();
-	plugin->map = map;
-	plugin->world = new Ingen::World(
-		plugin->argc, plugin->argv, map, unmap, log);
+	plugin->map   = map;
+	plugin->world = new Ingen::World(map, unmap, log);
+	plugin->world->load_configuration(plugin->argc, plugin->argv);
 
 	LV2_URID bufsz_max    = map->map(map->handle, LV2_BUF_SIZE__maxBlockLength);
 	LV2_URID bufsz_seq    = map->map(map->handle, LV2_BUF_SIZE__sequenceSize);
diff --git a/tests/TestClient.hpp b/tests/TestClient.hpp
new file mode 100644
index 00000000..f1e0c5a7
--- /dev/null
+++ b/tests/TestClient.hpp
@@ -0,0 +1,90 @@
+/*
+  This file is part of Ingen.
+  Copyright 2007-2017 David Robillard <http://drobilla.net/>
+
+  Ingen is free software: you can redistribute it and/or modify it under the
+  terms of the GNU Affero General Public License as published by the Free
+  Software Foundation, either version 3 of the License, or any later version.
+
+  Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+  A PARTICULAR PURPOSE.  See the GNU Affero General Public License for details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef INGEN_TESTCLIENT_HPP
+#define INGEN_TESTCLIENT_HPP
+
+#include "ingen/Interface.hpp"
+
+using namespace Ingen;
+
+class TestClient : public Ingen::Interface
+{
+public:
+	explicit TestClient(Log& log) : _log(log) {}
+	~TestClient() {}
+
+	Raul::URI uri() const { return Raul::URI("ingen:testClient"); }
+
+	void bundle_begin() {}
+
+	void bundle_end() {}
+
+	void put(const Raul::URI&  uri,
+	         const Properties& properties,
+	         Resource::Graph   ctx = Resource::Graph::DEFAULT) {}
+
+	void delta(const Raul::URI&  uri,
+	           const Properties& remove,
+	           const Properties& add) {}
+
+	void copy(const Raul::URI& old_uri,
+	          const Raul::URI& new_uri) {}
+
+	void move(const Raul::Path& old_path,
+	          const Raul::Path& new_path) {}
+
+	void del(const Raul::URI& uri) {}
+
+	void connect(const Raul::Path& tail,
+	             const Raul::Path& head) {}
+
+	void disconnect(const Raul::Path& tail,
+	                const Raul::Path& head) {}
+
+	void disconnect_all(const Raul::Path& parent_patch_path,
+	                    const Raul::Path& path) {}
+
+	void set_property(const Raul::URI& subject,
+	                  const Raul::URI& predicate,
+	                  const Atom&      value) {}
+
+	void set_response_id(int32_t id) {}
+
+	void get(const Raul::URI& uri) {}
+
+	void undo() {}
+
+	void redo() {}
+
+	void response(int32_t id, Status status, const std::string& subject) {
+		if (status != Status::SUCCESS) {
+			_log.error(fmt("error on message %1%: %2% (%3%)\n")
+			           % id % ingen_status_string(status) % subject);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	void error(const std::string& msg) {
+		_log.error(fmt("error: %1%\n") % msg);
+		exit(EXIT_FAILURE);
+	}
+
+private:
+	Log& _log;
+};
+
+#endif // INGEN_TESTCLIENT_HPP
diff --git a/tests/ingen_bench.cpp b/tests/ingen_bench.cpp
new file mode 100644
index 00000000..c8203331
--- /dev/null
+++ b/tests/ingen_bench.cpp
@@ -0,0 +1,189 @@
+/*
+  This file is part of Ingen.
+  Copyright 2007-2017 David Robillard <http://drobilla.net/>
+
+  Ingen is free software: you can redistribute it and/or modify it under the
+  terms of the GNU Affero General Public License as published by the Free
+  Software Foundation, either version 3 of the License, or any later version.
+
+  Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+  A PARTICULAR PURPOSE.  See the GNU Affero General Public License for details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <signal.h>
+#include <stdlib.h>
+
+#include <iostream>
+#include <string>
+#include <thread>
+
+#include <boost/optional.hpp>
+
+#include <glibmm/convert.h>
+#include <glibmm/miscutils.h>
+#include <glibmm/thread.h>
+#include <glibmm/timer.h>
+
+#include "raul/Path.hpp"
+
+#include "serd/serd.h"
+#include "sord/sordmm.hpp"
+#include "sratom/sratom.h"
+
+#include "ingen_config.h"
+
+#include "ingen/AtomReader.hpp"
+#include "ingen/AtomWriter.hpp"
+#include "ingen/Configuration.hpp"
+#include "ingen/Configuration.hpp"
+#include "ingen/EngineBase.hpp"
+#include "ingen/Interface.hpp"
+#include "ingen/Parser.hpp"
+#include "ingen/Serialiser.hpp"
+#include "ingen/Store.hpp"
+#include "ingen/URIMap.hpp"
+#include "ingen/World.hpp"
+#include "ingen/client/ThreadedSigClientInterface.hpp"
+#include "ingen/runtime_paths.hpp"
+#include "ingen/types.hpp"
+#include "../src/server/Clock.hpp" // FIXME
+
+#include "TestClient.hpp"
+
+using namespace std;
+using namespace Ingen;
+
+World* world = NULL;
+
+static void
+ingen_try(bool cond, const char* msg)
+{
+	if (!cond) {
+		cerr << "ingen: Error: " << msg << endl;
+		delete world;
+		exit(EXIT_FAILURE);
+	}
+}
+
+static uint32_t
+flush_events(Ingen::World* world, const uint32_t start)
+{
+	static const uint32_t block_length = 4096;
+	int                   count        = 0;
+	uint32_t              offset       = start;
+	while (world->engine()->pending_events()) {
+		world->engine()->locate(offset, block_length);
+		world->engine()->run(block_length);
+		world->engine()->main_iteration();
+		g_usleep(1000);
+		++count;
+		offset += block_length;
+	}
+	return offset;
+}
+
+static std::string
+real_path(const char* path)
+{
+	char* const       c_real_path = realpath(path, NULL);
+	const std::string result(c_real_path ? c_real_path : "");
+	free(c_real_path);
+	return result;
+}
+
+int
+main(int argc, char** argv)
+{
+	Glib::thread_init();
+	set_bundle_path_from_code((void*)&flush_events);
+
+	// Create world
+	try {
+		world = new World(NULL, NULL, NULL);
+		world->conf().add(
+			"output", "output", 'O', "File to write benchmark output",
+			Ingen::Configuration::SESSION, world->forge().String, Atom());
+		world->load_configuration(argc, argv);
+	} catch (std::exception& e) {
+		cout << "ingen: " << e.what() << endl;
+		return EXIT_FAILURE;
+	}
+
+	// Get mandatory command line arguments
+	const Atom& load = world->conf().option("load");
+	const Atom& out  = world->conf().option("output");
+	if (!load.is_valid() || !out.is_valid()) {
+		cerr << "Usage: ingen_bench --load START_GRAPH --output OUT_FILE" << endl;
+		return EXIT_FAILURE;
+	}
+
+	// Get start graph and output file options
+	const std::string start_graph = real_path((const char*)load.get_body());
+	const std::string out_file    = (const char*)out.get_body();
+	if (start_graph.empty()) {
+		cerr << "error: initial graph '"
+		     << ((const char*)load.get_body())
+		     << "' does not exist" << endl;
+		return EXIT_FAILURE;
+	}
+
+	// Load modules
+	ingen_try(world->load_module("server_profiled"),
+	          "Unable to load server module");
+
+	// Initialise engine
+	ingen_try(bool(world->engine()),
+	          "Unable to create engine");
+	world->engine()->init(48000.0, 4096, 4096);
+	world->engine()->activate();
+
+	// Load graph
+	if (!world->parser()->parse_file(world, world->interface().get(), start_graph)) {
+		cerr << "error: failed to load initial graph " << start_graph << endl;
+		return EXIT_FAILURE;
+	}
+	uint32_t time = flush_events(world, 0);
+
+	Ingen::Server::Clock clock;
+	static const uint32_t n_test_frames = 1 << 20;
+	static const uint32_t block_length = 4096;
+
+	// Set up real-time scheduling for this (main run) thread
+	pthread_t   pthread = pthread_self();
+	const int   policy  = SCHED_FIFO;
+	sched_param sp;
+	sp.sched_priority = 90;
+	if (pthread_setschedparam(pthread, policy, &sp)) {
+		world->log().error(
+			fmt("Failed to set real-time priority of run thread (%s)\n")
+			% strerror(errno));
+	}
+
+	const uint64_t t_start = clock.now_microseconds();
+	for (uint32_t i = time; i < time + n_test_frames; i += block_length) {
+		world->engine()->locate(i, block_length);
+		world->engine()->run(block_length);
+		//world->engine()->main_iteration();
+	}
+	const uint64_t t_end = clock.now_microseconds();
+
+	FILE* log = fopen(out_file.c_str(), "a");
+	if (ftell(log) == 0) {
+		fprintf(log, "n_threads\trun_time\tn_frames\n");
+	}
+	fprintf(log, "%u\t%llu\t%u\n",
+	        world->conf().option("threads").get<int32_t>(),
+	        t_end - t_start,
+	        n_test_frames);
+	fclose(log);
+
+	// Shut down
+	world->engine()->deactivate();
+
+	delete world;
+	return EXIT_SUCCESS;
+}
diff --git a/tests/ingen_test.cpp b/tests/ingen_test.cpp
index 1ac2e383..d55789db 100644
--- a/tests/ingen_test.cpp
+++ b/tests/ingen_test.cpp
@@ -51,78 +51,13 @@
 #include "ingen/runtime_paths.hpp"
 #include "ingen/types.hpp"
 
+#include "TestClient.hpp"
+
 using namespace std;
 using namespace Ingen;
 
 World* world = NULL;
 
-class TestClient : public Interface
-{
-public:
-	explicit TestClient(Log& log) : _log(log) {}
-	~TestClient() {}
-
-	Raul::URI uri() const { return Raul::URI("ingen:testClient"); }
-
-	void bundle_begin() {}
-
-	void bundle_end() {}
-
-	void put(const Raul::URI&  uri,
-	         const Properties& properties,
-	         Resource::Graph   ctx = Resource::Graph::DEFAULT) {}
-
-	void delta(const Raul::URI&  uri,
-	           const Properties& remove,
-	           const Properties& add) {}
-
-	void copy(const Raul::URI& old_uri,
-	          const Raul::URI& new_uri) {}
-
-	void move(const Raul::Path& old_path,
-	          const Raul::Path& new_path) {}
-
-	void del(const Raul::URI& uri) {}
-
-	void connect(const Raul::Path& tail,
-	             const Raul::Path& head) {}
-
-	void disconnect(const Raul::Path& tail,
-	                const Raul::Path& head) {}
-
-	void disconnect_all(const Raul::Path& parent_patch_path,
-	                    const Raul::Path& path) {}
-
-	void set_property(const Raul::URI& subject,
-	                  const Raul::URI& predicate,
-	                  const Atom&      value) {}
-
-	void set_response_id(int32_t id) {}
-
-	void get(const Raul::URI& uri) {}
-
-	void undo() {}
-
-	void redo() {}
-
-	void response(int32_t id, Status status, const std::string& subject) {
-		if (status != Status::SUCCESS) {
-			_log.error(fmt("error on message %1%: %2% (%3%)\n")
-			           % id % ingen_status_string(status) % subject);
-			exit(EXIT_FAILURE);
-		}
-	}
-
-	void error(const std::string& msg) {
-		_log.error(fmt("error: %1%\n") % msg);
-		exit(EXIT_FAILURE);
-	}
-
-private:
-	Log& _log;
-};
-
-
 static void
 ingen_try(bool cond, const char* msg)
 {
@@ -158,7 +93,8 @@ main(int argc, char** argv)
 
 	// Create world
 	try {
-		world = new World(argc, argv, NULL, NULL, NULL);
+		world = new World(NULL, NULL, NULL);
+		world->load_configuration(argc, argv);
 	} catch (std::exception& e) {
 		cout << "ingen: " << e.what() << endl;
 		return EXIT_FAILURE;
@@ -194,7 +130,7 @@ main(int argc, char** argv)
 	world->engine()->init(48000.0, 4096, 4096);
 	world->engine()->activate();
 
-	// Load patch
+	// Load graph
 	if (!world->parser()->parse_file(world, world->interface().get(), start_graph)) {
 		cerr << "error: failed to load initial graph " << start_graph << endl;
 		return EXIT_FAILURE;
diff --git a/wscript b/wscript
index 538e2b84..5ff3f4ba 100644
--- a/wscript
+++ b/wscript
@@ -234,15 +234,16 @@ def build(bld):
 
     # Test program
     if bld.env.BUILD_TESTS:
-        obj = bld(features     = 'cxx cxxprogram',
-                  source       = 'tests/ingen_test.cpp',
-                  target       = 'tests/ingen_test',
-                  includes     = ['.'],
-                  use          = 'libingen_profiled',
-                  install_path = '',
-                  cxxflags     = bld.env.INGEN_TEST_CXXFLAGS,
-                  linkflags    = bld.env.INGEN_TEST_LINKFLAGS)
-    autowaf.use_lib(bld, obj, 'GTHREAD GLIBMM SORD RAUL LILV INGEN LV2 SRATOM')
+        for i in ['ingen_test', 'ingen_bench']:
+            obj = bld(features     = 'cxx cxxprogram',
+                      source       = 'tests/%s.cpp' % i,
+                      target       = 'tests/%s' % i,
+                      includes     = ['.'],
+                      use          = 'libingen_profiled',
+                      install_path = '',
+                      cxxflags     = bld.env.INGEN_TEST_CXXFLAGS,
+                      linkflags    = bld.env.INGEN_TEST_LINKFLAGS)
+            autowaf.use_lib(bld, obj, 'GTHREAD GLIBMM SORD RAUL LILV INGEN LV2 SRATOM')
 
     bld.install_files('${DATADIR}/applications', 'src/ingen/ingen.desktop')
     bld.install_files('${BINDIR}', 'scripts/ingenish', chmod=Utils.O755)