Thread Management 的协作图:

结构体
struct	rt_cpu_usage_stats

struct	rt_cpu

struct	rt_interrupt_context

struct	rt_thread

宏定义
#define	RT_THREAD_INIT 0x00

#define	RT_THREAD_CLOSE 0x01

#define	RT_THREAD_READY 0x02

#define	RT_THREAD_RUNNING 0x03

#define	RT_THREAD_SUSPEND_MASK 0x04

#define	RT_SIGNAL_COMMON_WAKEUP_MASK 0x02

#define	RT_SIGNAL_KILL_WAKEUP_MASK 0x01

#define	RT_THREAD_SUSPEND_INTERRUPTIBLE (RT_THREAD_SUSPEND_MASK)

#define	RT_THREAD_SUSPEND RT_THREAD_SUSPEND_INTERRUPTIBLE

#define	RT_THREAD_SUSPEND_KILLABLE (RT_THREAD_SUSPEND_MASK \| RT_SIGNAL_COMMON_WAKEUP_MASK)

#define	RT_THREAD_SUSPEND_UNINTERRUPTIBLE (RT_THREAD_SUSPEND_MASK \| RT_SIGNAL_COMMON_WAKEUP_MASK \| RT_SIGNAL_KILL_WAKEUP_MASK)

#define	RT_THREAD_STAT_MASK 0x07

#define	RT_THREAD_STAT_YIELD 0x08

#define	RT_THREAD_STAT_YIELD_MASK RT_THREAD_STAT_YIELD

#define	RT_THREAD_STAT_SIGNAL 0x10

#define	RT_THREAD_STAT_SIGNAL_READY (RT_THREAD_STAT_SIGNAL \| RT_THREAD_READY)

#define	RT_THREAD_STAT_SIGNAL_WAIT 0x20

#define	RT_THREAD_STAT_SIGNAL_PENDING 0x40

#define	RT_THREAD_STAT_SIGNAL_MASK 0xf0

#define	RT_THREAD_CTRL_STARTUP 0x00

#define	RT_THREAD_CTRL_CLOSE 0x01

#define	RT_THREAD_CTRL_CHANGE_PRIORITY 0x02

#define	RT_THREAD_CTRL_INFO 0x03

#define	RT_THREAD_CTRL_BIND_CPU 0x04

#define	rt_current_thread rt_thread_self()

#define	LWP_IS_USER_MODE(t)

#define	RT_SCHEDULER_STACK_CHECK(thr)

类型定义
typedef struct rt_cpu_usage_stats *	rt_cpu_usage_stats_t

typedef struct rt_cpu *	rt_cpu_t

typedef struct rt_interrupt_context *	rt_interrupt_context_t

typedef void(*	rt_thread_cleanup_t) (struct rt_thread *tid)

typedef struct rt_thread *	rt_thread_t

typedef void(*	rt_thread_inited_hookproto_t) (rt_thread_t thread)

枚举
enum	{ RT_INTERRUPTIBLE = 0 , RT_KILLABLE , RT_UNINTERRUPTIBLE }

函数
rt_err_t	rt_thread_init (struct rt_thread thread, const char name, void(entry)(void parameter), void parameter, void stack_start, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick)

	RTM_EXPORT (rt_thread_init)

rt_thread_t	rt_thread_self (void)

	RTM_EXPORT (rt_thread_self)

rt_err_t	rt_thread_startup (rt_thread_t thread)

	RTM_EXPORT (rt_thread_startup)

rt_err_t	rt_thread_close (rt_thread_t thread)

	RTM_EXPORT (rt_thread_close)

rt_err_t	rt_thread_detach (rt_thread_t thread)

	RTM_EXPORT (rt_thread_detach)

rt_thread_t	rt_thread_create (const char name, void(entry)(void parameter), void parameter, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick)

	RTM_EXPORT (rt_thread_create)

rt_err_t	rt_thread_delete (rt_thread_t thread)

	RTM_EXPORT (rt_thread_delete)

rt_err_t	rt_thread_yield (void)

	RTM_EXPORT (rt_thread_yield)

rt_err_t	rt_thread_delay (rt_tick_t tick)

	RTM_EXPORT (rt_thread_delay)

rt_err_t	rt_thread_delay_until (rt_tick_t *tick, rt_tick_t inc_tick)

	RTM_EXPORT (rt_thread_delay_until)

rt_err_t	rt_thread_mdelay (rt_int32_t ms)

	RTM_EXPORT (rt_thread_mdelay)

rt_err_t	rt_thread_control (rt_thread_t thread, int cmd, void *arg)

	RTM_EXPORT (rt_thread_control)

rt_err_t	rt_thread_suspend_to_list (rt_thread_t thread, rt_list_t *susp_list, int ipc_flags, int suspend_flag)

	RTM_EXPORT (rt_thread_suspend_to_list)

rt_err_t	rt_thread_suspend_with_flag (rt_thread_t thread, int suspend_flag)

	RTM_EXPORT (rt_thread_suspend_with_flag)

rt_err_t	rt_thread_suspend (rt_thread_t thread)

	RTM_EXPORT (rt_thread_suspend)

rt_err_t	rt_thread_resume (rt_thread_t thread)

	RTM_EXPORT (rt_thread_resume)

rt_thread_t	rt_thread_find (char *name)

	RTM_EXPORT (rt_thread_find)

rt_err_t	rt_thread_get_name (rt_thread_t thread, char *name, rt_uint8_t name_size)

	RTM_EXPORT (rt_thread_get_name)

void	rt_thread_suspend_sethook (void(*hook)(rt_thread_t thread))

void	rt_thread_resume_sethook (void(*hook)(rt_thread_t thread))

	RT_OBJECT_HOOKLIST_DECLARE (rt_thread_inited_hookproto_t, rt_thread_inited)

void	rt_thread_idle_init (void)

rt_err_t	rt_thread_idle_sethook (void(*hook)(void))

rt_err_t	rt_thread_idle_delhook (void(*hook)(void))

rt_thread_t	rt_thread_idle_gethandler (void)

void	rt_system_scheduler_init (void)

void	rt_system_scheduler_start (void)

void	rt_schedule (void)

