Как установить valgrind на windows

Valgrind is a famous tool to debug your memory leak, but what sad is it only supports Linux, yeah, not a perfect support even on Mac. But with the new Windows 10 Anniversary update, it’s happening. And works way much better than Mac with OS X. Let’s rock!

1. What, Linux in a Windows?

It is easy since in the new update, windows has Ubuntu as a subsystem. And it is neither a virtual machine nor some kind of a container. It is a subsystem, roughly speaking, all the functions will finally invoked by Windows sys-call. So this is a 1st class, blazing fast solution. But the prerequisite is you need a new Windows 10 version 1607 (Build 14393.187) or above.

2. How to install and use it?

When you search online, you will find that you need to join the Windows Insider program and open the developer mode. But no, you don’t need to.

1. press win+s to open Cortana.
2. search for windows features, open Turn Windows features On or Off.
3. find Windows Subsystem for Linux (Beta), click to turn it on.
4. After a restart you could now open your windows command line and input bash, then enter.
5. It will first download and install Ubuntu 14.04 from Windows store.
6. Then you need to configure your default user and password to the system. This is just for this built-in Ubuntu, not Windows
7. Afterwards, every time you need bash, you just open CLI then bash and enter, splendid!

3. Try it first time.

It is a Ubuntu, so you might simply use the command. sudo apt-get install valgrind. Yes, it will work as a charm. But only for this part. If you want to use it, it will totally not work.

1
2
3
4
5
6

--1791:0:aspacem   -1: ANON 0038000000-00383d5fff 4022272 r-x-- SmFixed d=0x000 i=205168  o=0       (0) m=0 /usr/lib/valgrind/memcheck-amd64-linux
--1791:0:aspacem  Valgrind: FATAL: aspacem assertion failed:
--1791:0:aspacem    segment_is_sane
--1791:0:aspacem    at m_aspacemgr/aspacemgr-linux.c:1502 (add_segment)
--1791:0:aspacem  Exiting now.

You may abort at this stage, since it is a beta feature, and the translation in the Sys-call level may seems a big deal. And after googling, you decide to abort. But, the story never ends like this

4.How to deal with it?

A brief first:

You just need to compile Valgrind by yourself on your own machine.”

The idea is simple, the procedures is still easy but take a little bit longer than expected. But I will cover all the commands

1. Open bash in Windows.
2. Update your Ubuntu package lists by sudo apt-get update
3. Install SVN first via this command: sudo apt-get install svn
4. Install subversion next: sudo apt-get install subversion (Thanks to Ran Lottem)
5. Find a folder you want to put the valgrind, anywhere is OK, we just need to compile.
6. Download source code of Valgrind via SVN svn co svn://svn.valgrind.org/valgrind/trunk valgrind. It will download the codes and put them into a new folder called valgrind right under then folder you create or locate in step 3.
7. Install the library used when compiling by sudo apt-get install automake
8. Ran Lottem confirmed that you need to sudo apt-get install build-essential
9. Go to the folder of Valgrind via cd valgrind/
10. Running the official bash script first by using ./autogen.sh
11. Configure via ./configure.
12. From now on, things will get much more normal. first, install make via sudo apt-get install make.
13. Then make, this command will build the files from many modules. Add sudo if failed (Thanks Waleed Mahmoud).
14. make install, it will copy compiled files into appropriate locations. Add sudo if failed (Thanks Waleed Mahmoud).
15. It’s done already, but feel free to use make clean, it will delete all the temporary files generated while compiling.
16. A make distclean will make things much better.
17. Use valgrind as you wish.

5.Happily ever after

I have built a linked list to test the leak, it works exactly the same way as linux, even better than Mac, OS X, yes, I mean it. The valgrind on OS X will tell you have some leak problems while there is no leak.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

camus@ALBERTSURFACEB:/mnt/d/github/C_Playground$ valgrind ./main
==2529== Memcheck, a memory error detector
==2529== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==2529== Using Valgrind-3.12.0.SVN and LibVEX; rerun with -h for copyright info
==2529== Command: ./main
==2529==

