Текст книги "Основы программирования в Linux"

Автор книги: Нейл Мэтью

Соавторы: Ричард Стоунс
сообщить о нарушении

Текущая страница: 24 (всего у книги 67 страниц)

Простое выделение памяти

Вы можете выделить память с помощью вызова malloc из стандартной библиотеки С:

#include

void *malloc(size_t size);

Примечание

Имейте в виду, что ОС Linux (следующая требованиям стандарта X/Open) отличается от некоторых реализаций UNIX тем, что не требует включения специального заголовочного файла malloc.h. Кроме того, параметр size, задающий количество выделяемых байтов, – это не простой тип int, хотя обычно он задается типом беззнаковое целое (unsigned integer).

В большинстве систем Linux вы можете выделять большой объем памяти. Давайте начнем с очень простой программы из упражнения 7.1, которая, тем не менее, выигрывает соревнование со старыми программами ОС MS-DOS, поскольку они не могут обращаться к памяти за пределами базовой карты памяти ПК объемом 640 Кбайт.

Упражнение 7.1. Простое распределение памяти

Наберите следующую программу memory1.с:

#include

#include

#include

#define A_MEGABYTE (1024 * 1024)

int main() {

 char *some_memory;

 int megabyte = A_MEGABYTE;

 int exit_code = EXIT_FAILURE;

 some_memory = (char*)malloc(megabyte);

 if (some_memory ! = NULL) {

  sprintf(some_memory, «Hello Worldn»);

  printf(«%s», some_memory);

  exit_code = EXIT_SUCCESS;

 }

 exit(exit_code);

}

Когда вы выполните эту программу, то получите следующий вывод:

$ ./memory1

Hello World

Как это работает

Данная программа запрашивает с помощью библиотечного вызова malloc указатель на один мегабайт памяти. Вы проверяете, успешно ли завершился вызов malloc, и используете часть памяти, чтобы продемонстрировать ее наличие. Когда вы выполните программу, то увидите вывод фразы «Hello World», показывающий, что malloc действительно вернул мегабайт используемой памяти. Мы не проверяем наличие мегабайта целиком; мы приняли на веру программный код malloc!

Поскольку функция malloc возвращает указатель типа void*, вы преобразуете результат в нужный вам указатель типа char*. Эта функция возвращает память, выровненную так, что она может быть преобразована в указатель любого типа.

Простое основание – современные системы Linux применяют 32-разрядные целые и 32-разрядные указатели, что позволяет задавать до 4 Гбайт. Эта способность задавать адреса с помощью 32-разрядного указателя без необходимости применения регистров сегментов или других приемов, называется простой 32-разрядной моделью памяти. Эта модель также используется и в 32-разрядных версиях ОС Windows ХР и Vista. Тем не менее, никогда не следует рассчитывать на 32-разрядные целые, поскольку все возрастающее количество 64-разрядных версий Linux находится в употреблении.

Выделение огромных объемов памяти

Теперь, когда вы увидели, что ОС Linux преодолевает ограничения модели памяти ОС MS-DOS, давайте усложним ей задачу. Приведенная в упражнении 7.2 программа запрашивает выделение объема памяти, большего, чем физически есть в машине, поэтому можно предположить, что функция malloc начнет давать сбои при приближении к максимальному объему физической памяти, поскольку ядру и всем остальным выполняющимся процессам также нужна память.

Упражнение 7.2. Запрос на всю физическую память

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

#include

#include

#include

#define A_MEGABYTE (1024 * 1024)

#define PHY_MEM_MEGS 1024 /* Откорректируйте это число

                             должным образом */

int main() {

 char *some_memory;

 size_t size_to_allocate = A_MEGABYTE;

 int megs_obtained = 0;

 while (megs_obtained < (PHY_MEM_MEGS * 2)) {

  some_memory = (char *)malloc(size_to_allocate);

  if (some_memory != NULL) {

   megs_obtained++;

   sprintf(somememory, «Hello World»);

   printf(«%s – now allocated %d Megabytesn», some_memory, megs_obtained);

  } else {

   exit(EXIT_FAILURE);

  }

 }

 exit(EXIT_SUCCESS);

}