void	rt_scheduler_do_irq_switch (void *context)

rt_base_t	rt_enter_critical (void)

void	rt_exit_critical (void)

void	rt_exit_critical_safe (rt_base_t critical_level)

rt_uint16_t	rt_critical_level (void)

void	rt_scheduler_sethook (void(*hook)(rt_thread_t from, rt_thread_t to))

void	rt_scheduler_switch_sethook (void(hook)(struct rt_thread tid))

void	rt_scheduler_ipi_handler (int vector, void *param)

void	rt_schedule_insert_thread (struct rt_thread *thread)

void	rt_schedule_remove_thread (struct rt_thread *thread)

详细描述

the thread management

RT-Thread operating system supports multitask systems, which are based on thread scheduling.

The scheduling is a full preemptive priority-based scheduling algorithm.
8/32/256 priority levels are supported, in which 0 is the highest and 7/31/255 the lowest. The 7/31/255th priority is used for idle thread.
Threads running at same priority level are supported. The shared time-slice round-robin scheduling is used for this case.
The time of scheduler to choose the next highest ready thread is determinant.
There are four status in thread management
1. Initialization
2. Running/Ready
3. Blocked
4. Closed
The number of threads in the system is unlimited, only related with RAM.

宏定义说明

◆ RT_THREAD_INIT

#define RT_THREAD_INIT 0x00

Initialized status

在文件 rtdef.h 第 604 行定义.

◆ RT_THREAD_CLOSE

#define RT_THREAD_CLOSE 0x01

Closed status

在文件 rtdef.h 第 605 行定义.

◆ RT_THREAD_READY

#define RT_THREAD_READY 0x02

Ready status

在文件 rtdef.h 第 606 行定义.

◆ RT_THREAD_RUNNING

#define RT_THREAD_RUNNING 0x03

Running status

在文件 rtdef.h 第 607 行定义.

◆ RT_THREAD_SUSPEND_MASK

#define RT_THREAD_SUSPEND_MASK 0x04

在文件 rtdef.h 第 619 行定义.

◆ RT_SIGNAL_COMMON_WAKEUP_MASK

#define RT_SIGNAL_COMMON_WAKEUP_MASK 0x02

在文件 rtdef.h 第 620 行定义.

◆ RT_SIGNAL_KILL_WAKEUP_MASK

#define RT_SIGNAL_KILL_WAKEUP_MASK 0x01

在文件 rtdef.h 第 621 行定义.

◆ RT_THREAD_SUSPEND_INTERRUPTIBLE

#define RT_THREAD_SUSPEND_INTERRUPTIBLE (RT_THREAD_SUSPEND_MASK)

Suspend interruptable 0x4

在文件 rtdef.h 第 623 行定义.

◆ RT_THREAD_SUSPEND

#define RT_THREAD_SUSPEND RT_THREAD_SUSPEND_INTERRUPTIBLE

在文件 rtdef.h 第 624 行定义.

◆ RT_THREAD_SUSPEND_KILLABLE

#define RT_THREAD_SUSPEND_KILLABLE (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK)

Suspend with killable 0x6

在文件 rtdef.h 第 625 行定义.

◆ RT_THREAD_SUSPEND_UNINTERRUPTIBLE

#define RT_THREAD_SUSPEND_UNINTERRUPTIBLE (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK | RT_SIGNAL_KILL_WAKEUP_MASK)

Suspend with uninterruptable 0x7

在文件 rtdef.h 第 626 行定义.

◆ RT_THREAD_STAT_MASK

#define RT_THREAD_STAT_MASK 0x07

在文件 rtdef.h 第 627 行定义.

◆ RT_THREAD_STAT_YIELD

#define RT_THREAD_STAT_YIELD 0x08

indicate whether remaining_tick has been reloaded since last schedule

在文件 rtdef.h 第 629 行定义.

◆ RT_THREAD_STAT_YIELD_MASK

#define RT_THREAD_STAT_YIELD_MASK RT_THREAD_STAT_YIELD

在文件 rtdef.h 第 630 行定义.

◆ RT_THREAD_STAT_SIGNAL

#define RT_THREAD_STAT_SIGNAL 0x10

task hold signals

在文件 rtdef.h 第 632 行定义.

◆ RT_THREAD_STAT_SIGNAL_READY

#define RT_THREAD_STAT_SIGNAL_READY (RT_THREAD_STAT_SIGNAL | RT_THREAD_READY)

在文件 rtdef.h 第 633 行定义.

◆ RT_THREAD_STAT_SIGNAL_WAIT

#define RT_THREAD_STAT_SIGNAL_WAIT 0x20

task is waiting for signals

在文件 rtdef.h 第 634 行定义.

◆ RT_THREAD_STAT_SIGNAL_PENDING

#define RT_THREAD_STAT_SIGNAL_PENDING 0x40

signals is held and it has not been procressed

在文件 rtdef.h 第 635 行定义.

◆ RT_THREAD_STAT_SIGNAL_MASK

#define RT_THREAD_STAT_SIGNAL_MASK 0xf0

在文件 rtdef.h 第 636 行定义.

◆ RT_THREAD_CTRL_STARTUP

#define RT_THREAD_CTRL_STARTUP 0x00

thread control command definitions Startup thread.

在文件 rtdef.h 第 641 行定义.

◆ RT_THREAD_CTRL_CLOSE

#define RT_THREAD_CTRL_CLOSE 0x01

Close thread.

在文件 rtdef.h 第 642 行定义.

◆ RT_THREAD_CTRL_CHANGE_PRIORITY

#define RT_THREAD_CTRL_CHANGE_PRIORITY 0x02

Change thread priority.

在文件 rtdef.h 第 643 行定义.

◆ RT_THREAD_CTRL_INFO

#define RT_THREAD_CTRL_INFO 0x03

Get thread information.

在文件 rtdef.h 第 644 行定义.

◆ RT_THREAD_CTRL_BIND_CPU

#define RT_THREAD_CTRL_BIND_CPU 0x04

Set thread bind cpu.

在文件 rtdef.h 第 645 行定义.

◆ rt_current_thread

#define rt_current_thread rt_thread_self()

在文件 rtdef.h 第 744 行定义.

◆ LWP_IS_USER_MODE

