Skip to content

R
rt-thread

lfmiao0 / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread

体验新版 GitCode，发现更多精彩内容 >>

提交 ff658411 编写于 作者: D dzzxzz@gmail.com
浏览文件
操作

fixed coding style in src/scheduler.c 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2526 bbd45198-f89e-11dd-88c7-29a3b14d5316
上级 dec45642
隐藏空白更改
内联 并排
Showing with 206 addition and 195 deletion
src/scheduler.c
浏览文件 @ ff658411
...@@ -12,15 +12,15 @@ ...@@ -12,15 +12,15 @@
* 2006-03-17 Bernard the first version * 2006-03-17 Bernard the first version
* 2006-04-28 Bernard fix the scheduler algorthm * 2006-04-28 Bernard fix the scheduler algorthm
* 2006-04-30 Bernard add SCHEDULER_DEBUG * 2006-04-30 Bernard add SCHEDULER_DEBUG
* 2006-05-27 Bernard fix the scheduler algorthm for same priority thread * 2006-05-27 Bernard fix the scheduler algorthm for same priority
* schedule * thread schedule
* 2006-06-04 Bernard rewrite the scheduler algorithm * 2006-06-04 Bernard rewrite the scheduler algorithm
* 2006-08-03 Bernard add hook support * 2006-08-03 Bernard add hook support
* 2006-09-05 Bernard add 32 priority level support * 2006-09-05 Bernard add 32 priority level support
* 2006-09-24 Bernard add rt_system_scheduler_start function * 2006-09-24 Bernard add rt_system_scheduler_start function
* 2009-09-16 Bernard fix _rt_scheduler_stack_check * 2009-09-16 Bernard fix _rt_scheduler_stack_check
* 2010-04-11 yi.qiu add module feature * 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 * issue found by kuronca
* 2010-12-13 Bernard add defunct list initialization even if not use heap. * 2010-12-13 Bernard add defunct list initialization even if not use heap.
* 2011-05-10 Bernard clean scheduler debug log. * 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); ...@@ -83,9 +83,10 @@ static void (*rt_scheduler_hook)(struct rt_thread *from, struct rt_thread *to);
* *
* @param hook the hook function * @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 ...@@ -94,28 +95,29 @@ void rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread
#ifdef RT_USING_OVERFLOW_CHECK #ifdef RT_USING_OVERFLOW_CHECK
static void _rt_scheduler_stack_check(struct rt_thread *thread) 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 || if ((rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr ||
(rt_uint32_t)thread->sp > (rt_uint32_t)thread->sp >
(rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size) (rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size)
{ {
rt_uint32_t level; rt_uint32_t level;
rt_kprintf("thread:%s stack overflow\n", thread->name); rt_kprintf("thread:%s stack overflow\n", thread->name);
#ifdef RT_USING_FINSH #ifdef RT_USING_FINSH
{ {
extern long list_thread(void); extern long list_thread(void);
list_thread(); list_thread();
} }
#endif #endif
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
while (level); while (level);
} }
else if ((rt_uint32_t)thread->sp <= ((rt_uint32_t)thread->stack_addr + 32)) 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("warning: %s stack is close to end of stack address.\n",
} thread->name);
}
} }
#endif #endif
...@@ -125,31 +127,31 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread) ...@@ -125,31 +127,31 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread)
*/ */
void rt_system_scheduler_init(void) 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)); RT_THREAD_PRIORITY_MAX));
for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
{ {
rt_list_init(&rt_thread_priority_table[offset]); rt_list_init(&rt_thread_priority_table[offset]);
} }
rt_current_priority = RT_THREAD_PRIORITY_MAX - 1; rt_current_priority = RT_THREAD_PRIORITY_MAX - 1;
rt_current_thread = RT_NULL; rt_current_thread = RT_NULL;
/* initialize ready priority group */ /* initialize ready priority group */
rt_thread_ready_priority_group = 0; rt_thread_ready_priority_group = 0;
#if RT_THREAD_PRIORITY_MAX > 32 #if RT_THREAD_PRIORITY_MAX > 32
/* initialize ready table */ /* initialize ready table */
rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table)); rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table));
#endif #endif
/* initialize thread defunct */ /* initialize thread defunct */
rt_list_init(&rt_thread_defunct); rt_list_init(&rt_thread_defunct);
} }
/** /**
...@@ -159,48 +161,50 @@ void rt_system_scheduler_init(void) ...@@ -159,48 +161,50 @@ void rt_system_scheduler_init(void)
*/ */
void rt_system_scheduler_start(void) void rt_system_scheduler_start(void)
{ {
register struct rt_thread *to_thread; register struct rt_thread *to_thread;
register rt_ubase_t highest_ready_priority; register rt_ubase_t highest_ready_priority;
#if RT_THREAD_PRIORITY_MAX == 8 #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 #else
register rt_ubase_t number; register rt_ubase_t number;
/* find out the highest priority task */ /* find out the highest priority task */
if (rt_thread_ready_priority_group & 0xff) if (rt_thread_ready_priority_group & 0xff)
{ {
number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff]; number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff];
} }
else if (rt_thread_ready_priority_group & 0xff00) else if (rt_thread_ready_priority_group & 0xff00)
{ {
number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8; number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8;
} }
else if (rt_thread_ready_priority_group & 0xff0000) else if (rt_thread_ready_priority_group & 0xff0000)
{ {
number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16; number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16;
} }
else else
{ {
number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24; number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24;
} }
#if RT_THREAD_PRIORITY_MAX > 32 #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 #else
highest_ready_priority = number; highest_ready_priority = number;
#endif #endif
#endif #endif
/* get switch to thread */ /* get switch to thread */
to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
struct rt_thread, tlist); struct rt_thread,
tlist);
rt_current_thread = to_thread; rt_current_thread = to_thread;
/* switch to new thread */ /* switch to new thread */
rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp); 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) ...@@ -215,85 +219,89 @@ void rt_system_scheduler_start(void)
*/ */
void rt_schedule(void) void rt_schedule(void)
{ {
rt_base_t level; rt_base_t level;
struct rt_thread *to_thread; struct rt_thread *to_thread;
struct rt_thread *from_thread; struct rt_thread *from_thread;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
/* check the scheduler is enabled or not */ /* check the scheduler is enabled or not */
if (rt_scheduler_lock_nest == 0) if (rt_scheduler_lock_nest == 0)
{ {
register rt_ubase_t highest_ready_priority; register rt_ubase_t highest_ready_priority;
#if RT_THREAD_PRIORITY_MAX == 8 #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 #else
register rt_ubase_t number; register rt_ubase_t number;
/* find out the highest priority task */ /* find out the highest priority task */
if (rt_thread_ready_priority_group & 0xff) if (rt_thread_ready_priority_group & 0xff)
{ {
number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff]; number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff];
} }
else if (rt_thread_ready_priority_group & 0xff00) else if (rt_thread_ready_priority_group & 0xff00)
{ {
number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8; number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8;
} }
else if (rt_thread_ready_priority_group & 0xff0000) else if (rt_thread_ready_priority_group & 0xff0000)
{ {
number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16; number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16;
} }
else else
{ {
number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24; number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24;
} }
#if RT_THREAD_PRIORITY_MAX > 32 #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 #else
highest_ready_priority = number; highest_ready_priority = number;
#endif #endif
#endif #endif
/* get switch to thread */ /* get switch to thread */
to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
struct rt_thread, tlist); struct rt_thread,
tlist);
/* if the destination thread is not the same as current thread */
if (to_thread != rt_current_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_priority = highest_ready_priority;
rt_current_thread = to_thread; 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", ("[%d]switch to priority#%d thread:%s\n",
rt_interrupt_nest, rt_interrupt_nest,
highest_ready_priority, highest_ready_priority,
to_thread->name)); to_thread->name));
#ifdef RT_USING_OVERFLOW_CHECK #ifdef RT_USING_OVERFLOW_CHECK
_rt_scheduler_stack_check(to_thread); _rt_scheduler_stack_check(to_thread);
#endif #endif
if (rt_interrupt_nest == 0) if (rt_interrupt_nest == 0)
{ {
rt_hw_context_switch((rt_uint32_t)&from_thread->sp, (rt_uint32_t)&to_thread->sp); rt_hw_context_switch((rt_uint32_t)&from_thread->sp,
} (rt_uint32_t)&to_thread->sp);
else }
{ else
RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n")); {
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) ...@@ -305,25 +313,26 @@ void rt_schedule(void)
*/ */
void rt_schedule_insert_thread(struct rt_thread *thread) 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 */ /* disable interrupt */
temp = rt_hw_interrupt_disable(); temp = rt_hw_interrupt_disable();
/* change stat */ /* change stat */
thread->stat = RT_THREAD_READY; thread->stat = RT_THREAD_READY;
/* insert thread to ready list */ /* insert thread to ready list */
rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), &(thread->tlist)); 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 #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)); thread->name, thread->current_priority));
#else #else
RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
("insert thread[%s], the priority: %d 0x%x %d\n", ("insert thread[%s], the priority: %d 0x%x %d\n",
thread->name, thread->name,
thread->number, thread->number,
...@@ -332,12 +341,12 @@ void rt_schedule_insert_thread(struct rt_thread *thread) ...@@ -332,12 +341,12 @@ void rt_schedule_insert_thread(struct rt_thread *thread)
#endif #endif
#if RT_THREAD_PRIORITY_MAX > 32 #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 #endif
rt_thread_ready_priority_group |= thread->number_mask; rt_thread_ready_priority_group |= thread->number_mask;
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(temp); rt_hw_interrupt_enable(temp);
} }
/* /*
...@@ -349,18 +358,18 @@ void rt_schedule_insert_thread(struct rt_thread *thread) ...@@ -349,18 +358,18 @@ void rt_schedule_insert_thread(struct rt_thread *thread)
*/ */
void rt_schedule_remove_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 */ /* disable interrupt */
temp = rt_hw_interrupt_disable(); temp = rt_hw_interrupt_disable();
#if RT_THREAD_PRIORITY_MAX <= 32 #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)); thread->name, thread->current_priority));
#else #else
RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
("remove thread[%s], the priority: %d 0x%x %d\n", ("remove thread[%s], the priority: %d 0x%x %d\n",
thread->name, thread->name,
thread->number, thread->number,
...@@ -368,23 +377,23 @@ void rt_schedule_remove_thread(struct rt_thread *thread) ...@@ -368,23 +377,23 @@ void rt_schedule_remove_thread(struct rt_thread *thread)
thread->high_mask)); thread->high_mask));
#endif #endif
/* remove thread from ready list */ /* remove thread from ready list */
rt_list_remove(&(thread->tlist)); rt_list_remove(&(thread->tlist));
if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority]))) if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority])))
{ {
#if RT_THREAD_PRIORITY_MAX > 32 #if RT_THREAD_PRIORITY_MAX > 32
rt_thread_ready_table[thread->number] &= ~thread->high_mask; rt_thread_ready_table[thread->number] &= ~thread->high_mask;
if (rt_thread_ready_table[thread->number] == 0) if (rt_thread_ready_table[thread->number] == 0)
{ {
rt_thread_ready_priority_group &= ~thread->number_mask; rt_thread_ready_priority_group &= ~thread->number_mask;
} }
#else #else
rt_thread_ready_priority_group &= ~thread->number_mask; rt_thread_ready_priority_group &= ~thread->number_mask;
#endif #endif
} }
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(temp); rt_hw_interrupt_enable(temp);
} }
/** /**
...@@ -392,17 +401,19 @@ void rt_schedule_remove_thread(struct rt_thread *thread) ...@@ -392,17 +401,19 @@ void rt_schedule_remove_thread(struct rt_thread *thread)
*/ */
void rt_enter_critical(void) void rt_enter_critical(void)
{ {
register rt_base_t level; register rt_base_t level;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
/* the maximal number of nest is RT_UINT16_MAX, which is big /*
* enough and does not check here */ * the maximal number of nest is RT_UINT16_MAX, which is big
rt_scheduler_lock_nest ++; * enough and does not check here
*/
rt_scheduler_lock_nest ++;
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
/** /**
...@@ -410,26 +421,26 @@ void rt_enter_critical(void) ...@@ -410,26 +421,26 @@ void rt_enter_critical(void)
*/ */
void rt_exit_critical(void) void rt_exit_critical(void)
{ {
register rt_base_t level; register rt_base_t level;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
rt_scheduler_lock_nest --; rt_scheduler_lock_nest --;
if (rt_scheduler_lock_nest <= 0) if (rt_scheduler_lock_nest <= 0)
{ {
rt_scheduler_lock_nest = 0; rt_scheduler_lock_nest = 0;
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
rt_schedule(); rt_schedule();
} }
else else
{ {
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
} }
/*@}*/ /*@}*/
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或