scheduler.c 25.9 KB
Newer Older
1
/*
2
 * Copyright (c) 2006-2018, RT-Thread Development Team
B
Bernard Xiong 已提交
3
 *
4
 * SPDX-License-Identifier: Apache-2.0
5 6 7 8 9 10
 *
 * Change Logs:
 * Date           Author       Notes
 * 2006-03-17     Bernard      the first version
 * 2006-04-28     Bernard      fix the scheduler algorthm
 * 2006-04-30     Bernard      add SCHEDULER_DEBUG
11 12
 * 2006-05-27     Bernard      fix the scheduler algorthm for same priority
 *                             thread schedule
13 14 15 16 17
 * 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
18
 * 2010-04-11     yi.qiu       add module feature
19
 * 2010-07-13     Bernard      fix the maximal number of rt_scheduler_lock_nest
20
 *                             issue found by kuronca
21
 * 2010-12-13     Bernard      add defunct list initialization even if not use heap.
B
bernard.xiong@gmail.com 已提交
22
 * 2011-05-10     Bernard      clean scheduler debug log.
23
 * 2013-12-21     Grissiom     add rt_critical_level
S
shaojinchun 已提交
24 25 26 27 28 29 30
 * 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
 *
31 32 33 34 35
 */

#include <rtthread.h>
#include <rthw.h>

S
shaojinchun 已提交
36 37 38
#ifdef RT_USING_SMP
rt_hw_spinlock_t _rt_critical_lock;
#endif /*RT_USING_SMP*/
39 40

rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];
S
shaojinchun 已提交
41
rt_uint32_t rt_thread_ready_priority_group;
42
#if RT_THREAD_PRIORITY_MAX > 32
43
/* Maximum priority level, 256 */
44 45 46
rt_uint8_t rt_thread_ready_table[32];
#endif

S
shaojinchun 已提交
47 48 49 50 51 52 53
#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*/

54 55 56
rt_list_t rt_thread_defunct;

#ifdef RT_USING_HOOK
D
dzzxzz 已提交
57
static void (*rt_scheduler_hook)(struct rt_thread *from, struct rt_thread *to);
58 59 60 61

/**
 * @addtogroup Hook
 */
D
dzzxzz 已提交
62

D
dogandog 已提交
63
/**@{*/
64 65 66 67 68 69 70

/**
 * This function will set a hook function, which will be invoked when thread
 * switch happens.
 *
 * @param hook the hook function
 */
71 72
void
rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread *to))
73
{
74
    rt_scheduler_hook = hook;
75 76
}

D
dogandog 已提交
77
/**@}*/
78 79 80
#endif

#ifdef RT_USING_OVERFLOW_CHECK
D
dzzxzz 已提交
81
static void _rt_scheduler_stack_check(struct rt_thread *thread)
82
{
83 84
    RT_ASSERT(thread != RT_NULL);

Z
zhaohengbo 已提交
85 86 87
#if defined(ARCH_CPU_STACK_GROWS_UPWARD)
	if (*((rt_uint8_t *)((rt_ubase_t)thread->stack_addr + thread->stack_size - 1)) != '#' ||
#else
A
Aubr.Cool 已提交
88
    if (*((rt_uint8_t *)thread->stack_addr) != '#' ||
Z
zhaohengbo 已提交
89
#endif
B
Bernard Xiong 已提交
90 91 92
        (rt_ubase_t)thread->sp <= (rt_ubase_t)thread->stack_addr ||
        (rt_ubase_t)thread->sp >
        (rt_ubase_t)thread->stack_addr + (rt_ubase_t)thread->stack_size)
93
    {
B
Bernard Xiong 已提交
94
        rt_ubase_t level;
95 96

        rt_kprintf("thread:%s stack overflow\n", thread->name);
97
#ifdef RT_USING_FINSH
98 99 100 101
        {
            extern long list_thread(void);
            list_thread();
        }
102
#endif
103 104 105
        level = rt_hw_interrupt_disable();
        while (level);
    }
106 107 108 109 110 111 112
#if defined(ARCH_CPU_STACK_GROWS_UPWARD)
    else if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size))
    {
        rt_kprintf("warning: %s stack is close to the top of stack address.\n",
                   thread->name);
    }
#else
S
shaojinchun 已提交
113
    else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32))
114
    {
S
shaojinchun 已提交
115
        rt_kprintf("warning: %s stack is close to end of stack address.\n",
116 117
                   thread->name);
    }
