valgrind

PROGRAM:

NUME

valgrind - o suită de instrumente pentru programe de depanare și profilare

REZUMAT

valgrind [Valgrind-opțiuni] [programul dumneavoastră] [opțiunile-programului dvs]

DESCRIERE

valgrind este un program flexibil pentru depanarea și profilarea executabilelor Linux. Constă
a unui nucleu, care oferă un CPU sintetic în software, și o serie de depanare și
instrumente de profilare. Arhitectura este modulară, astfel încât noi instrumente pot fi create cu ușurință și
fără a perturba structura existentă.

Unele dintre opțiunile descrise mai jos funcționează cu toate instrumentele Valgrind, iar altele funcționează numai cu
câteva sau una. Secțiunea OPȚIUNI MEMCHECK și cele de mai jos descriu instrumente specifice
opțiuni.

Această pagină de manual acoperă numai utilizarea și opțiunile de bază. Pentru informații mai complete,
vă rugăm să consultați documentația HTML de pe sistemul dvs.:
$INSTALL/share/doc/valgrind/html/index.html sau online:
http://www.valgrind.org/docs/manual/index.html.

TOOL SELECȚIE OPŢIUNI

Cea mai importantă opțiune.

--instrument= [Mod implicit: memcheck]
Rulați instrumentul Valgrind numit nume instrument, de exemplu, memcheck, cachegrind, callgrind, helgrind,
drd, masiv, lacheu, niciunul, exp-sgcheck, exp-bbv, exp-dhat etc.

BASIC OPŢIUNI

Aceste opțiuni funcționează cu toate instrumentele.

-h --Ajutor
Afișați ajutor pentru toate opțiunile, atât pentru nucleu, cât și pentru instrumentul selectat. Dacă opțiunea
se repetă este echivalent cu a da --help-debug.

--help-debug
La fel ca --Ajutor, dar listează și opțiunile de depanare care sunt de obicei utile doar pentru
Dezvoltatorii lui Valgrind.

--versiune
Afișați numărul versiunii nucleului Valgrind. Instrumentele pot avea propria lor versiune
numerele. Există o schemă în vigoare pentru a se asigura că instrumentele se execută numai atunci când sunt de bază
versiunea este una cu care se știe că lucrează. Acest lucru a fost făcut pentru a minimiza șansele de
probleme ciudate care decurg din incompatibilitățile versiunii instrument-vs-core.

-q, --Liniște
Rulați în tăcere și imprimați numai mesajele de eroare. Util dacă rulați regresia
teste sau au alte mașini automate de testare.

-v, --verbos
Fii mai pronunțat. Oferă informații suplimentare despre diferite aspecte ale programului dvs., cum ar fi:
obiectele partajate încărcate, suprimarile folosite, progresul instrumentației
și motoare de execuție și avertismente despre comportamentul neobișnuit. Repetând opțiunea
crește nivelul de verbozitate.

--urme-copii= [Mod implicit: Nu]
Când este activat, Valgrind va urmări sub-procesele inițiate prin intermediul Exec sistem
apel. Acest lucru este necesar pentru programele cu mai multe procese.

Rețineți că Valgrind urmărește copilul lui a furculiţă (ar fi dificil să nu,
întrucât furculiţă face o copie identică a unui proces), așa că această opțiune este probabil proastă
numit. Cu toate acestea, majoritatea copiilor de furculiţă apelează imediat Exec oricum.

--trace-children-skip=patt1,patt2,...
Această opțiune are efect numai atunci când --trace-children=da este specificat. Permite
nişte copii să fie săriţi peste. Opțiunea are o listă de modele separate prin virgulă
numele executabilelor copil pe care Valgrind nu ar trebui să le urmărească. Modelele pot
include metacaracterele? și *, care au sensul obișnuit.

Acest lucru poate fi util pentru tăierea ramurilor neinteresante dintr-un arbore de procese
alerga pe Valgrind. Dar ar trebui să fii atent când îl folosești. Când Valgrind omite urmărirea
într-un executabil, nu doar omite urmărirea acelui executabil, ci și
urmărirea oricăruia dintre procesele secundare ale acelui executabil. Cu alte cuvinte, steagul nu
face doar oprirea urmăririi la executabilele specificate -- omite urmărirea
subarborele întregului proces înrădăcinat la oricare dintre executabilele specificate.

--trace-children-skip-by-arg=patt1,patt2,...
Aceasta este la fel ca --urme-copii-sări, cu o singură diferență: decizia cu privire la
dacă să urmăriți un proces copil se face prin examinarea argumentelor aduse copilului
proces, mai degrabă decât numele executabilului său.

--copil-tăcut-după-furculiță= [Mod implicit: Nu]
Când este activat, Valgrind nu va afișa nicio ieșire de depanare sau de înregistrare pentru copil
proces rezultat din a furculiţă apel. Acest lucru poate face ieșirea mai puțin confuză (deși
mai înșelătoare) când se confruntă cu procese care creează copii. Este în special
util împreună cu --urme-copii=. Utilizarea acestei opțiuni este, de asemenea, puternică
recomandat dacă solicitați ieșire XML (--xml=da), deoarece, în caz contrar, XML de la
copilul și părintele se pot amesteca, ceea ce de obicei îl face inutil.

--vgdb= [Mod implicit: da]
Valgrind va oferi funcționalitatea „gdbserver” atunci când --vgdb=da or --vgdb=plin is
specificat. Acest lucru permite unui depanator GNU GDB extern să controleze și să depaneze programul dvs
când rulează pe Valgrind. --vgdb=plin implică cheltuieli generale de performanță semnificative, dar
oferă puncte de întrerupere și puncte de urmărire mai precise. Consultați Depanarea programului dvs. folosind
Valgrind gdbserver și GDB pentru o descriere detaliată.

Dacă serverul gdb încorporat este activat, dar nu este utilizat în prezent niciun gdb, vgdb
Utilitarul de linie de comandă poate trimite „comenzi de monitorizare” către Valgrind dintr-un shell. The
Valgrind core oferă un set de comenzi de monitorizare Valgrind. Un instrument poate opțional
furnizați comenzi de monitor specifice instrumentului, care sunt documentate în instrumentul specific
capitol.

--vgdb-error= [Mod implicit: 999999999]
Utilizați această opțiune când Valgrind gdbserver este activat cu --vgdb=da or --vgdb=plin.
Instrumentele care raportează erori vor aștepta ca erorile „număr” să fie raportate înainte de înghețare
programul și așteaptă să vă conectați la GDB. Rezultă că o valoare de zero
va face ca gdbserver să fie pornit înainte ca programul dumneavoastră să fie executat. Aceasta este
folosit de obicei pentru a insera puncte de întrerupere GDB înainte de execuție și, de asemenea, funcționează cu instrumente
care nu raportează erori, cum ar fi Massif.

--vgdb-stop-at= [Mod implicit: nici unul]
Utilizați această opțiune când Valgrind gdbserver este activat cu --vgdb=da or --vgdb=plin.
Valgrind gdbserver va fi invocat pentru fiecare eroare de după --vgdb-error au fost
raportat. În plus, puteți cere ca Valgrind gdbserver să fie invocat pentru altele
evenimente, specificate într-unul din următoarele moduri:

· o listă separată prin virgulă cu unul sau mai multe dintre ele lansare ieşire valgrindabexit.

Valorile lansare ieşire valgrindabexit respectiv indica invocarea gdbserver
înainte ca programul dvs. să fie executat, după ultima instrucțiune a programului dvs., pornit
Ieșire anormală Valgrind (de exemplu, eroare internă, memorie lipsită, ...).

Notă: lansare si --vgdb-error=0 ambele vor face ca Valgrind gdbserver să fie invocat
înainte ca programul dumneavoastră să fie executat. The --vgdb-error=0 va provoca în plus dvs
programul pentru a opri toate erorile ulterioare.

· toate pentru a specifica setul complet. Este echivalent cu
--vgdb-stop-at=pornire,ieșire,valgrindabexit.

· nici unul pentru setul gol.

--track-fds= [Mod implicit: Nu]
Când este activat, Valgrind va tipări o listă de descriptori de fișier deschis la ieșire sau la pornire
cerere, prin comanda gdbserver monitor v.info open_fds. Împreună cu fiecare fișier
descriptor este tipărit un backtrace al stivei unde a fost deschis fișierul și orice detalii
referitoare la descriptorul fișierului, cum ar fi numele fișierului sau detaliile prizei.

--time-stamp= [Mod implicit: Nu]
Când este activat, fiecare mesaj este precedat de o indicație a ceasului de perete scurs
timpul de la pornire, exprimat ca zile, ore, minute, secunde și milisecunde.

--log-fd= [Mod implicit: 2, stderr]
Specifică faptul că Valgrind ar trebui să trimită toate mesajele sale către fișierul specificat
descriptor. Valoarea implicită, 2, este canalul de eroare standard (stderr). Rețineți că acest lucru poate
interferează cu utilizarea stderr de către client, așa cum va fi rezultatul lui Valgrind
intercalat cu orice ieșire pe care clientul o trimite la stderr.

--log-file=
Specifică faptul că Valgrind ar trebui să trimită toate mesajele sale către fișierul specificat. Dacă
numele fișierului este gol, provoacă o întrerupere. Există trei specificatori speciali de format care
poate fi folosit în numele fișierului.

%p este înlocuit cu ID-ul procesului curent. Acest lucru este foarte util pentru acest program
invoca mai multe procese. AVERTISMENT: Dacă utilizați --trace-children=da și programul tău
invocă mai multe procese SAU programul tău furcă fără a apela pe exec după aceea și
nu utilizați acest specificator (sau %q specificatorul de mai jos), ieșirea Valgrind de la toate
acele procese vor intra într-un singur fișier, posibil amestecate și posibil incomplete.

%q{FOO} este înlocuit cu conținutul variabilei de mediu FOO. Dacă {FOO}
parte este malformată, provoacă un avort. Acest specificator este rareori necesar, dar foarte
util în anumite circumstanțe (de ex. la rularea programelor MPI). Ideea este că tu
specificați o variabilă care va fi setată diferit pentru fiecare proces din job, pt
exemplu BPROC_RANK sau orice este aplicabil în configurația dvs. MPI. Dacă numitul
variabila de mediu nu este setată, aceasta provoacă o întrerupere. Rețineți că în unele cochilii, {
si } Este posibil ca caracterele să fie evadate cu o bară oblică inversă.

%% este înlocuit cu %.

Daca un % este urmat de orice alt caracter, provoacă o întrerupere.

Dacă numele fișierului specifică un nume de fișier relativ, acesta este pus în inițiala programului
director de lucru: acesta este directorul curent când a început programul
executie dupa furca sau dupa exec. Dacă specifică un nume absolut de fișier (de ex.
începe cu '/') apoi este pus acolo.

--log-socket=
Specifică faptul că Valgrind ar trebui să trimită toate mesajele sale către portul specificat la
adresa IP specificată. Portul poate fi omis, caz în care este utilizat portul 1500. În cazul în care o
conexiunea nu se poate face la priza specificată, Valgrind revine la scriere
ieșire la eroarea standard (stderr). Această opțiune este destinată a fi utilizată în
împreună cu programul valgrind-listener. Pentru mai multe detalii, consultați
comentariu în manual.

LEGATE DE EROARE OPŢIUNI

Aceste opțiuni sunt folosite de toate instrumentele care pot raporta erori, de exemplu Memcheck, dar nu
Cachegrind.

--xml= [Mod implicit: Nu]
Când este activată, părțile importante ale ieșirii (de exemplu, mesajele de eroare a instrumentului) vor fi în
Format XML mai degrabă decât text simplu. În plus, rezultatul XML va fi trimis către a
canal de ieșire diferit de cel al textului simplu. Prin urmare, trebuie să utilizați unul
of --xml-fd, --xml-file or --xml-socket pentru a specifica unde va fi trimis XML-ul.

Mesajele mai puțin importante vor fi în continuare tipărite în text simplu, dar din cauza XML
ieșirea și textul simplu sunt trimise către diferite canale de ieșire (destinația lui
ieșirea textului simplu este încă controlată de --log-fd, --fișier jurnal si --log-socket)
acest lucru nu ar trebui să provoace probleme.

Această opțiune are scopul de a face viața mai ușoară pentru uneltele care consumă producția Valgrind ca
intrare, cum ar fi front-end-urile GUI. În prezent, această opțiune funcționează cu Memcheck, Helgrind,
DRD și SGcheck. Formatul de ieșire este specificat în fișier
docs/internals/xml-output-protocol4.txt în arborele sursă pentru Valgrind 3.5.0 sau
mai târziu.

Opțiunile recomandate pentru ca o interfață grafică să treacă, atunci când se solicită ieșire XML, sunt: --xml=da
pentru a activa ieșirea XML, --xml-file pentru a trimite ieșirea XML la o (se presupune că este selectată de GUI)
fişier, --fișier jurnal pentru a trimite rezultatul text simplu la un al doilea fișier selectat de GUI,
--child-silent-after-furk=da și -q pentru a restricționa rezultatul textului simplu la critic
mesaje de eroare create chiar de Valgrind. De exemplu, eșecul de a citi un specificat
fișierul de suprimare este considerat un mesaj de eroare critic. În acest fel, pentru un succes
rulați fișierul de ieșire text va fi gol. Dar dacă nu este gol, atunci va conține
informații importante de care ar trebui să fie informat utilizatorul GUI.

--xml-fd= [Mod implicit: -1, dezactivat]
Specifică faptul că Valgrind ar trebui să-și trimită rezultatul XML către descriptorul de fișier specificat.
Trebuie folosit împreună cu --xml=da.

--xml-file=
Specifică faptul că Valgrind ar trebui să-și trimită rezultatul XML către fișierul specificat. Trebuie să fie
folosit împreună cu --xml=da. Orice %p or %q secvențe care apar în numele fișierului
sunt extinse exact în același mod ca și pentru --fișier jurnal. Vezi descrierea
of --fișier jurnal pentru detalii.