3.00
4.00
5.00

4.00
5.00

5.00

==2529==
==2529== HEAP SUMMARY:
==2529==     in use at exit: 0 bytes in 0 blocks
==2529==   total heap usage: 6 allocs, 6 frees, 104 bytes allocated
==2529==
==2529== All heap blocks were freed -- no leaks are possible
==2529==
==2529== For counts of detected and suppressed errors, rerun with: -v
==2529== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
camus@ALBERTSURFACEB:/mnt/d/github/C_Playground$

And if you have a leak, it will tell you.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

==2539== HEAP SUMMARY:
==2539==     in use at exit: 80 bytes in 5 blocks
==2539==   total heap usage: 6 allocs, 1 frees, 104 bytes allocated
==2539==
==2539== LEAK SUMMARY:
==2539==    definitely lost: 16 bytes in 1 blocks
==2539==    indirectly lost: 64 bytes in 4 blocks
==2539==      possibly lost: 0 bytes in 0 blocks
==2539==    still reachable: 0 bytes in 0 blocks
==2539==         suppressed: 0 bytes in 0 blocks
==2539== Rerun with --leak-check=full to see details of leaked memory
==2539==
==2539== For counts of detected and suppressed errors, rerun with: -v
==2539== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Furthermore, running valgrind --leak-check=full ./main will give the information of your stack. WOW! Fantastic! After I suffered so much from day 1 for the stupid Surface Book, this is the only time I feel Microsoft is a company you could rely on, haha xD

6. One more thing

Mr Artem reached out to me recently about his awesome software for debugging memory issues. He built Deleaker, which is a modern substitution of
Valgrind. Deleaker supports C as well as C++/Delphi/.Net etc. In general, it doesn’t matter what language is used to write code as it works at lower level, hooking allocation/deallocation functions and storing call stacks.

And having a nice GUI to work with just seems much more efficient to me, which is why I love jetBrains’ products.

• Check this blog for a comparison between Deleaker and Valgrind, why it is better.
• Check the Deleaker official site for more information.

Thanks for reading!

Follow me (albertgao) on twitter, if you want to hear more about my interesting ideas.

Valgrind is a famous tool to debug your memory leak, but what sad is it only supports Linux, yeah, not a perfect support even on Mac. But with the new Windows 10 Anniversary update, it’s happening. And works way much better than Mac with OS X. Let’s rock!

1. What, Linux in a Windows?

It is easy since in the new update, windows has Ubuntu as a subsystem. And it is neither a virtual machine nor some kind of a container. It is a subsystem, roughly speaking, all the functions will finally invoked by Windows sys-call. So this is a 1st class, blazing fast solution. But the prerequisite is you need a new Windows 10 version 1607 (Build 14393.187) or above.

2. How to install and use it?

When you search online, you will find that you need to join the Windows Insider program and open the developer mode. But no, you don’t need to.

1. press win+s to open Cortana.
2. search for windows features, open Turn Windows features On or Off.
3. find Windows Subsystem for Linux (Beta), click to turn it on.
4. After a restart you could now open your windows command line and input bash, then enter.
5. It will first download and install Ubuntu 14.04 from Windows store.
6. Then you need to configure your default user and password to the system. This is just for this built-in Ubuntu, not Windows
7. Afterwards, every time you need bash, you just open CLI then bash and enter, splendid!

3. Try it first time.

It is a Ubuntu, so you might simply use the command. sudo apt-get install valgrind. Yes, it will work as a charm. But only for this part. If you want to use it, it will totally not work.

1
2
3
4
5
6

--1791:0:aspacem   -1: ANON 0038000000-00383d5fff 4022272 r-x-- SmFixed d=0x000 i=205168  o=0       (0) m=0 /usr/lib/valgrind/memcheck-amd64-linux
--1791:0:aspacem  Valgrind: FATAL: aspacem assertion failed:
--1791:0:aspacem    segment_is_sane
--1791:0:aspacem    at m_aspacemgr/aspacemgr-linux.c:1502 (add_segment)
--1791:0:aspacem  Exiting now.

