RDM/2 The Russian Electronic Developer Magazine  
RDM/2 Русский электронный журнал разработчика  
ДомойОт редактораПишите намОбратная связьRU/2

Использование High Memory в OS/2

Предисловие

Дмитpий Завалишин в свое время писал в статье "Пpогpаммиpование в OS/2" [1]:
Проблема, вызванная отсутствием проблем с памятью

Один из вечных вопросов программирования в DOS — память, а точнее, её нехватка. Вечные свопинги на диск перед запуском другой программы, копание во временных файлах, работа с данными по маленьким кусочкам — всё это отнимает массу времени и заставляет идти на ухищрения при решении, казалось бы, элементарных программистских задач. При программировании в операционных средах с виртуальной памятью (а к таковым принадлежит и OS/2) всё это совершенно не имеет смысла до тех пор, пока размеры данных не приближаются к пределу адресного пространства процессов (для текущей версии OS/2 — около 512 мегабайтов, в будущих версиях предполагается увеличение). Забудьте про временные файлы, и пусть ничто не остановит вас перед, скажем, такой последовательностью операторов:

int fd = open (filename,mode);
long size_of_file = filesize(fd);
char * input = malloc(size_of_file);
read(fd, input, (unsigned) size_of_file);
( Не забудьте, что это — 32-битовый мир, и параметр sizeof третьего аргумента функции read равен 4, как и параметр long.)
т.е. вроде бы как не стоит писать
char * input = malloc(size_of_file);
if(input == NULL)
{  printf("Error: malloc кердык\n");
  exit(1);
}
так как система сама ругнется на нехватку памяти.

Проблема

И вот в один прекрасный момент ваша программа загибается неизвестно где и почему. При разборе полётов выясняется, что malloc таки возвращает вам NULL. После чего вы решаете таки проверять возвращаемое malloc/realloc значение и ставите вышеописанную конструкцию. Однако при полевых испытаниях программа опять иногда загибается без сообщения об ошибке.

Делаем тестовую программу memEat.cpp
Программа выделяет по 1 Мб памяти, после получения NULL от malloc выводит сообщение об ошибке и выделяет по 1k , после очередного NULL выводит второе сообщение об ошибке и выделяет по 32 байта, после получения третьего NULL выводит третье сообщение и выходит по exit(1).

RAM eat:246Mb
RAM eat:247Mb
RAM eat:248Mb
Error1: malloc кердык
15675:263.3086Mb:
Error2: malloc кердык
5216:263.467804Mb:

Позвольте, а где обещанные 512 Mb ?! А где последнее сообщение об ошибке ?!

С последним сообщением все более-менее понятно: printf & Co сами пользуются внутри malloc'ом и в условиях нехватки памяти не работает. В случае использования более сложной системы обработки сообщений об ошибках (например, для PM-программы) вероятность попасть на функцию, использущую функцию, вызывающую malloc/calloc/realloc, значительно увеличивается.

А что же с нашими 512Mb ? Вспоминаем разные умные статьи, доки и факи. Пропустим процесс вспоминания, представим сразу результаты.

Системная информация

DosQuerySysInfo предоставляет нам достаточно много интересных параметров, среди которых QSV_MAXPRMEM и QSV_MAXSHMEM.
Попробуем собрать всю возможную информацию о системе, которую предоставляет фунция DosQuerySysInfo. При этом обнаруживается, что параметр QSV_MAX, вообще говоря, разный для разных версий оси (от 27 до 32). Собираем тестовую программу DosQuery.cpp и смотрим, что получается:

Revision 9.032
19 Maximum number of bytes of memory that can
 be allocated by all processes in the system 2068 279 296
20 Maximum number of bytes of memory that this
 process can allocate in its private arena. 271450112
21 Maximum number of bytes of memory that a process
 can allocate in the shared arena. 231538688

Revision 14.088
19 Maximum number of bytes of memory that can
 be allocated by all processes in the system 529948672
20 Maximum number of bytes of memory that this
 process can allocate in its private arena. 318111744
21 Maximum number of bytes of memory that a process
 can allocate in the shared arena. 1933312

Таким образом, мы можем сообразить, что реально malloc/calloc, который внутри вызывает DosAllocMem, может использовать памяти не более, чем указано в QSV_MAXPRMEM(20). Почему и откуда получается цифра в QSV_MAXSHMEM(21) — это на сегодняшний день науке неизвестно, но, очевидно, что чем больше значение для shared arena, тем меньше обычной памяти остается для процесса. Попутно можем заметить "драматическую разницу" в значениях для QSV_TOTAVAILMEM (19) для разных версий OS/2. Кроме того, заметим, что разница DosQuerySysInfo при реакции на запрос QSV_MAX параметров может быть использована нами для определения наличия поддержки High Memory, хотя далее мы будем использовать более прямой метод.

VIRTUALADDRESSLIMIT

VIRTUALADDRESSLIMIT — такая строка в CONFIG.SYS появилась в авроровских ядрах. Вот что по этому поводу написано в [5]:
A new config.sys parameter, VIRTUALADDRESSLIMIT, has been added to specify the highest virtual memory address that may be accessed. The default value for OS/2 Warp Server for SMP is 2 GB, which is specified in megabytes in the command argument:

