LecturesCMC/ArchitectureAssembler2019/08_TrapsAndMMIO

Долги за прошлую лекцию

Имитация исключений

С одной стороны, на все случаи жизни исключения предусмотреть нельзя.

С другой стороны, это очень эффективный механизм обращения к ОС почти (или совсем) без дополнительных действий, в отличие от syscall. Системный обработчик по адресу 0x80000180 вызывается немедленно одной инструкцией, атомарно с операцией сравнения.

Таким образом гарантируется, что за время, прошедшее между сравнением и обращением к системе, никакие данные не изменятся (потому что этого времени нет ).

Назначение инструкций типа trap:

• Отладочный останов программы (т. н. assertion). Допустим, в регистре не должно получаться 0, а если ошибочно получится, то лучше пускай система обработает эту ошибку, чем программа будет дальше считать. Например, можно проверить, что изменение счётчика в цикле вообще происходит:

          teqi    $t1 0
          subu    $t0 $t0 $t1
          bgez    $t0 loop

• Обработка исключительной ситуации, если аппаратного обнаружения её нет. Обычно используется команда R-типа, в которой можно в неиспользуемом аппаратно поле хранить причину исключения. Ср. архитектура RISCore:

  TEQ - Ловушка по равенству
  31	25	20	15	5
  SPECIAL 000000	rs	rt	code	TEQ 110100

Содержимое поля code игнорируется системой и может быть использовано для кодированиия информации для системного ПО. Для получения этой информации программа должна загрузить слово команды из памяти (адрес хранится в регистре EPC сопроцессора 0). В ассемблере Mars эта возможность отсутствует, обидно.

Свойства макроассемблера MARS

Замечания авторов MARS относительно их макроассемблера:

• Макроопределение должно идти в тексте программы до соответствующей макрокоманды (иначе пришлось бы анализировать текст дважды)

• Макроопределение локально в пределах одного файла. Это с очевидностью вытекает из самого процесса макроподстановки перед трансляцией. Если нужно, чтобы один и тот же макрос был виден из нескольких файлов, используйте .include

• Вложенные макросы не поддерживаются, т. е. внутри макроопределения не может встречаться директива .macro

• Внутри макроопределения, как и в тексте программы, могут встречаться только ранее определённые макрокоманды, искать их определения далее по тексту никто не будет

• Все метки меняются в процессе макроподстановки, превращаясь в метка_M№

  • (Замечание от меня: нет, на все! если передать метку в качестве параметра, а потом написать что-то вроде %label: , _M№ к ней не припишется. Не знаю, как и зачем это можно использовать…)

• Несколько макроса с одинаковым именем, но разным количеством параметров, считаются различными, и их можно использовать все
• Повторное определение макроса с тем же именем и тем же количеством параметров игнорируется, макрокоманда раскрывается в первое определение

• Параметром макроса (в силу ограниченной реализации) может быть только атомарная лексема языка ассемблера. Например, параметром не может быть "4($t0)", потому что это две лексемы, а не одна

• Макросредства ассемблера не входят ни в какой стандарт и остаются на усмотрение авторов ассемблера

  В больших многофайловых проектах принято все макросы складывать в отдельный файл и включать их в код программы с помощью директивы .include файл_с_макросами . Подпрограммы при этом складываются в другой файл (возможно. не один), т. н. «библиотеку», и подключаются посредством многофайловой сборки. На предыдущем примере: Файл с программой prog.asm:

  .include        "macro.inc"
  .globl  main
  .text
  main:
          input   "First input" $t0
          input   "Second input" $t1
          print   "First result" $t0
          print   "Second result" $t1
          exit

  Файл с подпрограммами lib.asm:

  .globl  _print _input
  
  .text
  _input: # $a0 — message / $v0 — input value
          li      $v0 4
          syscall
          li      $v0 5
          syscall
          jr      $ra
  
  _print: # $a0 — message, $a1 — number
          li      $v0 4
          syscall
          move    $a0 $a1
          li      $v0 1
          syscall
          li      $a0 10
          li      $v0 11
          syscall
          jr      $ra

  На забываем метки всех подпрограмм, которые понадобятся в других файлах, объявлять как .globl Файл с макросами macro.inc (имя файла не заканчивается на .asm в знак того, что его не нужно транслировать отдельно):

  .macro  input   %msg %reg
  .data
  msg:    .ascii  %msg
          .asciiz ": "
  .text
          la      $a0 msg
          jal     _input
          move    %reg $v0
  .end_macro
  
  .macro  print   %msg %reg
  .data
  msg:    .ascii  %msg
          .asciiz ": "
  .text
          la      $a0 msg
          move    $a1 %reg
          jal     _print
  .end_macro
  
  .macro  exit
          li      $v0 10
          syscall
  .end_macro

