pcsx2/common/include/Utilities/TlsVariable.inl

/*  PCSX2 - PS2 Emulator for PCs
 *  Copyright (C) 2002-2010  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
 *  ation, either version 3 of the License, or (at your option) any later version.
 *
 *  PCSX2 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 PCSX2.
 *  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include "Threading.h"

#if PCSX2_THREAD_LOCAL
#	define DeclareTls(x) __threadlocal x
#else
#	define DeclareTls(x) Threading::TlsVariable<x>
#endif

namespace Threading
{
// --------------------------------------------------------------------------------------
//  TlsVariable - Thread local storage
// --------------------------------------------------------------------------------------
// Wrapper class for pthread_getspecific, which is pthreads language for "thread local
// storage."  This class enables code to act as a drop-in replacement for compiler-native
// thread local storage (typically specified via __threadlocal).  Mac OS/X (Darwin) does
// not have TLS, which is the main reason for this class existing.
//
// Performance considerations: While certainly convenient, performance of this class can
// be sub-optimal when the operator overloads are used, since each one will most likely
// result in repeated calls to pthread_getspecific.  (if the function inlines then it
// should actually optimize well enough, but I doubt it does).
//
template< typename T >
class BaseTlsVariable
{
	DeclareNoncopyableObject(BaseTlsVariable<T>);

protected:
	pthread_key_t	m_thread_key;
	bool			m_IsDisposed;

public:
	BaseTlsVariable();

	virtual ~BaseTlsVariable() throw()
	{
		Dispose();
	}

	T* GetPtr() const;
	T& GetRef() const { return *GetPtr(); }

	operator T&() const		{ return GetRef(); }
	T* operator->() const	{ return GetPtr(); }

	void Dispose()
	{
		if (!m_IsDisposed)
		{
			m_IsDisposed = true;
			KillKey();
		}
	}

protected:
	void CreateKey();
	void KillKey();

	virtual void CreateInstance( T* result ) const
	{
		new (result) T();
	}

	static void _aligned_delete_and_free( void* ptr )
	{
		if (!ptr) return;
		((T*)ptr)->~T();
		_aligned_free(ptr);
	}
};

template< typename T >
class TlsVariable : public BaseTlsVariable<T>
{
	DeclareNoncopyableObject(TlsVariable<T>);

protected:
	T				m_initval;

public:
	TlsVariable() {}
	TlsVariable( const T& initval )
		: m_initval(initval) { }

	// This is needed; The C++ standard likes making life suck for programmers.
	using BaseTlsVariable<T>::GetRef;

	virtual ~TlsVariable() throw()
	{
		// disable the parent cleanup.  This leaks memory blocks, but its necessary because
		// TLS is expected to be persistent until the very end of execution on the main thread.
		// Killing the pthread_key at all will lead to the console logger death, etc.
		
		// DON'T REMOVE this->, the "official"[ly stupid] C++ standard requires it because of its
		// insistence that variables be looked up during initial template parsing and not during
		// instantiation.
		this->m_IsDisposed = true;
	}

	TlsVariable<T>& operator=( const T& src )
	{
		GetRef() = src;
		return *this;
	}

	bool operator==( const T& src ) const	{ return GetRef() == src; }
	bool operator!=( const T& src ) const	{ return GetRef() != src; }
	bool operator>( const T& src ) const	{ return GetRef() > src; }
	bool operator<( const T& src ) const	{ return GetRef() < src; }
	bool operator>=( const T& src ) const	{ return GetRef() >= src; }
	bool operator<=( const T& src ) const	{ return GetRef() <= src; }

	T operator+( const T& src ) const		{ return GetRef() + src; }
	T operator-( const T& src ) const		{ return GetRef() - src; }

	void operator+=( const T& src )			{ GetRef() += src; }
	void operator-=( const T& src )			{ GetRef() -= src; }
	
protected:
	virtual void CreateInstance( T* result ) const
	{
		new (result) T(m_initval);
	}
};
};

template< typename T >
Threading::BaseTlsVariable<T>::BaseTlsVariable()
{
	m_IsDisposed = false;
	CreateKey();
}

template< typename T >
void Threading::BaseTlsVariable<T>::KillKey()
{
	if (!m_thread_key) return;

	// Delete the handle for the current thread (which should always be the main/UI thread!)
	// This is needed because pthreads does *not* clean up the dangling objects when you delete
	// the key.  The TLS for the process main thread will only be deleted when the process
	// ends; which is too damn late (it shows up int he leaked memory blocks).

	BaseTlsVariable<T>::_aligned_delete_and_free( pthread_getspecific(m_thread_key) );

	pthread_key_delete( m_thread_key );
	m_thread_key = 0;
}

template< typename T >
T* Threading::BaseTlsVariable<T>::GetPtr() const
{
	T* result = (T*)pthread_getspecific( m_thread_key );
	if( result == NULL )
	{
		pthread_setspecific( m_thread_key, result = (T*)_aligned_malloc(sizeof(T), 16) );
		CreateInstance(result);
		if( result == NULL )
			throw Exception::OutOfMemory( L"thread local storage variable instance" );
	}
	return result;
}

template< typename T >
void Threading::BaseTlsVariable<T>::CreateKey()
{
	if( 0 != pthread_key_create(&m_thread_key, BaseTlsVariable<T>::_aligned_delete_and_free) )
	{
		pxFailRel( "Thread Local Storage Error: key creation failed.  This will most likely lead to a rapid application crash." );
	}
}