--xml-socket=
Specifică faptul că Valgrind ar trebui să trimită ieșirea XML portul specificat la portul specificat
Adresa IP. Trebuie folosit împreună cu --xml=da. Forma argumentului este
la fel ca cel folosit de --log-socket. Vezi descrierea lui --log-socket pentru mai multe
Detalii.

--xml-user-comment=
Încorporează un șir suplimentar de comentarii de utilizator la începutul ieșirii XML. Functioneaza doar cand
--xml=da este specificat; ignorat altfel.

--demangle= [Mod implicit: da]
Activați/dezactivați dezmembrarea (decodarea) automată a numelor C++. Activat implicit. Cand
activat, Valgrind va încerca să traducă numele C++ codificate înapoi în ceva
apropiindu-se de original. Demangler se ocupă de simboluri alterate de versiunile g++ 2.X,
3.X și 4.X.

Un fapt important despre demangling este că numele funcțiilor menționate în suprimări
fișierele ar trebui să fie în forma lor deteriorată. Valgrind nu demangle numele funcțiilor când
căutarea suprimărilor aplicabile, pentru că a face altfel ar face suprimare
conținutul fișierului depinde de starea mașinilor de dezmembrare a lui Valgrind și, de asemenea, lent
potrivirea suprimarii în jos.

--num-callers= [Mod implicit: 12]
Specifică numărul maxim de intrări afișate în urmele stivei care identifică programul
locatii. Rețineți că erorile sunt comune folosind numai primele patru locații ale funcției
(locul din funcția curentă și cel al celor trei apelanți imediati ai săi). Deci asta
nu afectează numărul total de erori raportate.

Valoarea maximă pentru aceasta este 500. Rețineți că setările mai mari vor face Valgrind să ruleze a
puțin mai lent și luați puțin mai multă memorie, dar poate fi util când lucrați cu
programe cu lanțuri de apeluri profund imbricate.

--unw-stack-scan-thresh= [Mod implicit: 0] , --unw-stack-scan-frames= [Mod implicit:
5]
Suportul pentru scanarea stivă este disponibil numai pentru ținte ARM.

Aceste steaguri permit și controlează derularea stivei prin scanarea stivei. Când normalul
mecanisme de derulare a stivei -- utilizarea înregistrărilor Dwarf CFI și urmărirea indicatorului de cadru
-- eșuează, scanarea stivei poate fi capabilă să recupereze o urmă de stivă.

Rețineți că scanarea stivei este un mecanism euristic imprecis, care poate da foarte mult
rezultate înșelătoare sau deloc. Ar trebui folosit numai în situații de urgență, când este normal
derularea eșuează și este important să aveți totuși urme de stivă.

Scanarea stivei este o tehnică simplă: desfășuratorul citește cuvintele din stivă și
încearcă să ghicească care dintre ele ar putea fi adrese de retur, verificând dacă acestea
punct imediat după instrucțiunile de apel ARM sau Thumb. Dacă da, cuvântul este adăugat la
trage înapoi.

Pericolul principal apare atunci când un apel de funcție revine, părăsind adresa de returnare
expusă și este apelată o nouă funcție, dar noua funcție nu o suprascrie pe cea veche
abordare. Rezultatul este că backtrace poate conține intrări pentru funcții
care s-au întors deja și deci să fie foarte confuz.

O a doua limitare a acestei implementări este că va scana numai pagina (4KB,
în mod normal) care conţine indicatorul stivei de pornire. Dacă cadrele stivei sunt mari, aceasta
poate avea ca rezultat doar câteva (sau chiar niciunul) prezente în urmă. De asemenea, dacă tu
au ghinion și au un indicator de stivă inițial aproape de sfârșitul paginii care le conține, the
scanarea poate pierde toate cadrele interesante.

În mod implicit, scanarea stivei este dezactivată. Cazul de utilizare normal este să-l ceri atunci când a
Urmărirea stivei ar fi altfel foarte scurtă. Deci, pentru a-l activa, utilizați
--unw-stack-scan-thresh=număr. Aceasta îi cere lui Valgrind să încerce să folosească scanarea stivei la
„extinde” urmele stivei care conțin mai puține cadre numerice.

Dacă scanarea stivei are loc, va genera doar cel mult numărul de cadre
specificat de --unw-stack-scan-frames. De obicei, scanarea stivei generează atât de multe
intrări de gunoi că această valoare este setată la o valoare scăzută (5) în mod implicit. În niciun caz nu va
să fie creată o urmă de stivă mai mare decât valoarea specificată de --num-callers.

--error-limit= [Mod implicit: da]
Când este activat, Valgrind oprește raportarea erorilor după 10,000,000 în total sau 1,000
altele diferite, au fost văzute. Acest lucru este pentru a opri mașina de urmărire a erorilor
devenind o suprasolicitare uriașă de performanță în programele cu multe erori.

--error-exitcode= [Mod implicit: 0]
Specifică un cod de ieșire alternativ de returnat dacă Valgrind a raportat erori în fișierul
alerga. Când este setată la valoarea implicită (zero), valoarea returnată de la Valgrind va fi întotdeauna
fi valoarea de returnare a procesului simulat. Când este setată la o valoare diferită de zero, asta
valoarea este returnată în schimb, dacă Valgrind detectează erori. Acest lucru este util pentru utilizare
Valgrind ca parte a unei suite de teste automatizate, deoarece face ușor detectarea testului
cazuri pentru care Valgrind a raportat erori, doar prin inspectarea codurilor de returnare.

--markeri de eroare= , [Mod implicit: nici unul]
Când erorile sunt afișate ca text simplu (adică XML nu este utilizat), --marcatori de eroare instruiește să
scoateți o linie care conține începe (capăt) șir înainte (după) fiecare eroare.

Astfel de linii de marcare facilitează căutarea erorilor și/sau extragerea erorilor într-un
fișier de ieșire care conține erori valgrind amestecate cu ieșirea programului.

Rețineți că marcatoarele goale sunt acceptate. Deci, numai folosirea unui marker de început (sau de sfârșit).
posibil.

--sigill-diagnostics= [Mod implicit: da]
Activați/dezactivați imprimarea diagnosticelor de instrucțiuni ilegale. Activat implicit, dar
implicit este dezactivat când --Liniște este dată. Valoarea implicită poate fi întotdeauna în mod explicit
înlocuit prin acordarea acestei opțiuni.

Când este activată, va fi tipărit un mesaj de avertizare, împreună cu unele diagnostice, oricând
este întâlnită o instrucțiune pe care Valgrind nu o poate decoda sau traduce, înainte de
programului i se dă un semnal SIGILL. Adesea, o instrucțiune ilegală indică o eroare în
program sau suport lipsă pentru instrucțiunea specială în Valgrind. Dar unii
programele încearcă în mod deliberat să execute o instrucțiune care ar putea să lipsească și să capteze
semnalul SIGILL pentru a detecta caracteristicile procesorului. Utilizarea acestui steag face posibilă
evitați rezultatul de diagnosticare pe care altfel le-ați obține în astfel de cazuri.

--show-below-main= [Mod implicit: Nu]
În mod implicit, urmele stivei pentru erori nu arată nicio funcție care apare dedesubt principal
pentru că de cele mai multe ori sunt chestii neinteresante din bibliotecă C și/sau gobbledygook.
Alternativ, dacă principal nu este prezent în urmărirea stivei, urmele stivei nu se vor afișa
orice funcții de mai jos principal-ca funcții precum glibc __libc_start_main.
Mai mult decât atât, dacă principal-funcţiile asemănătoare sunt prezente în urmă, sunt normalizate ca
(de mai jos principal), pentru a face ieșirea mai deterministă.

Dacă această opțiune este activată, toate intrările de urmărire a stivei vor fi afișate și principal-Ca
funcțiile nu vor fi normalizate.

--fullpath-after= [Mod implicit: nu face Arăta sursă poteci]
În mod implicit, Valgrind arată numai numele fișierelor în urmele stivei, dar nu și căile complete către
fișiere sursă. Când utilizați Valgrind în proiecte mari în care se află sursele
mai multe directoare diferite, acest lucru poate fi incomod. --fullpath-after oferă o
soluție flexibilă la această problemă. Când această opțiune este prezentă, calea către fiecare
este afișat fișierul sursă, cu următoarea avertizare extrem de importantă: dacă şir se găsește în
calea, apoi calea până la și inclusiv şir este omis, altfel calea este afișată
nemodificat. Rețineți că şir nu este necesar să fie un prefix al căii.

De exemplu, luați în considerare un fișier numit /home/janedoe/blah/src/foo/bar/xyzzy.c. Precizând
--fullpath-after=/home/janedoe/blah/src/ va determina Valgrind să arate numele ca
foo/bar/xyzzy.c.

Deoarece șirul nu trebuie să fie un prefix, --fullpath-after=src/ va produce
aceeași ieșire. Acest lucru este util atunci când calea conține arbitrare generate de mașină
personaje. De exemplu, calea /my/build/dir/C32A1B47/blah/src/foo/xyzzy poate fi
tăiat la foo/xyzzy folosind --fullpath-after=/blah/src/.

Dacă doriți pur și simplu să vedeți calea completă, trebuie doar să specificați un șir gol:
--fullpath-after=. Acesta nu este un caz special, ci doar o consecință logică a
regulile de mai sus.

În cele din urmă, puteți utiliza --fullpath-after de mai multe ori. Orice apariție a acesteia provoacă
Valgrind va trece la producerea de căi complete și la aplicarea regulii de filtrare de mai sus. Fiecare
calea produsă este comparată cu toate --fullpath-after-şiruri specificate, în
comanda specificata. Primul șir care se potrivește face ca calea să fie trunchiată ca
descris mai sus. Dacă niciunul nu se potrivește, este afișată calea completă. Acest lucru facilitează tăierea
prefixe atunci când sursele sunt extrase dintr-un număr de directoare care nu au legătură.

--extra-debuginfo-path= [Mod implicit: nedefinit si nefolosit]
În mod implicit, Valgrind caută în mai multe căi binecunoscute obiecte de depanare, cum ar fi
/usr/lib/debug/.

Cu toate acestea, pot exista scenarii în care ați dori să puneți obiecte de depanare la un
locație arbitrară, cum ar fi stocarea externă atunci când rulați Valgrind pe un dispozitiv mobil
cu stocare locală limitată. Un alt exemplu ar putea fi o situație în care nu aveți
permisiunea de a instala pachete de obiecte de depanare pe sistemul în care rulați
Valgrind.

În aceste scenarii, puteți oferi o cale absolută ca loc suplimentar, final pentru
Valgrind pentru a căuta obiecte de depanare specificând
--extra-debuginfo-path=/path/to/debug/objects. Calea dată va fi adăugată înaintea
numele căii absolute a obiectului căutat. De exemplu, dacă Valgrind caută
informațiile de depanare pentru /w/x/y/zz.so și --extra-debuginfo-path=/a/b/c este specificat, va fi
căutați un obiect de depanare la /a/b/c/w/x/y/zz.so.

Acest flag ar trebui specificat o singură dată. Dacă este specificat de mai multe ori, numai
ultima instanta este onorata.

--debuginfo-server=ipaddr:port [Mod implicit: nedefinit si nefolosit]
Aceasta este o caracteristică nouă, experimentală, introdusă în versiunea 3.9.0.

În unele scenarii, poate fi convenabil să citiți informațiile de depanare din obiectele stocate pe un
mașină diferită. Cu acest indicator, Valgrind va interoga un server de informații de depanare care rulează
ipaddr și ascultă pe portul port, dacă nu poate găsi obiectul debuginfo în local
Sistemul de fișiere.

Serverul de informații de depanare trebuie să accepte conexiuni TCP pe portul de port. Serverul de debuginfo este
conținute în fișierul sursă auxprogs/valgrind-di-server.c. Va servi doar de la
directorul în care este pornit. port este implicit 1500 atât în ​​client cât și în server dacă
nespecificat.

Dacă Valgrind caută informațiile de depanare pentru /w/x/y/zz.so folosind serverul de informații de depanare,
va elimina componentele căii și va solicita doar zz.so pe server. Că în
turn va căuta doar în directorul său curent de lucru un obiect debuginfo care se potrivește.

Datele de debuginfo sunt transmise în fragmente mici (8 KB) așa cum este solicitat de Valgrind.
Fiecare bloc este comprimat folosind LZO pentru a reduce timpul de transmisie. Implementarea are
a fost reglat pentru cea mai bună performanță printr-o conexiune de rețea 802.11g (WiFi) cu o singură etapă.

Rețineți că verifică potrivirea obiectelor primare cu cele de depanare, folosind GNU debuglink CRC
schema, sunt efectuate chiar și atunci când se utilizează serverul de debuginfo. Pentru a dezactiva o astfel de verificare,
trebuie să specificați și --allow-mismatched-debuginfo=yes.

În mod implicit, sistemul de compilare Valgrind va construi valgrind-di-server pentru țintă
platformă, care aproape sigur nu este ceea ce îți dorești. Până acum nu am putut
aflați cum să obțineți automake/autoconf pentru a-l crea pentru platforma de compilare. Daca vrei
pentru a-l folosi, va trebui să îl recompilați manual folosind comanda afișată în partea de sus a
auxprogs/valgrind-di-server.c.

--allow-mismatched-debuginfo=nu|da [Nu]
Când citește informații de depanare din obiecte separate de informații de depanare, Valgrind va verifica implicit
că obiectele principale și debuginfo se potrivesc, folosind mecanismul GNU debuglink. Acest
garantează că nu citește debuginfo din obiectele debuginfo învechite și
de asemenea, se asigură că Valgrind nu se poate prăbuși ca urmare a nepotrivirilor.

Această verificare poate fi suprascrisă folosind --allow-mismatched-debuginfo=yes. Aceasta ar putea fi
util atunci când informațiile de depanare și obiectele principale nu au fost împărțite în mod corespunzător. Fi
Cu toate acestea, aveți grijă când utilizați acest lucru: dezactivează verificarea tuturor consistenței și Valgrind
s-a observat că se blochează atunci când obiectele principale și debuginfo nu se potrivesc.