#define LWP_IS_USER_MODE ( t )

值:

(0)

在文件 rtdef.h 第 958 行定义.

◆ RT_SCHEDULER_STACK_CHECK

#define RT_SCHEDULER_STACK_CHECK ( thr )

在文件 rtthread.h 第 228 行定义.

类型定义说明

◆ rt_cpu_usage_stats_t

typedef struct rt_cpu_usage_stats* rt_cpu_usage_stats_t

在文件 rtdef.h 第 657 行定义.

◆ rt_cpu_t

typedef struct rt_cpu* rt_cpu_t

在文件 rtdef.h 第 742 行定义.

◆ rt_interrupt_context_t

typedef struct rt_interrupt_context * rt_interrupt_context_t

interrupt/exception frame handling

◆ rt_thread_cleanup_t

typedef void(* rt_thread_cleanup_t) (struct rt_thread *tid)

在文件 rtdef.h 第 845 行定义.

◆ rt_thread_t

typedef struct rt_thread* rt_thread_t

在文件 rtdef.h 第 953 行定义.

◆ rt_thread_inited_hookproto_t

typedef void(* rt_thread_inited_hookproto_t) (rt_thread_t thread)

Sets a hook function when a thread is initialized.

参数

thread is the target thread that initializing

在文件 rtthread.h 第 197 行定义.

枚举类型说明

◆ anonymous enum

anonymous enum

枚举值
RT_INTERRUPTIBLE	0
RT_KILLABLE
RT_UNINTERRUPTIBLE

在文件 rtdef.h 第 612 行定义.

{
    RT_INTERRUPTIBLE = 0,
    RT_KILLABLE,
    RT_UNINTERRUPTIBLE,
};

函数说明

◆ rt_thread_init()

rt_err_t rt_thread_init	(	struct rt_thread *	thread,
		const char *	name,
		void(*	entry )(void *parameter),
		void *	parameter,
		void *	stack_start,
		rt_uint32_t	stack_size,
		rt_uint8_t	priority,
		rt_uint32_t	tick )

This function will initialize a thread. It's used to initialize a static thread object.

参数

thread	is the static thread object.
name	is the name of thread, which shall be unique.
entry	is the entry function of thread.
parameter	is the parameter of thread enter function.
stack_start	is the start address of thread stack.
stack_size	is the size of thread stack.
priority	is the priority of thread.
tick	is the time slice if there are same priority thread.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 328 行定义.

{
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(stack_start != RT_NULL);
    RT_ASSERT(tick != 0);
 
    /* clean memory data of thread */
    rt_memset(thread, 0x0, sizeof(struct rt_thread));
 
    /* initialize thread object */
    rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);
 
    return _thread_init(thread,
                        name,
                        entry,
                        parameter,
                        stack_start,
                        stack_size,
                        priority,
                        tick);
}

引用了 rt_thread::entry, rt_thread::parameter, RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_init() , 以及 rt_thread::stack_size.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [1/18]

RTM_EXPORT ( rt_thread_init )

引用了 rt_thread_init().

函数调用图:

◆ rt_thread_self()

rt_thread_t rt_thread_self ( void )

This function will return self thread object.

返回: The self thread object.

在文件 thread.c 第 364 行定义.

{
#ifndef RT_USING_SMP
    return rt_cpu_self()->current_thread;
 
#elif defined (ARCH_USING_HW_THREAD_SELF)
    return rt_hw_thread_self();
 
#else /* !ARCH_USING_HW_THREAD_SELF */
    rt_thread_t self;
    rt_base_t lock;
 
    lock = rt_hw_local_irq_disable();
    self = rt_cpu_self()->current_thread;
    rt_hw_local_irq_enable(lock);
 
    return self;
#endif /* ARCH_USING_HW_THREAD_SELF */
}

引用了 rt_cpu::current_thread, rt_cpu_self(), rt_hw_local_irq_disable , 以及 rt_hw_local_irq_enable.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [2/18]

RTM_EXPORT ( rt_thread_self )

引用了 rt_thread_self().

函数调用图:

◆ rt_thread_startup()

rt_err_t rt_thread_startup ( rt_thread_t thread )

This function will start a thread and put it to system ready queue.

参数

thread is the thread to be started.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 393 行定义.

{
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_MASK) == RT_THREAD_INIT);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
 
    LOG_D("startup a thread:%s with priority:%d",
          thread->parent.name, thread->current_priority);
 
    /* calculate priority attribute and reset thread stat to suspend */
    rt_sched_thread_startup(thread);
 
    /* resume and do a schedule if scheduler is available */
    rt_thread_resume(thread);
 
    return RT_EOK;
}

引用了 LOG_D, rt_object::name, rt_thread::parent, RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_get_type(), RT_SCHED_CTX, RT_THREAD_INIT, rt_thread_resume(), RT_THREAD_STAT_MASK , 以及 stat().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [3/18]

RTM_EXPORT ( rt_thread_startup )

引用了 rt_thread_startup().

函数调用图:

◆ rt_thread_close()

rt_err_t rt_thread_close ( rt_thread_t thread )

This function will close a thread. The thread object will be removed from thread queue and detached/deleted from the system object management. It's different from rt_thread_delete or rt_thread_detach that this will not enqueue the closing thread to cleanup queue.

参数

thread is the thread to be closed.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 424 行定义.

{
    rt_sched_lock_level_t slvl;
    rt_uint8_t thread_status;
 
    /* forbid scheduling on current core if closing current thread */
    RT_ASSERT(thread != rt_thread_self() || rt_critical_level());
 
    /* before checking status of scheduler */
    rt_sched_lock(&slvl);
 
    /* check if thread is already closed */
    thread_status = rt_sched_thread_get_stat(thread);
    if (thread_status != RT_THREAD_CLOSE)
    {
        if (thread_status != RT_THREAD_INIT)
        {
            /* remove from schedule */
            rt_sched_remove_thread(thread);
        }
 
        /* release thread timer */
        rt_timer_detach(&(thread->thread_timer));
 
        /* change stat */
        rt_sched_thread_close(thread);
    }
 
    /* scheduler works are done */
    rt_sched_unlock(slvl);
 
    return RT_EOK;
}

