В начало

СПИСОК ЛИТЕРАТУРЫ

8. МОДЕЛИ ПАМЯТИ

Реализация моделей памяти в СП MSC и в СП ТС имеет ряд отличий. В разделах 8.1 и 8.2 описаны модели памяти СП MSC, а в разделе 8.3 приведены отличия моделей памяти СП ТС.

8.1. Виды моделей

Применение моделей памяти позволяет контролировать распределение памяти в программе и делать его более эффективным или адекватным решаемой задаче. По умолчанию в процессе компиляции и редактирования связей генерируется код для работы в малой (small) модели. Для большинства программ этой модели достаточно. Существуют, однако, два условия, когда малая модель не годится; если программа удовлетворяет хотя бы одному из них, следует использовать другую модель памяти:

— размер кода программы превышает 64 Кбайта;

— размер статических данных программы превышает 64 Кбайта.

Имеется два варианта выбора модели памяти для программы: назначить при компиляции новую модель вместо действующей по умолчанию малой либо использовать в объявлении объектов программы модификаторы near, far, huge. Можно также комбинировать эти способы.

Архитектура микропроцессора типа 8086/8088 предусматривает разбиение оперативной памяти на физические сегменты. Размер одного сегмента не превышает 64 Кбайта. Минимальное количество сегментов, которое выделяется программе, равно двум: один для кода, другой для статических данных. Эти сегменты называются стандартными. Малая модель памяти использует только эти два сегмента. Другие модели позволяют выделять программе более одного сегмента кода и/или данных.

Статические данные — это все данные, объявленные в программе с классом памяти extern или static. Формальные параметры функций и локальные переменные функций и блоков не являются статическими данными. Они хранятся не в сегменте данных, а в сегменте стека. Он обычно совмещен со стандартным сегментом данных физически.

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

Адрес оперативной памяти состоит из двух частей:

1) 16-битового числа, представляющего базовый адрес сегмента;

2) 16-битового числа, представляющего смещение внутри этого сегмента.

Для доступа к коду или данным, находящимся в стандартном сегменте, достаточно использовать только вторую часть адреса, т.е. смещение. В этом случае можно применить указатель, объявленный с модификатором near (ближний). Поскольку для доступа к объекту используется только одно 16-битовое число, применение указателей типа near компактно по занимаемой памяти и быстро по времени.

Если код или данные располагаются за пределами стандартных сегментов, для доступа к ним должны использоваться обе части адреса — и адрес сегмента, и смещение. Указатели для такого доступа объявляются с модификатором far (дальний). Доступ к объектам по указателям типа far занимает больше памяти и времени, однако позволяет адресовать всю оперативную память, а не только 64 Кбайта.

Имеется третий вид указателей — huge (максимальный). Адрес типа huge подобен адресу типа far, поскольку оба включают и адрес сегмента, и смещение. Однако адресная арифметика для far и huge адресов различается. Поскольку объекты, адресуемые far указателями, не выходят за границу адресуемого сегмента, действия адресной арифметики выполняются только над второй половиной адреса — над смещением. Это ускоряет доступ, однако ограничивает размер одного программного объекта 64 Кбайтами. Для указателей типа huge арифметические действия выполняются над всеми 32 битами адреса.

Тип адреса huge определен только для данных (массивов); никакой сегмент кода, т. е. никакой из исходных файлов, составляющих программу, не может сгенерировать больше 64 Кбайтов кода. Поэтому ключевое слово huge применимо только к элементам данных — массивам и указателям на них.

Малая модель

В малой (small) модели памяти программа занимает два стандартных сегмента: сегмент кода и сегмент данных, в котором размещен также стек. Как код, так и данные программы не могут превышать 64 Кбайтов; следовательно, суммарный размер программы не может превышать 128 Кбайтов. Малая модель подходит для большинства программ и потому назначается компилятором по умолчанию.