--suprimări= [Mod implicit: $PREFIX/lib/valgrind/default.supp]
Specifică un fișier suplimentar din care să citească descrierile erorilor de suprimat. Poți
utilizați până la 100 de fișiere suplimentare de suprimare.

--gen-suprimari= [Mod implicit: Nu]
Când este setat la da, Valgrind se va întrerupe după fiecare eroare afișată și va imprima linia:

---- Suprimarea tipăririi? --- [Retur/N/n/Y/a/C/c] ----

Presare putrezi, N putrezi or n putrezi, determină Valgrind să continue execuția fără a imprima a
suprimarea acestei erori.

Presare Y putrezi or y putrezi determină Valgrind să scrie o suprimare pentru această eroare. Poti
apoi tăiați și lipiți-l într-un fișier de suprimare dacă nu doriți să auziți despre
eroare în viitor.

Când este setat la toate, Valgrind va imprima o suprimare pentru fiecare eroare raportată, fără
interogarea utilizatorului.

Această opțiune este deosebit de utilă cu programele C++, deoarece imprimă fișierul
suprimări cu nume alterate, după cum este necesar.

Rețineți că suprimările imprimate sunt cât se poate de specifice. Poate doriți să obișnuiți
creați altele similare, adăugând caractere joker la numele funcțiilor și utilizând la nivel de cadru
wildcards. Facilitățile de wildcarding sunt puternice, dar flexibile și cu puțin
editare atentă, este posibil să puteți suprima o întreagă familie de erori asociate cu
doar câteva suprimari.

Uneori, două erori diferite sunt suprimate prin aceeași suprimare, caz în care
Valgrind va scoate suprimarea de mai multe ori, dar trebuie să aveți doar una
copiați în fișierul dvs. de suprimare (dar dacă aveți mai multe nu va cauza probleme). De asemenea,
numele de suprimare este dat ca ; numele nu
chiar contează, este folosit doar cu -v opțiune care imprimă toată suprimarea utilizată
Înregistrări.

--input-fd= [Mod implicit: 0, stdin]
Atunci când se utilizează --gen-suppressions=da, Valgrind se va opri pentru a citi intrarea de la tastatură
de la tine atunci când apare fiecare eroare. În mod implicit, citește de la intrarea standard (stdin),
ceea ce este problematic pentru programele care închid stdin. Această opțiune vă permite să specificați
un descriptor de fișier alternativ din care să citiți intrarea.

--dsymutil=nu|da [da]
Această opțiune este relevantă numai atunci când rulați Valgrind pe Mac OS X.

Mac OS X utilizează o schemă de legare a informațiilor de depanare amânată (debuginfo). Când obiect
fișierele care conțin informații de depanare sunt legate într-un .dylib sau un executabil, informațiile de depanare sunt
nu a fost copiat în fișierul final. În schimb, informațiile de depanare trebuie conectate manual de către
rulează dsymutil, un utilitar furnizat de sistem, pe executabilul sau .dylib. The
Informația de depanare combinată rezultată este plasată într-un director alături de executabilul sau
.dylib, dar cu extensia .dSYM.

cu --dsymutil=nu, Valgrind va detecta cazurile în care directorul .dSYM este fie
lipsește sau este prezent, dar nu pare să se potrivească cu executabilul asociat sau
.dylib, cel mai probabil pentru că este depășit. În aceste cazuri, Valgrind va tipări a
mesaj de avertizare, dar nu mai luați nicio măsură.

cu --dsymutil=da, Valgrind, în astfel de cazuri, va rula automat dsymutil ca
necesar pentru a actualiza informațiile de depanare. Pentru toate scopurile practice, dacă întotdeauna
utilizare --dsymutil=da, atunci nu este niciodată nevoie să rulați dsymutil manual sau ca parte
din sistemul de compilare al aplicațiilor dvs., deoarece Valgrind îl va rula după cum este necesar.

Valgrind nu va încerca să ruleze dsymutil pe niciun executabil sau bibliotecă în /usr/,
/ cos /, / sbin /, / opt /, /sw/, /System/, /Library/ sau /Applications/ deoarece dsymutil va
eșuează întotdeauna în astfel de situații. Eșuează ambele deoarece informațiile de depanare pentru astfel de
Componentele de sistem preinstalate nu sunt disponibile nicăieri și, de asemenea, pentru că ar fi
necesită privilegii de scriere în acele directoare.

Aveți grijă când utilizați --dsymutil=da, deoarece va provoca .dSYM preexistent
directoarele care urmează să fie șterse și recreate în tăcere. De asemenea, rețineți că dsymutil este destul de
lent, uneori excesiv.

--max-stackframe= [Mod implicit: 2000000]
Dimensiunea maximă a unui cadru de stivă. Dacă indicatorul stivei se mișcă cu mai mult decât această sumă
atunci Valgrind va presupune că programul trece la o stivă diferită.

Poate fi necesar să utilizați această opțiune dacă programul dvs. are matrice mari alocate în stivă.
Valgrind ține evidența indicatorului de stivă al programului dvs. Dacă se schimbă cu mai mult decât
valoarea pragului, Valgrind presupune că programul dvs. trece la o stivă diferită și
Memcheck se comportă diferit decât s-ar face pentru o modificare a indicatorului de stivă mai mică decât
prag. De obicei, această euristică funcționează bine. Cu toate acestea, dacă programul dvs. alocă mari
structuri de pe stivă, această euristică va fi păcălită, iar Memcheck va fi ulterior
raportați un număr mare de accesări nevalide la stivă. Această opțiune vă permite să schimbați
prag la o valoare diferită.

Ar trebui să luați în considerare utilizarea acestei opțiuni numai dacă rezultatul de depanare a lui Valgrind vă îndrumă
face acest lucru. În acest caz, vă va spune noul prag pe care ar trebui să-l specificați.

În general, alocarea unor structuri mari pe stivă este o idee proastă, pentru că poți
rămâne cu ușurință fără spațiu de stivă, în special pe sisteme cu memorie limitată sau care
așteptați-vă să suportați un număr mare de fire, fiecare cu o stivă mică și, de asemenea, pentru că
verificarea erorilor efectuată de Memcheck este mai eficientă pentru datele alocate în heap
decât pentru datele alocate în stivă. Dacă trebuie să utilizați această opțiune, poate doriți
luați în considerare rescrierea codului pentru a-l aloca pe heap, mai degrabă decât pe stivă.

--main-stacksize= [Mod implicit: utilizare curent „ulimit” valoare]
Specifică dimensiunea stivei firului principal.

Pentru a simplifica gestionarea memoriei, Valgrind rezervă tot spațiul necesar pentru principal
stiva de fire la pornire. Aceasta înseamnă că trebuie să cunoască dimensiunea necesară a stivei la
pornire.

În mod implicit, Valgrind utilizează valoarea curentă „ulimit” pentru dimensiunea stivei sau 16 MB,
oricare este mai jos. În multe cazuri, aceasta oferă o dimensiune a stivei în intervalul 8 până la 16 MB,
care aproape niciodată nu debordează pentru majoritatea aplicațiilor.

Dacă aveți nevoie de o dimensiune totală mai mare a stivei, utilizați --main-stacksize pentru a o preciza. Setează-l doar
cât de sus aveți nevoie, deoarece rezervând mult mai mult spațiu decât aveți nevoie (adică sute
de megaocteți mai mult decât aveți nevoie) constrânge alocatorii de memorie ai Valgrind și poate
reduce cantitatea totală de memorie pe care Valgrind o poate folosi. Acest lucru este doar de
semnificație pe mașinile pe 32 de biți.

Pe Linux, puteți solicita o stivă de până la 2 GB. Valgrind se va opri cu a
mesaj de diagnostic dacă stiva nu poate fi alocată.

--main-stacksize afectează doar dimensiunea stivei pentru firul inițial al programului. Are
nu influențează dimensiunea stivelor de fire, deoarece Valgrind nu le alocă.

Poate fi necesar să le folosiți pe ambele --main-stacksize si --max-stackframe împreună. Este
important să înțelegem asta --main-stacksize setează dimensiunea maximă totală a stivei,
în timp ce --max-stackframe specifică cea mai mare dimensiune a oricărui cadru de stivă. Tu vei
trebuie să rezolve --main-stacksize valoare pentru tine (de obicei, dacă ai
aplicații segfaults). Dar Valgrind vă va spune ce este necesar --max-stackframe mărimea,
daca este necesar.

După cum se discută mai departe în descrierea --max-stackframe, o cerință pentru un mare
stiva este un semn al potențialelor probleme de portabilitate. Cel mai bine vă sfătuiți să plasați toate
date mari în memoria alocată în heap.

--max-threads= [Mod implicit: 500]
În mod implicit, Valgrind poate gestiona până la 500 de fire. Ocazional, acest număr este și el
mic. Utilizați această opțiune pentru a oferi o limită diferită. De exemplu --max-threads=3000.

LEGATE DE MALLOC(). OPŢIUNI

Pentru instrumentele care folosesc propria versiune de malloc (de exemplu, Memcheck, Massif, Helgrind, DRD),
se aplică următoarele opțiuni.

--alignment= [Mod implicit: 8 or 16, în funcție on il platformă]
Implicit al lui Valgrind malloc, realloc, etc, returnează un bloc a cărui adresă de pornire este
Aliniat pe 8 octeți sau aliniat pe 16 octeți (valoarea depinde de platformă și se potrivește cu
platformă implicită). Această opțiune vă permite să specificați o aliniere diferită. The
valoarea furnizată trebuie să fie mai mare sau egală cu valoarea implicită, mai mică sau egală cu
4096 și trebuie să fie o putere de doi.

--redzone-size= [Mod implicit: depinde de on il instrument]
a lui Valgrind malloc, realloc, etc., adăugați blocuri de umplutură înainte și după fiecare bloc heap
alocate de programul rulat. Astfel de blocuri de umplutură sunt numite zone roșii. The
valoarea implicită pentru dimensiunea zonei roșii depinde de instrument. De exemplu, Memcheck adaugă și
protejează minim 16 octeți înainte și după fiecare bloc alocat de client.
Acest lucru îi permite să detecteze depășirile de blocare sau depășirile de până la 16 octeți.

Creșterea dimensiunii zonei roșii face posibilă detectarea depășirilor pe distanțe mai mari,
dar crește cantitatea de memorie folosită de Valgrind. Scăderea dimensiunii zonei roșii va
reduce memoria necesară Valgrind dar și șansele de detectare
supra/subîncărcări, deci nu este recomandat.

neobișnuit OPŢIUNI

Aceste opțiuni se aplică tuturor instrumentelor, deoarece afectează anumite funcții obscure ale Valgrind
miez. Majoritatea oamenilor nu vor trebui să le folosească.

--smc-check= [Mod implicit: all-non-file pentru x86/amd64/s390x,
stivui pentru alte arcuri]
Această opțiune controlează detectarea de către Valgrind a codului cu auto-modificare. Dacă nu se verifică
gata, când un program execută un cod, apoi îl suprascrie cu cod nou și
execută noul cod, Valgrind va continua să execute traducerile pentru care a făcut-o
vechiul cod. Acest lucru va duce probabil la un comportament incorect și/sau la blocări.

Pentru arhitecturile „moderne” -- orice nu este x86, amd64 sau s390x -- implicit
is stivui. Acest lucru se datorează faptului că un program corect trebuie să ia măsuri explicite pentru a restabili
Coerența cache-ului DI după modificarea codului. Valgrind observă și onorează astfel
acțiuni, cu rezultatul că codul cu auto-modificare este tratat transparent cu zero
cost suplimentar.

Pentru x86, amd64 și s390x, programul nu este necesar să notifice hardware-ul despre
sincronizarea coerenței DI necesară. Prin urmare, implicit este all-non-file, care acoperă
caz normal de generare a codului într-o zonă anonimă (fără suport de fișiere) mmap'd.

Semnificațiile celor patru setări disponibile sunt următoarele. Nicio detectare (nici unul),
detectează codul care se modifică automat pe stivă (care este folosit de GCC pentru a implementa imbricat
funcții) (stivui), detectează codul care se modifică automat peste tot (toate), și detectați
cod auto-modificabil peste tot, cu excepția mapărilor susținute de fișiere (all-non-file).

Alergând cu toate va încetini vizibil Valgrind. Alergând cu nici unul va rar
accelerează lucrurile, deoarece foarte puțin cod este generat dinamic în majoritatea programelor.
VALGRIND_DISCARD_TRANSLATIONS cererea clientului este o alternativă la --smc-check=toate
si --smc-check=toate-non-fișier care necesită mai mult efort programator, dar permite Valgrind
pentru a rula programul mai repede, spunându-i exact când trebuie să fie traduceri
refăcut.

--smc-check=toate-non-fișier oferă o versiune mai ieftină, dar mai limitată a
--smc-check=toate. Adaugă verificări la orice traduceri care nu provin din
mapări ale memoriei susținute de fișiere. Aplicații tipice care generează cod, de exemplu JIT-uri
în browserele web, generați cod în zone anonime mmaped, în timp ce codul „fix”.
al browserului trăiește întotdeauna în mapări susținute de fișiere. --smc-check=toate-non-fișier ia
avantajul acestei observații, limitând overheadul de verificare la cod care este
probabil să fie generat JIT.

--read-inline-info= [Mod implicit: vedea de mai jos]
Când este activat, Valgrind va citi informații despre apelurile de funcții integrate de la DWARF3
informații de depanare. Acest lucru încetinește pornirea Valgrind și îl face să utilizeze mai multă memorie (de obicei pentru
fiecare bucată de cod aliniată, 6 cuvinte și spațiu pentru numele funcției), dar rezultă
în stacktraces mai descriptive. Pentru versiunea 3.10.0, această funcționalitate este activată
implicit numai pentru ținte Linux, Android și Solaris și numai pentru instrumente
Memcheck, Helgrind și DRD. Iată un exemplu de câteva stacktraces cu
--read-inline-info=nu:

==15380== Saltul sau mutarea condiționată depinde de valorile neinițializate
==15380== la 0x80484EA: principal (inlinfo.c:6)
==15380==
==15380== Saltul sau mutarea condiționată depinde de valorile neinițializate
==15380== la 0x8048550: fun_noninline (inlinfo.c:6)
==15380== de 0x804850E: principal (inlinfo.c:34)
==15380==
==15380== Saltul sau mutarea condiționată depinde de valorile neinițializate
==15380== la 0x8048520: principal (inlinfo.c:6)

Și aici sunt aceleași erori cu --read-inline-info=da:

==15377== Saltul sau mutarea condiționată depinde de valorile neinițializate
==15377== la 0x80484EA: fun_d (inlinfo.c:6)
==15377== de 0x80484EA: fun_c (inlinfo.c:14)
==15377== de 0x80484EA: fun_b (inlinfo.c:20)
==15377== de 0x80484EA: fun_a (inlinfo.c:26)
==15377== de 0x80484EA: principal (inlinfo.c:33)
==15377==
==15377== Saltul sau mutarea condiționată depinde de valorile neinițializate
==15377== la 0x8048550: fun_d (inlinfo.c:6)
==15377== de 0x8048550: fun_noninline (inlinfo.c:41)
==15377== de 0x804850E: principal (inlinfo.c:34)
==15377==
==15377== Saltul sau mutarea condiționată depinde de valorile neinițializate
==15377== la 0x8048520: fun_d (inlinfo.c:6)
==15377== prin 0x8048520: principal (inlinfo.c:35)

--read-var-info= [Mod implicit: Nu]
Când este activat, Valgrind va citi informații despre tipurile de variabile și locații din
Informații de depanare DWARF3. Acest lucru încetinește semnificativ pornirea Valgrind și îl face să utilizeze
mult mai multă memorie, dar pentru instrumentele care pot profita de ea (Memcheck,
Helgrind, DRD) poate duce la mesaje de eroare mai precise. De exemplu, aici sunt
unele erori standard emise de Memcheck:

==15363== Octeți neinițializați găsit(i) în timpul solicitării de verificare a clientului
==15363== la 0x80484A9: croak (varinfo1.c:28)
==15363== prin 0x8048544: principal (varinfo1.c:55)
==15363== Adresa 0x80497f7 are 7 octeți în interiorul simbolului de date „global_i2”
==15363==
==15363== Octeți neinițializați găsit(i) în timpul solicitării de verificare a clientului
==15363== la 0x80484A9: croak (varinfo1.c:28)
==15363== prin 0x8048550: principal (varinfo1.c:56)
==15363== Adresa 0xbea0d0cc este în stiva firului 1
==15363== în cadrul #1, creat de main (varinfo1.c:45)

Și aici sunt aceleași erori cu --read-var-info=da:

==15370== Octeți neinițializați găsit(i) în timpul solicitării de verificare a clientului
==15370== la 0x80484A9: croak (varinfo1.c:28)
==15370== prin 0x8048544: principal (varinfo1.c:55)
==15370== Locația 0x80497f7 are 0 octeți în global_i2[7],
==15370== o variabilă globală declarată la varinfo1.c:41
==15370==
==15370== Octeți neinițializați găsit(i) în timpul solicitării de verificare a clientului
==15370== la 0x80484A9: croak (varinfo1.c:28)
==15370== prin 0x8048550: principal (varinfo1.c:56)
==15370== Locația 0xbeb4a0cc are 0 octeți în interiorul local var "local"
==15370== declarat la varinfo1.c:46, în cadrul #1 al firului 1

--vgdb-poll= [Mod implicit: 5000]
Ca parte a buclei sale principale, programatorul Valgrind va sonda pentru a verifica dacă există activitate
(cum ar fi o comandă externă sau o intrare de la un gdb) trebuie să fie gestionată de gdbserver.
Acest sondaj de activitate va fi efectuat după ce ați rulat numărul dat de blocuri de bază (sau
puțin mai mult decât numărul dat de blocuri de bază). Acest sondaj este destul de ieftin, așa că
valoarea implicită este setată relativ scăzută. Este posibil să micșorați și mai mult această valoare dacă vgdb
nu poate folosi apelul de sistem ptrace pentru a întrerupe Valgrind dacă toate firele sunt (majoritatea
timp) blocat într-un apel de sistem.

--vgdb-shadow-registers=nu|da [Mod implicit: Nu]
Când este activat, gdbserver va expune registrele umbră Valgrind la GDB. Cu asta,
valoarea registrelor de umbră Valgrind poate fi examinată sau modificată folosind GDB.
Expunerea registrelor umbre funcționează numai cu GDB versiunea 7.1 sau o versiune ulterioară.

--vgdb-prefix= [Mod implicit: /tmp/vgdb-pipe]
Pentru a comunica cu gdb/vgdb, Valgrind gdbserver creează 3 fișiere (2 FIFO-uri denumite
și un fișier de memorie partajat mmap). Opțiunea de prefix controlează directorul și prefixul
pentru crearea acestor fișiere.

--run-libc-freeres= [Mod implicit: da]
Această opțiune este relevantă numai atunci când rulați Valgrind pe Linux.

Biblioteca GNU C (libc.so), care este folosit de toate programele, poate aloca memorie pentru
propriile sale utilizări. De obicei, nu se deranjează să elibereze acea memorie când programul se termină—
nu ar avea niciun rost, deoarece nucleul Linux revendică toate resursele de proces atunci când a
oricum se iese de proces, așa că ar încetini lucrurile.

Autorii glibc și-au dat seama că acest comportament provoacă verificări de scurgeri, cum ar fi Valgrind,
pentru a raporta în mod fals scurgeri în glibc, atunci când se face o verificare a scurgerilor la ieșire. Pentru a evita
aceasta, au oferit o rutină numită __libc_freeres special pentru a face lansarea glibc
toată memoria pe care a alocat-o. Prin urmare, Memcheck încearcă să fugă __libc_freeres la iesire.

Din păcate, în unele versiuni foarte vechi de glibc, __libc_freeres este suficient
bug pentru a provoca erori de segmentare. Acest lucru a fost vizibil în special pe Red Hat 7.1.
Deci această opțiune este furnizată pentru a inhiba rularea __libc_freeres. Dacă ale tale
programul pare să ruleze bine pe Valgrind, dar segfaults la ieșire, s-ar putea să găsiți asta
--run-libc-freeres=nu remediază asta, deși cu prețul unei eventuale raportări false
scurgeri de spațiu în libc.so.

--sim-hints=hint1,hint2,...
Transmiteți diverse indicii lui Valgrind, care modifică ușor comportamentul simulat în
moduri nestandard sau periculoase, posibil pentru a ajuta la simularea unor caracteristici ciudate. De
implicit, niciun indiciu nu este activat. Utilizați cu prudență! Sugestiile cunoscute în prezent sunt:

· lax-ioctls: Fiți foarte lax în ceea ce privește manipularea ioctl; singura presupunere este că dimensiunea
este corect. Nu necesită ca bufferul complet să fie inițializat la scriere.
Fără aceasta, folosirea unor drivere de dispozitiv cu un număr mare de ioctl ciudate
comenzile devin foarte obositoare.

· compatibil cu siguranțe: Activați gestionarea specială pentru anumite apeluri de sistem care pot bloca
într-un sistem de fișiere FUSE. Acest lucru poate fi necesar atunci când rulați Valgrind pe o
program cu mai multe fire care utilizează un fir pentru a gestiona un sistem de fișiere FUSE și
un alt fir pentru a accesa acel sistem de fișiere.

· activare-exterior: Activați o magie specială necesară atunci când programul rulat este
însuşi Valgrind.

· fără prefix interior: Dezactivați imprimarea unui prefix > în fața fiecărui stdout sau stderr
linia de ieșire într-un Valgrind interior condus de un Valgrind exterior. Acest lucru este util
atunci când rulați teste de regresie Valgrind într-o configurație exterioară/internă. Rețineți că
prefix > va fi întotdeauna tipărită în fața liniilor interioare de înregistrare a erorilor.

· no-nptl-pthread-stackcache: Acest indiciu este relevant doar atunci când rulați Valgrind
Linux.

Biblioteca GNU glibc pthread (libpthread.deci), care este folosit de programele pthread,
menține un cache de stive de pthread. Când un pthread se termină, memoria utilizată
pentru stiva pthread și unele structuri de date legate de stocarea locală de fire nu sunt
întotdeauna eliberat direct. Această memorie este păstrată într-un cache (până la o anumită dimensiune),
și este reutilizat dacă este început un fir nou.

Acest cache face ca instrumentul helgrind să raporteze o condiție de cursă fals pozitivă
erori pe această memorie cache, deoarece Helgrind nu înțelege glibc-ul intern
primitive de sincronizare cache. Deci, atunci când utilizați helgrind, dezactivați memoria cache
ajută la evitarea condițiilor fals pozitive de cursă, în special atunci când se utilizează fir
variabilele de stocare locală (de exemplu, variabilele care utilizează __fir calificativ).

Când utilizați instrumentul memcheck, dezactivarea memoriei cache asigură memoria utilizată de glibc
pentru a gestiona variabilele __thread este eliberat direct atunci când un fir se termină.

Notă: Valgrind dezactivează memoria cache folosind unele cunoștințe interne ale stivei glibc
implementarea cache-ului și prin examinarea informațiilor de depanare a pthread-ului
bibliotecă. Această tehnică este astfel oarecum fragilă și s-ar putea să nu funcționeze pentru toate glibc
versiuni. Acest lucru a fost testat cu succes cu diferite versiuni glibc (de ex
2.11, 2.16, 2.18) pe diverse platforme.

· uși relaxate: (Numai Solaris) Fiți foarte relaxat în ceea ce privește gestionarea apelurilor de sistem de la ușă
descriptori de fișiere uși nerecunoscute. Nu necesită un tampon complet
initializat la scriere. Fără aceasta, programele care folosesc libdoor(3LIB) funcționalitate
cu semantică complet proprietară poate raporta un număr mare de fals pozitive.

--fair-sched= [Mod implicit: Nu]
--programul echitabil opțiunea controlează mecanismul de blocare utilizat de Valgrind pentru a serializa
executia firului. Mecanismul de blocare controlează modul în care sunt programate firele,
iar setările diferite oferă compromisuri diferite între corectitudine și performanță. Pentru
mai multe detalii despre schema de serializare a firului Valgrind și impactul acesteia asupra
performanța și programarea firelor, consultați Programarea și performanța cu mai multe fire.

· Valoarea --fair-sched=da activează un planificator corect. Pe scurt, dacă sunt multiple
firele sunt gata de rulare, firele vor fi programate într-un mod round robin.
Acest mecanism nu este disponibil pe toate platformele sau versiunile Linux. Dacă nu
disponibil, folosind --fair-sched=da va face ca Valgrind să se încheie cu o eroare.

Este posibil să descoperiți că această setare îmbunătățește capacitatea de răspuns generală dacă executați un
program interactiv cu mai multe fire, de exemplu un browser web, pe Valgrind.

· Valoarea --fair-sched=încercați activează programarea corectă dacă este disponibilă pe platformă.
În caz contrar, va reveni automat la --fair-sched=nu.

· Valoarea --fair-sched=nu activează un planificator care nu garantează corectitudinea
intre fire gata de rulare, dar care in general ofera cele mai mari performante.

--kernel-variant=varianta1,varianta2,...
Gestionați apelurile de sistem și ioctl-urile care decurg din variante minore ale nucleului implicit pentru
această platformă. Acest lucru este util pentru rularea pe nuclee piratate sau cu module de kernel
care acceptă ioctls nonstandard, de exemplu. Utilizați cu prudență. Dacă nu
înțelegeți ce face această opțiune, atunci aproape sigur nu aveți nevoie de ea. În prezent
variantele cunoscute sunt:

· bproc: sprijină sys_broc apel de sistem pe x86. Acesta este pentru rularea pe BProc,
care este o variantă minoră a standardului Linux care este uneori folosită pentru construirea
clustere.

· android-no-hw-tls: unele versiuni ale emulatorului Android pentru ARM nu oferă a
se înregistrează hardware TLS (thread-local state) și Valgrind se blochează la pornire. Utilizare
această variantă pentru a selecta suportul software pentru TLS.

· android-gpu-sgx5xx: utilizați acest lucru pentru a sprijini gestionarea ioctls-ului proprietar pentru
Seria de GPU PowerVR SGX 5XX pe dispozitive Android. Eșecul de a selecta acest lucru nu
cauza probleme de stabilitate, dar poate determina Memcheck să raporteze erori false după
programul realizează ioctls specifice GPU-ului.

· android-gpu-adreno3xx: în mod similar, utilizați acest lucru pentru a sprijini gestionarea proprietății
ioctls pentru seria de GPU Qualcomm Adreno 3XX pe dispozitive Android.

--merge-recursive-frames= [Mod implicit: 0]
Unii algoritmi recursivi, de exemplu implementări echilibrate de arbore binar, creează
multe urme de stivă diferite, fiecare conținând cicluri de apeluri. Un ciclu este definit ca
două valori identice ale contorului programului separate de zero sau mai multe alte contoare de program
valorile. Valgrind poate folosi apoi multă memorie pentru a stoca toate aceste urme de stivă. Aceasta este
o utilizare slabă a memoriei având în vedere că astfel de urme de stivă conțin neinteresant repetat
apeluri recursive în loc de informații mai interesante, cum ar fi funcția care are
a inițiat apelul recursiv.

Optiunea --merge-recursive-frames= îi instruiește pe Valgrind să detecteze și să fuzioneze
cicluri de apel recursive având o dimensiune de până la rame. Când un astfel de ciclu este
detectat, Valgrind înregistrează ciclul în urmărirea stivei ca un număr unic de program.

Valoarea 0 (implicit) nu provoacă îmbinarea apelurilor recursive. O valoare de 1 va cauza
stiva urme de algoritmi recursivi simpli (de exemplu, o implementare factorială)
să fie prăbușit. O valoare de 2 va fi de obicei necesară pentru a restrânge urmele stivei produse
prin algoritmi recursivi, cum ar fi arbori binari, sortare rapidă etc. Valorile mai mari pot fi
necesare pentru algoritmi recursivi mai complexi.