Чего нет в Mars

Макроассемблер Mars вполне достаточен для учебных целей, но не реализует много из того, что есть в промышленных средствах программирования на ассемблере

• Библиотека макросов и подпрограмм. Чтобы написать большую программу, потребуется множество подпрограмм, реализующих стандартные приёмы работы — ввод-вывод, работа с дисками, управление внешними устройствами и т. п. Для этого в профессиональных инструментариях, типа NASM или Gnu Assebmler, имеются заранее подготовленные библиотеки макросов и подпрограмм. А мы пишем их сами

• «Настоящий» макропроцессор. Макропросессор в Mars опирается только на лексемы языка ассемблера и не имеет собственного языка. Это почти не мешает, но временами (как в примере с 4($t0) ) слегка неудобно
• Адресная арифметика. Вычисление некоторых значений. смещений и размеров на основании уже известных адресов находится в ассемблере Mars в зачаточном состоянии.
  • Мы можем программе написать в качестве адреса Arr+0x200, и макроассемблер подсчитает и вставит в код результат

  • А вот написать что-то вроде ArrEnd-Arr, где ArrEnd — метка конца массива, в Mars уже нельзя, вычислять это в самой программе

• Переменные периода трансляции. полезно уметь назначать мнемонические имена результатам таких вычислений, чего Mars делать тоже не умеет

  • Например SIZE=ArrEnd-Arr, и потом использование константы SIZE

• ⇒ Вычисление выражений с использованием переменных и констант. В промышленных макропроцессорах возможно вычисление любых арифметических выражений и задание констант для них. Ещё раз напомним, что всё это происходит до трансляции, и в оттранслированный код попадает результат таких вычислений

• Условная трансляция. Наиболее полезное свойство вычислений в период трансляции — это возможность транслировать или не транслировать части текста в зависимости от результата этих вычислений. Например можно вставить исходный текст отладочные сообщения, но транслировать их только если определена некоторая переменная периода трансляции DEBUG. Как-нибудь так:

  .if DEBUG
          код, транслируемый
          только если существует
          константа DEBUG
  .endif

• Генерация макроопределений. Если разрешить создавать макросы внутри макросов, можно развёртывать целые семейства определений в зависимости от исходного параметра внешнего макроса

