Формат ассемблерных руководств
Процессор NM6403 трудится с машинными командами 32-х и 64-х разрядного формата, причем в одной машинной команде содержится две операции процессора. В этом смысле NM6403 представляет собой скалярный процессор со статической Very Long Instruction Word ( V LIW) — архитектурой. Наряду с этим употребляются маленькие и долгие руководства. При чем маленькие инструкциине содержат константы и имеют разрядность 32 бита. А долгие инструкциисодержат в коде команды 32-х разрядную константу. Исходя из этого их разрядность образовывает 64 бита. Процессор адресуется к 32-х разрядным словам. На хранение маленьких руководств отводится одна ячейка памяти, для долгих – две.
ПримечаниеДлинные инструкции постоянно располагаются по четным адресам.
В случае, если начало долгой инструкции при компиляции ассемблером приходится на нечетный адрес, перед ней машинально вставляется безлюдная команда nul.
Процессор NM6403 за одно обращение к памяти считывает или две маленьких руководства, или одну долгую, исходя из этого регистр pc, определяющий адрес следующей считываемой инструкции, постоянно имеет четное значение.
Все инструкции процессора NM6403 делятся на два типа:
- скалярные руководства, каковые руководят работой скалярного RISC-ядра, таймеров, реализовывают загрузку/чтение всех регистров (дешёвых по чтению/записи) за исключением векторных регистров, образующих очереди FIFO;
- векторные руководства, каковые руководят работой векторного процессора.
Обе части инструкции выполняются процессором в один момент за один такт. В левойчасти руководства записываются лишь адресные операции, в правойвсе арифметическо-логические, не связанные с обращением и вычислением адресов к памяти. Левая и правая части инструкции соединяются воедино при помощи главного слова with.
Пример скалярной инструкции процессора:
gr 0 = [ ar 0++] with gr 1 = gr 3 + gr 0;
gr 1 = gr 3 + gr 0 – правая часть инструкции, арифметическая операция.
gr 0 = [ ar 0++] – левая часть инструкции, адресная операция.
В языке ассемблера левая либо правая часть инструкции возможно опущена, но потому, что процессор не имеет возможности выполнить лишь левую либо лишь правую часть команды, вместо опускаемой части при компиляции машинально добавляется безлюдная операция nul. Другими словами ассемблерная инструкция, записанная как: gr0 = [ar0++];
трактуется ассемблером как: gr 0 = [ ar 0++] with nul ;
Подобно с левой частью: gr1 = gr3 + gr 0;
рассматривается как: nul with gr 1 = gr 3 + gr 0;
Для улучшения читаемости программы, если левая либо правая часть инструкции не употребляется, связка with может опускаться.
Примечание:Векторные и скалярные руководства не смогут смешиваться в одной команде, даже в том случае, если у одной из них опущена левая часть, а у второй правая.
Векторные руководства процессора
Векторные руководства процессора, кроме этого как и скалярные, поделены на левую и правую части. Но кроме этого они имеют дополнительное поле, которое присутствует во всех векторных руководствах за исключением одиночных руководств ftwи wtw. Поле, о котором идет обращение, именуется полем количества повторений. Вот пример того, как выглядит векторная инструкция:
rep 32 data = [ar1++] with vsum , data, afifo;
Левая и правая часть векторной инструкции поделены главным словом with , поле количества повторений (выделено) определяет, сколько долгих слов будет обработано данной приказом. Как правило векторная команда будет выполняться столько тактов, каково значение счетчика, потому, что операция над долгим словом в векторном процессоре выполняется за один такт.
, если левая часть инструкции опущена, слово и поле повторения-связка with остаются при написании инструкции, к примеру:
rep 16 with ram — 1; // верная инструкция
Каждые другие формы записи инструкции, как то
rep 16 ram — 1; либо with ram — 1; // содержат неточности
являются ошибочными, о чем скажет компилятор.
Регистры процессора
Главные регистры
К главным регистрам процессора относятся 8 адресных регистров: ar0 — ar7( sp ) и 8 регистров неспециализированного назначения: gr0 — gr0, каковые употребляются в большинстве вычислительных операций процессора. Все они 32-х разрядные, дешёвы как по чтению, так и по записи.
Адресные регистры
Адресные регистры делятся на две равноправные группы. В первую входят ar0-ar3 , а во вторую ar4..ar7 . Это связано с наличием двух адресных устройств в процессоре.
Существуют ограничения на возможность применять адресные регистры из различных групп в одной процессорной инструкции. Наряду с этим адресные регистры смогут употребляться лишь в левой части ассемблерной инструкции.
Примеры применения адресных регистров:
ar0 = ar5; // копирование .
ar2 = ar3 + gr3; // модификация.
[ar4++] = gr7 with gr7 -= gr4 ; // запись в память.
Адресный регистр ar7 употребляется процессором в качестве указателя стека адресов возврата sp(Stack Pointer) . Это указывает, что ar7 модифицируется машинально, в то время, когда происходит вызов функции либо прерывания, и возврат из функции либо из прерывания.
Регистры неспециализированного назначения
Регистры неспециализированного назначения в отличии от адресных не имеют разделения на группы, смогут употребляться как в левой, так и в правой частях ассемблерной инструкции. С их помощью возможно делать арифметические и логические преобразования, адресоваться по памяти. Не смотря на то, что регистры неспециализированного назначения смогут употребляться для адресации по памяти, к примеру:
[gr0] = gr4; // запись значения регистра gr4 в память
// по адресу, хранящемуся в gr0.
Но адресные регистры владеют в этом смысле намного более широкими возможностями.
Примеры применения регистров неспециализированного назначения:
gr0 = gr5; // копирование.
gr2 = gr1 + gr3; // модификация.
[ar4++] = gr7 with gr7 -= gr4 ; // запись в память.
ПримечаниеВ процессоре NM6403 не предусмотрены особые регистры для организации программных циклов.
ПРИМЕРЫ НЕСЛОЖНЫХ ПРОГРАММ
Пример 1: доступ и Организация циклов к памяти
Пример демонстрирует несложный способ организации цикла руководствами -начало цикла и if goto Loop; — финиш цикла при заполнении массива данных возрастающими значениями.
global __main: label; // объявление глобальной метки.
nobits .MyData1 // секция неинициализированных данных.
global C:word[16]; // заявили массив из 16 32-разрядных слов
end .MyData1;
begin . textAAA // начало секции кода.
ar0 = C; // в ar0 загрузили адрес массива С.
gr0 = 0; // в gr0 загрузили значение 0.
gr1 = 16; // в gr1 загрузили значение 16, равное количеству итераций в цикле.
[ar0++] = gr0; // в память по адресу ar0 записываем
// содержимое gr0, а после этого увеличиваем
// адрес на 1 (пост-инкрементация).
gr0++; // увеличили значение gr0 на 1
gr1—; // уменьшили значение gr1 на 1, так установили флаг в регистре pswr для предстоящей проверки
if goto Loop; // в случае, если условие выполнено, осуществляется переход на метку Loop.
return;
end .textAAA; // показатель окончания секции кода.
Комментарии. В примере массив С в цикле последовательно заполняется возрастающими значениями. Цикл организован методом перехода на заданную метку при исполнении определенных условий (посредством команд условного перехода).
Пример 2: Копирование массива данных на скалярном процессоре
Пример демонстрирует два метода копирования массива 64-разрядных слов на скалярном процессоре. Первый метод – простое копирование, второй – копирование при помощи регистровых пар.
global __main: label; // объявление глобальной метки.
data .MyData // секция инициализированных данных массив А из 16 64-разрядных слов заполняется начальными значениями
global A: long[16] = (0l,1l,2l,3l,4l,5hl,6l,7l,8l,9l,
10l, 0Bhl, 0Chl, 13l, 14l, 15l);
end .MyData;
nobits .MyData1//секция неинициализированных данных.
global B:long[16];//объявляется массив В из 16 64-разрядных слов
global C:long[16]; // объявляется массив С из 16 64-разрядных слов
end .MyData1;
begin .textAAA // начало секции кода .
// простое копирование массива данных на скалярном процессоре
ar0 = A;
ar1 = B;
gr1 = 32; // счётчик цикла ( 32 цикла для копирования 16 64-bit слов)
gr1—; // устанавливается флаг для первого вхождения в цикл
// в случае, если условие выполнено, осуществляется отложенный переход на метку Loop
if delayed goto Loop with gr1—;// чтение из памяти 32-разрядного слова
gr2 = [ar0++];// запись в память 32-разрядного слова
[ar1++] = gr2; // копирование массива данных при помощи регистровых пар
ar0 = A;
ar1 = B;
gr1 = 16;// счётчик цикла ( 16 циклов для копирования 16 64-bit слов)
gr1—; // устанавливается флаг для первого вхождения в цикл
// в случае, если условие выполнено, осуществляется отложенный переход на метку Loop1
if delayed goto Loop1 with gr1—;
// чтение из памяти 64-разрядного слова
gr2,ar2 = [ar0++];
// запись в память 64-разрядного слова
[ar1++] = ar2,gr2;
return;
end .textAAA; // показатель окончания секции кода.
Комментарии.В первой части примера копирование данных осуществляется через один 32-х разрядный регистр. На первом шаге в регистр заносится слово из памяти, на втором оно копируется из регистра в память По другому адресу. В этом случае значения адресных регистров любой раз возрастают на единицу. Потому, что нужно скопировать массив из шестнадцати 64-х разрядных слов, а за один цикл копирования через регистр переносится одно 32-х разрядное число (младшая либо старшая добрая половина 64-х разрядного слова), то чтобы скопировать целый массив нужно выполнить тридцать двацикла.
Во второй части примера копирование происходит через регистровую несколько ar2 , gr2 (в регистровой паре каждому адресному регистру поставлен в соответствие регистр неспециализированного назначения с тем же номером). За один цикл чтения/записи переносится полностью 64-разрядное слово, исходя из этого количество циклов копирования равняется шестнадцати.
При чтении из памяти в регистровую несколько ar2,gr2 = [ar0++]; всега младшая часть 64-разрядного слова попадает в arX , старшая – в grX независимо от того, в каком порядке перечислены регистры в паре. Те же правила действуют при записи содержимого регистровой пары в память. По младшему адресу постоянно записывается содержимое регистра arX , по старшему — grX . Так, команда [ar1++] = gr2,ar2 ; запишет данные в память в том же порядке, в каком они были считаны, независимо от того, в какой последовательности перечислены регистры регистровой пары.
Вторым серьёзным моментом, на что стоит обратить внимание, есть то, как изменяются значения адресных регистров, применяемых для доступа к памяти. И в первой, и во второй части примера употребляется одинаковая форма записи для инкрементации регистров ar0 и ar1 . Но в первой части, в то время, когда выполняется 32-х разрядный доступ к памяти, значения адресных регистров возрастают на единицу, а во второй на двойку.
Процессор машинально распознаёт, какой тип доступа к памяти употребляется в заданной инструкции – 32-х либо 64-х разрядный.
Наличие в инструкции регистровой пары либо 64-х разрядного регистра управления ведет к тому, что доступ к памяти ведётся 64-х разрядными словами. Но потому, что единица адресации — 32-х разрядное слово, то при 64-х разрядном доступе несложная инкрементация адресного регистра ведет к повышению его значения на два, к примеру:
gr2 = [ar0++]; // ar0 возрастает на 1
ar2,gr2 = [ar0++]; // ar0 возрастает на 2
Пример 3: Копирование массива данных на векторном процессоре
Пример демонстрирует копирование массива 32-разрядных слов посредством векторного процессора.
global __main: label; // объявление глобальной метки.
data .MyData // секция инициализированных данных массив А из 16 32-разрядных слов заполняется начальными значениями
global A: word[16] = (0,1,2,3,4,5h,6,7,8,9,10,0Bh,0Ch,13,14, 15);
end .MyData;
nobits .MyData1 // секция неинициализированных данных.
global B:word[16]; // объявляется массив В из 16
// 32-разрядных слов
global C:word[16]; // объявляется массив С из 16
// 32-разрядных слов
end .MyData1;
begin . textAAA // начало секции кода.
// копирование массивов данных
ar0 = A; // посредством векторного процессора
ar1 = C; // массив А подаётся на векторное АЛУ и попадает в afifo без трансформаций
rep 8 data = [ar0++] with data;// сохранение во внешней памяти содержимого afifo, заполненного прошлой векторной инструкцией.
rep 8 [ar1++] = afifo;
return;
end .textAAA; // показатель окончания секции кода.
Комментарии.Необходимым атрибутом векторной инструкции есть количество повторений, определяющее, какое количество 64-х разрядных векторов данных обрабатывается данной инструкцией. В этом смысле векторные руководства являются SIMD (Single Instruction Multiple Data) руководствами, делая одно да и то же воздействие над несколькими векторами данных.
Команда
rep 8 [ar1++] = afifo;
осуществляет выгрузку данных из afifo в память с постинкрементацией адресного регистра. ( rep кол-во выгружаемых слов). Запрещено выгружать эти по частям (к примеру, сперва 4, а позже еще 4 слова), лишь полностью все содержимое afifo .
Содержимое afifo не может быть выгружено в регистры процессора либо регистровые пары, лишь в память.
Пример 4: Операция взвешенного суммирования
Демонстрируется пример применения устройства умножения, теневой и рабочей матрицы, входящих в состав векторного процессора NeuroMatrix. В примере рассмотрено применение операции взвешенного суммирования для перестановки байтов в 64-х разрядного вектора данных.
global __main: label; // объявление глобальной метки.
data .MyData//секция инициализированных данных исходный вектор
A: long = 8877665544332211hl;
// место для хранения результата вычислений
B: long = 0l;// массив Matr содержит значения для заполнения матрицы весовых коэфициентов
Matr: long[8] = (0100000000000000hl,
0001000000000000hl,
0000010000000000hl,
0000000100000000hl,
0000000001000000hl,
0000000000010000hl,
0000000000000100hl,
0000000000000001hl);
end .MyData;
begin .textAAA // начало секции кода .
ar1 = Matr;
nb1 = 80808080h; // матрица делится на 8 столбцов по 8 бит
sb = 03030303h; // матрица делится на 8 строчков
// весовые коэффициенты загружаются в буфер wfifo
rep 8 wfifo = [ar1++];
ftw; // весовые коэффициенты пересылаются в теневую матрицу с перекодировкой. Эта инструкция постоянно выполняется 32 такта.
wtw; // весовые коэф.копируются из теневой матрицы в рабочую
ar2 = A;
ar4 = B;// операция взвешенного суммирования, переставляющая местами байты вектора.
rep 1 data = [ar2] with vsum , data, 0;
// итог операции выгружается из afifo в память
rep 1 [ar4] = afifo;
return;
end .textAAA; // показатель окончания секции кода.
Комментарии.Задачей данного примера есть перестановка порядка элементов в 64-разрядном векторе из состояния A = 8877665544332211hl в состояние В = 1122334455667788hl . Эта перестановка выполняется на устройстве умножения векторного процессора при помощи операции взвешенного суммирования. Главная мысль этого преобразования:
Рисунок 3.1Перестановка Элементов Вектора на Матричном Умножителе
Команда rep 8 wfifo = [ar1++]; осуществляет загрузку весовых коэффициентов из памяти в регистр-контейнер wfifo . Загрузку возможно осуществлять и по частям, но так, дабы не случилось переполнения. Контейнер wfifo имеет глубину в тридцать два 64-х разрядных слова.
Команда ftw; делает перекодировку весовых коэффициентов, расположенных в wfifo , в особый вид, в котором они сохраняются в теневой матрице. Эта операция постоянно выполняется за 32 такта, но, она может выполняться параллельно с другими векторными руководствами.
Команда wtw; копирует весовые коэффициенты из теневой матрицы в рабочую.
Инструкция
rep 1 data = [ar2] with vsum , data, 0;
делает взвешенное суммирование с коэффициентами, каковые прежде были загружены в рабочую матрицу. Вычисление производится по схеме приведённой на рисунке 3.1.
ПОРЯДОК Исполнения РАБОТЫ
Практическая часть работы предполагает разработку несложной программы на ассемблере. Программа заполняет блок памяти возрастающими значениями, а после этого делает кое-какие манипуляции над ним. Блок памяти (либо массив) будем разглядывать складывающимся из элементов определённой разрядности. Для простоты, будем брать лишь кратные двум разрядности (к примеру, 2, 4, 8, 16, 32, 64 бит) дабы блок в любой момент возможно было представить из целого количества таких элементов. Наряду с этим, элементы имеют порядковые номера от начала блока: 0, 1, 2,… Под четными/нечетными элементами будем осознавать элементы с четными / нечетными порядковыми номерами. Ещё раз, направляться обратить внимание на то, что нумерация начинается с нуля! , а ноль – это четное число. Так же, направляться уточнить, что понимается под хорошими/отрицательными числами. Все числа, старший разряд которых =1 процессор принимает как отрицательные, а все остальные – как хорошие.
В качестве ассистента при написании программы будем применять программу NMCalculator.
Для отладки программы воспользуемся особым отладчиком emudbg . exe , поставляемым вместе с пакетом разработчика для процессора NM 6403.
Задание:
1. Заполнить блок памяти размером в 8 64-разрядных слов (либо, что то же самое, – 16 32-разрядных слов) элементами долгой 32 бита возрастающими с INC на INC , где INC = этот год * (номер бригады + количество человек в бригаде + сумма цифр номера группы). Разработать программу для исполнения этого задания (см. разобранный пример для 11 варианта), скомпилировать её в делаемый файл (*. abs ) и отладить её на отладчике emudbg . exe . Зафиксировать в отчете полученный блок памяти с указанием его начального и конечного адреса.
Для написания текста программы направляться воспользоваться любым текстовым процессором не сохраняющим знаки форматирования (к примеру, notepad . exe ). Файл направляться сохранить с расширением *. asm .
Для компиляции взятого файла нужно поместить его в каталог, где установлен пакет разработчика для NM 6403. Это возможно каталог: С:\ Program Files \ Module \ Nmsdk \ bin \ либо второй по указанию инженера. Из этого каталога направляться запустить программу компилятора следующей командой: nmcc -g step1.asm libc.lib –m, где step1. asm – имя файла с исходными текстами вашей программы. Рекомендуется создать командный (*. bat ) файл с данной командой, дабы не вводить её любой раз, а запускать уже данный файл. В случае, если компиляция пройдёт удачно, то в этом же каталоге будут созданы пара файлов с тем же именем, но с другими расширениями. Нас из них будут интересовать следующие: *. abs – делаемый файл открываемый из отладчика emudbg . exe , *. map – файл карты памяти в котором возможно просмотреть начальные адреса переменных (то, что объявляется в секциях данных) в памяти для наблюдения за их содержимым в ходе отладки. В случае, если же в ходе компиляции будут найдены неточности в тексте программы, компилятор скажет о них выводом сообщений с указанием номера строчка в которой найдена неточность.
Для отладки скомпилированной программы направляться запустить программу emudbg . exe всё из того же каталога. После этого, в главном меню выбрать пункт: Цель-Загрузить программу и в появивадшемся диалоге указать *. abs -файл вашей программы. Дабы просмотреть разные ресурсы процессора, память и дизассемблированный либо исходный код программы направляться обратиться к соответствующим подпунктам меню Вид. Рекомендуется, в один момент следить как минимум за содержимым: памяти, применяемых программой скалярных и векторных регистров, конфигурацией рабочей матрицы и текущей делаемой строчком исходного текста. Для доступа к ним нужно открыть следующие пункты меню Вид: Память, Регистры, Специфика целевой среды и Исходные тексты-Ваш файл *. asm . Наряду с этим, память во многих случаях будет эргономичнее просматривать не 32-разрядными словами, а 64-разрядными. Для этого: Щелчок правой кнопкой мыши в окне Память-64-битные слова. На панели инструментов отладчика расположены кнопки стремительного доступа к самый применяемым командам, всплывающие подсказки поясняют их назначение. Нам пригодятся: Ход несложной / Ход обходящий – любой из них для исполнения текущей команды; Снять / поставить точку останова; Запуск / Анимация – каждая из них для исполнения уже отлично отлаженной части программы до точки останова, дабы не применять многократно Ход несложной / Ход обходящий. Дабы выгрузить программу из отладчика, но покинуть содержимое памяти и конфигурацию процессора без трансформаций направляться выбрать: Цель-Выгрузить программу. В случае, если же нужен полный сброс процессора в исходное состояние, то направляться выбрать: Цель-Перезагрузить цель.
2. Выполнить обработку взятого блока памяти (массива) в соответствии с вариантом для вашей бригады:
Вариант 1. Вычислить контрольную сумму блока памяти (количество единичных бит) и записать её сходу за финишем блока.
Советы по исполнению: Воспользуйтесь операцией взвешенного суммирования, разбив рабочую матрицу на 32 столбец и 1 строки. На первой стадии, вычислите сумму четных единичных бит (нумерация, как и для элементов блока памяти начинается с нуля, а ноль – четное число) блока памяти. Полученные восемь 64-разрядных частичных суммы запишите в память для их временного хранения. На втором этапе, вычислите сумму нечетных единичных бит. На третьем этапе, просуммируйте частичные суммы четных и нечетных бит. Выгрузите полученные восемь 64-разрядных частичных суммы в память для их временного хранения. На четвертом этапе, просуммируйте полученные частичные суммы на скалярном процессоре (см. разобранный пример для 11 варианта) и запишите итог в память. Для того чтобы получить доступ к четным/нечетным битам входа Х, нужно воспользоваться блоком маскирования задав соответствующие векторы масок:
EvenMask: long = 05555555555555555hl; // маска для четных бит (0101).
OddMask: long = 0aaaaaaaaaaaaaaaahl; // маска для нечетных бит (1010).
Вектор масок направляться хранить в ram , причем столько 64-разрядных слов, сколько раз выполняется векторная команда (в нашем случае – 8). Помимо этого, при суммировании нечетных бит, нужно подключить регистр сдвига, т.к. разрядность элементов входа Х – 2 бита. Чтобы не было путаницы, направляться четко воображать последовательность исполнения всех этих операций в процессоре (см. прошлую работу).
Вариант 2 Прибавить всем четным элементам разрядностью 16 бит сегодняшнее число. После этого, вычислить сумму 0-го и 1-го 64-разрядных элементов и записать её сходу за финишем блока.
Вариант 3. Умножить любой элемент блока памяти разрядностью 8 бит на количество человек в бригаде. После этого, отыскать разность между 2-ым и 0-ым 32-разрядными элементами и записать её сходу за финишем блока 64-разрядным словом с обнулением старших 32 разрядов этого слова.
Вариант 4. Вычесть из каждого нечетного элемента разрядностью 32 бита прошлый (четный) элемент. После этого, отыскать итог логического «либо» 0-го и 4-го элементов разрядностью 16 бит и записать его сходу за финишем блока 64-разрядным словом с обнулением старших 48 разрядов этого слова.
Советы по исполнению: Для исполнения первой части задания воспользуйтесь операцией взвешенного суммирования. Задайте нужное разбиение рабочей матрицы и весовые коэффициенты. Для исполнения второй части задания направляться воспользоваться соответствующей операцией на векторном АЛУ. Наряду с этим помните, что разбиение на элементы при применении векторного АЛУ одинаково для входов Х и Y , и задаётся регистром nb (см. разобранный пример для 11 варианта). Ответьте на вопрос – воздействует ли разбиение на итог вашей операции на ВАЛУ?
Вариант 5. Поменять местами соседние четные и нечетные 16-разрядные элементы. После этого, отыскать итог логического «и» 0-го и 1-го 64-разрядных слов и записать его сходу за финишем блока.
Вариант 6. Отыскать сумму всех четных 32-разрядных элементов. После этого, обнулить у всех 32-разрядных элементов блока биты, каковые в взятой сумме равны нулю.
Вариант 7. Проинвертировать побитно блок памяти, а после этого отыскать итог логического «и» исходного и проинвертированного блока.
Вариант 8. Замените все неотрицательные 4-разрядные элементы нулём, а отрицательные – минус единицей. После этого, замените все -1 на 1, а нулевые элементы покиньте без трансформаций.
Вариант 9. Выполнить арифметическую активацию всех 4-разрядных элементов порогами [-4; 3] (см. прошлую работу). После этого отыскать итог «исключающего либо» 0-го и 7-го (последнего) 64-разрядных элементов, и записать его сходу за финишем блока.
Советы по исполнению: Для арифметической активации нужно составить 64-разрядную константу задающую пороги активации. Адрес последнего 64-разрядного элемента возможно взять двойным декрементом счетчика адреса по окончании исполнения активации.
Вариант 10. Переставить в каждом 64-разрядном элементе 4-разрядные тетрады в обратном порядке, по окончании чего проинвертировать побитно целый блок памяти.
Вариант 11. Прибавить всем четным 16-разрядным элементам следующий за ними нечетный элемент, умноженный на 2 и уменьшенный на 1. По окончании чего, отыскать итог операции исключающего либо над 0-ым и 4-ым 16-разрядными элементами блока памяти, итог которой записать в память 64-разрядным словом сходу за финишем блока с обнулением оставшихся 48 старших бит слова. После этого, отыскать сумму всех нечетных 8-разрядных элементов блока памяти в формате 32-разрядного слова.
3. Отладить по шагам взятую программу и убедиться в её правильности. Зафиксировать в отчете результаты и текст программы её работы.
КОНТРОЛЬНЫЕ ВОПРОСЫ
- Перечислите главные внутренние блоки процессора NM 6403 и поясните их назначение.
- Какова разрядность интерфейса с внешней памятью процессора NM 6403?
- назначение и Состав скалярного процессора.
- Перечислите главные элементы векторного процессора и поясните их назначение.
- Какова разрядность узлов векторного процессора?
- Как возможно организовано и обработано слово упакованных векторных данных?
- Какие конкретно операции способен делать векторный процессор?
- Поясните сущность операции взвешенного суммирования и приведите примеры её применения.
- Какие конкретно операции способно делать векторное АЛУ? Чем оно отличается от скалярного АЛУ?
- Каковы особенности исполнения операций на векторном АЛУ при происхождении переполнений?
- Чем определяется разбиение на элементы при операциях на рабочей матрице и на векторном АЛУ?
- Поясните сущность операции маскирования с векторным умножением.
- Поясните сущность операции логического маскирования, с какими операциями она употребляется?
- Поясните сущность операции арифметической активации, с какими операциями она употребляется?
- Поясните сущность операции логической активации, с какими операциями она употребляется?
- Поясните сущность операции циклического сдвига вправо операнда Х , с какими операциями она употребляется?
- Каков порядок исполнения преобразований над данными на векторном процессоре?
ЛАБОРАТОРНАЯ РАБОТА № 3
Программирование нейромикропроцессора NeuroMatrix ® NM 6403 с применением макросов
Цель работы:ознакомление с языком ассемблера нейромикропроцессора NeuroMatrix ® NM 6403 (Л18789 ВМ1) и правилами использования и описания макросов в программе..
ПОРЯДОК Исполнения РАБОТЫ
По данным разделов 2 и 3 изучить структуру формат ассемблерных руководств структуру микрокоманд (МК), порядок ввода данных, выполнение и кодирование МК.
По данным раздела 4 ознакомиться с порядком ввода микропрограмм и данные.
Выполнить упражнения из раздела 5 по указанию учителя.