Notă: apelurile recursive sunt detectate prin analiza valorilor contorului programului. Ei nu sunt
detectate analizând numele funcțiilor.

--num-transtab-sectors= [Mod implicit: 6 pentru Android platforme, 16 pentru toate alții]
Valgrind traduce și instrumentează codul mașină al programului dvs. în fragmente mici
(blocuri de bază). Traducerile sunt stocate într-un cache de traducere care este împărțit
într-un număr de secțiuni (sectoare). Dacă memoria cache este plină, sectorul care conține
cele mai vechi traduceri sunt golite și refolosite. Dacă aceste traduceri vechi sunt necesare din nou,
Valgrind trebuie să retraducă și să reinstrumenteze codul de mașină corespunzător, adică
scump. Dacă setul de lucru „instrucțiuni executate” al unui program este mare, crește
numărul de sectoare poate îmbunătăți performanța prin reducerea numărului de
necesare retraduceri. Sectoarele sunt alocate la cerere. Odată alocat, un sector poate
nu se eliberează niciodată și ocupă spațiu considerabil, în funcție de instrument și de valoare
of --avg-transtab-entry-size (aproximativ 40 MB per sector pentru Memcheck). Utilizați opțiunea
--stats=da pentru a obține informații precise despre memoria utilizată de un sector și cele
alocarea și reciclarea sectoarelor.

--avg-transtab-entry-size= [Mod implicit: 0, sens utilizare instrument prevăzut Mod implicit]
Dimensiunea medie a blocului de bază tradus. Această dimensiune medie este utilizată pentru a dimensiona
dimensiunea unui sector. Fiecare instrument oferă o valoare implicită care trebuie utilizată. Dacă această valoare implicită
este prea mic, sectoarele de traducere vor deveni pline prea repede. Dacă acest lucru implicit
valoarea este prea mare, o parte semnificativă a memoriei sectorului de traducere va fi neutilizată.
Rețineți că dimensiunea medie a unei traduceri de bloc de bază depinde de instrument și poate
depinde de opțiunile instrumentului. De exemplu, opțiunea memcheck --track-origins=da creșteri
dimensiunea traducerilor blocurilor de bază. Utilizare --avg-transtab-entry-size pentru a acorda
dimensiunea sectoarelor, fie pentru a câștiga memorie, fie pentru a evita prea multe retraduceri.

--aspace-minaddr= [Mod implicit: depinde de on il platformă]
Pentru a evita potențiale conflicte cu unele biblioteci de sistem, Valgrind nu utilizează
spațiu de adresă de mai jos --aspace-minaddr valoare, păstrând-o rezervată în cazul unei biblioteci
solicită în mod specific memorie în această regiune. Deci, se ghicește o valoare „pesimistă”.
de Valgrind în funcție de platformă. Pe Linux, în mod implicit, Valgrind evită utilizarea
primii 64 MB, chiar dacă de obicei nu există niciun conflict în această zonă completă. Poți să folosești
optiunea --aspace-minaddr pentru a beneficia de aplicația ta de memorie
mai mult din această memorie inferioară. Pe de altă parte, dacă întâmpinați un conflict, în creștere
aspace-minaddr value s-ar putea rezolva. Conflictele se vor manifesta de obicei cu
Eșecuri mmap în intervalul inferior al spațiului de adrese. Adresa furnizată trebuie să fie pagina
aliniat și trebuie să fie egal sau mai mare cu 0x1000 (4KB). Pentru a găsi valoarea implicită pe dvs
platformă, faceți ceva precum valgrind -d -d data 2>&1 | grep -i minaddr. Valori
Se știe că mai mici de 0x10000 (64KB) creează probleme pe unele distribuții.

--valgrind-stacksize= [Mod implicit: 1 MB]
Pentru fiecare thread, Valgrind are nevoie de propriul său stack „privat”. Mărimea implicită pentru acestea
stivele sunt în mare măsură dimensionate și astfel ar trebui să fie suficiente în majoritatea cazurilor. În cazul în care
dimensiunea este prea mică, Valgrind va defecta. Înainte de segfault, ar putea fi un avertisment
produs de Valgrind la apropierea limitei.

Utilizați opțiunea --valgrind-stacksize dacă se produce un astfel de avertisment (improbabil) sau
Valgrind moare din cauza unei încălcări a segmentării. Astfel de încălcări ale segmentării au fost
văzut atunci când demangling simboluri uriașe C++.

Dacă aplicația dvs. folosește multe fire și are nevoie de multă memorie, puteți obține câteva
memorie prin reducerea dimensiunii acestor stive Valgrind folosind opțiunea
--valgrind-stacksize.

--show-emwarns= [Mod implicit: Nu]
Când este activat, Valgrind va emite avertismente despre emularea CPU în anumite cazuri.
Acestea de obicei nu sunt interesante.

--require-text-symbol=:sonampatt:fnnamepatt
Când un obiect partajat al cărui nume se potrivește sonampatt este încărcat în proces,
examinați toate simbolurile text pe care le exportă. Dacă niciuna dintre acestea nu se potrivește fnnamepatt, tipăriți an
mesaj de eroare și abandonați rularea. Acest lucru face posibilă asigurarea faptului că rularea are loc
nu continuă decât dacă un anumit obiect partajat conține un anumit nume de funcție.

Ambele sonampatt si fnnamepatt poate fi scris folosind cele obișnuite ? si * wildcards. Pentru
exemplu: „:*libc.so*:foo?bar”. Puteți folosi alte caractere decât două puncte pentru a separa
cele două modele. Este important doar ca primul caracter și separatorul
caracterul sunt aceleași. De exemplu, exemplul de mai sus ar putea fi și scris
„Q*libc.so*Qfoo?bar”. Multiplu
--require-text-simbol sunt permise steaguri, caz în care obiecte partajate care sunt încărcate
în proces vor fi verificate împotriva tuturor acestora.

Scopul acestui lucru este de a sprijini utilizarea fiabilă a bibliotecilor marcate. De exemplu,
să presupunem că avem o versiune a GCC-urilor libgomp.deci care a fost marcat cu
adnotări pentru a sprijini Helgrind. Este prea ușor și confuz să încărcați greșit,
neadnotat libgomp.deci în aplicație. Deci ideea este: adăugați un simbol text în
biblioteca marcată, de exemplu adnotat_pentru_helgrind_3_6, și apoi dă steagul
--require-text-symbol=:*libgomp*so*:annotated_for_helgrind_3_6 astfel încât când libgomp.deci
este încărcat, Valgrind își scanează tabelul de simboluri, iar dacă simbolul nu este prezent, rularea este
avortat, în loc să continue în tăcere cu biblioteca nemarcată. Rețineți că dvs
ar trebui să pună întregul steag între ghilimele pentru a opri extinderea shell-urilor în sus * si ?
wildcards.

--sonam-synonyms=syn1=pattern1,syn2=pattern2,...
Când o bibliotecă partajată este încărcată, Valgrind verifică funcțiile din bibliotecă care
trebuie înlocuit sau împachetat. De exemplu, Memcheck înlocuiește toate cele legate de malloc
funcții (malloc, free, calloc, ...) cu propriile versiuni. Astfel de înlocuiri sunt
se face în mod implicit numai în bibliotecile partajate al căror nume se potrivește cu un nume predefinit
model (de ex libc.so* pe Linux). În mod implicit, nu se face nicio înlocuire pentru un static
bibliotecă legată sau pentru biblioteci alternative, cum ar fi tcmalloc. În unele cazuri,
înlocuirile permit --sonam-sinonime pentru a specifica un model de sinonim suplimentar, dând
flexibilitate în înlocuire.

În prezent, această flexibilitate este permisă numai pentru funcțiile legate de malloc, folosind
sinonimul somalloc. Acest sinonim este utilizabil pentru toate instrumentele care efectuează înlocuire standard
de funcții legate de malloc (de exemplu, memcheck, massif, drd, helgrind, exp-dhat,
exp-sgcheck).

· Bibliotecă malloc alternativă: pentru a înlocui funcțiile legate de malloc într-o bibliotecă alternativă
biblioteca cu soname mymalloclib.so, da optiunea
--sonam-synonyms=somalloc=mymalloclib.so. Un model poate fi folosit pentru a potrivi mai multe
biblioteci soname. De exemplu, --sonam-synonyms=somalloc=*tcmalloc* se va potrivi
numele tuturor variantelor bibliotecii tcmalloc (nativ, depanare, profilat, ...
variantele tcmalloc).

Notă: numele unei biblioteci partajate de elf poate fi preluat folosind readelf
utilitate.

· Înlocuirile într-o bibliotecă legată static se fac utilizând NONE model.
De exemplu, dacă vă conectați cu libtcmalloc.a, memcheck va funcționa corect atunci când dvs
da optiunea --sonam-synonyms=somalloc=NIMIC. Rețineți că un model NONE va
potrivește executabilul principal și orice bibliotecă partajată care nu are un nume.

· Pentru a rula o versiune Firefox „implicit” pentru Linux, în care JEMalloc este conectat la
executabil principal, utilizare --sonam-synonyms=somalloc=NIMIC.

DEBUGARE VALGRIND OPŢIUNI

Există, de asemenea, câteva opțiuni pentru depanarea Valgrind în sine. Nu ar trebui să le folosiți
în mersul normal al lucrurilor. Dacă doriți să vedeți lista, utilizați --help-debug opțiune.

MEMCHECK OPŢIUNI

--leak-check= [Mod implicit: rezumat]
Când este activat, căutați scurgeri de memorie când programul client se termină. Dacă este setat la
rezumat, scrie câte scurgeri au avut loc. Dacă este setat la Complet or da, fiecare scurgere individuală
va fi afișat în detaliu și/sau numărat ca o eroare, așa cum este specificat de opțiuni
--arata-tipuri-scurgeri si --erori-pentru-tipuri-scurgeri.

--leak-resolution= [Mod implicit: înalt]
Când faceți verificarea scurgerilor, determină cât de dispus este Memcheck să ia în considerare diferit
urmele înapoi să fie aceleași în scopul îmbinării mai multor scurgeri într-o singură
raport de scurgere. Când este setat la scăzut, doar primele două intrări trebuie să se potrivească. Cand med, patru
intrările trebuie să se potrivească. Cand înalt, toate intrările trebuie să se potrivească.

Pentru depanarea scurgerilor hardcore, probabil că doriți să utilizați --leak-resolution=înaltă împreună
cu --num-callers=40 sau un număr atât de mare.

Rețineți că --rezoluție-scurgere setarea nu afectează capacitatea Memcheck de a găsi
scurgeri. Schimbă doar modul în care sunt prezentate rezultatele.

--show-leak-kinds= [Mod implicit: cert, posibil]
Specifică tipurile de scurgeri de afișat în a Complet căutarea scurgerilor, într-unul dintre următoarele moduri:

· o listă separată prin virgulă cu unul sau mai multe dintre ele definit indirect posibil accesibil.

· toate pentru a specifica setul complet (toate tipurile de scurgeri). Este echivalent cu
--show-leak-kinds=definit, indirect, posibil, accesibil.

· nici unul pentru setul gol.

--errors-for-leak-kinds= [Mod implicit: cert, posibil]
Specifică tipurile de scurgeri care să fie considerate erori în a Complet căutarea scurgerilor. The is
specificat în mod similar cu --arata-tipuri-scurgeri

--leak-check-euristics= [Mod implicit: toate]
Specifică setul de euristici de verificare a scurgerilor care vor fi utilizate în timpul căutărilor de scurgeri. The
euristica controlează care indicatori interiori către un bloc îl determină să fie considerat
accesibil. Setul euristic este specificat în unul dintre următoarele moduri:

· o listă separată prin virgulă cu unul sau mai multe dintre ele stdstring lungime64 newarray
moştenire multiplă.

· toate pentru a activa setul complet de euristici. Este echivalent cu
--leak-check-heuristics=stdstring,length64,newarray,multipleinheritance.

· nici unul pentru setul gol.

Rețineți că aceste euristici depind de aspectul obiectelor produse de
compilator C++. Au fost testate cu unele versiuni gcc (de ex. 4.4 și 4.7). ei
s-ar putea să nu funcționeze corect cu alte compilatoare C++.

--show-accessible= , --show-possibly-lost=
Aceste opțiuni oferă o modalitate alternativă de a specifica tipurile de scurgeri de afișat:

· --show-reachable=nu --show-possibly-lost=da este echivalent cu
--show-leak-kinds=definit,posibil.

· --show-reachable=nu --show-possibly-lost=nu este echivalent cu
--show-leak-kinds=definit.

· --show-reachable=da este echivalent cu --show-leak-kinds=toate.

Rețineți că --show-possibly-lost=nu nu are efect dacă --show-reachable=da este specificat.

--undef-value-errors= [Mod implicit: da]
Controlează dacă Memcheck raportează utilizările erorilor de valori nedefinite. Setați acest lucru la Nu. if
nu doriți să vedeți erori de valoare nedefinită. Are și efectul secundar al vitezei
sus Memcheck oarecum.

--track-origins= [Mod implicit: Nu]
Controlează dacă Memcheck urmărește originea valorilor neinițializate. În mod implicit, acesta
nu, ceea ce înseamnă că, deși vă poate spune că o valoare neinițializată este
fiind folosit într-un mod periculos, nu vă poate spune de unde a venit valoarea neinițializată
din. Acest lucru face adesea dificilă depistarea problemei rădăcină.

Când este setat la da, Memcheck ține evidența originilor tuturor valorilor neinițializate.
Apoi, când este raportată o eroare de valoare neinițializată, Memcheck va încerca să afișeze
originea valorii. O origine poate fi unul dintre următoarele patru locuri: un bloc heap,
o alocare de stivă, o solicitare a unui client sau diverse alte surse (de exemplu, un apel către
brk).

Pentru valorile neinițializate care provin dintr-un bloc heap, Memcheck arată unde este blocul
a fost alocat. Pentru valorile neinițializate care provin dintr-o alocare de stivă, Memcheck
vă poate spune ce funcție a alocat valoarea, dar nu mai mult de atât -- de obicei
vă arată locația sursă a bretei de deschidere a funcției. Deci ar trebui
verificați cu atenție dacă toate variabilele locale ale funcției sunt inițializate corect.