You may abort at this stage, since it is a beta feature, and the translation in the Sys-call level may seems a big deal. And after googling, you decide to abort. But, the story never ends like this

4.How to deal with it?

A brief first:

You just need to compile Valgrind by yourself on your own machine.”

The idea is simple, the procedures is still easy but take a little bit longer than expected. But I will cover all the commands

1. Open bash in Windows.
2. Update your Ubuntu package lists by sudo apt-get update
3. Install SVN first via this command: sudo apt-get install svn
4. Install subversion next: sudo apt-get install subversion (Thanks to Ran Lottem)
5. Find a folder you want to put the valgrind, anywhere is OK, we just need to compile.
6. Download source code of Valgrind via SVN svn co svn://svn.valgrind.org/valgrind/trunk valgrind. It will download the codes and put them into a new folder called valgrind right under then folder you create or locate in step 3.
7. Install the library used when compiling by sudo apt-get install automake
8. Ran Lottem confirmed that you need to sudo apt-get install build-essential
9. Go to the folder of Valgrind via cd valgrind/
10. Running the official bash script first by using ./autogen.sh
11. Configure via ./configure.
12. From now on, things will get much more normal. first, install make via sudo apt-get install make.
13. Then make, this command will build the files from many modules. Add sudo if failed (Thanks Waleed Mahmoud).
14. make install, it will copy compiled files into appropriate locations. Add sudo if failed (Thanks Waleed Mahmoud).
15. It’s done already, but feel free to use make clean, it will delete all the temporary files generated while compiling.
16. A make distclean will make things much better.
17. Use valgrind as you wish.

5.Happily ever after

I have built a linked list to test the leak, it works exactly the same way as linux, even better than Mac, OS X, yes, I mean it. The valgrind on OS X will tell you have some leak problems while there is no leak.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

camus@ALBERTSURFACEB:/mnt/d/github/C_Playground$ valgrind ./main
==2529== Memcheck, a memory error detector
==2529== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==2529== Using Valgrind-3.12.0.SVN and LibVEX; rerun with -h for copyright info
==2529== Command: ./main
==2529==

3.00
4.00
5.00

4.00
5.00

5.00

==2529==
==2529== HEAP SUMMARY:
==2529==     in use at exit: 0 bytes in 0 blocks
==2529==   total heap usage: 6 allocs, 6 frees, 104 bytes allocated
==2529==
==2529== All heap blocks were freed -- no leaks are possible
==2529==
==2529== For counts of detected and suppressed errors, rerun with: -v
==2529== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
camus@ALBERTSURFACEB:/mnt/d/github/C_Playground$

And if you have a leak, it will tell you.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

==2539== HEAP SUMMARY:
==2539==     in use at exit: 80 bytes in 5 blocks
==2539==   total heap usage: 6 allocs, 1 frees, 104 bytes allocated
==2539==
==2539== LEAK SUMMARY:
==2539==    definitely lost: 16 bytes in 1 blocks
==2539==    indirectly lost: 64 bytes in 4 blocks
==2539==      possibly lost: 0 bytes in 0 blocks
==2539==    still reachable: 0 bytes in 0 blocks
==2539==         suppressed: 0 bytes in 0 blocks
==2539== Rerun with --leak-check=full to see details of leaked memory
==2539==
==2539== For counts of detected and suppressed errors, rerun with: -v
==2539== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Furthermore, running valgrind --leak-check=full ./main will give the information of your stack. WOW! Fantastic! After I suffered so much from day 1 for the stupid Surface Book, this is the only time I feel Microsoft is a company you could rely on, haha xD

6. One more thing

Mr Artem reached out to me recently about his awesome software for debugging memory issues. He built Deleaker, which is a modern substitution of
Valgrind. Deleaker supports C as well as C++/Delphi/.Net etc. In general, it doesn’t matter what language is used to write code as it works at lower level, hooking allocation/deallocation functions and storing call stacks.

And having a nice GUI to work with just seems much more efficient to me, which is why I love jetBrains’ products.