VIRTUALADDRESSLIMIT=2048

The smallest value allowed is 512, which provides compatability with previous versions of OS/2 which only allowed access to 512 MB. The largest value supported is 3072 (3 GB). The VIRTUALADDRESSLIMIT parameter may be specified as part of selective install.

Values in excess of 512 will reduce the number of processes that can concurrently run on the system. When memory has been exhausted, OS/2 control program functions will fail with ERROR_NOT_ENOUGH_MEMORY and PM functions will fail with PMERR_INSUFFICIENT_MEMORY.

This information can be found in the SMP programming addendum, shipped as part of the Warp SMP toolkit (SMP.INF).

Warp SMP toolkit я не видел, а в обычном тулките есть addendum.inf (232941 | 16/10/00 | 13:14). Однако в этом addendum.inf нет никаких подробностей о том, как всё это можно использовать. Есть только суперлаконичный список APIs Supporting High Memory Objects.

26 Number of processors in the machine  1
27 Maximum amount of free space in process's high private arena 2348810240
28 Maximum amount of free space in process's high shared arena 2348810240
29 Maximum number of concurrent processes supported  172
30 Size of the user's address space in megabytes  3072

Итак, на новых ядрах процессу доступно раз в десять больше памяти, как же её теперь можно использовать?

OBJ_ANY: секретный параметр

Точно помню, что видел описание того, как можно использовать High Memory, вот где — так и не вспомнил. Единственное, что находит Google — это [7]:
(To activate HMS in your application, use the attribute OBJ_ANY with the memory allocation functions!)
APIRET result;
PCHAR lowp = NULL;
ULONG i, size;

 size = 1024*1024;
 result = DosAllocMem((PPVOID)&lowp,size,
             PAG_COMMIT | PAG_WRITE | OBJ_ANY)
\TOOLKIT\H\bsememf.h содержит следующее:
#define OBJ_ANY 0x00000400U /* allocate memory anywhere */
Итак, мы вспомнили или научились выделять память из High Memory private arena. Осталось научится пользоваться этим по-человечески.

User's heap

По-человечески пользоваться системой управления памятью — это значит через использование функций семейства malloc или им подобным. Многоплатформенные приложения, такие, как, например Squid или Mesa3d используют обертки (wrappers) для большинства системо-зависимых и системо-связанных функций. Например:
void *
_mesa_malloc(size_t bytes)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
 return xf86malloc(bytes);
#else
 return _malloc(bytes);
#endif
}
Таким образом можно сосредоточить все функции для работы с памятью в одном месте. Далее обращаемся к документации Visual Age C++, раздел "Managing Memory With Multiple Heaps"
VisualAge C++ now gives you the option of creating and using your own pools of memory, called heaps. You can use your own heaps in place of or in addition to the default VisualAge C++ runtime heap to improve the performance of your program. This section describes how to implement multiple user-created heaps using VisualAge C++.

Note: Many readers will not be interested in creating their own heaps. Using your own heaps is entirely optional, and your applications will work perfectly well using the default memory management provided (and used by) the VisualAge C++ runtime library. If you want to improve the performance and memory management of your program, multiple heaps can help you. Otherwise, you can ignore this section and any heap-specific library functions.

Работу с пользовательскими кучами поддерживают функции из семейства _umalloc, и описаны они в <umalloc.h>. EMX тоже содержит<umalloc.h> ([8]). Простейший пример работы с _umalloc смотрите в [9]. А теперь внимание! Делаем простейшее мыслительное усилие. Читаем описание _ucreate и догадывамся добавить в вызов DosAllocMem секретный параметр OBJ_ANY
#include 

