From 5e08d73490edc7d9cc702a8e9c38a19709b034ea Mon Sep 17 00:00:00 2001 From: patacongo Date: Thu, 12 Mar 2009 10:55:26 +0000 Subject: Finishes basic implementation git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1594 42af7a65-404d-4744-a932-0658087f49c3 --- nuttx/sched/sem_holder.c | 146 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 112 insertions(+), 34 deletions(-) (limited to 'nuttx/sched/sem_holder.c') diff --git a/nuttx/sched/sem_holder.c b/nuttx/sched/sem_holder.c index d8694c79d..376903d6a 100644 --- a/nuttx/sched/sem_holder.c +++ b/nuttx/sched/sem_holder.c @@ -240,6 +240,110 @@ static int sem_foreachholder(FAR sem_t *sem, holderhandler_t handler, FAR void * return ret; } +/**************************************************************************** + * Name: sem_boostholderprio + ****************************************************************************/ + +static int sem_boostholderprio(struct semholder_s *pholder, FAR sem_t *sem, FAR void *arg) +{ + FAR _TCB *htcb = (FAR _TCB *)pholder->holder; + FAR _TCB *rtcb = (FAR _TCB*)arg; +#if CONFIG_SEM_NNESTPRIO > 0 + int i; +#endif + + /* Make sure that the thread is still active. If it exited without releasing + * its counts, then that would be a bad thing. But we can take no real + * action because we don't know know that the program is doing. Perhaps its + * plan is to kill a thread, then destroy the semaphore. + */ + + if (!sched_verifytcb(htcb)) + { + sdbg("TCB 0x%08x is a stale handle, counts lost\n", htcb); + sem_freeholder(sem, pholder); + } + +#if CONFIG_SEM_NNESTPRIO > 0 + + /* If the priority of the thread that is waiting for a count is greater than + * the base priority of the thread holding a count, then we may need to + * adjust the holder's priority now or later to that priority. + */ + + else if (rtcb->sched_priority > htcb->base_priority) + { + /* If the new priority is greater than the current, possibly already + * boosted priority of the holder thread, then we will have to raise + * the holder's priority now. + */ + + if (rtcb->sched_priority > htcb->sched_priority) + { + /* If the current priority has already been boosted, then add the + * boost priority to the list of restoration priorities. When the + * higher priority thread gets its count, then we need to revert + * to this saved priority, not to the base priority. + */ + + if (htcb->sched_priority > htcb->base_priority) + { + /* Save the current, boosted priority */ + + if (htcb->npend_reprio < CONFIG_SEM_NNESTPRIO) + { + htcb->pend_reprios[htcb->npend_reprio] = htcb->sched_priority; + htcb->npend_reprio++; + } + else + { + sdgb("CONFIG_SEM_NNESTPRIO exceeded\n"); + } + } + + /* Raise the priority of the holder of the semaphore. This + * cannot cause a context switch because we have preemption + * disabled. The task will be marked "pending" and the switch + * will occur during up_block_task() processing. + */ + + (void)sched_setpriority(htcb, rtcb->sched_priority); + } + else + { + /* The new priority is above the base priority of the holder, + * but not as high as its current working priority. Just put it + * in the list of pending restoration priorities so that when the + * higher priority thread gets its count, we can revert to this + * saved priority and not to the base priority. + */ + + htcb->pend_reprios[htcb->npend_reprio] = rtcb->sched_priority; + htcb->npend_reprio++; + } + } + +#else + /* If the priority of the thread that is waiting for a count is less than + * of equal to the priority of the thread holding a count, then do nothing + * because the thread is already running at a sufficient priority. + */ + + else if (rtcb->sched_priority > htcb->sched_priority) + { + /* Raise the priority of the holder of the semaphore. This + * cannot cause a context switch because we have preemption + * disabled. The task will be marked "pending" and the switch + * will occur during up_block_task() processing. + */ + + (void)sched_setpriority(htcb, rtcb->sched_priority); + } +#endif + + return 0; +} + /**************************************************************************** * Name: sem_verifyholder ****************************************************************************/ @@ -502,41 +606,13 @@ void sem_addholder(FAR sem_t *sem) void sem_boostpriority(FAR sem_t *sem) { FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; - FAR _TCB *htcb; - struct semholder_s *pholder; - /* Traverse the list of holders */ - - pholder = &sem->hlist; -#if CONFIG_SEM_PREALLOCHOLDERS > 0 - for (; pholder; pholder = pholder->flink) -#endif - { - /* As an artifact, there will be holders that have no counts. This - * because they have posted the semaphore and there count was decrement - * by sem_releaseholder(), but they are still being retained in the - * list to be harvested by sem_restorebaseprio. - */ - - if (pholder->counts > 0) - { - htcb = pholder->holder; -#if CONFIG_SEM_NNESTPRIO > 0 -# error "Missing implementation" -#else - if (htcb && htcb->sched_priority < rtcb->sched_priority) - { - /* Raise the priority of the holder of the semaphore. This - * cannot cause a context switch because we have preemption - * disabled. The task will be marked "pending" and the switch - * will occur during up_block_task() processing. - */ + /* Boost the priority of every thread holding counts on this semaphore + * that are lower in priority than the new thread that is waiting for a + * count. + */ - (void)sched_setpriority(htcb, rtcb->sched_priority); -#endif - } - } - } + (void)sem_foreachholder(sem, sem_boostholderprio, rtcb); } /**************************************************************************** @@ -566,7 +642,9 @@ void sem_releaseholder(FAR sem_t *sem) pholder = sem_findholder(sem, rtcb); if (pholder && pholder->counts > 0) { - /* Decrement the counts on this holder */ + /* Decrement the counts on this holder -- the holder will be freed + * later in sem_restorebaseprio. + */ pholder->counts--; } -- cgit v1.2.3