FreeRTOS 优先级翻转与互斥信号量（二）

优先级翻转简介：

就是高优先级的任务运行起来的效果好像成了低优先级，而低优先级比高优先级先运行。

优先级翻转如下所示：

优先级翻转过程：

为什么会发生优先级翻转？

因为两个任务（L和H）使用了同一个二值信号量，而在这两个任务之间，又有一个中等优先级的任务M，在这种情况下就容易发生优先级翻转。主要就是因为二值信号量产生的，低优先级任务L占用了信号量没有释放，导致高优先级任务请求信号量时无效，此时高优先级任务无法运行。

实验设计

总体思路是，任务L和任务H都请求信号量，当接收到信号量时，任务H立马释放信号量，而任务L做软件延时占用一段时间后再释放信号量，看程序的执行流程。测试代码如下所示：

/*
 * FreeRTOS Kernel V10.2.1
 * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * http://www.FreeRTOS.org
 * http://aws.amazon.com/freertos
 *
 * 1 tab == 4 spaces!
 */

/* FreeRTOS kernel includes. */
#include <FreeRTOS.h>
#include <task.h>
#include <semphr.h>
#include "os.h"

/******************************************************************************
 * This project provides two demo applications.  A simple blinky style project,
 * and a more comprehensive test and demo application.  The
 * mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting (defined in this file) is used to
 * select between the two.  The simply blinky demo is implemented and described
 * in main_blinky.c.  The more comprehensive test and demo application is
 * implemented and described in main_full.c.
 *
 * This file implements the code that is not demo specific, including the
 * hardware setup and standard FreeRTOS hook functions.
 *
 * ENSURE TO READ THE DOCUMENTATION PAGE FOR THIS PORT AND DEMO APPLICATION ON
 * THE http://www.FreeRTOS.org WEB SITE FOR FULL INFORMATION ON USING THIS DEMO
 * APPLICATION, AND ITS ASSOCIATE FreeRTOS ARCHITECTURE PORT!
 *
 *
 * NOTE 1:
 *
 * This project has only been tested in the QEMU emulation of the HiFive board
 * from SiFive.
 *
 * Start QEMU using the following command line:
 *
 * [your_path_1]\qemu-system-riscv32 -kernel [your_path_2]\FreeRTOS\Demo\RISC-V-Qemu-sifive_e-FreedomStudio\Debug\RTOSDemo.elf -S -s -machine sifive_e
 *
 * Where [your_path_1] must be replaced with the correct path to your QEMU
 * installation and the elf file generated by this project respectively.
 *
 *
 * NOTE 2:
 *
 * Start GDB using the following command line (this can be entered in the
 * Eclipse Debug Launch Configuration dialogue):
 *
 * riscv64-unknown-elf-gdb.exe -iex "set mem inaccessible-by-default off" -iex "set arch riscv:rv32" -iex "set riscv use_compressed_breakpoint off"
 *
 *
 * Note 3:
 *
 * Status information is sent to the QEMU serial console.
 */

/* Prototypes for the standard FreeRTOS callback/hook functions implemented
within this file.  See https://www.freertos.org/a00016.html */
void vApplicationMallocFailedHook( void );
void vApplicationIdleHook( void );
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName );
void vApplicationTickHook( void );
void start_task(void *pvParameters);
void low_task(void *pvParameters);
void middle_task(void *pvParameters);
void high_task(void *pvParameters);

/* 任务相关参数 */
//#define START_TASK_SIZE     (configMINIMAL_STACK_SIZE * 2U)
#define START_TASK_SIZE     256
#define START_TASK_PRIO     1
TaskHandle_t start_Task_Handle;

#define LOW_TASK_SIZE       256
#define LOW_TASK_PRIO       2
TaskHandle_t low_task_Handle;

#define MIDDLE_TASK_SIZE    256
#define MIDDLE_TASK_PRIO    3
TaskHandle_t middle_task_Handle;

#define HIGH_TASK_SIZE      256
#define HIGH_TASK_PRIO      4
TaskHandle_t high_task_Handle;

SemaphoreHandle_t binary_semphr = NULL;   // 二值信号量句柄

