 |
The Russian Electronic Developer Magazine |
 |
Русский электронный журнал разработчика |
     |
|
|
The Russian Electronic Developer Magazine |
|
Русский электронный журнал разработчика |
|
|
т.е. вроде бы как не стоит писать
Проблема, вызванная отсутствием проблем с памятью Один из вечных вопросов программирования в 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);
}
Делаем тестовую программу 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 ? Вспоминаем разные умные статьи, доки и факи. Пропустим процесс вспоминания, представим сразу результаты.
| Revision 9.032 | |
| |
Revision 14.088 | |
|
Таким образом, мы можем сообразить, что реально malloc/calloc, который внутри вызывает DosAllocMem, может использовать памяти не более, чем указано в QSV_MAXPRMEM(20). Почему и откуда получается цифра в QSV_MAXSHMEM(21) — это на сегодняшний день науке неизвестно, но, очевидно, что чем больше значение для shared arena, тем меньше обычной памяти остается для процесса. Попутно можем заметить "драматическую разницу" в значениях для QSV_TOTAVAILMEM (19) для разных версий OS/2. Кроме того, заметим, что разница DosQuerySysInfo при реакции на запрос QSV_MAX параметров может быть использована нами для определения наличия поддержки High Memory, хотя далее мы будем использовать более прямой метод.
Warp SMP toolkit я не видел, а в обычном тулките есть addendum.inf
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).
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 |
Итак, на новых ядрах процессу доступно раз в десять больше памяти, как же её теперь можно использовать?
\TOOLKIT\H\bsememf.h содержит следующее:
(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)
#define OBJ_ANY 0x00000400U /* allocate memory anywhere */Итак, мы вспомнили или научились выделять память из High Memory private arena. Осталось научится пользоваться этим по-человечески.
void *
_mesa_malloc(size_t bytes)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86malloc(bytes);
#else
return _malloc(bytes);
#endif
}
Работу с пользовательскими кучами поддерживают функции из семейства _umalloc, и описаны они в <umalloc.h>. EMX тоже содержит<umalloc.h> ([8]). Простейший пример работы с _umalloc смотрите в [9]. А теперь внимание! Делаем простейшее мыслительное усилие. Читаем описание _ucreate и догадывамся добавить в вызов DosAllocMem секретный параметр OBJ_ANY
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.h> мы, с одной стороны, можем использовать все свои старые функции, с другой стороны, остается вся фунциональность <malloc.h>, в том числе возможность сжатия кучи и автоматического (в VAC) использования отладочных версиий функций этого семейства, с третьей стороны, realloc и free сами умеют распознавать, из какой кучи используется память. Ещё с одной стороны — в программе остается обычная куча, которую используют функции printf и другие, и, таким образом, в случае некорректной работы с нашей пользовательской кучей есть надежда, что по крайней мере сообщения об ошибках будут доставлены по назначению.
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.)
When you call _ucreate, you pass it the following parameters:
Note: You must also return this initial block of memory to the system after you destroy the heap.
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.
- 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.
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:
Note: Make sure your getmore_fn allocates the right type of memory for the heap.
- 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.
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.
Собственно, это всё ;-). Осталось только реализовать.
В примере Mem_OBJ.cpp: выделяется (но не коммитится) 1 Гб памяти, потом выделяется еще 1 Мб и пишется на диск посредством fwrite c передачей ему указателя из High Memory, затем читается и сравнивается с образцом.
В Memory2.cpp и imports.cpp приведен пример pеализации работы с High Memory для порта в OS/2 Mesa3d.
Евгений Коцюба, 2003
Интересные ссылки:
Комментариев к странице: 0 | Добавить комментарий
Редактор: Дмитрий Бан
Оформление: Евгений Кулешов