Таймер

Виртуальное время

Зачем нужно знать время внутри программы?

Базовая статья на Хабре. Обратите внимание на количество «исторического наследия», оно же — легаси.

Определять относительный порядок событий. Для этого используются часы, измеряющие время от «начала времён», «эпохи» или какого-то иного фиксированного события в прошлом.
- Разрешение — не меньше, чем минимальный интервал между событиями
- Точность — достаточная, чтобы не перепутать события)
Измерять длительность процессов. Для этого используются секундомеры (с событием по каждому интервалу) и таймеры (с событием по окончанию отсчёта, частный случай).
- Точность и разрешение зависят от требований. Как правило, требования высокие, иначе можно воспользоваться часами.
Не пропустить важное событие в будущем. Для этого нужны будильники. Процессор при этом может быть (частично) обесточен.
- Точность и разрешение соотносятся с ожиданиями от времени «пробуждения» — точнее не очень надо.

Свойства:

Точность / стабильность
Разрешение
Задержка при чтении
Интервал переполнения-сброса (watchdog?) и монотонность
- watchdog сброса + программная обработка = монотонные часы ∞ объёма)
Энергонезваисимость
В секундах или в тиках?

Если устройств времени несколько, их надо время от времени) согласовывать.

Выбрать «главные часы»
Переустанавливать и калибровать остальные (в т. ч. при переустановке и калибровке «главных»)
- Скорее всего, это дело программное, а не аппаратное.

Устройства времени бывают:

Внешние аппаратные (например, RTC/HPET и т. п.) — специальные устройства В/В, с которыми взаимодействует процессор
Внутренние (всякие счётчики инструкций/тактов) — встроены в процессор; часто бывают виртуальными, т. е. задаются обработкой уже имеющихся данных
Программные — для формирования «правильных» значений, протоколов и т. п.

Аппаратные таймеры — ценный и ходовой ресурс.

Почему все непросто и что с этим делать?

Кварцевый резонатор

Ограничен по частоте (мегагерцами)
Имеет стабильность частоты (относительную) 10⁻⁵ — 10⁻¹² (в последнем случае это генератор размером с автобус)
Другого пока нет. Для достижения бОльших частот используются множители — пропорционально множителю падает стабильность! Сами множители тоже вносят нестабильность

Получить одновременно короткий и стабильный импульс само по себе дело не простое. Однако его еще надо доставить и обработать — значит, параметры устройства времени зависят и от схемотехники / разводки / технологии и т. п.

Дополнительно Виртуальное время. Часть 2: вопросы симуляции и виртуализации, нужная для понимания "глубины неудобозримой" этого вопроса в случаях многмашинной распределенной системы с развитым уровнем привилегий.

Роль устройств времени

«провода» — запуск и синхронизация работы устройств
«внешние устройства и процессор» — тайм-ауты, генераторы сигналов, протоколы обмена в РВ
«ядро и супервизор» — планировщики (в т. ч реальное время) и многозадачность
«ОС» — запуск по расписанию, учёт потребления, энергосбережение
«Эксплуатация» — профилирование и отладка, прикладное ПО

RISC-V

Machine Timer Registers (mtime and mtimecmp)
- Volume II: RISC-V Privileged Architectures V20211203 44
  - есть на five-embeddev
  - Там же немножко программирования на Си
- Это MMIO, а не CSR, потому что:
  - Аппаратное внешнее устройство
  - Дорогое и одно на все уровни/hart-ы
- Выделенные прерывания таймера:
  - mtime — в действительности не таймер, а часы (RTC) — в тиках; перевод в секунды — ответственность окружения
  - mtimecmp — «галочка», при достижении которой происходит прерывание

Регистры времени и счетчиков в CSR процессора:
- Также на five-embeddev
RARS:
- cycle / cycleh — число выполненных тактов
- time / timeh — время в тиках
- instret / instreth — число выполненных до конца машинных инструкций

Таймер RARS

Инструмент RARS Timer Tool имитирует устройство таймера, похожее на базовый таймер mtime/mtimecmp из спецификации. Ввод-вывод с отображением в память (MMIO) линия таймерного прерывания.