int main(void)
{
  uart_init();
  uart_puts("Hello, FreeRTOS!\n");
  plic_init();
 

  // 创建开始任务
  xTaskCreate((TaskFunction_t )start_task,
              (char *         )"start_task",
              (uint16_t       )START_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )START_TASK_PRIO,
              (TaskHandle_t * )&start_Task_Handle);

  vTaskStartScheduler(); // 开启调度器
}

void start_task(void *pvParameters)
{
  uart_puts("start task!\n");
  taskENTER_CRITICAL();

  binary_semphr = xSemaphoreCreateBinary();  // 创建信号量
  if (binary_semphr != NULL)
  {
    printf("\n二值信号量创建成功");
    xSemaphoreGive(binary_semphr);    // 释放信号量
  }
  else
  {
    printf("\n二值信号量创建失败");
  }

  // 创建低优先级任务
  xTaskCreate((TaskFunction_t )low_task,
              (char *         )"low_task",
              (uint16_t       )LOW_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )LOW_TASK_PRIO,
              (TaskHandle_t * )&low_task_Handle);
  // 创建中优先级任务
  xTaskCreate((TaskFunction_t )middle_task,
              (char *         )"middle_task",
              (uint16_t       )MIDDLE_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )MIDDLE_TASK_PRIO,
              (TaskHandle_t * )&middle_task_Handle);
  // 创建高优先级任务
  xTaskCreate((TaskFunction_t )high_task,
              (char *         )"high_task",
              (uint16_t       )HIGH_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )HIGH_TASK_PRIO,
              (TaskHandle_t * )&high_task_Handle);
  taskEXIT_CRITICAL();
  // 删除开始任务
  vTaskDelete(start_Task_Handle);
}

void low_task(void *pvParameters)
{
  BaseType_t error_state;
  uint32_t limit;
  for (;;)
  {
    if (binary_semphr != NULL)
    {
      // 一直等待二值信号量
      error_state = xSemaphoreTake(binary_semphr, portMAX_DELAY);   
      if (error_state == pdTRUE)
      {
        printf("\n低优先级任务获取到信号量，正在占用...");
      }
      else
      {
        printf("\n低优先级任务获取信号量失败");
      }
      #if 1
      // 模拟低优先级占用信号量
      for (limit = 0; limit < 5000000; limit++)
      {
        taskYIELD();      // 一直调用任务切换 
      }
      #else
      HAL_Delay(8000);
      #endif
      // 释放二值信号量
      printf("\n低优先级任务占用信号量结束，即将释放");
      xSemaphoreGive(binary_semphr);
    }
    vTaskDelay(500);
  }
}

void middle_task(void *pvParameters)
{
  for (;;)
  {
    printf("\n中优先级任务正在运行");
    vTaskDelay(1000);
  }
}

void high_task(void *pvParameters)
{
  for (;;)
  {
    if (binary_semphr != NULL)
    {
      printf("\n高优先级任务正在等待信号量...");
      // 一直等待二值信号量
      xSemaphoreTake(binary_semphr, portMAX_DELAY);   
      printf("\n高优先级任务获取到信号量，即将释放...");
      xSemaphoreGive(binary_semphr);    // 释放信号量
    }
    vTaskDelay(1000);
  }
}
/*-----------------------------------------------------------*/

void vApplicationMallocFailedHook( void )
{
        /* vApplicationMallocFailedHook() will only be called if
        configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h.  It is a hook
        function that will get called if a call to pvPortMalloc() fails.
        pvPortMalloc() is called internally by the kernel whenever a task, queue,
        timer or semaphore is created.  It is also called by various parts of the
        demo application.  If heap_1.c or heap_2.c are used, then the size of the
        heap available to pvPortMalloc() is defined by configTOTAL_HEAP_SIZE in
        FreeRTOSConfig.h, and the xPortGetFreeHeapSize() API function can be used
        to query the size of free heap space that remains (although it does not
        provide information on how the remaining heap might be fragmented). */
        taskDISABLE_INTERRUPTS();
        for( ;; );
}
/*-----------------------------------------------------------*/

