void ThreadPool::Start(uint16 WorkerThreads) { if(IsStarted) { printf(TM_TEXT"ERROR - ThreadPool is already started!\n"); return; } if(WorkerThreads) { for (uint16 i = 0; i < WorkerThreads; ++i) { if(TaskLine->GetSize() == 0) { if(!MakeThread(new Thread(this))) { printf(TM_TEXT"ERROR - creating suspended thread!\n"); } } else { if(!MakeThread(new Thread(this, TaskLine->PopFront()))) { printf(TM_TEXT"ERROR - creating thread with target!\n"); } } } } else { printf(TM_TEXT"ERROR - Cannot start 0 threads!?\n"); } IsStarted = true; }
void ThreadPool::Start() { if(IsStarted) { printf(TM_TEXT"ERROR - ThreadPool is already started!\n"); return; } for(uint16 i = 0; i < DEFAULT_THREADS; ++i) { if(TaskLine->GetSize() == 0) { if(!MakeThread(new Thread(this))) { printf(TM_TEXT"ERROR - Creating suspended thread!\n"); } } else { if(!MakeThread(new Thread(this, TaskLine->PopFront()))) { printf(TM_TEXT"ERROR - creating thread with target!\n"); } } } IsStarted = true; }
void RageThread::Create( int (*fn)(void *), void *data ) { /* Don't create a thread that's already running: */ ASSERT( m_pSlot == NULL ); InitThreads(); /* Lock unused slots, so nothing else uses our slot before we mark it used. */ LockMut(g_ThreadSlotsLock); int slotno = FindEmptyThreadSlot(); m_pSlot = &g_ThreadSlots[slotno]; if( name == "" ) { if( LOG ) LOG->Warn("Created a thread without naming it first."); /* If you don't name it, I will: */ strcpy( m_pSlot->name, "Joe" ); } else { strcpy( m_pSlot->name, name.c_str() ); } if( LOG ) LOG->Trace( "Starting thread: %s", name.c_str() ); sprintf( m_pSlot->ThreadFormattedOutput, "Thread: %s", name.c_str() ); /* Start a thread using our own startup function. We pass the id to fill in, * to make sure it's set before the thread actually starts. (Otherwise, early * checkpoints might not have a completely set-up thread slot.) */ m_pSlot->pImpl = MakeThread( fn, data, &m_pSlot->id ); }
void TaskQueue::TaskThreadPool::AddQueueTask(TaskQueue *queue, Task &&task) { QMutexLocker lock(&queues_mutex_); queue->tasks_.push_back(new Task(std_::move(task))); auto list_was_empty = queue_list_.Empty(kAllQueuesList); auto threads_count = threads_.size(); auto all_threads_processing = (threads_count == tasks_in_process_); auto some_threads_are_vacant = !all_threads_processing && list_was_empty; auto will_create_thread = !some_threads_are_vacant && (threads_count < MaxThreadsCount); if (!queue->SerialTaskInProcess()) { if (!queue_list_.IsInList(queue)) { queue_list_.Register(queue); } } if (will_create_thread) { threads_.push_back(MakeThread([this]() { ThreadFunction(); })); threads_.back()->start(); } else if (some_threads_are_vacant) { t_assert(threads_count > tasks_in_process_); thread_condition_.wakeOne(); } }
IThreadHandle *PosixThreader::MakeThread(IThread *pThread, ThreadFlags flags) { ThreadParams defparams; defparams.flags = flags; defparams.prio = ThreadPrio_Normal; return MakeThread(pThread, &defparams); }
void PosixThreader::MakeThread(IThread *pThread) { ThreadParams defparams; defparams.flags = Thread_AutoRelease; defparams.prio = ThreadPrio_Normal; MakeThread(pThread, &defparams); }
IThreadHandle *BaseWorker::MakeThread(IThread *pThread, ThreadFlags flags) { ThreadParams pt; pt.flags = flags; pt.prio = ThreadPrio_Normal; return MakeThread(pThread, &pt); }
void BaseWorker::MakeThread(IThread *pThread) { ThreadParams pt; pt.flags = Thread_AutoRelease; pt.prio = ThreadPrio_Normal; MakeThread(pThread, &pt); }
static void CPROC OkayChoiceClicked( uintptr_t psv, PCONTROL pc ) { PBANNER banner = (PBANNER)psv; #ifdef DEBUG_BANNER_DRAW_UPDATE lprintf( WIDE( "OKAY!" ) ); #endif banner->flags |= (BANNER_CLOSED|BANNER_OKAY); { PTHREAD thread = (banner)->pWaitThread; if( thread && ( thread != MakeThread() ) ) { WakeThread( thread ); } } }
int GetCh( void ) { int ch; //if( g.pCurrentPlayer && g.pCurrentPlayer->flags.bRemote ) // return 0; if( !pThreadInput ) pThreadInput = MakeThread(); if( !inputpipe ) { inputpipe = open( WIDE("stockmarket.pipe"), O_RDWR|O_CREAT|O_TRUNC, 0600 ); ThreadTo( InputThread, 0 ); } if( !save ) save = sack_fopen( 0, WIDE("stockmarket.save"), WIDE("wt") ); if( script ) { ch = fgetc( script ); if( ch == -1 ) { fclose( script ); script = NULL; } } if( !script ) { ch = 0; // clear upper bits. lprintf( WIDE("will read 1 TEXTCHAR") ); while( bEnque || ( read( inputpipe, &ch, 1 ) < 1 ) ) { lprintf( WIDE("Waiting for input event.") ); WakeableSleep( SLEEP_FOREVER ); lprintf( WIDE("Input event received.") ); } lprintf( WIDE("Read input.") ); } if( ch == '\r' ) fputc( '\n', save ); else fputc( ch, save ); fflush( save ); return ch; }
KinectInterfacePrimesense::KinectInterfacePrimesense(const char* device_uri) { device_initialized_ = false; device_ = NULL; pts_world_ = NULL; pts_uvd_ = NULL; labels_ = NULL; depth_1mm_ = NULL; registered_rgb_ = NULL; openni_funcs_ = NULL; depth_dim_.zeros(); rgb_dim_.zeros(); ir_dim_.zeros(); for (uint32_t i = 0; i < NUM_STREAMS; i++) { streams_[i] = NULL; frames_[i] = NULL; } depth_frame_number_ = 0; rgb_frame_number_ = 0; ir_frame_number_ = 0; tp_ = NULL; init(device_uri); // Now spawn the Kinect Update Thread kinect_running_ = true; Callback<void>* threadBody = MakeCallableOnce( &KinectInterfacePrimesense::kinectUpdateThread, this); kinect_thread_ = MakeThread(threadBody); device_initialized_ = true; // Increment the devices counter openni_static_lock_.lock(); openni_devices_open_++; open_kinects_.pushBack(this); openni_static_lock_.unlock(); }
DWORD CClient::StartClient() { DWORD dwRet; DWORD dwCount = 0; while (1) { dwRet = ConnectServer(); if (dwRet != E_RET_SUCCESS) { WriteLog(E_LOG_LEVEL_ERROR, "Fail to connect to Server"); } dwRet = MakeThread(); if (dwRet != E_RET_SUCCESS) { WriteLog(E_LOG_LEVEL_ERROR, "Fail to make thread"); } WaitForMultipleObjects(MAX_THREAD, m_hArray, TRUE, INFINITE); /* normally, code have to be not executed if it was done, first or second thread is exited */ g_bThreadExit = FALSE; /* Wait for 1 second to exit all thread ordinarily */ ::Sleep(1000); int i; for (i = 0; i < MAX_THREAD; i++) m_hArray[i] = NULL; g_bThreadExit = TRUE; } }
SaneWinMain( argc, argv ) { int nowait = 0; int task_monitor = 0; int noinput = 0; if( argc < 2 ) { #ifdef WIN32 const TEXTCHAR * const args[] ={ WIDE("cmd.exe"), NULL }; #else const TEXTCHAR * const args[] ={ WIDE("/bin/sh"), NULL }; #endif if( !( task = LaunchPeerProgram( args[0], NULL, args, output, ended, 0 ) ) ) done = 1; } else { int delay = 0; int offset = 1; while( argv[offset] && argv[offset][0] == '-' ) { if( StrCaseCmp( argv[offset]+1, WIDE("nowait") ) == 0 ) nowait = 1; if( StrCaseCmp( argv[offset]+1, WIDE("taskmon") ) == 0 ) task_monitor = 1; if( StrCaseCmp( argv[offset]+1, WIDE("noin") ) == 0 ) noinput = 1; if( StrCaseCmp( argv[offset]+1, WIDE("local") ) == 0 ) { SetCurrentPath( OSALOT_GetEnvironmentVariable( WIDE("MY_LOAD_PATH") ) ); } if( StrCaseCmp( argv[offset]+1, WIDE("delay") ) == 0 ) { delay = atoi( argv[offset+1] ); offset++; // used an extra parameter } offset++; } if( delay ) WakeableSleep( delay ); if( offset < argc ) { if( !( task = LaunchPeerProgram( argv[offset], NULL, argv + offset, noinput?NULL:output, ended, 0 ) ) ) done = 1; } else { #ifdef WIN32 const TEXTCHAR * const args[] ={ WIDE("cmd.exe"), NULL }; #else const TEXTCHAR * const args[] ={ WIDE("/bin/sh"), NULL }; #endif if( !( task = LaunchPeerProgram( args[0], NULL, args, noinput?NULL:output, ended, 0 ) ) ) done = 1; } } main_thread = MakeThread(); while( !done ) { TEXTCHAR buf[256]; if( nowait ) WakeableSleep( 1000 ); else { if( !noinput ) { if( fgets( buf, 256, stdin ) ) { pprintf( task, WIDE("%s"), buf ); } } else nowait = 1; } } if( task_monitor ) SendMessage( FindWindow( WIDE("TaskMonClass"), WIDE("Task Completion Monitor") ), WM_USER+500, 0, 0 ); fprintf( stdout, WIDE("Shell Completed.") ); return 0; }