NAVN

sprof - læs og vis delte objektprofileringsdata

SYNOPSIS

sprof [tilvalg]... delt-objekt-sti [profil-data-sti]

BESKRIVELSE

Kommandoen sprof viser en profileringsoversigt for det delte objekt (delt bibliotek) angivet som dets første kommandolinjeargument. Profileringsoversigten oprettes via tidligere oprettede profileringsdata i det (valgfrie) andet kommandolinjeargument. Hvis profileringsdatastinavnet udelades, så vil sprof forsøge at udlede denne via soname for det delte objekt, kiggende efter en fil med navnet <soname>.profile i den nuværende mappe.

TILVALG

De følgende kommandolinjetilvalg angiver profilresultatet:

--call-pairs

-c

Vis en liste af par for kaldstier for grænsefladerne eksporteret af det delte objekt, sammen med antallet af gange hver sti anvendes.

--flat-profile

-p

Opret en flad profil for alle funktonerne i det overvågede objekt, med antal og krydser.

--graph

-q

Opret en kaldgraf.

Hvis ingen af de ovenstående tilvalg er angivet, så er standardopførelsen at vise en flad profil og en kaldgraf.

De følgende yderligere tilvalg for kommandolinjen er tilgængelige:

--help

-?

Vis en summering af tilvalg for kommandolinjen samt argumenter og afslut.

--usage

Vis en kort hjælpetekst og afslut.

--version

-V

Vis programversionen og afslut.

STANDARDER

GNU.

EKSEMPLER

Det følgende eksempel viser brugen af sprof. Eksemplet består af et hovedprogram, der kalder to funktioner i et delt objekt. Først koden for hovedprogrammet:

$ cat prog.c
#include <stdlib.h>
void x1(void);
void x2(void);
int
main(int argc, char *argv[])
{
    x1();
    x2();
    exit(EXIT_SUCCESS);
}

Funktionerne x1() og x2() er defineret i den følgende kildefil, der bruges til at konstruere det delte objekt:

$ cat libdemo.c
#include <unistd.h>
void
consumeCpu1(int lim)
{
    for (unsigned int j = 0; j < lim; j++)
	getppid();
}
void
x1(void) {
    for (unsigned int j = 0; j < 100; j++)
	consumeCpu1(200000);
}
void
consumeCpu2(int lim)
{
    for (unsigned int j = 0; j < lim; j++)
	getppid();
}
void
x2(void)
{
    for (unsigned int j = 0; j < 1000; j++)
	consumeCpu2(10000);
}

Nu konstruerer vi det delte objekt med det reelle navn libdemo.so.1.0.1 og soname libdemo.so.1:

$ cc -g -fPIC -shared -Wl,-soname,libdemo.so.1 \
        -o libdemo.so.1.0.1 libdemo.c

Så konstruerer vi symbolske henvisninger for biblioteket soname og henvisingsnavnet for biblioteket:

$ ln -sf libdemo.so.1.0.1 libdemo.so.1
$ ln -sf libdemo.so.1 libdemo.so

Efterfølgende kompilerer vi hovedprogrammet, henviser det til det delte objekt og viser de dynamiske afhængigheder for programmet:

$ cc -g -o prog prog.c -L. -ldemo
$ ldd prog
	linux-vdso.so.1 =>  (0x00007fff86d66000)
	libdemo.so.1 => not found
	libc.so.6 => /lib64/libc.so.6 (0x00007fd4dc138000)
	/lib64/ld-linux-x86-64.so.2 (0x00007fd4dc51f000)

For at indhente profileringsinformation for det delte objekt definerer vi miljøvariablen LD_PROFILE med soname for biblioteket:

$ export LD_PROFILE=libdemo.so.1

Så definerer vi miljøvariablen LD_PROFILE_OUTPUT med stinavnet for mappen, hvor profilresultatet skal skrives, og opretter den mappe, hvis den ikke allerede findes:

$ export LD_PROFILE_OUTPUT=$(pwd)/prof_data
$ mkdir -p $LD_PROFILE_OUTPUT

LD_PROFILE gør at profileringsresultatet tilføjes til resultatfilen, hvis den allerede findes, så vi sikrer, at der ikke er allerede er præprofileringsdata:

$ rm -f $LD_PROFILE_OUTPUT/$LD_PROFILE.profile

Så afvikler vi programmet for at lave profileringsresultatet, der skrives til en fil i mappen angivet i LD_PROFILE_OUTPUT:

$ LD_LIBRARY_PATH=. ./prog
$ ls prof_data
libdemo.so.1.profile

Vi bruger så tilvalget sprof -p til at oprette en flad profil med antal og krydser:

$ sprof -p libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
Flat profile:
Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total
 time   seconds   seconds    calls  us/call  us/call  name
 60.00      0.06     0.06      100   600.00           consumeCpu1
 40.00      0.10     0.04     1000    40.00           consumeCpu2
  0.00      0.10     0.00        1     0.00           x1
  0.00      0.10     0.00        1     0.00           x2

Tilvalget sprof -q opretter en kaldgraf:

$ sprof -q libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
index % time    self  children    called     name
                0.00    0.00      100/100         x1 [1]
[0]    100.0    0.00    0.00      100         consumeCpu1 [0]
-----------------------------------------------
                0.00    0.00        1/1           <UNKNOWN>
[1]      0.0    0.00    0.00        1         x1 [1]
                0.00    0.00      100/100         consumeCpu1 [0]
-----------------------------------------------
                0.00    0.00     1000/1000        x2 [3]
[2]      0.0    0.00    0.00     1000         consumeCpu2 [2]
-----------------------------------------------
                0.00    0.00        1/1           <UNKNOWN>
[3]      0.0    0.00    0.00        1         x2 [3]
                0.00    0.00     1000/1000        consumeCpu2 [2]
-----------------------------------------------

Over og under, strengene »<UNKNOWN>« repræsenterer identifikatorer, der er uden for det profilerede objekt (i dette eksempel er disse instanser af main()).

Tilvalget sprof -c opretter en list af kaldpar og antallet af deres forekomster:

$ sprof -c libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
<UNKNOWN>                  x1                                 1
x1                         consumeCpu1                      100
<UNKNOWN>                  x2                                 1
x2                         consumeCpu2                     1000

SE OGSÅ

gprof(1), ldd(1), ld.so(8)

OVERSÆTTELSE

Oversættere af denne manual til dansk Joe Hansen <joedalton2@yahoo.dk>

Denne oversættelse er gratis dokumentation; læs GNU General Public License version 3 eller nyere for ophavsretbetingelser. Der er INGEN ANSVAR.

Hvis du støder på fejl i oversættelsen af ​​denne vejledning, skal du sende en besked til debian-l10n-danish@lists.debian.org.