Läsa rapporter

En Valgrind-rapport består av tre delar:

• process-ID-prefixet på varje rad
• Ett eller flera felblock allteftersom de uppstår
• En avslutande HEAP and LEAK SUMMARY när programmet avslutas

När du lär dig läsa varje del förvandlas en vägg av text till en exakt att-göra-lista.

Varje Valgrind-rad börjar med ==PID==, till exempel ==12345==.

Detta är process-ID:t, inte en del av programmets utskrift. Det gör att du kan skilja Valgrinds meddelanden från programmets printf när båda visas i samma terminal.

Här är ett verkligt block för en ogiltig skrivning:

==12345== Invalid write of size 4
==12345== at 0x4005A1: main (prog.c:6)
==12345== Address 0x520304c is 0 bytes after a block of size 20 alloc'd
==12345== at 0x4838B40: malloc
==12345== by 0x40058E: main (prog.c:5)

Den första raden anger feltyp och storlek: 'Invalid write of size 4'.

Storlek 4 betyder en åtkomst på 4 byte, vanligtvis en int. Den här enda raden talar om vilken typ av fel du kan förvänta dig innan du läser vidare.

Raden med at är den innersta stackramen, där felet inträffade. Varje rad med by anger en anropare, ett steg upp.

Läs uppifrån och ned, från djupast till ytligast. Den första ramen med din filnamn är nästan alltid platsen för buggen.

Raden Address ... anger åtkomsten i förhållande till ett känt block:

• 0 bytes after a block of size 20 alloc'd — spill precis efter slutet
• 4 bytes inside a block of size 4 free'd — användning efter frigöring
• on thread 1's stack — en stackåtkomst

Den visar även var blocket allokerades eller frigjordes.

Vid avslutningen får du en sammanställning av allokeringarna:

==12345== HEAP SUMMARY:
==12345== in use at exit: 20 bytes in 1 blocks
==12345== total heap usage: 3 allocs, 2 frees, 1,044 bytes allocated

'in use at exit' större än noll betyder att något inte frigjordes.

Under heap-sammanställningen grupperas minnesläckorna:

definitely lost: 20 bytes in 1 blocks
indirectly lost: 0 bytes in 0 blocks
possibly lost: 0 bytes in 0 blocks
still reachable: 0 bytes in 0 blocks

Lägg till --leak-check=full för att koppla ett stackspår till varje förlorat block.

Den allra sista raden räknar samman allt:

ERROR SUMMARY: 2 errors from 2 contexts

En 'context' är en unik felplats. Om en felaktig rad körs en miljon gånger i en loop är det fortfarande en enda kontext. Målet är 0 errors from 0 contexts.

Arbeta metodiskt igenom rapporten:

• Åtgärda fel med ogiltig åtkomst först; de orsakar korruption
• Åtgärda sedan fel med oinitierade värden
• Åtgärda därefter läckor som är definitely och indirectly lost
• Kör om efter varje åtgärd; en grundorsak löser ofta flera rapporterade fel

Vissa fel kommer från bibliotek som du inte kan åtgärda, till exempel C-körmiljön eller en grafikdrivrutin. Generera en suppression-fil för att tysta dessa fel utan att dölja dina egna buggar.

--gen-suppressions=all skriver ut färdiga suppression-poster som du sparar och skickar tillbaka med --suppressions=file.

Nu kan du läsa Valgrind-rapporter från början till slut:

• ==PID== står som prefix på Valgrind-rader och skiljer dem från programmets utskrift
• Varje felblock anger typ, storlek, stackspårning och adressinformation
• HEAP/LEAK-sammanställningarna redovisar allokeringar och förlorat minne
• ERROR SUMMARY räknar unika kontexter; sikta på noll

Prioritera åtkomstfel, sedan läckor, och kör om efter hand.