Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 11)

Рассмотрим теперь использование логических команд при обработке упакованных структур данных. Пусть, например, на языке Паскаль дано описание упакованного массива с элементами ограниченного целого типа:

Const N=10000;

Var A: packed array[0..N] of 0..15;

X: byte;

Напомним, что служебное слово packed есть рекомендация Паскаль-машине по возможности более компактно хранить данные, даже если это повлечёт за собой увеличения времени доступа к этим данным по чтению и записи. Многие Паскаль-машины могут и "не прислушаться" к этим рекомендация (игнорировать их).

Рассмотрим фрагмент программы на Ассемблере, который работает с описанным выше упакованным массивом A. Реализуем, например, оператор присваивания X:=A[i]. Каждый элемент массива требует для своего хранения 4 бита памяти, так что будем в одном байте хранить два последовательных элемента массива A:

N equ 10000

Data segment

A db N/2 dup (?); N/2  N div 2

X db ?

. . .

Data ends

. . .

mov bx,i

xor ax,ax; ax:=0

shr bx,1

mov al,A[bx]; в al два элемента

jc L1; i-ый элемент – правый

mov cl,4; число сдвигов

shr al,cl

L1: and al,1111b; выделение A[i]

mov X,al

Сначала мы разделили индекс i на 2 и определили тот байт массива A, в котором находится пара элементов, один из которых нам нужен. На положение нужного нам элемента в байте указывает остаток от деления индекса i на 2: если остаток равен нулю (т.е. i чётное), то элемент расположен в левых четырёх битах байта, иначе – в правых. Для выделения нужного элемента, который занимает в байте только 4 бита из 8, мы использовали команду логического умножения and al,1111b , где второй операнд задан для удобства понимания смысла команды в виде двоичного числа, на что указывает буква b в конце этого числа.

Использование команды логического умножения для выделения нужной нам части байта или слова, и обнуление остальной части является типичной для программирования на Ассемблере. При этом константа, используемая для выделения нужной части (у нас это 00001111b), называется маской выделения или просто маской. Таким образом, мы поместили элемент массива X, который занимает 4 бита, в регистр al и дополнили этот элемент до 8 бит нулями слева. Заметим, что это не изменило величины нашего элемента, так как он беззнаковый (0..15).

Наш простой пример показывает, что при работе с упакованными данными скорость доступа к ним уменьшается в несколько раз и программист должен решить, стоит ли это достигнутой нами экономии памяти (в нашем примере мы сэкономили 5000 байт оперативной памяти). Обычно это типичная ситуация в программировании: выигрывая в скорости обработки данных, мы проигрываем в объёме памяти для хранения этих данных, и наоборот. Иногда, по аналогии с физикой, это называют "законом рычага", который гласит, что, выигрывая в силе, мы проигрываем в длине перемещения конца рычага, и наоборот.

Упражнение. Реализуйте для нашего примера оператор присваивания A[i]:=X.

В качестве последнего примера использования логических команд рассмотрим реализацию на Ассемблере некоторых операций языка Паскаль над множествами. Пусть на Паскале есть описания двух символьных множеств X и Y, а также символьной переменной Sym:

Var X,Y: set of char; Sym: char;

Напишем на Ассемблере фрагмент программы для реализации операции объединения двух множеств:

X := X + Y;

Каждое такое множество будем хранить в памяти в виде 256 последовательных битов, т.е. 32 байт или 16 слов. Бит, расположенный в позиции I принимает значение 1, если символ с номером I присутствует во множестве, иначе этот бит имеет значение 0. Множества X и Y можно так описать на Ассемблере:

Data Segment

. . .

X dw 16 dup (?)

Y dw 16 dup (?)

. . .

Data ends

Тогда операцию объединения двух множеств можно реализовать, например, таким фрагментом на Ассемблере:

mov cx,16

xor bx,bx

L: mov ax,Y[bx]

or X[bx],ax

add bx,2

loop L

В заключение рассмотрим условный оператор языка Паскаля, включающий операцию отношения in (символ Sym входит во множество X):

if Sym in X then goto L;

На Ассемблере этот оператор можно, например, реализовать в виде такого фрагмента программы:

. . .

X db 32 dup (?); 32*8=256 битов

Sym db ?

. . .

mov al,Sym

mov cl,3

shr al,cl

xor bx,bx

mov bl,al; Индекс нужного байта в X

mov al,X[bx]; Байт с символом Sym

mov cl,Sym

and cl,111b; Позиция символа Sym в байте

shl al,cl; наш бит в al – крайний слева

shl al,1; Нужный бит в CF

jc L

Сначала, используя команду сдвига на 3 (это, как мы знаем, аналогично делению на 8), на регистр bx заносим индекс того байта в X, в котором находится бит, соответствующий символу Sym в множестве X. Затем этот байт выбирается на регистр al, а на регистр cl помещаем три последних бита номера символа Sym в алфавите – это и будет номер нужного нам бита в выбранном байте (правда, биты при этом нумеруем слева направо, начиная с нуля). После этого первой командой сдвига перемещаем нужный нам бит в крайнюю левую позицию в байте, а следующей командой сдвига – во флаг переноса. Теперь осталось только сделать условный переход по значению этого флага.

На этом мы закончим рассмотрение логических команд.

10. Модульное программирование

Сейчас мы переходим к новой теме – модульному программированию. Модульное программирование предполагает особый способ разработки программы, которая при этом строится из нескольких относительно независимых друг от друга частей – модулей. Модули могут писаться как на одном языке программирования, например, на Ассемблере, так и на разных языках, в этом случае говорят, что используется многоязыковая система программирования. Что такое система программирования мы строго определим несколько позже, а пока изучим общее понятие модульного программирования и программного модуля.

Мы уже знаем одно из полезных свойств такой программы, отдельные части (модули) которой написаны на разных языках программирования – это позволяет нам из программ на языках высокого уровня вызывать процедуры на Ассемблере. Познакомимся теперь со свойствами модульной программы, написанной на одном языке программирования (в нашем случае на Ассемблере).

Перечислим сначала те преимущества, которые предоставляет модульное программирование. Во-первых, как мы уже отмечали, это возможность писать модули на разных языках программирования. Во-вторых, модуль является естественной единицей локализации имён: как мы говорили, внутри модуля на Ассемблере все имена должны быть различны (уникальны),¹ что не очень удобно, особенно когда модуль большой по объёму или совместно пишется разными программистами. Как и в блоке программы на языке Паскаль, имена локализованы в модуле на Ассемблере и не видны из другого модуля, если только это не указано явно с помощью специальных директив.

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

Разумеется, за всё надо платить, у модульного программирования есть и свои слабые стороны. Во-первых, модули не являются совсем независимыми друг от друга: между ними существуют связи, то есть один модуль иногда может использовать переменные и программный код другого модуля. Необходимость связей между модулями естественно вытекает из того факта, что модули совместно решают одну общую задачу, при этом каждый модуль выполняет свою часть задачи. Связи между модулями на Ассемблере должны быть явно заданы при описании этих модулей.

Во-вторых, теперь перед счётом программы необходим особый этап сборки программы из составляющих её модулей. Этот процесс достаточно сложен, так как кроме собственно сборки программы из модулей, необходимо проконтролировать и установить все связи между модулями.³ Сборки программы из модулей производится специальной системной программой, которая называется редактором внешних связей между модулями.

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

Несмотря на отмеченные недостатки, преимущества модульного программирования так велики, что сейчас это главный способ разработки программного обеспечения. Теперь мы начнём знакомиться с особенностями написания модульной программы на языке Ассемблера.

10.1. Модульное программирование на Ассемблере.

Как мы уже говорили, программа на Ассемблере может состоять из нескольких модулей. Исходным (или входным) программным модулем на Ассемблере называется текстовый файл, состоящий из предложений языка Ассемблер и заканчивающийся специальной директивой с именем end – признаком конца модуля.

