yuzu/FasTC
1
0
Fork 0
mirror of https://github.com/yuzu-emu/FasTC.git synced 2025-01-08 22:05:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove boost threading.

Browse source
This commit is contained in:
Pavel Krajcevski 2013-11-11 17:07:57 -05:00
parent ed188ae415
commit 46e83c8b4a
2 changed files with 19 additions and 299 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
Core/CMakeLists.txt
View file

@ -91,71 +91,28 @@ INCLUDE_DIRECTORIES( ${FasTC_BINARY_DIR}/IO/include )
INCLUDE_DIRECTORIES( ${FasTC_SOURCE_DIR}/Core/include )
SET( THREAD_API )
SET( THREAD_APIS_AVAILABLE "None" )
###### Find Boost...
###### Find Threads....
IF( MSVC )
SET(ENV{BOOSTLIBDIR} "${MSVC_LIB_DIR}")
SET(ENV{BOOSTINCLUDEDIR} "${MSVC_INSTALL_PATH}/include")
ENDIF( MSVC )
SET( Boost_USE_STATIC_LIBS ON )
FIND_PACKAGE( Boost COMPONENTS thread system date_time chrono )
IF( Boost_FOUND )
SET( THREAD_APIS_AVAILABLE "Boost" ${THREAD_APIS_AVAILABLE} )
IF( "${THREAD_API}" STREQUAL "" )
SET( THREAD_API "Boost" )
ENDIF()
ENDIF()
###### Find PThreads....
FIND_PACKAGE( Threads )
IF( CMAKE_USE_PTHREADS_INIT )
SET( THREAD_APIS_AVAILABLE "PThread" ${THREAD_APIS_AVAILABLE} )
IF( "${THREAD_API}" STREQUAL "" )
SET( THREAD_API "PThread" )
ENDIF()
ENDIF()
IF( "${THREAD_API}" STREQUAL "" )
SET( THREAD_API "None" )
ENDIF()
SET( THREAD_API_DESC "API used to implement threading operations")
SET( THREAD_API ${THREAD_API} CACHE STRING ${THREAD_API_DESC} FORCE )
SET_PROPERTY( CACHE THREAD_API PROPERTY STRINGS ${THREAD_APIS_AVAILABLE} )
IF( THREAD_API MATCHES "Boost")
INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIR} )
SET( SOURCES ${SOURCES} "src/ThreadBoost.cpp" )
LINK_DIRECTORIES( ${Boost_LIBRARY_DIRS} )
ENDIF()
IF( THREAD_API MATCHES "PThread" )
SET( SOURCES ${SOURCES} "src/ThreadPThread.cpp" )
ENDIF()
IF( THREAD_API MATCHES "None")
MESSAGE( FATAL_ERROR "Could not find suitable threading library." )
SET( SOURCES ${SOURCES} "src/ThreadWin32.cpp" )
ELSE()
SET( SOURCES ${SOURCES} "src/Thread.cpp" )
SET( HEADERS ${HEADERS} "src/ThreadSafeStreambuf.cpp" )
SET( SOURCES ${SOURCES} "src/ThreadGroup.cpp" )
SET( SOURCES ${SOURCES} "src/WorkerQueue.cpp" )
SET( HEADERS ${HEADERS} "src/Thread.h" )
SET( HEADERS ${HEADERS} "include/ThreadSafeStreambuf.h" )
SET( HEADERS ${HEADERS} "src/ThreadGroup.h" )
SET( HEADERS ${HEADERS} "src/WorkerQueue.h" )
FIND_PACKAGE( Threads )
IF( CMAKE_USE_PTHREADS_INIT )
SET( SOURCES ${SOURCES} "src/ThreadPThread.cpp" )
ELSE()
MESSAGE( FATAL_ERROR "Could not find suitable threading library." )
ENDIF()
ENDIF()
SET( HEADERS ${HEADERS} "src/Thread.h" )
SET( HEADERS ${HEADERS} "include/ThreadSafeStreambuf.h" )
SET( HEADERS ${HEADERS} "src/ThreadGroup.h" )
SET( HEADERS ${HEADERS} "src/WorkerQueue.h" )
SET( SOURCES ${SOURCES} "src/ThreadSafeStreambuf.cpp" )
SET( SOURCES ${SOURCES} "src/Thread.cpp" )
SET( SOURCES ${SOURCES} "src/ThreadGroup.cpp" )
SET( SOURCES ${SOURCES} "src/WorkerQueue.cpp" )
ADD_LIBRARY( FasTCCore
${HEADERS}
${SOURCES}
@ -168,11 +125,7 @@ TARGET_LINK_LIBRARIES( FasTCCore DXTEncoder )
TARGET_LINK_LIBRARIES( FasTCCore BPTCEncoder )
TARGET_LINK_LIBRARIES( FasTCCore PVRTCEncoder )
IF( THREAD_API MATCHES "Boost" )
TARGET_LINK_LIBRARIES( FasTCCore ${Boost_LIBRARIES} )
ENDIF()
IF( THREAD_API MATCHES "PThread" )
IF( CMAKE_USE_PTHREADS_INIT )
TARGET_LINK_LIBRARIES( FasTCCore ${CMAKE_THREAD_LIBS_INIT} )
ENDIF()

233
Core/src/ThreadBoost.cpp
View file

@ -1,233 +0,0 @@
/* FasTC
* Copyright (c) 2012 University of North Carolina at Chapel Hill. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and its documentation for educational,
* research, and non-profit purposes, without fee, and without a written agreement is hereby granted,
* provided that the above copyright notice, this paragraph, and the following four paragraphs appear
* in all copies.
*
* Permission to incorporate this software into commercial products may be obtained by contacting the
* authors or the Office of Technology Development at the University of North Carolina at Chapel Hill <otd@unc.edu>.
*
* This software program and documentation are copyrighted by the University of North Carolina at Chapel Hill.
* The software program and documentation are supplied "as is," without any accompanying services from the
* University of North Carolina at Chapel Hill or the authors. The University of North Carolina at Chapel Hill
* and the authors do not warrant that the operation of the program will be uninterrupted or error-free. The
* end-user understands that the program was developed for research purposes and is advised not to rely
* exclusively on the program for any reason.
*
* IN NO EVENT SHALL THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL OR THE AUTHORS BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE
* USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL OR THE
* AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL AND THE AUTHORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AND ANY
* STATUTORY WARRANTY OF NON-INFRINGEMENT. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY
* OF NORTH CAROLINA AT CHAPEL HILL AND THE AUTHORS HAVE NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
* ENHANCEMENTS, OR MODIFICATIONS.
*
* Please send all BUG REPORTS to <pavel@cs.unc.edu>.
*
* The authors may be contacted via:
*
* Pavel Krajcevski
* Dept of Computer Science
* 201 S Columbia St
* Frederick P. Brooks, Jr. Computer Science Bldg
* Chapel Hill, NC 27599-3175
* USA
*
* <http://gamma.cs.unc.edu/FasTC/>
*/
#include "Thread.h"
#include <assert.h>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>
////////////////////////////////////////////////////////////////////////////////
//
// Thread Implementation
//
////////////////////////////////////////////////////////////////////////////////
class TCThreadImpl : public TCThreadBaseImpl {
private:
class Instance {
private:
TCCallable &m_Callable;
public:
Instance(TCCallable &c) : m_Callable(c) { }
void operator()() {
m_Callable();
}
};
boost::thread m_Thread;
public:
TCThreadImpl(TCCallable &callable)
: m_Thread(Instance(callable))
{ }
virtual ~TCThreadImpl() { }
void Join() {
m_Thread.join();
}
};
class TCThreadImplFactory : public TCThreadBaseImplFactory {
TCCallable &m_Callable;
public:
TCThreadImplFactory(TCCallable &callable) : m_Callable(callable) { }
virtual ~TCThreadImplFactory() { }
virtual TCThreadBaseImpl *CreateImpl() const {
return new TCThreadImpl(m_Callable);
}
};
TCThread::TCThread(TCCallable &callable)
: TCThreadBase(TCThreadImplFactory(callable))
{ }
void TCThread::Join() {
CheckReferenceCount();
((TCThreadImpl *)m_Impl)->Join();
}
void TCThread::Yield() {
boost::thread::yield();
}
uint64 TCThread::ThreadID() {
boost::thread::id thisID = boost::this_thread::get_id();
std::stringstream ss;
ss << thisID;
uint64 retID;
ss >> retID;
return retID;
}
////////////////////////////////////////////////////////////////////////////////
//
// Mutex Implementation
//
////////////////////////////////////////////////////////////////////////////////
class TCMutexImpl : public TCThreadBaseImpl {
private:
boost::mutex m_Mutex;
public:
boost::mutex &GetMutex() { return m_Mutex; }
virtual ~TCMutexImpl() { }
};
class TCMutexImplFactory : public TCThreadBaseImplFactory {
public:
TCMutexImplFactory() { }
virtual ~TCMutexImplFactory() { }
virtual TCThreadBaseImpl *CreateImpl() const {
return new TCMutexImpl();
}
};
TCMutex::TCMutex() : TCThreadBase(TCMutexImplFactory())
{ }
////////////////////////////////////////////////////////////////////////////////
//
// Lock Implementation
//
////////////////////////////////////////////////////////////////////////////////
class TCLockImpl : public TCThreadBaseImpl {
private:
boost::unique_lock<boost::mutex> lock;
public:
TCLockImpl(TCMutex &mutex)
: lock(((TCMutexImpl *)(mutex.m_Impl))->GetMutex())
{ }
virtual ~TCLockImpl() { }
boost::unique_lock<boost::mutex> &GetLock() { return lock; }
};
class TCLockImplFactory : public TCThreadBaseImplFactory {
private:
TCMutex &m_Mutex;
public:
TCLockImplFactory(TCMutex &mutex) : m_Mutex(mutex){ }
virtual ~TCLockImplFactory() { }
virtual TCThreadBaseImpl *CreateImpl() const {
return new TCLockImpl(m_Mutex);
}
};
TCLock::TCLock(TCMutex &mutex) : TCThreadBase(TCLockImplFactory(mutex))
{ }
////////////////////////////////////////////////////////////////////////////////
//
// Condition Variable Implementation
//
////////////////////////////////////////////////////////////////////////////////
class TCConditionVariableImpl : public TCThreadBaseImpl {
private:
boost::condition_variable m_CV;
public:
TCConditionVariableImpl() { }
virtual ~TCConditionVariableImpl() { }
void Wait(TCLock &lock) {
TCLockImpl *lockImpl = (TCLockImpl *)(lock.m_Impl);
m_CV.wait(lockImpl->GetLock());
}
void NotifyOne() {
m_CV.notify_one();
}
void NotifyAll() {
m_CV.notify_all();
}
};
class TCConditionVariableImplFactory : public TCThreadBaseImplFactory {
public:
TCConditionVariableImplFactory() { }
virtual ~TCConditionVariableImplFactory() { }
virtual TCThreadBaseImpl *CreateImpl() const {
return new TCConditionVariableImpl();
}
};
TCConditionVariable::TCConditionVariable()
: TCThreadBase(TCConditionVariableImplFactory())
{ }
void TCConditionVariable::Wait(TCLock &lock) {
CheckReferenceCount();
TCConditionVariableImpl *impl = (TCConditionVariableImpl *)m_Impl;
impl->Wait(lock);
}
void TCConditionVariable::NotifyOne() {
CheckReferenceCount();
TCConditionVariableImpl *impl = (TCConditionVariableImpl *)m_Impl;
impl->NotifyOne();
}
void TCConditionVariable::NotifyAll() {
CheckReferenceCount();
TCConditionVariableImpl *impl = (TCConditionVariableImpl *)m_Impl;
impl->NotifyAll();
}