close

Вход

Забыли?

вход по аккаунту

- Ухтинский государственный технический университет

код для вставкиСкачать
МИНОБРНАУКИ РОССИИ
Федеральное государственное бюджетное образовательное учреждение
высшего профессионального образования
«Ухтинский государственный технический университет»
(УГТУ)
Системные средства организации
и взаимодействия программ
Методические указания
Ухта, УГТУ, 2014
УДК 004.45 (075.8)
ББК 32.972 я7
Б 17
Б 17
Базарова, И. А.
Системные средства организации и взаимодействия программ [Текст] :
метод. указания / И. А. Базарова. – Ухта : УГТУ, 2014. – 23 с.
Методические указания предназначены для выполнения курсовой работы по дисциплине «Системные средства организации и взаимодействия программ» для студентов
дневной формы обучения для направления 230100 ИВТ квалификации «Бакалавр».
Методические указания охватывают основные разделы тем «Микропрограммирование», «Интерфейс прикладного программирования» и включают в себя задания
по разработке программы с использованием функций интерфейса прикладного программирования и моделированию работы компонентов микропроцессорной системы
при выполнении микрокоманд.
Содержание методических указаний соответствует рабочей учебной программе.
УДК 004.45 (075.8)
ББК 32.972 я7
Методические указания рассмотрены и одобрены заседанием кафедры АИС (протокол №09 от 14.05.2014).
Рецензент: О. М. Кудряшова, доцент кафедры АИС УГТУ.
Корректор: П. В. Котова. Технический редактор: Л. П. Коровкина.
В методических указаниях учтены замечания рецензента и редактора.
План 2014 г., позиция 80.
Подписано в печать 30.09.2014 г. Компьютерный набор.
Объём 23 с. Тираж 50 экз. Заказ №288.
© Ухтинский государственный технический университет, 2014
169300, Республика Коми, г. Ухта, ул. Первомайская, д. 13.
Типография УГТУ.
169300, Республика Коми, г. Ухта, ул. Октябрьская, д. 13.
Интерфейс прикладного программирования
Интерфейс прикладного программирования (application program interface,
API) – набор функций, предоставляемых системой программирования разработчику прикладной программы, и ориентированных на организацию взаимодействия прикладной программы с целевой вычислительной системой.
API предназначен для использования прикладными программами системных ресурсов ОС.
Целевая вычислительная система представляет собой совокупность программных и аппаратных средств, в окружении которых выполняется результирующая программа.
Программный интерфейс включает в себя не только сами функции, но и
соглашения об их использовании, которые регламентируются ОС, архитектурой целевой вычислительной системы и системой программирования.
Как правило, API-функции не стандартизированы. В то же время предпринимаются попытки стандартизировать некоторый базовый набор функций
для облегчения переноса приложений с одной ОС на другую. Большинство этих
стандартов определяют требования к операционной системе, которая должна
эффективно выполнять приложения, написанные на языке Си.
Windows NT поддерживает графический интерфейс (GUI) Windows и является первой базирующейся на Windows операционной системой фирмы
Microsoft, поддерживающей Win32 API – 32-х битный программный интерфейс
для разработки новых приложений. Win32 API делает доступными для приложений такие свойства операционной системы, как многонитевые процессы,
синхронизацию, безопасность, I/O, управление объектами.
Структуру приложения можно представить в следующем виде:
- определение и регистрация класса окна приложения;
- создание и отображение окна приложения;
- создание цикла обработки сообщений;
- создание оконной процедуры.
WinMain()
{
RegisterClass() //регистрация класса окна приложения
CreateWindow() //создание окна приложения
//цикл обработки сообщений
while(GetMessage())
{
3
TranslateMessage();
DispatchMessage();
}
return;
}
//оконная процедура
WndProc
{
switch(msg)
{
case WM_CREATE:
...
case WM_COMMAND:
...
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc()
}
Программирование в Windows основано на событиях и сообщениях. Операционная система общается с программой путём посылки ей сообщений. Каждый
раз при запуске новой программы, Windows создает новый процесс и выделяет для
этого процесса свою очередь сообщений. Когда в системе происходит какое-либо
событие (нажатие клавиши клавиатуры, кнопки мыши, движение мыши и др.), первой получает сообщение об этом операционная система. Получив сообщение, ОС
направляет это событие в очередь сообщений для данной программы. Цикл обработки сообщений читает сообщение из очереди сообщений программы и направляет это сообщение назад ОС, которая затем вызывает оконную процедуру
программы, передавая ей это сообщение в качестве параметра.
Типы данных Win32API
BOOL – булева переменная (TRUE; FALSE)
BYTE – 8-битное целое беззнаковое
CHAR – 8-битный символ
WCHAR – 16-битный символ (Unicode)
DWORD – 32-битное беззнаковое целое число
4
LONG – 32-битное знаковое целое
LPCSTR – 32-битный указатель на константную строку
LPSTR – 32-битный указатель на строку
LPCTSTR – 32-битный указатель на постоянную строку, представленную
символами UNICODE
LPTSTR – 32-битный указатель на символьную строку, представленную
символами UNICIDE
LPVOID – 32-битный нетипизированный указатель
UINT – 32-битное беззнаковое целое
WORD – 16-битное целое число
HANDLE – описатель объектов WIN32
FLOAT – число с плавающей точкой
SHORT – целое знаковое 16-битное число
INT64, LONG64, LONGLONG – целое знаковое 64-битное число
VOID – пустой тип
Функция WinMain
При запуске программы в Windows операционная система вызывает в
программе функцию WinMain. В любом приложении обязательно должна присутствовать эта функция, на которую возлагается ряд специфических задач. И
самая важная из них – создание основного окна программы, с которым должен
быть связан код, способный обрабатывать сообщения, передаваемые операционной системой этому окну.
Любая программа имеет точку входа – место, откуда непосредственно
начинается программа разработчика. В языке Си – это функция, в которую будет передано управление сразу после запуска программы. Прежде чем начнёт
выполняться код разработчика, операционная система должна прочитать программу с диска, выделить ей память, настроить сегменты данных и кода. И сама
программа должна проверить операционную систему и выполнить ряд действий. Только после проведения всех необходимых настроек управление будет
передано функции WinMain (определена в windows.h).
int WINAPI WinMain
(
HINSTANCE hInstance,
// указатель на текущий экземпляр
HINSTANCE hPrevInstance, // указатель на предыдущий запущенный экземпляр
LPSTR lpszCmdParam,
// командная строка
5
int nCmdShow
// тип отображения окна программы
);
Функция WinMain() имеет четыре аргумента:
- hInstance – уникальный идентификатор текущего экземпляра приложения;
- hPrevInstance – идентификатор последнего из запущенных экземпляров
приложения, если запущено несколько экземпляров приложения. В WIN32 –
этот параметр всегда равен NULL. Если нужно определить, запущен другой экземпляр или нет, используют семафоры CreateMutex();
- lpszCmdParam – указатель на строку, которая заканчивается нулевым
байтом и содержит все параметры командной строки, передаваемые данному
экземпляру программы.
Функция WinMain() позволяет передавать аргументы командной строки
приложениям Windows через параметр lpszCmdParam. Другими словами, это
строка параметров, которые были посланы программе при запуске. Если их не
было, то строка пуста.
- nCmdShow – целое число, показывающее как отображать запущенную
программу, в виде открытого окна или в виде кнопки на панели задач.
Действия, обычно выполняемые функцией WinMain:
 Регистрирует класс окна приложения и другие инициализации.
 Создаёт главное окно приложения и, возможно, другие подчинённые окна.
 Запускает цикл обработки сообщений, помещаемых в очередь приложения.
 Завершает работу приложения при извлечении из очереди сообщения
WM_QUIT.
Регистрация класса окна
Обычно приложение создает окно за два шага. Сначала с помощью функции RegisterClass регистрируется класс окна, а затем создаётся само окно зарегистрированного класса с помощью функции CreateWindow. Класс окна
определяет общее поведение нового типа окон, включая адрес новой оконной
процедуры. Такие второстепенные аспекты как размер, расположение и внешний вид окна определяются при его создании.
Новый класс окна регистрируется при вызове приложением следующей
функции:
ATOM RegisterClass(const WNDCLASS *lpwc);
Единственный параметр этой функции lpwc указывает на структуру типа
WNDCLASS, описывающую тип нового окна. Возвращаемое значение является
атомом Windows – 16-разрядным значением, идентифицирующим уникальную
символьную строку в таблице Windows.
6
Создание окна
Создаётся окно приложения при помощи функции CreateWindow().
Стиль окна, передаваемый CreateWindow, используется для инициализации локальных свойств окна. Вызов CreateWindow возвращает дескриптор созданного окна типа HWND. У каждого окна в Windows имеется такой
уникальный дескриптор, характеризующий в дальнейшем созданное окно: он
может использоваться в качестве аргумента при вызове других функций, работающих с нашим окном.
HWND CreateWindow
(
LPCTSTR lpClassName,// имя класса окна
LPCTSTR lpWindowName, // заголовок окна
DWORD dwStyle,
// стиль окна
int x,
// горизонтальная позиция окна
int y,
// вертикальная позиция окна
int nWidth,
// ширина окна
int nHeight,
// высота окна
HWND hWndParent,
// указатель на родительское окно
HMENU hMenu,
// указатель на меню
HINSTANCE hInstance, // указатель на приложение создающее окно
LPVOID lpParam
// дополнительные параметры
);
Перед тем, как завершить создание окна, посылается сообщение
WM_CREATE в процедуру обработки окна (оконная процедура).
Отображение окна
После создания окна его необходимо отобразить на экране монитора при
помощи функции ShowWindow(), которой в качестве параметра передаётся дескриптор окна HWND, возвращённый функцией CreateWindow(), и аргумент
nCmdShow, переданный функции WinMain().
ShowWindow( hwnd , nCmdShow ); // отобразить окно на экране
UpdateWindow( hwnd );
// вывести на экран рабочую область окна
Функция UpdateWindow передаёт оконной процедуре сообщение
WM_PAINT. Получив это сообщение, функция обновляет содержимое экрана.
7
Обработка сообщений
На последнем этапе в функции WinMain реализуется цикл обработки сообщений, посылаемых операционной системой. При получении приложением
сообщения оно передаётся функции WndProc на обработку. Цикл обработки сообщений выглядит следующим образом:
while( GetMessage( &msg, NULL, 0, 0 ))
// управляющая структура while при
каждом проходе цикла получает очередное сообщение
из очереди, посредством функции GetMessage(),
функция возвращает true, пока не выберет
WM_QUIT
(завершение приложения, функция возвращает 0)
{
TranslateMessage( &msg );
//функция преобразования виртуальных клавиш в символьные сообщения
DispatchMessage( &msg );
//распределяет сообщения по функциям
окна,
именно здесь происходит вызов оконной процедуры
}
return msg.wParam;
}
//завершение цикла обработки сообщений
//завершение функции WinMain()
&msg – указатель на структуру сообщения, в которой хранятся данные о
полученном сообщении, msg имеет тип MSG, который описан в файле
windows.h.
Тип сообщения MSG определён следующим образом:
typedef struct tagMSG {
HWND hwnd;
//дескриптор окна, которому адресуется сообщение
UINT message;
//тип Windows-сообщения (например,
WM_RBUTTONDOWN – нажатие правой кнопки мыши)
WPARAM wparam; //параметр сообщения, зависит от типа сообщения,
например координаты указателя мыши
LPARAM lparam; //параметр сообщения, зависит от типа сообщения
DWORD time;
// время постановки сообщения в очередь
POINT pt;
/координаты мыши в момент time, имеет тип struct (
int x, int y; }
} MSG;
8
Параметры функции GetMessage()
Цикл обработки начинается с извлечения сообщений из очереди при помощи функции:
BOOL GetMessage(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UIN
T wMsgFilterMax);
Функция GetMessage принимает следующие параметры:
 LPMSG lpMsg – указатель на структуру сообщения, в которую
