memusage(1)

NAMN

memusage – profilera ett programs minnesanvändning

SYNOPSIS

memusage [option ...] program [programoption ...]

BESKRIVNING

memusage är ett bash(1)-skript som profilerar minnesanvändningen för programmet program.

Det fungerar genom att förinläsa biblioteket libmemusage.so i anroparens miljö via miljövariabeln LD_PRELOAD. Se även ld.so(8).

Biblioteket libmemusage.so spårar minnesallokering genom att fånga upp anrop till:

• malloc(3)
• calloc(3)
• free(3)
• realloc(3)

Valfritt kan även anrop till följande systemanrop fångas upp:

• mmap(2)
• mremap(2)
• munmap(2)

memusage kan skriva ut de insamlade uppgifterna i textform. Det kan också använda memusagestat(1) för att skapa en PNG-fil med en grafisk representation av de insamlade uppgifterna. Se optionen -p.

SAMMANFATTNING AV MINNESANVÄNDNING

Raden Memory usage summary som skrivs ut av memusage innehåller tre fält:

heap total

Summan av size-argumenten för alla malloc(3)-anrop, produkterna av argumenten n * size för alla calloc(3)-anrop, samt summan av length-argumenten för alla mmap(2)-anrop.

För realloc(3) och mremap(2) gäller att om den nya storleken på en allokering är större än den tidigare storleken, läggs skillnaden mellan ny och gammal storlek till.

heap peak

Det största värdet bland alla size-argument till malloc(3), alla produkter av n * size för calloc(3), alla size-argument till realloc(3), alla length-argument till mmap(2) och alla new_size-argument till mremap(2).

stack peak

Innan det första anropet till någon övervakad funktion sparas stackpekarens adress som basstackpekare. Efter varje funktionsanrop läses den aktuella stackpekarens adress, och skillnaden mot basstackpekaren beräknas. Det största av dessa värden blir stackens toppvärde.

Direkt efter denna sammanfattningsrad visas en tabell med:

• antal anrop
• totalt allokerat eller frigjort minne
• antal misslyckade anrop

för varje uppfångad funktion.

För realloc(3) och mremap(2) finns ett extra fält, nomove, som visar reallokeringar som ändrade adressen för ett block. Fältet dec visar reallokeringar som minskade blockets storlek.

För realloc(3) visar fältet free reallokeringar som gjorde att ett block frigjordes, det vill säga när den nya storleken var 0.

Värdet realloc/total memory i tabellen från memusage speglar inte fall där realloc(3) används för att reallokera ett minnesblock till en mindre storlek än tidigare. Detta kan göra att summan av alla fält för total memory, utom free, blir större än fältet free/total memory.

HISTOGRAM FÖR BLOCKSTORLEKAR

Avsnittet Histogram for block sizes visar en uppdelning av minnesallokeringar i olika storleksintervall.

Detta gör det lättare att se vilka blockstorlekar programmet allokerar ofta.

OPTIONER

-n namn

--progname= namn

Namn på programfilen som ska profileras.

-p fil

--png= fil

Skapa en PNG-grafik och spara den i fil.

-d fil

--data= fil

Skapa en binär datafil och spara den i fil.

-u

--unbuffered

Buffra inte utmatningen.

-b storlek

--buffer= storlek

Samla storlek poster innan de skrivs ut.

--no-timer

Inaktivera timerbaserad sampling av stackpekarvärdet via SIGPROF.

-m

--mmap

Spåra även mmap(2), mremap(2) och munmap(2).

-?

--help

Visa hjälptext och avsluta.

--usage

Visa ett kort användningsmeddelande och avsluta.

-V

--version

Visa versionsinformation och avsluta.

OPTIONER FÖR GRAFISK UTMATNING

Följande optioner gäller endast när grafisk utmatning skapas:

-t

--time-based

Använd tid, i stället för antal funktionsanrop, som skala för X-axeln.

-T

--total

Rita även en graf över total minnesanvändning.

--title= namn

Använd namn som grafens titel.

-x storlek

--x-size= storlek

Gör grafen storlek pixlar bred.

-y storlek

--y-size= storlek

Gör grafen storlek pixlar hög.

AVSLUTNINGSSTATUS

Avslutningsstatusen för memusage är samma som avslutningsstatusen för det profilerade programmet.

FEL

Fel kan rapporteras via GNU C Librarys felrapporteringssida:

http://www.gnu.org/software/libc/bugs.html

EXEMPEL

Följande exempel visar ett enkelt program som reallokerar ett minnesblock i cykler som först växer till en topp och därefter minskar tillbaka till noll.

Efter kompilering av programmet kan följande kommandon köras för att samla data och skapa en graf:

memusage --data=memusage.dat ./a.out
memusagestat memusage.dat memusage.png

Exempel på textutmatning:

Memory usage summary: heap total: 45200, heap peak: 6440, stack peak: 224
        total calls  total memory  failed calls
 malloc|         1           400             0
realloc|        40         44800             0  (nomove:40, dec:19, free:0)
 calloc|         0             0             0
   free|         1           440

Grafen över programmets minnesanvändning sparas i filen:

memusage.png

PROGRAMKÄLLA

#include <stdio.h>
#include <stdlib.h>

#define CYCLES 20

int
main(int argc, char *argv[])
{
    int i, j;
    size_t size;
    int *p;

    size = sizeof(*p) * 100;
    printf("malloc: %zu\n", size);
    p = malloc(size);

    for (i = 0; i < CYCLES; i++) {
        if (i < CYCLES / 2)
            j = i;
        else
            j--;

        size = sizeof(*p) * (j * 50 + 110);
        printf("realloc: %zu\n", size);
        p = realloc(p, size);

        size = sizeof(*p) * ((j + 1) * 150 + 110);
        printf("realloc: %zu\n", size);
        p = realloc(p, size);
    }

    free(p);
    exit(EXIT_SUCCESS);
}

PRAKTISK ANVÄNDNING

memusage är användbart när man vill undersöka hur ett program använder heap och stack under körning.

Vanliga användningsfall:

• hitta stora eller oväntade minnesallokeringar
• jämföra minnesanvändning mellan olika versioner av ett program
• skapa en graf över minnesanvändningen
• se hur många anrop som görs till malloc, calloc, realloc och free
• analysera program som använder mmap

Exempel med textutmatning:

memusage ./program

Exempel med spårning av mmap-anrop:

memusage --mmap ./program

Exempel med grafisk utmatning:

memusage --data=memusage.dat ./program
memusagestat memusage.dat memusage.png

BEGRÄNSNINGAR

Eftersom memusage bygger på LD_PRELOAD fungerar det främst med dynamiskt länkade program där de relevanta funktionerna kan fångas upp.

Program som är statiskt länkade, använder egna allokerare eller kringgår standardfunktionerna kan ge ofullständiga eller missvisande resultat.

SE ÄVEN

• memusagestat(1)
• mtrace(1)
• ld.so(8)
• malloc(3)
• calloc(3)
• free(3)
• realloc(3)
• mmap(2)
• mremap(2)
• munmap(2)

KOLOFON

Denna sida är en del av projektet man-pages, dokumentationen för Linux-kärnans och C-bibliotekets användarrymdsgränssnitt.

Information om projektet finns på:

https://www.kernel.org/doc/man-pages/

Felrapporter för denna manualsida hanteras enligt informationen i projektets bidragsdokumentation:

https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/tree/CONTRIBUTING

Denna sida hämtades från tarbollen:

man-pages-6.18.tar.gz

Tarbollen hämtades från:

https://mirrors.edge.kernel.org/pub/linux/docs/man-pages/

Den hämtades den 24 maj 2026.

Om du upptäcker renderingsproblem i HTML-versionen av sidan, eller anser att det finns en bättre eller mer uppdaterad källa för sidan, eller har rättelser eller förbättringar av informationen i denna kolofon, kan du skicka e-post till:

man-pages@man7.org

KORT SAMMANFATTNING

memusage profilerar minnesanvändningen för ett program.

Grundform:

memusage ./program

Skapa datafil:

memusage --data=memusage.dat ./program

Skapa PNG-graf från datafil:

memusagestat memusage.dat memusage.png

Spåra även mmap-relaterade anrop:

memusage --mmap ./program

memusage är användbart för att se hur mycket heap och stack ett program använder och vilka minnesallokeringsfunktioner som anropas.

Sidslut

Orginalhemsidan på Engelska https://man7.org/linux/man-pages/man1/memusage.1.html Det här är en maskinöversättning av Linux man sidor till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på https://www.linux.se/kontaka-linux-se/

Tack till Datorhjälp hemma som har sponsrat Linux.se med webbhotell.