Визуализация работы кэш памяти

Кэш — это специализированная высокоскоростная память, предназначенная для временного хранения и быстрого извлечения часто используемых данных.

Современные электронные устройства (компьютеры, смартфоны, микроконтроллеры) используют многоуровневую систему памяти. У каждого типа свои свойства и назначение:

• Основная память (например, жесткие диски или Flash-память) способна вмещать огромные объемы информации и хранить её долго, но работает медленно. Если процессор будет постоянно обращаться напрямую к ней, это сильно замедлит выполнение программ.

• Кэш-память решает эту проблему. Она выступает «буфером»: копирует в себя самые востребованные данные, обеспечивая процессору мгновенный доступ к ним.

Благодаря кэшированию работа программ значительно ускоряется, а количество запросов к медленной основной памяти снижается. Для некоторых типов накопителей (например, Flash или SSD) это критически важно, так как уменьшение числа циклов перезаписи сохраняет их ресурс и продлевает срок службы устройства.

Виды кэша

Кэш бывает двух типов:

1. Аппаратный — физически встроен в архитектуру процессора или контроллера (например, кэш-память уровней L1, L2, L3).

2. Программный — реализуется разработчиками в коде приложений на базе оперативной памяти (RAM) или регистров для ускорения работы с базами данных и файлами.

Алгоритмы вытеснения: стратегия LRU

Объем кэша всегда ограничен. Когда он заполняется «под завязку», устройству нужно решить, какие старые данные удалить, чтобы освободить место для новых. Для этого используются специальные алгоритмы.

Один из самых популярных — LRU (Least Recently Used), что переводится как «наименее недавно использованный». Его логика проста: алгоритм отслеживает время последнего обращения к элементам. Если кэш полон и в него нужно записать новые данные, LRU находит ту ячейку, к которой дольше всего никто не обращался, удаляет её содержимое и записывает туда свежую информацию.

Визуализация работы алгоритма LRU

Ниже представлена интерактивная схема, которая наглядно показывает этот процесс:

• Слева расположена основная (медленная) память, состоящая из 4 ячеек. В таблице отображаются адреса ячеек, хранящиеся в них данные, а также счетчики обращений (для общей информации).

• По центру находится быстрый кэш, рассчитанный всего на 2 ячейки.

• Справа выводится текущее извлекаемое значение, к которому программа обращается в данный момент.

память

>

0	a	0
1	b	0
2	c	0
3	d	0

>

кэш

>

текущее значение

Адрес биткоин кошелька для поддержки канала - bc1qlhrmmkh77x2lzhqe4lt9qwkglswj64tsqt2l5g

STM32 FreeRTOS уведомления задач

 Операционная система FreeRTOS содержит некоторое количество инструментов для коммуникации задачи и обработчиков прерываний между собой. Для этого можно использовать бинарные семафоры и даже, рассмотренные ранее, очереди но если нужно организовать максимально быстрое и не затратное по памяти решение то лучше всего подойдут "уведомления задач" (Task Notifications). Уведомления задач имеются в новых версиях FreeRTOS и могут передавать не только уведомления но и некоторое небольшое количество данных, 32 бита. Уведомления задач на 40% работают быстрее бинарных семафоров и в 90% случаев могут их заменить. Попробуем изучить уведомления задач на простом примере. Допустим у нас есть прерывание по приему на UART1 после получения данных в UART1, в обработчике прерывания, упакуем принятый байт данных и отправим как уведомление в задачу.Задача примет байт и отправит его в UART1. Таким образом мы получим простой эхо режим, работающий через задачу и использующий уведомление задачи. Чтобы использовать уведомление задачи нужно сначала инициализировать её хэндл.

В функции main когда мы создаем задачу то в функцию xTaskCreate, последним параметром, передаем этот хэндл.

Он, в последствии, будет использоваться для передачи уведомлений. Периферию настраиваем как обычно, включаем UART1, 

не будем на этом останавливаться см. предыдущие уроки.

Сейчас нас интересуют две функции. Это сама задача и обработчик прерывания по приему UART1.

В обработчике прерывания принимаем байт.

Далее используя специальную функцию для отправки уведомлений задачам из прерывания.

Отправляем уведомление задаче. Важно в прерывании использовать именно такую функцию. Если нужно отправить уведомление от задачи к задаче то есть другая похожая.

В этой функции хэндл задачи указываем первым параметром. Вторым параметром передаем принятый байт, предварительно приведя его к нужному типу.

Третьим параметром передаем константу означающую перезапись значения если задача не успела его вовремя принять и обработать. 