Далее приведен немного сокращенный вывод:

$ ./memory3

Hello World – now allocated 1 Megabytes

Hello World – now allocated 2 Megabytes

...

Hello World – now allocated 2047 Megabytes

Hello World – now allocated 2048 Megabytes

Как это работает

Программа очень похожа на предыдущий пример. Это просто циклы, запрашивающие все больше и больше памяти до тех пор, пока не будет выделено памяти вдвое больше, чем заданный вами с помощью корректировки определения PHY_MEM_MEGS объем памяти, имеющейся у вашего компьютера. Удивительно, что эта программа вообще работает, потому что мы, как оказалось, создали программу, которая использует каждый байт физической памяти на машине одного из авторов. Обратите внимание на то, что в нашем вызове malloc применяется тип size_t.

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

Продолжим исследование и посмотрим, сколько памяти мы сможем выделить на этой машине с помощью программы memory3.c (упражнение 7.3). Поскольку уже понятно, что система Linux способна очень умно обходиться с запросами памяти, мы каждый раз будем выделять память по 1 Кбайт и записывать данные в каждый полученный нами блок.

Упражнение 7.3. Доступная память

Далее приведена программа memory3.c. По своей истинной природе она крайне недружественная по отношению к пользователю и может очень серьезно повлиять на многопользовательскую машину. Если вас беспокоит подобный риск, лучше совсем не запускать ее; если вы окажитесь от выполнения этой программы, усвоению материала это не повредит.

#include

#include

#include

#define ONE_K (1024)

int main() {

 char *some_memory;

 int size_to_allocate = ONE_K;

 int megs_obtained = 0;

 int ks_obtained = 0;

 while (1) {

  for (ks_obtained = 0; ks_obtained < 1024; ks_obtained++) {

   some_memory = (char *)malloc(size_to_allocate);

   if (some_memory == NULL) exit(EXIT_FAILURE);

   sprintf(some_memory, «Hello World»);

  }

  megs_obtained++;

  printf(«Now allocated %d Megabytesn», megs_obtained);

 }

 exit(EXIT_SUCCESS);

}

На этот раз вывод, также сокращенный, выглядит следующим образом:

$ ./memory3

Now allocated 1 Megabytes

...

Now allocated 1535 Megabytes

Now allocated 1536 Megabytes

Out of Memory: Killed process 2365

Killed

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

Как это работает

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

Сначала ядро может использовать свободную физическую память для удовлетворения запроса приложения на выделение памяти, но когда физическая память исчерпана, ядро начинает использовать так называемую область свопинга или подкачки. В ОС Linux это отдельная область диска, выделяемая во время инсталляции системы. Если вы знакомы с ОС Windows, функционирование области свопинга в Linux немного напоминает файл подкачки в Windows. Но в отличие от ОС Windows при написании программного кода не нужно беспокоиться ни о локальной, ни о глобальной динамической памяти (heap), ни о выгружаемых сегментах памяти – ядро Linux все организует для вас.

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

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

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

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

Примечание

Это поведение, сопровождающееся уничтожением процесса, отличается от поведения более старых версий Linux и множества других вариантов UNIX, в которых просто аварийно завершалась функция malloc. Называется оно уничтожением из-за нехватки памяти (out of memory (OOM) killer), и хотя может показаться чересчур радикальным, на самом деле служит разумным компромиссом между возможностью быстрого и эффективного выделения памяти процессам и необходимостью собственной защиты ядра от полного исчерпания ресурсов, что является серьезной проблемой.

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

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