GetMessage вернёт результат;
 HWND hWnd – описатель окна, от которого GetMessage примет сообщение (NULL означает, что GetMessage принимает сообщения от всех
окон, принадлежащих потоку);
 UINT wMsgFilterMin – наименьший идентификатор сообщения, которое
примет GetMessage, нижняя граница диапазона извлечения;
 UINT wMsgFilterMax – наибольший идентификатор сообщения, которое
примет GetMessage, верхняя граница диапазона извлечения (если в значениях параметров wMsgFilterMin и wMsgFilterMax передать 0, функция будет принимать все сообщения).
Функция GetMessage не отдаёт управление программе, пока не придёт какое-либо сообщение. Если пришедшее сообщение – WM_QUIT, функция
GetMessage вернёт 0. Тогда цикл прервётся, и программа завершит свою работу. При любом другом сообщении функция GetMessage возвращает значение
больше нуля, и начинается выполнение тела цикла. При ошибке GetMessage
возвращает –1 (минус 1).
Оконная процедура
Оконная процедура обрабатывает сообщения с помощью функции
WndProc, которую вызывает функция DispatchMessage.
Именно оконная процедура определяет то, что выводится в рабочую область окна и то, как окно реагирует на пользовательский ввод.
WndProc
{
switch(msg)
{
case WM_CREATE:
case WM_COMMAND:
case WM_PAINT:
...
case WM_DESTROY:
9
PostQuitMessage(0);
return 0;
}
return DefWindowProc()
}
Таких функций в программе может быть несколько, но их прототипы обязательно должны выглядеть так:
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam,
LPARAM lParam)
При вызове этой функции ей передаются следующие параметры:
 HWND hWnd – описатель (хэндл) окна, от которого пришло сообщение;
 UINT message – идентификатор сообщения (код сообщения), по которому происходит реакция на сообщение;
 WPARAM wParam и LPARAM lParam – параметры сообщения (зависят
от типа сообщения).
Сообщения оконной процедуры
Функция окна получает сообщение из двух источников: из цикла обработки сообщений (синхронные) и от Windows (асинхронные).
Синхронными сообщениями называются сообщения, которые Windows
помещает в очередь сообщений программы, и которые извлекаются и диспетчеризуются в цикле обработки сообщений. Синхронными сообщения становятся, в основном, тогда, когда они являются результатом пользовательского
ввода: нажатие клавиш (WM_KEYDOWN и WM_KEYUP), символы, введённые
с клавиатуры (WM_CHAR), результат движения мыши (WM_MOUSEMOVE),
щелчки кнопки мыши (WM_LBUTTONDOWN), сообщение от таймера
(WM_TIMER), сообщение о необходимости плановой перерисовки
(WM_PAINT) и сообщение о выходе из программы (WM_QUIT).
Асинхронные сообщения – это сообщения, которые Windows посылает
функции окна напрямую, минуя очередь приложения и цикл обработки сообщений. Эти сообщения обычно вызваны событиями, требующими немедленной
реакции по изменению вида окна.
В результате оконная процедура получает все предназначенные для окна
сообщения, как синхронные, так и асинхронные.
С позиции оконной процедуры, все сообщения проходят через неё упорядочено. Оконная процедура может обработать эти сообщения, а может их проигнорировать. Поэтому оконную процедуру называют «конечным пунктом
10
обработки» (ultimate hook). Сообщения извещают оконную процедуру почти
обо всем, что влияет на окно.
Сообщения рассылаются функциями PostMessage( ) и SendMessage( ).
Функция PostMessage( ) сразу помещает сообщение в очередь и программа работает дальше. Функция SendMessage( ) посылает сообщение оконной
процедуре указанного окна и ждёт, пока окно не обработает сообщение. Возвpат результата из функции осуществляется только после обpаботки сообщения. Эту функцию предпочтительнее использовать в случае, если в сообщении
задействованы указатели на динамически размещаемые данные.
Коды сообщений определены в файле windows.h, включаемом в исходные
тексты любых приложений, Windows.
При разрушении структуры данных окна (при уничтожении окна) функция окна получает сообщение с кодом WM_DESTROY. Оно посылается оконной процедуре разрушаемого окна после того, как окно удалено с экрана.
Это сообщение показывает, что Windows находится в процессе ликвидации окна в ответ на полученную от пользователя команду. Пользователь вызывает поступление этого сообщения, если нажмёт на кнопку «Close», выберет
пункт «Close» из системного меню или нажмёт комбинацию клавиш Alt+F4.
Главное окно стандартно реагирует на это сообщение, вызывая функцию
PostQuitMessage(0);
Эта функция ставит сообщение WM_QUIT в очередь сообщений приложения. Когда функция GetMessage извлекает это сообщение, она возвращает
ноль, что заставляет функцию WinMain прервать цикл обработки сообщений и
выйти в систему, завершив работу приложения.
DefWindowProc
В Windows существует огромное количество сообщений. Чтобы Windows
сама их обрабатывала, необходимо вызвать функцию DefWindowProc (такой
механизм позволяет Windows обрабатывать окно совместно с приложением).
Желательно передавать все необработанные сообщения этой функции, а
результат её выполнения возвращать при выходе из WndProc. Это очень важно,
так как от обработки некоторых сообщений Windows ждёт возврата конкретных
результатов или действий.
Стандартная обработка всех сообщений:
LRESULT DefWindowProc(HWND hWnd,UINT message, WPARAM wParam,
LPARAM lParam);
11
Функция DefWindowProc играет ключевую роль в формировании информационных потоков сообщений Windows, и её указание в функции окна обязательно. Перед тем, как передать управление функции DefWindowProc, можно
перехватить и обработать практически любое сообщение.
Дескриптор процесса (HANDLE)
Компонент исполнительной части ядра «Диспетчер процессов» выполняет следующие операции над процессами:
- Создание специальной информационной структуры (дескриптор) и
включение его в очередь;
- Обеспечение созданного процесса необходимыми ресурсами;
- Организация взаимодействия этого процесса с другими (если требуется);
- Изменение приоритета процесса (работа с очередями);
- Завершение процесса.
Дескриптор процесса – это переменная типа HANDLE, включающая в
себя следующую информацию:
 PID – идентификатор процесса;
 тип или класс процесса, который определяет для супервизора некоторые правила предоставления ресурсов;
 приоритет процесса в соответствии, с которым супервизор предоставляет ресурсы, это число, характеризующее степень привилегированности
