CC BY
124
УДК 621.3
РАЗРАБОТКА МОДЕЛИ МИКРОПРОЦЕССОРНОГО ЯДРА В СИСТЕМЕ
MATLAB/SIMULINK
А.В. Строгонов, С.А. Цыбин, А.И. Буслов, О.А. Золотухина
В статье рассматривается разработка модели микропроцессорного ядра с использованием системы визуального имитационного моделирования МаНаЪ/ВтиНпк для реализации в базисе программируемых логических интегральных схем
Ключевые слова: микропроцессор, распределенное управление, й-объекты системы Ма1аЪ/81ши1шк
В работах [1,2] с использованием системы команд из работ [3,4] показаны примеры проектирования микропроцессорных ядер для реализации в базисе ПЛИС фирмы Altera, как с использованием мегафункций асинхронного ОЗУ/ПЗУ САПР Quartus II, так и с использованием функциональных блоков на языке VHDL, сгенерированных с помощью Simu-link HDL Coder системы Matlab/Simulink. Общим недостатком работ [1,2] является отсутствие управляющего автомата.
В работе предлагается на основе системы команд из работы [4] спроектировать в системе Matlab/Simulink процессор с управляющим автоматом и позволяющим проводить вычисления с фиксированной зяпятой. Выполнение арифметических операций над операндами, представленными в формате с фиксированной запятой, позволяет получать высокую скорость вычислений, но возможно переполнение разрядной сетки либо значительной погрешности из-за округления [5].
На рисунке показан процессор с управляющим автоматом на шесть состояний и его отладка в системе Matlab/Simulink с использованием отладчика (Simulink Debugger). Перед отладкой необходимо в меню Simulation/Configuration Parameters выбрать диалог Solver (“решатели”, методы численного решения дифференциальных и дифференциальноалгебраических уравнений). В Solver options выбрать Type: Fixed-step; Solver: discrete (no continuous state); Fixed step size (fundamental sample time) - 1.0. Осуществляется тестирование команд MOV A,12; MOV B,23; ADD A,B (рисунке).
Проектируемый процессор состоит из следующих блоков: управляющий автомат (блок
CPU_Controller, пример); память программ - ПЗУ процессора (блок Memory); АЛУ процессора (блок
Строгонов Андрей Владимирович - ВГТУ, д-р техн. наук, профессор, тел. (4732) 43-76-95, E-mail: andreis@hotmail.ru Цыбин Сергей Александрович - ОАО “Конструкторско-технологический центр “Электроника”, соискатель, тел. (4732) 43-76-95, E-mail: chipcec@comch.ru Буслов Артем Иванович - ВГТУ, магистрант, тел. (4732) 43-76-95, E-mail: buslov-artem@yandex.ru Золотухина Ольга Анатольевна - ВГТУ, аспирант, тел. (4732) 43-76-95, E-mail: olga_03_84@mail.ru
alu); двух регистров общего назначения (РОН, блоки RegisterA и RegisterB); регистра специального назначения (РСН, блок PC_Inc), необходимого для обеспечения “прыжковых” команд, таких как JMP, JMPZ, CALL и RET; счетчика команд (блок PC); регистра инструкций (блок Instruction_Reg).
Процессор реализован в формате с фиксированной запятой, с использованием fi-объектов системы Matlab. Будем используем следующий формат, для представления десятичных чисел: a = fi(v, s, w, f), где v - десятичное число, s - знак (О (false)- для чисел без знака и 1 (true) - для чисел со знаком), w -размер слова в битах (целая часть числа), f - дробная часть числа в битах. Все используемые десятичные числа в процессоре беззнаковые (положительные) и целые. В системе Matlab пользователь имеет возможность определить беззнаковые (например, uint8, uint16) и знаковые целые числа (sint), с помощью внутренних форматов.
При проектировании процессоров с фиксированной запятой необходимо учитывать следующие факторы: диапазон для результатов вычислений; требуемую погрешность результата; ошибки, связанные с квантованием; алгоритм реализации вычислений и др. Это связано с тем, что десятичное число v представляется с использованием формулы
[5]: V = 2-m x Q, где m — длина дробной части
П—1
числа; для беззнаковых чисел Q = IW x 2i,
і=0
W — весовые коэффициенты, 2і — веса двоичных разрядов машинного слова, n — длина двоичного слова в битах. Диапазон целого беззнакового числа определяется выражением: 0 < V < 2n — 1.
Это можно осуществить с использование следующего формата:
a = fi(v, s, w, f, fimath).
% HDL specific fimath hdl_fm = fimath(...
'RoundMode', 'floor',...
'OverflowMode', 'wrap',...
'ProductMode', 'FullPrecision', 'ProductWordLength',
32....'SumMode', 'FullPrecision', 'SumWordLength',
32....'CastBeforeSum', true);
Процессор c управляющим автоматом в системе Matlab/Simulink. Тестирование команд MOV A,12; MOV B,23;
ADD A,B
Данные настройки вычислений в формате с фиксированной запятой приняты в системе Simu-link по умолчанию. Можно задать режим округления (Roundmode) - ‘floor’ - округление вниз; реакцию на переполнение (OverflowMode) - ‘wrap’ -перенос, при выходе значения v из допустимого диапазона, “лишние” старшие разряды игнорируются. При выполнении операций умножения (‘ProductMode’) и сложения (SumMode), для повышения точности вычислений (precision) используется машинное слово шириной в 32 бита.
Для блоков РОН, в качестве примера, используем формат a = fi(v, s, w, f, fimath). Можно также добавить учет выше приведенных факторов и в другие M-файлы функций блоков процессора. Это позволит “управлять” встроенным генератором кода языка HDL (Simulink HDL Coder). Если этого не сделать, то необходимо с использованием проводника модели осуществить настройки блоков процессора для вычислений в формате с фиксированной запятой.
Процессор имеет распределенное управление. В блоках alu, RegisterA, RegisterB, PC_Inc и PC, имеется свой локальный управляющий сигнал func, дешифрация которого внутри блоков будет приводить к выполнению некоторых операций, например, к изменению внутреннего содержимого блока или, наоборот, к его сохранению. Например, в блоке АЛУ локальный сигнал func 4 - х разрядный, десятичные числа с 0 по 8 кодируют логикоарифметические операции процессора, такие как ADD A,B; SUB A,B; AND A,B; OR A,B; XOR A,B и DEC и команды пересылки, такие как MOV A,B; MOV B,A; XCHG A,B. В блоках PC_Inc, PC и In-
struction_Reg сигнал Гипс 2 - х разрядный, а в блоках RegisterA и RegisterB 3 - х разрядный.
Пример показывает М-файл функции управляющего автомата микропроцессора в системе МаНаЪ^шиИпк (блок CPU_Contro11er). Управляющий автомат может принимать 6 состояний. Состояния кодируются сигналом CPU_state в формате шШ:8 (целое десятичное число без знака с размером слова 8 бит). По сигналу master_rst (логическая 1), происходит установка автомата в нулевое состояние CPU_state = шШ:8(0). Далее происходит настройка блоков процессора с помощью локальных управляющих сигналов Гипс.
Управляющий автомат формирует на выходе Р^ш^Шпс десятичный ноль, по которому внутреннее содержимое блока РСН будет сброшено (распознается блоком как сигнал сброса), на выходах Р^Шпс и Ш_Шпс формируется десятичное число 3, по которому текущее содержимое счетчика команд и регистра инструкций остается неизменным. На выходах RegA_func и RegB_func формируется десятичное число 4, по которому текущее содержимое регистров общего назначения РОН А и В, также остается неизменным. На выходе АЪи_:Рипс формируется десятичное число 9, по которому в блоке АЛУ произойдет обход логикоарифметических операций и команд пересылки, а значение сигналов на входах шА и шВ будут переданы на выход outA и оиШ без изменений.
На выходах 1М_геа4 addr_inc, Reg_OutA, Reg_OutB автомат формирует десятичные нули. Ноль на выходе IM_read запрещает чтение из ПЗУ программ. А десятичные нули на выходах addr_inc, Reg_OutA и Reg_OutB означают обнуление этих выходов.
В нулевом состоянии (case 0) осуществляется загрузка в РОН (блоки RegisterA, RegisterB), в РСН (блок PC_Inc) и в счетчик команд (блок PC) нуля (десятичный нуль преобразуется в формат с фиксированной запятой с размером слова 8 бит), а в регистр инструкций (Instruction_Reg) также загружается десятичный ноль, но он преобразуется в формат с фиксированной запятой с размером слова і6 бит. Эти операции осуществляются с помощью локальных сигналов управления PC_inc_func, PC_func, IR_func, RegA_func, RegB_func.
Следующим состоянием автомата будет CPU_state = uint8(1). В этом состоянии и в двух последующих состояниях uint8(2) и uint8(3) происходит выделение полей команды. В состоянии і управляющий автомат формирует сигал разрешения чтения команды из памяти IM_read = fi(1, 0, і,
0). Поскольку порядковые номера строк в памяти программ начинаются с і, например, data(1) = fi(1036, 0, 16, 0), то счетчик команд предварительно должен быть обнулен, т. е. нулевое значение счетчика указывает на строку в ПЗУ с порядковым номером і.
Для того чтобы счетчик команд содержал адрес следующей команды, управляющий автомат должен сформировать локальный сигнал управления счетчиком PC_func = fi(2, 0, 2, 0), т.е. на выходе PC_func должно присутствовать десятичное число
2, по которому текущее значение счетчика увеличится на і. Поэтому эта строка стоит второй в операторе case і. Извлеченную команду (в первоначальный момент и в последующие, в регистре инструкций сохраняются текущие команды, а не следующие, загруженные в счетчик по команде PC_func = fi(2, 0, 2, 0)) из памяти программ в этом состоянии необходимо сохранить в регистре инструкций (16-битный регистр). Поэтому автомат сформирует локальный сигнал управления IR_func = fi(1, 0, 2, 0), разрешающий запись команды в регистр. Следующим состоянием, которое примет автомат, будет состояние CPU_state = uint8(2).
Рассмотрим состояние 3 (case 3) управляющего автомата проектируемого процессора. Например, рассмотрим, как обрабатывается команда 1536 (RET). Из регистра инструкций целое беззнаковое десятичное число 1536 (размер слова 16 бит) поступает на вход IR_in управляющего автомата CPU Controller и присваивается переменной main_opcode, которая представляет і6 - ти битную инструкцию (необходимо последовательно копировать ниже приведенные строки фрагмента M-файла и вставлять их в командную строку системы Mat-lab). Из этой инструкции выделяется переменная major_opcode путем сдвига і6 - ти битного вектора вправо на 8 позиций, с размером слова в 4 бита, таким образом мы выделяем, биты с 9 по і2 из і6 -ти разрядной инструкции. В системе команд [4] разряды с і3 по і6 нулевые, поэтому выделение переменной minor_opcode путем побитного И переменной major_opcode (4 разряда) и маски (переменная mask4, 4 разряда) в принципе не обязательно, но не обходимо в случае последующей модифи-
кации системы команд процессора. Для выделения операнда (переменная address_data) из инструкции потребуется маска в 16 разрядов. Побитное И с переменной IR_in и с маской mask8 (0000000011111111) позволяет выделить переменную address_data с размером слова 8 бит. Для команды 1536 переменная address_data это 8 нулей. Следующим состоянием которое примет автомат будет состояние CPU_state = uint8(4).
В состоянии 4 (case 4) происходит декодирование и выполнение инструкции (case 4). Декодирование происходит по сигналу minor_opcode (фактически 9, 10 и 11 биты сигнала IR_in, 12 бит не используется, т. к. он нулевой). Далее, декодируются 6 команд: NOP, JMP, JMPZ, CAL, MOV A,XX, MOV B,XX. Рассмотрим команду JMP. Выделенный операнд address_data из инструкции содержит адрес команды в ПЗУ на который необходимо перейти. Операнд присваевается переменной addr_inc. Автомат формирует локальные сигналы управления РСН - PC_inc_func (десятичное число 1) и счетчика команд - PC_func (десятичное число
1). Далее выделенный операнд (содержит адрес команды на который необходимо перейти) будет загружен в РСН и в счетчик команд. При загрузки операнда в РСН, содержимое счетчика команд при этом сохраняется во внутренней переменной PC_Temp данного регистра.
Если ни одна их этих команд не выполняется, то далее дешифрируются и отрабатываются команда RET, логико-арифметические команды (ADD A,B, OR A,B, XOR A,B, DEC A) и команды пересылки (MOV A,B, MOV B,A, XCHG A,B,). Последним состоянием является состояние case 5. В этом состоянии обновляются регистры РОН A и B, затем будет осущетвлен переход в состояние 1. И весь описанный выше процесс обработки команды повторится вновь и то тех пор, пока не будет отработана последняя команда в программе.
function [ALU_func, IR_func, PC_inc_func, PC_func, addr_inc, IM_read, RegA_func, RegB_func, Reg_OutA, Reg_OutB] = CPU_Controller(master_rst, IR_in, Reg_A)
% CPU Controller % 16-bit Instruction Encoding:
% minor_opcode
% NOP: 00000 000 <00000000>
% JMP: 00000 001 <8-bit>
% JMPZ: 00000 010 <8-bit>
% CALL: 00000 011 <8-bit>
% MOV A,xx: 00000 100 <8-bit>
% MOV B,xx: 00000 101 <8-bit>
% RET: 00000 110 <00000000>
% MOV A,B: 00000 110 <00000001>
% MOV B,A: 00000 110 <00000010>
% XCHG A,B: 00000 110 <00000011>
% ADD A,B: 00000 110 <00000100>
% SUB A,B: 00000 110 <00000101>
% AND A,B: 00000 110 <00000110>
% OR A,B: 00000 110 <00000111>
% XOR A,B: 00000 110 <00001000>
% DEC A: 00000 110 <00001001>
persistent CPU_state; if(isempty(CPU_state))
CPU_state = uint8(0); end
if(master_rst)
CPU_state = uint8(0); end
PC_inc_func = fi(0, 0, 2, 0);
IR_func = fi(3, 0, 2, 0); % NOP PC_func = fi(3, 0, 2, 0); % NOP IM_read = fi(0, 0, 1, 0); addr_inc = fi(0, 0, 8, 0);
Reg_OutA = fi(0, 0, 8, 0);
Reg_OutB = fi(0, 0, 8, 0);
RegA_func = fi(4, 0, 3, 0); % NOP RegB_func = fi(4, 0, 3, 0); % NOP ALU_func = fi(9, 0, 4, 0); % NOP % main_code: <16..1>
% major_opcode: <16..9>
% minor_opcode: <12..9>
% address_data: <8..1> persistent main_opcode; persistent major_opcode; persistent minor_opcode; persistent address_data; if(isempty(major_opcode)) main_opcode = fi(0, 0, 16, 0); major_opcode = fi(0, 0, 4, 0); minor_opcode = fi(0, 0, 4, 0); address_data = fi(0, 0, 8, 0); end
switch(CPU_state)
% RESETTING OUTPUTS case 0,
PC_inc_func = fi(0, 0, 2, 0);
PC_func = fi(0, 0, 2, 0);
IR_func = fi(0, 0, 2, 0);
RegA_func = fi(0, 0, 3, 0);
RegB_func = fi(0, 0, 3, 0);
CPU_state = uint8(1);
% FETCH case 1,
% Read from IM (ROM)
IM_read = fi(1, 0, 1, 0);
% PC increment PC+1 PC_func = fi(2, 0, 2, 0);
% store into IR IR_func = fi(1, 0, 2, 0);
CPU_state = uint8(2); case 2,
% Read from IR IR_func = fi(2, 0, 2, 0);
% Accommodating for the 'unit delay' from IR_out to IR_in
CPU_state = uint8(3); case 3,
% IR_in <16..1>
main_opcode = fi(IR_in, 0, 16, 0);
% IR_in <16..9> major_opcode = fi(bitsrl(main_opcode, 8), 0, 4, 0);
% for instructions NOP,JMP,JMPZ,CALL,MOV A,xx MOV B,xx,RET % IR_in <12..9> mask4 = fi(15, 0, 4, 0); minor_opcode = fi(bitand(major_opcode, mask4), 0, 4, 0);
% IR_in <8..1> mask8 = fi(255, 0, 16, 0); address_data = fi(bitand(main_opcode, mask8),0, 8, 0); % Go to the decode stage CPU_state = uint8(4);
%DECODE AND EXECUTE case 4,
switch(uint8(minor_opcode)) case 0,
% NOP
CPU_state = uint8(1); case 1,
% JMP
temp_addr_data = fi(address_data, 0, 8, 0); addr_inc = fi(temp_addr_data, 0, 8, 0); PC_inc_func = fi(1, 0, 2, 0);
PC_func = fi(1, 0, 2, 0);
CPU_state = uint8(1); case 2,
%JMPZ
temp_addr_data = fi(address_data, 0, 8, 0); if fi(Reg_A,0,8,0) == fi(0,0,8,0) addr_inc = fi(temp_addr_data, 0, 8, 0); PC_inc_func = fi(1, 0, 2, 0);
PC_func = fi(1, 0, 2, 0); end
CPU_state = uint8(1); case 3,
% CALL
temp_addr_data = fi(address_data, 0, 8, 0); addr_inc = fi(temp_addr_data, 0, 8, 0); PC_inc_func = fi(1, 0, 2, 0);
PC_func = fi(1, 0, 2, 0);
CPU_state = uint8(1); case 4,
%MOV A,xx temp_addr_data = fi(address_data, 0, 8, 0); Reg_OutA = fi(temp_addr_data , 0, 8, 0); RegA_func = fi(1, 0, 3, 0);
CPU_state = uint8(1); case 5,
%MOV B,xx temp_addr_data = fi(address_data, 0, 8, 0); Reg_OutB = fi(temp_addr_data , 0, 8, 0); RegB_func = fi(1, 0, 3, 0);
CPU_state = uint8(1); case 6,
switch(uint8(address_data)) case 0,
%RET
PC_inc_func = fi(2, 0, 2, 0); PC_func = fi(2, 0, 2, 0); CPU_state = uint8(5); case 1,
%MOV A,B
ALU_func = fi(0, 0, 4, 0);
RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 2,
%MOV B,A
ALU_func = fi(1, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 3,
%XCHG A,B ALU_func = fi(2, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 4,
%ADD A,B
ALU_func = fi(3, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 5,
%SUB A,B
ALU_func = fi(4, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 6,
%AND A,B
ALU_func = fi(5, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 7,
%OR A,B
ALU_func = fi(6, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 8,
%XOR A,B
ALU_func = fi(7, 0, 4, 0); RegA_func = fi(2, 0, 3, 0); RegB_func = fi(2, 0, 3, 0); CPU_state = uint8(5); case 9,
%DEC A
ALU_func = fi(8, 0, 4, 0);
RegA_func = fi(2, 0, 3, 0);
CPU_state = uint8(5);
end
end case 5,
RegA_func = fi(2, 0, 3, 0);
RegB_func = fi(2, 0, 3, 0);
CPU_state = uint8(1);
End
Пример. M-файл функции управляющего автомата микропроцессора (CPU_Controller) в системе Matlab/Simulink
Выводы. В системе Matlab/Simulink разработан учебный вариант 8-ми разрядного процессорного ядра, позволяющего проводить вычисления в формате с фиксированной запятой, с управляющим автоматом на шесть состояний и системой команд из работы [4].
Преимуществом архитектуры процессора с распределенным управлением является адаптивность к последующим модификациям, например, в случае если потребуется добавить дополнительные функциональные блоки и команды. Недостатком является отсутствие памяти данных, поддержка незначительного числа команд, а также то, что процессор оперирует только с целыми положительными числами и отсутствие конвейеризации вычислений.
Литература
1. Строгонов А. Проектирование учебного процессора для реализации в базисе ПЛИС // Компоненты и технологии, 2009, N3.
2. Строгонов А., Буслов А. Проектирование учебного процессора для реализации в базисе ПЛИС с использованием системы Matlab/Simulink // Компоненты и технологии, 2009, N5.
3. Тарасов И. Проектирование конфигурируемых процессоров на базе ПЛИС. Часть I // Компоненты и технологии, 2006, N2.
4. Тарасов И. Проектирование конфигурируемых процессоров на базе ПЛИС. Часть II // Компоненты и технологии, 2006, N3.
5. www.exponenta.ru. К.Г. Жуков “Справочное руководство пользователя Fixed-Point Blockset”.
Воронежский государственный технический университет ОАО “Конструкторско -технологический центр “Электроника”
DEVELOPMENT MODEL OF THE MICROPROCESSOR KERNEL WITH USE OF SYSTEM MATLAB/SIMULINK
A.V. Strogonov, S.A. Tsybin, A.I. Buslov, O.A. Zolotuhina
In article development model of a microprocessor kernel with use of system of visual imitating modelling Matlab/Simulink for realization in basis of programmed logic integrated circuits is considered
Key words: microprocessor, the distributed management, fi-objects of system Matlab/Simulink