Его нужно

Подключить, как внешнее устройство
- (вот досада, в EJudge не запихнёшь! Георгий Курячий),
Нажать Play — он запустит часы в милисекундах, начиная с 0.

Время хранится в виде 64-битного целого числа, и к нему можно получить доступ (с помощью инструкции lw):

time — по адресу 0xFFFF0018 для младших 32 битов
timeh — по адресу 0xFFFF001B для старших 32 битов.

За обработку прерываний по таймеру отвечают два регистра CSR:

uie, в котором отмечается, какие именно типы прерываний уходят в нашу ловушку: от устройств, от таймеров или программные (нам нужны таймерные, UYIP, т. е. 0x10)
ustatus, в котором, как и в случае обработки исключений, надо выставить младший бит (UIE — разрешение обработки ловушек) в 1

Перед установкой прерывания необходимо сделать три вещи:

Адрес вашего обработчика ловушек (прерываний и исключений) должен храниться в CSR utvec.
Четвертый бит CSR uie должен быть установлен в 1.
- ori uie, uie, 0x10
Нулевой бит CSR ustatus должен быть установлен в 1
- ori ustatus, ustatus, 1

вот тут про CSR в старой спецификации RISC-V

Чтобы установить таймер — timecmp/tmpecmph, нужно записать туда время срабатывания виде 64-битного целого числа (с помощью инструкции sw):

timecmp — по адресу 0xFFFF0020 для младших 32 битов
timpecmph — 0xFFFF0024 для старших 32 битов.

Регистры таймера time и tmpecmph — это регистрв внешнего устройства MMIO, их не надо путать с спохожими CSR, которые в RARS, к сожалению, называются так же ☹.

Прерывание произойдет, когда время в time* станет больше или равно значению в timecmp*. Имеет смысл записывать число, большее, чем текущее значение часов.

Таймер сработает только один раз, после чего time* окажется больше timecmp* «навсегда» — пока туда снова что-нибудь подходящее не запишут
Как только вы записываете что-то в любой из регистров timecmp и timecmph, может случиться прерывание. Поэтому обновлять timecmp* рекомендуется так:

   1     # a0: младшие 32 бита времени
   2     # a1: старшие 32 бита времени
   3     li t0 -1
   4     la t1 timecmp
   5     sw t0 0(t1)         # Наибольшее возможное значение timecmp
   6     sw a1 4(t1)         # Актуальное значение timecmph
   7     sw a0 0(t0)         # Актуальное значение timecmp

Замечание от нашего постоянного участника @COKPOWEHEU,:

Вот это интересный момент. Поскольку таймер работает асинхронно и разрядность времени больше, чем размер регистра, старшая и младшая половины могут быть рассинхронизированы. Скажем, начали читать время 0x00000000:FFFFFFFF, а между чтениями произошел клок, получим либо 0x00000001:FFFFFFFF, либо 0x00000000:00000000. Одно из аппаратных решений - теневые регистры. При доступе к старшей части, младшая "защелкивается". Не наоборот, потому что смысл читать младшую часть без старшей смысл есть, а старшую без младшей - нет.

Замечание от меня: 64-битный режим работы с регистрами снимает подобные вопросы — до тех пор, пока мы не собираемся считать что-то действительно очень быстро растущее)…

TODO проверить, что такое «64bit» в RARS, не подойдёт ли оно?

Обработчик прерывания по таймеру, если в архитектуре не предусмотрен векторный режим — это та же самая ловушка, что и обработчик исключений. Понять, что мы обрабатываем — прерывание или исключение — можно поглядев в CSR ucause:

в случае, когда ловушка сработала по исключению, знаковый бит ucause нулевой,
а если по прерыванию — единичный (0x80000000).
Прерывание от Timer Tool также выставляет 2-й бит в ucause — получается 0x80000004
Чтобы отличить это таймерное прерывание от других, в SCR utval Timer Tool выставляет значение 0x10

Важно отличить обработку прерывания от обработки исключения:

После обработки прерывания мы должны вернуться к исполнению прерванной инструкции (с помощью uret)
после обработки исключения мы должны перейти к исполнению инструкции, следующей за прерванной (прибавить 4 к CSR uepc и только после этого выполнить uret)

Плохой, негодный пример простейшего обработчика прерывания по таймеру, который не сохраняет никаких регистров, в нём используемых (что совсем нехорошо!)

   1 .eqv    TIME    0xFFFF0018
   2 .eqv    TIMECMP 0xFFFF0020
   3 .eqv    INTERVAL        500
   4 .data
   5 timer:  .word   0
   6 .text
   7         li      s2 TIMECMP      # CSR таймера
   8         li      t1 1000         # Заряжаем на секунду
   9         sw      t1 (s2)
  10 
  11         la      t0 handle       # Адрес обработчика
  12         csrw    t0 utvec        # CAS вектора обработки ловушек
  13         csrwi   uie 0x10        # Включим обработку таймерных прерываний
  14         csrwi   ustatus 1       # Разрешим ловушки
  15 
  16 loop:   lw      a0 timer        # Сюда обработчик запишет текущее время
  17         li      a7 34           # Выведем его в 16-чном виде
  18         ecall
  19         li      a0 '\n'         # И перевод строки
  20         li      a7 11
  21         ecall
  22         b       loop            # sorry, вечный цикл
  23 
  24 # Плохой, негодный обработчик — ничего не сохраняет
  25 # Но в нашем цикле регистры типа t* не испльзуются, может, пронесёт, а?
  26 handle: lw     t1 TIMECMP       # Время срабатывания таймера
  27         sw     t1 timer t0      # Запишем его в память
  28         li     t0 1000          # Увеличим на 1000 (секунда)
  29         add    t1 t1 t0
  30         sw     t1 TIMECMP t0    # Установим следующее время срабатывания
  31         uret

Счётчик инструкций в Digital Lab

В RARS есть ещё одно устройство, которое умеет вызывать внутреннее таймерное прерывание — это уже знакомый нам Digital Lab.

Если записать ненулевой байт в MMIO-регистр 0xFFFF0013, это устройcтво будет вызывать таймерное прерывание каждые 30 выполненных инструкций RARS. Не знаю, существуют ли в реальном мире такие возможности / необходимость тоже под вопросом, но это пример другого «таймера» (который в действительности счётчик).

Не забываем, что для работы Digital Lab надо «подключить» к RARS-у.

   1 .eqv    COUNTER 0xFFFF0013
   2 .data
   3 count:  .word   0
   4 .text
   5         li      s2 COUNTER      # CSR счётчика
   6         li      t1 1
   7         sb      t1 (s2)         # Надо записать байт
   8 
   9         la      t0 handle       # Адрес обработчика
  10         csrw    t0 utvec        # CAS вектора обработки ловушек
  11         csrwi   uie 0x10        # Включим обработку таймерных прерываний
  12         csrwi   ustatus 1       # Разрешим ловушки
  13 
  14 loop:   lw      a0 count        # Сюда обработчик запишет текущее время
  15         li      a7 34           # Выведем его в 16-чном виде
  16         ecall
  17         li      a0 '\n'         # И перевод строки
  18         li      a7 11
  19         ecall
  20         b       loop            # sorry, вечный цикл
  21 .data
  22         .align  2               # Область сохранения контекста
  23 h.save: .space  4               # Пока только t1
  24 .text
  25 handle: csrw    t0 uscratch
  26         la      t0 h.save
  27         sw      t1 (t0)         # Сохраняем t0
  28         lw     t1 count         # Счётчик
  29         li     t0 1             # Увеличим на 1
  30         add    t1 t1 t0
  31         sw     t1 count t0      # Запишем счётчик
  32         la      t0 h.save
  33         lw      t1 (t0)         # Восстановим t1
  34         csrr    t0 uscratch     # восстановим t0
  35         uret

Обратите внимание на то, что заданных 30 тактов на прерывание едва хватает на два выполнения обработчика! Если бы в нём было, скажем, в три раза больше инструкций, то ничего, кроме кода обработчика, не выполнялось бы!