Обычный результат – аварийное завершение последующих вызовов malloc не из– за нехватки памяти, а из-за повреждения структур памяти. Такие проблемы бывает трудно отследить, и чем быстрее в программах обнаружится ошибка, тем больше шансов найти причину. В главе 10, посвященной отладке и оптимизации, мы обсудим некоторые средства, которые могут помочь вам выявить проблемы, связанные с памятью.

Неправильное обращение к памяти

Предположим, что вы хотите сделать что-то «плохое» с памятью. В упражнении 7.4 в программе memory4.c вы выделяете некоторую область памяти, а затем пытаетесь записать данные за пределами выделенной области.

Упражнение 7.4. Неправильное обращение к вашей памяти

#include

#define ONE_K (1024)

int main() {

 char *some_memory;

 char *scan_ptr;

 some_memory = (char *)malloc(ONE_K);

 if (some_memory == NULL) exit(EXIT_FAILURE);

 scan_ptr = some_memory;

 while (1) {

  *scan_ptr = '';

  scan_ptr++;

 }

 exit(EXIT_SUCCESS);

}

Вывод прост:

$ ./memory4

Segmentation fault

Как это работает

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

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

Указатель null

Современные системы Linux, в отличие от ОС MS-DOS, но подобно новейшим вариантам ОС Windows, надежно защищены от записи или чтения по адресу, на который ссылается пустой указатель (null), хотя реальное поведение системы зависит от конкретной реализации.

Выполните упражнение 7.5.

Упражнение 7.5. Обращение по указателю null

Давайте выясним, что произойдет, когда мы попытаемся обратиться к памяти по пустому или null-указателю в программе memory5a.c.

#include

#include

#include

int main() {

 char *some_memory = (char*)0;

 printf(«A read from null %sn», some_memory);

 sprintf(some_memory, «A write to nulln»);

 exit(EXIT_SUCCESS);

}

Будет получен следующий вывод:

$ ./memory5a

A read from null (null)

Segmentation fault

Как это работает

Первая функция printf пытается вывести строку, полученную от указателя null; далее sprintf пытается записать по указателю null. В данном случае Linux (под видом библиотеки GNU С) простила чтение и просто предоставила «магическую» строку, содержащую символы (null). Система не столь терпима в случае записи и просто завершила программу. Такое поведение порой полезно при выявлении программных ошибок.

Если вы повторите попытку, но не будете использовать библиотеку GNU С, вы обнаружите, что безадресное чтение не разрешено. Далее приведена программа memory5b.c:

#include

#include

#include

int main() {

 char z = *(const char *)0;

 printf(«I read from location zeron»);

 exit(EXIT_SUCCESS);

}

Вы получите следующий результат:

$ ./memory5b

Segmentation fault

В этот раз вы пытаетесь прочесть непосредственно из нулевого адреса. Между вами и ядром теперь нет GNU-библиотеки libc, и программа прекращает выполнение. Имейте в виду, что некоторые системы UNIX разрешают читать из нулевого адреса, ОС Linux этого не допускает.

Освобождение памяти

До сих пор мы выделяли память и затем надеялись на то, что по завершении программы использованная нами память не будет потеряна, К счастью, система управления памятью в ОС Linux вполне способна с высокой степенью надежности гарантировать возврат памяти в систему по завершении программы. Но большинство программ просто не хотят распределять память, используют ее очень короткий промежуток времени и затем завершаются. Гораздо более распространено динамическое использование памяти по мере необходимости.