В малой модели для доступа к объектам кода или данных используются указатели типа near. Можно, однако, изменить это умолчание, применяя модификаторы far или huge для объявления элементов данных и модификатор far для функций.

Средняя модель

В средней (medium) модели памяти для данных и стека программы выделяется один сегмент, а для кода — столько сегментов, сколько потребуется. Каждому исходному модулю программы выделяется собственный сегмент кода.

Средняя модель применяется обычно для программ с большим количеством операторов (более 64 Кбайтов кода), но сравнительно небольшим размером данных (менее 64 Кбайтов). Для доступа к функциям по умолчанию используются указатели типа far, для доступа к данным — указатели типа near. Можно, однако, изменить это умолчание, применяя модификаторы far или huge для объявления элементов данных и модификатор near для функций.

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

Компактная модель

В компактной (compact) модели программному коду выделяется только один сегмент, а данным — столько сегментов, сколько потребуется. Компактная модель применяется для программ, небольших по количеству операторов, но работающих с большим объемом данных.

В компактной модели доступ к коду (функциям) производится по указателям типа near, а к данным — по указателям типа far. Это умолчание можно обойти, используя модификаторы near и huge для объявления данных и модификатор far для функций.

Большая модель

В большой (large) модели и под код, и под данные выделяется несколько сегментов. Большая модель используется для больших программ с большим объемом данных.

В большой модели доступ к элементам кода и данных производится по указателям типа far. Это умолчание можно обойти, используя модификаторы near и huge для объявления данных и модификатор near для функций.

Максимальная модель

Максимальная (huge) модель аналогична большой модели, за исключением того, что в ней снимается ограничение на размер массивов (указатели типа far, применяемые в большой модели, ограничивают размер отдельного элемента данных 64 Кбайтами). Некоторые ограничения, однако, налагаются на размер элементов huge массивов, если эти массивы превышают по размеру 64 Кбайта. В целях повышения эффективности адресации не допускается пересечения элементами массива границ сегмента. Из этого вытекает следующее:

1) Никакой элемент массива не может превышать по размеру 64 Кбайта.

2) Если размер массива больше 128 Кбайтов, размер его элементов (в байтах) должен быть степенью двойки (т.е. 2, 4, 8, 16 и т.д.). Если же размер массива меньше или равен 128 Кбайтам, то размер его элементов может быть от 1 байта до 64 Кбайтов (включительно).

Работая в максимальной модели, программист должен быть осторожен в применении операции sizeof и при вычитании указателей. В языке Си определено, что значение операции sizeof имеет тип unsigned int, однако число байтов в huge массиве может быть представлено только типом unsigned long. Для получения правильного значения в этом случае следует применять приведение типа операции sizeof:

(unsigned long) sizeof (huge_item)

Аналогично, результат вычитания указателей определен в языке Си как значение типа int. При вычитании указателей типа huge может оказаться, что результат имеет тип long. В этом случае также необходимо применить приведение типа:

(long) (huge_ptrl—huge_ptr2)

8.2. Модификация стандартной модели памяти

Работая в некоторой стандартной модели памяти, программист может в той или иной мере модифицировать ее, применяя в объявлениях модификаторы near, far и huge. Правила интерпретации объявлений с модификаторами рассмотрены в разделе 3.3.3.4 "Модификаторы near, far, huge".

8.2.1. Объявление данных

Если непосредственно за ключевым словом near, far или huge следует идентификатор, то это значит, что соответствующий элемент данных будет размещен в стандартном сегменте (для near) или может быть размещен в другом сегменте данных (для far или huge). Например, объявление

char far x;

сообщает, что адрес объекта х имеет тип far.

Если же непосредственно за ключевым словом near, far или huge следует признак указателя (звездочка), то это значит, что соответствующий указатель будет хранить адрес типа near, типа far или типа huge, соответственно. Например, объявление

char far *p;

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

char * far p;