引用了 RT_ASSERT, rt_critical_level(), rt_sched_lock(), rt_sched_thread_close(), rt_sched_thread_get_stat(), rt_sched_unlock(), RT_THREAD_CLOSE, RT_THREAD_INIT, rt_thread_self(), rt_timer_detach() , 以及 rt_thread::thread_timer.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [4/18]

RTM_EXPORT ( rt_thread_close )

引用了 rt_thread_close().

函数调用图:

◆ rt_thread_detach()

rt_err_t rt_thread_detach ( rt_thread_t thread )

This function will detach a thread. The thread object will be removed from thread queue and detached/deleted from the system object management.

参数

thread is the thread to be deleted.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 470 行定义.

{
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
    RT_ASSERT(rt_object_is_systemobject((rt_object_t)thread));
 
    return _thread_detach(thread);
}

引用了 RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_get_type() , 以及 rt_object_is_systemobject().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [5/18]

RTM_EXPORT ( rt_thread_detach )

引用了 rt_thread_detach().

函数调用图:

◆ rt_thread_create()

rt_thread_t rt_thread_create	(	const char *	name,
		void(*	entry )(void *parameter),
		void *	parameter,
		rt_uint32_t	stack_size,
		rt_uint8_t	priority,
		rt_uint32_t	tick )

This function will create a thread object and allocate thread object memory. and stack.

参数

name	is the name of thread, which shall be unique.
entry	is the entry function of thread.
parameter	is the parameter of thread enter function.
stack_size	is the size of thread stack.
priority	is the priority of thread.
tick	is the time slice if there are same priority thread.

返回: If the return value is a rt_thread structure pointer, the function is successfully executed. If the return value is RT_NULL, it means this operation failed.

在文件 thread.c 第 523 行定义.

{
    /* parameter check */
    RT_ASSERT(tick != 0);
 
    struct rt_thread *thread;
    void *stack_start;
 
    thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread,
                                                    name);
    if (thread == RT_NULL)
        return RT_NULL;
 
    stack_start = (void *)RT_KERNEL_MALLOC(stack_size);
    if (stack_start == RT_NULL)
    {
        /* allocate stack failure */
        rt_object_delete((rt_object_t)thread);
 
        return RT_NULL;
    }
 
    _thread_init(thread,
                 name,
                 entry,
                 parameter,
                 stack_start,
                 stack_size,
                 priority,
                 tick);
 
    return thread;
}

引用了 rt_thread::entry, rt_thread::parameter, RT_ASSERT, RT_KERNEL_MALLOC, RT_NULL, rt_object_allocate(), RT_Object_Class_Thread, rt_object_delete() , 以及 rt_thread::stack_size.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [6/18]

RTM_EXPORT ( rt_thread_create )

引用了 rt_thread_create().

函数调用图:

◆ rt_thread_delete()

rt_err_t rt_thread_delete ( rt_thread_t thread )

This function will delete a thread. The thread object will be removed from thread queue and deleted from system object management in the idle thread.

参数

thread is the thread to be deleted.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 572 行定义.

{
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
    RT_ASSERT(rt_object_is_systemobject((rt_object_t)thread) == RT_FALSE);
 
    return _thread_detach(thread);
}

引用了 RT_ASSERT, RT_FALSE, RT_NULL, RT_Object_Class_Thread, rt_object_get_type() , 以及 rt_object_is_systemobject().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [7/18]

RTM_EXPORT ( rt_thread_delete )

引用了 rt_thread_delete().

函数调用图:

◆ rt_thread_yield()

rt_err_t rt_thread_yield ( void )

This function will let current thread yield processor, and scheduler will choose the highest thread to run. After yield processor, the current thread is still in READY state.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 592 行定义.

{
    rt_sched_lock_level_t slvl;
    rt_sched_lock(&slvl);
 
    rt_sched_thread_yield(rt_thread_self());
 
    rt_sched_unlock_n_resched(slvl);
 
    return RT_EOK;
}

引用了 rt_sched_lock(), rt_sched_thread_yield(), rt_sched_unlock_n_resched() , 以及 rt_thread_self().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [8/18]

RTM_EXPORT ( rt_thread_yield )

引用了 rt_thread_yield().

函数调用图:

◆ rt_thread_delay()

rt_err_t rt_thread_delay ( rt_tick_t tick )

This function will let current thread delay for some ticks.

参数

tick	is the delay ticks.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 676 行定义.

{
    return _thread_sleep(tick);
}

这是这个函数的调用关系图:

◆ RTM_EXPORT() [9/18]

RTM_EXPORT ( rt_thread_delay )

引用了 rt_thread_delay().

函数调用图:

◆ rt_thread_delay_until()

rt_err_t rt_thread_delay_until	(	rt_tick_t *	tick,
		rt_tick_t	inc_tick )

This function will let current thread delay until (*tick + inc_tick).

参数

tick	is the tick of last wakeup.
inc_tick	is the increment tick.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 692 行定义.

{
    struct rt_thread *thread;
    rt_tick_t cur_tick;
    rt_base_t critical_level;
 
    RT_ASSERT(tick != RT_NULL);
 
    /* set to 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);
 
    /* reset thread error */
    thread->error = RT_EOK;
 
    /* disable interrupt */
    critical_level = rt_enter_critical();
 
    cur_tick = rt_tick_get();
    if (cur_tick - *tick < inc_tick)
    {
        rt_tick_t left_tick;
 
        *tick += inc_tick;
        left_tick = *tick - cur_tick;
 
        /* suspend thread */
        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
 
        /* reset the timeout of thread timer and start it */
        rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &left_tick);
        rt_timer_start(&(thread->thread_timer));
 
        rt_exit_critical_safe(critical_level);
 
        rt_schedule();
 
        /* clear error number of this thread to RT_EOK */
        if (thread->error == -RT_ETIMEOUT)
        {
            thread->error = RT_EOK;
        }
    }
    else
    {
        *tick = cur_tick;
        rt_exit_critical_safe(critical_level);
    }
 
    return thread->error;
}