Среди всех модулей, составляющих программу, должен быть один и только один модуль, который называется головным модулем программы. Признаком головного модуля является параметр-метка у директивы end конца модуля, в учебниках такую метку часто называют именем Start, хотя это, как мы отмечали, несущественно и можно выбрать любое подходящее имя. Эта метка должна быть меткой команды, которая находится в одном из сегментов головного модуля. Именно этот сегмент по определению будет кодовым сегментом и содержать первую выполняемую команду всей программы. Перед началом счёта программы загрузчик установит на начало этого кодового сегмента регистр CS, а в счётчик адреса IP запишет смещение указанной метки начальной команды в сегменте кода.

Как уже отмечалось, модули не могут быть абсолютно независимыми друг от друга, так как решают разные части одной общей задачи, и, следовательно, хотя бы время от времени должны обмениваться между собой информацией. Таким образом, между модулями существуют связи. Говорят, что между модулями существуют связи по управлению, если один модуль может передавать управление (с возвратом или без возврата) на программный код в другом модуле. В архитектуре нашего компьютера для такой передачи можно использовать одну из команд перехода.

Кроме связей по управлению, между модулями могут существовать и связи по данным. Связи по данным предполагают, что один модуль может иметь доступ к областям памяти (переменным) в другом модуле. Частным случаем связи по данным является и использование одним модулем целочисленной константы, определённой в другом модуле (в Ассемблере такая константа может объявляться, например, директивой эквивалентности equ).

Связи между модулями реализуются в виде адресов, для нашей архитектуры это одно число (близкий адрес) или два числа (дальний адрес – значение сегментного регистра и смещения в сегменте).¹ Действительно, чтобы выполнить команду из другого модуля, а также считать или записать значение в переменную, нужно знать месторасположение (адрес) этой команды или переменной. Заметим, что численные значения связей между модулями (значения адресов) невозможно установить на этапе компиляции модуля, так как будущее расположение модулей в памяти во время счёта неизвестно на этапе компиляции.

Связи между модулями будем называть статическими, если численные значения этих связей (т.е. адреса) известны до начала счёта программы (до выполнения её первой команды). В отличие от статических, значения динамических связей между модулями становятся известны только во время счёта программы. Вскоре мы приведём примеры статических и динамических связей, как по данным, так и по управлению.

На языке Ассемблера связи между модулями задаются с помощью специальных директив. Директива

public <список имён модуля>

объявляет перечисленные в директиве имена общедоступными, т.е. разрешает использование этих имён в других модулях. В некоторых модульных системах программирования про такие имена говорится, что они экспортируются в другие модули.² В Ассемблере вместе с каждым именем экспортируется и его тип. Как мы уже знаем, для имён, использованных в директивах резервирования памяти, тип имени определяет длину области памяти, а для меток их тип равен –1 для близкой метки и –2 для дальней. Остальные имена (имена сегментов, имена констант в директивах эквивалентности и другие) имеют тип ноль. Тип имени в принципе позволяет проводить контроль использования этого имени в другом модуле. Все остальные имена модуля, кроме имён, перечисленных в директивах public, являются локальными и не видны извне (из других модулей).

Экспортируемые имена одного модуля не становятся автоматически доступными в других модулях. Для получения доступа к таким именам этот другой модуль должен, с помощью специальной директивы, явно объявить о своём желании использовать общедоступные имена первого модуля. Это делается с помощью директивы

extrn <имя:тип>,...,<имя:тип>

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

Таким образом, для установления связи между двумя модулями первый модуль должен разрешить использовать некоторые из своих имён в других модулях, а второй модуль – явно объявить, что он хочет использовать внутри себя такие имена. В языке Ассемблера общедоступные имена называются входными точками модуля, что хорошо отражает суть дела, так как только в эти точки возможен доступ к модулю извне (из других модулей). Внешние имена модуля называются внешними адресами, так как это адреса областей памяти и команд, а также значения констант в других модулях.

Все программы, которые мы писали до сих пор, на самом деле состояли из двух модулей, но один из них с именем ioproc мы не писали сами, он поставлялся нам в готовом виде. Этот второй модуль содержит процедуры ввода/вывода, к которым мы обращаемся с помощью наших макрокоманд (inint, outint и других). Теперь настало время написать программу, которая будет содержать два наших собственных модуля, и модуль ioproc (так как без ввода/вывода нам, скорее всего, не обойтись).

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

Характеристики

Список файлов лекций