Как я могу получить память одного процесса в Linux

Возможный дубликат:
Linux: как измерять фактическое использование памяти приложения или процесса?

Почему я использую «топ» в Linux, чтобы показать свою память об одном процессе, я понимаю, что хранение процесса только увеличивается и не уменьшается, за исключением того, что я закрываю весь процесс. Я не знаю, почему, хотя я использую «бесплатно» «только позади» malloc. Как я могу получить правильное фактическое хранилище REAL-TIME моего процесса? Спасибо всем.

Короткий ответ заключается в том, что в современной операционной системе это очень сложно.

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

На этот вопрос уже был дан более подробный ответ на другой stream SO. Вы можете найти свой ответ.

найдите pid, если он работает как один и тот же пользователь, используйте «ps aux», иначе используйте «ps ax», затем выполните следующее:

cat /proc//status 

это должно быть все, что вы хотите знать.

В зависимости от размера ваших распределений ваша память может быть возвращена или не возвращена ОС. Если вы выделяете большие вещи (см. MMAP_THRESHOLD в malloc(3) ), то, что занимает много страниц памяти, glibc будет использовать флаг MAP_ANONYMOUS mmap(2) для выделения; когда вы free(3) этот объект, glibc может вернуть страницу в ОС, а использование вашей памяти будет уменьшаться.

Вы можете настроить MMAP_THRESHOLD вниз, используя mallopt(3) если хотите.

Если у вас много меньших распределений, ваша память может быть fragmentирована настолько, что free(3) не может фактически освободить всю страницу, которая может быть возвращена ОС. Возможно, на данной странице относительно мало используется , но вся страница по-прежнему распределяется против вашего процесса и заменяет ценность данных всей страницы из других процессов.

Я не думаю, что этот другой вопрос действительно подробно объясняет это.

Добавляя к тому, что говорит sarnold , было бы полезно free() в обратном порядке как malloc() – особенно для меньших fragmentов памяти. Тогда куча может снова сжиматься с конца …

Чтобы убедиться в этом, вы должны в тестовой программе вызвать void *sbrk(intptr_t increment); с приращением 0 – тогда он сообщает вам текущее значение кучи – и выводит его, чтобы увидеть его изменения. Если вы сделаете это правильно и в правильном направлении, glib должен вызвать brk() чтобы увеличить кучу и в конечном итоге сжать ее снова.

Вы можете попробовать pmap и процесс id:

  1: init [3] 

001c3000 100K rx– /lib/ld-2.5.so

001dc000 4K rx– /lib/ld-2.5.so

001dd000 4K rwx– /lib/ld-2.5.so

001e0000 1256K rx– /lib/libc-2.5.so

0031a000 8K rx– /lib/libc-2.5.so

0031c000 4K rwx– /lib/libc-2.5.so

0031d000 12K rwx– [anon]

0034b000 8K rx– /lib/libdl-2.5.so

0034d000 4K rx– /lib/libdl-2.5.so

0034e000 4K rwx– /lib/libdl-2.5.so

006f2000 236K rx– /lib/libsepol.so.1

0072d000 4K rwx– /lib/libsepol.so.1

0072e000 40K rwx– [anon]

0073a000 84K rx– /lib/libselinux.so.1

0074f000 8K rwx– /lib/libselinux.so.1

00fff000 4K rx– [anon]

08048000 32K rx– / sbin / init

08050000 4K rw — / sbin / init

09c0f000 132K rw — [anon]

b7fed000 8K rw — [anon]

bfd87000 84K rw — [stack]

всего 2040K