引用了 rt_thread::error, RT_ASSERT, rt_enter_critical(), rt_exit_critical_safe(), RT_NULL, RT_Object_Class_Thread, rt_object_get_type(), rt_schedule(), rt_thread_self(), rt_thread_suspend_with_flag(), rt_tick_get(), rt_timer_control(), RT_TIMER_CTRL_SET_TIME, rt_timer_start(), RT_UNINTERRUPTIBLE , 以及 rt_thread::thread_timer.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [10/18]

RTM_EXPORT ( rt_thread_delay_until )

引用了 rt_thread_delay_until().

函数调用图:

◆ rt_thread_mdelay()

rt_err_t rt_thread_mdelay ( rt_int32_t ms )

This function will let current thread delay for some milliseconds.

参数

ms	is the delay ms time.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 754 行定义.

{
    rt_tick_t tick;
 
    tick = rt_tick_from_millisecond(ms);
 
    return _thread_sleep(tick);
}

引用了 rt_tick_from_millisecond().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [11/18]

RTM_EXPORT ( rt_thread_mdelay )

引用了 rt_thread_mdelay().

函数调用图:

◆ rt_thread_control()

rt_err_t rt_thread_control	(	rt_thread_t	thread,
		int	cmd,
		void *	arg )

This function will control thread behaviors according to control command.

参数

thread is the specified thread to be controlled.

cmd

is 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_BIND_CPU for bind the thread to a CPU.

arg is the argument of control command.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 787 行定义.

{
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
 
    switch (cmd)
    {
        case RT_THREAD_CTRL_CHANGE_PRIORITY:
        {
            rt_err_t error;
            rt_sched_lock_level_t slvl;
            rt_sched_lock(&slvl);
            error = rt_sched_thread_change_priority(thread, *(rt_uint8_t *)arg);
            rt_sched_unlock(slvl);
            return error;
        }
 
        case RT_THREAD_CTRL_STARTUP:
        {
            return rt_thread_startup(thread);
        }
 
        case RT_THREAD_CTRL_CLOSE:
        {
            rt_err_t rt_err = -RT_EINVAL;
 
            if (rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE)
            {
                rt_err = rt_thread_detach(thread);
            }
    #ifdef RT_USING_HEAP
            else
            {
                rt_err = rt_thread_delete(thread);
            }
    #endif /* RT_USING_HEAP */
            rt_schedule();
            return rt_err;
        }
 
        case RT_THREAD_CTRL_BIND_CPU:
        {
            rt_uint8_t cpu;
 
            cpu = (rt_uint8_t)(rt_size_t)arg;
            return rt_sched_thread_bind_cpu(thread, cpu);
        }
 
    default:
        break;
    }
 
    return RT_EOK;
}

引用了 rt_thread::error, RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_get_type(), rt_object_is_systemobject(), rt_sched_lock(), rt_sched_thread_change_priority(), rt_sched_unlock(), rt_schedule(), RT_THREAD_CTRL_BIND_CPU, RT_THREAD_CTRL_CHANGE_PRIORITY, RT_THREAD_CTRL_CLOSE, RT_THREAD_CTRL_STARTUP, rt_thread_delete(), rt_thread_detach(), rt_thread_startup() , 以及 RT_TRUE.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [12/18]

RTM_EXPORT ( rt_thread_control )

引用了 RT_INTERRUPTIBLE, RT_KILLABLE, RT_NULL, rt_thread_control(), RT_THREAD_SUSPEND_INTERRUPTIBLE, RT_THREAD_SUSPEND_KILLABLE, RT_THREAD_SUSPEND_UNINTERRUPTIBLE, RT_UNINTERRUPTIBLE , 以及 stat().

函数调用图:

◆ rt_thread_suspend_to_list()

rt_err_t rt_thread_suspend_to_list	(	rt_thread_t	thread,
		rt_list_t *	susp_list,
		int	ipc_flags,
		int	suspend_flag )

This function will suspend the specified thread and change it to suspend state.

注解: This function ONLY can suspend current thread itself. rt_thread_suspend(rt_thread_self());

Do not use the rt_thread_suspend to suspend other threads. You have no way of knowing what code a thread is executing when you suspend it. If you suspend a thread while sharing a resouce with other threads and occupying this resouce, starvation can occur very easily.

参数

thread	the thread to be suspended.
susp_list	the list thread enqueued to. RT_NULL if no list.
ipc_flags	is a flag for the thread object to be suspended. It determines how the thread is suspended. The flag can be ONE of the following values: RT_IPC_FLAG_PRIO The pending threads will queue in order of priority. RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method (also known as first-come-first-served (FCFS) scheduling strategy). NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about the first-in-first-out principle, and you clearly understand that all threads involved in this semaphore will become non-real-time threads.
suspend_flag	status flag of the thread to be suspended.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

enqueue thread on the push list before leaving critical region of scheduler, so we won't miss notification of async events.

在文件 thread.c 第 897 行定义.

{
    rt_base_t stat;
    rt_sched_lock_level_t slvl;
 
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
    RT_ASSERT(thread == rt_thread_self());
 
    LOG_D("thread suspend:  %s", thread->parent.name);
 
    rt_sched_lock(&slvl);
 
    stat = rt_sched_thread_get_stat(thread);
    if ((stat != RT_THREAD_READY) && (stat != RT_THREAD_RUNNING))
    {
        LOG_D("thread suspend: thread disorder, 0x%2x", thread->stat);
        rt_sched_unlock(slvl);
        return -RT_ERROR;
    }
 
    if (stat == RT_THREAD_RUNNING)
    {
        /* not suspend running status thread on other core */
        RT_ASSERT(thread == rt_thread_self());
    }
 
#ifdef RT_USING_SMART
    if (thread->lwp)
    {
        rt_sched_unlock(slvl);
 
        /* check pending signals for thread before suspend */
        if (lwp_thread_signal_suspend_check(thread, suspend_flag) == 0)
        {
            /* not to suspend */
            return -RT_EINTR;
        }
 
        rt_sched_lock(&slvl);
        if (stat == RT_THREAD_READY)
        {
            stat = rt_sched_thread_get_stat(thread);
 
            if (stat != RT_THREAD_READY)
            {
                /* status updated while we check for signal */
                rt_sched_unlock(slvl);
                return -RT_ERROR;
            }
        }
    }
#endif
 
    /* change thread stat */
    rt_sched_remove_thread(thread);
    _thread_set_suspend_state(thread, suspend_flag);
 
    if (susp_list)
    {
        rt_susp_list_enqueue(susp_list, thread, ipc_flags);
    }
 
    /* stop thread timer anyway */
    rt_sched_thread_timer_stop(thread);
 
    rt_sched_unlock(slvl);
 
    RT_OBJECT_HOOK_CALL(rt_thread_suspend_hook, (thread));
    return RT_EOK;
}

