Still reachable valgrind что значит

[SOLVED]valgrind: still reachable

Вопрос: это linux «лениво» освобождает память, или программист я чего-то не освободил?

Ответ: память теоретически может быть освобождена, но не освобождена. Т.е. программа не освобождает память, а оставляет это ос.

Нет кода – нет ответа.

it didn’t free some memory it could have

Программа не освободила память, которую могла иметь? Не понимаю.

Т.е. память была выделена, но не была освобождена? Т.е. проблема в коде, и какая-то память выделяется, но не освобождается?

Сформулирую иначе: возможно ли, что каждая выделенная в куче память освобождается в коде программы, но still reachable не нуль?

Если выделение памяти произошло в библиотеке, то возможно.

Сформулирую иначе: возможно ли, что каждая выделенная в куче память освобождается в коде программы, но still reachable не нуль?

Если выделение памяти произошло в библиотеке, то возможно.

Ясно. Возможно ли, что какая-то выделенная в коде программы память не освобождается в коде программы, но:

still reachable означает что указатель на память не утерян, память может быть теоритически освобождена, но она не освобождена.

P.S. это «типа норм» считается, например, PVS-Studio говорили что они только выделяют память, а освобождает сама система, после того как программа завершит анализ файла. Ещё Уолтер Брайт говорил, что в его dmd dlang compiler память только выделяется, а освободится системой, и это одна из фич, которая позволяет компилятору D быстрее собирать код, чем другим компиляторам…

still reachable означает что указатель на память не утерян, память может быть теоритически освобождена, но она не освобождена.

Источник

Что такое valgrind и зачем он нужен

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

Данная статья содержит краткое описание принципов работы с valgrind и использования различных его модулей. Данное описание соответствует valgrind версии 3.3. Дополнительную информацию о работе с valgrind вы можете найти на его сайте, который содержит руководства разного уровня сложности, начиная от достаточно легкого Quick Start, и заканчивая подробными руководством пользователя и техническим описанием системы.

Архитектура Valgrind

Valgrind имеет модульную архитектуру, и состоит из ядра, которое выполняет эмуляцию процессора, а конкретные модули выполняют сбор и анализ информации, полученной во время выполнения кода на эмуляторе. Valgrind работает под управлением ОС Linux на процессорах x86, amd64, ppc32 и ppc64 (стоит отметить, что ведуться работы по переносу Valgrind и на другие ОС), при этом существуют некоторые ограничения, которые потенциально могут повлиять на работу исследуемых программ. 1

В поставку valgrind входят следующие модули-анализаторы:

memcheck основной модуль, обеспечивающий обнаружение утечек памяти, и прочих ошибок, связанных с неправильной работой с областями памяти — чтением или записью за пределами выделенных регионов и т.п. cachegrind анализирует выполнение кода, собирая данные о (не)попаданиях в кэш, и точках перехода (когда процессор неправильно предсказывает ветвление). Эта статистика собирается для всей программы, отдельных функций и строк кода callgrind анализирует вызовы функций, используя примерно ту же методику, что и модуль cachegrind. Позволяет построить дерево вызовов функций, и соответственно, проанализировать узкие места в работе программы. massif позволяет проанализировать выделение памяти различными частями программы helgrind анализирует выполняемый код на наличие различных ошибок синхронизации, при использовании многопоточного кода, использующего POSIX Threads.

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

Начало работы с valgrind

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

Стоит отметить, что часто используемые опции можно задать один раз, используя глобальный файл конфигурации (

/.valgrindrc ), так что вам не придется их набирать при каждом запуске valgrind.

Общие опции запуска программы

Некоторые опции командной строки являются общими для всех модулей. К наиболее часто используемым опциям можно отнести 3 :

Опции управления обработкой ошибок

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

Поиск утечек памяти

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

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

Интерпретация полученных результатов

Существует несколько видов ошибок, обнаруживаемых модулем memcheck. Ошибки чтения и записи за пределами выделенной памяти (и еще несколько видов ошибок) выдаются сразу, в процессе работы программы. А ошибки, ведущие к утечкам памяти, выдаются valgrind’ом после завершения работы анализируемой программы. Формат выдачи этих ошибок немного отличается, поэтому они будут описаны по отдельности.