Ну и остальное просто оставим пока как есть. В самой задаче, объявляем переменную в которую будем принимать байт от UART1.

В бесконечном цикле задачи проверяем когда в задачу придет уведомление. Когда оно приходит, извлекаем принятый байт.

После отправляем его обратно в UART1.

Полный код файла main.c проекта, можно скопировать от сюда:

#include <stm32f10x.h> #include <stm32f10x_rcc.h> #include <stm32f10x_gpio.h> #include <stm32f10x_usart.h> #include "stm32f10x.h" #include "FreeRTOS.h" #include "task.h" #include "misc.h" // Хэндл задачи для работы с UART TaskHandle_t xUartTaskHandle = NULL; // Прототипы функций настройки периферии SPL void UART1_Init(void); // 1. Задача обработки данных из UART void vUartTask(void *pvParameters) { uint32_t ulReceivedValue; // Включаем прерывание на прием (RXNE) после запуска задачи USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); for(;;) { // Ожидаем уведомления. Принятое 32-битное значение запишется в ulReceivedValue // 0x00, 0x00 означает, что биты уведомления очищать при входе/выходе не нужно if(xTaskNotifyWait(0x00, 0x00, &ulReceivedValue, portMAX_DELAY) == pdTRUE) { // Извлекаем наш байт (символ) из нижних 8 бит 32-битного значения uint8_t rx_char = (uint8_t)(ulReceivedValue & 0xFF); // Эхо: Отправляем символ обратно в UART1 (простая отправка в SPL) while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); USART_SendData(USART1, rx_char); } } } // 2. Обработчик прерывания USART1 (SPL стандартное имя) void USART1_IRQHandler(void) { // Проверяем, что прерывание вызвано флагом "Приемный регистр не пуст" if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) { // Считываем байт из регистра данных (очищает флаг RXNE автоматически) uint8_t received_byte = (uint8_t)USART_ReceiveData(USART1); BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Отправляем байт НАПРЯМУЮ в задачу как значение (перезаписывая предыдущее, если задача не успела считать) xTaskNotifyFromISR(xUartTaskHandle, // Кому (uint32_t)received_byte, // Что (данные) eSetValueWithOverwrite, // Действие &xHigherPriorityTaskWoken); // Флаг разблокировки // Если задача vUartTask имеет более высокий приоритет — переключаемся на нее сразу portYIELD_FROM_ISR(xHigherPriorityTaskWoken); } } // 3. Функция инициализации GPIO, USART1 и NVIC средствами SPL void UART1_Init(void) { // Включаем тактирование GPIOA, USART1 и альтернативных функций (AFIO) RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1 | RCC_APB2Periph_AFIO, ENABLE); GPIO_InitTypeDef GPIO_InitStructure; // Настройка PA9 (USART1_TX) как Alternate Function Push-Pull GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); // Настройка PA10 (USART1_RX) как Floating Input GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); // Настройка параметров самого USART1 (115200, 8-N-1) USART_InitTypeDef USART_InitStructure; USART_InitStructure.USART_BaudRate = 9600;//14400;//9600;//115200; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_Init(USART1, &USART_InitStructure); // Конфигурация прерываний NVIC для USART1 NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; // Внимание: приоритет должен быть числом >= configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 11; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); // Включаем UART1 USART_Cmd(USART1, ENABLE); } int main(void) { // Настройка групп приоритетов NVIC (обязательно для FreeRTOS на Cortex-M3) NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); // Инициализируем периферию UART1_Init(); // Создаем задачу обработки UART xTaskCreate(vUartTask, "UartTask", configMINIMAL_STACK_SIZE + 50, NULL, tskIDLE_PRIORITY + 3, &xUartTaskHandle); // Запускаем планировщик vTaskStartScheduler(); while (1); } // нужно для работы функции GPIO_Init() иначе появиться ошибка #ifdef USE_FULL_ASSERT /** * @brief Вызывается в случае, если assert_param обнаружил ошибку в аргументах функции. * @param file: указатель на имя исходного файла, где произошла ошибка * @param line: номер строки, где произошла ошибка * @retval None */ void assert_failed(uint8_t* file, uint32_t line) { // Здесь можно поставить точку останова для отладки // или организовать вывод ошибки в UART while (1) { } } #endif

Его можно вставить в свой проект и откомпилировать запустив скрипт. О том как скачать и настроить проект а также откомпилировать см. первый урок по FreeRTOS. Если откомпилировать проект получилось то можно его загрузить в микроконтроллер. Подключить его через usb-uart переходник к компьютеру и в каком либо терминале последовательного порта наблюдать работу.