процесса при использовании ресурсов вычислительной машины, в частности,
процессорного времени: чем выше приоритет, тем выше привилегии;
 переменная состояния процесса определяет, в каком состоянии
находится процесс в данный момент времени (готов к работе, состояние выполнения, ожидание устройства ввода-вывода);
 контекст процесса – защищённая область памяти, в которой хранятся
текущие значения регистров процессора для возобновления выполнения процесса.
Контекст включает в себя такие данные, как счётчик команд, указатель стека, регистры МП, открытые файлы, незавершённые операции ввода-вывода, режим работы
МП и т. п. Планировщик задач в случае необходимости сохраняет контекст текущей активной задачи и восстанавливает контекст задачи, назначенной к исполнению. Такое переключение контекстов является основным механизмом ОС при
переходе от выполнения одной задачи к выполнению другой;
 информация о ресурсах, которыми имеет право пользоваться процесс
(указатели на открытые файлы, указатели на каналы связи между процессорами, информация о незавершённых операциях ввода/вывода и т. д.);
12
 параметры времени запуска (момент времени, в который процесс
должен активизироваться и периодичность этой процедуры);
 адрес для организации взаимодействия с другими процессами;
 в случае отсутствия СУФ (система управления файлами) – адрес задачи на диске в исходном состоянии и адрес на диске, куда она выгружается из
