diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Kconfig | 16 | ||||
| -rw-r--r-- | src/clock.c | 9 | ||||
| -rw-r--r-- | src/components.c | 8 | ||||
| -rw-r--r-- | src/cpu.c | 91 | ||||
| -rw-r--r-- | src/idle.c | 75 | ||||
| -rw-r--r-- | src/irq.c | 13 | ||||
| -rw-r--r-- | src/scheduler.c | 674 | ||||
| -rw-r--r-- | src/signal.c | 12 | ||||
| -rw-r--r-- | src/thread.c | 92 |
9 files changed, 816 insertions, 174 deletions
diff --git a/src/Kconfig b/src/Kconfig index 78a3bf6d67..bf0bd5a3fd 100644 --- a/src/Kconfig +++ b/src/Kconfig @@ -8,6 +8,22 @@ config RT_NAME_MAX Each kernel object, such as thread, timer, semaphore etc, has a name, the RT_NAME_MAX is the maximal size of this object name. +config RT_USING_SMP + bool "Enable SMP(Symmetric multiprocessing)" + default n + help + This option should be selected by machines which have an SMP- + capable CPU. + The only effect of this option is to make the SMP-related + options available to the user for configuration. + +config RT_CPUS_NR + int "Number of CPUs" + default 2 + depends on RT_USING_SMP + help + Number of CPUs in the system + config RT_ALIGN_SIZE int "Alignment size for CPU architecture data access" default 4 diff --git a/src/clock.c b/src/clock.c index 651465e0a8..1bedb4e06a 100644 --- a/src/clock.c +++ b/src/clock.c @@ -12,12 +12,17 @@ * 2010-05-20 Bernard fix the tick exceeds the maximum limits * 2010-07-13 Bernard fix rt_tick_from_millisecond issue found by kuronca * 2011-06-26 Bernard add rt_tick_set function. + * 2018-11-22 Jesven add per cpu tick */ #include <rthw.h> #include <rtthread.h> +#ifdef RT_USING_SMP +#define rt_tick rt_cpu_index(0)->tick +#else static rt_tick_t rt_tick = 0; +#endif extern void rt_timer_check(void); @@ -71,7 +76,11 @@ void rt_tick_increase(void) struct rt_thread *thread; /* increase the global tick */ +#ifdef RT_USING_SMP + rt_cpu_self()->tick ++; +#else ++ rt_tick; +#endif /* check time slice */ thread = rt_thread_self(); diff --git a/src/components.c b/src/components.c index 68e5799f59..d77ef8300f 100644 --- a/src/components.c +++ b/src/components.c @@ -14,6 +14,7 @@ * 2015-05-04 Bernard Rename it to components.c because compiling issue * in some IDEs. * 2015-07-29 Arda.Fu Add support to use RT_USING_USER_MAIN with IAR + * 2018-11-22 Jesven Add secondary cpu boot up */ #include <rthw.h> @@ -180,6 +181,9 @@ void main_thread_entry(void *parameter) /* RT-Thread components initialization */ rt_components_init(); +#ifdef RT_USING_SMP + rt_hw_secondary_cpu_up(); +#endif /* invoke system main function */ #if defined(__CC_ARM) || defined(__CLANG_ARM) $Super$$main(); /* for ARMCC. */ @@ -243,6 +247,10 @@ int rtthread_startup(void) /* idle thread initialization */ rt_thread_idle_init(); +#ifdef RT_USING_SMP + rt_hw_spin_lock(&_cpus_lock); +#endif /*RT_USING_SMP*/ + /* start scheduler */ rt_system_scheduler_start(); diff --git a/src/cpu.c b/src/cpu.c new file mode 100644 index 0000000000..ef6dce1787 --- /dev/null +++ b/src/cpu.c @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2006-2018, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2018-10-30 Bernard The first version + */ + +#include <rtthread.h> +#include <rthw.h> + +#ifdef RT_USING_SMP + +static struct rt_cpu rt_cpus[RT_CPUS_NR]; +rt_hw_spinlock_t _cpus_lock; + +/** + * This fucntion will return current cpu. + */ +struct rt_cpu *rt_cpu_self(void) +{ + return &rt_cpus[rt_hw_cpu_id()]; +} + +struct rt_cpu *rt_cpu_index(int index) +{ + return &rt_cpus[index]; +} + +/** + * This function will lock all cpus's scheduler and disable local irq. + */ +rt_base_t rt_cpus_lock(void) +{ + rt_base_t level; + struct rt_cpu* pcpu; + + level = rt_hw_local_irq_disable(); + + pcpu = rt_cpu_self(); + if (pcpu->current_thread != RT_NULL) + { + if (pcpu->current_thread->cpus_lock_nest++ == 0) + { + pcpu->current_thread->scheduler_lock_nest++; + rt_hw_spin_lock(&_cpus_lock); + } + } + return level; +} +RTM_EXPORT(rt_cpus_lock); + +/** + * This function will restore all cpus's scheduler and restore local irq. + */ +void rt_cpus_unlock(rt_base_t level) +{ + struct rt_cpu* pcpu = rt_cpu_self(); + + if (pcpu->current_thread != RT_NULL) + { + if (--pcpu->current_thread->cpus_lock_nest == 0) + { + pcpu->current_thread->scheduler_lock_nest--; + rt_hw_spin_unlock(&_cpus_lock); + } + } + rt_hw_local_irq_enable(level); +} +RTM_EXPORT(rt_cpus_unlock); + +/** + * This function is invoked by scheduler. + * It will restore the lock state to whatever the thread's counter expects. + * If target thread not locked the cpus then unlock the cpus lock. + */ +void rt_cpus_lock_status_restore(struct rt_thread *thread) +{ + struct rt_cpu* pcpu = rt_cpu_self(); + + pcpu->current_thread = thread; + if (!thread->cpus_lock_nest) + { + rt_hw_spin_unlock(&_cpus_lock); + } +} +RTM_EXPORT(rt_post_switch); + +#endif diff --git a/src/idle.c b/src/idle.c index ec7d6bea6e..7d985e3816 100644 --- a/src/idle.c +++ b/src/idle.c @@ -13,6 +13,8 @@ * 2016-08-09 ArdaFu add method to get the handler of the idle thread. * 2018-02-07 Bernard lock scheduler to protect tid->cleanup. * 2018-07-14 armink add idle hook list + * 2018-11-22 Jesven add per cpu idle task + * combine the code of primary and secondary cpu */ #include <rthw.h> @@ -28,6 +30,11 @@ #endif #endif +#ifdef RT_USING_IDLE_HOOK +#ifndef RT_IDEL_HOOK_LIST_SIZE +#define RT_IDEL_HOOK_LIST_SIZE 4 +#endif + #ifndef IDLE_THREAD_STACK_SIZE #if defined (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP) #define IDLE_THREAD_STACK_SIZE 256 @@ -36,18 +43,17 @@ #endif #endif -static struct rt_thread idle; -ALIGN(RT_ALIGN_SIZE) -static rt_uint8_t rt_thread_stack[IDLE_THREAD_STACK_SIZE]; +#ifdef RT_USING_SMP +#define _CPUS_NR RT_CPUS_NR +#else +#define _CPUS_NR 1 +#endif extern rt_list_t rt_thread_defunct; -#ifdef RT_USING_IDLE_HOOK - -#ifndef RT_IDEL_HOOK_LIST_SIZE -#define RT_IDEL_HOOK_LIST_SIZE 4 -#endif - +static struct rt_thread idle[_CPUS_NR]; +ALIGN(RT_ALIGN_SIZE) +static rt_uint8_t rt_thread_stack[_CPUS_NR][IDLE_THREAD_STACK_SIZE]; static void (*idle_hook_list[RT_IDEL_HOOK_LIST_SIZE])(); /** @@ -221,14 +227,21 @@ void rt_thread_idle_excute(void) static void rt_thread_idle_entry(void *parameter) { -#ifdef RT_USING_IDLE_HOOK - rt_size_t i; +#ifdef RT_USING_SMP + if (rt_hw_cpu_id() != 0) + { + while (1) + { + rt_hw_secondary_cpu_idle_exec(); + } + } #endif while (1) { - #ifdef RT_USING_IDLE_HOOK + rt_size_t i; + for (i = 0; i < RT_IDEL_HOOK_LIST_SIZE; i++) { if (idle_hook_list[i] != RT_NULL) @@ -251,18 +264,26 @@ static void rt_thread_idle_entry(void *parameter) */ void rt_thread_idle_init(void) { - /* initialize thread */ - rt_thread_init(&idle, - "tidle", - rt_thread_idle_entry, - RT_NULL, - &rt_thread_stack[0], - sizeof(rt_thread_stack), - RT_THREAD_PRIORITY_MAX - 1, - 32); + int i; + char tidle_name[RT_NAME_MAX]; - /* startup */ - rt_thread_startup(&idle); + for (i = 0; i < _CPUS_NR; i++) + { + rt_sprintf(tidle_name, "tidle%d", i); + rt_thread_init(&idle[i], + tidle_name, + rt_thread_idle_entry, + RT_NULL, + &rt_thread_stack[i][0], + sizeof(rt_thread_stack[i]), + RT_THREAD_PRIORITY_MAX - 1, + 32); +#ifdef RT_USING_SMP + rt_thread_control(&idle[i], RT_THREAD_CTRL_BIND_CPU, (void*)i); +#endif + /* startup */ + rt_thread_startup(&idle[i]); + } } /** @@ -273,5 +294,11 @@ void rt_thread_idle_init(void) */ rt_thread_t rt_thread_idle_gethandler(void) { - return (rt_thread_t)(&idle); +#ifdef RT_USING_SMP + register int id = rt_hw_cpu_id(); +#else + register int id = 0; +#endif + + return (rt_thread_t)(&idle[id]); } @@ -8,6 +8,7 @@ * 2006-02-24 Bernard first version * 2006-05-03 Bernard add IRQ_DEBUG * 2016-08-09 ArdaFu add interrupt enter and leave hook. + * 2018-11-22 Jesven rt_interrupt_get_nest function add disable irq */ #include <rthw.h> @@ -48,7 +49,11 @@ void rt_interrupt_leave_sethook(void (*hook)(void)) /**@{*/ +#ifdef RT_USING_SMP +#define rt_interrupt_nest rt_cpu_self()->irq_nest +#else volatile rt_uint8_t rt_interrupt_nest; +#endif /** * This function will be invoked by BSP, when enter interrupt service routine @@ -102,7 +107,13 @@ RTM_EXPORT(rt_interrupt_leave); */ rt_uint8_t rt_interrupt_get_nest(void) { - return rt_interrupt_nest; + rt_uint8_t ret; + rt_base_t level; + + level = rt_hw_interrupt_disable(); + ret = rt_interrupt_nest; + rt_hw_interrupt_enable(level); + return ret; } RTM_EXPORT(rt_interrupt_get_nest); diff --git a/src/scheduler.c b/src/scheduler.c index fd068a6671..e177bde6b7 100644 --- a/src/scheduler.c +++ b/src/scheduler.c @@ -21,28 +21,36 @@ * 2010-12-13 Bernard add defunct list initialization even if not use heap. * 2011-05-10 Bernard clean scheduler debug log. * 2013-12-21 Grissiom add rt_critical_level + * 2018-11-22 Jesven remove the current task from ready queue + * add per cpu ready queue + * add _get_highest_priority_thread to find highest priority task + * rt_schedule_insert_thread won't insert current task to ready queue + * in smp version, rt_hw_context_switch_interrupt maybe switch to + * new task directly + * */ #include <rtthread.h> #include <rthw.h> -static rt_int16_t rt_scheduler_lock_nest; -extern volatile rt_uint8_t rt_interrupt_nest; +#ifdef RT_USING_SMP +rt_hw_spinlock_t _rt_critical_lock; +#endif /*RT_USING_SMP*/ rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX]; -struct rt_thread *rt_current_thread; - -rt_uint8_t rt_current_priority; - +rt_uint32_t rt_thread_ready_priority_group; #if RT_THREAD_PRIORITY_MAX > 32 /* Maximum priority level, 256 */ -rt_uint32_t rt_thread_ready_priority_group; rt_uint8_t rt_thread_ready_table[32]; -#else -/* Maximum priority level, 32 */ -rt_uint32_t rt_thread_ready_priority_group; #endif +#ifndef RT_USING_SMP +extern volatile rt_uint8_t rt_interrupt_nest; +static rt_int16_t rt_scheduler_lock_nest; +struct rt_thread *rt_current_thread; +rt_uint8_t rt_current_priority; +#endif /*RT_USING_SMP*/ + rt_list_t rt_thread_defunct; #ifdef RT_USING_HOOK @@ -91,19 +99,84 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread) level = rt_hw_interrupt_disable(); while (level); } -#if defined(ARCH_CPU_STACK_GROWS_UPWARD) - else if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size)) + else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32)) { - rt_kprintf("warning: %s stack is close to the top of stack address.\n", + rt_kprintf("warning: %s stack is close to end of stack address.\n", thread->name); } +} +#endif + +/* + * get the highest priority thread in ready queue + */ +#ifdef RT_USING_SMP +static struct rt_thread* _get_highest_priority_thread(rt_ubase_t *highest_prio) +{ + register struct rt_thread *highest_priority_thread; + register rt_ubase_t highest_ready_priority, local_highest_ready_priority; + struct rt_cpu* pcpu = rt_cpu_self(); + +#if RT_THREAD_PRIORITY_MAX > 32 + register rt_ubase_t number; + + if (rt_thread_ready_priority_group == 0 && pcpu->priority_group == 0) + { + *highest_prio = pcpu->current_thread->current_priority; + /* only local IDLE is readly */ + return pcpu->current_thread; + } + + number = __rt_ffs(rt_thread_ready_priority_group) - 1; + highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1; + number = __rt_ffs(pcpu->priority_group) - 1; + local_highest_ready_priority = (number << 3) + __rt_ffs(pcpu->ready_table[number]) - 1; #else - else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32)) + highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1; + local_highest_ready_priority = __rt_ffs(pcpu->priority_group) - 1; +#endif + + /* get highest ready priority thread */ + if (highest_ready_priority < local_highest_ready_priority) { - rt_kprintf("warning: %s stack is close to the bottom of stack address.\n", - thread->name); + *highest_prio = highest_ready_priority; + highest_priority_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, + struct rt_thread, + tlist); + } + else + { + *highest_prio = local_highest_ready_priority; + highest_priority_thread = rt_list_entry(pcpu->priority_table[local_highest_ready_priority].next, + struct rt_thread, + tlist); } + + return highest_priority_thread; +} +#else +static struct rt_thread* _get_highest_priority_thread(rt_ubase_t *highest_prio) +{ + register struct rt_thread *highest_priority_thread; + register rt_ubase_t highest_ready_priority; + +#if RT_THREAD_PRIORITY_MAX > 32 + register rt_ubase_t number; + + number = __rt_ffs(rt_thread_ready_priority_group) - 1; + highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1; +#else + highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1; #endif + + /* get highest ready priority thread */ + highest_priority_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, + struct rt_thread, + tlist); + + *highest_prio = highest_ready_priority; + + return highest_priority_thread; } #endif @@ -113,9 +186,14 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread) */ void rt_system_scheduler_init(void) { +#ifdef RT_USING_SMP + int cpu; +#endif /*RT_USING_SMP*/ register rt_base_t offset; +#ifndef RT_USING_SMP rt_scheduler_lock_nest = 0; +#endif /*RT_USING_SMP*/ RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n", RT_THREAD_PRIORITY_MAX)); @@ -124,9 +202,25 @@ void rt_system_scheduler_init(void) { rt_list_init(&rt_thread_priority_table[offset]); } +#ifdef RT_USING_SMP + for (cpu = 0; cpu < RT_CPUS_NR; cpu++) + { + struct rt_cpu *pcpu = rt_cpu_index(cpu); + for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) + { + rt_list_init(&pcpu->priority_table[offset]); + } - rt_current_priority = RT_THREAD_PRIORITY_MAX - 1; - rt_current_thread = RT_NULL; + pcpu->irq_switch_flag = 0; + pcpu->current_priority = RT_THREAD_PRIORITY_MAX - 1; + pcpu->current_thread = RT_NULL; + pcpu->priority_group = 0; + +#if RT_THREAD_PRIORITY_MAX > 32 + rt_memset(pcpu->ready_table, 0, sizeof(pcpu->ready_table)); +#endif + } +#endif /*RT_USING_SMP*/ /* initialize ready priority group */ rt_thread_ready_priority_group = 0; @@ -148,26 +242,24 @@ 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; + rt_ubase_t highest_ready_priority; -#if RT_THREAD_PRIORITY_MAX > 32 - register rt_ubase_t number; + to_thread = _get_highest_priority_thread(&highest_ready_priority); - number = __rt_ffs(rt_thread_ready_priority_group) - 1; - highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1; +#ifdef RT_USING_SMP + to_thread->oncpu = rt_hw_cpu_id(); #else - highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1; -#endif - - /* 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; +#endif /*RT_USING_SMP*/ + + rt_schedule_remove_thread(to_thread); /* switch to new thread */ - rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp); +#ifdef RT_USING_SMP + rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp, to_thread); +#else + rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp); +#endif /*RT_USING_SMP*/ /* never come back */ } @@ -178,6 +270,114 @@ void rt_system_scheduler_start(void) /**@{*/ + +#ifdef RT_USING_SMP +/** + * This function will handle IPI interrupt and do a scheduling in system; + * + * @param vector, the number of IPI interrupt for system scheduling + * @param param, use RT_NULL + * + * NOTE: this function should be invoke or register as ISR in BSP. + */ +void rt_scheduler_ipi_handler(int vector, void *param) +{ + rt_schedule(); +} + +/** + * This function will perform one scheduling. It will select one thread + * with the highest priority level in global ready queue or local ready queue, + * then switch to it. + */ +void rt_schedule(void) +{ + rt_base_t level; + struct rt_thread *to_thread; + struct rt_thread *current_thread; + struct rt_cpu *pcpu; + int cpu_id; + + /* disable interrupt */ + level = rt_hw_interrupt_disable(); + + cpu_id = rt_hw_cpu_id(); + pcpu = rt_cpu_index(cpu_id); + current_thread = pcpu->current_thread; + + /* whether do switch in interrupt */ + if (pcpu->irq_nest) + { + pcpu->irq_switch_flag = 1; + } + else if (current_thread->scheduler_lock_nest == 1) /* whether lock scheduler */ + { + rt_ubase_t highest_ready_priority; + + if (rt_thread_ready_priority_group != 0 || pcpu->priority_group != 0) + { + to_thread = _get_highest_priority_thread(&highest_ready_priority); + current_thread->oncpu = RT_CPU_DETACHED; + if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) + { + if (current_thread->current_priority < highest_ready_priority) + { + to_thread = current_thread; + } + else + { + rt_schedule_insert_thread(current_thread); + } + } + to_thread->oncpu = cpu_id; + if (to_thread != current_thread) + { + /* if the destination thread is not the same as current thread */ + pcpu->current_priority = (rt_uint8_t)highest_ready_priority; + + RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (current_thread, to_thread)); + + rt_schedule_remove_thread(to_thread); + + /* switch to new thread */ + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, + ("[%d]switch to priority#%d " + "thread:%.*s(sp:0x%08x), " + "from thread:%.*s(sp: 0x%08x)\n", + pcpu->irq_nest, highest_ready_priority, + RT_NAME_MAX, to_thread->name, to_thread->sp, + RT_NAME_MAX, current_thread->name, current_thread->sp)); + +#ifdef RT_USING_OVERFLOW_CHECK + _rt_scheduler_stack_check(to_thread); +#endif + + { + extern void rt_thread_handle_sig(rt_bool_t clean_state); + + rt_hw_context_switch((rt_ubase_t)¤t_thread->sp, + (rt_ubase_t)&to_thread->sp, to_thread); + + /* enable interrupt */ + rt_hw_interrupt_enable(level); + +#ifdef RT_USING_SIGNALS + /* check signal status */ + rt_thread_handle_sig(RT_TRUE); +#endif + goto __exit; + } + } + } + } + + /* enable interrupt */ + rt_hw_interrupt_enable(level); + +__exit: + return ; +} +#else /** * This function will perform one schedule. It will select one thread * with the highest priority level, then switch to it. @@ -194,81 +394,169 @@ void rt_schedule(void) /* check the scheduler is enabled or not */ if (rt_scheduler_lock_nest == 0) { - register rt_ubase_t highest_ready_priority; + rt_ubase_t highest_ready_priority; -#if RT_THREAD_PRIORITY_MAX <= 32 - highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1; -#else - register rt_ubase_t number; + if (rt_thread_ready_priority_group != 0) + { + int need_insert_from_thread = 0; - number = __rt_ffs(rt_thread_ready_priority_group) - 1; - highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1; -#endif + to_thread = _get_highest_priority_thread(&highest_ready_priority); - /* get switch to thread */ - to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next, - struct rt_thread, - tlist); + if ((rt_current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) + { + if (rt_current_thread->current_priority < highest_ready_priority) + { + to_thread = rt_current_thread; + } + else + { + need_insert_from_thread = 1; + } + } - /* if the destination thread is not the same as current thread */ - if (to_thread != rt_current_thread) - { - rt_current_priority = (rt_uint8_t)highest_ready_priority; - from_thread = rt_current_thread; - rt_current_thread = to_thread; + if (to_thread != rt_current_thread) + { + /* if the destination thread is not the same as current thread */ + rt_current_priority = (rt_uint8_t)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)); + if (need_insert_from_thread) + { + rt_schedule_insert_thread(from_thread); + } - /* switch to new thread */ - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, - ("[%d]switch to priority#%d " - "thread:%.*s(sp:0x%08x), " - "from thread:%.*s(sp: 0x%08x)\n", - rt_interrupt_nest, highest_ready_priority, - RT_NAME_MAX, to_thread->name, to_thread->sp, - RT_NAME_MAX, from_thread->name, from_thread->sp)); + rt_schedule_remove_thread(to_thread); + + /* switch to new thread */ + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, + ("[%d]switch to priority#%d " + "thread:%.*s(sp:0x%p), " + "from thread:%.*s(sp: 0x%p)\n", + rt_interrupt_nest, highest_ready_priority, + RT_NAME_MAX, to_thread->name, to_thread->sp, + RT_NAME_MAX, from_thread->name, from_thread->sp)); #ifdef RT_USING_OVERFLOW_CHECK - _rt_scheduler_stack_check(to_thread); + _rt_scheduler_stack_check(to_thread); #endif - if (rt_interrupt_nest == 0) - { - extern void rt_thread_handle_sig(rt_bool_t clean_state); + if (rt_interrupt_nest == 0) + { + extern void rt_thread_handle_sig(rt_bool_t clean_state); - rt_hw_context_switch((rt_ubase_t)&from_thread->sp, - (rt_ubase_t)&to_thread->sp); + rt_hw_context_switch((rt_ubase_t)&from_thread->sp, + (rt_ubase_t)&to_thread->sp); - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); #ifdef RT_USING_SIGNALS - /* check signal status */ - rt_thread_handle_sig(RT_TRUE); + /* check signal status */ + rt_thread_handle_sig(RT_TRUE); #endif + goto __exit; + } + else + { + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n")); + + rt_hw_context_switch_interrupt((rt_ubase_t)&from_thread->sp, + (rt_ubase_t)&to_thread->sp); + } } else { - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n")); - - rt_hw_context_switch_interrupt((rt_ubase_t)&from_thread->sp, - (rt_ubase_t)&to_thread->sp); - /* enable interrupt */ - rt_hw_interrupt_enable(level); + rt_schedule_remove_thread(rt_current_thread); } } - else - { - /* enable interrupt */ - rt_hw_interrupt_enable(level); - } } - else + + /* enable interrupt */ + rt_hw_interrupt_enable(level); + +__exit: + return; +} +#endif /*RT_USING_SMP*/ + +/** + * This function checks if a scheduling is needed after IRQ context. If yes, + * it will select one thread with the highest priority level, and then switch + * to it. + */ +#ifdef RT_USING_SMP +void rt_scheduler_do_irq_switch(void *context) +{ + int cpu_id; + rt_base_t level; + struct rt_cpu* pcpu; + struct rt_thread *to_thread; + struct rt_thread *current_thread; + + level = rt_hw_interrupt_disable(); + + cpu_id = rt_hw_cpu_id(); + pcpu = rt_cpu_index(cpu_id); + current_thread = pcpu->current_thread; + + if (pcpu->irq_switch_flag == 0) { - /* enable interrupt */ rt_hw_interrupt_enable(level); + return; + } + + if (current_thread->scheduler_lock_nest == 1 && pcpu->irq_nest == 0) + { + rt_ubase_t highest_ready_priority; + + /* clear irq switch flag */ + pcpu->irq_switch_flag = 0; + + if (rt_thread_ready_priority_group != 0 || pcpu->priority_group != 0) + { + to_thread = _get_highest_priority_thread(&highest_ready_priority); + current_thread->oncpu = RT_CPU_DETACHED; + if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) + { + if (current_thread->current_priority < highest_ready_priority) + { + to_thread = current_thread; + } + else + { + rt_schedule_insert_thread(current_thread); + } + } + to_thread->oncpu = cpu_id; + if (to_thread != current_thread) + { + /* if the destination thread is not the same as current thread */ + + pcpu->current_priority = (rt_uint8_t)highest_ready_priority; + + RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (current_thread, to_thread)); + + rt_schedule_remove_thread(to_thread); + +#ifdef RT_USING_OVERFLOW_CHECK + _rt_scheduler_stack_check(to_thread); +#endif + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n")); + + current_thread->cpus_lock_nest--; + current_thread->scheduler_lock_nest--; + + rt_hw_context_switch_interrupt(context, (rt_ubase_t)¤t_thread->sp, + (rt_ubase_t)&to_thread->sp, to_thread); + } + } } + rt_hw_interrupt_enable(level); } +#endif /*RT_USING_SMP*/ /* * This function will insert a thread to system ready queue. The state of @@ -277,6 +565,70 @@ void rt_schedule(void) * @param thread the thread to be inserted * @note Please do not invoke this function in user application. */ +#ifdef RT_USING_SMP +void rt_schedule_insert_thread(struct rt_thread *thread) +{ + int cpu_id; + int bind_cpu; + rt_uint32_t cpu_mask; + register rt_base_t level; + + RT_ASSERT(thread != RT_NULL); + + /* disable interrupt */ + level = rt_hw_interrupt_disable(); + + /* change stat */ + thread->stat = RT_THREAD_READY | (thread->stat & ~RT_THREAD_STAT_MASK); + + if (thread->oncpu != RT_CPU_DETACHED) + { + goto __exit; + } + + cpu_id = rt_hw_cpu_id(); + bind_cpu = thread->bind_cpu ; + + /* insert thread to ready list */ + if (bind_cpu == RT_CPUS_NR) + { +#if RT_THREAD_PRIORITY_MAX > 32 + rt_thread_ready_table[thread->number] |= thread->high_mask; +#endif + rt_thread_ready_priority_group |= thread->number_mask; + + rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), + &(thread->tlist)); + cpu_mask = RT_CPU_MASK ^ (1 << cpu_id); + rt_hw_ipi_send(RT_SCHEDULE_IPI_IRQ, cpu_mask); + } + else + { + struct rt_cpu *pcpu = rt_cpu_index(bind_cpu); + +#if RT_THREAD_PRIORITY_MAX > 32 + pcpu->ready_table[thread->number] |= thread->high_mask; +#endif + pcpu->priority_group |= thread->number_mask; + + rt_list_insert_before(&(rt_cpu_index(bind_cpu)->priority_table[thread->current_priority]), + &(thread->tlist)); + + if (cpu_id != bind_cpu) + { + cpu_mask = 1 << bind_cpu; + rt_hw_ipi_send(RT_SCHEDULE_IPI_IRQ, cpu_mask); + } + } + + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%.*s], the priority: %d\n", + RT_NAME_MAX, thread->name, thread->current_priority)); + +__exit: + /* enable interrupt */ + rt_hw_interrupt_enable(level); +} +#else void rt_schedule_insert_thread(struct rt_thread *thread) { register rt_base_t temp; @@ -289,32 +641,29 @@ void rt_schedule_insert_thread(struct rt_thread *thread) /* change stat */ thread->stat = RT_THREAD_READY | (thread->stat & ~RT_THREAD_STAT_MASK); + if (thread == rt_current_thread) + { + goto __exit; + } + /* insert thread to ready list */ rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), &(thread->tlist)); - /* set priority mask */ -#if RT_THREAD_PRIORITY_MAX <= 32 RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%.*s], the priority: %d\n", RT_NAME_MAX, thread->name, thread->current_priority)); -#else - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, - ("insert thread[%.*s], the priority: %d 0x%x %d\n", - RT_NAME_MAX, - thread->name, - thread->number, - thread->number_mask, - thread->high_mask)); -#endif + /* set priority mask */ #if RT_THREAD_PRIORITY_MAX > 32 rt_thread_ready_table[thread->number] |= thread->high_mask; #endif rt_thread_ready_priority_group |= thread->number_mask; +__exit: /* enable interrupt */ rt_hw_interrupt_enable(temp); } +#endif /*RT_USING_SMP*/ /* * This function will remove a thread from system ready queue. @@ -323,28 +672,71 @@ void rt_schedule_insert_thread(struct rt_thread *thread) * * @note Please do not invoke this function in user application. */ +#ifdef RT_USING_SMP void rt_schedule_remove_thread(struct rt_thread *thread) { - register rt_base_t temp; + register rt_base_t level; RT_ASSERT(thread != RT_NULL); /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + level = rt_hw_interrupt_disable(); -#if RT_THREAD_PRIORITY_MAX <= 32 RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%.*s], the priority: %d\n", RT_NAME_MAX, thread->name, thread->current_priority)); + + /* remove thread from ready list */ + rt_list_remove(&(thread->tlist)); + if (thread->bind_cpu == RT_CPUS_NR) + { + 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; + } +#else + rt_thread_ready_priority_group &= ~thread->number_mask; +#endif + } + } + else + { + struct rt_cpu *pcpu = rt_cpu_index(thread->bind_cpu); + + if (rt_list_isempty(&(pcpu->priority_table[thread->current_priority]))) + { +#if RT_THREAD_PRIORITY_MAX > 32 + pcpu->ready_table[thread->number] &= ~thread->high_mask; + if (rt_thread_ready_table[thread->number] == 0) + { + pcpu->priority_group &= ~thread->number_mask; + } #else - RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, - ("remove thread[%.*s], the priority: %d 0x%x %d\n", - RT_NAME_MAX, - thread->name, - thread->number, - thread->number_mask, - thread->high_mask)); + pcpu->priority_group &= ~thread->number_mask; #endif + } + } + + /* enable interrupt */ + rt_hw_interrupt_enable(level); +} +#else +void rt_schedule_remove_thread(struct rt_thread *thread) +{ + register rt_base_t level; + + RT_ASSERT(thread != RT_NULL); + + /* disable interrupt */ + level = rt_hw_interrupt_disable(); + + RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%.*s], the priority: %d\n", + RT_NAME_MAX, thread->name, + thread->current_priority)); /* remove thread from ready list */ rt_list_remove(&(thread->tlist)); @@ -362,12 +754,41 @@ void rt_schedule_remove_thread(struct rt_thread *thread) } /* enable interrupt */ - rt_hw_interrupt_enable(temp); + rt_hw_interrupt_enable(level); } +#endif /*RT_USING_SMP*/ /** * This function will lock the thread scheduler. */ +#ifdef RT_USING_SMP +void rt_enter_critical(void) +{ + register rt_base_t level; + struct rt_thread *current_thread; + + /* disable interrupt */ + level = rt_hw_local_irq_disable(); + + current_thread = rt_cpu_self()->current_thread; + /* + * the maximal number of nest is RT_UINT16_MAX, which is big + * enough and does not check here + */ + + /* lock scheduler for all cpus */ + if (current_thread->scheduler_lock_nest == !!current_thread->cpus_lock_nest) + { + rt_hw_spin_lock(&_rt_critical_lock); + } + + /* lock scheduler for local cpu */ + current_thread->scheduler_lock_nest ++; + + /* enable interrupt */ + rt_hw_local_irq_enable(level); +} +#else void rt_enter_critical(void) { register rt_base_t level; @@ -384,11 +805,45 @@ void rt_enter_critical(void) /* enable interrupt */ rt_hw_interrupt_enable(level); } +#endif /*RT_USING_SMP*/ RTM_EXPORT(rt_enter_critical); /** * This function will unlock the thread scheduler. */ +#ifdef RT_USING_SMP +void rt_exit_critical(void) +{ + register rt_base_t level; + struct rt_thread *current_thread; + + /* disable interrupt */ + level = rt_hw_local_irq_disable(); + + current_thread = rt_cpu_self()->current_thread; + + current_thread->scheduler_lock_nest --; + + if (current_thread->scheduler_lock_nest == !!current_thread->cpus_lock_nest) + { + rt_hw_spin_unlock(&_rt_critical_lock); + } + + if (current_thread->scheduler_lock_nest <= 0) + { + current_thread->scheduler_lock_nest = 0; + /* enable interrupt */ + rt_hw_local_irq_enable(level); + + rt_schedule(); + } + else + { + /* enable interrupt */ + rt_hw_local_irq_enable(level); + } +} +#else void rt_exit_critical(void) { register rt_base_t level; @@ -412,6 +867,7 @@ void rt_exit_critical(void) rt_hw_interrupt_enable(level); } } +#endif /*RT_USING_SMP*/ RTM_EXPORT(rt_exit_critical); /** @@ -421,8 +877,14 @@ RTM_EXPORT(rt_exit_critical); */ rt_uint16_t rt_critical_level(void) { - return rt_scheduler_lock_nest; +#ifdef RT_USING_SMP + struct rt_thread *current_thread = rt_cpu_self()->current_thread; + + return current_thread->scheduler_lock_nest; +#else + return rt_scheduler_lock_nest; +#endif /*RT_USING_SMP*/ } RTM_EXPORT(rt_critical_level); -/**@}*/ +/**@}*/ diff --git a/src/signal.c b/src/signal.c index 890f16f497..05632b2c4a 100644 --- a/src/signal.c +++ b/src/signal.c @@ -6,6 +6,8 @@ * Change Logs: * Date Author Notes * 2017/10/5 Bernard the first version + * 2018/09/17 Jesven fix: in _signal_deliver RT_THREAD_STAT_MASK to RT_THREAD_STAT_SIGNAL_MASK + * 2018/11/22 Jesven in smp version rt_hw_context_switch_to add a param */ #include <stdint.h> @@ -60,10 +62,14 @@ static void _signal_entry(void *parameter) tid->sp = tid->sig_ret; tid->sig_ret = RT_NULL; - LOG_D("switch back to: 0x%08x", tid->sp); + LOG_D("switch back to: 0x%08x\n", tid->sp); tid->stat &= ~RT_THREAD_STAT_SIGNAL; - rt_hw_context_switch_to((rt_uint32_t) & (tid->sp)); +#ifdef RT_USING_SMP + rt_hw_context_switch_to((rt_ubase_t)&(tid->sp), tid); +#else + rt_hw_context_switch_to((rt_ubase_t)&(tid->sp)); +#endif /*RT_USING_SMP*/ } /* @@ -108,7 +114,7 @@ static void _signal_deliver(rt_thread_t tid) /* do signal action in self thread context */ rt_thread_handle_sig(RT_TRUE); } - else if (!((tid->stat & RT_THREAD_STAT_MASK) & RT_THREAD_STAT_SIGNAL)) + else if (!((tid->stat & RT_THREAD_STAT_SIGNAL_MASK) & RT_THREAD_STAT_SIGNAL)) { /* add signal state */ tid->stat |= RT_THREAD_STAT_SIGNAL; diff --git a/src/thread.c b/src/thread.c index 07c7619c6f..df9f151834 100644 --- a/src/thread.c +++ b/src/thread.c @@ -23,18 +23,17 @@ * 2012-12-29 Bernard fixed compiling warning. * 2016-08-09 ArdaFu add thread suspend and resume hook. * 2017-04-10 armink fixed the rt_thread_delete and rt_thread_detach - bug when thread has not startup. + * bug when thread has not startup. + * 2018-11-22 Jesven yield is same to rt_schedule + * add support for tasks bound to cpu */ -#include <rtthread.h> #include <rthw.h> +#include <rtthread.h> -extern rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX]; -extern struct rt_thread *rt_current_thread; extern rt_list_t rt_thread_defunct; #ifdef RT_USING_HOOK - static void (*rt_thread_suspend_hook)(rt_thread_t thread); static void (*rt_thread_resume_hook) (rt_thread_t thread); static void (*rt_thread_inited_hook) (rt_thread_t thread); @@ -84,7 +83,7 @@ void rt_thread_exit(void) register rt_base_t level; /* get current thread */ - thread = rt_current_thread; + thread = rt_thread_self(); /* disable interrupt */ level = rt_hw_interrupt_disable(); @@ -165,6 +164,16 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread, thread->error = RT_EOK; thread->stat = RT_THREAD_INIT; +#ifdef RT_USING_SMP + /* not bind on any cpu */ + thread->bind_cpu = RT_CPUS_NR; + thread->oncpu = RT_CPU_DETACHED; + + /* lock init */ + thread->scheduler_lock_nest = 0; + thread->cpus_lock_nest = 0; +#endif /*RT_USING_SMP*/ + /* initialize cleanup function and user data */ thread->cleanup = 0; thread->user_data = 0; @@ -251,7 +260,19 @@ RTM_EXPORT(rt_thread_init); */ rt_thread_t rt_thread_self(void) { +#ifdef RT_USING_SMP + rt_base_t lock; + rt_thread_t self; + + lock = rt_hw_local_irq_disable(); + self = rt_cpu_self()->current_thread; + rt_hw_local_irq_enable(lock); + return self; +#else + extern rt_thread_t rt_current_thread; + return rt_current_thread; +#endif } RTM_EXPORT(rt_thread_self); @@ -449,36 +470,7 @@ RTM_EXPORT(rt_thread_delete); */ rt_err_t rt_thread_yield(void) { - register rt_base_t level; - struct rt_thread *thread; - - /* disable interrupt */ - level = rt_hw_interrupt_disable(); - - /* set to current thread */ - thread = rt_current_thread; - - /* if the thread stat is READY and on ready queue list */ - if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY && - thread->tlist.next != thread->tlist.prev) - { - /* remove thread from thread list */ - rt_list_remove(&(thread->tlist)); - - /* put thread to end of ready queue */ - rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), - &(thread->tlist)); - - /* enable interrupt */ - rt_hw_interrupt_enable(level); - - rt_schedule(); - - return RT_EOK; - } - - /* enable interrupt */ - rt_hw_interrupt_enable(level); + rt_schedule(); return RT_EOK; } @@ -496,13 +488,14 @@ rt_err_t rt_thread_sleep(rt_tick_t tick) register rt_base_t temp; struct rt_thread *thread; - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); /* set to current thread */ - thread = rt_current_thread; + thread = rt_thread_self(); RT_ASSERT(thread != RT_NULL); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + /* suspend thread */ rt_thread_suspend(thread); @@ -559,7 +552,8 @@ RTM_EXPORT(rt_thread_mdelay); * @param cmd the control command, which includes * RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread; * RT_THREAD_CTRL_STARTUP for starting a thread; - * RT_THREAD_CTRL_CLOSE for delete a thread. + * RT_THREAD_CTRL_CLOSE for delete a thread; + * RT_THREAD_CTRL_BIND_CPU for bind the thread to a CPU. * @param arg the argument of control command * * @return RT_EOK @@ -625,6 +619,22 @@ rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg) return rt_thread_delete(thread); #endif +#ifdef RT_USING_SMP + case RT_THREAD_CTRL_BIND_CPU: + { + rt_uint8_t cpu; + + if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT) + { + /* we only support bind cpu before started phase. */ + return RT_ERROR; + } + + cpu = (rt_uint8_t)(size_t)arg; + thread->bind_cpu = cpu > RT_CPUS_NR? RT_CPUS_NR : cpu; + break; + } +#endif /*RT_USING_SMP*/ default: break; } @@ -661,6 +671,8 @@ rt_err_t rt_thread_suspend(rt_thread_t thread) return -RT_ERROR; } + RT_ASSERT(thread == rt_thread_self()); + /* disable interrupt */ temp = rt_hw_interrupt_disable(); |