Каждая строка в выводе valgrind имеет префикс вида

где число обозначает идентификатор запущенного процесса.

Ошибки работы с памятью

В ходе своей работы, модуль memcheck определяет несколько видов ошибок работы с памятью:

Для этих ошибок данные выдаются по мере их обнаружения, и обычно они выглядят следующим образом:

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

Нахождение утечек памяти

При окончании работы программы valgrind выдает сводную таблицу, описывающую количество найденных ошибок, а также выделение памяти в программе, например:

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

Между двумя этими таблицами выдаются данные по каждой из найденных ошибок работы с памятью, вида:

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

Полезные советы при работе с memcheck

Профилирование программ

Профилирование программ может осуществляться с помощью двух модулей — callgrind и cachegrind. Каждый из них собирает разную информацию. При этом нельзя полагаться на результаты работы только одного из модулей, лучше проводить поиск «узких» мест в программах на основе анализа вывода каждого из модулей.

cachegrind

Результаты собранные данным модулем по умолчанию выводятся в файл с именем cachegrind.out.

После завершения программы, valgrind выдаст таблицу с суммарными данными, собранными во время выполнения программы, например:

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

callgrind

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

Данные собранные модулем выводятся в файл callgrind.out.

, который затем может быть проанализирован с помощью программ kcachegrind или callgrind_annotate (входящей в поставку valgrind).

По умолчанию, callgrind выводит информацию один раз, в конце выполнения программы. Но пользователи, которым это нужно, могут использовать программу callgrind_control из поставки valgrind для получения промежуточных данных по запросу, или периодически.

Анализ выделения памяти в программе

Для анализа выделения памяти в программах используется модуль massif. Он собирает сведения не только о размерах блоков, выделяемых программой, но также и о том, сколько дополнительной памяти потребуется для хранения служебной информации.

После завершения программы под управлением massif, valgrind выдает краткую сводку использования памяти, а подробные данные выводятся в файл massif.out.

Пользователь может использовать дополнительные опции massif для управления частотой снятия снапшотов, их количеством, списком функций, для которых будет производиться анализ (можно, например, отслеживать только new или malloc ) и т.п.

Поиск ошибок синхронизации

За поиск этого класса ошибок отвечает модуль helgrind. Он позволяет найти ошибки синхронизации в программах на языках C, C++ & Fortran, использующих POSIX Thread API. Helgrind помогает обнаружить следующие классы ошибок:

Helgrind позволяет найти эти ошибки за счет отслеживания состояния каждого из байтов памяти, используемой программой, а также за счет мониторинга различных событий, связанных с выполнением нитей (threads) — их создания и завершения, получение и освобождения блокировок и т.п.

Формат вывода информации немного похож на формат вывода ошибок модулем memcheck:

В данном примере helgrind указывает на возможное повреждение данных при одновременном выводе данных на экран несколькими нитями исполнения. Кроме стека вызова функций, приводящего к ошибке, также выдается состояние памяти до и после возникновения ошибки (old и new state), а также причина возникновения ошибки (в нашем случае — отсутствие блокировок для данного участка памяти).

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

Дополнительные программы для работы с valgrind

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

1. Хорошее описание архитектуры Valgrind и принципов его работы можно найти в статье Valgrind: A Framework for Heavyweight Dynamic Binary Instrumentation

2. Интересующиеся, могут найти описание процесса сборки и установки в руководстве пользователя valgrind.

4. В руководстве пользователя valgrind есть описание формата данных, выводимых модулем cachegrind, так что пользователь может писать и свои анализаторы.

Источник

Still Reachable Leak detected by Valgrind

All the functions mentioned in this block are library functions. How can I rectify this memory leak?

It is listed under the «Still reachable» category. (There are 4 more, which are very similar, but of varying sizes)

Catch: Once I ran my program, it gave no memory leaks, but it had one additional line in the Valgrind output, which wasn’t present before:

Discarding syms at 0x5296fa0-0x52af438 in /lib/libgcc_s-4.4.4-20100630.so.1 due to munmap()

If the leak can’t be rectified, can someone atleast explain why the munmap() line causes Valgrind to report 0 «still reachable» leaks?

Edit:

Here’s a minimal test sample:

5 Answers 5

There is more than one way to define «memory leak». In particular, there are two primary definitions of «memory leak» that are in common usage among programmers.

The first commonly used definition of «memory leak» is, «Memory was allocated and was not subsequently freed before the program terminated.» However, many programmers (rightly) argue that certain types of memory leaks that fit this definition don’t actually pose any sort of problem, and therefore should not be considered true «memory leaks».

An arguably stricter (and more useful) definition of «memory leak» is, «Memory was allocated and cannot be subsequently freed because the program no longer has any pointers to the allocated memory block.» In other words, you cannot free memory that you no longer have any pointers to. Such memory is therefore a «memory leak». Valgrind uses this stricter definition of the term «memory leak». This is the type of leak which can potentially cause significant heap depletion, especially for long lived processes.

The «still reachable» category within Valgrind’s leak report refers to allocations that fit only the first definition of «memory leak». These blocks were not freed, but they could have been freed (if the programmer had wanted to) because the program still was keeping track of pointers to those memory blocks.

In general, there is no need to worry about «still reachable» blocks. They don’t pose the sort of problem that true memory leaks can cause. For instance, there is normally no potential for heap exhaustion from «still reachable» blocks. This is because these blocks are usually one-time allocations, references to which are kept throughout the duration of the process’s lifetime. While you could go through and ensure that your program frees all allocated memory, there is usually no practical benefit from doing so since the operating system will reclaim all of the process’s memory after the process terminates, anyway. Contrast this with true memory leaks which, if left unfixed, could cause a process to run out of memory if left running long enough, or will simply cause a process to consume far more memory than is necessary.

Probably the only time it is useful to ensure that all allocations have matching «frees» is if your leak detection tools cannot tell which blocks are «still reachable» (but Valgrind can do this) or if your operating system doesn’t reclaim all of a terminating process’s memory (all platforms which Valgrind has been ported to do this).

Источник

Valgrind Frequently Asked Questions

1. Background

Don’t feel bad: almost everyone gets it wrong at first.

From Nordic mythology. Originally (before release) the project was named Heimdall, after the watchman of the Nordic gods. He could «see a hundred miles by day or night, hear the grass growing, see the wool growing on a sheep’s back», etc. This would have been a great name, but it was already taken by a security package «Heimdal».

Keeping with the Nordic theme, Valgrind was chosen. Valgrind is the name of the main entrance to Valhalla (the Hall of the Chosen Slain in Asgard). Over this entrance there resides a wolf and over it there is the head of a boar and on it perches a huge eagle, whose eyes can see to the far regions of the nine worlds. Only those judged worthy by the guardians are allowed to pass through Valgrind. All others are refused entrance.

It’s not short for «value grinder», although that’s not a bad guess.

2. Compiling, installing and configuring

2.1. When building Valgrind, ‘make’ dies partway with an assertion failure, something like this:
2.2. When building Valgrind, ‘make’ fails with this:2.1.When building Valgrind, ‘make’ dies partway with an assertion failure, something like this:

It’s probably a bug in ‘make’. Some, but not all, instances of version 3.79.1 have this bug, see this. Try upgrading to a more recent version of ‘make’. Alternatively, we have heard that unsetting the CFLAGS environment variable avoids the problem.

You need to install the glibc-static-devel package.

3. Valgrind aborts unexpectedly

3.1. Programs run OK on Valgrind, but at exit produce a bunch of errors involving __libc_freeres and then die with a segmentation fault.
3.2. My (buggy) program dies like this:
3.3. My program dies, printing a message like this along the way:
3.4. I tried running a Java program (or another program that uses a just-in-time compiler) under Valgrind but something went wrong. Does Valgrind handle such programs?3.1.Programs run OK on Valgrind, but at exit produce a bunch of errors involving __libc_freeres and then die with a segmentation fault.

