static void Quit(void) { // Exit PowerPC emulation exit_emul_ppc(); // Stop 60Hz thread if (tick_thread_active) { tick_thread_cancel = true; wait_thread(tick_thread); } // Stop NVRAM watchdog thread if (nvram_thread_active) { nvram_thread_cancel = true; wait_thread(nvram_thread); } // Deinitialize everything ExitAll(); // Delete SheepShaver globals SheepMem::Exit(); // Delete RAM area if (ram_area_mapped) vm_mac_release(RAMBase, RAMSize); // Delete ROM area if (rom_area_mapped) vm_mac_release(ROMBase, ROM_AREA_SIZE); // Delete DR cache areas if (dr_emulator_area_mapped) vm_mac_release(DR_EMULATOR_BASE, DR_EMULATOR_SIZE); if (dr_cache_area_mapped) vm_mac_release(DR_CACHE_BASE, DR_CACHE_SIZE); // Delete Kernel Data area kernel_data_exit(); // Exit system routines SysExit(); // Exit preferences PrefsExit(); // Release win32 libraries KernelExit(); #ifdef ENABLE_MON // Exit mon mon_exit(); #endif exit(0); }
int main(void) { int i; pthread_t thread; pthread_t thread1; if (pthread_create(&thread, NULL, thread_func, NULL) != 0) { return EXIT_FAILURE; } if (pthread_create(&thread1, NULL, thread_func, NULL) != 0) { return EXIT_FAILURE; } for (i = 0; i < 20; i++) { puts("a"); wait_thread(); } if (pthread_join(thread, NULL) != 0) { return EXIT_FAILURE; } return EXIT_SUCCESS; }
int attach_thread(int tid) { if (ptrace(PTRACE_ATTACH, tid, NULL, NULL) < 0) { perror("PTRACE_ATTACH"); return -1; } if (wait_thread(tid) < 0) return -1; return 0; }
static void *thread_func(void *vptr_args) { int i; for (i = 0; i < 20; i++) { fputs(" b\n", stderr); wait_thread(); } return NULL; }
void call_wait_thread(void *context) { SshThread thread = context; D(("C: Call_wait_thread called, number of threads now out %d, thread = %p\n", threads, thread)); D(("C: Waiting for thread\n")); wait_thread(thread); threads--; D(("C: Waited for thread, decrementing threads counter, new value = %d\n", threads)); if (threads == 0) ssh_xregister_timeout(0, 0, check_for_threads, NULL); }
static struct kernel_dispatch_info *prepare_thread(struct kernel_dispatch_info *disp_info) { // Put the thread to wait int is_in_wait = wait_thread(disp_info->thread); assert(is_in_wait); // Duplicate dispatch info struct kernel_dispatch_info *dup_disp_info = salloc(kernel_dispatch_salloc_id); assert(dup_disp_info); memcpy(disp_info, dup_disp_info, sizeof(struct kernel_dispatch_info)); return dup_disp_info; }
int main() { //int fd = 0; char buffer[BUFFER_SIEZE] = {0}; if((fd = Open_Port(HOST_PORT)) == -1) { perror("Open port"); return -1; } if( Set_Port(fd,9600,8,'N',1) == -1) { perror("Set_Port"); return -1; } //Serial_SendStr(fd,"Hello This is from Ubuntu\n"); pthread_mutex_init(&mut,NULL); while(1) { time(&now); tm_now = localtime(&now); datetime=asctime(tm_now); create_thread(); wait_thread(); if( IsReceve ==1) { printf("\n%sInput the Send Message:\n",datetime); memset(buffer,0,BUFFER_SIEZE); if(fgets(buffer,BUFFER_SIEZE,stdin) == NULL)//get input chars { perror("Fgets"); break; } write(fd,buffer,strlen(buffer));//send chars IsReceve = 0; } } close(fd); return 0; }
int main(int argc, char **argv) { pthread_t tid; int opt; sem_init(&main_sem, 0, 0); sem_init(&thread_sem, 0, 0); while ((opt = getopt(argc, argv, "hs:d:")) != -1) { switch (opt){ case 'h': usage(); exit(0); case 'l': local = 1; break; case 's': sport = atoi(optarg); case 'd': dport = atoi(optarg); break; default: usage(); exit(0); } } if (optind != (argc - 1)) { usage(); exit(0); } dst = argv[optind]; /* prepare local for libpcap */ if (strcmp(dst, "127.0.0.1") == 0 || strcmp(src, dst) == 0) local = 1; signal(SIGALRM, sigalrm); alarm(10); pthread_create(&tid, NULL, pcap_thread, NULL); /* wait init ack num */ while (tcp_seq == 0) { wait_thread(); } /* when do_send OK, wait analyse */ do_send(); tell_thread(); pthread_join(tid, NULL); exit(0); }
//----------------------------------------------------------------------------- //used in application frame update (idle) to update new data -- virtual function //get data and update dataDims|Origin progresively until all data is updated //for data distribution: DL_CHUNK //and load mode: DL_BLOCKING or DL_THREAD //----------------------------------------------------------------------------- bool CDataLoader::update_data() { //fprintf(stderr, "**** %s:%s() ****\n", __FILE__, __func__); if(m_cid >= m_chunkNum[0]*m_chunkNum[1]*m_chunkNum[2]) return false; assert(m_dataDist == DL_CHUNK); switch(m_dataLoadmode) { case DL_BLOCKING: loaddata_chunk(m_cid); break; case DL_THREAD: wait_thread(m_cid); break; default: m_data = 0; } m_cid++; return true; }
int main(int argc, char *argv[]) { int threads = 8; if (argc > 1) threads = atoi(argv[1]); if (threads > MAX_THREADS) threads = MAX_THREADS; printf("Testing with %d threads\n", threads); for (int i = 0; i < threads; i++) { launch_thread(i); } for (int i = 0; i < threads; i++) { wait_thread(i); } return 0; }
int thread_wait(int tid,int timeout){ int rcode; int nmask,smask; if( ThreadWait ){ thwait++; if( lTHREADLOG() ){ syslog_ERROR("thread_wait(%X %d)\n",tid,timeout); } if( !isWindows() && 0 < timeout ){ if( thread_wait_timeout(tid,timeout) < 0 ){ thwaitTimeout++; return -1; } } if( wait_thread(tid,timeout) < 0 ) { thwaitWaiterr++; return -1; } nmask = sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGPIPE); nmask |= sigmask(SIGHUP); smask = sigblock(nmask); rcode = (*ThreadWait)(tid,timeout); if( rcode == 0 ){ ActiveThreads--; putpplog("actthreads()--=%d [%X]\n",ActiveThreads,tid); } else{ thwaitCodeerr++; } sigsetmask(smask); return rcode; /* return (*ThreadWait)(tid,timeout); */ } return -1; }
void draw_set(t_image *img, t_frac *f) { t_data_thread dt; pthread_t draw_threads[NUM_THREADS]; int i; int starts[NUM_THREADS]; int ends[NUM_THREADS]; init_starts_ends(starts, ends); i = 0; dt.img = img; dt.f = f; pthread_mutex_init(&dt.frac_mutex, NULL); while (i < NUM_THREADS) { dt.start = starts[i]; dt.f->p.x = dt.start; dt.end = ends[i]; launch_thread(&draw_threads[i], draw_worker, &dt); wait_thread(draw_threads[i]); i++; } pthread_mutex_destroy(&dt.frac_mutex); }
void TestThisThread() { hadesmem::Thread thread(::GetCurrentThreadId()); BOOST_TEST_EQ(thread, thread); hadesmem::Thread thread_new(::GetCurrentThreadId()); BOOST_TEST_EQ(thread, thread_new); hadesmem::Thread const thread_moved(std::move(thread_new)); hadesmem::Thread thread_copy(thread); BOOST_TEST_EQ(thread_copy, thread); thread = thread_copy; BOOST_TEST_EQ(thread, thread_copy); thread_new = std::move(thread_copy); BOOST_TEST_EQ(thread, thread_new); BOOST_TEST(thread >= thread); BOOST_TEST(thread <= thread); BOOST_TEST_EQ(thread.GetId(), ::GetCurrentThreadId()); std::stringstream thread_str_1; thread_str_1.imbue(std::locale::classic()); thread_str_1 << thread; DWORD thread_id_1; thread_str_1 >> thread_id_1; BOOST_TEST_EQ(thread.GetId(), thread_id_1); std::wstringstream thread_str_2; thread_str_2.imbue(std::locale::classic()); thread_str_2 << thread; DWORD thread_id_2; thread_str_2 >> thread_id_2; BOOST_TEST_EQ(thread.GetId(), thread_id_2); hadesmem::detail::SmartHandle quit_event( ::CreateEvent(nullptr, TRUE, FALSE, nullptr)); DWORD other_id = 0; hadesmem::detail::SmartHandle wait_thread( ::CreateThread(nullptr, 0, &WaitFunc, &quit_event, 0, &other_id)); // Disgusting hack to work around a potential race condition where we suspend // the thread before it's actually waiting on our event, and instead it's // still in its initialization routine and ends up holding a lock that the // main thread will need (e.g. from malloc). See thread_140224_144550.dmp. ::Sleep(5 * 1000); auto const cleanup_thread_func = [&]() { BOOST_TEST_NE(::SetEvent(quit_event.GetHandle()), 0); BOOST_TEST_EQ(::WaitForSingleObject(wait_thread.GetHandle(), INFINITE), WAIT_OBJECT_0); }; { ScopeExit<decltype(cleanup_thread_func)> cleanup_thread( cleanup_thread_func); hadesmem::Thread const other_thread(other_id); BOOST_TEST_EQ(hadesmem::SuspendThread(other_thread), 0UL); BOOST_TEST_EQ(hadesmem::SuspendThread(other_thread), 1UL); BOOST_TEST_EQ(hadesmem::ResumeThread(other_thread), 2UL); BOOST_TEST_EQ(hadesmem::ResumeThread(other_thread), 1UL); { hadesmem::SuspendedThread const suspend_thread(other_thread.GetId()); CONTEXT const full_context = hadesmem::GetThreadContext(other_thread, CONTEXT_FULL); CONTEXT const all_context = hadesmem::GetThreadContext(other_thread, CONTEXT_ALL); hadesmem::SetThreadContext(other_thread, full_context); hadesmem::SetThreadContext(other_thread, all_context); BOOST_TEST_THROWS(hadesmem::GetThreadContext(thread, CONTEXT_FULL), hadesmem::Error); } { hadesmem::SuspendedProcess const suspend_process(::GetCurrentProcessId()); } } }
int sys_wait_thread(void) { return wait_thread(); }