118
#endif
S
shaojinchun 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
}
#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;
146
#else
S
shaojinchun 已提交
147 148 149 150 151 152
    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)
153
    {
S
shaojinchun 已提交
154 155 156 157 158 159 160 161 162 163 164
        *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);
165
    }
S
shaojinchun 已提交
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181

    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;
182
#endif
S
shaojinchun 已提交
183 184 185 186 187 188 189 190 191

    /* 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;
192 193 194 195 196
}
#endif

/**
 * @ingroup SystemInit
B
bernard.xiong@gmail.com 已提交
197
 * This function will initialize the system scheduler
198 199 200
 */
void rt_system_scheduler_init(void)
{
S
shaojinchun 已提交
201 202 203
#ifdef RT_USING_SMP
    int cpu;
#endif /*RT_USING_SMP*/
204
    register rt_base_t offset;
205

S
shaojinchun 已提交
206
#ifndef RT_USING_SMP
207
    rt_scheduler_lock_nest = 0;
S
shaojinchun 已提交
208
#endif /*RT_USING_SMP*/
209

210
    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n",
211
                                      RT_THREAD_PRIORITY_MAX));
B
bernard.xiong@gmail.com 已提交
212

213 214 215 216
    for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
    {
        rt_list_init(&rt_thread_priority_table[offset]);
    }
S
shaojinchun 已提交
217 218 219 220 221 222 223 224
#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]);
        }
225

S
shaojinchun 已提交
226 227 228 229 230 231 232 233 234 235
        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*/
236

237 238
    /* initialize ready priority group */
    rt_thread_ready_priority_group = 0;
239 240

#if RT_THREAD_PRIORITY_MAX > 32
241 242
    /* initialize ready table */
    rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table));
243 244
#endif

245 246
    /* initialize thread defunct */
    rt_list_init(&rt_thread_defunct);
247 248 249
}

/**
250
 * @ingroup SystemInit
251 252 253
 * This function will startup scheduler. It will select one thread
 * with the highest priority level, then switch to it.
 */
D
dzzxzz 已提交
254
void rt_system_scheduler_start(void)
255
{
256
    register struct rt_thread *to_thread;
S
shaojinchun 已提交
257
    rt_ubase_t highest_ready_priority;
258

S
shaojinchun 已提交
259
    to_thread = _get_highest_priority_thread(&highest_ready_priority);
260

S
shaojinchun 已提交
261 262
#ifdef RT_USING_SMP
    to_thread->oncpu = rt_hw_cpu_id();
263
#else
264
    rt_current_thread = to_thread;
S
shaojinchun 已提交
265 266 267
#endif /*RT_USING_SMP*/

    rt_schedule_remove_thread(to_thread);
268
    to_thread->stat = RT_THREAD_RUNNING;
269

270
    /* switch to new thread */
S
shaojinchun 已提交
271
#ifdef RT_USING_SMP
272
    rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp, to_thread);
S
shaojinchun 已提交
273
#else
274
    rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp);
S
shaojinchun 已提交
275
#endif /*RT_USING_SMP*/
276

277
    /* never come back */
278 279 280 281 282
}

/**
 * @addtogroup Thread
 */
D
dzzxzz 已提交
283

D
dogandog 已提交
284
/**@{*/
285

S
shaojinchun 已提交
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314

#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 */
315
    level  = rt_hw_interrupt_disable();
S
shaojinchun 已提交
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333

    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;
334
            if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
S
shaojinchun 已提交
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
            {
                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);
354
                to_thread->stat = RT_THREAD_RUNNING;
S
shaojinchun 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394

                /* 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)&current_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
395 396 397 398
/**
 * This function will perform one schedule. It will select one thread
 * with the highest priority level, then switch to it.
 */
