diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/scheduler.c | 379 |
1 files changed, 195 insertions, 184 deletions
diff --git a/src/scheduler.c b/src/scheduler.c index 512d4ecfea..dc66380e45 100644 --- a/src/scheduler.c +++ b/src/scheduler.c @@ -12,15 +12,15 @@ * 2006-03-17 Bernard the first version * 2006-04-28 Bernard fix the scheduler algorthm * 2006-04-30 Bernard add SCHEDULER_DEBUG - * 2006-05-27 Bernard fix the scheduler algorthm for same priority thread - * schedule + * 2006-05-27 Bernard fix the scheduler algorthm for same priority + * thread schedule * 2006-06-04 Bernard rewrite the scheduler algorithm * 2006-08-03 Bernard add hook support * 2006-09-05 Bernard add 32 priority level support * 2006-09-24 Bernard add rt_system_scheduler_start function * 2009-09-16 Bernard fix _rt_scheduler_stack_check * 2010-04-11 yi.qiu add module feature - * 2010-07-13 Bernard fix the maximal number of rt_scheduler_lock_nest + * 2010-07-13 Bernard fix the maximal number of rt_scheduler_lock_nest * issue found by kuronca * 2010-12-13 Bernard add defunct list initialization even if not use heap. * 2011-05-10 Bernard clean scheduler debug log. @@ -83,9 +83,10 @@ static void (*rt_scheduler_hook)(struct rt_thread *from, struct rt_thread *to); * * @param hook the hook function */ -void rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread *to)) +void +rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread *to)) { - rt_scheduler_hook = hook; + rt_scheduler_hook = hook; } /*@}*/ @@ -94,28 +95,29 @@ void rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread #ifdef RT_USING_OVERFLOW_CHECK static void _rt_scheduler_stack_check(struct rt_thread *thread) { - RT_ASSERT(thread != RT_NULL); + RT_ASSERT(thread != RT_NULL); - if ((rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr || - (rt_uint32_t)thread->sp > - (rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size) - { - rt_uint32_t level; + if ((rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr || + (rt_uint32_t)thread->sp > + (rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size) + { + rt_uint32_t level; - rt_kprintf("thread:%s stack overflow\n", thread->name); - #ifdef RT_USING_FINSH - { - extern long list_thread(void); - list_thread(); - } - #endif - level = rt_hw_interrupt_disable(); - while (level); - } - else if ((rt_uint32_t)thread->sp <= ((rt_uint32_t)thread->stack_addr + 32)) - { - rt_kprintf("warning: %s stack is close to end of stack address.\n", thread->name); - } + rt_kprintf("thread:%s stack overflow\n", thread->name); + #ifdef RT_USING_FINSH + { + extern long list_thread(void); + list_thread(); + } + #endif + level = rt_hw_interrupt_disable(); + while (level); + } + else if ((rt_uint32_t)thread->sp <= ((rt_uint32_t)thread->stack_addr + 32)) + { + rt_kprintf("warning: %s stack is close to end of stack address.\n", + thread->name); + } } #endif @@ -125,31 +127,31 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread) */ void rt_system_scheduler_init(void) { - register rt_base_t offset; + register rt_base_t offset; - rt_scheduler_lock_nest = 0; + rt_scheduler_lock_nest = 0; - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n", + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n", RT_THREAD_PRIORITY_MAX)); - for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) - { - rt_list_init(&rt_thread_priority_table[offset]); - } + for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) + { + rt_list_init(&rt_thread_priority_table[offset]); + } - rt_current_priority = RT_THREAD_PRIORITY_MAX - 1; - rt_current_thread = RT_NULL; + rt_current_priority = RT_THREAD_PRIORITY_MAX - 1; + rt_current_thread = RT_NULL; - /* initialize ready priority group */ - rt_thread_ready_priority_group = 0; + /* initialize ready priority group */ + rt_thread_ready_priority_group = 0; #if RT_THREAD_PRIORITY_MAX > 32 - /* initialize ready table */ - rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table)); + /* initialize ready table */ + rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table)); #endif - /* initialize thread defunct */ - rt_list_init(&rt_thread_defunct); + /* initialize thread defunct */ + rt_list_init(&rt_thread_defunct); } /** @@ -159,48 +161,50 @@ void rt_system_scheduler_init(void) */ void rt_system_scheduler_start(void) { - register struct rt_thread *to_thread; - register rt_ubase_t highest_ready_priority; + register struct rt_thread *to_thread; + register rt_ubase_t highest_ready_priority; #if RT_THREAD_PRIORITY_MAX == 8 - highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group]; + highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group]; #else - register rt_ubase_t number; - /* find out the highest priority task */ - if (rt_thread_ready_priority_group & 0xff) - { - number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff]; - } - else if (rt_thread_ready_priority_group & 0xff00) - { - number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8; - } - else if (rt_thread_ready_priority_group & 0xff0000) - { - number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16; - } - else - { - number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24; - } + register rt_ubase_t number; + /* find out the highest priority task */ + if (rt_thread_ready_priority_group & 0xff) + { + number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff]; + } + else if (rt_thread_ready_priority_group & 0xff00) + { + number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8; + } + else if (rt_thread_ready_priority_group & 0xff0000) + { + number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16; + } + else + { + number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24; + } #if RT_THREAD_PRIORITY_MAX > 32 - highest_ready_priority = (number << 3) + rt_lowest_bitmap[rt_thread_ready_table[number]]; + highest_ready_priority = (number << 3) + + rt_lowest_bitmap[rt_thread_ready_table[number]]; #else - highest_ready_priority = number; + highest_ready_priority = number; #endif #endif - /* get switch to thread */ - to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, - struct rt_thread, tlist); + /* get switch to thread */ + to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, + struct rt_thread, + tlist); - rt_current_thread = to_thread; + rt_current_thread = to_thread; - /* switch to new thread */ - rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp); + /* switch to new thread */ + rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp); - /* never come back */ + /* never come back */ } /** @@ -215,85 +219,89 @@ void rt_system_scheduler_start(void) */ void rt_schedule(void) { - rt_base_t level; - struct rt_thread *to_thread; - struct rt_thread *from_thread; + rt_base_t level; + struct rt_thread *to_thread; + struct rt_thread *from_thread; - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - /* check the scheduler is enabled or not */ - if (rt_scheduler_lock_nest == 0) - { - register rt_ubase_t highest_ready_priority; + /* check the scheduler is enabled or not */ + if (rt_scheduler_lock_nest == 0) + { + register rt_ubase_t highest_ready_priority; #if RT_THREAD_PRIORITY_MAX == 8 - highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group]; + highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group]; #else - register rt_ubase_t number; - /* find out the highest priority task */ - if (rt_thread_ready_priority_group & 0xff) - { - number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff]; - } - else if (rt_thread_ready_priority_group & 0xff00) - { - number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8; - } - else if (rt_thread_ready_priority_group & 0xff0000) - { - number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16; - } - else - { - number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24; - } + register rt_ubase_t number; + /* find out the highest priority task */ + if (rt_thread_ready_priority_group & 0xff) + { + number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff]; + } + else if (rt_thread_ready_priority_group & 0xff00) + { + number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8; + } + else if (rt_thread_ready_priority_group & 0xff0000) + { + number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16; + } + else + { + number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24; + } #if RT_THREAD_PRIORITY_MAX > 32 - highest_ready_priority = (number << 3) + rt_lowest_bitmap[rt_thread_ready_table[number]]; + highest_ready_priority = (number << 3) + + rt_lowest_bitmap[rt_thread_ready_table[number]]; #else - highest_ready_priority = number; + highest_ready_priority = number; #endif #endif - /* get switch to thread */ - to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, - struct rt_thread, tlist); + /* get switch to thread */ + to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, + struct rt_thread, + tlist); - /* if the destination thread is not the same as current thread */ - if (to_thread != rt_current_thread) - { - rt_current_priority = highest_ready_priority; - from_thread = rt_current_thread; - rt_current_thread = to_thread; + /* if the destination thread is not the same as current thread */ + if (to_thread != rt_current_thread) + { + rt_current_priority = highest_ready_priority; + from_thread = rt_current_thread; + rt_current_thread = to_thread; - RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread)); + RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread)); - /* switch to new thread */ - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, + /* switch to new thread */ + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("[%d]switch to priority#%d thread:%s\n", rt_interrupt_nest, highest_ready_priority, to_thread->name)); #ifdef RT_USING_OVERFLOW_CHECK - _rt_scheduler_stack_check(to_thread); + _rt_scheduler_stack_check(to_thread); #endif - if (rt_interrupt_nest == 0) - { - rt_hw_context_switch((rt_uint32_t)&from_thread->sp, (rt_uint32_t)&to_thread->sp); - } - else - { - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n")); + if (rt_interrupt_nest == 0) + { + rt_hw_context_switch((rt_uint32_t)&from_thread->sp, + (rt_uint32_t)&to_thread->sp); + } + else + { + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n")); - rt_hw_context_switch_interrupt((rt_uint32_t)&from_thread->sp, (rt_uint32_t)&to_thread->sp); - } - } - } + rt_hw_context_switch_interrupt((rt_uint32_t)&from_thread->sp, + (rt_uint32_t)&to_thread->sp); + } + } + } - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); } /* @@ -305,25 +313,26 @@ void rt_schedule(void) */ void rt_schedule_insert_thread(struct rt_thread *thread) { - register rt_base_t temp; + register rt_base_t temp; - RT_ASSERT(thread != RT_NULL); + RT_ASSERT(thread != RT_NULL); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - /* change stat */ - thread->stat = RT_THREAD_READY; + /* change stat */ + thread->stat = RT_THREAD_READY; - /* insert thread to ready list */ - rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), &(thread->tlist)); + /* insert thread to ready list */ + rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), + &(thread->tlist)); - /* set priority mask */ + /* set priority mask */ #if RT_THREAD_PRIORITY_MAX <= 32 - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%s], the priority: %d\n", + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%s], the priority: %d\n", thread->name, thread->current_priority)); #else - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%s], the priority: %d 0x%x %d\n", thread->name, thread->number, @@ -332,12 +341,12 @@ void rt_schedule_insert_thread(struct rt_thread *thread) #endif #if RT_THREAD_PRIORITY_MAX > 32 - rt_thread_ready_table[thread->number] |= thread->high_mask; + rt_thread_ready_table[thread->number] |= thread->high_mask; #endif - rt_thread_ready_priority_group |= thread->number_mask; + rt_thread_ready_priority_group |= thread->number_mask; - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); } /* @@ -349,18 +358,18 @@ void rt_schedule_insert_thread(struct rt_thread *thread) */ void rt_schedule_remove_thread(struct rt_thread *thread) { - register rt_base_t temp; + register rt_base_t temp; - RT_ASSERT(thread != RT_NULL); + RT_ASSERT(thread != RT_NULL); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); #if RT_THREAD_PRIORITY_MAX <= 32 - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%s], the priority: %d\n", + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%s], the priority: %d\n", thread->name, thread->current_priority)); #else - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%s], the priority: %d 0x%x %d\n", thread->name, thread->number, @@ -368,23 +377,23 @@ void rt_schedule_remove_thread(struct rt_thread *thread) thread->high_mask)); #endif - /* remove thread from ready list */ - rt_list_remove(&(thread->tlist)); - if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority]))) - { + /* remove thread from ready list */ + rt_list_remove(&(thread->tlist)); + if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority]))) + { #if RT_THREAD_PRIORITY_MAX > 32 - rt_thread_ready_table[thread->number] &= ~thread->high_mask; - if (rt_thread_ready_table[thread->number] == 0) - { - rt_thread_ready_priority_group &= ~thread->number_mask; - } + rt_thread_ready_table[thread->number] &= ~thread->high_mask; + if (rt_thread_ready_table[thread->number] == 0) + { + rt_thread_ready_priority_group &= ~thread->number_mask; + } #else - rt_thread_ready_priority_group &= ~thread->number_mask; + rt_thread_ready_priority_group &= ~thread->number_mask; #endif - } + } - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); } /** @@ -392,17 +401,19 @@ void rt_schedule_remove_thread(struct rt_thread *thread) */ void rt_enter_critical(void) { - register rt_base_t level; + register rt_base_t level; - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - /* the maximal number of nest is RT_UINT16_MAX, which is big - * enough and does not check here */ - rt_scheduler_lock_nest ++; + /* + * the maximal number of nest is RT_UINT16_MAX, which is big + * enough and does not check here + */ + rt_scheduler_lock_nest ++; - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); } /** @@ -410,26 +421,26 @@ void rt_enter_critical(void) */ void rt_exit_critical(void) { - register rt_base_t level; + register rt_base_t level; - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - rt_scheduler_lock_nest --; + rt_scheduler_lock_nest --; - if (rt_scheduler_lock_nest <= 0) - { - rt_scheduler_lock_nest = 0; - /* enable interrupt */ - rt_hw_interrupt_enable(level); + if (rt_scheduler_lock_nest <= 0) + { + rt_scheduler_lock_nest = 0; + /* enable interrupt */ + rt_hw_interrupt_enable(level); - rt_schedule(); - } - else - { - /* enable interrupt */ - rt_hw_interrupt_enable(level); - } + rt_schedule(); + } + else + { + /* enable interrupt */ + rt_hw_interrupt_enable(level); + } } /*@}*/ |