Программы, применяющие память на динамической основе, должны всегда возвращать неиспользованную память диспетчеру распределения памяти malloc с помощью вызова free. Это позволяет выделить блоки, нуждающиеся в повторном объединении, и дает возможность библиотеке malloc следить за памятью, вместо того, чтобы заставлять приложение управлять ею. Если выполняющаяся программа (процесс) использует, а затем освобождает память, эта освободившаяся память остается выделенной процессу. За кадром система Linux управляет блоками памяти, которые программист использует как набор физических «страниц» в памяти, размером 4 Кбайт каждая. Но если страница памяти в данный момент не используется, диспетчер управления памятью ОС Linux сможет переместить ее из оперативной памяти в область свопинга (это называется обменом страниц), где она слабо влияет на потребление ресурсов. Если программа пытается обратиться к данным на странице, которая была перенесена в область свопинга, Linux на очень короткое время приостанавливает программу, возвращает страницу обратно из области свопинга в физическую память и затем разрешает программе продолжить выполнение так, будто данные все время находились в оперативной памяти.

#include

void free(void *ptr_to_memory);

Вызов free следует выполнять только с указателем на память, выделенную с помощью вызова malloc, calloc или realloc. Очень скоро вы встретитесь с функциями calloc и realloc. А сейчас выполните упражнение 7.6.

Упражнение 7.6. Освобождение памяти

Эта программа называется memory6.c.

#include

#include

#define ONE_K (1024)

int main() {

 char *some_memory;

 int exit code = EXIT_FAILURE;

 some_memory = (char*)malloc(ONE_K);

 if (some_memory != NULL) {

  free(some_memory);

  printf(«Memory allocated and freed againn»);

  exit_code = EXIT_SUCCESS;

 }

 exit(exit_code);

}

Вывод программы следующий:

$ ./memory6

Memory allocated and freed again

Как это работает

Эта программа просто показывает, как вызвать функцию free с указателем, направленным на предварительно выделенную область памяти.

Примечание

Помните о том, что после вызова free для освобождения блока памяти этот блок больше не принадлежит процессу. Он больше не управляется библиотекой malloc. Никогда не пытайтесь читать из области памяти или писать в область памяти, для которой была вызвана функция free.

Другие функции распределения памяти

Две другие функции распределения или выделения памяти calloc и realloc применяются не так часто, как malloc и free.

Далее приведены их прототипы:

#include

void *calloc(size_t number_of_elements, size_t element_size);

void *realloc(void *existing_memozy, size_t new_size);

Несмотря на то, что функция calloc выделяет память, которую можно освободить с помощью функции free, ее параметры несколько отличаются от параметров функции malloc: она выделяет память для массива структур и требует задания количества элементов и размера каждого элемента массива как параметров. Выделенная память заполняется нулями; и если функция calloc завершается успешно, возвращается указатель на первый элемент. Как и в случае функции malloc, последовательные вызовы не гарантируют возврата непрерывной области памяти, поэтому вы не можете увеличить длину массива, созданного функцией calloc, просто повторным вызовом этой функции и рассчитывать на то, что второй вызов вернет память, добавленную в конец блока памяти, полученного после первого вызова функции.

Функция realloc изменяет размер предварительно выделенного блока памяти. Она получает в качестве параметра указатель на область памяти, предварительно выделенную функциями malloc, calloc или realloc, и уменьшает или увеличивает эту область в соответствии с запросом. Функция бывает вынуждена для достижения результата в перемещении данных, поэтому важно быть уверенным в том, что к памяти, выделенной после вызова realloc, вы всегда обращаетесь с помощью нового указателя и никогда не используете указатель, установленный ранее до вызова функции realloc.

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

my_ptr = malloc(BLOCK_SIZE);

...

my_ptr = realloc(my_ptr, BLOCK_SIZE * 10);

Если realloc завершится аварийно, она вернет пустой указатель; переменная my_ptr будет указывать в никуда и к первоначальной области памяти, выделенной функцией malloc, больше нельзя будет обратиться с помощью указателя my_ptr. Следовательно, было бы полезно сначала запросить новый блок памяти с помощью malloc, а затем скопировать данные из старого блока памяти в новый блок с помощью функции memcpy и освободить старый блок памяти вызовом free. При возникновении ошибки это позволит приложению сохранить доступ к данным, хранящимся в первоначальном блоке памяти, возможно, на время организации корректного завершения программы.