объявляет р как указатель на char, причем сам указатель р может находиться в любом сегменте, и его адрес имеет тип far.

Объявление

char far * far p;

сообщает, что указатель р может указывать на объекты с адресом типа far. Адрес самого указателя р также имеет тип far.

Примеры:

char а[3000]; /*пример 1: малая модель*/

char far b[30000]; /*пример 2: малая модель*/

char а[3000]; /*пример 3: большая модель*/

char near b[3000]; /*пример 4: большая модель*/

char huge a[70000]; /*пример 5: малая модель*/

char huge *pa; /*пример 6: малая модель*/

char *pa; /*пример 7: малая модель*/

char far *pb; /*пример 8: малая модель*/

char far **pa; /*пример 9: малая модель*/

char far **pa; /*пример 10: большая модель*/

char far *near *pb; /*пример 11: любая модель*/

char far *far *pb; /*пример 12: любая модель*/

В примере 1 массиву а выделяется память в стандартном сегменте данных; массиву b во втором примере память может быть выделена в любом из сегментов данных программы. Поскольку оба объявления сделаны в малой модели, то, вероятно, массив а содержит часто используемые данные, которые для ускорения доступа должны располагаться в стандартном сегменте, а массив b содержит редко используемые данные, которые могут выйти за пределы 64-Кбайтного сегмента данных. Можно было бы использовать здесь другую модель памяти, в которой адрес данных по умолчанию имел бы тип far, однако для сохранения быстрого доступа к массиву а лучше сохранить малую модель, а адрес массива b объявить как far.

В примере 2 указан большой размер массива b, поскольку более вероятно, что программист будет модифицировать тип адреса объекта большой длины, который может не поместиться в текущий сегмент.

В примере 3, очевидно, скорость доступа к массиву а не является критичной; независимо от того, попадет он в стандартный сегмент или не попадет, обращение к нему всегда будет осуществляться по 32-битовому адресу. В примере 4 массиву b с помощью модификатора near явно назначен стандартный сегмент, с целью ускорения доступа к нему в большой модели.

В примере 5 массив а должен быть явно объявлен как huge, поскольку его размер превышает 64 Кбайта. Использование модификатора huge вместо выбора максимальной модели памяти в качестве стандартной позволяет сэкономить время доступа: только к массиву а обращение будет осуществляться по адресу типа huge, а все остальные данные будут размещаться в стандартном сегменте. Для обращения к массиву а может быть использован указатель ра из примера 6. Все арифметические операции над указателем ра (например, ра++) будут выполняться над всеми 32 его битами.

В примере 7 ра объявляется как указатель на near char. Указатель получает тип near по умолчанию, поскольку речь идет о малой модели. В примере 8 pb явно объявляется как указатель на far char. Он может быть использован, в частности, для доступа к символьному массиву, расположенному не в стандартном сегменте памяти. Например, ра может указывать на массив а из примера 1, a pb — на массив b из примера 2.

Хотя объявления ра в примерах 9 и 10 идентичны, в примере 9 ра объявляется как указатель на near массив указателей на тип far char, а в примере 10 ра объявляется как указатель на far массив указателей на тип far char.

В примере 11 pb объявляется как указатель на near массив указателей на тип far char. В примере 12 pb объявляется как указатель на far массив указателей на тип far char. В этих примерах употребление слов far и near изменяет действующие по умолчанию соглашения, связанные с моделями памяти; в отличие от примеров 9 и 10, объявления pb не зависят от выбранной модели памяти и в любой модели имеют одинаковый смысл.

8.2.2. Объявление функций

Правила применения модификаторов near и far в объявлениях функций аналогичны правилам применения их в объявлениях данных. Если непосредственно за модификатором следует имя функции, то данное ключевое слово определяет, в каком сегменте будет размещена функция. Например,

char far fun();

определяет fun как функцию, вызываемую по 32-битовому адресу и возвращающую тип char.