оперативной памяти, если её вытесняет другая.
Дескриптор процесса по сравнению с контекстом содержит более оперативную информацию, которая должна быть легкодоступна подсистеме планирования процессов: идентификатор процесса, состояние процесса, данные о
степени привилегированности процесса и т. п.
Микропрограммирование
Каждый процессор имеет свою систему команд, определяемую его архитектурой. Команда представляет собой определённую последовательность двоичных разрядов и содержит код операции и информацию об операндах.
Формат команды – это совокупность сведений, которые для каждой команды процессора задают: её длину, состав, назначение. Команды могут быть
безадресные и адресные.
В системе команд любого процессора можно выделить следующие основные группы команд:
1. Пересылка данных между RAM и регистрами процессора.
2. Арифметико-логические операции.
3. Управление ходом выполнения программы.
4. Связь с подпрограммами.
5. Операции над регистровыми структурами (сдвиг данных в регистрах,
очистка регистров и т. д.).
6. Группа команд, управляющих I/O (вводом/выводом).
7. Специальные системные команды.
Устройство управления процессора в строгой последовательности в рамках тактовых и цикловых временных интервалов осуществляет:
1. Выборку команды.
2. Её интерпретацию с целью анализа формата, служебных признаков и
вычисления адреса операнда (операндов).
3. Установление временной последовательности всех функциональных
управляющих сигналов.
4. Генерацию управляющих импульсов и передачу их на управляющие
шины функциональных частей ПК.
13
5. Анализ результата операции и изменение своего состояния для определения адреса следующей команды.
Регистры используются для хранения информации и её преобразования.
Операции над числом в регистре реализуются с помощью управляющих сигналов от устройства управления.
Регистры по функциональному назначению делятся на следующие типы:
1. Программный счётчик, (счётчик команд), (регистр адреса команды) –
используется для формирования адреса команды.
2. Регистр команд – используется для хранения кода текущей выполняемой команды. Входящий в состав команды код операции используется для
формирования в УУ определённой серии управляющих сигналов. Остальная
часть кода команды может содержать информацию об адресах операндов, если
команда адресная.
3. Регистр адреса памяти – используется для запоминания адреса команды, операнда или результата операции во время чтения команды или операнда
из памяти или во время записи результата операции в память.
Также регистры могут быть программно-недоступными и программнодоступными.
Для разных типов процессоров состав регистров может быть разным. Однако в их составе всегда присутствуют:
1. Регистр словосостояния процессора – содержит информацию о текущем состоянии процессора.
2. РОН (регистры общего назначения) – используются для разного рода
хранения информации исходя из программы, которую выполняет процессор.
Обращение к таким регистрам осуществляется через языки низкого уровня
(например, через ассемблер).
Для работы с памятью используются различные режимы адресации. Состав режимов адресации зависит от архитектуры процессора.
Выбор режима адресации предполагает компромисс между гибкостью
метода адресации с одной стороны и объёмом доступного адресного пространства памяти и сложностью вычисления исполнительного адреса – с другой.
Основные режимы адресации:
1. Непосредственный – в коде команды в адресном поле передаётся
значение операнда.
2. Прямой – в коде команды передаётся адрес операнда в ОП.
3. Косвенный – в коде команды передаётся ссылка на исполнительный
адрес ЕА в ОП, по которому хранится операнд (ЕА = (А)).
14
4. Регистровый – подобен прямой адресации, но в коде инструкции передаётся идентификатор регистра процессора (ЕА = R).
5. Косвенный через регистр – в коде команды передаётся ссылка на регистр процессора, в котором хранится адрес памяти операнда (ЕА = (R)).
6. Со смещением (относительная, через регистр базы, индексная) –
исполнительный адрес формируется как EA = A + (R). Метод требует, чтобы в
коде команды было два адресных поля. R указывает на регистр процессора, содержимое которого суммируется с операндом ОП, который располагается по
адресу А.
7. Стековый – одна из форм неявной адресации. ЕА = вершина стека.
При микропрограммном способе логика формирования управляющих
сигналов реализована в виде микропрограммы, которая состоит из последовательности микрокоманд на специальном языке.
Язык Ассемблера – система записи программы с детализацией до отдельной машинной команды, позволяющая использовать мнемоническое обозначение команд и символическое задание адресов.
Поскольку в разных аппаратных архитектурах разные программнодоступные компоненты (система команд, регистры, способы адресации), язык
Ассемблера является аппаратно-зависимым. Программы, написанные на языке
Ассемблера, могут быть перенесены только на вычислительную систему той же
архитектуры.
Программирование на Ассемблере позволяет в максимальной степени использовать особенности архитектуры вычислительной системы.
Доля ассемблерных программ неуклонно уменьшается. Язык Ассемблера
«в чистом виде» применяется только для написания отдельных небольших частей системного ПО: микроядра ОС, самых нижних уровней драйверов – частей, непосредственно взаимодействующих с реальными аппаратными
компонентами. Однако в некоторых случаях интерфейс программы удобно
представлять в виде системы команд (технологии виртуальных машин), что
требует использование данного языка.
При микропрограммном управлении в УУ вводится управляющая память,
содержащая программу, полностью описывающую его функционирование.
Для выполнения микрооперации УУ должно сформировать соответствующий набор управляющих сигналов, т. е. при выполнении микрооперации каждый выход УУ должен быть либо «включён» («1»), либо «отключён» («0»).
Следовательно, для совокупности выходов можно сформировать двоичное
управляющее слово, которое будет определять необходимую микрооперацию.
15
Теперь последовательность управляющих слов можно объединить в строку как определённую команду. Однако длина последовательности не может
быть фиксированной, т. к. не во всех командах присутствует, например, фаза
адресации. Поэтому в управляющее слово добавляют поле адреса, в котором
указывают, какое управляющее слово должно обрабатываться следующим при
выполнении определённых условий (например, при установке разряда косвенной адресации). А также добавляют разряды для спецификации условия.
Такую микрокоманду называют горизонтальной.
Помимо горизонтального микропрограммирования применяется вертикальное микропрограммирование (рис. 1).
Рисунок 1 – Детализированная схема микропрограммного устройства управления
Последовательность микрокоманд, образующая микропрограмму, хранится в блоке управляющей памяти (БУП). Регистр адреса управляющей памяти CAR (control address register) содержит адрес микрокоманды.
Микрокоманда, считанная из блока управляющей памяти, помещается в
буферный регистр CBR (control buffer register).
Узел синхронизации организует загрузку адреса в CAR и формирует сигнал чтения из блока управляющей памяти.
16
Верхний дешифратор преобразует код операции из регистра IR в адрес в
блоке управляющей памяти.
Нижний дешифратор используется только для тех УУ, где применяется
вертикальное микропрограммирование, для декодирования кода микроопераций в отдельные управляющие сигналы.
Рассмотрим процесс выполнения команд МП на примере структурной
схемы (рис. 2).
На данной схеме толстые линии – это магистрали адреса и данных, тонкие стрелки – сигналы от магистрали управления, пунктирные линии – непосредственное воздействие электрического сигнала на соответствующий
компонент. УВВ, связи РОН и генератора не показаны.
Предположим также, что управляющие сигналы устройства управления
соответствуют таблице 1.
Рассмотрим процесс выполнения операции чтения числа A из заданной
ячейки памяти, к которому необходимо прибавить единицу и сохранить результат в регистре АС. Решение данной задачи приведено в таблице 2.
Рисунок 2 – Схема взаимосвязи компонентов процессорной системы
17
Таблица 1 – Управляющие сигналы устройства управления
№
сигнала
1
Назначение линии
Наращивание содержимого PC
2
3
4
5
Чтение информации из PC и на МА
Запись информации с МД в регистр команд IR
Чтение адреса операции из регистра команд IR на МА
Запись информации с МА в регистр адреса памяти MAR
6
7
8
9
10
Чтение содержимого ячейки памяти в буферный регистр MBR
Запись информации из буферного регистра MBR в ячейку памяти
Запись информации с МД в операционный блок
Прибавление 1 к содержимому в операционном блоке
Инвертирование содержимого операционного блока
Суммирование содержимого операционного блока с содержимым
аккумулятора AC (результат остается в аккумуляторе)
Запись информации из операционного блока в аккумулятор AC
Чтение информации из аккумулятора AC на МД
Чтение PC на МД
Запись в PC с МД
Чтение MBR
Запись в MBR
11
12
13
14
15
16
17
Таблица 2 – Выполнение операции A+1 и соответствующие ей микрокоманды
Машинный цикл
Цикл генератора
тактовой частоты
I -cycle
E -cycle
Выполняемая микрооперация
Такт 1. (PC) → MAR
Такт 2. (PC) +I → PC
Память → MBR
Такт 3. (MBR) → IR
Такт 4. IR (Адрес) → MAR
Такт 5. Память → MBR
Такт 6. (MBR) → OB
Активные
сигналы МУ
2, 5
1
6, 17
16, 3
4, 5
6,17
16, 8
Такт 7. A+1
9
Такт 8. (A+1) → AC
12
Микрооперации фазы извлечения можно сгруппировать иначе (табл. 3):
Таблица 3
Такты генератора
Такт 1
Такт 2
Такт 3
Выполняемая микрооперация
MAR ← (PC)
MBR ← Память
PC ← (PC) +I
IR ← (MBR)
18
Практические задания к выполнению курсовой работы
Часть 1 Программное моделирование работы компонентов процессорной
системы при микропрограммировании
Требования к программному моделированию
а) При выполнении моделирования необходимо отразить все процессы,
протекающие в главных компонентах МПС и на магистралях адреса и данных,
а также активные сигналы магистрали управления.
б) Все операции над многоадресными инструкциями выполняются через
регистр АС.
в) При запуске программы необходимо отображать начальные и текущие
состояния основной памяти, программного счётчика, регистра адреса памяти,
регистра команд, MBR, АС, операционного блока.
г) Состояние программного счётчика можно представлять в десятичном,
двоичном или шестнадцатеричном коде.
д) Режим адресации для всех вариантов – прямая адресация.
е) Инструкции – одно- и двухадресные.
ж) В пояснительной записке к курсовой работе в части 1 должны содержаться следующие разделы: постановка задачи, решение в виде таблицы, интерфейс с исходной схемой, код программы, скриншоты выполнения
микроопераций.
Вариант 1
А  В 1
А = 1010102. Адрес числа АС6h. В = 1910. Адрес числа АС8h.
Состояние программного счётчика на момент выполнения программы FAh.
Сохранить результат по адресу АС8h.
Вариант 2
А  С 1
А = 1710. Адрес числа АDFАh. С = 1810. Адрес числа ВA5Аh.
Состояние программного счётчика на момент выполнения программы 53610.
Результат сохранить по адресу АFFВh.
Вариант 3
А  В C
А = 2010. Адрес числа A8Fh. В = 1710. Адрес числа A90h.
С = 11002. Адрес числа А92h.
19
Поместить результат по адресу АA9h. Состояние программного счётчика
на момент выполнения программы 157810.
Вариант 4
А ВС
А = 1510. Адрес числа 8AАh. В = 3810. Адрес числа 8АCh.
С = 510. Адрес числа 8AEh.
Состояние программного счётчика на момент выполнения программы 354810.
Сохранить результат в AC.
Вариант 5
А 1 В 1
А = 1310. Адрес числа F5AСh. В = 1710. Адрес числа F5AEh.
Состояние программного счётчика на момент выполнения программы 95410.
Сохранить результат в памяти по адресу FA01h.
Вариант 6
А  ( В  1)
А = 1010112. Адрес числа B4F5h. В = 0100112. Адрес числа B4F7h.
Состояние программного счётчика на момент выполнения программы 45310.
Сохранить результат по адресу B2FFh.
Вариант 7
А 1  В
А = 2910. Адрес числа EF3h. В = 3410. Адрес числа FF5h.
Состояние программного счётчика на момент выполнения программы 7Fh.
Сохранить результат по адресу FF4h.
Вариант 8
2 B
В = 2210. Адрес числа F25h. Состояние программного счётчика на момент выполнения программы 82210. Сохранить результат по адресу F4Bh.
Вариант 9
B  С 1
В = 10112. Адрес числа 2FAh. С = 1000102. Адрес числа 2FCh.
Состояние программного счётчика на момент выполнения программы 35210.
Сохранить результат по адресу 2FAh.
Вариант 10
( А  B)  С
А = 1110. Адрес числа 8DEh. В = 1610. Адрес числа 901h.
20
С = 1810. Адрес числа 903h.
Состояние программного счётчика на момент выполнения программы 475310.
Сохранить результат в AC.
Вариант 11
( B  1)  ( A  1)
А = 101012. Адрес числа 7BAh. В = 101102. Адрес числа 7BCh.
Состояние программного счётчика на момент выполнения программы 5FFh.
Сохранить результат по адресу 7BCh.
Вариант 12
А = 101112. Адрес числа F554h. Число 3 находится в АС.
Состояние программного счётчика на момент выполнения программы 875610.
Сохранить результат в АС.
Вариант 13
A+B+1
А = 2110. Адрес числа 4DEh. В = 3610. Адрес числа 901h.
Состояние программного счётчика на момент выполнения программы 574310.
Сохранить результат по адресу 4DEh.
Вариант 14
A B
А = 2810. Адрес числа 85Eh. В = 3410. Адрес числа 95Сh.
Состояние программного счётчика на момент выполнения программы 263810.
Сохранить результат по адресу 28С5h.
Вариант 15
BC
В = 1100112. Адрес числа 901h. С = 0010012. Адрес числа 903h.
Состояние программного счётчика на момент выполнения программы 143710.
Сохранить результат в AC.
Часть 2 Интерфейс прикладного программирования API
Разработать программу TaskManager (Диспетчер задач), предоставляющую информацию о запущенных в системе процессах с возможностью завершения выбранного процесса. Получить информацию о задаче из части 1.
Требования к программному моделированию
а) Поставленная задача должна быть реализована средствами API.
б) Список процессов должен быть представлен средствами GUI (рис. 3).
в) Среда разработки – на выбор.
21
в) В пояснительной записке к курсовой работе в части 2 должны содержаться следующие разделы: постановка задачи, подробное описание всех необходимых API-функций, описание интерфейса, код программы, скриншоты.
Рисунок 3 – Пример окна «Диспетчера задач»
Библиографический список
1. Базарова, И. А. Организация ЭВМ и систем : сб. лекций / И. А. Базарова. – Ухта : Институт управления, информации и бизнеса, 2003. – 97 с.
2. Столлингс, Уильям. Операционные системы / У. Столлингс. – 4-е изд. –
М. : Издательский дом «Вильямс», 2004. – 848 с.
3. Столлингс, Уильям. Структурная организация и архитектура компьютерных систем / У. Столлингс. – 5-е изд. – М. : Издательский дом «Вильямс»,
2002. – 896 с.
4. Шилдт, Герберт. Полный справочник по Си++ / Г. Шилдт. – М. : Издательский дом «Вильямс», 2007. – 800 с.
22
ОГЛАВЛЕНИЕ
Интерфейс прикладного программирования.......................................................... 3
Микропрограммирование ......................................................................................... 13
Практические задания к выполнению курсовой работы....................................... 19
Библиографический список ...................................................................................... 22
23
1/--страниц
Пожаловаться на содержимое документа