自学教程：C++ sys_yield函数代码示例

voidstart(void){	sys_priority(PRIORITY);	sys_share(SHARE);	sys_yield();	int i;	for (i = 0; i < RUNCOUNT; i++) {		// Write characters to the console, yielding after each one.		//*cursorpos++ = PRINTCHAR;		//call system call instead		#ifndef __EXERCISE_8__		sys_print(PRINTCHAR);		#endif		#ifdef __EXERCISE_8__		while(atomic_swap(&spin_lock, 1) != 0){ //run 4ever until locked			continue;		}		*cursorpos++ = PRINTCHAR;		atomic_swap(&spin_lock, 0); //free		#endif		sys_yield();	}	// Yield forever.	while (1)		//sys_yield();		sys_exit(0);}

voidinput(envid_t ns_envid){	binaryname = "ns_input";	// LAB 6: Your code here:	// 	- read a packet from the device driver	//	- send it to the network server	// Hint: When you IPC a page to the network server, it will be	// reading from it for a while, so don't immediately receive	// another packet in to the same physical page.    uint8_t data[2048];    int length, r;    for (;;) {        while ((length = sys_pkt_receive(data)) < 0)            sys_yield();        while (sys_page_alloc(0, &nsipcbuf, PTE_P | PTE_W | PTE_U) < 0)            sys_yield();        nsipcbuf.pkt.jp_len = length;        memmove(nsipcbuf.pkt.jp_data, data, length);        while (sys_ipc_try_send(ns_envid, NSREQ_INPUT, &nsipcbuf, PTE_P | PTE_W | PTE_U) < 0)            sys_yield();    }}

voidstart(void){	int i;	proc_priority(PRIORITYCHECK);	proc_share(PRIORITYCHECK);	sys_yield();	for (i = 0; i < RUNCOUNT; i++) {#ifdef USE_SYSTEM_SYNC		// use a safe system call to print character to avoid a race condition		proc_print(PRINTCHAR);#else		// use atomic_swap to get a lock		while (atomic_swap(&lock, 1) !=0 ) {			continue;		}		// Write characters to the console, yielding after each one.		*cursorpos++ = PRINTCHAR;		// use atomic_swap to release lock		atomic_swap(&lock, 0);#endif		sys_yield();	}	// Yield forever.	// while (1)	// 	sys_yield();	sys_exit(0);}

voidinput(envid_t ns_envid){	binaryname = "ns_input";	// LAB 6: Your code here:	// 	- read a packet from the device driver	//	- send it to the network server	// Hint: When you IPC a page to the network server, it will be	// reading from it for a while, so don't immediately receive	// another packet in to the same physical page.	int i, r;	int32_t length;	struct jif_pkt *cpkt = pkt;		for(i = 0; i < 10; i++)		if ((r = sys_page_alloc(0, (void*)((uintptr_t)pkt + i * PGSIZE), PTE_P | PTE_U | PTE_W)) < 0)			panic("sys_page_alloc: %e", r);		i = 0;	while(1) {		while((length = sys_netpacket_recv((void*)((uintptr_t)cpkt + sizeof(cpkt->jp_len)), PGSIZE - sizeof(cpkt->jp_len))) < 0) {			// cprintf("len: %d/n", length);			sys_yield();		}		cpkt->jp_len = length;		ipc_send(ns_envid, NSREQ_INPUT, cpkt, PTE_P | PTE_U);		i = (i + 1) % 10;		cpkt = (struct jif_pkt*)((uintptr_t)pkt + i * PGSIZE);		sys_yield();	}	}

// Send 'val' (and 'pg' with 'perm', assuming 'pg' is nonnull) to 'toenv'.// This function keeps trying until it succeeds.// It should panic() on any error other than -E_IPC_NOT_RECV.//// Hint://   Use sys_yield() to be CPU-friendly.//   If 'pg' is null, pass sys_ipc_recv a value that it will understand//   as meaning "no page".  (Zero is not the right value.)voidipc_send(envid_t to_env, uint32_t val, void *pg, int perm){	// LAB 4: Your code here.	int ret;	void * srcva;	if(pg == 0)		srcva = (void*)UTOP;	else		srcva = pg;	while(1)	{		ret = sys_ipc_try_send(to_env,val,srcva,perm);		if(ret == 0 || ret == 1)				{			//cprintf("return 0/n");			sys_yield();			break;		}		else if(ret == -E_IPC_NOT_RECV)		{			//cprintf("ipc not recv/n");			sys_yield();			continue;		}		else			panic("error occur in ipc send:%e",ret);	}	//cprintf("return from ipc send/n");	//panic("ipc_send not implemented");}

static void global_tests(uint32_t vcoreid){	switch (test) {		case TEST_YIELD_ALL:			printf("Core %d yielding/n", vcoreid);			sys_yield(0);			// should be RUNNABLE_M now, amt_wanted == 1			while(1);		case TEST_SWITCH_TO_RUNNABLE_S:			if (vcoreid == 2) {				printf("Core %d trying to request 0/ switch to _S/n", vcoreid);				udelay(3000000);				vcore_request_more(0);				// will only see this if we are scheduled()				printf("Core %d back up!/n");				printf("And exiting/n");				exit(0);			} 			while(1);		case TEST_CRAZY_YIELDS:			udelay(300000*vcoreid);			vcore_request_more(5);			sys_yield(0);			printf("should  never see me, unless you slip into *_S/n");			break;		case TEST_CONCURRENT_SYSCALLS:			for (int i = 0; i < 10; i++) {				for (int j = 0; j < 100; j++)					sys_null();				printf("Hello from vcore %d, iteration %d/n", vcoreid, i);			}			break;	}}

voidstart(void){	int i;	sys_share(SHARE);	sys_priority(PRIORITY);	#ifdef __EXERCISE_4A__ 	sys_yield();//for 4a	#endif	for (i = 0; i < RUNCOUNT; i++) {		// Write characters to the console, yielding after each one.		//cursorpos++ = PRINTCHAR;		//atomic_swap(uint32_t *addr, uint32_t val);		#ifdef __EXERCISE_8__  // exercise 8 sync method			sys_atomic_print(PRINTCHAR);		#else // exercise 6 sync method		while(atomic_swap(&lock,1)!= 0)		{			//return 0 means get the lock;			continue;		}		*cursorpos++ = PRINTCHAR;		atomic_swap(&lock,0);		#endif		sys_yield();				//release the lock	}	// Yield forever.	sys_exit(0);}

voidumain(int argc, char **argv){	int i, j;	int seen;	envid_t parent = sys_getenvid();	// Fork several environments	for (i = 0; i < 20; i++)		if (fork() == 0)			break;	if (i == 20) {		sys_yield();		return;	}	// Wait for the parent to finish forking	while (envs[ENVX(parent)].env_status != ENV_FREE)		asm volatile("pause");	// Check that one environment doesn't run on two CPUs at once	for (i = 0; i < 10; i++) {		sys_yield();		for (j = 0; j < 10000; j++)			counter++;	}	if (counter != 10*10000)		panic("ran on two CPUs at once (counter is %d)", counter);	// Check that we see environments running on different CPUs	cprintf("[%08x] stresssched on CPU %d/n", thisenv->env_id, thisenv->env_cpunum);}

void process_main(void) {    while (1) {        if (rand() % ALLOC_SLOWDOWN == 0) {            if (sys_fork() == 0) {                break;            }        } else {            sys_yield();        }    }    pid_t p = sys_getpid();    srand(p);    // The heap starts on the page right after the 'end' symbol,    // whose address is the first address not allocated to process code    // or data.    heap_top = ROUNDUP((uint8_t*) end, PAGESIZE);    // The bottom of the stack is the first address on the current    // stack page (this process never needs more than one stack page).    stack_bottom = ROUNDDOWN((uint8_t*) read_rsp() - 1, PAGESIZE);    // Allocate heap pages until (1) hit the stack (out of address space)    // or (2) allocation fails (out of physical memory).    while (1) {        int x = rand() % (8 * ALLOC_SLOWDOWN);        if (x < 8 * p) {            if (heap_top == stack_bottom || sys_page_alloc(heap_top) < 0) {                break;            }            *heap_top = p;      /* check we have write access to new page */            heap_top += PAGESIZE;            if (console[CPOS(24, 0)]) {                /* clear "Out of physical memory" msg */                console_printf(CPOS(24, 0), 0, "/n");            }        } else if (x == 8 * p) {            if (sys_fork() == 0) {                p = sys_getpid();            }        } else if (x == 8 * p + 1) {            sys_exit();        } else {            sys_yield();        }    }    // After running out of memory    while (1) {        if (rand() % (2 * ALLOC_SLOWDOWN) == 0) {            sys_exit();        } else {            sys_yield();        }    }}

voidumain(int argc, char **argv){	envid_t env;	cprintf("I am the parent.  Forking the child.../n");	if ((env = fork()) == 0) {		cprintf("I am the child.  Spinning.../n");		while (1)			/* do nothing */;	}	cprintf("I am the parent.  Running the child.../n");	sys_yield();	sys_yield();	sys_yield();	sys_yield();	sys_yield();	sys_yield();	sys_yield();	sys_yield();	cprintf("I am the parent.  Killing the child.../n");	sys_env_destroy(env);}

voidstart(void){	int i;	for (i = 0; i < RUNCOUNT; i++) {		// Write characters to the console, yielding after each one.		*cursorpos++ = PRINTCHAR;		sys_yield();	}	// Yield forever.	while (1)		sys_yield();}

voidstart(void){	int i;	for (i = 0; i < RUNCOUNT; i++) {		// Write characters to the console, yielding after each one.				#ifndef __EXERCISE_8__			// (exercise 6 code)			sys_print(PRINTCHAR);				#else			// (exercise 8 code)			// Implemented spinlock to remove race condition of printing for each process.			while (atomic_swap(&spin_lock, 1) != 0)				continue;			*cursorpos++ = PRINTCHAR;			atomic_swap(&spin_lock, 0);		#endif		sys_yield();	}	sys_exit(0);	// // Yield forever.	// while (1)	// 	sys_yield();}

static ssize_tdevpipe_write(struct Fd *fd, const void *vbuf, size_t n){	const uint8_t *buf;	size_t i;	struct Pipe *p;	p = (struct Pipe*) fd2data(fd);	if (debug)		cprintf("[%08x] devpipe_write %08x %d rpos %d wpos %d/n",			thisenv->env_id, uvpt[PGNUM(p)], n, p->p_rpos, p->p_wpos);	buf = vbuf;	for (i = 0; i < n; i++) {		while (p->p_wpos >= p->p_rpos + sizeof(p->p_buf)) {			// pipe is full			// if all the readers are gone			// (it's only writers like us now),			// note eof			if (_pipeisclosed(fd, p))				return 0;			// yield and see what happens			if (debug)				cprintf("devpipe_write yield/n");			sys_yield();		}		// there's room for a byte.  store it.		// wait to increment wpos until the byte is stored!		p->p_buf[p->p_wpos % PIPEBUFSIZ] = buf[i];		p->p_wpos++;	}	return i;}

static ssize_tdevpipe_read(struct Fd *fd, void *vbuf, size_t n){	uint8_t *buf;	size_t i;	struct Pipe *p;	p = (struct Pipe*)fd2data(fd);	if (debug)		cprintf("[%08x] devpipe_read %08x %d rpos %d wpos %d/n",			thisenv->env_id, uvpt[PGNUM(p)], n, p->p_rpos, p->p_wpos);	buf = vbuf;	for (i = 0; i < n; i++) {		while (p->p_rpos == p->p_wpos) {			// pipe is empty			// if we got any data, return it			if (i > 0)				return i;			// if all the writers are gone, note eof			if (_pipeisclosed(fd, p))				return 0;			// yield and see what happens			if (debug)				cprintf("devpipe_read yield/n");			sys_yield();		}		// there's a byte.  take it.		// wait to increment rpos until the byte is taken!		buf[i] = p->p_buf[p->p_rpos % PIPEBUFSIZ];		p->p_rpos++;	}	return i;}

voidumain(int argc, char **argv){	envid_t ns_envid = sys_getenvid();	int i, r;	binaryname = "testoutput";	output_envid = fork();	if (output_envid < 0)		panic("error forking");	else if (output_envid == 0) {		output(ns_envid);		return;	}	for (i = 0; i < TESTOUTPUT_COUNT; i++) {		if ((r = sys_page_alloc(0, pkt, PTE_P|PTE_U|PTE_W)) < 0)			panic("sys_page_alloc: %e", r);		pkt->jp_len = snprintf(pkt->jp_data,				       PGSIZE - sizeof(pkt->jp_len),				       "Packet %02d", i);		cprintf("Transmitting packet %d/n", i);		ipc_send(output_envid, NSREQ_OUTPUT, pkt, PTE_P|PTE_W|PTE_U);		sys_page_unmap(0, pkt);	}	// Spin for a while, just in case IPC's or packets need to be flushed	for (i = 0; i < TESTOUTPUT_COUNT*2; i++)		sys_yield();}

static ssize_tpipewrite(struct Fd *fd, const void *vbuf, size_t n, off_t offset){	// Your code here.  See the lab text for a description of what 	// pipewrite needs to do.  Write a loop that transfers one byte	// at a time.  Unlike in read, it is not okay to write only some	// of the data.  If the pipe fills and you've only copied some of	// the data, wait for the pipe to empty and then keep copying.	// If the pipe is full and closed, return 0.	// Use _pipeisclosed to check whether the pipe is closed.	struct Pipe *p;	const uint8_t *buf;	int i;	USED(offset);	p = (struct Pipe *)fd2data(fd);	buf = vbuf;	for (i = 0; i < n; i++) {		while (p->p_wpos - p->p_rpos >= PIPEBUFSIZ) {			if (_pipeisclosed(fd, p))				return 0;			sys_yield();		}		p->p_buf[p->p_wpos % PIPEBUFSIZ] = buf[i];		p->p_wpos++;	}	return n;}

voidoutput(envid_t ns_envid){	binaryname = "ns_output";	int32_t reqType;	int perm;		envid_t envid_sender;	// LAB 6: Your code here:	// 	- read a packet from the network server	//	- send the packet to the device driver	while(1)	{		perm = 0;		//Read a packet from ns		reqType = ipc_recv(&envid_sender, &nsipcbuf, &perm);		//Check if ipc_recv has received correctly		if(!(perm & PTE_P))		{			cprintf("Invalid request from network server[%08x]:no page",envid_sender);			continue; 		}		if(reqType != NSREQ_OUTPUT)		{			cprintf("Invalid request from network server[%08x]:not a NSREQ_OUTPUT message",envid_sender);			continue;		}		//Send packet to device driver.If packet send fails, give up CPU		while(sys_send_packet(nsipcbuf.pkt.jp_data, nsipcbuf.pkt.jp_len) < 0)			sys_yield();	}}

voidstart(void){	int i;	for (i = 0; i < RUNCOUNT; i++) {		// Write characters to the console, yielding after each one.		//*cursorpos++ = PRINTCHAR;		// Atomic syscall version		#ifdef __EXERCISE_6__		sys_print(PRINTCHAR);		#endif		// Atomic lock version		#ifdef __EXERCISE_8__		while (atomic_swap(&lock, 1) != 0)			continue;		*cursorpos++ = PRINTCHAR;		atomic_swap(&lock, 0);		#endif		sys_yield();	}	/*// Yield forever.	while (1)		sys_yield();*/	sys_exit(0);}

voidstart(void){	int i;		sys_set_priority(__PRIORITY__);	sys_set_share(__SHARE__);	sys_set_lottery_tickets(__LOTTERY_TICKETS__);	for (i = 0; i < RUNCOUNT; i++) {		// Write characters to the console, yielding after each one.		#ifdef __PRINT_METHOD_LOCK__		while(atomic_swap(&lock, 1) != 0) 			continue;		*cursorpos++ = PRINTCHAR;		atomic_swap(&lock, 0);				#else				sys_atomic_print(PRINTCHAR);		#endif		sys_yield();	}	// Yield forever.	//while (1)	//	sys_yield();	sys_exit(0);}

voidumain(int argc, char **argv){	int i, r;	// Spin for a bit to let the console quiet	for (i = 0; i < 10; ++i)		sys_yield();	close(0);	if ((r = opencons()) < 0)		panic("opencons: %e", r);	if (r != 0)		panic("first opencons used fd %d", r);	if ((r = dup(0, 1)) < 0)		panic("dup: %e", r);	for(;;){		char *buf;		buf = readline("Type a line: ");		if (buf != NULL)			fprintf(1, "%s/n", buf);		else			fprintf(1, "(end of file received)/n");        cprintf("read a line finish/n");	}}

voidsleep(int sec){	unsigned end = sys_time_msec() + sec * 1000;	while (sys_time_msec() < end)		sys_yield();}

static ssize_tdevpipe_read(struct Fd *fd, void *vbuf, size_t n){	struct Pipe *p = (struct Pipe *) fd2data(fd);	uint8_t *buf = (uint8_t *) vbuf;	size_t i;	for (i = 0; i < n; i++) {		while (p->p_rpos == p->p_wpos) {			// The pipe is currently empty.			// If any data has been read, return it.			// Otherwise, check for EOF; if not EOF, yield			// and try again.			if (i > 0)				return i;			else if (_pipeisclosed(fd, p))				return 0;			else				sys_yield();		}		buf[i] = p->p_buf[p->p_rpos % PIPEBUFSIZ];		// The increment must come AFTER we write to the buffer,		// or the C compiler might update the pointer before writing		// to the buffer!  In fact, we need a memory barrier here---		// on some machines a memory barrier instruction.		asm volatile("" : : : "memory");		p->p_rpos++;	}	return i;}

// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'.// This function keeps trying until it succeeds.// It should panic() on any error other than -E_IPC_NOT_RECV.//// Hint://   Use sys_yield() to be CPU-friendly.//   If 'pg' is null, pass sys_ipc_recv a value that it will understand//   as meaning "no page".  (Zero is not the right value.)voidipc_send(envid_t to_env, uint32_t val, void *pg, int perm){	// LAB 4: Your code here.    //panic("ipc_send not implemented");    /* lj */    int ret = 0;    void *addr = NULL;    addr = pg ? pg : (void *)-1;    //cprintf("%x->%x [%d]/n", thisenv->env_id, to_env, val);        while (1) {        if(-E_IPC_NOT_RECV == ret) {            sys_yield();        }        ret = sys_ipc_try_send(to_env, val, addr, perm);        if(0 == ret) {            break;        }        else if(-E_IPC_NOT_RECV == ret) {            //cprintf("%x continue/n", thisenv->env_id);            continue;        }        else if(ret < 0) {            panic("ipc_send error:%e", ret);        }    }}

// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'.// This function keeps trying until it succeeds.// It should panic() on any error other than -E_IPC_NOT_RECV.//// Hint://   Use sys_yield() to be CPU-friendly.//   If 'pg' is null, pass sys_ipc_recv a value that it will understand//   as meaning "no page".  (Zero is not the right value.)voidipc_send(envid_t to_env, uint32_t val, void *pg, int perm){	int r;	if (pg == NULL)		pg = (void *)UTOP;	do {		int r = sys_ipc_try_send(to_env, val, pg, perm);		switch (r) {		case 0:		case 1:			return;		case -E_IPC_NOT_RECV:			sys_yield();			continue;		default:			panic("sys_ipc_try_send(%08x, %u, %08x, %d) failed: %e/n",				to_env, val, pg, perm, r);		}	} while (1);}

voidstart(void){	int i;	for (i = 0; i < RUNCOUNT; i++) {		#ifndef __EXERCISE_8__		/* EXERCISE 6: use a system call to print characters *****************/		sys_print(PRINTCHAR);		#endif		#ifdef __EXERCISE_8__		/* EXERCISE 8: use a lock to prevent race conditions *****************/		// spinlock until we obtain write lock		while (atomic_swap(&spinlock, 1) != 0)			continue;		// write		*cursorpos++ = PRINTCHAR;		// release write lock		atomic_swap(&spinlock, 0);		#endif		sys_yield();	}	// Yield forever.	while (1)		sys_exit(0);}

void vcore_entry(void){	uint32_t vcoreid = vcore_id();	if (vcoreid) {		mcs_barrier_wait(&b, vcoreid);		udelay(5000000);		if (vcoreid == 1)			printf("Proc %d's vcores are yielding/n", getpid());		sys_yield(0);	} else {		/* trip the barrier here, all future times are in the loop */		mcs_barrier_wait(&b, vcoreid);		while (1) {			udelay(15000000);			printf("Proc %d requesting its cores again/n", getpid());			begin = read_tsc();			sys_resource_req(RES_CORES, max_vcores(), 1, REQ_SOFT);			mcs_barrier_wait(&b, vcoreid);			end = read_tsc();			printf("Took %llu usec (%llu nsec) to get my yielded cores back./n",			       udiff(begin, end), ndiff(begin, end));			printf("[T]:010:%llu:%llu/n",			       udiff(begin, end), ndiff(begin, end));		}	}	printf("We're screwed!/n");	exit(-1);}

void vcore_entry(void){	uint32_t vcoreid = vcore_id();/* begin: stuff userspace needs to do to handle notifications */	struct vcore *vc = &__procinfo.vcoremap[vcoreid];	struct preempt_data *vcpd;	vcpd = &__procdata.vcore_preempt_data[vcoreid];		/* Lets try to restart vcore0's context.  Note this doesn't do anything to	 * set the appropriate TLS.  On x86, this will involve changing the LDT	 * entry for this vcore to point to the TCB of the new user-thread. */	if (vcoreid == 0) {		handle_events(vcoreid);		set_tls_desc(core0_tls, 0);		assert(__vcoreid == 0); /* in case anyone uses this */		/* Load silly state (Floating point) too */		pop_user_ctx(&vcpd->uthread_ctx, vcoreid);		panic("should never see me!");	}	/* end: stuff userspace needs to do to handle notifications */	/* all other vcores are down here */	core1_up = TRUE;	while (core1_up)		cpu_relax();	printf("Proc %d's vcore %d is yielding/n", getpid(), vcoreid);	sys_yield(0);	while(1);}

// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'.// This function keeps trying until it succeeds.// It should panic() on any error other than -E_IPC_NOT_RECV.//// Hint://   Use sys_yield() to be CPU-friendly.//   If 'pg' is null, pass sys_ipc_recv a value that it will understand//   as meaning "no page".  (Zero is not the right value.)voidipc_send(envid_t to_env, uint32_t val, void *pg, int perm){	// LAB 4: Your code here.	//panic("ipc_send not implemented");	int result;	if(pg == NULL)	{		result=sys_ipc_try_send(to_env, val, (void *)UTOP, perm);	}	else	{		result=sys_ipc_try_send(to_env, val, pg, perm);	}		while(result < 0)	{		if(result != -E_IPC_NOT_RECV)		{			panic ("ipc send error!");		}				sys_yield ();		if(pg == NULL)		{			result=sys_ipc_try_send(to_env, val, (void *)UTOP, perm);		}		else		{			result=sys_ipc_try_send(to_env, val, pg, perm);		}	}}