引用了 LOG_D, rt_object::name, rt_thread::parent, RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_get_type(), RT_OBJECT_HOOK_CALL, rt_sched_lock(), rt_sched_thread_get_stat(), rt_sched_thread_timer_stop(), rt_sched_unlock(), rt_susp_list_enqueue(), RT_THREAD_READY, RT_THREAD_RUNNING, rt_thread_self() , 以及 stat().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [13/18]

RTM_EXPORT ( rt_thread_suspend_to_list )

引用了 rt_thread_suspend_to_list().

函数调用图:

◆ rt_thread_suspend_with_flag()

rt_err_t rt_thread_suspend_with_flag	(	rt_thread_t	thread,
		int	suspend_flag )

This function will suspend the specified thread and change it to suspend state.

注解: This function ONLY can suspend current thread itself. rt_thread_suspend(rt_thread_self());

Do not use the rt_thread_suspend to suspend other threads. You have no way of knowing what code a thread is executing when you suspend it. If you suspend a thread while sharing a resouce with other threads and occupying this resouce, starvation can occur very easily.

参数

thread	the thread to be suspended.
suspend_flag	status flag of the thread to be suspended.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

在文件 thread.c 第 991 行定义.

{
    return rt_thread_suspend_to_list(thread, RT_NULL, 0, suspend_flag);
}

引用了 RT_NULL , 以及 rt_thread_suspend_to_list().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [14/18]

RTM_EXPORT ( rt_thread_suspend_with_flag )

引用了 rt_thread_suspend_with_flag().

函数调用图:

◆ rt_thread_suspend()

rt_err_t rt_thread_suspend ( rt_thread_t thread )

在文件 thread.c 第 997 行定义.

{
    return rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
}

引用了 rt_thread_suspend_with_flag() , 以及 RT_UNINTERRUPTIBLE.

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [15/18]

RTM_EXPORT ( rt_thread_suspend )

引用了 rt_thread_suspend().

函数调用图:

◆ rt_thread_resume()

rt_err_t rt_thread_resume ( rt_thread_t thread )

This function will resume a thread and put it to system ready queue.

参数

thread is the thread to be resumed.

返回: Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

RT_ESCHEDLOCKED indicates that the current thread is in a critical section, rather than 'thread' can't be resumed. Therefore, we can ignore this error.

在文件 thread.c 第 1011 行定义.

{
    rt_sched_lock_level_t slvl;
    rt_err_t error;
 
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
 
    LOG_D("thread resume: %s", thread->parent.name);
 
    rt_sched_lock(&slvl);
 
    error = rt_sched_thread_ready(thread);
 
    if (!error)
    {
        error = rt_sched_unlock_n_resched(slvl);
        if (error == -RT_ESCHEDLOCKED)
        {
            error = RT_EOK;
        }
    }
    else
    {
        rt_sched_unlock(slvl);
    }
 
    RT_OBJECT_HOOK_CALL(rt_thread_resume_hook, (thread));
 
    return error;
}

引用了 rt_thread::error, LOG_D, rt_object::name, rt_thread::parent, RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_get_type(), RT_OBJECT_HOOK_CALL, rt_sched_lock(), rt_sched_thread_ready(), rt_sched_unlock() , 以及 rt_sched_unlock_n_resched().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [16/18]

RTM_EXPORT ( rt_thread_resume )

引用了 RT_NULL, RT_Object_Class_Thread , 以及 rt_thread_resume().

函数调用图:

◆ rt_thread_find()

rt_thread_t rt_thread_find ( char * name )

This function will find the specified thread.

注解: Please don't invoke this function in interrupt status.

参数

name	is the name of thread finding.

返回: If the return value is a rt_thread structure pointer, the function is successfully executed. If the return value is RT_NULL, it means this operation failed.

在文件 thread.c 第 1108 行定义.

{
    return (rt_thread_t)rt_object_find(name, RT_Object_Class_Thread);
}

引用了 RT_Object_Class_Thread , 以及 rt_object_find().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [17/18]

RTM_EXPORT ( rt_thread_find )

引用了 rt_thread_find().

函数调用图:

◆ rt_thread_get_name()

rt_err_t rt_thread_get_name	(	rt_thread_t	thread,
		char *	name,
		rt_uint8_t	name_size )

This function will return the name of the specified thread

注解: Please don't invoke this function in interrupt status

参数

thread	the thread to retrieve thread name
name	buffer to store the thread name string
name_size	maximum size of the buffer to store the thread name

返回: If the return value is RT_EOK, the function is successfully executed If the return value is -RT_EINVAL, it means this operation failed

在文件 thread.c 第 1127 行定义.

{
    return (thread == RT_NULL) ? -RT_EINVAL : rt_object_get_name(&thread->parent, name, name_size);
}

引用了 rt_thread::parent, RT_NULL , 以及 rt_object_get_name().

函数调用图:

这是这个函数的调用关系图:

◆ RTM_EXPORT() [18/18]

RTM_EXPORT ( rt_thread_get_name )

引用了 rt_thread_get_name().

函数调用图:

◆ rt_thread_suspend_sethook()

void rt_thread_suspend_sethook ( void(* hook )(rt_thread_t thread) )

◆ rt_thread_resume_sethook()

void rt_thread_resume_sethook ( void(* hook )(rt_thread_t thread) )

◆ RT_OBJECT_HOOKLIST_DECLARE()

RT_OBJECT_HOOKLIST_DECLARE	(	rt_thread_inited_hookproto_t	,
		rt_thread_inited	)

◆ rt_thread_idle_init()

void rt_thread_idle_init ( void )

This function will initialize idle thread, then start it.

注解: this function must be invoked when system init.

在文件 idle.c 第 171 行定义.

