sourcemod/core/thread/BaseWorker.cpp

/**
 * vim: set ts=4 :
 * =============================================================================
 * SourceMod
 * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.
 * =============================================================================
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, version 3.0, as published by the
 * Free Software Foundation.
 * 
 * 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/>.
 *
 * As a special exception, AlliedModders LLC gives you permission to link the
 * code of this program (as well as its derivative works) to "Half-Life 2," the
 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
 * by the Valve Corporation.  You must obey the GNU General Public License in
 * all respects for all other code used.  Additionally, AlliedModders LLC grants
 * this exception to all derivative works.  AlliedModders LLC defines further
 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
 * or <http://www.sourcemod.net/license.php>.
 *
 * Version: $Id$
 */

#include "BaseWorker.h"

BaseWorker::BaseWorker(IThreadWorkerCallbacks *hooks) : 
	m_perFrame(SM_DEFAULT_THREADS_PER_FRAME),
	m_state(Worker_Stopped),
	m_pHooks(hooks)
{
}

BaseWorker::~BaseWorker()
{
	if (m_state != Worker_Stopped || m_state != Worker_Invalid)
		Stop(true);

	if (m_ThreadQueue.size())
		Flush(true);
}

void BaseWorker::MakeThread(IThread *pThread)
{
	ThreadParams pt;

	pt.flags = Thread_AutoRelease;
	pt.prio = ThreadPrio_Normal;

	MakeThread(pThread, &pt);
}

IThreadHandle *BaseWorker::MakeThread(IThread *pThread, ThreadFlags flags)
{
	ThreadParams pt;

	pt.flags = flags;
	pt.prio = ThreadPrio_Normal;

	return MakeThread(pThread, &pt);
}

IThreadHandle *BaseWorker::MakeThread(IThread *pThread, const ThreadParams *params)
{
	if (m_state != Worker_Running)
		return NULL;

	SWThreadHandle *swt = new SWThreadHandle(this, params, pThread);

	AddThreadToQueue(swt);

	return swt;
}

void BaseWorker::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)
{
	max = ThreadPrio_Normal;
	min = ThreadPrio_Normal;
}

unsigned int BaseWorker::Flush(bool flush_cancel)
{
	SWThreadHandle *swt;
	unsigned int num = 0;

	while ((swt=PopThreadFromQueue()) != NULL)
	{
		swt->m_state = Thread_Done;
		if (!flush_cancel)
			swt->pThread->RunThread(swt);
		swt->pThread->OnTerminate(swt, flush_cancel);
		if (swt->m_params.flags & Thread_AutoRelease)
			delete swt;
		num++;
	}

	return num;
}

SWThreadHandle *BaseWorker::PopThreadFromQueue()
{
	if (!m_ThreadQueue.size())
		return NULL;

	SourceHook::List<SWThreadHandle *>::iterator begin;
	SWThreadHandle *swt;

	begin = m_ThreadQueue.begin();
	swt = (*begin);
	m_ThreadQueue.erase(begin);

	return swt;
}

void BaseWorker::AddThreadToQueue(SWThreadHandle *pHandle)
{
	m_ThreadQueue.push_back(pHandle);
}

unsigned int BaseWorker::GetMaxThreadsPerFrame()
{
	return m_perFrame;
}

WorkerState BaseWorker::GetStatus(unsigned int *threads)
{
	if (threads)
		*threads = m_perFrame;

	return m_state;
}

unsigned int BaseWorker::RunFrame()
{
	unsigned int done = 0;
	unsigned int max = GetMaxThreadsPerFrame();
	SWThreadHandle *swt = NULL;
	IThread *pThread = NULL;

	while (done < max)
	{
		if ((swt=PopThreadFromQueue()) == NULL)
		{
			break;
		}
		pThread = swt->pThread;
		swt->m_state = Thread_Running;
		pThread->RunThread(swt);
		swt->m_state = Thread_Done;
		pThread->OnTerminate(swt, false);
		if (swt->m_params.flags & Thread_AutoRelease)
		{
			delete swt;
		}
		done++;
	}

	return done;
}

void BaseWorker::SetMaxThreadsPerFrame(unsigned int threads)
{
	m_perFrame = threads;
}

bool BaseWorker::Start()
{
	if (m_state != Worker_Invalid && m_state != Worker_Stopped)
	{
		return false;
	}

	m_state = Worker_Running;

	if (m_pHooks)
	{
		m_pHooks->OnWorkerStart(this);
	}

    return true;
}

bool BaseWorker::Stop(bool flush_cancel)
{
	if (m_state == Worker_Invalid || m_state == Worker_Stopped)
	{
		return false;
	}

	if (m_state == Worker_Paused)
	{
		if (!Unpause())
		{
			return false;
		}
	}

	m_state = Worker_Stopped;
	Flush(flush_cancel);

	if (m_pHooks)
	{
		m_pHooks->OnWorkerStop(this);
	}

	return true;
}

bool BaseWorker::Pause()
{
	if (m_state != Worker_Running)
	{
		return false;
	}

	m_state = Worker_Paused;

	return true;
}


bool BaseWorker::Unpause()
{
	if (m_state != Worker_Paused)
	{
		return false;
	}

	m_state = Worker_Running;

	return true;
}

/***********************
 * THREAD HANDLE STUFF *
 ***********************/

void SWThreadHandle::DestroyThis()
{
	delete this;
}

void SWThreadHandle::GetParams(ThreadParams *p)
{
	*p = m_params;
}

ThreadPriority SWThreadHandle::GetPriority()
{
	return m_params.prio;
}

ThreadState SWThreadHandle::GetState()
{
	return m_state;
}

IThreadCreator *SWThreadHandle::Parent()
{
	return m_parent;
}

bool SWThreadHandle::SetPriority(ThreadPriority prio)
{
	if (m_params.prio != ThreadPrio_Normal)
		return false;

	m_params.prio = prio;

	return true;
}

bool SWThreadHandle::Unpause()
{
	if (m_state != Thread_Paused)
		return false;

	m_state = Thread_Running;

	return true;
}

bool SWThreadHandle::WaitForThread()
{
	return false;
}

SWThreadHandle::SWThreadHandle(IThreadCreator *parent, const ThreadParams *p, IThread *thread) : 
	m_state(Thread_Paused), m_params(*p), m_parent(parent), pThread(thread)
{
}

IThread *SWThreadHandle::GetThread()
{
	return pThread;
}