Как обнаруживают программно количество байтов, выделенных процессом на "куче"?

Для такого старого языка программирования (ну, может быть, не старого Lisp, но Ruby в конце концов старше Java) и сообщества, фанатично относящегося к качеству, стилю и красоте кода, Книжный рынок Ruby на удивление мало относится к книгам «более высокого уровня».

На это есть несколько причин: многие Rubyists уже являются опытными программистами на Smalltalk или Lisp, когда они берут на себя Ruby, поэтому они им не нужны. А Ruby и Smalltalk настолько похожи, что вместо этого вы можете просто прочитать книгу о Smalltalk. (Например, вы можете в значительной степени прочитать список бесплатных книг по Smalltalk Стефана Дюкасса сверху вниз.) То же самое касается Perl.

До недавнего времени лучшей книгой по Ruby высокого уровня была в основном Шаблоны передовой практики Smalltalk , автор Кент Бек .

#include <malloc.h>


struct mallinfo *info;

info = mallinfo();

printf ("total allocated space:  %llu bytes\n", info->uordblks);
printf ("total free space:       %llu bytes\n", info->fordblks);

Структура struct mallinfo является технической и специфичной для реализации malloc (). Но там есть нужная вам информация. Вот как я сообщаю о значениях:

mallinfo.arena = "Total Size (bytes)" 
mallinfo.uordblks = "Busy size (bytes)" 
mallinfo.fordblks = "Free size (bytes)" 
mallinfo.ordblks = "Free blocks (count)" 
mallinfo.keepcost = "Top block size (bytes)" 
mallinfo.hblks = "Blocks mapped via mmap() (count)" 
mallinfo.hblkhd = "Bytes mapped via mmap() (bytes)"

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

mallinfo.smblks = "Fast bin blocks (count)"
mallinfo.fsmblks = "Fast bin bytes (bytes)"

И другое интересное значение возвращается "sbrk (0)"

Есть несколько возможностей.

Насколько точным он вам нужен? Вы можете получить полезные данные через cat / proc / $ {PID} / status | grep VmData .

Вы можете #define свой собственный malloc () , realloc () , calloc () , и функции free () , заключающие реальные функции в собственный счетчик. Здесь вы можете делать действительно интересные вещи с помощью __FILE__, __LINE__, & __func__, чтобы облегчить выявление утечек ядра в простых тестах. Но он будет инструментировать только ваш собственный код!

(Точно так же вы также можете переопределить методы по умолчанию , new и , оператор delete , варианты как с массивом, так и без массива , и оба выбрасывают варианты std :: bad_alloc и std :: nothrow_t. Опять же, это будет инструментально только для вашего собственного кода! )

(Имейте в виду: в большинстве систем C ++ new в конечном итоге вызывает malloc () . Это не обязательно. Особенно с in-place new ]! Но обычно new действительно использует malloc () (или работает с областью памяти, которая ранее была malloc () 'ed . ) В противном случае вы бы попали в действительно забавные вещи с несколькими менеджерами кучи ...)

Вы можете использовать sbrk (0) , чтобы увидеть, где в данный момент установлен сегмент данных. Это не так уж и здорово. Это очень грубое измерение, и оно не учитывает дыры (неиспользуемые области памяти) в куче. (Вам будет гораздо лучше со строкой VmData из / proc / $ {PID} / status .) Но если вы просто ищете общую идею ...

Вы можете перехватить malloc () / free () / etc , написав свою собственную разделяемую библиотеку и заставив свой процесс использовать ее вместо реальных версий через LD_PRELOAD . Вы можете использовать dlopen () / dlsym () для загрузки и вызова * реального * malloc () / free () / etc . Это прекрасно работает. Исходный код не изменяется, даже не перекомпилирован. Но помните о ситуациях повторного входа при кодировании этой библиотеки и о том, что ваш процесс сначала вызовет malloc () / calloc () / realloc () перед dlopen () / dlsym () может завершить загрузку реальных функций.

Вы можете проверить такие инструменты, как Valgrind , хотя на самом деле они больше нацелены на утечки памяти.

Опять же, возможно, mtrace () - это то, что вам нужно? Или __ malloc_hook ? Очень проприетарный (GNU) и нестандартный ... Но вы помечены как "Linux" ...

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

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

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

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

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

Если вы в Windows вы можете использовать GetProcessHeap () , HeapQueryInfo () для получения информации о куче процессов. Пример обхода кучи из MSDN

Поскольку вы пометили свой вопрос как «linux», вам может быть полезно просмотреть некоторую информацию, представленную в каталоге / proc . Я мало изучал это, поэтому могу дать вам только отправную точку.

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

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

Отправная точка о том, как интерпретировать содержимое этих файлов, доступна в proc (5) справочная страница.

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