Отложенные прерывания (первый заход)

Как предотвратить повторный вход в обработчик, но при этом не потерять сам факт того, что ещё одно прерывание произошло за время обработки.

Давайте наполним обработчик прерывания счётчика от Digital Lab nop-ами настолько ,чтобы он занимал больше 30 инструкций — тогда второе прерывание счётчика возникнет до выхода из ловушки.

Повторного входа не произошло (об это позаботился соответствующий бит CSR uie), но в регистре uip (Interrupt Pending) появился 5-й бит: «было ещё одно прерывание таймера». Если мы выполним uret, содержимое uip переедет в ucause, случится прерывание на той же инструкции, все пойдёт по новой.

Мы можем попробовать обработать отложенное прерывание тем же обработчиком или просто убрать бит uip в знак того, что данное прерывание идемпотентно — то есть неважно, сколько их на определённый промежуток времени произошло, обрабатывать их можно только один раз.

Более длинные примеры

Пример (с использованием самописной библиотеки макросов из прошлых Д/З)

   1 .include        "utils.inc"
   2 .eqv    TIME    0xFFFF0018
   3 .eqv    TIMECMP 0xFFFF0020
   4 .eqv    INTERVAL        500
   5 .globl  main
   6 .text
   7 main:   li      s3 TIME
   8         li      s2 TIMECMP
   9         li      t1 INTERVAL
  10         sw      t1 (s2)
  11 
  12         la      t0 h.proc
  13         csrw    t0 utvec
  14         csrwi   uie 0x10
  15         csrwi   ustatus 1
  16 
  17         li      s1 200
  18 loop:   csrr    t1 time
  19         print.x "Time CSR:" t1 ','
  20         syscall 30
  21         mv      t1 a0
  22         print.x " Time syscall:" t1 ','
  23         lw      t1 (s3)
  24         print.w " MMIO time:" t1 ','
  25         lw      t1 (s2)
  26         print.w " MMIO timer:" t1 ','
  27         lw      t1 h.time
  28         print.w " Handler counter:" t1
  29         addi    s1 s1 -1
  30         bgez    a1 loop
  31 
  32         syscall 10
  33 .data
  34 h.time: .word   0
  35 .text
  36 h.proc: hprocedure
  37         lw      a0 h.time
  38         addi    a0 a0 1
  39         sw      a0 h.time a1
  40         li      a0 TIMECMP
  41         lw      a1 (a0)
  42         li      a2 INTERVAL
  43         add     a1 a1 a2
  44         sw      a1 (a0)
  45         hreturn

Макросы в этом примере:

print.X Строка Значение Символ='\n' — вывести Строку, затем — Значение соответствующего типа X, затем Символ. Первые два параметра — регистры не из набора a*
syscall Номер Необязательный_a0 Необязательный_регистр_a1 — заполнить, если заданы, a0 и a1 и вызвать ecall Номер
hprocedure — сохранить контекст вызова в буфере (который заводит макрокоманда hreturn)
hreturn — восстановить контекст из буфера и выполнить hret. Завести в памяти статический буфер для сохранения контекста.

