Kapag nagpatakbo ka ng isang programa sa ilalim ng Valgrind, dynamic nitong ginagamit ang executable ng program, na nagbibigay-daan dito na subaybayan ang paggamit ng memorya ng program at pag-uugali ng pagpapatupad.
Memory Leaks sa C++
Mahalagang tandaan na ang Valgrind ay pangunahing idinisenyo para sa mga programang C at C++ at maaaring hindi gumana nang kasing epektibo sa iba pang mga wika o sa lahat ng mga sitwasyon. Bukod pa rito, ang pagpapatakbo ng isang programa sa ilalim ng Valgrind ay maaaring makabuluhang makapagpabagal sa pagpapatupad nito, kaya madalas itong ginagamit sa panahon ng pag-develop at pag-debug kaysa sa mga kapaligiran ng produksyon.
Kapag ang isang dynamic na nilikhang memorya ay hindi nailabas nang maayos, maaari itong magdulot ng mga pagtagas ng memorya sa C/C++ na dahan-dahang mag-uubos ng mga magagamit na mapagkukunan ng memorya. Ito ay maaaring magresulta sa labis na pagkonsumo ng memorya at mababang pagganap ng programa.
Pag-install ng Valgrid
Para i-install ang Valgrind sa isang Linux system, magbukas ng terminal at i-update ang iyong mga package repository gamit ang package manager na partikular sa iyong pamamahagi ng Linux. Ang sumusunod na command ay gumagana para sa Ubuntu at Debian-based system:
$ sudo angkop na pag-update
Gamitin ang manager ng package para i-install ang Valgrind. Muli, ang utos ay maaaring mag-iba depende sa iyong pamamahagi ng Linux. Gamitin ang sumusunod na command para sa Ubuntu at Debian-based system:
$ sudo apt i-install gate ng halalan
Kapag sinenyasan, ipasok ang iyong password ng gumagamit at pindutin ang 'Enter'. Tandaan na ang iyong user account ay nangangailangan ng mga pribilehiyong pang-administratibo upang mai-install ang software. Ang manager ng package ay nagda-download at nag-i-install ng Valgrind kasama ang anumang kinakailangang dependencies. Maaaring tumagal ng ilang minuto ang proseso.
Pagkatapos ng proseso ng pag-install, maaari mong kumpirmahin ang matagumpay na pag-install ng Valgrind sa pamamagitan ng pagsasagawa ng sumusunod na command bilang isang hakbang sa pag-verify:
$ gate ng halalan --bersyonIpinapakita ng command na ito ang impormasyon ng bersyon ng Valgrind kung matagumpay itong na-install.
Ayan yun! Dapat na ngayong naka-install ang Valgrind sa iyong Linux system, at magagamit mo ito upang suriin at i-debug ang iyong mga C/C++ program para sa mga memory leaks at iba pang isyu.
Paglikha ng File sa Ubuntu
Upang magsimulang magtrabaho sa programa, kailangan muna naming lumikha ng isang file sa Ubuntu. Para sa paggawa ng file, ginagamit namin ang nano text editor. Kaya, isinulat namin ang utos sa terminal tulad ng sumusunod:
$ nano file1Dito, nano ang pangalan ng text editor na pinapagana. Ang argumentong 'file1' ay kumakatawan sa pangalan ng file na balak mong buksan o gawin gamit ang nano text editor. Binubuksan ng Nano ang file para sa pag-edit kung mayroon na ito; kung hindi, bubuo ito ng bagong file na may ibinigay na pangalan. Dahil wala kaming ganoong file, lumilikha ito ng bagong dokumento na may pangalan, 'file1'.
Sa sandaling patakbuhin mo ang command, magbubukas ang nano editor, na magbibigay sa iyo ng isang blangkong canvas upang ipasok o i-edit ang nilalaman ng 'file1' na file. Maaari mong simulan ang pag-type o pag-paste ng kasalukuyang nilalaman sa editor.
Ngayon na ang lahat ng mga kinakailangan ay nakamit, lumikha kami ng ilang mga halimbawa upang magamit ang Valgrind upang makita ang mga pagtagas ng memorya sa mga programang C++.
Halimbawa 1:
Ang unang halimbawa na ibinigay namin ay nagpapakita ng isang simpleng halimbawa ng dynamic na paglalaan ng memorya gamit ang function na 'malloc' mula sa
int pangunahing ( )
{
char * a = malloc ( 102 ) ;
bumalik 0 ;
}
Narito ang isang breakdown ng code:
Isama muna namin ang karaniwang file ng header ng library
Ang int main() na linya ay nagdedeklara ng pangunahing function. Pagkatapos, ang char *a = malloc(102); nagdedeklara ng pointer variable na “a” na may uri na char* (pointer to char). Ginagamit nito ang function na 'malloc' upang dynamic na maglaan ng memorya para sa isang hanay ng 102 char elements (102 bytes sa kabuuan). Ang laki ng alokasyon ng memorya, na ipinahayag sa mga byte, ay ipinadala bilang isang input sa malloc function at naglalabas ito ng isang pointer sa bagong likhang memory block. Ang char* pointer na 'a' ay nakatalaga sa pointer value na ito. Panghuli, ang 'return 0;' ay nagpapahiwatig ng pagtatapos ng pangunahing pag-andar.
Sa madaling salita, ang code na ito ay dynamic na naglalaan ng memorya para sa isang array ng 102 char elements gamit ang 'malloc' at itinalaga ang memory address sa pointer na 'a'. Gayunpaman, tandaan na ang code ay hindi gumagamit o nagmamanipula ng inilalaan na memorya sa anumang paraan at hindi kasama ang deallocation ng memorya gamit ang libre.
Kapag pinatakbo namin ang program na ito sa pamamagitan ng Valgrind gamit ang opsyong “–leak-check=full”, nagsasagawa ito ng memory leak check at nagbibigay ng output report.
Ang ulat ng output na ginawa ng Valgrid ay ibinigay bilang mga sumusunod:
Halimbawa 2:
Upang magsimula sa paglalarawang ito, lumikha muna kami ng 'test2' na file gamit ang nano text editor tulad ng ipinaliwanag dati sa pamamagitan ng pagsulat ng command:
$ nano pagsubok2Ngayon, sumulat kami ng isang C++ program upang suriin kung mayroong anumang memory leak gamit ang Valgrind:
#include#include
#include
const int a_s = 3000 ;
int pangunahing ( ) {
int * ia = malloc ( sukat ng ( int ) * a_s ) ;
para sa ( int i = 0 ; i < a_s; i++ ) {
ito [ i ] = i;
}
srand ( oras ( WALA ) ) ;
int rn = rand ( ) % a_s;
printf ( 'ito[%d]: %d \n ' , rn, ito [ rn ] ) ;
bumalik 0 ;
}
Tara na sa programa.
Kasama sa code ang mga kinakailangang header file at tinutukoy ang 'a_s' na constant variable na may halaga na 3000. Sa loob ng main() function, ang pointer na 'ia' na uri int* ay ipinahayag at ang memorya ay dynamic na inilalaan gamit ang 'malloc' function. Tinutukoy ng expression na 'sizeof(int) * a_s' ang kabuuang kinakailangang memory upang maiimbak ang 'a_s' na bilang ng mga integer. Ang lahat ng elemento ng array na 'ia' ay sinisimulan ng loop na 'para sa' na may katumbas na halaga ng index. Halimbawa, ang ia[0] ay magiging 0, ang ia[1] ay magiging 1, at iba pa.
Ang random number generator ay seeded gamit ang 'srand' function gamit ang kasalukuyang oras. Tinitiyak nito na ang programa ay gumagawa ng isang natatanging hanay ng mga random na integer sa bawat oras na ito ay isasagawa. Ang function na 'rand' ay bumubuo ng isang random na numero, at ang 'rn' ay itinalaga kasama ang resulta ng rand() % a_s. Nililimitahan ng modulus operator na “%” ang saklaw ng random na numero na nasa pagitan ng 0 at a_s – 1 na tumutugma sa isang wastong index sa loob ng array na “ia”.
Sa wakas, ginagamit ng programa ang function na 'printf' upang i-print ang halaga sa random na napiling index na 'rn' ng array na 'ia', kasama ang kaukulang index.
Kapag pinatakbo mo ang program na ito sa pamamagitan ng Valgrind, bubuo ito ng sumusunod na ulat ng output:
Konklusyon
Natuklasan namin ang paggamit ng Valgrind tool upang makita ang mga pagtagas ng memorya sa isang C++ program. Ang gabay sa pag-install ng Valgrind ay ibinigay sa simula. Pagkatapos nito, nagpaliwanag kami sa paglikha ng isang file sa Ubuntu gamit ang nano text editor. Sa huli, gamit ang mga kinakailangang ito, nagsagawa kami ng dalawang halimbawa ng C++ upang suriin ang mga pagtagas ng memorya sa kanila. Ang ulat na nabuo ng Valgrind ay nakalakip din na nagpapakita ng mga pagtagas ng memorya sa ibinigay na file.