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

static void run_add(void){    char next = 0;    for (unsigned iteration = 0; iteration < ITERATIONS; ++iteration) {        mutex_lock(&mutex);        for (unsigned i = 0; i < BUF_SIZE; ++i) {            assert_avail(i);            assert_add_one(next, -1);            assert_avail(i + 1);            ++next;        }        /* Overwrite oldest element. It should be returned to us. */        assert_avail(BUF_SIZE);        assert_add_one(next, next - BUF_SIZE);        assert_avail(BUF_SIZE);        ++next;        thread_wakeup(pid_get);        mutex_unlock_and_sleep(&mutex);    }    thread_wakeup(pid_get);}

/* *      Routine:        lck_rw_done_gen */lck_rw_type_tlck_rw_done_gen(	lck_rw_t	*lck){	boolean_t	wakeup_readers = FALSE;	boolean_t	wakeup_writers = FALSE;	lck_rw_type_t	lck_rw_type;	boolean_t	istate;	istate = lck_interlock_lock(lck);	if (lck->lck_rw_shared_count != 0) {		lck_rw_type = LCK_RW_TYPE_SHARED;		lck->lck_rw_shared_count--;	}	else {			lck_rw_type = LCK_RW_TYPE_EXCLUSIVE;		if (lck->lck_rw_want_upgrade) 			lck->lck_rw_want_upgrade = FALSE;		else 			lck->lck_rw_want_write = FALSE;	}	/*	 *	There is no reason to wakeup a waiting thread	 *	if the read-count is non-zero.  Consider:	 *		we must be dropping a read lock	 *		threads are waiting only if one wants a write lock	 *		if there are still readers, they can't proceed	 */	if (lck->lck_rw_shared_count == 0) {		if (lck->lck_w_waiting) {			lck->lck_w_waiting = FALSE;			wakeup_writers = TRUE;		} 		if (!(lck->lck_rw_priv_excl && wakeup_writers == TRUE) && 				lck->lck_r_waiting) {			lck->lck_r_waiting = FALSE;			wakeup_readers = TRUE;		}	}	lck_interlock_unlock(lck, istate);	if (wakeup_readers) 		thread_wakeup(RW_LOCK_READER_EVENT(lck));	if (wakeup_writers) 		thread_wakeup(RW_LOCK_WRITER_EVENT(lck));#if CONFIG_DTRACE	LOCKSTAT_RECORD(LS_LCK_RW_DONE_RELEASE, lck, (lck_rw_type == LCK_RW_TYPE_EXCLUSIVE ? 1 : 0));#endif	return(lck_rw_type);}

void etx_clock(void) {    /*     * Manages the etx_beacon thread to wake up every full second +- jitter     */    /*     * The jittercorrection and jitter variables keep usecond values divided     * through 1000 to fit into uint8 variables.     *     * That is why they are multiplied by 1000 when used for hwtimer_wait.     */    uint8_t jittercorrection = ETX_DEF_JIT_CORRECT;    uint8_t jitter = (uint8_t) (rand() % ETX_JITTER_MOD);    while (true) {        thread_wakeup(etx_beacon_pid);        /*         * Vtimer is buggy, but I seem to have no hwtimers left, so using this         * for now.         */        vtimer_usleep(                ((ETX_INTERVAL - ETX_MAX_JITTER)*MS)+ jittercorrection*MS + jitter*MS - ETX_CLOCK_ADJUST);        //hwtimer_wait(        //        HWTIMER_TICKS(((ETX_INTERVAL - ETX_MAX_JITTER)*MS) + jittercorrection*MS + jitter*MS - ETX_CLOCK_ADJUST));        jittercorrection = (ETX_MAX_JITTER) - jitter;        jitter = (uint8_t) (rand() % ETX_JITTER_MOD);    }}

void test_ltc_tick(void *ptr){    int pid = (int) ptr;    hwtimer_tick_id = hwtimer_set(tick_ticks, test_ltc_tick, ptr);    thread_wakeup(pid);}

static voiddbgsh (void){	ulong rbx;	int b;	if (!config.vmm.dbgsh)		return;	spinlock_lock (&dbgsh_lock);	if (!i) {		tid = thread_new (dbgsh_thread, NULL, VMM_STACKSIZE);		i = true;	}	spinlock_unlock (&dbgsh_lock);	current->vmctl.read_general_reg (GENERAL_REG_RBX, &rbx);	b = (int)rbx;	if (b != -1) {		r = b;		s = -1;#ifndef FWDBG		spinlock_lock (&dbgsh_lock2);		if (stopped)			thread_wakeup (tid);		spinlock_unlock (&dbgsh_lock2);#endif	}	current->vmctl.write_general_reg (GENERAL_REG_RAX, (ulong)s);}

void lock_release(struct lock *lock) {    assert(lock != NULL);    int enabled = interrupts_set(0);    lock->lock_state = 0;    thread_wakeup(lock->queue, 1);    interrupts_set(enabled);}

voidcv_broadcast(struct cv *cv, struct lock *lock){	int spl;	// Check to make sure we have an actual lock	assert(lock != NULL);	// Check to make sure we have an actual cv	assert(cv != NULL);	spl = splhigh();		// Release the lock	lock_release(lock);	// Wake up all threads waiting on the lock	thread_wakeup(cv);		// Reacquire the lock	lock_acquire(lock);	// Return to user mode	splx(spl);}

void lock_done(	register lock_t	l){	simple_lock(&l->interlock);	if (l->read_count != 0)		l->read_count--;	else	if (l->recursion_depth != 0)		l->recursion_depth--;	else	if (l->want_upgrade)	 	l->want_upgrade = FALSE;	else	 	l->want_write = FALSE;	/*	 *	There is no reason to wakeup a waiting thread	 *	if the read-count is non-zero.  Consider:	 *		we must be dropping a read lock	 *		threads are waiting only if one wants a write lock	 *		if there are still readers, they can't proceed	 */	if (l->waiting && (l->read_count == 0)) {		l->waiting = FALSE;		thread_wakeup(l);	}	simple_unlock(&l->interlock);}

int main(void){    indicator = 0;    count = 0;    main_pid = thread_getpid();    kernel_pid_t second_pid = thread_create(stack,                  sizeof(stack),                  THREAD_PRIORITY_MAIN - 1,                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,                  second_thread,                  NULL,                  "second_thread");    while (1) {        mutex_lock(&mutex);        thread_wakeup(second_pid);        indicator++;        count++;        if (indicator > 1 || indicator < -1) {            printf("Error, threads did not sleep properly. [indicator: %d]/n", indicator);            return -1;        }        if ((count % 100000) == 0) {            printf("Still alive alternated [count: %dk] times./n", count / 1000);        }        mutex_unlock_and_sleep(&mutex);    }}

voidcv_signal(struct cv *cv, struct lock *lock){#if opt_A1    // validate parameter    assert (cv != NULL);    assert (lock != NULL);    // others    assert (lock_do_i_hold(lock) == 1);    // disable interrupts    int spl = splhigh();    if (q_empty(cv->sleeping_list)) goto done;   // signal must be called after wait!    // pick one thread and wake it up    thread_wakeup((struct thread*) q_remhead(cv->sleeping_list));    // enable interruptsdone:    splx(spl);#else    (void) cv;    (void) lock;#endif}

voidlock_release(struct lock *lock){#if OPT_A1    // validate parameter    assert (lock != NULL);    int spl;    // disable interrupts    spl = splhigh();    assert (lock_do_i_hold(lock) == 1); // make sure right lock locks the right thread    // release the lock    lock ->status = 0;    assert (lock->status==0); // check    lock->target = NULL;    thread_wakeup(lock);    // enable interrupts    splx(spl);#else    (void) lock;#endif}

static void *run_get(void *arg){    (void) arg;    char next = 0;    for (unsigned iteration = 0; iteration < ITERATIONS; ++iteration) {        ++next; /* the first element of a stride is always overwritten */        mutex_lock(&mutex);        for (unsigned i = BUF_SIZE; i > 0; --i) {            assert_avail(i);            assert_get_one(next);            assert_avail(i - 1);            ++next;        }        assert_avail(0);        assert_get_one(-1);        assert_avail(0);        thread_wakeup(pid_add);        mutex_unlock_and_sleep(&mutex);    }    return NULL;}

voidcv_signal(struct cv *cv, struct lock *lock){	//On a signal, this means the next thread in the queue can start!!		int spl;	//We must complete an unconditional wait once an unlock occurs and we can then take the lock. We will check the conditions now.	assert(cv != NULL);	assert(lock !=NULL);	assert (lock_do_i_hold(lock));		spl = splhigh(); //Disable All Interrupts		cv->count--; //Decrement count since the next thread can go.		//We will never know which thread is next, so we must create a temp thread pointer to be able to work with the next pointer in the queue.	struct thread *next_thread = q_remhead(cv->thread_queue); //removes the next head in the queue.    		thread_wakeup(next_thread); //Wake up this next thread!    	splx(spl); //Re-enable All Interrupts		(void)cv;    // suppress warning until code gets written	(void)lock;  // suppress warning until code gets written}

int main(void){    count = 0;    is_finished = 0;    expected_value = 1000ul * 1000ul;    pthread_cond_init(&cv, NULL);    kernel_pid_t pid = thread_create(stack,sizeof(stack), THREAD_PRIORITY_MAIN - 1,                                     THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,                                     second_thread, NULL, "second_thread");    while (1) {        mutex_lock(&mutex);        thread_wakeup(pid);        count++;        if ((count % 100000) == 0) {            printf("Still alive alternated [count: %ldk] times./n", count / 1000);        }        if (count == expected_value) {            puts("condition fulfilled.");            is_finished = 1;            mutex_unlock(&mutex);            return 0;        }        pthread_cond_wait(&cv, &mutex);        mutex_unlock(&mutex);    }}

static voidtcpip_init_done(void *arg){	uint32_t *done = arg;	*done = 1;	thread_wakeup(done);}

voidcv_broadcast(struct cv *cv, struct lock *lock){  int spl = splhigh();  thread_wakeup(cv);  splx(spl);}

voidprocessor_doshutdown(	processor_t	processor){	register int		cpu = processor->slot_num;	timer_switch(&kernel_timer[cpu]);	/*	 *	Ok, now exit this cpu.	 */	PMAP_DEACTIVATE_KERNEL(cpu);        cpu_data[cpu].active_thread = THREAD_NULL;	active_kloaded[cpu] = THR_ACT_NULL;	cpu_down(cpu);	thread_wakeup((event_t)processor);	halt_cpu();	panic("zombie processor");	/*	 *	The action thread returns to life after the call to	 *	switch_to_shutdown_context above, on some other cpu.	 */	/*NOTREACHED*/}

/*  * Interrupts disabled, lock held; returns the same way.  * Only called on thread calls whose storage we own.  Wakes up * anyone who might be waiting on this work item and frees it * if the client has so requested. */static voidthread_call_finish(thread_call_t call){	boolean_t dowake = FALSE;	call->tc_finish_count++;	call->tc_refs--;	if ((call->tc_flags & THREAD_CALL_WAIT) != 0) {		dowake = TRUE;		call->tc_flags &= ~THREAD_CALL_WAIT;		/* 		 * Dropping lock here because the sched call for the 		 * high-pri group can take the big lock from under		 * a thread lock.		 */		thread_call_unlock();		thread_wakeup((event_t)call);		thread_call_lock_spin();	}	if (call->tc_refs == 0) {		if (dowake) {			panic("Someone waiting on a thread call that is scheduled for free: %p/n", call->tc_call.func);		}		enable_ints_and_unlock();		zfree(thread_call_zone, call);		(void)disable_ints_and_lock();	}}

voidhimem_revert(	hil_t		hil){	hil_t		next;	boolean_t	wakeup = FALSE;	spl_t		ipl;	while(hil) {		if (hil->length) {			bcopy((char *)phystokv(hil->low_page + hil->offset),				(char *)phystokv(hil->high_addr),			      hil->length);		}		hil->high_addr = 0;		hil->length = 0;		hil->offset = 0;		next = hil->next;		ipl = splhi();		simple_lock(&hil_lock);		if (!(hil->next = hil_head))			wakeup = TRUE;		hil_head = hil;		simple_unlock(&hil_lock);		splx(ipl);		hil = next;	}	if (wakeup)		thread_wakeup((event_t)&hil_head);}

int main(void){    indicator = 0;    count = 0;    mutex_init(&mutex);    thread_create(stack,                  KERNEL_CONF_STACKSIZE_MAIN,                  PRIORITY_MAIN - 1,                  CREATE_WOUT_YIELD | CREATE_STACKTEST,                  second_thread,                  "second_thread");    while (1) {        mutex_lock(&mutex);        thread_wakeup(2);        indicator++;        count++;        if (indicator > 1 || indicator < -1) {            //printf("Error, threads did not sleep properly. [indicator: %d]/n", indicator);            return -1;        }        if ((count % 100000) == 0) {            //printf("Still alive alternated [count: %dk] times./n", count / 1000);        }        mutex_unlock_and_sleep(&mutex);    }}

voidsvm_send_change_completed(	xmm_obj_t	mobj,	change_t	change){	kern_return_t kr;	assert(xmm_obj_lock_held(mobj));	if (change->reply_data.type == XMM_TEMPORARY_REPLY) {		/*		 * This request was generated by		 * svm_disable_active_temporary.		 * If the object is still alive,		 * mark the object as temporary_disabled.		 */		assert(! MOBJ->temporary_disabled);		assert(MOBJ->disable_in_progress);		if (MOBJ->state == MOBJ_STATE_READY) {			MOBJ->temporary_disabled = TRUE;		}		MOBJ->disable_in_progress = FALSE;		thread_wakeup(svm_disable_event(mobj));	} else {		/*		 * This is a real request.		 */		xmm_obj_unlock(mobj);		kr = M_CHANGE_COMPLETED(mobj, change->may_cache,					change->copy_strategy,					&change->reply_data);		assert(kr == KERN_SUCCESS);		xmm_obj_lock(mobj);	}}

void thread_swapin(thread_t thread){	switch (thread->state & TH_SWAP_STATE) {	    case TH_SWAPPED:		/*		 *	Swapped out - queue for swapin thread.		 */		thread->state = (thread->state & ~TH_SWAP_STATE)				| TH_SW_COMING_IN;		swapper_lock();		enqueue_tail(&swapin_queue, &(thread->links));		swapper_unlock();		thread_wakeup((event_t) &swapin_queue);		break;	    case TH_SW_COMING_IN:		/*		 *	Already queued for swapin thread, or being		 *	swapped in.		 */		break;	    default:		/*		 *	Already swapped in.		 */		panic("thread_swapin");	}}

int main(void){    uint32_t count = 0;    indicator = 0;    main_pid = thread_getpid();    kernel_pid_t second_pid = thread_create(stack,                  sizeof(stack),                  THREAD_PRIORITY_MAIN - 1,                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,                  second_thread,                  NULL,                  "second_thread");    while (1) {        mutex_lock(&mutex);        thread_wakeup(second_pid);        indicator++;        count++;        if ((indicator > 1) || (indicator < -1)) {            printf("[ERROR] threads did not sleep properly (%d)./n", indicator);            return 1;        }        if ((count % 100000) == 0) {            printf("[ALIVE] alternated %"PRIu32"k times./n", (count / 1000));        }        mutex_unlock_and_sleep(&mutex);    }}

voidtest_wakeup(int all){	Tid ret;	long ii;	static Tid child[NTHREADS];	unintr_printf("starting wakeup test/n");	done = 0;	queue = wait_queue_create();	assert(queue);	/* initial thread sleep and wake up tests */	ret = thread_sleep(NULL);	assert(ret == THREAD_INVALID);	unintr_printf("initial thread returns from sleep(NULL)/n");	ret = thread_sleep(queue);	assert(ret == THREAD_NONE);	unintr_printf("initial thread returns from sleep(NONE)/n");	ret = thread_wakeup(NULL, 0);	assert(ret == 0);	ret = thread_wakeup(queue, 1);	assert(ret == 0);	/* create all threads */	for (ii = 0; ii < NTHREADS; ii++) {		child[ii] = thread_create((void (*)(void *))test_wakeup_thread,					  (void *)ii);		assert(thread_ret_ok(child[ii]));	}	while (__sync_fetch_and_add(&done, 0) < NTHREADS) {		/* spin for 5 ms */		spin(5000);		/* this requires that thread_wakeup is working correctly */		ret = thread_wakeup(queue, all);		assert(ret >= 0);		assert(all ? ret <= NTHREADS : ret <= 1);	}	wait_queue_destroy(queue);	unintr_printf("wakeup test done/n");}

void blockdev_notify_complete(struct blockdev_req *req, int rc){	bool iflag = int_begin_atomic();	req->state = BLOCKDEV_REQ_FINISHED;	req->rc = rc;	thread_wakeup(&req->waitqueue);	int_end_atomic(iflag);}

static void second_thread(void){    while (1) {        mutex_lock(&mutex);        thread_wakeup(1);        indicator--;        mutex_unlock_and_sleep(&mutex);    }}

/* *	thread_stack_enqueue: * *	Enqueue a thread for stack allocation. * *	Called at splsched. */voidthread_stack_enqueue(	thread_t		thread){	simple_lock(&thread_stack_lock);	enqueue_tail(&thread_stack_queue, (queue_entry_t)thread);	simple_unlock(&thread_stack_lock);	thread_wakeup((event_t)&thread_stack_queue);}

/* *      Routine:        lck_rw_lock_exclusive_to_shared */voidlck_rw_lock_exclusive_to_shared(	lck_rw_t	*lck){	boolean_t	wakeup_readers = FALSE;	boolean_t	wakeup_writers = FALSE;	boolean_t	istate;	KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_RW_LCK_EX_TO_SH_CODE) | DBG_FUNC_START,			     (int)lck, lck->lck_rw_want_write, lck->lck_rw_want_upgrade, 0, 0);	istate = lck_interlock_lock(lck);	lck->lck_rw_shared_count++;	if (lck->lck_rw_want_upgrade)		lck->lck_rw_want_upgrade = FALSE;	else	 	lck->lck_rw_want_write = FALSE;	if (lck->lck_w_waiting) {		lck->lck_w_waiting = FALSE;		wakeup_writers = TRUE;	} 	if (!(lck->lck_rw_priv_excl && wakeup_writers == TRUE) && 			lck->lck_r_waiting) {		lck->lck_r_waiting = FALSE;		wakeup_readers = TRUE;	}	lck_interlock_unlock(lck, istate);	if (wakeup_readers)		thread_wakeup(RW_LOCK_READER_EVENT(lck));	if (wakeup_writers)		thread_wakeup(RW_LOCK_WRITER_EVENT(lck));	KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_RW_LCK_EX_TO_SH_CODE) | DBG_FUNC_END,			     (int)lck, lck->lck_rw_want_write, lck->lck_rw_want_upgrade, lck->lck_rw_shared_count, 0);#if CONFIG_DTRACE	LOCKSTAT_RECORD(LS_LCK_RW_LOCK_EXCL_TO_SHARED_DOWNGRADE, lck, 0);#endif}

voidipc_target_wakeup(struct ipc_target *ipt){	ipt_lock(ipt);	if (ipt->ipt_waiting) {		thread_wakeup((int)&ipt->ipt_acts);		ipt->ipt_waiting = 0;	}	ipt_unlock(ipt);}