Программа из rars-master/examples

   1 .data
   2 loopStr:.asciz "Loop\n"
   3 hello:  .asciz "Hello\n"
   4 newLine:.asciz "\n"
   5 Time:   .word 0xFFFF0018
   6 cmp:    .word 0xFFFF0020
   7 .text
   8 main:
   9         # Set time to trigger interrupt to be 5 seconds
  10         lw  a0, cmp
  11         li  a1, 5000
  12         sw  a1, 0(a0)
  13 
  14         # Set the handler address and enable interrupts
  15         la      t0, handle
  16         csrrs   zero, 5, t0
  17         csrrsi  zero, 4, 0x10
  18         csrrsi  zero, 0, 0x1
  19 
  20 
  21 loop:
  22         # Output current time in loop
  23         li      a7, 1
  24         lw      a0 Time
  25         lw      a0, 0(a0)
  26         ecall
  27         li      a7, 4
  28         la      a0, newLine
  29         ecall
  30         j       loop
  31 
  32 
  33 handle:
  34         # Save some space for temporaries
  35         addi    sp, sp, -20
  36         sw      t0, 16(sp)
  37         sw      t1, 12(sp)
  38         sw      t2, 8(sp)
  39         sw      a0, 4(sp)
  40         sw      a7, 0(sp)
  41 
  42         # Print out hello
  43         li      a7, 4
  44         la      a0, hello
  45         ecall
  46 
  47         # Set cmp to time + 5000
  48         lw a0 Time
  49         lw t2 0(a0)
  50         li t1 5000
  51         add t1 t2 t1
  52         lw t0 cmp
  53         sw t1 0(t0)
  54 
  55         # Reload the saved registers and return
  56         lw      t0, 16(sp)
  57         lw      t1, 12(sp)
  58         lw      t2, 8(sp)
  59         lw      a0, 4(sp)
  60         lw      a7, 0(sp)
  61         addi    sp, sp, 20
  62         uret
  63 
  64 done:
  65         li      a7, 10
  66         ecall

Найдите ошибку в этой программе!
- Подсказка: в программе молчаливо предполагается, что некоторые значения инициализированы нулём
- Подсказка 2: программа явно рассчитана на то, что некоторые значения она инициализирует ровно один раз

Д/З

В этих домашних заданиях предлагается написать обработчик прерываний по таймеру, обладающий заданными свойствами. Пользовательская часть обработчика прилагается в виде footer-программы, которая приписывается в конец общего текста (так поступает EJudge). или добавляется в многофайловую сборку.

В данный момент классический RARS не умеет обрабатывать прерывания по таймеру при запуске из командной строки. Желающие могут потестировать модифицированную версию, в которой добавлен параметр командной строки «ti», запускающий таймер сразу при старте RARS. Эта же версия будет на EJudge, когда там появятся тесты.

EJudge: TwoTasks 'Двухзадачность'
Написать обработчик прерываний по таймеру handler:, который переключает контекст выполнения между двумя задачами, а после истечения тайм-аута — выполняет третью. Написать также подпрограмму init:, которой передаётся 6 параметров (через регистры a*):
1. Адрес первой задачи
2. Продолжительность такта (квант работы) первой задачи
3. Адрес второй задачи
4. Продолжительность такта (квант работы) второй задачи
5. Адрес завершающей задачи
6. Время, по истечении которого надо запустить завершающую задачу
Требования и допущения:
- Задачи используют только регистры типа a* и не используют стек, для простоты сохранения контекста
- Алгоритм работы обработчика: переключить контекст на другую задачу (включая uepc), выставить таймер равным кванту работы этой задачи; когда придёт время завершения, таймер не выставлять, а вернуться сразу в завершающую задачу
- Первая и вторая «задачи» в данном задании — это бесконечно работающие фрагменты кода, начинающиеся с определённого адреса; третья — фрагмент кода, вызывающий по окончании работы ecall 10.
- footer, применяющийся в первом тесте
$/!\$ Значения очень сильно отличаются от запуска к запуску и сильно зависят от производительности компьютера (привет Java?), так что если одно число результата примерно в два раза больше другого, то и ладно.
- Вводится три числа:
  1. квант работы первой задачи в миллисекундах,
  2. квант работы первой второй в миллисекундах,
  3. общее время работы в миллисекундах
Input:
```
29
58
3000
```
Output:
```
551645
1114830
```
EJudge: UniHandler 'Прерывания и исключения'
Написать обработчик для прерываний по таймеру и исключений. Для прерываний по таймеру обработчик должен выводить тип таймера (из регистра utval), а для исключений — причину исключения (из регистра ucause).
- Напоминаю, что из прерывания и из исключения надо возвращаться в разные места программы
- TODO footer пока не готов
Input:
```
TODO
```
Output:
```
TODO
```

TODO

LecturesCMC/ArchitectureAssembler2022/08_Timers (последним исправлял пользователь FrBrGeorge 2022-04-09 23:06:19)