void
BenchmarkPlayback::InputExhausted()
{
MOZ_ASSERT(OnThread());
if (mFinished || mSampleIndex >= mSamples.Length()) {
return;
}
RefPtr<Benchmark> ref(mMainThreadState);
mDecoder->Decode(mSamples[mSampleIndex])
->Then(Thread(), __func__,
[ref, this](const MediaDataDecoder::DecodedData& aResults) {
Output(aResults);
InputExhausted();
},
[ref, this](const MediaResult& aError) { MainThreadShutdown(); });
mSampleIndex++;
if (mSampleIndex == mSamples.Length()) {
if (ref->mParameters.mStopAtFrame) {
mSampleIndex = 0;
} else {
mDecoder->Drain()->Then(
Thread(), __func__,
[ref, this](const MediaDataDecoder::DecodedData& aResults) {
mDrained = true;
Output(aResults);
},
[ref, this](const MediaResult& aError) { MainThreadShutdown(); });
}
}
}
void image_info::adjustThreads()
{
int new_threads = nr_threads - threads.size();
if (new_threads == 0)
{
return;
}
else if (new_threads > 0)
{
for (int i = 0; i < new_threads; i++)
{
// FIXME: avoid leaking the memory for RenderThread
threads.push_back(Thread(new RenderThread(this)));
}
}
else
{
// this is inefficient but we don't know which threads are going to
// pick up the quit notices, so we don't know which threads we
// should call join on, so just delete all of them and create
// the new number of threads.
stopThreads();
adjustThreads();
}
}
void
BenchmarkPlayback::MainThreadShutdown()
{
MOZ_ASSERT(OnThread());
if (mDecoder) {
mDecoder->Flush();
mDecoder->Shutdown();
mDecoder = nullptr;
}
mDecoderTaskQueue->BeginShutdown();
mDecoderTaskQueue->AwaitShutdownAndIdle();
mDecoderTaskQueue = nullptr;
if (mTrackDemuxer) {
mTrackDemuxer->Reset();
mTrackDemuxer->BreakCycles();
mTrackDemuxer = nullptr;
}
RefPtr<Benchmark> ref(mMainThreadState);
Thread()->AsTaskQueue()->BeginShutdown()->Then(
ref->Thread(), __func__,
[ref]() { ref->Dispose(); },
[]() { MOZ_CRASH("not reached"); });
}
void
BenchmarkPlayback::DemuxNextSample()
{
MOZ_ASSERT(OnThread());
RefPtr<Benchmark> ref(mMainThreadState);
RefPtr<MediaTrackDemuxer::SamplesPromise> promise = mTrackDemuxer->GetSamples();
promise->Then(
Thread(), __func__,
[this, ref](RefPtr<MediaTrackDemuxer::SamplesHolder> aHolder) {
mSamples.AppendElements(Move(aHolder->mSamples));
if (ref->mParameters.mStopAtFrame &&
mSamples.Length() == (size_t)ref->mParameters.mStopAtFrame.ref()) {
InitDecoder(Move(*mTrackDemuxer->GetInfo()));
} else {
Dispatch(NS_NewRunnableFunction([this, ref]() { DemuxNextSample(); }));
}
},
[this, ref](DemuxerFailureReason aReason) {
switch (aReason) {
case DemuxerFailureReason::END_OF_STREAM:
InitDecoder(Move(*mTrackDemuxer->GetInfo()));
break;
default:
MainThreadShutdown();
}
});
}
void CPacketQueue::Init()
{
gEnv->pLog->Log(TITLE "CPacketQueue::Init()");
std::thread Thread(&CPacketQueue::Thread, this);
Thread.detach();
}
/** This test case checks that the CCheckQueue works properly
* with each specified size_t Checks pushed.
*/
static void Correct_Queue_range(std::vector<size_t> range)
{
auto small_queue = std::unique_ptr<Correct_Queue>(new Correct_Queue {QUEUE_BATCH_SIZE});
boost::thread_group tg;
for (auto x = 0; x < nScriptCheckThreads; ++x) {
tg.create_thread([&]{small_queue->Thread();});
}
// Make vChecks here to save on malloc (this test can be slow...)
std::vector<FakeCheckCheckCompletion> vChecks;
for (auto i : range) {
size_t total = i;
FakeCheckCheckCompletion::n_calls = 0;
CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get());
while (total) {
vChecks.resize(std::min(total, (size_t) InsecureRandRange(10)));
total -= vChecks.size();
control.Add(vChecks);
}
BOOST_REQUIRE(control.Wait());
if (FakeCheckCheckCompletion::n_calls != i) {
BOOST_REQUIRE_EQUAL(FakeCheckCheckCompletion::n_calls, i);
BOOST_TEST_MESSAGE("Failure on trial " << i << " expected, got " << FakeCheckCheckCompletion::n_calls);
}
}
tg.interrupt_all();
tg.join_all();
}
int _tmain(int argc, _TCHAR* argv[])
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
try
{
AC::Semaphore Tickets(NUM_TICKETS, NUM_TICKETS);
std::vector<AC::Thread> Threads;
for (unsigned short i = 0; i < NUM_SELLERS; i++)
{
AC::Thread Thread(new Seller(Tickets, i+1));
Thread.Start();
Threads.push_back(Thread);
}
for (unsigned short i = 0; i < Threads.size(); i++)
Threads[i].Wait();
}
catch(std::exception& ex)
{
fprintf(stderr, "Exception: %s\n", ex.what());
}
return 0;
}
void Vm::startsWith(const byte* const beg, const byte* const end, const uint64_t startOffset, HitCallback hitFn, void* userData) {
CurHitFn = hitFn;
UserData = userData;
const Instruction* base = &(*Prog)[0];
uint64_t offset = startOffset;
if (Prog->First[*beg]) {
for (ThreadList::const_iterator t(First.begin()); t != First.end(); ++t) {
Active.emplace_back(
#ifdef _MSC_VER
Thread(t->PC, Thread::NOLABEL, offset, Thread::NONE)
#else
t->PC, Thread::NOLABEL, offset, Thread::NONE
#endif
);
}
for (const byte* cur = beg; cur < end; ++cur, ++offset) {
for (ThreadList::iterator t(Active.begin()); t != Active.end(); ++t) {
_executeThread(base, t, cur, offset);
}
_cleanup();
if (Active.empty()) {
// early exit if threads die out
break;
}
}
}
closeOut(hitFn, userData);
reset();
}
/// <summary>
/// Create the thread.
/// </summary>
/// <param name="threadProc">Thread enty point</param>
/// <param name="arg">Thread argument.</param>
/// <param name="flags">Thread creation flags</param>
/// <returns>New thread object</returns>
Thread ProcessThreads::CreateNew( ptr_t threadProc, ptr_t arg, DWORD flags /*= 0*/ )
{
HANDLE hThd = NULL;
_core.native()->CreateRemoteThreadT( hThd, threadProc, arg, flags );
return Thread( hThd, &_core );
}
/// <summary>
/// Gets all process threads
/// </summary>
/// <param name="dontUpdate">Return already existing thread list</param>
/// <returns>Threads collection</returns>
std::vector<Thread>& ProcessThreads::getAll( bool dontUpdate /*= false*/ )
{
if (dontUpdate)
return _threads;
HANDLE hThreadSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
_threads.clear();
if (hThreadSnapshot != INVALID_HANDLE_VALUE)
{
THREADENTRY32 tEntry = { 0 };
tEntry.dwSize = sizeof(THREADENTRY32);
// Iterate threads
for (BOOL success = Thread32First( hThreadSnapshot, &tEntry );
success == TRUE;
success = Thread32Next( hThreadSnapshot, &tEntry ))
{
if (tEntry.th32OwnerProcessID != _core.pid())
continue;
_threads.emplace_back( Thread( tEntry.th32ThreadID, &_core ) );
}
CloseHandle( hThreadSnapshot );
}
return _threads;
}
BOOL WINAPI CtrlHandler(DWORD CtrlType)
{
switch(CtrlType)
{
case CTRL_C_EVENT:
return TRUE;
case CTRL_BREAK_EVENT:
if(!CancelIoInProgress().Signaled())
{
CancelIoInProgress().Set();
Thread(&Thread::detach, &CancelSynchronousIoWrapper, Global->MainThreadHandle());
}
WriteInput(KEY_BREAK);
if (Global->CtrlObject && Global->CtrlObject->Cp())
{
if (Global->CtrlObject->Cp()->LeftPanel && Global->CtrlObject->Cp()->LeftPanel->GetMode()==PLUGIN_PANEL)
Global->CtrlObject->Plugins->ProcessEvent(Global->CtrlObject->Cp()->LeftPanel->GetPluginHandle(),FE_BREAK, ToPtr(CtrlType));
if (Global->CtrlObject->Cp()->RightPanel && Global->CtrlObject->Cp()->RightPanel->GetMode()==PLUGIN_PANEL)
Global->CtrlObject->Plugins->ProcessEvent(Global->CtrlObject->Cp()->RightPanel->GetPluginHandle(),FE_BREAK, ToPtr(CtrlType));
}
return TRUE;
case CTRL_CLOSE_EVENT:
Global->CloseFAR=TRUE;
Global->AllowCancelExit=FALSE;
// trick to let wmain() finish correctly
ExitThread(1);
//return TRUE;
}
return FALSE;
}
int _tmain(int argc, _TCHAR* argv[])
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
try
{
AC::Event Event(FALSE, TRUE);
std::vector<AC::Thread> Threads;
for (unsigned short i = 1; i <= NUM_THREADS; i++)
{
AC::Thread Thread(new TaskPrint(Event, i));
Thread.Start();
Threads.push_back(Thread);
}
Sleep(DELAY_MS);
Event.SetEvent();
for (unsigned short i = 0; i < Threads.size(); i++)
Threads[i].Wait();
}
catch(std::exception& ex)
{
fprintf(stderr, "Exception: %s\n", ex.what());
}
return 0;
}
tAsyncCall* System_Threading_Thread_ctorParam(PTR pThis_, PTR pParams, PTR pReturnValue) {
tThread *pThread = Thread();
pThread->startDelegate = ((PTR*)pParams)[0];
*(HEAP_PTR*)pReturnValue = (HEAP_PTR)pThread;
pThread->hasParam = 1;
return NULL;
}
ThreadList Thread::GetList(UInt32 processId)
{
Handle hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, processId);
if (!hSnapshot.IsValid())
{
THROW_LAST_ERROR_EXCEPTION();
}
THREADENTRY32 threadEntry = {0};
threadEntry.dwSize = sizeof(threadEntry);
BOOL success = ::Thread32First(hSnapshot, &threadEntry);
if (!success)
{
THROW_LAST_ERROR_EXCEPTION();
}
ThreadList list;
while (success)
{
if (threadEntry.th32OwnerProcessID == processId)
{
list.push_back(Thread(threadEntry.th32ThreadID));
}
success = ::Thread32Next(hSnapshot, &threadEntry);
}
return list;
}
int _tmain(int argc, _TCHAR* argv[])
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
srand((unsigned int)time(NULL));
try
{
AC::SharedQueue<Pair> InputQueue(NUM_POLYNOMIALS), OutputQueue(NUM_POLYNOMIALS);
AC::Thread Thread(new MathTask(InputQueue, OutputQueue));
Thread.Start();
for (unsigned short i = 0; i < NUM_POLYNOMIALS; i++)
{
Pair p;
p.first = rand();
InputQueue.Push(p);
}
for (unsigned short i = 0; i < NUM_POLYNOMIALS; i++)
{
Pair p = OutputQueue.Pop();
printf( "El valor del polinomio para x=%f es y=%f\n", p.first, p.second);
}
Thread.Wait();
}
catch(std::exception& ex)
{
fprintf(stderr, "Exception: %s\n", ex.what());
}
return 0;
}
void BenchmarkPlayback::DemuxNextSample() {
MOZ_ASSERT(OnThread());
RefPtr<Benchmark> ref(mGlobalState);
RefPtr<MediaTrackDemuxer::SamplesPromise> promise =
mTrackDemuxer->GetSamples();
promise->Then(
Thread(), __func__,
[this, ref](RefPtr<MediaTrackDemuxer::SamplesHolder> aHolder) {
mSamples.AppendElements(std::move(aHolder->mSamples));
if (ref->mParameters.mStopAtFrame &&
mSamples.Length() == ref->mParameters.mStopAtFrame.ref()) {
InitDecoder(std::move(*mTrackDemuxer->GetInfo()));
} else {
Dispatch(
NS_NewRunnableFunction("BenchmarkPlayback::DemuxNextSample",
[this, ref]() { DemuxNextSample(); }));
}
},
[this, ref](const MediaResult& aError) {
switch (aError.Code()) {
case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
InitDecoder(std::move(*mTrackDemuxer->GetInfo()));
break;
default:
Error(aError);
break;
}
});
}
void Music::Play()
{
#if NAZARA_AUDIO_SAFE
if (!m_impl)
{
NazaraError("Music not created");
return;
}
#endif
// Maybe we are already playing
if (m_impl->streaming)
{
switch (GetStatus())
{
case SoundStatus_Playing:
SetPlayingOffset(0);
break;
case SoundStatus_Paused:
alSourcePlay(m_source);
break;
default:
break; // We shouldn't be stopped
}
}
else
{
// Starting streaming's thread
m_impl->streaming = true;
m_impl->thread = Thread(&Music::MusicThread, this);
}
}
void LauncherApp::ReadyToRun()
{
// Since we will essentially run the GUI...
set_thread_priority(Thread(), B_DISPLAY_PRIORITY);
BWebPage::InitializeOnce();
BWebPage::SetCacheModel(B_WEBKIT_CACHE_MODEL_WEB_BROWSER);
BFile settingsFile;
BRect windowFrameFromSettings = m_lastWindowFrame;
if (openSettingsFile(settingsFile, B_READ_ONLY)) {
BMessage settingsArchive;
settingsArchive.Unflatten(&settingsFile);
settingsArchive.FindRect("window frame", &windowFrameFromSettings);
}
m_lastWindowFrame = windowFrameFromSettings;
m_initialized = true;
if (m_launchRefsMessage) {
RefsReceived(m_launchRefsMessage);
delete m_launchRefsMessage;
m_launchRefsMessage = 0;
} else {
LauncherWindow* window = new LauncherWindow(m_lastWindowFrame);
window->Show();
}
}
/*!
* \brief Plays the music
*
* Plays/Resume the music.
* If the music is currently playing, resets the playing offset to the beginning offset.
* If the music is currently paused, resumes the playing.
* If the music is currently stopped, starts the playing at the previously set playing offset.
*
* \remark Music must be valid when calling this function
*/
void Music::Play()
{
NazaraAssert(m_impl, "Music not created");
// Maybe we are already playing
if (m_impl->streaming)
{
switch (GetStatus())
{
case SoundStatus_Playing:
SetPlayingOffset(0);
break;
case SoundStatus_Paused:
alSourcePlay(m_source);
break;
default:
break; // We shouldn't be stopped
}
}
else
{
// Starting streaming's thread
m_impl->streaming = true;
m_impl->thread = Thread(&Music::MusicThread, this);
}
}
Program::Program(const Params & aParams)
: input(aParams.GetUrl()),
output(aParams.GetOutput().empty() ? input.GetFileName() : aParams.GetOutput(), input.GetFileSize()),
threadsNumber(input.AcceptRanges() ? aParams.GetThreadsCount() : 1),
barrier(threadsNumber, aParams.GetRefresh()),
threads(threadsNumber, Thread(input.GetAddress(), &output, &barrier))
{}
int main(int argc, char **argv)
{
int i, retval;
long long elapsed_us, elapsed_cyc;
tests_quiet(argc, argv); /* Set TESTS_QUIET variable */
retval = PAPI_library_init(PAPI_VER_CURRENT);
if (retval != PAPI_VER_CURRENT)
test_fail(__FILE__, __LINE__, "PAPI_library_init", retval);
hw_info = PAPI_get_hardware_info();
if (hw_info == NULL)
test_fail(__FILE__, __LINE__, "PAPI_get_hardware_info", 2);
elapsed_us = PAPI_get_real_usec();
elapsed_cyc = PAPI_get_real_cyc();
#if defined(_AIX)
retval = PAPI_thread_init((unsigned long (*)(void)) (pthread_self));
if (retval != PAPI_OK) {
if (retval == PAPI_ESBSTR)
test_skip(__FILE__, __LINE__, "PAPI_thread_init", retval);
else
test_fail(__FILE__, __LINE__, "PAPI_thread_init", retval);
}
#pragma ibm parallel_loop
#elif defined(sgi) && defined(mips)
retval = PAPI_thread_init((unsigned long (*)(void)) (mp_my_threadnum));
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_thread_init", retval);
}
#pragma parallel
#pragma local(i)
#pragma pfor
#elif defined(sun) && defined(sparc)
retval = PAPI_thread_init((unsigned long (*)(void)) (thr_self));
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_thread_init", retval);
}
#pragma MP taskloop private(i)
#else
#error "Architecture not included in this test file yet."
#endif
for (i = 1; i < 3; i++)
Thread(i, 10000000 * i);
elapsed_cyc = PAPI_get_real_cyc() - elapsed_cyc;
elapsed_us = PAPI_get_real_usec() - elapsed_us;
if (!TESTS_QUIET) {
printf("Master real usec : \t%lld\n", elapsed_us);
printf("Master real cycles : \t%lld\n", elapsed_cyc);
}
test_pass(__FILE__, NULL, 0);
exit(1);
}
inline void Vm::_executeFrame(const ByteSet& first, ThreadList::iterator t, const Instruction* const base, const byte* const cur, const uint64_t offset) {
// run old threads at this offset
// uint32_t count = 0;
while (t != Active.end()) {
_executeThread(base, t, cur, offset);
++t;
// ++count;
}
// create new threads at this offset
if (first[*cur]) {
const size_t oldsize = Active.size();
for (t = First.begin(); t != First.end(); ++t) {
#ifdef LBT_TRACE_ENABLED
Active.emplace_back(
#ifdef _MSC_VER
Thread(t->PC, Thread::NOLABEL, NextId++, offset, Thread::NONE)
#else
t->PC, Thread::NOLABEL, NextId++, offset, Thread::NONE
#endif
);
#else
Active.emplace_back(
#ifdef _MSC_VER
Thread(t->PC, Thread::NOLABEL, offset, Thread::NONE)
#else
t->PC, Thread::NOLABEL, offset, Thread::NONE
#endif
);
#endif
#ifdef LBT_TRACE_ENABLED
new_thread_json.insert(Active.back().Id);
#endif
}
for (t = Active.begin() + oldsize; t != Active.end(); ++t) {
_executeThread(base, t, cur, offset);
// ++count;
}
}
// ThreadCountHist.resize(count + 1, 0);
// ++ThreadCountHist[count];
}
void BenchmarkPlayback::InputExhausted() {
MOZ_ASSERT(OnThread());
MOZ_ASSERT(!mFinished);
if (mSampleIndex >= mSamples.Length()) {
Error(MediaResult(NS_ERROR_FAILURE, "Nothing left to decode"));
return;
}
RefPtr<MediaRawData> sample = mSamples[mSampleIndex];
RefPtr<Benchmark> ref(mGlobalState);
RefPtr<MediaDataDecoder::DecodePromise> p = mDecoder->Decode(sample);
mSampleIndex++;
if (mSampleIndex == mSamples.Length() && !ref->mParameters.mStopAtFrame) {
// Complete current frame decode then drain if still necessary.
p->Then(Thread(), __func__,
[ref, this](MediaDataDecoder::DecodedData&& aResults) {
Output(std::move(aResults));
if (!mFinished) {
mDecoder->Drain()->Then(
Thread(), __func__,
[ref, this](MediaDataDecoder::DecodedData&& aResults) {
mDrained = true;
Output(std::move(aResults));
MOZ_ASSERT(mFinished, "We must be done now");
},
[ref, this](const MediaResult& aError) { Error(aError); });
}
},
[ref, this](const MediaResult& aError) { Error(aError); });
} else {
if (mSampleIndex == mSamples.Length() && ref->mParameters.mStopAtFrame) {
mSampleIndex = 0;
}
// Continue decoding
p->Then(Thread(), __func__,
[ref, this](MediaDataDecoder::DecodedData&& aResults) {
Output(std::move(aResults));
if (!mFinished) {
InputExhausted();
}
},
[ref, this](const MediaResult& aError) { Error(aError); });
}
}
void ThreadPool::Start(void * (*Routine)(void * argv), ThreadPoolServer* tps)
{
for(int i = 0; i < capacity; ++i)
{
pool.push_back(Thread(i, Routine));
pool.back().Run(tps);
}
}
void wm_listener::Check()
{
if (!m_Thread.joinable() || m_Thread.Signaled())
{
Event ReadyEvent(Event::automatic, Event::nonsignaled);
m_Thread = Thread(&Thread::join, &wm_listener::WindowThreadRoutine, this, &ReadyEvent);
ReadyEvent.Wait();
}
}
RefPtr<Benchmark::BenchmarkPromise> Benchmark::Run() {
RefPtr<Benchmark> self = this;
return InvokeAsync(Thread(), __func__, [self] {
RefPtr<BenchmarkPromise> p = self->mPromise.Ensure(__func__);
self->mPlaybackState.Dispatch(NS_NewRunnableFunction(
"Benchmark::Run", [self]() { self->mPlaybackState.DemuxSamples(); }));
return p;
});
}
PyrideRemoteDataHandler::PyrideRemoteDataHandler(void) :
robotID_( -1 )
{
ConsoleDataProcessor::instance()->init( this );
Thread ^ dataThread = gcnew Thread( gcnew ThreadStart( &PyrideRemoteDataHandler::DataThreadProc ) );
dataThread->IsBackground = true;
dataThread->Start();
}
Benchmark::Benchmark(MediaDataDemuxer* aDemuxer, const Parameters& aParameters)
: QueueObject(AbstractThread::GetCurrent())
, mParameters(aParameters)
, mKeepAliveUntilComplete(this)
, mPlaybackState(this, aDemuxer)
{
MOZ_COUNT_CTOR(Benchmark);
MOZ_ASSERT(Thread(), "Must be run in task queue");
}
// Ejects a module (fully qualified path) via process id
void Injector::EjectLib(DWORD ProcID, const std::wstring& Path)
{
// Grab a new snapshot of the process
EnsureCloseHandle Snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ProcID));
if (Snapshot == INVALID_HANDLE_VALUE)
throw std::runtime_error("Could not get module snapshot for remote process.");;
// Get the HMODULE of the desired library
MODULEENTRY32W ModEntry = { sizeof(ModEntry) };
bool Found = false;
BOOL bMoreMods = Module32FirstW(Snapshot, &ModEntry);
for (; bMoreMods; bMoreMods = Module32NextW(Snapshot, &ModEntry))
{
std::wstring ModuleName(ModEntry.szModule);
std::wstring ExePath(ModEntry.szExePath);
Found = (ModuleName == Path || ExePath == Path);
if (Found) break;
}
if (!Found)
throw std::runtime_error("Could not find module in remote process.");;
// Get a handle for the target process.
EnsureCloseHandle Process(OpenProcess(
PROCESS_QUERY_INFORMATION |
PROCESS_CREATE_THREAD |
PROCESS_VM_OPERATION, // For CreateRemoteThread
FALSE, ProcID));
if (!Process)
throw std::runtime_error("Could not get handle to process.");
// Get the real address of LoadLibraryW in Kernel32.dll
HMODULE hKernel32 = GetModuleHandle(TEXT("Kernel32"));
if (hKernel32 == NULL)
throw std::runtime_error("Could not get handle to Kernel32.");
PTHREAD_START_ROUTINE pfnThreadRtn = (PTHREAD_START_ROUTINE)
GetProcAddress(hKernel32, "FreeLibrary");
if (pfnThreadRtn == NULL)
throw std::runtime_error("Could not get pointer to FreeLibrary.");
// Create a remote thread that calls FreeLibrary()
EnsureCloseHandle Thread(CreateRemoteThread(Process, NULL, 0,
pfnThreadRtn, ModEntry.modBaseAddr, 0, NULL));
if (!Thread)
throw std::runtime_error("Could not create thread in remote process.");
// Wait for the remote thread to terminate
WaitForSingleObject(Thread, INFINITE);
// Get thread exit code
DWORD ExitCode;
if (!GetExitCodeThread(Thread,&ExitCode))
throw std::runtime_error("Could not get thread exit code.");
// Check LoadLibrary succeeded and returned a module base
if(!ExitCode)
throw std::runtime_error("Call to FreeLibrary in remote process failed.");
}
void HiloControl::iniciarHilo()
{
hilo = gcnew Thread(gcnew ThreadStart(this, &HiloControl::metodoHilo));
hilo->Start();
/*while (!myThread->IsAlive); // wait for the thread to start
Thread::Sleep(100);
*/
}