• Check this blog for a comparison between Deleaker and Valgrind, why it is better.
• Check the Deleaker official site for more information.

Thanks for reading!

Follow me (albertgao) on twitter, if you want to hear more about my interesting ideas.

������Basic�Installation
==================

���These�are�generic�installation�instructions.

���The�`configure’�shell�script�attempts�to�guess�correct�values�for
various�system-dependent�variables�used�during�compilation.��It�uses
those�values�to�create�a�`Makefile’�in�each�directory�of�the�package.
It�may�also�create�one�or�more�`.h’�files�containing�system-dependent
definitions.��Finally,�it�creates�a�shell�script�`config.status’�that
you�can�run�in�the�future�to�recreate�the�current�configuration,�a�file
`config.cache’�that�saves�the�results�of�its�tests�to�speed�up
reconfiguring,�and�a�file�`config.log’�containing�compiler�output
(useful�mainly�for�debugging�`configure’).

���If�you�need�to�do�unusual�things�to�compile�the�package,�please�try
to�figure�out�how�`configure’�could�check�whether�to�do�them,�and�mail
diffs�or�instructions�to�the�address�given�in�the�`README’�so�they�can
be�considered�for�the�next�release.��If�at�some�point�`config.cache’
contains�results�you�don’t�want�to�keep,�you�may�remove�or�edit�it.

���The�file�`configure.in’�is�used�to�create�`configure’�by�a�program
called�`autoconf’.��You�only�need�`configure.in’�if�you�want�to�change
it�or�regenerate�`configure’�using�a�newer�version�of�`autoconf’.

The�simplest�way�to�compile�this�package�is:

��1.�`cd’�to�the�directory�containing�the�package’s�source�code�and�type
�����`./configure’�to�configure�the�package�for�your�system.��If�you’re
�����using�`csh’�on�an�old�version�of�System�V,�you�might�need�to�type
�����`sh�./configure’�instead�to�prevent�`csh’�from�trying�to�execute
�����`configure’�itself.

�����Running�`configure’�takes�awhile.��While�running,�it�prints�some
�����messages�telling�which�features�it�is�checking�for.

��2.�Type�`make’�to�compile�the�package.

��3.�Optionally,�type�`make�check’�to�run�any�self-tests�that�come�with
�����the�package.

��4.�Type�`make�install’�to�install�the�programs�and�any�data�files�and
�����documentation.

��5.�You�can�remove�the�program�binaries�and�object�files�from�the
�����source�code�directory�by�typing�`make�clean’.��To�also�remove�the
�����files�that�`configure’�created�(so�you�can�compile�the�package�for
�����a�different�kind�of�computer),�type�`make�distclean’.��There�is
�����also�a�`make�maintainer-clean’�target,�but�that�is�intended�mainly
�����for�the�package’s�developers.��If�you�use�it,�you�may�have�to�get
�����all�sorts�of�other�programs�in�order�to�regenerate�files�that�came
�����with�the�distribution.

Compilers�and�Options
=====================

���Some�systems�require�unusual�options�for�compilation�or�linking�that
the�`configure’�script�does�not�know�about.��You�can�give�`configure’
initial�values�for�variables�by�setting�them�in�the�environment.��Using
a�Bourne-compatible�shell,�you�can�do�that�on�the�command�line�like
this:
�����CC=c89�CFLAGS=-O2�LIBS=-lposix�./configure

Or�on�systems�that�have�the�`env’�program,�you�can�do�it�like�this:
�����env�CPPFLAGS=-I/usr/local/include�LDFLAGS=-s�./configure

Compiling�For�Multiple�Architectures
====================================

���You�can�compile�the�package�for�more�than�one�kind�of�computer�at�the
same�time,�by�placing�the�object�files�for�each�architecture�in�their
own�directory.��To�do�this,�you�must�use�a�version�of�`make’�that
supports�the�`VPATH’�variable,�such�as�GNU�`make’.��`cd’�to�the
directory�where�you�want�the�object�files�and�executables�to�go�and�run
the�`configure’�script.��`configure’�automatically�checks�for�the
source�code�in�the�directory�that�`configure’�is�in�and�in�`..’.

���If�you�have�to�use�a�`make’�that�does�not�supports�the�`VPATH’
variable,�you�have�to�compile�the�package�for�one�architecture�at�a�time
in�the�source�code�directory.��After�you�have�installed�the�package�for
one�architecture,�use�`make�distclean’�before�reconfiguring�for�another
architecture.

Installation�Names
==================

���By�default,�`make�install’�will�install�the�package’s�files�in
`/usr/local/bin’,�`/usr/local/man’,�etc.��You�can�specify�an
installation�prefix�other�than�`/usr/local’�by�giving�`configure’�the
option�`—prefix=PATH’.

���You�can�specify�separate�installation�prefixes�for
architecture-specific�files�and�architecture-independent�files.��If�you
give�`configure’�the�option�`—exec-prefix=PATH’,�the�package�will�use
PATH�as�the�prefix�for�installing�programs�and�libraries.
Documentation�and�other�data�files�will�still�use�the�regular�prefix.

���In�addition,�if�you�use�an�unusual�directory�layout�you�can�give
options�like�`—bindir=PATH’�to�specify�different�values�for�particular
kinds�of�files.��Run�`configure�—help’�for�a�list�of�the�directories
you�can�set�and�what�kinds�of�files�go�in�them.

���If�the�package�supports�it,�you�can�cause�programs�to�be�installed
with�an�extra�prefix�or�suffix�on�their�names�by�giving�`configure’�the
option�`—program-prefix=PREFIX’�or�`—program-suffix=SUFFIX’.

Optional�Features
=================

���Some�packages�pay�attention�to�`—enable-FEATURE’�options�to
`configure’,�where�FEATURE�indicates�an�optional�part�of�the�package.
They�may�also�pay�attention�to�`—with-PACKAGE’�options,�where�PACKAGE
is�something�like�`gnu-as’�or�`x’�(for�the�X�Window�System).��The
`README’�should�mention�any�`—enable-‘�and�`—with-‘�options�that�the
package�recognizes.

���For�packages�that�use�the�X�Window�System,�`configure’�can�usually
find�the�X�include�and�library�files�automatically,�but�if�it�doesn’t,
you�can�use�the�`configure’�options�`—x-includes=DIR’�and
`—x-libraries=DIR’�to�specify�their�locations.

Specifying�the�System�Type
==========================

���There�may�be�some�features�`configure’�can�not�figure�out
automatically,�but�needs�to�determine�by�the�type�of�host�the�package
will�run�on.��Usually�`configure’�can�figure�that�out,�but�if�it�prints
a�message�saying�it�can�not�guess�the�host�type,�give�it�the
`—host=TYPE’�option.��TYPE�can�either�be�a�short�name�for�the�system
type,�such�as�`sun4′,�or�a�canonical�name�with�three�fields:
�����CPU-COMPANY-SYSTEM

See�the�file�`config.sub’�for�the�possible�values�of�each�field.��If
`config.sub’�isn’t�included�in�this�package,�then�this�package�doesn’t
need�to�know�the�host�type.

���If�you�are�building�compiler�tools�for�cross-compiling,�you�can�also
use�the�`—target=TYPE’�option�to�select�the�type�of�system�they�will
produce�code�for�and�the�`—build=TYPE’�option�to�select�the�type�of
system�on�which�you�are�compiling�the�package.

Sharing�Defaults
================

���If�you�want�to�set�default�values�for�`configure’�scripts�to�share,
you�can�create�a�site�shell�script�called�`config.site’�that�gives
default�values�for�variables�like�`CC’,�`cache_file’,�and�`prefix’.
`configure’�looks�for�`PREFIX/share/config.site’�if�it�exists,�then
`PREFIX/etc/config.site’�if�it�exists.��Or,�you�can�set�the
`CONFIG_SITE’�environment�variable�to�the�location�of�the�site�script.
A�warning:�not�all�`configure’�scripts�look�for�a�site�script.

Operation�Controls
==================

���`configure’�recognizes�the�following�options�to�control�how�it
operates.

`—cache-file=FILE’
�����Use�and�save�the�results�of�the�tests�in�FILE�instead�of
�����`./config.cache’.��Set�FILE�to�`/dev/null’�to�disable�caching,�for
�����debugging�`configure’.

`—help’
�����Print�a�summary�of�the�options�to�`configure’,�and�exit.

`—quiet’
`—silent’
`-q’
�����Do�not�print�messages�saying�which�checks�are�being�made.��To
�����suppress�all�normal�output,�redirect�it�to�`/dev/null’�(any�error
�����messages�will�still�be�shown).

`—srcdir=DIR’
�����Look�for�the�package’s�source�code�in�directory�DIR.��Usually
�����`configure’�can�determine�that�directory�automatically.

`—version’
�����Print�the�version�of�Autoconf�used�to�generate�the�`configure’
�����script,�and�exit.

`configure’�also�accepts�some�other,�not�widely�useful,�options.

����

Valgrind является многоцелевым инструментом профилирования кода и отладки памяти для Linux на x86, и, начиная с версии 3 и AMD64. Это позволяет запускать программу в собственной среде Valgrind, что контролирует использование памяти, например, вызовы malloc и free (или new и delete в C++). Если вы используете неинициализированную память, записываете за пределами концов массива, или не освобождаете указатель, Valgrind может это обнаружить. Поскольку это наиболее распространенные проблемы, эта статья будет сосредоточена главным образом на использовании Valgrind для обнаружения простых проблем с памятью, хотя Valgrind — это инструмент, который может сделать гораздо больше.

Для пользователей Windows: если вы не имеете доступа к Linux, или если вы хотите разрабатывать специальное программное обеспечение Windows, вас может заинтересовать IBM Purify, которая имеет аналогичные Valgrind функции для поиска утечек и неправильного доступа к памяти. Доступна пробная версия.

Получение Valgrind

Если вы работаете в Linux и у вас пока нет копии, то вы можете получить Valgrind на странице загрузки Valgrind.

Установка проста: распакуйте архив используя команды bzip2 и tar (X.Y.Z — номер версии в примерах ниже, разделённые символами точки):

bzip2 -d valgrind-X.Y.Z.tar.bz2
tar -xf valgrind-X.Y.Z.tar

После выполнения этих команд, будет создан каталог с именем valgrind-X.Y.Z, зайдите в этот каталог (команда cd и через пробел путь) и выполните следующие команды:

./configure
make
make install

Теперь, когда вы установили Valgrind, давайте посмотрим как его использовать.

Поиск утечек памяти с помощью Valgrind

Утечки памяти одни из самых трудных для обнаружения ошибок, потому что они не вызывают никаких внешних проблем, до тех пор, пока у вас не закончится память и вам не удастся вызвать malloc. В самом деле, при работе с языками C или C++, которые не имеют сборки мусора, почти половину времени вы можете потратить на правильное освобождение памяти. И даже одна ошибка может дорого обойтись, если ваша программа работает достаточно долго и следует этой ветви кода.

Когда вы запустите код, вы должны будете указать инструмент, который хотите использовать, просто запустите Valgrind для получения текущего списка. В этой статье мы сосредоточимся в основном на инструменте Memcheck, так как Valgrind с инструментом Memcheck позволит нам проверить правильность использования памяти. Без дополнительных аргументов, Valgrind выведет обзор вызовов free и malloc:

valgrind —tool=memcheck myProg

myProg — это имя программы (объектный файл, который получается после процесса построения проекта — компиляции). Если в проекте нет утечки памяти, вывод будет похож на этот

==15916== HEAP SUMMARY:
==15916== in use at exit: 16 bytes in 1 blocks
==15916== total heap usage: 5 allocs, 4 frees, 80 bytes allocated
==15916==
==15916== LEAK SUMMARY:
==15916== definitely lost: 16 bytes in 1 blocks
==15916== indirectly lost: 0 bytes in 0 blocks
==15916== possibly lost: 0 bytes in 0 blocks
==15916== still reachable: 0 bytes in 0 blocks
==15916== suppressed: 0 bytes in 0 blocks
==15916== Rerun with —leak-check=full to see details of leaked memory
==15916==
==15916== For counts of detected and suppressed errors, rerun with: -v
==15916== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

(Обратите внимание, что 15916 — идентификатор процесса в системе, он будет отличаться от запуска к запуску.)

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

Если количество malloc отличается от количества free, вы захотите перезапустить программу снова с опцией leak-check. Это покажет вам все вызовы malloc/new и т.д., которые не имеют соответствующего free.

В целях демонстрации я буду использовать очень простую программу, которую я скомпилирую в исполняемый файл под названием "example1"

int main()
{
    char *ix = new char [10]; // или, char *ix = malloc(10) для языка СИ
    return 0;
}

Это покажет некоторую информацию о программе, завершающуюся списком вызовов new, которые не имеют последующих вызовов delete:

==18350== HEAP SUMMARY:
==18350== in use at exit: 10 bytes in 1 blocks
==18350== total heap usage: 1 allocs, 0 frees, 10 bytes allocated

Это не дает нам столько информации, как хотелось бы, но — мы знаем, что утечка памяти произошла из-за вызова new в main, но у нас нет номера строки. Проблема в том, что мы компилировали без параметра -g в g++, который добавляет символы отладки. Поэтому, если мы перекомпилируем код с отладочной информацией, мы получим более полезную информацию:

==15635== HEAP SUMMARY:
==15635== in use at exit: 10 bytes in 1 blocks
==15635== total heap usage: 1 allocs, 0 frees, 10 bytes allocated
==15635==
==15635== 10 bytes in 1 blocks are definitely lost in loss record 1 of 1
==15635== at 0x4C2BAD7: operator new[](unsigned long) (vg_replace_malloc.c:363)
==15635== by 0x400575: main (man.cpp:3)

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

Иногда --leak-check=yes не показывает все утечки памяти. Чтобы найти абсолютно все непарные вызовы free или new, необходимо использовать --show-reachable=yes. Вывод программы будет почти точно такой же, но он будет показывать больше неосвобождённой памяти.

Поиск недопустимого использования указателя с Valgrind

Valgrind может также показывать неверное использование памяти с помощью инструмента Memcheck. Например, если выделить массив импользуя malloc или new, а затем попытаться получить доступ к элементу за пределами массива:

char *ptr = new char [10];
ptr[10] = 'c';

Valgrind обнаружит его. Например, проверим следующую программу, с помощью Valgrind

int main()
{
    char *ptr = new char [10];
    ptr[10] = 'c';
    return 0;
}

Сначала компилируем в g++  этот исходник, команда g++ -g programname. После этого в терминале вводим команду запуска Valgrind:

valgrind —tool=memcheck —leak-check=yes ‘/home/den/a.out’

В ответ Valgrind нам выдаст следующее сообщение:

==15911== Invalid write of size 1
==15911== at 0x400582: main (man.cpp:4)
==15911== Address 0x5a0504a is 0 bytes after a block of size 10 alloc’d
==15911== at 0x4C2BAD7: operator new[](unsigned long) (vg_replace_malloc.c:363)
==15911== by 0x400575: main (man.cpp:3)

Это говорит нам о том, что мы используем указатель, выделенный для 10 байт, за пределами этого диапазона, — следовательно, мы получаем Invalid write. Если бы мы пытались читать из этой памяти, мы бы получили предупреждение Invalid read of size num, где num — это объем памяти, который мы пытаемся прочитать. (Для char это будет один, а для int это будет либо 2, либо 4, в зависимости от вашей системы.) Как обычно, Valgrind выводит трассировку стека вызовов функций, так что мы точно знаем, где произошла ошибка .

Обнаружение использования неинициализированных переменных

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

#include <iostream>

int main()
{
    int num;
    if(num == 0)    
        std::cout << "num равна нулю"; // или printf() для языка Си    
    return 0;
}

через Valgrind, получим следующий ответ:

==16284== Conditional jump or move depends on uninitialised value(s)
==16284== at 0x4006E0: main (man.cpp:6)

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

#include <iostream>

int func(int val)
{
    if(val < 7)
    {
        std::cout << "val меньше 7n";
    }
}

int main()
{
    int num;
    func(num);
}

в Valgrind, результом будет следующее предупреждение:

==16371== Conditional jump or move depends on uninitialised value(s)
==16371== at 0x4006E3: func(int) (man.cpp:5)
==16371== by 0x400707: main (man.cpp:14)

Вы думаете, что проблема была в func, и что остальная часть вызовов стека, вероятно, не так уж важна. Но так как main предоставляет неинициализированное значение в foo (мы не присваиваем значение num), то получается, что здесь мы должны начать искать и отслеживать путь присвоения переменных, пока не найдем переменную, которая не была инициализирована.

Это поможет только если вы на самом деле тестируете ту ветвь кода, и, в частности, тот условный оператор. Убедитесь в том, что вы охватили все пути выполнения во время тестирования!

Что еще находит Valgrind

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

==16441== Invalid free() / delete / delete[] / realloc()

Valgrind также обнаруживает неправильно выбранные методы освобождения памяти. Например, в C++ есть три основных варианта для освобождения динамической памяти: free, delete и delete[]. Функция free должна быть согласована с вызовом malloc, а не с вызовом, например, delete — на некоторых системах вы могли бы не делать этого, но это не очень переносимо. Кроме того, ключевое слово delete должно быть только в паре с ключевым словом new (для выделения отдельных объектов), а ключевое слово delete[] должно быть только в паре с ключевым словом new[] (для распределения массивов). (Хотя некоторые компиляторы позволят обойтись без использования неправильной версии delete, нет никакой гарантии, что все из них позволят это.)

Что Valgrind не найдет?

Valgrind не выполняет проверку границ в статических массивах (выделенных в стеке). Так что если вы объявите массив внутри функции:

int main()
{
    char string[10];
    string[11] = 'c';
}

то Valgrind не предупредит вас! Одно из возможных решений для тестирования — просто изменить свои статические массивы на динамически выделяемые, где вы получите проверку на границы, хотя это может внести дополнительную путаницу связанную с вызовами delete.

Еще несколько предостережений

Какой недостаток использования Valgrind? Он использует больше памяти — до двух раз больше, чем ваша обычная программа. Если вы тестируете программу, которая использует очень много памяти, у вас могут возникнуть проблемы. Также увеличивается время запуска программы, когда вы используете Valgrind. Но это не проблема, так как это только во время тестирования. Но если ваша программа медленная, это может быть существенным.

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

Вывод

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

Valgrind for Windows / Wiki / DevelopmentEnvironment

Check out the source code .
Open a Windows command prompt cmd.exe
cd to the source code directory.
run: sh ./autogen.sh.
configure either for the 32 bit or 64 bit version.
build the source by running: make.
build tests by running: make check.

Can you Use Valgrind on Windows?

Valgrind is a developer tool for C++ developers used to find memory issues including C++ memory leak detection. Valgrind heavy relies on Linux internals, thats why Valgrind does not support Windows.

How do I Get Valgrind for Windows?

press win+s to open Cortana.
search for windows features , open Turn Windows features On or Off.
find Windows Subsystem for Linux Beta , click to turn it on.
After a restart you could now open your windows command line and input bash , then enter.

How do I Install Valgrind?

Make sure Valgrind is installed. sudo apt-get install valgrind.
Remove any old Valgrind logs: rm valgrind.log*
Start the program under control of memcheck:

How do you Install Valgrind on CLion Windows?

Install Valgrind on your system.
In CLion, go to Settings / Preferences | Build, Execution, Deployment | Dynamic Analysis Tools | Valgrind.
CLion will attempt to detect the Valgrind binary by searching in standard locations defined in the system PATH variable.