Performanță generală: urmărirea originii este costisitoare. Înjumătăţeşte viteza lui Memcheck şi
crește utilizarea memoriei cu minim 100 MB și, eventual, mai mult. Cu toate acestea se poate
reduce drastic efortul necesar pentru a identifica cauza principală a neinițializate
erorile de valoare, și așa este adesea un câștig de productivitate programator, în ciuda faptului că rulează mai mult
încet.

Precizie: Memcheck urmărește originile destul de precis. Pentru a evita spațiul și timpul foarte mari
cheltuieli generale, se fac unele aproximări. Este posibil, deși puțin probabil, asta
Memcheck va raporta o origine incorectă sau nu va putea identifica nicio origine.

Rețineți că combinația --track-origins=da si --undef-value-errors=nu is
fără sens. Memcheck verifică și respinge această combinație la pornire.

--partial-loads-ok= [Mod implicit: da]
Controlează modul în care Memcheck gestionează sarcinile aliniate natural pe 32, 64, 128 și 256 de biți de la
adrese pentru care unii octeți sunt adresabili, iar alții nu. Cand da, astfel
încărcările nu produc o eroare de adresă. În schimb, octeții încărcați proveniți din ilegal
adresele sunt marcate ca neinițializate, iar cele corespunzătoare adreselor legale sunt
tratate în mod normal.

Cand Nu., încărcările de la adrese parțial nevalide sunt tratate la fel ca și încărcările de la
adrese complet nevalide: este emisă o eroare de adresă ilegală și rezultatul
octeții sunt marcați ca inițializați.

Rețineți că codul care se comportă în acest fel încalcă standardele ISO C/C++,
și ar trebui considerată ruptă. Dacă este posibil, un astfel de cod ar trebui să fie reparat.

--expensive-definedness-checks= [Mod implicit: Nu]
Controlează dacă Memcheck ar trebui să utilizeze mai precis, dar și mai scump (timp
consuming) algoritmi la verificarea definiției unei valori. Setarea implicită este
să nu faci asta și de obicei este suficient. Cu toate acestea, pentru codul extrem de optimizat
valgrind se poate plânge uneori incorect. Invocând valgrind cu
--expensive-definedness-checks=da ajută, dar are un cost de performanță. Timp de rulare
s-au observat o degradare de 25% dar costul suplimentar depinde foarte mult de
aplicație la îndemână.

--keep-stacktraces=alloc|free|alloc-and-free|alloc-then-free|niciun [Mod implicit:
alloc-and-free]
Controlează ce urme de stivă trebuie păstrată pentru blocurile mallocate și/sau eliberate.

cu aloc-atunci-liber, o urmărire a stivei este înregistrată la momentul alocării și este asociată
cu blocul. Când blocul este eliberat, se înregistrează o a doua urmă de stivă și aceasta
înlocuiește urmărirea stivei de alocare. Ca urmare, orice „utilizare după gratuit” se referă la erori
la acest bloc poate arăta doar o urmă de stivă pentru locul în care blocul a fost eliberat.

cu aloc-şi-liber, atât urmele de alocare, cât și ale stivei de dealocare pentru bloc
sunt stocate. Prin urmare, o eroare „utilizare după gratuit” le va afișa pe ambele, ceea ce poate face eroarea
mai usor de diagnosticat. Comparat cu aloc-atunci-liber, această setare crește ușor
Utilizarea memoriei de către Valgrind ca bloc conține două referințe în loc de una.

cu aloc, numai urmărirea stivei de alocare este înregistrată (și raportată). Cu gratuit,
numai traseul stivei de dealocare este înregistrată (și raportată). Aceste valori oarecum
reduceți memoria Valgrind și utilizarea procesorului. Pot fi utile în funcție de eroare
tipurile pe care le căutați și nivelul de detaliu de care aveți nevoie pentru a le analiza. Pentru
de exemplu, dacă sunteți interesat doar de erorile de scurgere de memorie, este suficient să înregistrați
urmele stivei de alocare.

cu nici unul, nu sunt înregistrate urme de stivă pentru operațiunile malloc și gratuite. Dacă ale tale
programul alocă o mulțime de blocuri și/sau alocă/eliberează din multe stive diferite
urme, acest lucru poate reduce semnificativ procesorul și/sau memoria necesară. Desigur, puțini
detaliile vor fi raportate pentru erorile legate de blocurile heap.

Rețineți că, odată ce o urmă de stivă este înregistrată, Valgrind păstrează urma de stivă în memorie
chiar dacă nu este referit de niciun bloc. Unele programe (de exemplu, recursive
algoritmi) poate genera un număr mare de urme de stivă. Dacă Valgrind folosește prea mult
memorie în astfel de circumstanțe, puteți reduce memoria necesară cu ajutorul opțiunilor
--keep-stacktraces și/sau prin utilizarea unei valori mai mici pentru opțiune --num-callers.

--freelist-vol= [Mod implicit: 20000000]
Când programul client eliberează memorie folosind gratuit (în C) sau ștergeți (C++), acea memorie
nu este disponibil imediat pentru realocare. În schimb, este marcat
inaccesibil și plasat într-o coadă de blocuri eliberate. Scopul este de a amâna atâta timp cât
posibil punctul în care memoria eliberată revine în circulație. Acest
crește șansa ca Memcheck să poată detecta accesele nevalide la blocuri
pentru o perioadă semnificativă de timp după ce au fost eliberați.

Această opțiune specifică dimensiunea totală maximă, în octeți, a blocurilor din coadă.
Valoarea implicită este de douăzeci de milioane de octeți. Mărind aceasta crește suma totală
de memorie utilizată de Memcheck, dar poate detecta utilizări nevalide ale blocurilor eliberate care ar putea
altfel rămâne nedetectat.

--freelist-big-blocks= [Mod implicit: 1000000]
Când faceți blocuri din coada de blocuri eliberate disponibile pentru realocare,
Memcheck va recircula cu prioritate blocurile cu o dimensiune mai mare sau egală cu
--freelist-big-blocks. Acest lucru asigură că eliberarea blocurilor mari (în special eliberarea
blocuri mai mari decât --freelist-vol) nu duce imediat la o recirculare a
toate (sau multe) blocuri mici din lista liberă. Cu alte cuvinte, această opțiune
crește probabilitatea de a descoperi indicatori atârnați chiar și pentru blocurile „mici”.
când blocurile mari sunt eliberate.

Setarea unei valori de 0 înseamnă că toate blocurile sunt recirculate într-o ordine FIFO.

--workaround-gcc296-bugs= [Mod implicit: Nu]
Când este activat, presupuneți că citește și scrie la o mică distanță sub indicatorul stivei
se datorează erorilor din GCC 2.96 și nu le raportează. „Distanța mică” este 256
octeți în mod implicit. Rețineți că GCC 2.96 este compilatorul implicit pe unele Linux vechi
distribuții (RedHat 7.X) și, prin urmare, poate fi necesar să utilizați această opțiune. Nu-l utilizați dacă
nu trebuie, deoarece poate cauza erori reale să fie trecute cu vederea. O alternativă mai bună
este să folosiți un GCC mai recent în care această eroare este remediată.

De asemenea, poate fi necesar să utilizați această opțiune atunci când lucrați cu GCC 3.X sau 4.X pe 32 de biți
PowerPC Linux. Acest lucru se datorează faptului că GCC generează cod care ocazional accesează mai jos
indicatorul de stivă, în special pentru conversiile în virgulă mobilă la/de la numere întregi. Acest
încalcă specificația PowerPC ELF pe 32 de biți, care nu prevede nicio prevedere
locațiile de sub indicatorul stivei să fie accesibile.

--show-mismatched-frees= [Mod implicit: da]
Când este activat, Memcheck verifică dacă blocurile heap sunt dealocate folosind o funcție care
se potrivește cu funcția de alocare. Adică se așteaptă gratuit pentru a fi folosit pentru dealocare
blocuri alocate de malloc, șterge pentru blocurile alocate de nou și șterge[] pentru
blocuri alocate de nou[]. Dacă este detectată o nepotrivire, este raportată o eroare. Aceasta este în
general important deoarece în unele medii, eliberarea cu o funcție care nu se potrivește
poate provoca accidente.

Există totuși un scenariu în care astfel de nepotriviri nu pot fi evitate. Acesta este momentul în care
utilizatorul oferă implementări ale nou/nou[] acel apel malloc şi de șterge/șterge[]
acel apel gratuit, iar aceste funcții sunt înliniate asimetric. De exemplu, imaginați-vă
acea șterge[] este aliniat dar nou[] nu este. Rezultatul este că Memcheck „vede” totul
șterge[] apeluri ca apeluri directe către gratuit, chiar și atunci când sursa programului conține nr
apeluri nepotrivite.

Acest lucru provoacă o mulțime de rapoarte de eroare confuze și irelevante.
--show-mismatched-frees=nu dezactivează aceste verificări. În general, nu este recomandabil
dezactivați-le, totuși, deoarece este posibil să pierdeți erori reale ca urmare.

--ignore-ranges=0xPP-0xQQ[,0xRR-0xSS]
Orice intervale enumerate în această opțiune (și pot fi specificate mai multe intervale, separate prin
virgulele) vor fi ignorate de verificarea adresabilității Memcheck.

--malloc-fill=
Completează blocurile alocate prin malloc, new, etc, dar nu prin calloc, cu cele specificate
octet. Acest lucru poate fi util atunci când încercați să eliminați problemele obscure de corupție a memoriei.
Zona alocată este încă considerată de Memcheck ca nedefinită -- doar această opțiune
afectează conținutul acestuia. Rețineți că --malloc-umplere nu afectează un bloc de memorie când
este folosit ca argument pentru cererile clientului VALGRIND_MEMPOOL_ALLOC sau
VALGRIND_MALLOCLIKE_BLOCK.

--free-fill=
Umple blocurile eliberate de free, delete, etc, cu valoarea de octet specificată. Acesta poate fi
util atunci când încercați să eliminați problemele obscure de corupție a memoriei. Zona eliberată este
încă considerat de către Memcheck ca nevalid pentru acces -- această opțiune îi afectează doar
continuturi. Rețineți că --umplere gratuită nu afectează un bloc de memorie atunci când este folosit ca
argument pentru solicitările clientului VALGRIND_MEMPOOL_FREE sau VALGRIND_FREELIKE_BLOCK.

CACHEGRIND OPŢIUNI

--I1= , , dimensiune>
Specificați dimensiunea, asociativitatea și dimensiunea liniei cache-ului de instrucțiuni de nivel 1.

--D1= , , dimensiune>
Specificați dimensiunea, asociativitatea și dimensiunea liniei cache-ului de date de nivel 1.

--LL= , , dimensiune>
Specificați dimensiunea, asociativitatea și dimensiunea liniei cache-ului de ultimul nivel.

--cache-sim=nu|da [da]
Activează sau dezactivează colectarea accesului la cache și contorizările ratate.

--branch-sim=nu|da [Nu]
Activează sau dezactivează colectarea de instrucțiuni de ramuri și contorizări de predicții greșite. De
implicit, aceasta este dezactivată deoarece încetinește Cachegrind cu aproximativ 25%. Rețineți că
nu poti specifica --cache-sim=nu si --branch-sim=nu împreună, pentru că asta ar pleca
Cachegrind fără informații de colectat.

--cachegrind-out-file=
Scrieți datele profilului în fișier, mai degrabă decât în ​​fișierul de ieșire implicit,
cachegrind.out. . The %p si %q specificatorii de format pot fi utilizați pentru a încorpora procesul
ID-ul și/sau conținutul unei variabile de mediu din nume, așa cum este cazul
opțiunea de bază --fișier jurnal.

CALLGRIND OPŢIUNI

--callgrind-out-file=
Scrieți datele profilului în fișier, mai degrabă decât în ​​fișierul de ieșire implicit,
callgrind.out. . The %p si %q specificatorii de format pot fi utilizați pentru a încorpora procesul
ID-ul și/sau conținutul unei variabile de mediu din nume, așa cum este cazul
opțiunea de bază --fișier jurnal. Când se fac mai multe imagini, numele fișierului este modificat
mai departe; Vezi mai jos.

--dump-line= [Mod implicit: da]
Aceasta specifică faptul că contorizarea evenimentelor trebuie efectuată la granularitatea liniei sursă.
Acest lucru permite adnotarea surselor pentru sursele care sunt compilate cu informații de depanare
(-g).

--dump-instr= [Mod implicit: Nu]
Aceasta specifică faptul că contorizarea evenimentelor trebuie efectuată la granularitatea pe instrucțiune.
Acest lucru permite adnotarea codului de asamblare. Momentan rezultatele pot fi doar afișate
de KCachegrind.

--compress-strings= [Mod implicit: da]
Această opțiune influențează formatul de ieșire al datelor de profil. Se precizează dacă
șirurile de caractere (numele fișierelor și ale funcțiilor) trebuie identificate prin numere. Acest lucru micșorează
fișier, dar îngreunează citirea oamenilor (ceea ce nu este recomandat în niciunul
caz).

--compress-pos= [Mod implicit: da]
Această opțiune influențează formatul de ieșire al datelor de profil. Se precizează dacă
pozițiile numerice sunt întotdeauna specificate ca valori absolute sau li se permite să fie
raportat la numerele anterioare. Acest lucru micșorează dimensiunea fișierului.

--combine-dumps= [Mod implicit: Nu]
Când este activat, atunci când mai multe părți de date de profil urmează să fie generate, aceste părți sunt
atașat la același fișier de ieșire. Nu se recomandă.

--dump-every-bb= [Mod implicit: 0, nu]
Eliminați datele profilului fiecare conta blocuri de bază. Dacă este necesară o descărcare, se verifică doar
când este rulat planificatorul intern al lui Valgrind. Prin urmare, setarea minimă utilă este
aproximativ 100000. Numărul este o valoare de 64 de biți pentru a face posibile perioade lungi de descărcare.

