void work(int num, bool print) { #define printf(...) \ do { \ if ((print)) { \ cprintf(__VA_ARGS__); \ } \ } while (0) do_yield(); int i, j; for (i = 0; i < size; i++) { assert(buffer[i] == (char)(i * i)); } printf("check cow ok.\n"); char c = (char)num; for (i = 0; i < 5; i++, c++) { printf("round %d\n", i); memset(buffer, c, size); for (j = 0; j < size; j++) { assert(buffer[i] == c); } } do_yield(); printf("child check ok.\n"); #undef printf }
void thread4(void) { /* get timer, yield to thread5 */ num_inst = get_timer(); do_yield(); do_exit(); }
long do_sched_op_compat(int cmd, unsigned long arg) { long ret = 0; switch ( cmd ) { case SCHEDOP_yield: { ret = do_yield(); break; } case SCHEDOP_block: { ret = do_block(); break; } case SCHEDOP_shutdown: { TRACE_3D(TRC_SCHED_SHUTDOWN, current->domain->domain_id, current->vcpu_id, arg); domain_shutdown(current->domain, (u8)arg); break; } default: ret = -ENOSYS; } return ret; }
static void barrier_thread(int id) { int i, j; if (0 == id) { barrier_init(&barrier, NUM_THREADS); barrier_initialized = TRUE; } else { while (!barrier_initialized) { do_yield(); } } for (i = 0; i < NUM_ITERATIONS; ++i) { ++value[id]; barrier_wait(&barrier); do_sleep(rand() % MAX_SLEEP); for (j = 0; j < NUM_THREADS; ++j) { ASSERT(value[j] == value[id]); } printf(LINE + id, COL, "Barrier thread %d: %d", do_getpid(), value[id]); barrier_wait(&barrier); } ASSERT(NUM_ITERATIONS == value[id]); printf(LINE + id, COL, "Barrier thread %d: Passed\t", do_getpid()); do_exit(); }
// the only difference here is do_yield() call DWORD unsqu_y (BYTE *i_buf,BYTE *o_buf, void* yield_) { const unsigned int bits[16] = { 1<<15, 1<<14, 1<<13, 1<<12, 1<<11, 1<<10, 1<<9, 1<<8, 1<<7, 1<<6, 1<<5, 1<<4, 1<<3, 1<<2, 1<<1, 1<<0 }; DWORD len; DWORD bit; int span; BYTE* s_fp = i_buf; BYTE* o_ptr = o_buf; void* yield = yield_; int y_count = 4; unsigned int s_buf; int s_count = 0; if (0 == yield_) return unsqu(i_buf,o_buf); fillbitbuf(); while(1){ getbit(bit); if(bit) { *o_ptr++=getbyte(); continue; } getbit(bit); if(!bit) { // len 2-5, span 0-ff getbit(bit); if (bit) len=2; else len=0; getbit(bit); if (bit) len++; len += 2; span=getbyte() | 0xffffff00; } else { span=getbyte(); len=getbyte(); span |= ((len & ~0x07)<<5) | 0xffffe000; len = (len & 0x07)+2; if (len==2) { len=getbyte(); if(len==0) break; // end mark of compressed load module if(len==1) continue; // segment change else len++; } do_yield(); } // "for" works better then memcpy for( ;len>0;len--,o_ptr++) *o_ptr=*(o_ptr+span); } return(o_ptr-o_buf); }
// Nothrow. void do_return(context_exit_status status, std::exception_ptr && info) noexcept { HPX_ASSERT(status != ctx_not_exited); HPX_ASSERT(m_state == ctx_running); m_type_info = std::move(info); m_state = ctx_exited; m_exit_status = status; #if defined(HPX_HAVE_ADDRESS_SANITIZER) start_yield_fiber(&asan_fake_stack, m_caller); #endif do_yield(); }
static gboolean oss_output_stop(gboolean must_flush) { if (oss_fd == -1) return TRUE; if (must_flush) while (ringbuf_available(oss_output_buffer)>0) { oss_output_flush(NULL,NULL,NULL); do_yield(TRUE); } else oss_output_clear_buffers(); close(oss_fd); oss_fd = -1; /* printf("oss_stop: oss_delay_time = %f\n",oss_delay_time); */ ringbuf_drain(oss_output_buffer); return must_flush; }
// Put coroutine in ready state and relinquish control // to caller until resumed again. // Pre: Coroutine is running. // Exit not pending. // Operations not pending. // Post: Coroutine is running. // Throws: exit_exception, if exit is pending *after* it has been // resumed. void yield() { HPX_ASSERT(m_exit_state < ctx_exit_signaled); //prevent infinite loops HPX_ASSERT(running()); m_state = ctx_ready; #if defined(HPX_HAVE_ADDRESS_SANITIZER) start_yield_fiber(&asan_fake_stack, m_caller); #endif do_yield(); #if defined(HPX_HAVE_ADDRESS_SANITIZER) finish_switch_fiber(asan_fake_stack, m_caller); #endif HPX_ASSERT(running()); }
sync_sched::fstate_t sync_sched::frun() { if (debug_driver) fprintf(stderr,"[sync] frun: entry ft=%p, active size=%ld\n", ft,active->size()); dispatch: if (ft == 0) { if (active->size() == 0) // out of active fthreads { return blocked; } ft = active->front(); // grab next fthread active->pop_front(); } request = ft->run(); // run fthread to get request if(request == 0) // euthenasia request { if(debug_driver) fprintf(stderr,"unrooting fthread %p\n",ft); collector->remove_root(ft); ft = 0; goto dispatch; } if (debug_driver) fprintf(stderr,"[flx_sync:sync_sched] dispatching service request %d\n", request->variant); switch(request->variant) { case svc_yield: do_yield(); goto dispatch; case svc_spawn_detached: do_spawn_detached(); goto dispatch; case svc_sread: do_sread(); goto dispatch; case svc_swrite: do_swrite(); goto dispatch; case svc_multi_swrite: do_multi_swrite(); goto dispatch; case svc_kill: do_kill(); goto dispatch; default: return delegated; } }
/* * This thread runs indefinitely */ void clock_thread(void) { unsigned int time; unsigned long long int ticks; unsigned int start_time; /* To show time since last boot, remove all references to start_time */ ticks = get_timer() >> 20; /* divide on 2^20 = 10^6 (1048576) */ start_time = ((int) ticks) / MHZ; /* divide on CPU clock frequency in * megahertz */ while (1) { ticks = get_timer() >> 20; /* divide on 2^20 = 10^6 (1048576) */ time = ((int) ticks) / MHZ; /* divide on CPU clock frequency in * megahertz */ print_str(24, 50, "Time (in seconds) : "); print_int(24, 70, time - start_time); print_counter(); do_yield(); } }
static uint32_t sys_yield(uint32_t arg[]) { return do_yield(); }
static uint32_t __sys_linux_sched_yield(uint32_t arg[]) { return do_yield(); }