D
dzzxzz 已提交
399
void rt_schedule(void)
400
{
401 402 403
    rt_base_t level;
    struct rt_thread *to_thread;
    struct rt_thread *from_thread;
404

405 406
    /* disable interrupt */
    level = rt_hw_interrupt_disable();
407

408 409 410
    /* check the scheduler is enabled or not */
    if (rt_scheduler_lock_nest == 0)
    {
S
shaojinchun 已提交
411
        rt_ubase_t highest_ready_priority;
412

S
shaojinchun 已提交
413 414 415
        if (rt_thread_ready_priority_group != 0)
        {
            int need_insert_from_thread = 0;
416

S
shaojinchun 已提交
417
            to_thread = _get_highest_priority_thread(&highest_ready_priority);
418

419
            if ((rt_current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
S
shaojinchun 已提交
420 421 422 423 424 425 426 427 428 429
            {
                if (rt_current_thread->current_priority < highest_ready_priority)
                {
                    to_thread = rt_current_thread;
                }
                else
                {
                    need_insert_from_thread = 1;
                }
            }
430

S
shaojinchun 已提交
431 432 433 434 435 436 437 438
            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));
439

S
shaojinchun 已提交
440 441 442 443
                if (need_insert_from_thread)
                {
                    rt_schedule_insert_thread(from_thread);
                }
444

S
shaojinchun 已提交
445
                rt_schedule_remove_thread(to_thread);
446
                to_thread->stat = RT_THREAD_RUNNING;
S
shaojinchun 已提交
447 448 449 450

                /* switch to new thread */
                RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
                        ("[%d]switch to priority#%d "
B
Bernard Xiong 已提交
451 452
                         "thread:%.*s(sp:0x%08x), "
                         "from thread:%.*s(sp: 0x%08x)\n",
S
shaojinchun 已提交
453 454 455
                         rt_interrupt_nest, highest_ready_priority,
                         RT_NAME_MAX, to_thread->name, to_thread->sp,
                         RT_NAME_MAX, from_thread->name, from_thread->sp));
456

457
#ifdef RT_USING_OVERFLOW_CHECK
S
shaojinchun 已提交
458
                _rt_scheduler_stack_check(to_thread);
459 460
#endif

S
shaojinchun 已提交
461 462 463
                if (rt_interrupt_nest == 0)
                {
                    extern void rt_thread_handle_sig(rt_bool_t clean_state);
B
bernard 已提交
464

S
shaojinchun 已提交
465 466
                    rt_hw_context_switch((rt_ubase_t)&from_thread->sp,
                            (rt_ubase_t)&to_thread->sp);
B
bernard 已提交
467

S
shaojinchun 已提交
468 469
                    /* enable interrupt */
                    rt_hw_interrupt_enable(level);
B
bernard 已提交
470 471

#ifdef RT_USING_SIGNALS
S
shaojinchun 已提交
472 473
                    /* check signal status */
                    rt_thread_handle_sig(RT_TRUE);
B
bernard 已提交
474
#endif
S
shaojinchun 已提交
475 476 477 478 479 480 481 482 483
                    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);
                }
484 485 486
            }
            else
            {
S
shaojinchun 已提交
487
                rt_schedule_remove_thread(rt_current_thread);
488
                rt_current_thread->stat = RT_THREAD_RUNNING;
489 490 491
            }
        }
    }
S
shaojinchun 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521

    /* 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)
armink_ztl's avatar
armink_ztl 已提交
522 523
    {
        rt_hw_interrupt_enable(level);
S
shaojinchun 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537
        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;
538
            if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
S
shaojinchun 已提交
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
            {
                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);
559
                to_thread->stat = RT_THREAD_RUNNING;
S
shaojinchun 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572

#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)&current_thread->sp,
                        (rt_ubase_t)&to_thread->sp, to_thread);
            }
        }
armink_ztl's avatar
armink_ztl 已提交
573
    }
S
shaojinchun 已提交
574
    rt_hw_interrupt_enable(level);
575
}
S
shaojinchun 已提交
576
#endif /*RT_USING_SMP*/
577

B
bernard.xiong@gmail.com 已提交
578
/*
579 580 581 582 583 584
 * This function will insert a thread to system ready queue. The state of
 * thread will be set as READY and remove from suspend queue.
 *
 * @param thread the thread to be inserted
 * @note Please do not invoke this function in user application.
 */
S
shaojinchun 已提交
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
#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);
S
shaojinchun 已提交
620
        rt_hw_ipi_send(RT_SCHEDULE_IPI, cpu_mask);
S
shaojinchun 已提交
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
    }
    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;
S
shaojinchun 已提交
637
            rt_hw_ipi_send(RT_SCHEDULE_IPI, cpu_mask);
S
shaojinchun 已提交
638 639 640 641 642 643 644 645 646 647 648
        }
    }

    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
D
dzzxzz 已提交
649
void rt_schedule_insert_thread(struct rt_thread *thread)
650
{
651
    register rt_base_t temp;
652

653
    RT_ASSERT(thread != RT_NULL);
654

655 656
    /* disable interrupt */
    temp = rt_hw_interrupt_disable();
657

658
    /* change stat */
659
    thread->stat = RT_THREAD_READY | (thread->stat & ~RT_THREAD_STAT_MASK);
660

S
shaojinchun 已提交
661 662 663 664 665
    if (thread == rt_current_thread)
    {
        goto __exit;
    }

666 667 668
    /* insert thread to ready list */
    rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),
                          &(thread->tlist));