--dump-before=
Dump la intrare funcţie.

--zero-inainte=
Zero toate costurile la intrare funcţie.

--dump-after=
Pune la plecare funcţie.

--instr-atstart= [Mod implicit: da]
Specificați dacă doriți ca Callgrind să înceapă simularea și profilarea de la începutul
programul. Când este setat la nu, Callgrind nu va putea colecta nicio informație,
inclusiv apelurile, dar va avea cel mult o încetinire de aproximativ 4, care este minim
Valgrind deasupra capului. Instrumentația poate fi activată interactiv prin callgrind_control
- eu pe.

Rețineți că graficul de apel rezultat, cel mai probabil, nu va conține principal, dar va
conțin toate funcțiile executate după ce instrumentația a fost activată. Instrumentaţie
poate, de asemenea, activat/dezactivat programatic. Vedeți fișierul Callgrind include callgrind.h
pentru macro-ul pe care trebuie să o utilizați în codul sursă.

Pentru simularea cache, rezultatele vor fi mai puțin precise la pornirea instrumentelor
mai târziu în rularea programului, deoarece simulatorul începe cu un cache gol în acel moment.
Activați colecția de evenimente mai târziu pentru a face față acestei erori.

--collect-atstart= [Mod implicit: da]
Specificați dacă colectarea evenimentelor este activată la începutul rulării profilului.

Pentru a vă uita doar la părți ale programului dvs., aveți două posibilități:

1. Zero contoare de evenimente înainte de a intra în partea de program pe care doriți să o profilați și descărcați
evenimentul contorează la un fișier după părăsirea acelei părți de program.

2. Activați/dezactivați starea de colectare după cum este necesar pentru a vedea numai contoarele de evenimente care se întâmplă
în timp ce în interiorul părții de program pe care doriți să o profilați.

A doua opțiune poate fi utilizată dacă partea de program pe care doriți să o profilați se numește multe
ori. Opțiunea 1, adică crearea multor depozite nu este practică aici.

Starea de colectare poate fi comutată la intrarea și ieșirea dintr-o funcție dată cu opțiunea
--toggle-colect. Dacă utilizați această opțiune, starea de colectare ar trebui să fie dezactivată la
început. Rețineți că specificația de --toggle-colect implicit setează
--collect-state=nu.

Starea de colectare poate fi comutată și prin inserarea cererii clientului
CALLGRIND_TOGGLE_COLLECT ; la pozițiile de cod necesare.

--toggle-collect=
Comutați colectarea la intrarea/ieșirea din funcţie.

--aduna-sări= [Mod implicit: Nu]
Acesta specifică dacă trebuie colectate informații pentru sărituri (condiționale). La fel de
mai sus, callgrind_annotate momentan nu vă poate afișa datele. Trebuie să folosești
KCachegrind pentru a obține săgeți de salt în codul adnotat.

--collect-systime= [Mod implicit: Nu]
Acesta specifică dacă trebuie colectate informații pentru orele apelurilor de sistem.

--collect-bus= [Mod implicit: Nu]
Acesta specifică dacă trebuie colectat numărul de evenimente globale de magistrală executate.
Tipul de eveniment „Ge” este folosit pentru aceste evenimente.

--cache-sim= [Mod implicit: Nu]
Specificați dacă doriți să faceți simularea cache completă. În mod implicit, numai instrucțiunile sunt citite
accesele vor fi numărate ("Ir"). Cu simularea cache, contoare de evenimente suplimentare sunt
activat: Cache-ul ratat la citirile de instrucțiuni ("I1mr"/"ILmr"), accesări de citire a datelor ("Dr")
și pierderile de cache aferente ("D1mr"/"DLmr"), accesările de scriere a datelor ("Dw") și memoria cache aferentă
rateuri ("D1mw"/"DLmw"). Pentru mai multe informații, consultați Cachegrind: un cache și branch-
profiler de predicție.

--branch-sim= [Mod implicit: Nu]
Specificați dacă doriți să faceți simularea predicției ramurilor. Alte contoare de evenimente sunt
activat: numărul de ramuri condiționate executate și rateuri de predictor aferente
("Bc"/"Bcm"), sărituri indirecte executate și greșeli aferente predictorului de adresă de salt
("Bi"/"Bim").

HELGRIND OPŢIUNI

--free-is-write=nu|da [Mod implicit: Nu]
Când este activată (nu este cea implicită), Helgrind tratează eliberarea memoriei heap ca și cum ar fi
memoria a fost scrisă imediat înaintea liberului. Acest lucru expune cursele unde este memoria
referit de un fir și eliberat de altul, dar nu există niciun observabil
eveniment de sincronizare pentru a se asigura că referința are loc înaintea liberului.

Această funcționalitate este nouă în Valgrind 3.7.0 și este considerată experimentală. Este
nu este activată în mod implicit, deoarece interacțiunea sa cu alocatorii de memorie personalizați nu este
bine înțeles în prezent. Feedbackul utilizatorilor este binevenit.

--track-lockorders=nu|da [Mod implicit: da]
Când este activat (prestabilit), Helgrind efectuează verificarea coerenței ordinii de blocare. Pentru
unele programe cu erori, numărul mare de erori de ordine de blocare raportate poate deveni
enervant, mai ales dacă ești interesat doar de erorile de cursă. Prin urmare, puteți
consideră că este util să dezactivați verificarea comenzii de blocare.

--history-level=niciunul|aproximativ|plin [Mod implicit: deplin]
--history-level=plin (implicit) face ca Helgrind să colecteze suficiente informații despre
„vechi” accesează că poate produce două urme de stivă într-un raport de cursă -- ambele stiva
urmări pentru accesul curent și urmă pentru accesul mai vechi, aflat în conflict. La
limitează utilizarea memoriei, accesările „vechi” urmele stivei sunt limitate la maximum 8 intrări,
chiar dacă --num-callers valoarea este mai mare.

Colectarea unor astfel de informații este costisitoare atât în ​​viteză, cât și în memorie, în special pentru
programe care fac multe evenimente de sincronizare între fire (blocuri, deblocări etc).
Fără astfel de informații, este mai dificil de urmărit cauzele fundamentale ale raselor.
Cu toate acestea, este posibil să nu aveți nevoie de el în situațiile în care doriți doar să verificați
prezența sau absența raselor, de exemplu, atunci când se efectuează testarea de regresie a unui
program anterior fără curse.

--history-level=niciunul este extrema opusă. Determină Helgrind să nu colecteze niciunul
informații despre accesările anterioare. Acest lucru poate fi dramatic mai rapid decât
--history-level=plin.

--history-level=aprox oferă un compromis între aceste două extreme. Cauzează
Helgrind pentru a arăta o urmă completă pentru accesul ulterior și informații aproximative
referitor la accesul anterior. Această informație aproximativă constă din două stive și
accesul mai devreme este garantat că a avut loc undeva între punctele programului
notat prin cele două stive. Acest lucru nu este la fel de util ca arătarea stivei exacte pentru
acces anterior (ca --history-level=plin face), dar este mai bine decât nimic, și asta
este aproape la fel de rapid ca --history-level=niciunul.

--conflict-cache-size=N [Mod implicit: 1000000]
Acest steag are efect numai la --history-level=plin.

Informațiile despre accesele „vechi” aflate în conflict sunt stocate într-un cache de dimensiune limitată,
cu management în stil LRU. Acest lucru este necesar deoarece nu este practic să depozitați a
urmărirea stivei pentru fiecare acces la memorie făcut de program. Informații istorice
pe locații care nu au fost accesate recent este eliminată periodic, pentru a elibera spațiu în
cache.

Această opțiune controlează dimensiunea memoriei cache, în ceea ce privește numărul de memorie diferite
adresele pentru care sunt stocate informații de acces conflictuale. Daca gasesti asta
Helgrind arată erori de cursă cu un singur stivă în loc de cele două așteptate
stive, încercați să creșteți această valoare.

Valoarea minimă este 10,000, iar cea maximă este 30,000,000 (de treizeci de ori valoarea implicită
valoare). Creșterea valorii cu 1 crește necesarul de memorie a lui Helgrind cu foarte mult
aproximativ 100 de octeți, astfel încât valoarea maximă va consuma cu ușurință trei gigaocteți în plus
de memorie.

--check-stack-refs=nu|da [Mod implicit: da]
În mod implicit, Helgrind verifică toate accesările la memorie de date efectuate de programul dumneavoastră. Acest steag
vă permite să omiteți verificarea acceselor la stivele de fire (variabile locale). Acesta poate
îmbunătățește performanța, dar vine cu prețul lipsei curselor din datele alocate în stivă.

--ignore-thread-creation= [Mod implicit: Nu]
Controlează dacă toate activitățile din timpul creării firului de execuție trebuie ignorate. În mod implicit
activat numai pe Solaris. Solaris oferă un randament mai mare, paralelism și
scalabilitate decât alte sisteme de operare, cu prețul unei blocări mai fine
activitate. Aceasta înseamnă, de exemplu, că atunci când un thread este creat sub glibc, doar unul
Big lock este folosit pentru toate configurarea firelor. Solaris libc folosește mai multe blocaje cu granulație fină
iar firul de creație își reia activitățile cât mai curând posibil, plecând de exemplu
stiva și secvența de configurare TLS la firul creat. Această situație îl încurcă pe Helgrind
deoarece presupune că există o ordine falsă între creator și creat
fir; și, prin urmare, multe tipuri de condiții de cursă în aplicație nu ar fi
raportat. Pentru a preveni o astfel de ordine falsă, această opțiune de linie de comandă este setată la yes by
implicit pe Solaris. Prin urmare, toată activitatea (încărcări, magazine, solicitări ale clienților) este ignorată
pe parcursul:

· apelul pthread_create() în firul de execuție

· faza de creare a firului de execuție (stivă și configurare TLS) în firul de execuție creat

De asemenea, noua memorie alocată în timpul creării firului nu este urmărită, adică raportarea cursei
este suprimată acolo. DRD face același lucru implicit. Acest lucru este necesar deoarece
Solaris libc memorează în cache multe obiecte și le reutiliza pentru diferite fire și asta
îl încurcă pe Helgrind.

DRD OPŢIUNI

--check-stack-var= [Mod implicit: Nu]
Controlează dacă DRD detectează cursele de date pe variabilele stivei. Verificarea variabilelor stivei
este dezactivat implicit, deoarece majoritatea programelor nu partajează variabilele stivei
fire.

--exclusive-threshold= [Mod implicit: oprit]
Tipăriți un mesaj de eroare dacă orice blocare mutex sau writer a fost menținută mai mult decât timpul
specificat în milisecunde. Această opțiune permite detectarea conflictului de blocare.

--join-list-vol= [Mod implicit: 10]
Curse de date care apar între o instrucțiune la sfârșitul unui fir și altul
poate fi ratată dacă informațiile de acces la memorie sunt eliminate imediat după ce un fir de execuție a făcut
fost alaturat. Această opțiune vă permite să specificați câte fire de execuție unite de memorie
informațiile de acces ar trebui păstrate.

--first-race-only= [Mod implicit: Nu]
Dacă se raportează doar prima cursă de date care a fost detectată într-o locație de memorie
sau toate cursele de date care au fost detectate într-o locație de memorie.

--free-is-write= [Mod implicit: Nu]
Dacă să raportezi cursele între accesarea memoriei și eliberarea memoriei. Activarea acestui lucru
opțiunea poate determina DRD să ruleze puțin mai lent. Note:

· Nu activați această opțiune când utilizați alocatoare de memorie personalizate care utilizează
VG_USERREQ__MALLOCLIKE_BLOCK și VG_USERREQ__FREELIKE_BLOCK deoarece asta ar
rezultă fals pozitive.

· Nu activați această opțiune când utilizați obiecte numărate cu referințe, deoarece așa va fi
rezultă fals pozitive, chiar și atunci când acel cod a fost adnotat corespunzător
ANNOTATE_HAPPENS_BEFORE și ANNOTATE_HAPPENS_AFTER. Vezi, de exemplu, ieșirea lui
următoarea comandă pentru un exemplu: valgrind --tool=drd --free-is-write=yes
drd/tests/annotate_smart_pointer.

--report-signal-unlocked= [Mod implicit: da]
Dacă să raportezi apelurile către pthread_cond_signal si pthread_cond_broadcast unde
mutex asociat semnalului prin pthread_cond_wait or
pthread_cond_timed_waitnu este blocat în momentul trimiterii semnalului. Trimiterea unui semnal
fără a ține un blocare pe mutexul asociat este o eroare obișnuită de programare care poate
provoacă condiții de rasă subtile și comportament imprevizibil. Există unele neobișnuite
modele de sincronizare totuși în cazul în care este sigur să trimiteți un semnal fără a ține apăsat a
blocați mutex-ul asociat.

--segment-merging= [Mod implicit: da]
Controlează îmbinarea segmentelor. Fuziunea segmentelor este un algoritm care limitează utilizarea memoriei
algoritm de detectare a cursei de date. Dezactivarea îmbinării segmentelor poate îmbunătăți acuratețea
așa-numitele „alte segmente” afișate în rapoartele de cursă, dar pot declanșa și o ieșire
de eroare de memorie.

--segment-merging-interval= [Mod implicit: 10]
Efectuați îmbinarea segmentelor numai după ce numărul specificat de noi segmente au fost
creată. Aceasta este o opțiune de configurare avansată care vă permite să alegeți
minimizați utilizarea memoriei DRD prin alegerea unei valori scăzute sau pentru a lăsa DRD să ruleze mai repede
alegând o valoare ceva mai mare. Valoarea optimă pentru acest parametru depinde de
programul analizat. Valoarea implicită funcționează bine pentru majoritatea programelor.

--shared-threshold= [Mod implicit: oprit]
Tipăriți un mesaj de eroare dacă blocarea cititorului a fost menținută mai mult decât timpul specificat
(în milisecunde). Această opțiune permite detectarea conflictului de blocare.