When the program exits, Valgrind runs the procedure __libc_freeres in glibc. This is a hook for memory debuggers, so they can ask glibc to free up any memory it has used. Doing that is needed to ensure that Valgrind doesn’t incorrectly report space leaks in glibc.

The problem is that running __libc_freeres in older glibc versions causes this crash.

3.2.My (buggy) program dies like this: or like this: or otherwise aborts or crashes in m_mallocfree.c.

If Memcheck (the memory checker) shows any invalid reads, invalid writes or invalid frees in your program, the above may happen. Reason is that your program may trash Valgrind’s low-level memory manager, which then dies with the above assertion, or something similar. The cure is to fix your program so that it doesn’t do any illegal memory accesses. The above failure will hopefully go away after that.

One possibility is that your program has a bug and erroneously jumps to a non-code address, in which case you’ll get a SIGILL signal. Memcheck may issue a warning just before this happens, but it might not if the jump happens to land in addressable memory.

Another possibility is that Valgrind does not handle the instruction. If you are using an older Valgrind, a newer version might handle the instruction. However, all instruction sets have some obscure, rarely used instructions. Also, on amd64 there are an almost limitless number of combinations of redundant instruction prefixes, many of them undocumented but accepted by CPUs. So Valgrind will still have decoding failures from time to time. If this happens, please file a bug report.

3.4.I tried running a Java program (or another program that uses a just-in-time compiler) under Valgrind but something went wrong. Does Valgrind handle such programs?

Apart from this, in theory Valgrind can run any Java program just fine, even those that use JNI and are partially implemented in other languages like C and C++. In practice, Java implementations tend to do nasty things that most programs do not, and Valgrind sometimes falls over these corner cases.

4. Valgrind behaves unexpectedly

4.1. My program uses the C++ STL and string classes. Valgrind reports ‘still reachable’ memory leaks involving these classes at the exit of the program, but there should be none.
4.2. The stack traces given by Memcheck (or another tool) aren’t helpful. How can I improve them?
4.3. The stack traces given by Memcheck (or another tool) seem to have the wrong function name in them. What’s happening?
4.4. My program crashes normally, but doesn’t under Valgrind, or vice versa. What’s happening?
4.5. Memcheck doesn’t report any errors and I know my program has errors.
4.6. Why doesn’t Memcheck find the array overruns in this program?4.1.My program uses the C++ STL and string classes. Valgrind reports ‘still reachable’ memory leaks involving these classes at the exit of the program, but there should be none.

First of all: relax, it’s probably not a bug, but a feature. Many implementations of the C++ standard libraries use their own memory pool allocators. Memory for quite a number of destructed objects is not immediately freed and given back to the OS, but kept in the pool(s) for later re-use. The fact that the pools are not freed at the exit of the program cause Valgrind to report this memory as still reachable. The behaviour not to free pools at the exit could be called a bug of the library though.

Using GCC, you can force the STL to use malloc and to free memory as soon as possible by globally disabling memory caching. Beware! Doing so will probably slow down your program, sometimes drastically.

With GCC 3.2.2 and later, you should export the environment variable GLIBCPP_FORCE_NEW before running your program.

There are other ways to disable memory pooling: using the malloc_alloc template with your objects (not portable, but should work for GCC) or even writing your own memory allocators. But all this goes beyond the scope of this FAQ. Start by reading http://gcc.gnu.org/onlinedocs/libstdc++/faq/index.html#4_4_leak if you absolutely want to do that. But beware: allocators belong to the more messy parts of the STL and people went to great lengths to make the STL portable across platforms. Chances are good that your solution will work on your platform, but not on others.

4.2.The stack traces given by Memcheck (or another tool) aren’t helpful. How can I improve them?

Some example sub-traces:

With debug information and unstripped (best):

With no debug information, unstripped:

With no debug information, stripped:

A leak error message involving an unloaded shared object:

4.3.The stack traces given by Memcheck (or another tool) seem to have the wrong function name in them. What’s happening?4.4.My program crashes normally, but doesn’t under Valgrind, or vice versa. What’s happening?

