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();
}