--show-confl-seg= [Mod implicit: da]
Afișați segmente conflictuale în rapoartele de cursă. Deoarece aceste informații pot ajuta la găsirea
cauza unei curse de date, această opțiune este activată implicit. Dezactivarea acestei opțiuni face
ieșirea DRD mai compactă.

--show-stack-usage= [Mod implicit: Nu]
Utilizarea stivei de imprimare la momentul ieșirii firului. Când un program creează un număr mare de
fire de execuție, devine important să se limiteze cantitatea de memorie virtuală alocată
stive de fire. Această opțiune face posibilă observarea câtă memorie stivă a fost
utilizat de fiecare fir al programului client. Notă: instrumentul DRD însuși alocă o parte
date temporare pe stiva de fire client. Spațiul necesar pentru aceste date temporare
trebuie să fie alocat de programul client atunci când alocă memorie stivă, dar nu este
incluse în utilizarea stivei raportată de DRD.

--ignore-thread-creation= [Mod implicit: Nu]
Controlează dacă toate activitățile din timpul creării firului de execuție trebuie ignorate. În mod implicit
activat numai pe Solaris. Solaris oferă un randament mai mare, paralelism și
scalabilitate decât alte sisteme de operare, cu prețul unei blocări mai fine
activitate. Aceasta înseamnă, de exemplu, că atunci când un thread este creat sub glibc, doar unul
Big lock este folosit pentru toate configurarea firelor. Solaris libc folosește mai multe blocaje cu granulație fină
iar firul de creație își reia activitățile cât mai curând posibil, plecând de exemplu
stiva și secvența de configurare TLS la firul creat. Această situație derutează DRD așa cum este
presupune că există o ordine falsă între creator și firul creat; și
prin urmare, multe tipuri de condiții de cursă din aplicație nu ar fi raportate. La
pentru a preveni o astfel de ordine falsă, această opțiune de linie de comandă este setată implicit la da
Solaris. Prin urmare, toată activitatea (încărcări, magazine, solicitări ale clienților) este ignorată în timpul:

· apelul pthread_create() în firul de execuție

· faza de creare a firului de execuție (stivă și configurare TLS) în firul de execuție creat

--trace-addr= [Mod implicit: nici unul]
Urmăriți toată activitatea de încărcare și stocare pentru adresa specificată. Această opțiune poate fi
specificat de mai multe ori.

--ptrace-addr= [Mod implicit: nici unul]
Urmăriți toată activitatea de încărcare și stocare pentru adresa specificată și continuați chiar și să faceți asta
după ce memoria de la acea adresă a fost eliberată și realocată.

--trace-alloc= [Mod implicit: Nu]
Urmăriți toate alocările și dealocările de memorie. Poate produce o cantitate mare de ieșire.

--trace-barrier= [Mod implicit: Nu]
Urmăriți toate activitățile de barieră.

--trace-cond= [Mod implicit: Nu]
Urmăriți toate activitățile variabilelor de condiție.

--trace-fork-join= [Mod implicit: Nu]
Urmăriți toate evenimentele de creare și de terminare a firului de execuție.

--trace-hb= [Mod implicit: Nu]
Urmăriți execuția ANNOTATE_HAPPENS_BEFORE(), ANNOTATE_HAPPENS_AFTER() și
ANNOTATE_HAPPENS_DONE() solicitări ale clientului.

--trace-mutex= [Mod implicit: Nu]
Urmăriți toată activitatea mutex.

--trace-rwlock= [Mod implicit: Nu]
Urmăriți toată activitatea de blocare cititor-scriitor.

--urmă-semafor= [Mod implicit: Nu]
Urmăriți toată activitatea semaforului.

MASIV OPŢIUNI

--heap= [Mod implicit: da]
Specifică dacă trebuie făcută profilarea heap.

--heap-admin= [Mod implicit: 8]
Dacă profilarea heap este activată, oferă numărul de octeți administrativi pe bloc
utilizare. Aceasta ar trebui să fie o estimare a mediei, deoarece aceasta poate varia. De exemplu, cel
alocatorul folosit de glibc pe Linux necesită între 4 și 15 octeți pe bloc,
în funcţie de diverşi factori. Acest alocător necesită, de asemenea, spațiu de administrare pentru eliberare
blocuri, dar Massif nu poate explica acest lucru.

--stive= [Mod implicit: Nu]
Specifică dacă trebuie făcută profilarea stivei. Această opțiune încetinește Massif
foarte mult și este dezactivat implicit. Rețineți că Massif presupune că stiva principală are
dimensiunea zero la pornire. Acest lucru nu este adevărat, dar este dificil să faci altfel cu exactitate.
În plus, începerea de la zero indică mai bine dimensiunea părții stivei principale
asupra căreia un program de utilizator deține de fapt controlul.

--pages-as-heap= [Mod implicit: Nu]
Spune lui Massif să profileze memoria la nivel de pagină, mai degrabă decât la blocul malloc
nivel. Vezi mai sus pentru detalii.

--adâncime= [Mod implicit: 30]
Adâncimea maximă a arborilor de alocare înregistrată pentru instantanee detaliate. Creșterea acestuia
va face Massif să ruleze ceva mai lent, să folosească mai multă memorie și să producă o ieșire mai mare
fișiere.

--alloc-fn=
Funcțiile specificate cu această opțiune vor fi tratate ca și cum ar fi o grămadă
funcţie de alocare precum malloc. Acest lucru este util pentru funcțiile care sunt wrapper-uri
malloc or nou, care poate umple arborele de alocare cu informații neinteresante.
Această opțiune poate fi specificată de mai multe ori pe linia de comandă, pentru a numi mai multe
funcții.

Rețineți că funcția numită va fi tratată în acest fel numai dacă este intrarea de sus în a
stack trace sau chiar sub o altă funcție tratată în acest fel. De exemplu, dacă ai
o functie malloc1 care înfășoară malloc și malloc2 care înfășoară malloc1, doar precizând
--alloc-fn=malloc2 nu va avea niciun efect. Trebuie să specificați --alloc-fn=malloc1 as
bine. Acest lucru este puțin incomod, dar motivul este că verificarea pentru alocare
funcțiile este lentă și economisește mult timp dacă Massif nu poate să se uite prin
stiva intrările de urmărire de îndată ce găsește una care nu se potrivește, mai degrabă decât trebuie
continuați prin toate înregistrările.

Rețineți că numele C++ sunt demangle. De asemenea, rețineți că numele C++ supraîncărcate trebuie scrise
în întregime. Pot fi necesare ghilimele simple pentru a preveni ruperea cochiliei.
De exemplu:

--alloc-fn='operator nou (nesemnat, std::nothrow_t const&)'

--ignore-fn=
Orice alocare de heap directă (adică un apel către malloc, nou, etc, sau un apel la o funcție
numit de un --alloc-fn opțiune) care apare într-o funcție specificată de această opțiune va
fi ignorat. Acest lucru este util mai ales în scopuri de testare. Această opțiune poate fi specificată
de mai multe ori pe linia de comandă, pentru a denumi mai multe funcții.

Orice realloc a unui bloc ignorat va fi, de asemenea, ignorat, chiar dacă realloc apelul face
nu apar într-o funcție ignorată. Acest lucru evită posibilitatea unor dimensiuni negative ale heap-ului
dacă blocurile ignorate sunt reduse cu realloc.

Regulile pentru scrierea numelor de funcții C++ sunt aceleași ca și pentru --alloc-fn de mai sus.

--prag= [Mod implicit: 1.0]
Pragul de semnificație pentru alocările heap, ca procent din dimensiunea totală a memoriei.
Intrările din arborele de alocare care reprezintă mai puțin decât aceasta vor fi agregate. Rețineți că
aceasta ar trebui specificată în tandem cu opțiunea cu același nume a ms_print.

--peak-inacuracy= [Mod implicit: 1.0]
Massif nu înregistrează neapărat vârful real de alocare globală a memoriei; de
implicit, înregistrează un vârf numai atunci când dimensiunea globală de alocare a memoriei depășește
vârful anterior cu cel puțin 1.0%. Acest lucru se datorează faptului că pot exista multe alocări locale
vârfuri de-a lungul drumului, iar realizarea unui instantaneu detaliat pentru fiecare ar fi costisitoare
și risipitoare, deoarece toate, cu excepția unuia dintre ele, vor fi aruncate ulterior. Această inexactitate poate fi
modificat (chiar la 0.0%) prin această opțiune, dar Massif va rula drastic mai lent pe măsură ce
numărul se apropie de zero.

--time-unitate= [Mod implicit: i]
Unitatea de timp utilizată pentru profilare. Există trei posibilități: instrucțiuni
executat (i), ceea ce este bun pentru majoritatea cazurilor; timp real (ceas de perete) (ms, de ex
milisecunde), care este uneori util; și octeți alocați/dealocați pe heap
și/sau stiva (B), care este utilă pentru programe de scurtă durată și pentru testare
scopuri, deoarece este cel mai reproductibil pe diferite mașini.

--frecvența-detaliată= [Mod implicit: 10]
Frecvența instantaneelor ​​detaliate. Cu --frecvența-detaliată=1, fiecare instantaneu este detaliat.

--max-snapshots= [Mod implicit: 100]
Numărul maxim de instantanee înregistrate. Dacă este setată la N, pentru toate programele, cu excepția foarte
cele de scurtă durată, numărul final de instantanee va fi între N/2 și N.

--massif-out-file= [Mod implicit: masiv.out.%p]
Scrieți datele profilului în fișier, mai degrabă decât în ​​fișierul de ieșire implicit,
masiv.out. . The %p si %q specificatorii de format pot fi utilizați pentru a încorpora ID-ul procesului
și/sau conținutul unei variabile de mediu din nume, așa cum este cazul
opțiunea de bază --fișier jurnal.

SGCHECK OPŢIUNI

În prezent, nu există opțiuni de linie de comandă specifice SGCheck.

BBV OPŢIUNI

--bb-out-file= [Mod implicit: bb.out.%p]
Această opțiune selectează numele fișierului vectorial bloc de bază. The %p si %q format
specificatorii pot fi utilizați pentru a încorpora ID-ul procesului și/sau conținutul unui mediu
variabilă în nume, așa cum este cazul opțiunii de bază --fișier jurnal.

--pc-out-file= [Mod implicit: pc.out.%p]
Această opțiune selectează numele fișierului PC. Acest fișier conține adresele contorului programului
și informații despre numele funcției pentru diferitele blocuri de bază. Aceasta poate fi folosită împreună
cu fișierul vector de bloc de bază pentru a avansa rapid prin nume de funcții în loc de doar
instrucțiunile contează. The %p si %q specificatorii de format pot fi utilizați pentru a încorpora procesul
ID-ul și/sau conținutul unei variabile de mediu din nume, așa cum este cazul
opțiunea de bază --fișier jurnal.

--interval-size= [Mod implicit: 100000000]
Această opțiune selectează dimensiunea intervalului de utilizat. Valoarea implicită este 100 de milioane
instrucțiuni, care este o valoare folosită în mod obișnuit. Se pot folosi si alte dimensiuni; mai mica
intervalele pot ajuta programele cu faze mai fine. Cu toate acestea, dimensiunea intervalului este mai mică
poate duce la probleme de acuratețe din cauza efectelor de încălzire (La redirecționarea rapidă a diferitelor
caracteristicile arhitecturale vor fi neinițializate și va dura un anumit număr de
instrucțiuni înainte de a se „încălzi” la starea unei simulari complete ar fi fără
redirecționarea rapidă. Dimensiunile mari ale intervalelor tind să atenueze acest lucru.)

--instr-count-only [Mod implicit: Nu]
Această opțiune îi spune instrumentului să afișeze numai totalurile numărului de instrucțiuni și nu
generați fișierul vector bloc de bază real. Acest lucru este util pentru depanare și pentru
colectarea informațiilor privind numărul de instrucțiuni fără a genera vectorul bloc de bază mare
fișiere.

LACHEU OPŢIUNI

--bazic-counts= [Mod implicit: da]
Când este activat, Lackey tipărește următoarele statistici și informații despre
executarea programului client:

1. Numărul de apeluri către funcția specificat de --fnname opțiunea (implicit
este principala). Dacă programului i s-au eliminat simbolurile, numărul va fi întotdeauna
zero.

2. Numărul de ramuri condiționate întâlnite și numărul și proporția de
cele luate.

3. Numărul de superblocuri introduse și completate de program. Rețineți că din cauza
optimizările efectuate de JIT, aceasta nu este deloc o valoare exactă.

4. Numărul de instrucțiuni pentru invitați (x86, amd64, ppc etc.) și declarații IR
executat. IR este reprezentarea intermediară asemănătoare RISC a lui Valgrind prin care toate
instrumentarea se face.

5. Raporturi între unele dintre aceste numărări.

6. Codul de ieșire al programului client.

--detailed-counts= [Mod implicit: Nu]
Când este activat, Lackey tipărește un tabel care conține numărul de încărcări, depozite și ALU
operațiuni, diferențiate prin tipurile lor IR. Tipurile IR sunt identificate prin IR-ul lor
nume ("I1", "I8", ... "I128", "F32", "F64" și "V128").

--trace-mem= [Mod implicit: Nu]
Când este activat, Lackey tipărește dimensiunea și adresa aproape fiecărui acces la memorie realizat de
programul. Consultați comentariile din partea de sus a fișierului lackey/lk_main.c pentru detalii
despre formatul de ieșire, cum funcționează și inexactitățile în urmărirea adresei. Notă
că această opțiune produce cantități imense de producție.

--trace-superblocuri= [Mod implicit: Nu]
Când este activat, Lackey tipărește adresa fiecărui superbloc (o singură intrare,
ieșire multiplă, bucată liniară de cod) executată de program. Acesta este în primul rând de
interes pentru dezvoltatorii Valgrind. Vedeți comentariile din partea de sus a fișierului
lackey/lk_main.c pentru detalii despre formatul de ieșire. Rețineți că această opțiune produce
cantități mari de producție.

--fnname= [Mod implicit: principal]
Schimbă funcția pentru care sunt numărate apelurile când --basic-counts=da este specificat.

Utilizați valgrind online folosind serviciile onworks.net