{
    rt_ubase_t i;
#if RT_NAME_MAX > 0
    char idle_thread_name[RT_NAME_MAX];
#endif /* RT_NAME_MAX > 0 */
 
#ifdef RT_USING_IDLE_HOOK
    rt_spin_lock_init(&_hook_spinlock);
#endif
 
    for (i = 0; i < _CPUS_NR; i++)
    {
#if RT_NAME_MAX > 0
        rt_snprintf(idle_thread_name, RT_NAME_MAX, "tidle%d", i);
#endif /* RT_NAME_MAX > 0 */
        rt_thread_init(&idle_thread[i],
#if RT_NAME_MAX > 0
                idle_thread_name,
#else
                "tidle",
#endif /* RT_NAME_MAX > 0 */
                idle_thread_entry,
                RT_NULL,
                &idle_thread_stack[i][0],
                sizeof(idle_thread_stack[i]),
                RT_THREAD_PRIORITY_MAX - 1,
                32);
#ifdef RT_USING_SMP
        rt_thread_control(&idle_thread[i], RT_THREAD_CTRL_BIND_CPU, (void*)i);
#endif /* RT_USING_SMP */
 
        /* update */
        rt_cpu_index(i)->idle_thread = &idle_thread[i];
 
        /* startup */
        rt_thread_startup(&idle_thread[i]);
    }
}

引用了 _CPUS_NR, rt_cpu::idle_thread, rt_cpu_index(), RT_NULL, rt_spin_lock_init(), rt_thread_control(), RT_THREAD_CTRL_BIND_CPU, rt_thread_init() , 以及 rt_thread_startup().

函数调用图:

◆ rt_thread_idle_sethook()

rt_err_t rt_thread_idle_sethook ( void(* hook )(void) )

◆ rt_thread_idle_delhook()

rt_err_t rt_thread_idle_delhook ( void(* hook )(void) )

delete the idle hook on hook list.

参数

hook	the specified hook function.

返回: RT_EOK: delete OK. -RT_ENOSYS: hook was not found.

在文件 idle.c 第 101 行定义.

{
    rt_size_t i;
    rt_err_t ret = -RT_ENOSYS;
    rt_base_t level;
 
    level = rt_spin_lock_irqsave(&_hook_spinlock);
 
    for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
    {
        if (idle_hook_list[i] == hook)
        {
            idle_hook_list[i] = RT_NULL;
            ret = RT_EOK;
            break;
        }
    }
 
    rt_spin_unlock_irqrestore(&_hook_spinlock, level);
 
    return ret;
}

引用了 RT_IDLE_HOOK_LIST_SIZE, RT_NULL, rt_spin_lock_irqsave() , 以及 rt_spin_unlock_irqrestore().

函数调用图:

◆ rt_thread_idle_gethandler()

rt_thread_t rt_thread_idle_gethandler ( void )

This function will get the handler of the idle thread.

在文件 idle.c 第 214 行定义.

{
    int id = rt_cpu_get_id();
 
    return (rt_thread_t)(&idle_thread[id]);
}

引用了 rt_cpu_get_id.

◆ rt_system_scheduler_init()

void rt_system_scheduler_init ( void )

This function will initialize the system scheduler.

在文件 scheduler_mp.c 第 403 行定义.

{
    int cpu;
    rt_base_t offset;
 
    LOG_D("start scheduler: max priority 0x%02x",
          RT_THREAD_PRIORITY_MAX);
 
    rt_spin_lock_init(&_mp_scheduler_lock);
 
    for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
    {
        rt_list_init(&rt_thread_priority_table[offset]);
    }
 
    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]);
        }
 
        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 /* RT_THREAD_PRIORITY_MAX > 32 */
 
#ifdef RT_USING_SMART
        rt_spin_lock_init(&(pcpu->spinlock));
#endif
    }
 
    /* 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));
#endif /* RT_THREAD_PRIORITY_MAX > 32 */
}

引用了 rt_cpu::current_thread, LOG_D, rt_cpu_index(), rt_list_init(), RT_NULL, rt_spin_lock_init() , 以及 rt_thread_priority_table.

函数调用图:

◆ rt_system_scheduler_start()

void rt_system_scheduler_start ( void )

This function will startup the scheduler. It will select one thread with the highest priority level, then switch to it.

legacy rt_cpus_lock. some bsp codes still use it as for it's critical region. Since scheduler is never touching this, here we just release it on the entry.

for the accessing of the scheduler context. Noted that we don't have current_thread at this point

在文件 scheduler_mp.c 第 453 行定义.

{
    struct rt_thread *to_thread;
    rt_ubase_t highest_ready_priority;
    rt_hw_spin_unlock(&_cpus_lock);
 
    /* ISR will corrupt the coherency of running frame */
    rt_hw_local_irq_disable();
    _fast_spin_lock(&_mp_scheduler_lock);
 
    /* get the thread scheduling to */
    to_thread = _scheduler_get_highest_priority_thread(&highest_ready_priority);
    RT_ASSERT(to_thread);
 
    /* to_thread is picked to running on current core, so remove it from ready queue */
    _sched_remove_thread_locked(to_thread);
 
    /* dedigate current core to `to_thread` */
    RT_SCHED_CTX(to_thread).oncpu = rt_hw_cpu_id();
    RT_SCHED_CTX(to_thread).stat = RT_THREAD_RUNNING;
 
    LOG_D("[cpu#%d] switch to priority#%d thread:%.*s(sp:0x%08x)",
          rt_hw_cpu_id(), RT_SCHED_PRIV(to_thread).current_priority,
          RT_NAME_MAX, to_thread->parent.name, to_thread->sp);
 
    _fast_spin_unlock(&_mp_scheduler_lock);
 
    /* switch to new thread */
    rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp, to_thread);
 
    /* never come back */
}

引用了 _cpus_lock, _fast_spin_lock(), _fast_spin_unlock(), rt_cpu::current_thread, LOG_D, rt_object::name, rt_thread::parent, RT_ASSERT, rt_cpu_self(), rt_hw_context_switch_to(), rt_hw_cpu_id(), rt_hw_local_irq_disable, rt_hw_spin_unlock, RT_SCHED_CTX, RT_SCHED_PRIV, RT_THREAD_RUNNING , 以及 rt_thread::sp.

