Initial commit

engines/mtropolis/vthread.cpp

@@ -0,0 +1,243 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "mtropolis/coroutines.h"
+#include "mtropolis/coroutine_manager.h"
+#include "mtropolis/vthread.h"
+
+namespace MTropolis {
+
+VThreadTaskData::VThreadTaskData() {
+}
+
+VThreadTaskData::~VThreadTaskData() {
+}
+
+VThreadStackChunk::VThreadStackChunk(size_t capacity)
+	: _memory(nullptr), _size(capacity), _topFrame(nullptr) {
+
+	_memory = static_cast<byte *>(malloc(capacity));
+	if (!_memory)
+		error("Out of memory");
+}
+
+VThreadStackChunk::VThreadStackChunk(VThreadStackChunk &&other)
+	: _memory(other._memory), _size(other._size), _topFrame(other._topFrame) {
+	other._memory = nullptr;
+	other._size = 0;
+	other._topFrame = nullptr;
+}
+
+VThreadStackChunk::~VThreadStackChunk() {
+	if (_memory)
+		free(_memory);
+}
+
+#ifdef MTROPOLIS_DEBUG_ENABLE
+void VThreadTaskData::debugInit(const char *name) {
+	_debugName = name;
+}
+
+void VThreadTaskData::debugInspect(IDebugInspectionReport *report) const {
+}
+#endif
+
+VThread::VThread(ICoroutineManager *coroManager)
+	: _numActiveStackChunks(0), _coroManager(coroManager) {
+}
+
+VThread::~VThread() {
+	while (popFrame()) {
+	}
+}
+
+VThreadState VThread::step() {
+	while (hasTasks()) {
+		VThreadStackFrame *frame = _stackChunks[_numActiveStackChunks - 1]._topFrame;
+
+		VThreadState state = frame->data->execute(this);
+		if (state != kVThreadReturn)
+			return state;
+	}
+
+	return kVThreadReturn;
+}
+
+bool VThread::hasTasks() const {
+	return _numActiveStackChunks > 0;
+}
+
+bool VThread::reserveFrameInChunk(VThreadStackChunk *chunk, size_t frameAlignment, size_t frameSize, VThreadStackFrame *&outFramePtr, size_t dataAlignment, size_t dataSize, void *&outDataPtr) {
+	VThreadStackFrame *framePtr = nullptr;
+	void *dataPtr = nullptr;
+
+	uintptr address = 0;
+	size_t bytesAvailable = 0;
+
+	if (chunk->_topFrame) {
+		address = reinterpret_cast<uintptr>(chunk->_topFrame);
+		bytesAvailable = static_cast<size_t>(reinterpret_cast<const byte *>(chunk->_topFrame) - chunk->_memory);
+	} else {
+		address = reinterpret_cast<uintptr>(chunk->_memory + chunk->_size);
+		bytesAvailable = chunk->_size;
+	}
+
+	if (bytesAvailable < dataSize)
+		return false;
+
+	bytesAvailable -= dataSize;
+	address -= dataSize;
+
+	size_t dataAlignPadding = static_cast<size_t>(address % dataAlignment);
+
+	if (bytesAvailable < dataAlignPadding)
+		return false;
+
+	bytesAvailable -= dataAlignPadding;
+	address -= dataAlignPadding;
+
+	dataPtr = reinterpret_cast<void *>(address);
+
+	if (bytesAvailable < frameSize)
+		return false;
+
+	bytesAvailable -= frameSize;
+	address -= frameSize;
+
+	size_t frameAlignPadding = static_cast<size_t>(address % frameAlignment);
+
+	if (bytesAvailable < frameAlignPadding)
+		return false;
+
+	bytesAvailable -= frameAlignPadding;
+	address -= frameAlignPadding;
+
+	framePtr = reinterpret_cast<VThreadStackFrame *>(address);
+
+	chunk->_topFrame = framePtr;
+
+	outDataPtr = dataPtr;
+	outFramePtr = framePtr;
+
+	return true;
+}
+
+void VThread::reserveFrame(size_t frameAlignment, size_t frameSize, VThreadStackFrame *&outFramePtr, size_t dataAlignment, size_t dataSize, void *&outDataPtr, bool &outIsNewChunk) {
+	// See if this fits in the last active chunk
+	if (_numActiveStackChunks > 0) {
+		VThreadStackChunk &lastChunk = _stackChunks[_numActiveStackChunks - 1];
+
+		if (reserveFrameInChunk(&lastChunk, frameAlignment, frameSize, outFramePtr, dataAlignment, dataSize, outDataPtr)) {
+			outIsNewChunk = false;
+			return;
+		}
+	}
+
+	// Didn't fit, this is the first one in the chunk
+	size_t requiredSize = (frameAlignment - 1) + (dataAlignment - 1) + frameSize + dataSize;
+
+	if (_numActiveStackChunks >= _stackChunks.size() || _stackChunks[_numActiveStackChunks]._size < requiredSize) {
+		// Doesn't fit in the next chunk, deallocate the chunk and all subsequent chunks and reallocate
+
+		const size_t kChunkMinSize = 1024 * 1024;	// 1MB chunks
+		size_t chunkSize = requiredSize;
+		if (chunkSize < kChunkMinSize)
+			chunkSize = kChunkMinSize;
+
+		while (_stackChunks.size() > _numActiveStackChunks)
+			_stackChunks.pop_back();
+
+		_stackChunks.push_back(VThreadStackChunk(chunkSize));
+	}
+
+	VThreadStackChunk &lastChunk = _stackChunks[_numActiveStackChunks++];
+
+	bool reservedOK = reserveFrameInChunk(&lastChunk, frameAlignment, frameSize, outFramePtr, dataAlignment, dataSize, outDataPtr);
+	assert(reservedOK);
+	(void)reservedOK;
+
+	outIsNewChunk = true;
+}
+
+void VThread::pushCoroutineInternal(CompiledCoroutine **compiledCoroPtr, CoroutineCompileFunction_t compileFunction, bool isVoidReturn, const CoroutineParamsBase &params, const CoroutineReturnValueRefBase &returnValueRef) {
+	const CompiledCoroutine *compiledCoro = *compiledCoroPtr;
+	if (compiledCoro == nullptr) {
+		_coroManager->compileCoroutine(compiledCoroPtr, compileFunction, isVoidReturn);
+		compiledCoro = *compiledCoroPtr;
+		assert(compiledCoro);
+	}
+
+	pushCoroutineFrame(compiledCoro, params, returnValueRef);
+}
+
+VThreadTaskData *VThread::pushCoroutineFrame(const CompiledCoroutine *compiledCoro, const CoroutineParamsBase &params, const CoroutineReturnValueRefBase &returnValueRef) {
+	const size_t frameAlignment = alignof(VThreadStackFrame);
+	size_t dataAlignment = 0;
+	size_t dataSize = 0;
+
+	compiledCoro->_getFrameParameters(dataSize, dataAlignment);
+
+	VThreadStackFrame *prevFrame = nullptr;
+	if (_numActiveStackChunks > 0)
+		prevFrame = _stackChunks[_numActiveStackChunks - 1]._topFrame;
+
+	VThreadStackFrame *framePtr = nullptr;
+	void *dataPtr = nullptr;
+	bool isNewChunk = false;
+	reserveFrame(frameAlignment, sizeof(VThreadStackFrame), framePtr, dataAlignment, dataSize, dataPtr, isNewChunk);
+
+	VThreadStackFrame *frame = new (framePtr) VThreadStackFrame();
+	VThreadTaskData *frameData = compiledCoro->_frameConstructor(dataPtr, compiledCoro, params, returnValueRef);
+
+	frame->data = frameData;
+	frame->prevFrame = prevFrame;
+	frame->isLastInChunk = isNewChunk;
+
+	return frameData;
+}
+
+bool VThread::popFrame() {
+	if (_numActiveStackChunks == 0)
+		return false;
+
+	VThreadStackChunk &lastChunk = _stackChunks[_numActiveStackChunks - 1];
+	VThreadStackFrame *topFrame = lastChunk._topFrame;
+
+	VThreadStackFrame *secondFrame = topFrame->prevFrame;
+	bool isLastFrameInChunk = topFrame->isLastInChunk;
+
+	if (isLastFrameInChunk) {
+		lastChunk._topFrame = nullptr;
+		_numActiveStackChunks--;
+	} else {
+		assert(reinterpret_cast<byte *>(secondFrame) >= lastChunk._memory);
+		assert(reinterpret_cast<byte *>(secondFrame) < lastChunk._memory + lastChunk._size);
+
+		lastChunk._topFrame = secondFrame;
+	}
+
+	topFrame->data->~VThreadTaskData();
+	topFrame->~VThreadStackFrame();
+
+	return true;
+}
+
+} // End of namespace MTropolis