669

G
Grissiom 已提交
670 671
    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%.*s], the priority: %d\n",
                                      RT_NAME_MAX, thread->name, thread->current_priority));
672

S
shaojinchun 已提交
673
    /* set priority mask */
674
#if RT_THREAD_PRIORITY_MAX > 32
675
    rt_thread_ready_table[thread->number] |= thread->high_mask;
676
#endif
677
    rt_thread_ready_priority_group |= thread->number_mask;
678

S
shaojinchun 已提交
679
__exit:
680 681
    /* enable interrupt */
    rt_hw_interrupt_enable(temp);
682
}
S
shaojinchun 已提交
683
#endif /*RT_USING_SMP*/
684

B
bernard.xiong@gmail.com 已提交
685
/*
686 687 688 689 690 691
 * This function will remove a thread from system ready queue.
 *
 * @param thread the thread to be removed
 *
 * @note Please do not invoke this function in user application.
 */
S
shaojinchun 已提交
692
#ifdef RT_USING_SMP
D
dzzxzz 已提交
693
void rt_schedule_remove_thread(struct rt_thread *thread)
694
{
S
shaojinchun 已提交
695
    register rt_base_t level;
696

697
    RT_ASSERT(thread != RT_NULL);
698

699
    /* disable interrupt */
S
shaojinchun 已提交
700
    level = rt_hw_interrupt_disable();
701

G
Grissiom 已提交
702 703 704
    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%.*s], the priority: %d\n",
                                      RT_NAME_MAX, thread->name,
                                      thread->current_priority));
S
shaojinchun 已提交
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734

    /* 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;
            }
735
#else
S
shaojinchun 已提交
736
            pcpu->priority_group &= ~thread->number_mask;
737
#endif
S
shaojinchun 已提交
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
        }
    }

    /* 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));
757

758 759 760 761
    /* remove thread from ready list */
    rt_list_remove(&(thread->tlist));
    if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority])))
    {
762
#if RT_THREAD_PRIORITY_MAX > 32
763 764 765 766 767
        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;
        }
768
#else
769
        rt_thread_ready_priority_group &= ~thread->number_mask;
770
#endif
771
    }
772

773
    /* enable interrupt */
S
shaojinchun 已提交
774
    rt_hw_interrupt_enable(level);
775
}
S
shaojinchun 已提交
776
#endif /*RT_USING_SMP*/
777 778 779 780

/**
 * This function will lock the thread scheduler.
 */
S
shaojinchun 已提交
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
#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
D
dzzxzz 已提交
809
void rt_enter_critical(void)
810
{
811
    register rt_base_t level;
812

813 814
    /* disable interrupt */
    level = rt_hw_interrupt_disable();
815

816 817 818 819 820
    /*
     * the maximal number of nest is RT_UINT16_MAX, which is big
     * enough and does not check here
     */
    rt_scheduler_lock_nest ++;
821

822 823
    /* enable interrupt */
    rt_hw_interrupt_enable(level);
824
}
S
shaojinchun 已提交
825
#endif /*RT_USING_SMP*/
B
Bernard Xiong 已提交
826
RTM_EXPORT(rt_enter_critical);
827 828 829 830

/**
 * This function will unlock the thread scheduler.
 */
S
shaojinchun 已提交
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
#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
D
dzzxzz 已提交
864
void rt_exit_critical(void)
865
{
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
    register rt_base_t level;

    /* disable interrupt */
    level = rt_hw_interrupt_disable();

    rt_scheduler_lock_nest --;

    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);
    }
886
}
S
shaojinchun 已提交
887
#endif /*RT_USING_SMP*/
B
Bernard Xiong 已提交
888
RTM_EXPORT(rt_exit_critical);
889

890 891 892 893 894 895 896
/**
 * Get the scheduler lock level
 *
 * @return the level of the scheduler lock. 0 means unlocked.
 */
rt_uint16_t rt_critical_level(void)
{
S
shaojinchun 已提交
897 898 899 900 901 902 903
#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*/
904
}
B
Bernard Xiong 已提交
905
RTM_EXPORT(rt_critical_level);
906

S
shaojinchun 已提交
907
/**@}*/