函数调用图:

◆ rt_schedule()

void rt_schedule ( void )

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.

注解: this function is implemented in both scheduler_up.c and scheduler_mp.c.

这是这个函数的调用关系图:

◆ rt_scheduler_do_irq_switch()

void rt_scheduler_do_irq_switch ( void * context )

This function checks whether a scheduling is needed after an IRQ context switching. If yes, it will select one thread with the highest priority level, and then switch to it.

参数

context is the context to be switched to.

注解: this function is only implemented in scheduler_mp.c.

◆ rt_enter_critical()

void rt_enter_critical ( void )

This function will lock the thread scheduler.

注解: this function is implemented in both scheduler_up.c and scheduler_mp.c.

这是这个函数的调用关系图:

◆ rt_exit_critical()

void rt_exit_critical ( void )

This function will unlock the thread scheduler.

注解: this function is implemented in both scheduler_up.c and scheduler_mp.c.

这是这个函数的调用关系图:

◆ rt_exit_critical_safe()

void rt_exit_critical_safe ( rt_base_t critical_level )

这是这个函数的调用关系图:

◆ rt_critical_level()

rt_uint16_t rt_critical_level ( void )

Get the scheduler lock level.

返回: the level of the scheduler lock. 0 means unlocked.

注解: this function is implemented in both scheduler_up.c and scheduler_mp.c.

这是这个函数的调用关系图:

◆ rt_scheduler_sethook()

void rt_scheduler_sethook ( void(* hook )(rt_thread_t from, rt_thread_t to) )

◆ rt_scheduler_switch_sethook()

void rt_scheduler_switch_sethook ( void(* hook )(struct rt_thread *tid) )

◆ rt_scheduler_ipi_handler()

void rt_scheduler_ipi_handler	(	int	vector,
		void *	param )

This function will handle IPI interrupt and do a scheduling in system.

参数

vector	is the number of IPI interrupt for system scheduling.
param	is not used, and can be set to RT_NULL.

注解: this function should be invoke or register as ISR in BSP.; this function is only implemented in scheduler_mp.c.

◆ rt_schedule_insert_thread()

void rt_schedule_insert_thread ( struct rt_thread * thread )

This function will insert a thread to the system ready queue. The state of thread will be set as READY and the thread will be removed from suspend queue.

参数

thread is the thread to be inserted.

注解: Please do not invoke this function in user application.; this function is implemented in both scheduler_up.c and scheduler_mp.c.

◆ rt_schedule_remove_thread()

void rt_schedule_remove_thread ( struct rt_thread * thread )

This function will remove a thread from system ready queue.

参数

thread is the thread to be removed.

注解: Please do not invoke this function in user application.; this function is implemented in both scheduler_up.c and scheduler_mp.c.

结构体

宏定义

类型定义

枚举

函数

详细描述

宏定义说明

◆ RT_THREAD_INIT

◆ RT_THREAD_CLOSE

◆ RT_THREAD_READY

◆ RT_THREAD_RUNNING

◆ RT_THREAD_SUSPEND_MASK

◆ RT_SIGNAL_COMMON_WAKEUP_MASK

◆ RT_SIGNAL_KILL_WAKEUP_MASK

◆ RT_THREAD_SUSPEND_INTERRUPTIBLE

◆ RT_THREAD_SUSPEND

◆ RT_THREAD_SUSPEND_KILLABLE

◆ RT_THREAD_SUSPEND_UNINTERRUPTIBLE

◆ RT_THREAD_STAT_MASK

◆ RT_THREAD_STAT_YIELD

◆ RT_THREAD_STAT_YIELD_MASK

◆ RT_THREAD_STAT_SIGNAL

◆ RT_THREAD_STAT_SIGNAL_READY

◆ RT_THREAD_STAT_SIGNAL_WAIT

◆ RT_THREAD_STAT_SIGNAL_PENDING

◆ RT_THREAD_STAT_SIGNAL_MASK

◆ RT_THREAD_CTRL_STARTUP

◆ RT_THREAD_CTRL_CLOSE

◆ RT_THREAD_CTRL_CHANGE_PRIORITY

◆ RT_THREAD_CTRL_INFO

◆ RT_THREAD_CTRL_BIND_CPU

◆ rt_current_thread

◆ LWP_IS_USER_MODE

◆ RT_SCHEDULER_STACK_CHECK

类型定义说明

◆ rt_cpu_usage_stats_t

◆ rt_cpu_t

◆ rt_interrupt_context_t

◆ rt_thread_cleanup_t

◆ rt_thread_t

◆ rt_thread_inited_hookproto_t

枚举类型说明

◆ anonymous enum

函数说明

◆ rt_thread_init()

◆ RTM_EXPORT() [1/18]

◆ rt_thread_self()

◆ RTM_EXPORT() [2/18]

◆ rt_thread_startup()

◆ RTM_EXPORT() [3/18]

◆ rt_thread_close()

◆ RTM_EXPORT() [4/18]

◆ rt_thread_detach()

◆ RTM_EXPORT() [5/18]

◆ rt_thread_create()

◆ RTM_EXPORT() [6/18]

◆ rt_thread_delete()

◆ RTM_EXPORT() [7/18]

◆ rt_thread_yield()

◆ RTM_EXPORT() [8/18]

◆ rt_thread_delay()

◆ RTM_EXPORT() [9/18]

◆ rt_thread_delay_until()

◆ RTM_EXPORT() [10/18]

◆ rt_thread_mdelay()

◆ RTM_EXPORT() [11/18]

◆ rt_thread_control()

◆ RTM_EXPORT() [12/18]

◆ rt_thread_suspend_to_list()

◆ RTM_EXPORT() [13/18]

◆ rt_thread_suspend_with_flag()

◆ RTM_EXPORT() [14/18]

◆ rt_thread_suspend()

◆ RTM_EXPORT() [15/18]

◆ rt_thread_resume()

◆ RTM_EXPORT() [16/18]

◆ rt_thread_find()

◆ RTM_EXPORT() [17/18]

◆ rt_thread_get_name()

◆ RTM_EXPORT() [18/18]