fixed coding style in src/scheduler.c
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2526 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
dzzxzz@gmail.com
parent
dec45642fb
commit
ff65841125
379
src/scheduler.c
379
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);
|
||||
}
|
||||
}
|
||||
|
||||
/*@}*/
|
||||
|
|
|
|||
Loading…
Reference in New Issue