Если же непосредственно за специальным ключевым словом следует признак указателя (звездочка), то данное ключевое слово определяет тип адреса функций, которые могут вызываться через этот указатель. Например,

char (far *pfun) ();

определяет pfun как указатель (32-битовый) на far функцию, возвращающую char.

Модификатор huge к функциям и указателям на функции неприменим.

Объявления функций должны соответствовать их определениям по набору и расположению модификаторов. Рекомендуется всегда использовать предварительные объявления функций со списками типов аргументов, чтобы компилятор мог выявить ситуации некорректного вызова функции.

Примеры:

char far fun(); /*пример 1: малая модель*/

static char far *near fun(); /*пример 2: большая модель*/

void far fun(); /*пример 3: малая модель*/

void(far *pfun)()=fun;

double far * far fun(); /*пример 4: компактная модель*/

double far * (far *pfun)()=fun;

В первом примере fun объявляется как функция, возвращающая char. Ключевое слово far в объявлении означает, что fun вызывается по 32-битовому адресу типа far.

Во втором примере fun объявляется как near функция класса памяти static, возвращающая указатель на far char. Такая функция в большой модели памяти может быть использована, например, как вспомогательная подпрограмма, которая вызывается часто, но только функциями из своего исходного файла. Поскольку все функции из одного исходного файла помещаются в один и тот же сегмент, они могут обращаться друг к другу по адресам типа near. Будет ошибкой, однако, передать адрес функции fun в качестве аргумента другой функции, расположенной за пределами сегмента, в котором определена fun, поскольку из другого сегмента функция fun не может быть вызвана.

В третьем примере pfun объявляется как указатель на far функцию, не возвращающую значения, а затем ему присваивается адрес функции fun. Фактически pfun может быть использован для доступа к любой функции, имеющей тип адреса far. Следует понимать, что если функция, вызванная через указатель pfun, не была объявлена с модификатором far, или не получила тип far по умолчанию, то ее вызов приведет к ошибке во время выполнения.

В примере 4 pfun объявляется как указатель на far функцию, возвращающую указатель на far double, после чего ему присваивается адрес функции fun. Такой вариант может использоваться, например, в компактной модели памяти для функции, которая используется редко, и потому необязательно должна находиться в стандартном сегменте кода. И функция, и указатель должны быть объявлены с модификатором far.

8.3. Модели памяти СП ТС

Организация работы с моделями памяти в СП ТС имеет ряд отличий от СП MSC.

В дополнение к описанным выше моделям СП ТС имеет еще одну — tiny (минимальную). В этой модели вся программа — код, данные, стек, динамическая память — размещается в одном сегменте. Таким образом, размер программы ограничен 64 Кбайтами. Все указатели в этой модели имеют тип near. Программы модели памяти tiny могут быть преобразованы в формат выполняемых файлов СОМ операционной системы MS-DOS.

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

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

Указатели типа huge в СП ТС всегда хранятся в нормализованном виде, так что значение смещения никогда не превышает 15. Нормализация требует дополнительных временных затрат при работе с указателями тип huge, но зато позволяет применять к ним операции отношения (с ненормализованными 32-битовыми указателями операции отношения работают некорректно).

Допустимо применение модификатора huge к функциям и указателям на функции.

Имеется также четыре специальных указателя типа near с именами _cs, _ds, _ss, _es. Это 16-битовые указатели, ассоциированные с сегментными регистрами микропроцессора, содержащими адреса сегментов кода, данных, стека и динамической памяти, соответственно. Например, указатель р, объявленный следующим образом

char _ss *p;

будет содержать 16-битовое значение, хранящееся в сегменте стека.

Объявления с модификаторами near, far, huge отличаются тем, что нельзя модифицировать тип адреса самого указателя. Модификатор в объявлении указателя может стоять только перед звездочкой, тем самым объявляя указатель на модифицируемый тип. А объявление

int * far p;

допустимое в СП MSC, считается ошибкой в СП ТС.