From baeb3c1872a989b69eb89fae04f93c59b06f258e Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
Date: Wed, 9 May 2012 01:14:30 +0000
Subject: Simply event interface design and make only one pre-process thread.

This makes event pre-processing actually safe for multiple interfaces since multiple events will never be pre-processed simultaneously and the pre-process order is definitely the same as the execute order.


git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@4323 a436a847-0d15-0410-975c-d299462d15a1
---
 src/server/PreProcessor.cpp | 125 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 src/server/PreProcessor.cpp

(limited to 'src/server/PreProcessor.cpp')

diff --git a/src/server/PreProcessor.cpp b/src/server/PreProcessor.cpp
new file mode 100644
index 00000000..a88b74e5
--- /dev/null
+++ b/src/server/PreProcessor.cpp
@@ -0,0 +1,125 @@
+/*
+  This file is part of Ingen.
+  Copyright 2007-2012 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 "Event.hpp"
+#include "PostProcessor.hpp"
+#include "PreProcessor.hpp"
+#include "ProcessContext.hpp"
+#include "ThreadManager.hpp"
+
+using namespace std;
+
+namespace Ingen {
+namespace Server {
+
+PreProcessor::PreProcessor()
+{
+	Thread::set_context(THREAD_PRE_PROCESS);
+	set_name("PreProcessor");
+	start();
+}
+
+PreProcessor::~PreProcessor()
+{
+	stop();
+}
+
+void
+PreProcessor::event(Event* const ev)
+{
+	// TODO: Probably possible to make this lock-free with CAS
+	Glib::Mutex::Lock lock(_mutex);
+
+	assert(!ev->is_prepared());
+	assert(!ev->next());
+
+	Event* const head = _head.get();
+	Event* const tail = _tail.get();
+
+	if (!head) {
+		_head = ev;
+		_tail = ev;
+	} else {
+		_tail = ev;
+		tail->next(ev);
+	}
+
+	if (!_prepared_back.get()) {
+		_prepared_back = ev;
+	}
+
+	whip();
+}
+
+bool
+PreProcessor::process(PostProcessor& dest, ProcessContext& context, bool limit)
+{
+	ThreadManager::assert_thread(THREAD_PROCESS);
+
+	if (!_head.get())
+		return true;
+
+	/* Limit the maximum number of queued events to process per cycle.  This
+	   makes the process callback (more) realtime-safe by preventing being
+	   choked by events coming in faster than they can be processed.
+	   FIXME: test this and figure out a good value
+	*/
+	const size_t MAX_QUEUED_EVENTS = context.nframes() / 32;
+
+	size_t num_events_processed = 0;
+
+	Event* ev   = _head.get();
+	Event* last = ev;
+
+	while (ev && ev->is_prepared() && ev->time() < context.end()) {
+		ev->execute(context);
+		last = ev;
+		ev = (Event*)ev->next();
+		++num_events_processed;
+		if (limit && (num_events_processed > MAX_QUEUED_EVENTS))
+			break;
+	}
+
+	if (num_events_processed > 0) {
+		Event* next = (Event*)last->next();
+		last->next(NULL);
+		assert(!last->next());
+		dest.append(_head.get(), last);
+		_head = next;
+		if (!next)
+			_tail = NULL;
+	}
+
+	return true;
+}
+
+/** Pre-process a single event */
+void
+PreProcessor::_whipped()
+{
+	Event* ev = _prepared_back.get();
+	if (!ev)
+		return;
+
+	assert(!ev->is_prepared());
+	ev->pre_process();
+	assert(ev->is_prepared());
+
+	_prepared_back = (Event*)ev->next();
+}
+
+} // namespace Server
+} // namespace Ingen
-- 
cgit v1.2.1