void vApplicationIdleHook( void )
{
        /* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set
        to 1 in FreeRTOSConfig.h.  It will be called on each iteration of the idle
        task.  It is essential that code added to this hook function never attempts
        to block in any way (for example, call xQueueReceive() with a block time
        specified, or call vTaskDelay()).  If the application makes use of the
        vTaskDelete() API function (as this demo application does) then it is also
        important that vApplicationIdleHook() is permitted to return to its calling
        function, because it is the responsibility of the idle task to clean up
        memory allocated by the kernel to any task that has since been deleted. */
}
/*-----------------------------------------------------------*/

void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
{
        ( void ) pcTaskName;
        ( void ) pxTask;

        /* Run time stack overflow checking is performed if
        configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2.  This hook
        function is called if a stack overflow is detected. */
        taskDISABLE_INTERRUPTS();
        for( ;; );
}
/*-----------------------------------------------------------*/

void vApplicationTickHook( void )
{
}
/*-----------------------------------------------------------*/

void vAssertCalled( void )
{
volatile uint32_t ulSetTo1ToExitFunction = 0;

        taskDISABLE_INTERRUPTS();
        while( ulSetTo1ToExitFunction != 1 )
        {
                __asm volatile( "NOP" );
        }
}

qemu-system-riscv64 -M virt -kernel build/FreeRTOS-simple.elf.bin -bios none -serial stdio -display none
Hello, FreeRTOS!
start task!

二值信号量创建成功
低优先级任务获取到信号量，正在占用...
低优先级任务占用信号量结束，即将释放
中优先级任务正在运行
高优先级任务正在等待信号量...
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
中优先级任务正在运行
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
中优先级任务正在运行
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
中优先级任务正在运行
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
中优先级任务正在运行
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
中优先级任务正在运行
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行
中优先级任务正在运行

互斥信号量

互斥信号量简介：

创建互斥信号量：

测试实验：修改上一个优先级翻转的实验，看测试结果。

修改过程：将使用二值信号量的地方修改成使用互斥信号量。

修改如下：

void start_task(void *pvParameters)
{
  uart_puts("start task!\n");
  taskENTER_CRITICAL();

  mutex_semphr = xSemaphoreCreateMutex();  // 创建信号量
  if (mutex_semphr != NULL)
  {
    printf("\n mutex信号量创建成功");
    xSemaphoreGive(mutex_semphr);    // 释放信号量
  }
  else
  {
    printf("\n mutex信号量创建失败");
  }

  // 创建低优先级任务
  xTaskCreate((TaskFunction_t )low_task,
              (char *         )"low_task",
              (uint16_t       )LOW_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )LOW_TASK_PRIO,
              (TaskHandle_t * )&low_task_Handle);
  // 创建中优先级任务
  xTaskCreate((TaskFunction_t )middle_task,
              (char *         )"middle_task",
              (uint16_t       )MIDDLE_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )MIDDLE_TASK_PRIO,
              (TaskHandle_t * )&middle_task_Handle);
  // 创建高优先级任务
  xTaskCreate((TaskFunction_t )high_task,
              (char *         )"high_task",
              (uint16_t       )HIGH_TASK_SIZE,
              (void *         )NULL,
              (UBaseType_t    )HIGH_TASK_PRIO,
              (TaskHandle_t * )&high_task_Handle);
  taskEXIT_CRITICAL();
  // 删除开始任务
  vTaskDelete(start_Task_Handle);
}

void low_task(void *pvParameters)
{
  BaseType_t error_state;
  uint32_t limit;
  for (;;)
  {
    if (mutex_semphr != NULL)
    {
      // 一直等待二值信号量
      error_state = xSemaphoreTake(mutex_semphr, portMAX_DELAY);   
      if (error_state == pdTRUE)
      {
        printf("\n低优先级任务获取到信号量，正在占用...");
      }
      else
      {
        printf("\n低优先级任务获取信号量失败");
      }
      #if 1
      // 模拟低优先级占用信号量
      for (limit = 0; limit < 5000000; limit++)
      {
        taskYIELD();      // 一直调用任务切换 
      }
      #else
      HAL_Delay(8000);
      #endif
      // 释放二值信号量
      printf("\n低优先级任务占用信号量结束，即将释放");
      xSemaphoreGive(mutex_semphr);
    }
    vTaskDelay(500);
  }
}

