kaetemi
11 years ago
parent
2f302e93a9
commit
b74c3cc9fa
@ -1,97 +0,0 @@
|
||||
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
||||
// Copyright (C) 2010 Winch Gate Property Limited
|
||||
//
|
||||
// This program 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 (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 Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef NL_P_THREAD_H
|
||||
#define NL_P_THREAD_H
|
||||
|
||||
#include "types_nl.h"
|
||||
|
||||
#ifdef NL_OS_UNIX
|
||||
|
||||
#include "thread.h"
|
||||
#include <pthread.h>
|
||||
|
||||
|
||||
namespace NLMISC {
|
||||
|
||||
|
||||
/**
|
||||
* Posix Thread
|
||||
* \author Olivier Cado
|
||||
* \author Nevrax France
|
||||
* \date 2001
|
||||
*/
|
||||
class CPThread : public IThread
|
||||
{
|
||||
public:
|
||||
enum TThreadState
|
||||
{
|
||||
ThreadStateNone,
|
||||
ThreadStateRunning,
|
||||
ThreadStateFinished,
|
||||
};
|
||||
|
||||
/// Constructor
|
||||
CPThread( IRunnable *runnable, uint32 stackSize);
|
||||
|
||||
virtual ~CPThread();
|
||||
|
||||
virtual void start();
|
||||
virtual bool isRunning();
|
||||
virtual void terminate();
|
||||
virtual void wait();
|
||||
virtual bool setCPUMask(uint64 cpuMask);
|
||||
virtual uint64 getCPUMask();
|
||||
virtual void setPriority(TThreadPriority priority);
|
||||
virtual std::string getUserName();
|
||||
|
||||
virtual IRunnable *getRunnable()
|
||||
{
|
||||
return Runnable;
|
||||
}
|
||||
|
||||
/// Internal use
|
||||
IRunnable *Runnable;
|
||||
|
||||
TThreadState _State;
|
||||
pthread_t _ThreadHandle;
|
||||
|
||||
private:
|
||||
uint32 _StackSize;
|
||||
};
|
||||
|
||||
/**
|
||||
* Posix Process
|
||||
* \author Cyril 'Hulud' Corvazier
|
||||
* \author Nevrax France
|
||||
* \date 2001
|
||||
*/
|
||||
class CPProcess : public IProcess
|
||||
{
|
||||
public:
|
||||
virtual ~CPProcess() {}
|
||||
virtual uint64 getCPUMask();
|
||||
virtual bool setCPUMask(uint64 mask);
|
||||
};
|
||||
|
||||
} // NLMISC
|
||||
|
||||
|
||||
#endif // NL_OS_UNIX
|
||||
|
||||
#endif // NL_P_THREAD_H
|
||||
|
||||
/* End of p_thread.h */
|
||||
@ -1,145 +0,0 @@
|
||||
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
||||
// Copyright (C) 2010 Winch Gate Property Limited
|
||||
//
|
||||
// This program 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 (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 Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef NL_WIN_THREAD_H
|
||||
#define NL_WIN_THREAD_H
|
||||
|
||||
#include "types_nl.h"
|
||||
#include "thread.h"
|
||||
|
||||
#ifdef NL_OS_WINDOWS
|
||||
|
||||
namespace NLMISC {
|
||||
|
||||
|
||||
/**
|
||||
* Windows implementation of CThread class (look thread.h)
|
||||
* \author Vianney Lecroart
|
||||
* \author Nevrax France
|
||||
* \date 2000
|
||||
*/
|
||||
class CWinThread : public IThread
|
||||
{
|
||||
public:
|
||||
|
||||
/// Constructor
|
||||
CWinThread(IRunnable *runnable, uint32 stackSize);
|
||||
|
||||
/// Don't use this constructor, only used to initialise the main thread class
|
||||
CWinThread (void* threadHandle, uint32 threadId);
|
||||
|
||||
virtual ~CWinThread();
|
||||
|
||||
virtual void start();
|
||||
virtual bool isRunning();
|
||||
virtual void terminate();
|
||||
virtual void wait();
|
||||
virtual bool setCPUMask(uint64 cpuMask);
|
||||
virtual uint64 getCPUMask();
|
||||
virtual void setPriority(TThreadPriority priority);
|
||||
virtual std::string getUserName();
|
||||
|
||||
virtual IRunnable *getRunnable()
|
||||
{
|
||||
return Runnable;
|
||||
}
|
||||
|
||||
// Win32 specific
|
||||
// Get the suspend count. Will be -1 is the thread hasn't been started yet
|
||||
int getSuspendCount() const { return _SuspendCount; }
|
||||
// Increment the suspend count, a suspend count >= 1 means the thread is suspended
|
||||
void incSuspendCount();
|
||||
/** Descrement the suspend count. Reaching 0 will resume the thread
|
||||
* An assertion is raised is the suspend count is already 0
|
||||
*/
|
||||
void decSuspendCount();
|
||||
// Suspend the thread. No-op if already suspended
|
||||
void suspend();
|
||||
// Resume the thread. No-op if already resumed
|
||||
void resume();
|
||||
// Priority boost
|
||||
void enablePriorityBoost(bool enabled);
|
||||
|
||||
/// private use
|
||||
IRunnable *Runnable;
|
||||
|
||||
private:
|
||||
int _SuspendCount;
|
||||
uint32 _StackSize;
|
||||
void *ThreadHandle; // HANDLE don't put it to avoid including windows.h
|
||||
uint32 ThreadId; // DWORD don't put it to avoid including windows.h
|
||||
bool _MainThread; // true if ths thread is the main thread, else false
|
||||
};
|
||||
|
||||
/**
|
||||
* Windows Process
|
||||
* \author Cyril 'Hulud' Corvazier
|
||||
* \author Nicolas Vizerie
|
||||
* \author Nevrax France
|
||||
* \date 2001, 2007
|
||||
*/
|
||||
class CWinProcess : public IProcess
|
||||
{
|
||||
public:
|
||||
|
||||
CWinProcess (void *handle);
|
||||
virtual ~CWinProcess() {} // TODO do something with _ProcessHandle?
|
||||
|
||||
virtual uint64 getCPUMask();
|
||||
virtual bool setCPUMask(uint64 mask);
|
||||
|
||||
// processes helpers
|
||||
static bool enumProcessesId(std::vector<uint32> &processesId);
|
||||
// get fully qualified path for all modules used by a given process
|
||||
static bool enumProcessModules(uint32 processId, std::vector<std::string> &moduleNames);
|
||||
static uint32 getProcessIdFromModuleFilename(const std::string &moduleFileName);
|
||||
static bool terminateProcess(uint32 processId, uint exitCode = 0);
|
||||
static bool terminateProcessFromModuleName(const std::string &moduleName, uint exitCode = 0);
|
||||
|
||||
private:
|
||||
void *_ProcessHandle;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
// I didn't use and test that code, enventually, but maybe useful in the future
|
||||
//
|
||||
// Utility class to launch a process and check if it is still running.
|
||||
// Implemented under windows only for now
|
||||
//
|
||||
class CProcessWatch
|
||||
{
|
||||
public:
|
||||
CProcessWatch();
|
||||
~CProcessWatch();
|
||||
// launch a process with the given name and arguments, return true on success
|
||||
bool launch(const std::string &programName, const std::string &arguments);
|
||||
// return true if the process is still runing
|
||||
bool isRunning() const;
|
||||
private:
|
||||
class CProcessWatchImpl *_PImpl;
|
||||
};
|
||||
|
||||
*/
|
||||
|
||||
} // NLMISC
|
||||
|
||||
#endif // NL_OS_WINDOWS
|
||||
|
||||
#endif // NL_WIN_THREAD_H
|
||||
|
||||
/* End of win_thread.h */
|
||||
@ -1,387 +0,0 @@
|
||||
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
||||
// Copyright (C) 2010 Winch Gate Property Limited
|
||||
//
|
||||
// This program 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 (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 Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
#include "stdmisc.h"
|
||||
|
||||
#include <nel/misc/types_nl.h>
|
||||
#include <nel/misc/debug.h>
|
||||
|
||||
#ifdef NL_OS_UNIX
|
||||
|
||||
#include "nel/misc/p_thread.h"
|
||||
|
||||
#include <sched.h>
|
||||
#include <pwd.h>
|
||||
|
||||
#ifdef DEBUG_NEW
|
||||
#define new DEBUG_NEW
|
||||
#endif
|
||||
|
||||
namespace NLMISC {
|
||||
|
||||
/* Key for thread specific storage holding IThread pointer. */
|
||||
static pthread_key_t threadSpecificKey;
|
||||
|
||||
/* Special thread type representing the main thread. */
|
||||
struct CPMainThread : public CPThread
|
||||
{
|
||||
CPMainThread() : CPThread(NULL, 0)
|
||||
{
|
||||
if(pthread_key_create(&threadSpecificKey, NULL) != 0)
|
||||
throw EThread("cannot create thread specific storage key.");
|
||||
|
||||
if(pthread_setspecific(threadSpecificKey, this) != 0)
|
||||
throw EThread("cannot set main thread ptr in thread specific storage.");
|
||||
}
|
||||
|
||||
~CPMainThread()
|
||||
{
|
||||
if(pthread_key_delete(threadSpecificKey) != 0)
|
||||
throw EThread("cannot delete thread specific storage key.");
|
||||
}
|
||||
};
|
||||
|
||||
/* Holds the thread instance representing the main thread. */
|
||||
static CPMainThread mainThread = CPMainThread();
|
||||
|
||||
/*
|
||||
* The IThread static creator
|
||||
*/
|
||||
IThread *IThread::create( IRunnable *runnable, uint32 stackSize)
|
||||
{
|
||||
return new CPThread( runnable, stackSize );
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the current thread
|
||||
*/
|
||||
IThread *IThread::getCurrentThread ()
|
||||
{
|
||||
return (IThread *)pthread_getspecific(threadSpecificKey);
|
||||
}
|
||||
|
||||
/*
|
||||
* Thread beginning
|
||||
*/
|
||||
static void *ProxyFunc( void *arg )
|
||||
{
|
||||
CPThread *parent = (CPThread*)arg;
|
||||
|
||||
// Set this thread's thread specific storage to IThread instance pointer
|
||||
if(pthread_setspecific(threadSpecificKey, parent) != 0)
|
||||
throw EThread("cannot set thread ptr in thread specific storage.");
|
||||
|
||||
// Allow to terminate the thread without cancellation point
|
||||
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
|
||||
|
||||
// Run the code of the thread
|
||||
parent->Runnable->run();
|
||||
|
||||
{
|
||||
pthread_t thread_self = pthread_self();
|
||||
// Make sure the parent still cares
|
||||
// If this thread was replaced with a new thread (which should not happen),
|
||||
// and the IThread object has been deleted, this will likely crash.
|
||||
if (parent->_ThreadHandle == thread_self)
|
||||
parent->_State = CPThread::ThreadStateFinished;
|
||||
else
|
||||
throw EThread("Thread ended after being detached, this should not happen");
|
||||
}
|
||||
|
||||
// Allow some clean
|
||||
// pthread_exit(0);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Constructor
|
||||
*/
|
||||
CPThread::CPThread(IRunnable *runnable, uint32 stackSize)
|
||||
: Runnable(runnable),
|
||||
_State(ThreadStateNone),
|
||||
_StackSize(stackSize)
|
||||
{}
|
||||
|
||||
|
||||
/*
|
||||
* Destructor
|
||||
*/
|
||||
CPThread::~CPThread()
|
||||
{
|
||||
terminate(); // force the end of the thread if not already ended
|
||||
|
||||
if (_State != ThreadStateNone)
|
||||
pthread_detach(_ThreadHandle); // free allocated resources only if it was created
|
||||
}
|
||||
|
||||
/*
|
||||
* start
|
||||
*/
|
||||
void CPThread::start()
|
||||
{
|
||||
pthread_attr_t tattr;
|
||||
int ret;
|
||||
|
||||
if (_StackSize != 0)
|
||||
{
|
||||
/* initialized with default attributes */
|
||||
ret = pthread_attr_init(&tattr);
|
||||
|
||||
/* setting the size of the stack also */
|
||||
ret = pthread_attr_setstacksize(&tattr, _StackSize);
|
||||
}
|
||||
|
||||
bool detach_old_thread = false;
|
||||
pthread_t old_thread_handle;
|
||||
if (_State != ThreadStateNone)
|
||||
{
|
||||
if (_State == ThreadStateRunning)
|
||||
{
|
||||
// I don't know if this behaviour is allowed, but neither thread implementations
|
||||
// check the start function, and both simply let the existing running thread for what it is...
|
||||
// From now on, this is not allowed.
|
||||
throw EThread("Starting a thread that is already started, existing thread will continue running, this should not happen");
|
||||
}
|
||||
detach_old_thread = true;
|
||||
old_thread_handle = _ThreadHandle;
|
||||
}
|
||||
|
||||
if (pthread_create(&_ThreadHandle, _StackSize != 0 ? &tattr : NULL, ProxyFunc, this) != 0)
|
||||
{
|
||||
throw EThread("Cannot start new thread");
|
||||
}
|
||||
_State = ThreadStateRunning;
|
||||
|
||||
if (detach_old_thread)
|
||||
{
|
||||
// Docs don't say anything about what happens when pthread_create is called with existing handle referenced.
|
||||
if (old_thread_handle == _ThreadHandle)
|
||||
throw EThread("Thread handle did not change, this should not happen");
|
||||
// Don't care about old thread, free resources when it terminates.
|
||||
pthread_detach(old_thread_handle);
|
||||
}
|
||||
}
|
||||
|
||||
bool CPThread::isRunning()
|
||||
{
|
||||
return _State == ThreadStateRunning;
|
||||
}
|
||||
|
||||
/*
|
||||
* terminate
|
||||
*/
|
||||
void CPThread::terminate()
|
||||
{
|
||||
if (_State == ThreadStateRunning)
|
||||
{
|
||||
// cancel only if started
|
||||
pthread_cancel(_ThreadHandle);
|
||||
_State = ThreadStateFinished; // set to finished
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wait
|
||||
*/
|
||||
void CPThread::wait ()
|
||||
{
|
||||
if (_State == ThreadStateRunning)
|
||||
{
|
||||
int error = pthread_join(_ThreadHandle, 0);
|
||||
switch (error)
|
||||
{
|
||||
case 0:
|
||||
break;
|
||||
case EINVAL:
|
||||
throw EThread("Thread is not joinable");
|
||||
case ESRCH:
|
||||
throw EThread("No thread found with this id");
|
||||
case EDEADLK:
|
||||
throw EThread("Deadlock detected or calling thread waits for itself");
|
||||
default:
|
||||
throw EThread("Unknown thread join error");
|
||||
}
|
||||
if(_State != ThreadStateFinished)
|
||||
throw EThread("Thread did not finish, this should not happen");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* setCPUMask
|
||||
*/
|
||||
bool CPThread::setCPUMask(uint64 cpuMask)
|
||||
{
|
||||
#ifdef __USE_GNU
|
||||
|
||||
nlwarning("This code does not work. May cause a segmentation fault...");
|
||||
|
||||
sint res = pthread_setaffinity_np(_ThreadHandle, sizeof(uint64), (const cpu_set_t*)&cpuMask);
|
||||
|
||||
if (res)
|
||||
{
|
||||
nlwarning("pthread_setaffinity_np() returned %d", res);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
#else // __USE_GNU
|
||||
|
||||
return false;
|
||||
|
||||
#endif // __USE_GNU
|
||||
}
|
||||
|
||||
/*
|
||||
* getCPUMask
|
||||
*/
|
||||
uint64 CPThread::getCPUMask()
|
||||
{
|
||||
#ifdef __USE_GNU
|
||||
|
||||
nlwarning("This code does not work. May cause a segmentation fault...");
|
||||
|
||||
uint64 cpuMask = 0;
|
||||
|
||||
sint res = pthread_getaffinity_np(_ThreadHandle, sizeof(uint64), (cpu_set_t*)&cpuMask);
|
||||
|
||||
if (res)
|
||||
{
|
||||
nlwarning("pthread_getaffinity_np() returned %d", res);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return cpuMask;
|
||||
|
||||
#else // __USE_GNU
|
||||
|
||||
return 0;
|
||||
|
||||
#endif // __USE_GNU
|
||||
}
|
||||
|
||||
void CPThread::setPriority(TThreadPriority priority)
|
||||
{
|
||||
// TODO: Test this
|
||||
sched_param sp;
|
||||
switch (priority)
|
||||
{
|
||||
case ThreadPriorityHigh:
|
||||
{
|
||||
int minPrio = sched_get_priority_min(SCHED_FIFO);
|
||||
int maxPrio = sched_get_priority_max(SCHED_FIFO);
|
||||
sp.sched_priority = ((maxPrio - minPrio) / 4) + minPrio;
|
||||
pthread_setschedparam(_ThreadHandle, SCHED_FIFO, &sp);
|
||||
break;
|
||||
}
|
||||
case ThreadPriorityHighest:
|
||||
{
|
||||
int minPrio = sched_get_priority_min(SCHED_FIFO);
|
||||
int maxPrio = sched_get_priority_max(SCHED_FIFO);
|
||||
sp.sched_priority = ((maxPrio - minPrio) / 2) + minPrio;
|
||||
pthread_setschedparam(_ThreadHandle, SCHED_FIFO, &sp);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
sp.sched_priority = 0;
|
||||
pthread_setschedparam(_ThreadHandle, SCHED_OTHER, &sp);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* getUserName
|
||||
*/
|
||||
std::string CPThread::getUserName()
|
||||
{
|
||||
struct passwd *pw = getpwuid(getuid());
|
||||
|
||||
if (!pw)
|
||||
return "";
|
||||
|
||||
return pw->pw_name;
|
||||
}
|
||||
|
||||
|
||||
// **** Process
|
||||
|
||||
// The current process
|
||||
CPProcess CurrentProcess;
|
||||
|
||||
// Get the current process
|
||||
IProcess *IProcess::getCurrentProcess ()
|
||||
{
|
||||
return &CurrentProcess;
|
||||
}
|
||||
|
||||
/*
|
||||
* getCPUMask
|
||||
*/
|
||||
uint64 CPProcess::getCPUMask()
|
||||
{
|
||||
#ifdef __USE_GNU
|
||||
|
||||
uint64 cpuMask = 0;
|
||||
sint res = sched_getaffinity(getpid(), sizeof(uint64), (cpu_set_t*)&cpuMask);
|
||||
|
||||
if (res)
|
||||
{
|
||||
nlwarning("sched_getaffinity() returned %d, errno = %d: %s", res, errno, strerror(errno));
|
||||
return 0;
|
||||
}
|
||||
|
||||
return cpuMask;
|
||||
|
||||
#else // __USE_GNU
|
||||
|
||||
return 0;
|
||||
|
||||
#endif // __USE_GNU
|
||||
}
|
||||
|
||||
/// set the CPU mask
|
||||
bool CPProcess::setCPUMask(uint64 cpuMask)
|
||||
{
|
||||
#ifdef __USE_GNU
|
||||
|
||||
sint res = sched_setaffinity(getpid(), sizeof(uint64), (const cpu_set_t*)&cpuMask);
|
||||
|
||||
if (res)
|
||||
{
|
||||
nlwarning("sched_setaffinity() returned %d, errno = %d: %s", res, errno, strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
#else // __USE_GNU
|
||||
|
||||
return false;
|
||||
|
||||
#endif // __USE_GNU
|
||||
}
|
||||
|
||||
|
||||
} // NLMISC
|
||||
|
||||
#else // NL_OS_UNIX
|
||||
|
||||
// remove stupid VC6 warnings
|
||||
void foo_p_thread_cpp() {}
|
||||
|
||||
#endif // NL_OS_UNIX
|
||||
@ -0,0 +1,105 @@
|
||||
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
||||
// Copyright (C) 2010 Winch Gate Property Limited
|
||||
//
|
||||
// This program 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 (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 Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include "stdmisc.h"
|
||||
#include "nel/misc/thread.h"
|
||||
#include "nel/misc/debug.h"
|
||||
|
||||
#include <SDL_thread.h>
|
||||
|
||||
namespace NLMISC {
|
||||
|
||||
CThread::CThread(IRunnable *runnable) : m_IsRunning(false), m_SDLThread(NULL), m_Runnable(runnable)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
CThread::~CThread ()
|
||||
{
|
||||
/*
|
||||
NOTE: Detach not supported, due to m_IsRunning which is referenced by the running thread
|
||||
FIX: Use a thread-safe reference counted object for the m_IsRunning flag
|
||||
if (m_SDLThread)
|
||||
{
|
||||
SDL_DetachThread(m_SDLThread);
|
||||
}
|
||||
NOTE: Currently use wait, which is much saner behaviour.
|
||||
*/
|
||||
|
||||
wait();
|
||||
}
|
||||
|
||||
void CThread::start()
|
||||
{
|
||||
nlassert(!m_SDLThread);
|
||||
nlassert(!m_IsRunning);
|
||||
std::string name;
|
||||
m_Runnable->getName(name);
|
||||
m_IsRunning = true;
|
||||
m_SDLThread = SDL_CreateThread(run, name.c_str(), (void *)this);
|
||||
}
|
||||
|
||||
int CThread::run(void *ptr)
|
||||
{
|
||||
NLMISC::CThread *thread = static_cast<NLMISC::CThread *>(ptr);
|
||||
thread->m_Runnable->run();
|
||||
thread->m_IsRunning = false;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CThread::setPriority(TThreadPriority priority)
|
||||
{
|
||||
switch (priority)
|
||||
{
|
||||
case ThreadPriorityLow:
|
||||
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_LOW);
|
||||
break;
|
||||
case ThreadPriorityNormal:
|
||||
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_NORMAL);
|
||||
break;
|
||||
case ThreadPriorityHigh:
|
||||
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
|
||||
break;
|
||||
default:
|
||||
nlerror("Invalid thread priority");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool CThread::isRunning()
|
||||
{
|
||||
return m_IsRunning;
|
||||
}
|
||||
|
||||
int CThread::wait()
|
||||
{
|
||||
m_WaitMutex.enter();
|
||||
if (m_SDLThread)
|
||||
{
|
||||
SDL_WaitThread(m_SDLThread, &m_ThreadResult);
|
||||
m_SDLThread = NULL;
|
||||
nlassert(!m_IsRunning);
|
||||
}
|
||||
m_WaitMutex.leave();
|
||||
return m_ThreadResult;
|
||||
}
|
||||
|
||||
IRunnable *CThread::getRunnable()
|
||||
{
|
||||
return m_Runnable;
|
||||
}
|
||||
|
||||
} // NLMISC
|
||||
@ -1,609 +0,0 @@
|
||||
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
||||
// Copyright (C) 2010 Winch Gate Property Limited
|
||||
//
|
||||
// This program 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 (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 Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include "stdmisc.h"
|
||||
#include "nel/misc/win_thread.h"
|
||||
|
||||
#ifdef NL_OS_WINDOWS
|
||||
|
||||
#include "nel/misc/path.h"
|
||||
#define NOMINMAX
|
||||
#include <windows.h>
|
||||
|
||||
#include <typeinfo>
|
||||
|
||||
#ifdef DEBUG_NEW
|
||||
#define new DEBUG_NEW
|
||||
#endif
|
||||
|
||||
namespace NLMISC {
|
||||
|
||||
CWinThread MainThread ((void*)GetCurrentThread (), GetCurrentThreadId());
|
||||
DWORD TLSThreadPointer = 0xFFFFFFFF;
|
||||
|
||||
// the IThread static creator
|
||||
IThread *IThread::create (IRunnable *runnable, uint32 stackSize)
|
||||
{
|
||||
return new CWinThread (runnable, stackSize);
|
||||
}
|
||||
|
||||
IThread *IThread::getCurrentThread ()
|
||||
{
|
||||
// TLS alloc must have been done
|
||||
nlassert (TLSThreadPointer != 0xffffffff);
|
||||
|
||||
// Get the thread pointer
|
||||
IThread *thread = (IThread*)TlsGetValue (TLSThreadPointer);
|
||||
|
||||
// Return current thread
|
||||
return thread;
|
||||
}
|
||||
|
||||
static unsigned long __stdcall ProxyFunc (void *arg)
|
||||
{
|
||||
CWinThread *parent = (CWinThread *) arg;
|
||||
|
||||
// TLS alloc must have been done
|
||||
nlassert (TLSThreadPointer != 0xffffffff);
|
||||
|
||||
// Set the thread pointer in TLS memory
|
||||
nlverify (TlsSetValue (TLSThreadPointer, (void*)parent) != 0);
|
||||
|
||||
// Run the thread
|
||||
parent->Runnable->run();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
CWinThread::CWinThread (IRunnable *runnable, uint32 stackSize)
|
||||
{
|
||||
_StackSize = stackSize;
|
||||
this->Runnable = runnable;
|
||||
ThreadHandle = NULL;
|
||||
_SuspendCount = -1;
|
||||
_MainThread = false;
|
||||
}
|
||||
|
||||
namespace {
|
||||
class CWinCriticalSection
|
||||
{
|
||||
private:
|
||||
CRITICAL_SECTION cs;
|
||||
public:
|
||||
CWinCriticalSection() { InitializeCriticalSection(&cs); }
|
||||
~CWinCriticalSection() { DeleteCriticalSection(&cs); }
|
||||
inline void enter() { EnterCriticalSection(&cs); }
|
||||
inline void leave() { LeaveCriticalSection(&cs); }
|
||||
};
|
||||
CWinCriticalSection s_CS;
|
||||
}/* anonymous namespace */
|
||||
|
||||
CWinThread::CWinThread (void* threadHandle, uint32 threadId)
|
||||
{
|
||||
// Main thread
|
||||
_MainThread = true;
|
||||
this->Runnable = NULL;
|
||||
ThreadHandle = threadHandle;
|
||||
ThreadId = threadId;
|
||||
|
||||
// TLS alloc must have been done
|
||||
TLSThreadPointer = TlsAlloc ();
|
||||
nlassert (TLSThreadPointer!=0xffffffff);
|
||||
|
||||
// Set the thread pointer in TLS memory
|
||||
nlverify (TlsSetValue (TLSThreadPointer, (void*)this) != 0);
|
||||
|
||||
if (GetCurrentThreadId() == threadId)
|
||||
{
|
||||
_SuspendCount = 0; // is calling thread call this itself, well, if we reach this place
|
||||
// there are chances that it is not suspended ...
|
||||
}
|
||||
else
|
||||
{
|
||||
// initialized from another thread (very unlikely ...)
|
||||
nlassert(0); // WARNING: following code has not tested! don't know if it work fo real ...
|
||||
// This is just a suggestion of a possible solution, should this situation one day occur ...
|
||||
// Ensure that this thread don't get deleted, or we could suspend the main thread
|
||||
s_CS.enter();
|
||||
// the 2 following statement must be executed atomicaly among the threads of the current process !
|
||||
SuspendThread(threadHandle);
|
||||
_SuspendCount = ResumeThread(threadHandle);
|
||||
s_CS.leave();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CWinThread::incSuspendCount()
|
||||
{
|
||||
nlassert(ThreadHandle); // start was not called !!
|
||||
int newSuspendCount = ::SuspendThread(ThreadHandle) + 1;
|
||||
nlassert(newSuspendCount != 0xffffffff); // more infos with 'GetLastError'
|
||||
nlassert(newSuspendCount == _SuspendCount + 1); // is this assert fire , then 'SuspendThread' or 'ResumeThread'
|
||||
// have been called outside of this object interface! (on this thread handle ...)
|
||||
_SuspendCount = newSuspendCount;
|
||||
}
|
||||
|
||||
void CWinThread::decSuspendCount()
|
||||
{
|
||||
nlassert(ThreadHandle); // 'start' was not called !!
|
||||
nlassert(_SuspendCount > 0);
|
||||
int newSuspendCount = ::ResumeThread(ThreadHandle) - 1;
|
||||
nlassert(newSuspendCount != 0xffffffff); // more infos with 'GetLastError'
|
||||
nlassert(newSuspendCount == _SuspendCount - 1); // is this assert fire , then 'SuspendThread' or 'ResumeThread'
|
||||
// have been called outside of this object interface! (on this thread handle ...)
|
||||
_SuspendCount = newSuspendCount;
|
||||
}
|
||||
|
||||
void CWinThread::suspend()
|
||||
{
|
||||
if (getSuspendCount() == 0)
|
||||
{
|
||||
incSuspendCount();
|
||||
}
|
||||
}
|
||||
|
||||
void CWinThread::resume()
|
||||
{
|
||||
while (getSuspendCount() != 0)
|
||||
{
|
||||
decSuspendCount();
|
||||
}
|
||||
}
|
||||
|
||||
void CWinThread::setPriority(TThreadPriority priority)
|
||||
{
|
||||
nlassert(ThreadHandle); // 'start' was not called !!
|
||||
BOOL result = SetThreadPriority(ThreadHandle, (int)priority);
|
||||
nlassert(result);
|
||||
}
|
||||
|
||||
void CWinThread::enablePriorityBoost(bool enabled)
|
||||
{
|
||||
nlassert(ThreadHandle); // 'start' was not called !!
|
||||
SetThreadPriorityBoost(ThreadHandle, enabled ? TRUE : FALSE);
|
||||
}
|
||||
|
||||
|
||||
CWinThread::~CWinThread ()
|
||||
{
|
||||
// If not the main thread
|
||||
if (_MainThread)
|
||||
{
|
||||
// Free TLS memory
|
||||
nlassert (TLSThreadPointer!=0xffffffff);
|
||||
TlsFree (TLSThreadPointer);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ThreadHandle != NULL) terminate();
|
||||
}
|
||||
}
|
||||
|
||||
void CWinThread::start ()
|
||||
{
|
||||
if (isRunning())
|
||||
throw EThread("Starting a thread that is already started, existing thread will continue running, this should not happen");
|
||||
|
||||
// ThreadHandle = (void *) ::CreateThread (NULL, _StackSize, ProxyFunc, this, 0, (DWORD *)&ThreadId);
|
||||
ThreadHandle = (void *) ::CreateThread (NULL, 0, ProxyFunc, this, 0, (DWORD *)&ThreadId);
|
||||
// nldebug("NLMISC: thread %x started for runnable '%x'", typeid( Runnable ).name());
|
||||
// OutputDebugString(toString(NL_LOC_MSG " NLMISC: thread %x started for runnable '%s'\n", ThreadId, typeid( *Runnable ).name()).c_str());
|
||||
SetThreadPriorityBoost (ThreadHandle, TRUE); // FALSE == Enable Priority Boost
|
||||
if (ThreadHandle == NULL)
|
||||
{
|
||||
throw EThread ( "Cannot create new thread" );
|
||||
}
|
||||
|
||||
_SuspendCount = 0;
|
||||
}
|
||||
|
||||
bool CWinThread::isRunning()
|
||||
{
|
||||
if (ThreadHandle == NULL)
|
||||
return false;
|
||||
|
||||
DWORD exitCode;
|
||||
if (!GetExitCodeThread(ThreadHandle, &exitCode))
|
||||
return false;
|
||||
|
||||
return exitCode == STILL_ACTIVE;
|
||||
}
|
||||
|
||||
|
||||
void CWinThread::terminate ()
|
||||
{
|
||||
TerminateThread((HANDLE)ThreadHandle, 0);
|
||||
CloseHandle((HANDLE)ThreadHandle);
|
||||
ThreadHandle = NULL;
|
||||
_SuspendCount = -1;
|
||||
}
|
||||
|
||||
void CWinThread::wait ()
|
||||
{
|
||||
if (ThreadHandle == NULL) return;
|
||||
|
||||
WaitForSingleObject(ThreadHandle, INFINITE);
|
||||
CloseHandle(ThreadHandle);
|
||||
ThreadHandle = NULL;
|
||||
_SuspendCount = -1;
|
||||
}
|
||||
|
||||
bool CWinThread::setCPUMask(uint64 cpuMask)
|
||||
{
|
||||
// Thread must exist
|
||||
if (ThreadHandle == NULL)
|
||||
return false;
|
||||
|
||||
// Ask the system for number of processor available for this process
|
||||
return SetThreadAffinityMask ((HANDLE)ThreadHandle, (DWORD_PTR)cpuMask) != 0;
|
||||
}
|
||||
|
||||
uint64 CWinThread::getCPUMask()
|
||||
{
|
||||
// Thread must exist
|
||||
if (ThreadHandle == NULL)
|
||||
return 1;
|
||||
|
||||
// Get the current process mask
|
||||
uint64 mask=IProcess::getCurrentProcess ()->getCPUMask ();
|
||||
|
||||
// Get thread affinity mask
|
||||
DWORD_PTR old = SetThreadAffinityMask ((HANDLE)ThreadHandle, (DWORD_PTR)mask);
|
||||
nlassert (old != 0);
|
||||
if (old == 0)
|
||||
return 1;
|
||||
|
||||
// Reset it
|
||||
SetThreadAffinityMask ((HANDLE)ThreadHandle, old);
|
||||
|
||||
// Return the mask
|
||||
return (uint64)old;
|
||||
}
|
||||
|
||||
std::string CWinThread::getUserName()
|
||||
{
|
||||
char userName[512];
|
||||
DWORD size = 512;
|
||||
GetUserName (userName, &size);
|
||||
return (const char*)userName;
|
||||
}
|
||||
|
||||
// **** Process
|
||||
|
||||
// The current process
|
||||
CWinProcess CurrentProcess ((void*)GetCurrentProcess());
|
||||
|
||||
// Get the current process
|
||||
IProcess *IProcess::getCurrentProcess ()
|
||||
{
|
||||
return &CurrentProcess;
|
||||
}
|
||||
|
||||
CWinProcess::CWinProcess (void *handle)
|
||||
{
|
||||
// Get the current process handle
|
||||
_ProcessHandle = handle;
|
||||
}
|
||||
|
||||
uint64 CWinProcess::getCPUMask()
|
||||
{
|
||||
// Ask the system for number of processor available for this process
|
||||
DWORD_PTR processAffinityMask;
|
||||
DWORD_PTR systemAffinityMask;
|
||||
if (GetProcessAffinityMask((HANDLE)_ProcessHandle, &processAffinityMask, &systemAffinityMask))
|
||||
{
|
||||
// Return the CPU mask
|
||||
return (uint64)processAffinityMask;
|
||||
}
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool CWinProcess::setCPUMask(uint64 mask)
|
||||
{
|
||||
// Ask the system for number of processor available for this process
|
||||
DWORD_PTR processAffinityMask= (DWORD_PTR)mask;
|
||||
return SetProcessAffinityMask((HANDLE)_ProcessHandle, processAffinityMask)!=0;
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
/**
|
||||
* Simple wrapper around the PSAPI library
|
||||
* \author Nicolas Vizerie
|
||||
* \author GameForge
|
||||
* \date 2007
|
||||
*/
|
||||
|
||||
class CPSAPILib
|
||||
{
|
||||
public:
|
||||
typedef BOOL (WINAPI *EnumProcessesFunPtr)(DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded);
|
||||
typedef DWORD (WINAPI *GetModuleFileNameExAFunPtr)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize);
|
||||
typedef BOOL (WINAPI *EnumProcessModulesFunPtr)(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded);
|
||||
EnumProcessesFunPtr EnumProcesses;
|
||||
GetModuleFileNameExAFunPtr GetModuleFileNameExA;
|
||||
EnumProcessModulesFunPtr EnumProcessModules;
|
||||
public:
|
||||
CPSAPILib();
|
||||
~CPSAPILib();
|
||||
bool init();
|
||||
private:
|
||||
HINSTANCE _PSAPILibHandle;
|
||||
bool _LoadFailed;
|
||||
};
|
||||
|
||||
// ****************************************************************************************************************
|
||||
CPSAPILib::CPSAPILib()
|
||||
{
|
||||
_LoadFailed = false;
|
||||
_PSAPILibHandle = NULL;
|
||||
EnumProcesses = NULL;
|
||||
GetModuleFileNameExA = NULL;
|
||||
EnumProcessModules = NULL;
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
CPSAPILib::~CPSAPILib()
|
||||
{
|
||||
if (_PSAPILibHandle)
|
||||
{
|
||||
FreeLibrary(_PSAPILibHandle);
|
||||
}
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
bool CPSAPILib::init()
|
||||
{
|
||||
//
|
||||
if (_LoadFailed) return false;
|
||||
if (!_PSAPILibHandle)
|
||||
{
|
||||
_PSAPILibHandle = LoadLibrary("psapi.dll");
|
||||
if (!_PSAPILibHandle)
|
||||
{
|
||||
nlwarning("couldn't load psapi.dll, possibly not supported by os");
|
||||
_LoadFailed = true;
|
||||
return false;
|
||||
}
|
||||
EnumProcesses = (EnumProcessesFunPtr) GetProcAddress(_PSAPILibHandle, "EnumProcesses");
|
||||
GetModuleFileNameExA = (GetModuleFileNameExAFunPtr) GetProcAddress(_PSAPILibHandle, "GetModuleFileNameExA");
|
||||
EnumProcessModules = (EnumProcessModulesFunPtr) GetProcAddress(_PSAPILibHandle, "EnumProcessModules");
|
||||
if (!EnumProcesses ||
|
||||
!GetModuleFileNameExA ||
|
||||
!EnumProcessModules
|
||||
)
|
||||
{
|
||||
nlwarning("Failed to import functions from psapi.dll!");
|
||||
_LoadFailed = true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static CPSAPILib PSAPILib;
|
||||
|
||||
|
||||
|
||||
// ****************************************************************************************************************
|
||||
bool CWinProcess::enumProcessesId(std::vector<uint32> &processesId)
|
||||
{
|
||||
if (!PSAPILib.init()) return false;
|
||||
// list of processes
|
||||
std::vector<uint32> prcIds(16);
|
||||
for (;;)
|
||||
{
|
||||
DWORD cbNeeded;
|
||||
if (!PSAPILib.EnumProcesses((DWORD *) &prcIds[0], (DWORD)(prcIds.size() * sizeof(DWORD)), &cbNeeded))
|
||||
{
|
||||
nlwarning("Processes enumeration failed!");
|
||||
return false;
|
||||
}
|
||||
if (cbNeeded < prcIds.size() * sizeof(DWORD))
|
||||
{
|
||||
prcIds.resize(cbNeeded / sizeof(DWORD));
|
||||
break;
|
||||
}
|
||||
// make some more room
|
||||
prcIds.resize(prcIds.size() * 2);
|
||||
}
|
||||
processesId.swap(prcIds);
|
||||
return true;
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
bool CWinProcess::enumProcessModules(uint32 processId, std::vector<std::string> &moduleNames)
|
||||
{
|
||||
if (!PSAPILib.init()) return false;
|
||||
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ, FALSE, (DWORD) processId);
|
||||
if (!hProcess) return false;
|
||||
// list of modules
|
||||
std::vector<HMODULE> prcModules(2);
|
||||
for (;;)
|
||||
{
|
||||
DWORD cbNeeded;
|
||||
if (!PSAPILib.EnumProcessModules(hProcess, (HMODULE *) &prcModules[0], (DWORD)(prcModules.size() * sizeof(HMODULE)), &cbNeeded))
|
||||
{
|
||||
//nlwarning("Processe modules enumeration failed!");
|
||||
return false;
|
||||
}
|
||||
if (cbNeeded < prcModules.size() * sizeof(HMODULE))
|
||||
{
|
||||
prcModules.resize(cbNeeded / sizeof(HMODULE));
|
||||
break;
|
||||
}
|
||||
// make some more room
|
||||
prcModules.resize(prcModules.size() * 2);
|
||||
}
|
||||
moduleNames.clear();
|
||||
std::vector<std::string> resultModuleNames;
|
||||
char moduleName[MAX_PATH + 1];
|
||||
for (uint m = 0; m < prcModules.size(); ++m)
|
||||
{
|
||||
if (PSAPILib.GetModuleFileNameExA(hProcess, prcModules[m], moduleName, MAX_PATH))
|
||||
{
|
||||
moduleNames.push_back(moduleName);
|
||||
}
|
||||
}
|
||||
CloseHandle(hProcess);
|
||||
return true;
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
uint32 CWinProcess::getProcessIdFromModuleFilename(const std::string &moduleFileName)
|
||||
{
|
||||
std::vector<uint32> processesId;
|
||||
if (!enumProcessesId(processesId)) return false;
|
||||
std::vector<std::string> moduleNames;
|
||||
for (uint prc = 0; prc < processesId.size(); ++prc)
|
||||
{
|
||||
if (enumProcessModules(processesId[prc], moduleNames))
|
||||
{
|
||||
for (uint m = 0; m < moduleNames.size(); ++m)
|
||||
{
|
||||
if (nlstricmp(CFile::getFilename(moduleNames[m]), moduleFileName) == 0)
|
||||
{
|
||||
return processesId[prc];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
bool CWinProcess::terminateProcess(uint32 processId, uint exitCode)
|
||||
{
|
||||
if (!processId) return false;
|
||||
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, (DWORD) processId);
|
||||
if (!hProcess) return false;
|
||||
BOOL ok = TerminateProcess(hProcess, (UINT) exitCode);
|
||||
CloseHandle(hProcess);
|
||||
return ok != FALSE;
|
||||
}
|
||||
|
||||
// ****************************************************************************************************************
|
||||
bool CWinProcess::terminateProcessFromModuleName(const std::string &moduleName, uint exitCode)
|
||||
{
|
||||
return terminateProcess(getProcessIdFromModuleFilename(moduleName), exitCode);
|
||||
}
|
||||
|
||||
|
||||
///////////////////
|
||||
// CProcessWatch //
|
||||
///////////////////
|
||||
|
||||
|
||||
/*
|
||||
|
||||
// I didn't use and test that code, eventually, but maybe useful in the future
|
||||
|
||||
class CProcessWatchTask : public IRunnable
|
||||
{
|
||||
public:
|
||||
HANDLE HProcess;
|
||||
public:
|
||||
CProcessWatchTask(HANDLE hProcess) : HProcess(hProcess)
|
||||
{
|
||||
}
|
||||
virtual void run()
|
||||
{
|
||||
WaitForSingleObject(HProcess, INFINITE);
|
||||
}
|
||||
};
|
||||
|
||||
class CProcessWatchImpl
|
||||
{
|
||||
public:
|
||||
bool Launched;
|
||||
IThread *WatchThread;
|
||||
CProcessWatchTask *WatchTask;
|
||||
public:
|
||||
CProcessWatchImpl() : Launched(false), WatchThread(NULL), WatchTask(NULL)
|
||||
{
|
||||
}
|
||||
~CProcessWatchImpl()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
void reset()
|
||||
{
|
||||
if (WatchThread)
|
||||
{
|
||||
if (WatchThread->isRunning())
|
||||
{
|
||||
WatchThread->terminate();
|
||||
}
|
||||
delete WatchTask;
|
||||
delete WatchThread;
|
||||
WatchTask = NULL;
|
||||
WatchThread = NULL;
|
||||
Launched = false;
|
||||
}
|
||||
}
|
||||
bool launch(const std::string &programName, const std::string &arguments)
|
||||
{
|
||||
if (isRunning()) return false;
|
||||
PROCESS_INFORMATION processInfo;
|
||||
STARTUPINFO startupInfo = {0};
|
||||
startupInfo.cb = sizeof(STARTUPINFO);
|
||||
if (CreateProcess(programName.c_str(), const_cast<LPTSTR>(arguments.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo))
|
||||
{
|
||||
WatchTask = new CProcessWatchTask(processInfo.hProcess);
|
||||
WatchThread = IThread::create(WatchTask);
|
||||
WatchThread->start();
|
||||
Launched = true;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool isRunning()
|
||||
{
|
||||
if (!Launched) return false;
|
||||
nlassert(WatchThread);
|
||||
nlassert(WatchTask);
|
||||
if (WatchThread->isRunning()) return true;
|
||||
reset();
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
CProcessWatch::CProcessWatch()
|
||||
{
|
||||
_PImpl = new CProcessWatchImpl;
|
||||
}
|
||||
|
||||
CProcessWatch::~CProcessWatch()
|
||||
{
|
||||
delete _PImpl;
|
||||
}
|
||||
|
||||
bool CProcessWatch::launch(const std::string &programName, const std::string &arguments)
|
||||
{
|
||||
return _PImpl->launch(programName, arguments);
|
||||
}
|
||||
|
||||
bool CProcessWatch::isRunning() const
|
||||
{
|
||||
return _PImpl->isRunning();
|
||||
}
|
||||
|
||||
*/
|
||||
} // NLMISC
|
||||
|
||||
#endif // NL_OS_WINDOWS
|
||||
Loading…
Reference in New Issue