Heap_t _ucreate(void *block, size_t initsz, int clean, int memtype,
 void *(*getmore_fn)(Heap_t, size_t *, int *)
 void (*release_fn)(Heap_t, void *, size_t);
Language Level: Extension

_ucreate creates your own memory heap that you can allocate and free memory from, just like the VisualAge C++ runtime heap.

Before you call _ucreate, you must first get the initial block of memory for the heap. You can get this block by calling an OS/2 API (such as DosAllocMem or or DosAllocSharedMem) or by statically allocating it. (See the CP Programming Guide and Reference for more information on the OS/2 APIs.)
Note: You must also return this initial block of memory to the system after you destroy the heap.

When you call _ucreate, you pass it the following parameters:
  • block The pointer to the initial block you obtained.
  • initsz The size of the initial block, which must be at least _HEAP_MIN_SIZE bytes (defined in<malloc.h>). If you are creating a fixed-size heap, the size must be large enough to satisfy all memory requests your program will make of it.
  • clean The macro _BLOCK_CLEAN, if the memory in the block has been initialized to 0, or !_BLOCK_CLEAN, if the memory has not been touched. This improves the efficiency of _ucalloc; if the memory is already initialized to 0, _ucalloc does not need to initialize it.
    • Note: DosAllocMem initializes memory to 0 for you. You can also use memset to initialize the memory; however, memset also commits all the memory at once, an action that could slow overall performance.
  • memtype A macro indicating the type of memory in your heap: _HEAP_REGULAR (regular) or _HEAP_TILED (tiled). If you want the memory to be shared, specify _HEAP_SHARED as well (for example, _HEAP_REGULAR | _HEAP_SHARED). Tiled memory blocks will not cross 64K boundaries, so the data in them can be used in 16-bit programs. Shared memory can be shared between different processes. For more information on different types of memory, see the Programming Guide and the Control Program Guide and Reference.
    • Note: Make sure that when you get the initial block, you request the same type of memory that you specify for memtype.
  • getmore_fn A function you provide to get more memory from the system (typically using OS/2 APIs or static allocation). To create a fixed-size heap, specify NULL for this parameter.
  • release_fn A function you provide to return memory to the system (typically using DosFreeMem). To create a fixed-size heap, specify NULL for this parameter.
If you create a fixed-size heap, the initial block of memory must be large enough to satisfy all allocation requests made to it. Once the block is fully allocated, further allocation requests to the heap will fail. If you create an expandable heap, the getmore_fn and release_fn allow your heap to expand and shrink dynamically.

When you call _umalloc (or a similar function) for your heap, if not enough memory is available in the block, it calls the getmore_fn you provide. Your getmore_fn then gets more memory from the system and adds it to the heap, using any method you choose.

Your getmore_fn must have the following prototype:

void *(*getmore_fn)(Heap_t uh, size_t *size, int *clean);
where:
  • uh Is the heap to get memory for.
  • size Is the size of the allocation request passed by _umalloc. You probably want to return enough memory at a time to satisfy several allocations; otherwise, every subsequent allocation has to call getmore_fn. You should return multiples of 64K (the smallest size that DosAllocMem returns). Make sure you update the size parameter if you return more than the original request.
  • clean Within getmore_fn, you must set this variable either to _BLOCK_CLEAN, to indicate that you initialized the memory to 0, or to !_BLOCK_CLEAN, to indicate that the memory is untouched.
Note: Make sure your getmore_fn allocates the right type of memory for the heap.

When you call _uheapmin to coalesce the heap or _udestroy to destroy it, these functions call the release_fn you provide to return the memory to the system. function.

Your release_fn must have the following prototype:

void (*release_fn)(Heap_t uh, void *block, size_t size);

The heap uh the block is from, the block to be returned, and its size are passed to release_fn by _uheapmin or _udestroy.

For more information about creating and using heaps, see the "Managing Memory" in the Programming Guide.

Return Value: If successful, _ucreate returns a pointer to the heap created. If errors occur, _ucreate returns NULL.
Таким образом, с <umalloc.h> мы, с одной стороны, можем использовать все свои старые функции, с другой стороны, остается вся фунциональность <malloc.h>, в том числе возможность сжатия кучи и автоматического (в VAC) использования отладочных версиий функций этого семейства, с третьей стороны, realloc и free сами умеют распознавать, из какой кучи используется память. Ещё с одной стороны — в программе остается обычная куча, которую используют функции printf и другие, и, таким образом, в случае некорректной работы с нашей пользовательской кучей есть надежда, что по крайней мере сообщения об ошибках будут доставлены по назначению.

Собственно, это всё ;-). Осталось только реализовать.

В примере Mem_OBJ.cpp: выделяется (но не коммитится) 1 Гб памяти, потом выделяется еще 1 Мб и пишется на диск посредством fwrite c передачей ему указателя из High Memory, затем читается и сравнивается с образцом.

В Memory2.cpp и imports.cpp приведен пример pеализации работы с High Memory для порта в OS/2 Mesa3d.


Ссылки по теме

  1. Введение в пpогpаммиpование под OS/2
    Дм.Завалишин
  2. OS/2 изнутри: работа с памятью
    Николай Смирнов, Евгений Лызенко, Мир ПК, #07/1997
  3. The Life Cycle of a Memory Page in OS/2
  4. The OS/2 API Project - DosAllocMem
  5. Frequently Asked Questions OS/2® Warp
    What is the parameter VIRTUALADDRESSLIMIT in config.sys
  6. os2ddprog/message/2465
    Scott Garfinkle сознаётся, что для VMLock есть ключик
    #define VMDHA_USEHMA 0x2000 /* Like OBJ_ANY for DosAllocMem -- use mem above 512mb line if possible */
  7. OS/2 address range и пример использования OBJ_ANY by Frank Meilinger
  8. Multiple heaps in EMX
    The interface to multiple heaps is more or less compatible to the one of IBM's Visual Age C++ compiler. Definitions and declarations for using multiple heaps are in the <umalloc.h> header.
  9. Example of Using VisualAge Extenstions to Memory Management Functions
Исходные тексты и три откомпилированнных примера к данной статье: HighMemory_examples.zip
Евгений Коцюба, 2003

---
Интересные ссылки:

---

---
Комментариев к странице: 0 | Добавить комментарий
---
Редактор: Дмитрий Бан
Оформление: Евгений Кулешов
(C) Russian Underground/2