Адрес биткоин кошелька для поддержки канала - bc1qlhrmmkh77x2lzhqe4lt9qwkglswj64tsqt2l5g

Визуализация работы кольцевого буфера

 Кольцевой буфер — один из самых эффективных инструментов для обмена данными между асинхронными процессами. Его главное преимущество в средах с ограниченными ресурсами — работа без динамической памяти. Типичный пример асинхронности в микроконтроллерах — прерывания, момент возникновения которых заранее неизвестен. Встраиваемые системы имеют свою специфику выделения памяти, которая кардинально отличается от ПК: • На ПК оперативной памяти много, поэтому программы динамически запрашивают её у ОС и возвращают в общую кучу. • В микроконтроллерах объем ОЗУ жестко ограничен. Инженер может полностью контролировать всю память и заранее распределить её между задачами, избегая непредсказуемого поведения кучи. В таких условиях кольцевой буфер служит идеальным временным хранилищем. Конечно, это не единственный способ защитить данные от потери. Однако, в отличие от классической очереди, он требует гораздо меньше тактов процессора на операции чтения и записи. Благодаря высокому быстродействию и простоте программной реализации этот алгоритм стал стандартом де-факто в микроконтроллерных системах. Принцип его работы наглядно показан на визуализации ниже:

Кольцевой буфер с перезаписью (Overwrite)

➔

➔

Буфер пуст

Пример реализации кольцевого буфера на языке си #include <stdio.h> #include <stdint.h> #include <stdbool.h> // Размер буфера обязательно должен быть степенью двойки #define BUFFER_SIZE 8 #define BUFFER_MASK (BUFFER_SIZE - 1) // 8 - 1 = 7 (в двоичном виде: 00000111) // Структура кольцевого буфера typedef struct { int data[BUFFER_SIZE]; // Массив для хранения данных uint32_t head; // Индекс для записи uint32_t tail; // Индекс для чтения } RingBuffer; // Инициализация буфера void RingBuffer_Init(RingBuffer *rb) { rb->head = 0; rb->tail = 0; for (int i = 0; i < BUFFER_SIZE; i++) { rb->data[i] = 0; // Заполняем нулями } } // Проверка: пуст ли буфер bool RingBuffer_IsEmpty(const RingBuffer *rb) { return rb->head == rb->tail; } // Проверка: заполнен ли буфер bool RingBuffer_IsFull(const RingBuffer *rb) { return (rb->head - rb->tail) == BUFFER_SIZE; } // Запись элемента с автоматической перезаписью (Overwrite) void RingBuffer_Push(RingBuffer *rb, int value) { // Применяем маску к head для получения физического индекса в массиве. // Например, если head = 8, то 8 & 7 = 0. rb->data[rb->head & BUFFER_MASK] = value; // Если буфер уже полон, head "догнал" tail. // Сдвигаем tail вперед, тем самым стирая самый старый элемент. if (RingBuffer_IsFull(rb)) { rb->tail++; } rb->head++; } // Чтение (извлечение) элемента из буфера bool RingBuffer_Pop(RingBuffer *rb, int *value) { if (RingBuffer_IsEmpty(rb)) { return false; // Буфер пуст, читать нечего } // Извлекаем значение по маскированному индексу tail *value = rb->data[rb->tail & BUFFER_MASK]; rb->tail++; return true; // Успешное чтение }
Пример использования: int main(void) { RingBuffer myBuffer; RingBuffer_Init(&myBuffer); // 1. Заполняем буфер полностью (8 элементов) for (int i = 1; i <= 8; i++) { RingBuffer_Push(&myBuffer, i * 10); } // Сейчас в буфере: [10, 20, 30, 40, 50, 60, 70, 80] // 2. Добавляем еще два элемента (происходит перезапись старых) RingBuffer_Push(&myBuffer, 90); // Перезапишет 10 RingBuffer_Push(&myBuffer, 100); // Перезапишет 20 // Физически в памяти: [90, 100, 30, 40, 50, 60, 70, 80] // Но логически порядок чтения начнется с 30! // 3. Читаем все данные из буфера int poppedValue; printf("Элементы в порядке очереди:\n"); while (RingBuffer_Pop(&myBuffer, &poppedValue)) { printf("%d ", poppedValue); } // Выведет: 30 40 50 60 70 80 90 100 return 0; }

Адрес биткоин кошелька для поддержки канала - bc1qlhrmmkh77x2lzhqe4lt9qwkglswj64tsqt2l5g