When a program runs under Valgrind, its environment is slightly different to when it runs natively. For example, the memory layout is different, and the way that threads are scheduled is different.

Most of the time this doesn’t make any difference, but it can, particularly if your program is buggy. For example, if your program crashes because it erroneously accesses memory that is unaddressable, it’s possible that this memory will not be unaddressable when run under Valgrind. Alternatively, if your program has data races, these may not manifest under Valgrind.

There isn’t anything you can do to change this, it’s just the nature of the way Valgrind works that it cannot exactly replicate a native execution environment. In the case where your program crashes due to a memory error when run natively but not when run under Valgrind, in most cases Memcheck should identify the bad memory operation.

4.5. Memcheck doesn’t report any errors and I know my program has errors.

There are two possible causes of this.

First, by default, Valgrind only traces the top-level process. So if your program spawns children, they won’t be traced by Valgrind by default. Also, if your program is started by a shell script, Perl script, or something similar, Valgrind will trace the shell, or the Perl interpreter, or equivalent.

Obviously you have to start the listener process first. See the manual for more details.

Unfortunately, Memcheck doesn’t do bounds checking on global or stack arrays. We’d like to, but it’s just not possible to do in a reasonable way that fits with how Memcheck works. Sorry.

5. Miscellaneous

5.1. I tried writing a suppression but it didn’t work. Can you write my suppression for me?
5.2. With Memcheck’s memory leak detector, what’s the difference between «definitely lost», «indirectly lost», «possibly lost», «still reachable», and «suppressed»?
5.3. Memcheck’s uninitialised value errors are hard to track down, because they are often reported some time after they are caused. Could Memcheck record a trail of operations to better link the cause to the effect? Or maybe just eagerly report any copies of uninitialised memory values?
5.4. Is it possible to attach Valgrind to a program that is already running?5.1.I tried writing a suppression but it didn’t work. Can you write my suppression for me?

If you really want to write suppressions by hand, read the manual carefully. Note particularly that C++ function names must be mangled (that is, not demangled).

5.2.With Memcheck’s memory leak detector, what’s the difference between «definitely lost», «indirectly lost», «possibly lost», «still reachable», and «suppressed»?

The details are in the Memcheck section of the user manual.

«indirectly lost» means your program is leaking memory in a pointer-based structure. (E.g. if the root node of a binary tree is «definitely lost», all the children will be «indirectly lost».) If you fix the «definitely lost» leaks, the «indirectly lost» leaks should go away.

«suppressed» means that a leak error has been suppressed. There are some suppressions in the default suppression files. You can ignore suppressed errors.

5.3.Memcheck’s uninitialised value errors are hard to track down, because they are often reported some time after they are caused. Could Memcheck record a trail of operations to better link the cause to the effect? Or maybe just eagerly report any copies of uninitialised memory values?

As for eager reporting of copies of uninitialised memory values, this has been suggested multiple times. Unfortunately, almost all programs legitimately copy uninitialised memory values around (because compilers pad structs to preserve alignment) and eager checking leads to hundreds of false positives. Therefore Memcheck does not support eager checking at this time.

5.4.Is it possible to attach Valgrind to a program that is already running?

No. The environment that Valgrind provides for running programs is significantly different to that for normal programs, e.g. due to different layout of memory. Therefore Valgrind has to have full control from the very start.

It is possible to achieve something like this by running your program without any instrumentation (which involves a slow-down of about 5x, less than that of most tools), and then adding instrumentation once you get to a point of interest. Support for this must be provided by the tool, however, and Callgrind is the only tool that currently has such support. See the instructions on the callgrind_control program for details.

6. How To Get Further Assistance

Read the appropriate section(s) of the Valgrind Documentation.

If you think an answer in this FAQ is incomplete or inaccurate, please e-mail valgrind@valgrind.org.

If you have tried all of these things and are still stuck, you can try mailing the valgrind-users mailing list. Note that an email has a better change of being answered usefully if it is clearly written. Also remember that, despite the fact that most of the community are very helpful and responsive to emailed questions, you are probably requesting help from unpaid volunteers, so you have no guarantee of receiving an answer.

Источник