void middle_task(void *pvParameters)
{
  for (;;)
  {
    printf("\n中优先级任务正在运行");
    vTaskDelay(1000);
  }
}

void high_task(void *pvParameters)
{
  for (;;)
  {
    if (mutex_semphr != NULL)
    {
      printf("\n高优先级任务正在等待信号量...");
      // 一直等待二值信号量
      xSemaphoreTake(mutex_semphr, portMAX_DELAY);   
      printf("\n高优先级任务获取到信号量，即将释放...");
      xSemaphoreGive(mutex_semphr);    // 释放信号量
    }
    vTaskDelay(1000);
  }
}

qemu-system-riscv64 -M virt -kernel build/FreeRTOS-simple.elf.bin -bios none -serial stdio -display none
Hello, FreeRTOS!
start task!

 mutex信号量创建成功
低优先级任务获取到信号量，正在占用...
低优先级任务占用信号量结束，即将释放
中优先级任务正在运行
高优先级任务正在等待信号量...
高优先级任务获取到信号量，即将释放...
低优先级任务获取到信号量，正在占用...
中优先级任务正在运行
高优先级任务正在等待信号量...
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...
低优先级任务占用信号量结束，即将释放
高优先级任务获取到信号量，即将释放...
中优先级任务正在运行
低优先级任务获取到信号量，正在占用...
高优先级任务正在等待信号量...

二值信号量和互斥锁到底有什么区别？

在说明之前我先抛出结论：互斥锁和二值信号量在使用上非常相似，但是互斥锁解决了优先级翻转的问题

假定我们现在有三个任务，task1，task2，task3，任务优先级task1最高，然后依次降低。我们知道在系统调度的时候当两个任务同时处于就绪态的时候，系统会优先执行优先级高的任务

好了，让我们来看两个案例

优先级翻转分析(使用信号量)

在例子中，我们使用pend()函数来表示获取信号量，用post()函数来表示释放信号量

如上图所示，过程分下面几步

1.一开始task3开始运行，先获取到信号量

2.task1开始运行尝试去获取信号量失败被阻塞等待task3执行完

3.task3运行过程中，task2被触发，由于其优先级高于task3，task2被运行，浪费了大量时间

4.继续运行task3，运行完后释放信号量

5.task1继续运行

看到这里我们可以得知，本应该优先级最高的task1结果居然是最后开始运行的，这就是优先级反转现象。这明显是不利的。比如如果有安装看门狗，task1在长时间没有得到执行，就会触发看门狗，导致系统的重启。

改进分析(使用互斥锁)

在例子中，我们使用lock()函数来表示获取互斥锁，用unlock()函数来表示释放互斥锁

如上图所示，过程分下面几步

1.一开始task3开始运行，先获取到互斥锁

2.task1开始运行尝试去获取互斥锁失败被阻塞等待task3执行完，但是此时提升task3的优先级，让其优先级跟自己一样

3.task3运行过程中，task2被触发，由于其优先级低于task3(第2步被提升过)，task2等待运行

4.继续运行task3，运行完后释放互斥锁

5.task1继续运行

6.task1执行完，执行task2

所以过程跟前面的虽然一样，但是互斥锁多做了一个步骤就是将task3的优先级提升到task1的级别，防止task2中途出来搅局浪费大量时间。

生活中的实例类比

使用信号量的情况：

领导在台上讲话。场内三个角色，领导，组长，小兵。

小兵先拿起话筒说话，领导要讲话发现没有话筒，就等待小兵讲完。

组长要讲话，由于他比较野蛮，不需要话筒，并制止了小兵说话，自己开始说。

组长讲完，小兵接着讲

小兵讲完，把话筒给领导，领导讲完

使用互斥锁的情况：

领导在台上讲话。场内三个角色，领导，组长，小兵。

小兵先拿起话筒说话，领导要讲话发现没有话筒，就等待小兵讲完，并且跟小兵说，现在你就是领导的身份

组长要讲话，但是他发现领导已经赋予了小兵比自己更高的权限，自己没有权力打断，只好作罢