• Конкатенация.. Иногда необходимо, чтобы результат постановки нескольких макросов интерпретировался затем как одна лексема языка (например, строка label##suffix##index превращалась при наличии констант suffix=_M и index=5 в label_M5). В Mars такого механизма нет

• Бывает очень полезно ограничить видимость меток сильнее, чем просто внутри файла. Например, если в файле задано несколько подпрограмм, в каждой из них хотелось бы иметь возможность использовать метки типа start, finish, loop или стандартные имена переменных. Это можно было бы сделать, введя особенный синтаксис временных меток или ограничить видимость меток специальной конструкцией «локальное пространство имён» и т. п. В целом макроассемблер Mars достаточен для написания программ среднего объёма, а написание действительно крупных проектов на языке ассемблера выходит за рамки данного курса

Ввод-вывод

Базовая лекция

Внешние устройства

Внешнее устройство (также периферийное) — любая аппаратура, которая обменивается данными с ЭВМ.

Задачи:

• Ввод (микрофон, кнопка выключения питания и т. п.)
• Вывод (колонки, монитор…)

• Ввод-вывод (консоль)

• Частный случай: хранение = ввод/вывод + полное (или избыточное) кодирование + атрибуция (например, номера секторов на диске)
• Передача = ввод/вывод + несколько ЭВМ + синхронизация (сетевая карта, …)

⇒ ВУ может быть не сложнее трёх проводов с кнопкой, а может быть целым специализированным компьютером со своим процессором, памятью, регистрами и т. п.

Способы взаимодействия с ВУ на разных архитектурах

• Унифицированный: ∃ стандарт на команды и логику работы ВУ

  • ВУ слишком разные, общий стандарт запредельно сложен
  • Логику сложных ВУ надо уметь программировать непосредственно при работе (а что вообще тв них за процессоры стоят?)

• Порты В/В: стандартизуется только способ обращения к ВУ

  • все каналы связи с ВУ (т. н. порты) как-то нумеруются

  • вывод — инструкция out данные номер_порта ; ввод — инструкция in приёмник номер_порта

  • что означают передаваемые и принимаемые данные — зависит от самого устройства и способа его физического подключения (например, один бит = один провод)
• MMIO: отображение В/В на оперативную память (используется в MIPS)
  • вместо портов используются обычные адреса и команды работы с памятью
  • обращение к адресу из определённого диапазона приводит к обмену данными с ВУ, а не с оперативной памятью

  • соответствие конкретных адресов конкретным интерфейсам ВУ определяется как-то

  • вариант: отображается целая область памяти ВУ (например, страница видеопамяти)

MMIO-регистры бывают

• управляющими (запись = команда ВУ или изменение его состояния)
• регистрами данных (запись/чтение данных, соответствующих команде)
• статусными (только чтение информации о состоянии ВУ)
  • часто встречается т. н. «флаг готовности» — бит, который равен единице ,если устройство готово что-то делать (пришли новые данные в устройство ввода, все данные устройства вывода переданы и т. п.)

Работа процессора с MMIO:

• Арбитраж (какие операции В/В делать первыми)
• Сопоставление MMIO-адреса устройству
• Превращение MMIO-адреса во внутреннюю операцию обмена данными с ВУ
• Анализ состояния ВУ и отображение на MMIO-ячейке
• Передача данных от/к ВУ

Взаимодейстие на основе опроса

Поллинг (polling, опрос) — способ работы с внешними устройствами, при котором программа регуларно проверяет готовность устройства к В/В, и если готовность есть, осуществляет соответствующую операцию.

Организация поллинга из программы:

1. Подготовка устройства к работе
2. Цикл
   1. Проверка готовности устройства
   2. Если устройство готово
      • Операция В/В
      • Выход из цикла
   3. Если устройство не готово
      • Бессмысленное ожидание
3. Перевод устройства в исходное состояние

Замечание: пункт «бессмысленное ожидание» (бессмысленная трата процессорного времени!) можно было бы заменить на «выполнение полезных действий», но

• Всё происходит в процедуре обмена с ВУ, которая может и не знать о ом, какие действия полезны (это вообще может быть подпрограмма, вызываемая из многих мест)

• «Полезные действия» в этом случае должны длиться строго определённое время (время ожидания готовности). Отмерить бессмысленные действия намного проще.

Цифровой блок Mars

Цифровой блок «Digital Lab Sim» — это воображаемое внешнее устройство для Mars, позволяющее потренироваться в организации ввода и вывода

Выглядит в работе оно так:

• Чтобы Mars «увидел» устройство, нужно «подключить» его нажатием кнопки «Connect to MIPS».

Если записать байт в регистр 0xFFFF0010, на правом индикаторе загорятся красным некоторые сегменты, а некоторые станут серыми. Сегментов всего семь, восьмая — точка, так что каждый бит байта отвечает за свою лампочку. Запись 0 погасит все сегменты, запись 0xff — зажжёт. Аналогично для регистра 0xFFFF0011 и левого индикатора. Считать содержимое индикатора нельзя.

Например, при выполнении следующего кода:

    lui   $t8 0xffff              # база MMIO
    li    $t1 0xdb
    sb    $t1 0x10($t8)
    li    $t2 0x66
    sb    $t2 0x11($t8)

Получим вот такой результат ☺ :

Если с выводом в цифровые окошки всё более-менее (а всё-таки, какие биты каким сегментам соответствуют?) понятно, то ввод с клавиатуры на первый взгляд кажется совершенно эзотерическим:

• Возвращается не номер клавиши, а битовая маски, в которой четыре бита соответствуют колонке и четыре столбцу. Если клавиша активна, два бита будут выставлены в 1
• Чтобы получить ответ, надо запустить операцию сканирования, а затем считать результат
• Операцию сканирования надо проводить с каждой строкой клавиатуры по отдельности!

Дело в том, что это устройство спроектировано «как в жизни». Предполагается, что в клавиатуре есть всего 8 проводов (как в матрице памяти) – 4×4 – и всё, что можно сделать — это подать напряжение на один из горизонтальных проводов и отобразить, на какой вертикальный провод он замкнут, если соответствующая клавиша нажата.

Сравнительно несложно обеспечить соответствие провода, на котором обнаружилось напряжение, отдельному биту в регистре, а также произвести простейшие операции над этими битами.

Однако более сложные логические цепочки — шифратор ( для превращения провода N в двоичное число), дешифратор (обратно), сумматор и т. п. — в подобных «железках» обычно отсутствуют.

Вот и выходит, что задача превратить «сырые» данные устройства в осмысленные ложится на программу.

Итак, для того, чтобы просканировать, нажата ли какая-нибудь клавиша в ряду «0-1-2-3», надо:

1. «Подать напряжение на нулевую строку», то есть записать в 0xffff0012 число, у которого только нулевой бит равен 1 (это число 1)

2. Считать из регистра 0xffff0014 значение. Если клавиша в нулевом ряду не нажата, вернётся 0, если нажата, вернётся число, в котором

   • установлен в 1 ровно один из первых четырёх битов, соответствующий нулевой строке (так же, как в операции сканирования)
   • установлен в 1 ровно один из битов 4…7, в соответствие со столбцом, в котором находится нажатая клавиша (0x10,0x20,0x40 и 0x80 для клавиш «0», «1», «2» и «3» соответственно)
   • например, для клавиши «2» ответ будет 0x41
3. Кусок кода при этом может выглядеть так:

           li      $t0 1                   # первая строка
           sb      $t0 0xffff0012          # «подаём напряжение»
           lb      $t0 0xffff0014          # забираем результат

4. Для «подачи напряжения» на другие строки («4-5-6-7», «8-9-a-b» или «c-d-e-f») в 0xffff0012 надо записывать 2, 4 или 8. Из 0xffff0014 будет считываться число, у которого первые четыре бита установлены аналогично (если нажата клавиша в соответствующем ряду, иначе считывается 0)
5. Если записать в 0xffff0012 число, отличное от 1,2,4 или 8, вернётся всегда 0 (более умное устройство подало бы напряжение на провод «ошибочная операция», который можно было бы прочитать в регистре статуса)

Пример: просканировать цифровую клавиатуру и полученное значение записать в правое окошко. В левое окошко записывается количество нажатий. Оба значения не приводят к каким-то осмысленным изображениям в цифровых окошках, но по правому видно, что результат сканирования имеет активными всегда 2 бита.

•         lui     $t8 0xffff              # база MMIO
          move    $t7 $zero               # счётчик
          move    $t6 $zero               # предыдущее значение
  loop:
          move    $t1 $zero               # общий результат сканирования
          li      $t0 1                   # первый ряд
          sb      $t0 0x12($t8)           # сканируем
          lb      $t0 0x14($t8)           # забираем результат
          or      $t1 $t1 $t0             # добавляем биты в общий результат
          li      $t0 2                   # второй ряд
          sb      $t0 0x12($t8)
          lb      $t0 0x14($t8)
          or      $t1 $t1 $t0
          li      $t0 4                   # третий ряд
          sb      $t0 0x12($t8)
          lb      $t0 0x14($t8)
          or      $t1 $t1 $t0
          li      $t0 8                   # четвёртый ряд
          sb      $t0 0x12($t8)
          lb      $t0 0x14($t8)
          or      $t1 $t1 $t0
          beq     $t1 $t6 same
          sb      $t1 0x10($t8)           # запишем результат в биты окошка
          move    $a0 $t1                 # выведем результат как двоичное
          li      $v0 35
          syscall
          li      $a0 10
          li      $v0 11
          syscall
          addi    $t7 $t7 1               # счётчик
          sb      $t7 0x11($t8)           # запишем его в другое окошко
          move    $t6 $t1
  same:   ble     $t7 20 loop
  
          li      $v0 10
          syscall

Последовательность внутри цикла — команды запуска считывания соответствующего ряда и аккумуляции считанных значений. Программа выполняет поллинг, но без заполнения промежутков между опросами устройства «бессмысленным ожиданием»: после каждого опроса немедленно начинается следующий. На практике такие программы начинают потреблять чень много процессорного времени, не делая почти ничего (пользователь — самое медленное на свете устройство ввода ☺). Чтобы ожидание меньше нагружало процессор, можно использовать системный вызов sleep (32), которрый передаёт управление операционной системе на указанный в миллисекундах период. Может, хоть ОС в это время будет делать что-то полезное?