Profiling works by changing how every function in your program iscompiled so that when it is called, it will stash away some informationabout where it was called from. From this, the profiler can figure outwhat function called it, and can count how many times it was called.This change is made by the compiler when your program is compiled withthe `-pg' option.

Profiling also involves watching your program as it runs, andkeeping a histogram of where the program counter happens to be everynow and then. Typically the program counter is looked at around 100times per second of run time, but the exact frequency may vary fromsystem to system.

A special startup routine allocates memory for the histogram andsets up a clock signal handler to make entries in it. Use of thisspecial startup routine is one of the effects of using `gcc ... -pg' tolink. The startup file also includes an `exit' function which isresponsible for writing the file `gmon.out'.

Number-of-calls information for library routines is collected byusing a special version of the C library. The programs in it are thesame as in the usual C library, but they were compiled with `-pg'. Ifyou link your program with `gcc ... -pg', it automatically uses theprofiling version of the library.

The output from gprof gives no indication of parts of your programthat are limited by I/O or swapping bandwidth. This is because samplesof the program counter are taken at fixed intervals of run time.Therefore, the time measurements in gprof output say nothing about timethat your program was not running. For example, a part of the programthat creates so much data that it cannot all fit in physical memory atonce may run very slowly due to thrashing, but gprof will say it useslittle time. On the other hand, sampling by run time has the advantagethat the amount of load due to other users won't directly affect theoutput you get.

A special startup routine allocates memory for the histogram andeither calls profil() or sets up a clock signal handler. This routine(monstartup) can be invoked in several ways. On Linux systems, aspecial profiling startup file gcrt0.o, which invokes monstartup beforemain, is used instead of the default crt0.o. Use of this specialstartup file is one of the effects of using `gcc ... -pg' to link. OnSPARC systems, no special startup files are used. Rather, the mcountroutine, when it is invoked for the first time (typically when main iscalled), calls monstartup.

crt0.o是应用程序编译链接时需要的起动文件，在程序链接阶段被链接。主要工作是初试化应用程序栈，初试化程序的运行环境和在程序退出时清除和释放资源。

void

__gmon_start__ (void)

{

#ifdef HAVE_INITFINI

/* Protect from being called more than once. Since crti.o is linked

into every shared library, each of their init functions will call us. */

static int called;

if (called)

return;

called = 1;

#endif

/* Start keeping profiling records. */

__monstartup ((u_long) TEXT_START, (u_long) &etext);

/* Call _mcleanup before exiting; it will write out gmon.out from the

collected data. */

atexit (&_mcleanup);

void

__monstartup (lowpc, highpc)

u_long lowpc;

u_long highpc;

{

register int o;

char *cp;

struct gmonparam *p = &_gmonparam;

/*

* round lowpc and highpc to multiples of the density we're using

* so the rest of the scaling (here and in gprof) stays in ints.

*/

p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));

p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));

p->textsize = p->highpc - p->lowpc;

p->kcountsize = ROUNDUP(p->textsize / HISTFRACTION, sizeof(*p->froms));

p->hashfraction = HASHFRACTION;

p->log_hashfraction = -1;

/* The following test must be kept in sync with the corresponding

test in mcount.c. */

if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {

/* if HASHFRACTION is a power of two, mcount can use shifting

instead of integer division. Precompute shift amount. */

p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;

}

p->fromssize = p->textsize / HASHFRACTION;

p->tolimit = p->textsize * ARCDENSITY / 100;

if (p->tolimit < MINARCS)

p->tolimit = MINARCS;

else if (p->tolimit > MAXARCS)

p->tolimit = MAXARCS;

p->tossize = p->tolimit * sizeof(struct tostruct);

cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);

if (! cp)

{

ERR("monstartup: out of memory\n");

p->tos = NULL;

p->state = GMON_PROF_ERROR;

return;

}

p->tos = (struct tostruct *)cp;

cp += p->tossize;

p->kcount = (HISTCOUNTER *)cp;

cp += p->kcountsize;

p->froms = (ARCINDEX *)cp;

p->tos[0].link = 0;

o = p->highpc - p->lowpc;

if (p->kcountsize < (u_long) o)

{

#ifndef hp300

s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;

#else

/* avoid floating point operations */

int quot = o / p->kcountsize;

if (quot >= 0x10000)

s_scale = 1;

else if (quot >= 0x100)

s_scale = 0x10000 / quot;

else if (o >= 0x800000)

s_scale = 0x1000000 / (o / (p->kcountsize >> 8));

else

s_scale = 0x1000000 / ((o << 8) / p->kcountsize);

#endif

} else

s_scale = SCALE_1_TO_1;

__moncontrol(1);

}

#include <stdio.h>

int or_f(int a,int b)

{

return a^b;

}

int main(int argc,char** argv)

{

printf("%d\n",or_f(1,2));

sleep(30);

return 1;

}

Section Headers:

[Nr] Name Type Address Offset

Size EntSize Flags Link Info Align

......

[12] .text PROGBITS 0000000000400540 00000540

0000000000000278 0000000000000000 AX 0 0 16

.......

00400000-00401000 r-xp 00000000 08:03 70746688 /tmp/test

00600000-00601000 rw-p 00000000 08:03 70746688 /tmp/test

10ca4000-10cc5000 rw-p 10ca4000 00:00 0 [heap]

3536600000-353661c000 r-xp 00000000 08:03 93028660 /lib64/ld-2.5.so

353681b000-353681c000 r--p 0001b000 08:03 93028660 /lib64/ld-2.5.so

353681c000-353681d000 rw-p 0001c000 08:03 93028660 /lib64/ld-2.5.so

2b4f1af23000-2b4f1af25000 rw-p 2b4f1af23000 00:00 0

2b4f1af25000-2b4f1b063000 r-xp 00000000 08:03 32931849 /root/glibc-2.5-42-build/lib/libc-2.5.so

2b4f1b063000-2b4f1b263000 ---p 0013e000 08:03 32931849 /root/glibc-2.5-42-build/lib/libc-2.5.so

2b4f1b263000-2b4f1b267000 r--p 0013e000 08:03 32931849 /root/glibc-2.5-42-build/lib/libc-2.5.so

2b4f1b267000-2b4f1b268000 rw-p 00142000 08:03 32931849 /root/glibc-2.5-42-build/lib/libc-2.5.so

2b4f1b268000-2b4f1b26f000 rw-p 2b4f1b268000 00:00 0

7fffa306b000-7fffa3080000 rw-p 7ffffffea000 00:00 0 [stack]

ffffffffff600000-ffffffffffe00000 ---p 00000000 00:00 0 [vdso]

void

__moncontrol (mode)

int mode;

{

struct gmonparam *p = &_gmonparam;

/* Don't change the state if we ran into an error. */

if (p->state == GMON_PROF_ERROR)

return;

if (mode)

{

/* start */

__profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);

p->state = GMON_PROF_ON;

}

else

{

/* stop */

__profil(NULL, 0, 0, 0);

p->state = GMON_PROF_OFF;

}

}

int

__profil (u_short *sample_buffer, size_t size, size_t offset, u_int scale)

{

struct sigaction act;

struct itimerval timer;

#ifndef IS_IN_rtld

static struct sigaction oact;

static struct itimerval otimer;

# define oact_ptr &oact

# define otimer_ptr &otimer

if (sample_buffer == NULL)

{

/* Disable profiling. */

if (samples == NULL)

/* Wasn't turned on. */

return 0;

if (__setitimer (ITIMER_PROF, &otimer, NULL) < 0)

return -1;

samples = NULL;

return __sigaction (SIGPROF, &oact, NULL);

}

if (samples)

{

/* Was already turned on. Restore old timer and signal handler

first. */

if (__setitimer (ITIMER_PROF, &otimer, NULL) < 0

|| __sigaction (SIGPROF, &oact, NULL) < 0)

return -1;

}

#else

/* In ld.so profiling should never be disabled once it runs. */

//assert (sample_buffer != NULL);

# define oact_ptr NULL

# define otimer_ptr NULL

#endif

samples = sample_buffer;

nsamples = size / sizeof *samples;

pc_offset = offset;

pc_scale = scale;

act.sa_handler = (sighandler_t) &profil_counter;

act.sa_flags = SA_RESTART;

__sigfillset (&act.sa_mask);

if (__sigaction (SIGPROF, &act, oact_ptr) < 0)

return -1;

timer.it_value.tv_sec = 0;

timer.it_value.tv_usec = 1000000 / __profile_frequency ();

timer.it_interval = timer.it_value;

return __setitimer (ITIMER_PROF, &timer, otimer_ptr);

}

#define MCOUNT \

void _mcount (void) \

{ \

mcount_internal ((u_long) RETURN_ADDRESS (1), (u_long) RETURN_ADDRESS (0)); \

}

__builtin_return_address(LEVEL)

---This function returns the return address of the currentfunction,or of one of its callers. The LEVEL argument is number offrames to scan up the call stack. A value of '0' yields the returnaddress of the current function,a value of '1' yields the returnaddress of the caller of the current function,and so forth.

_MCOUNT_DECL(frompc, selfpc) /* _mcount; may be static, inline, etc */

{

register ARCINDEX *frompcindex;

register struct tostruct *top, *prevtop;

register struct gmonparam *p;

register ARCINDEX toindex;

int i;

p = &_gmonparam;

/*

* check that we are profiling

* and that we aren't recursively invoked.

*/

if (catomic_compare_and_exchange_bool_acq (&p->state, GMON_PROF_BUSY,

GMON_PROF_ON))

return;

/*

* check that frompcindex is a reasonable pc value.

* for example: signal catchers get called from the stack,

* not from text space. too bad.

*/

frompc -= p->lowpc;

if (frompc > p->textsize)

goto done;

/* The following test used to be

if (p->log_hashfraction >= 0)

But we can simplify this if we assume the profiling data

is always initialized by the functions in gmon.c. But

then it is possible to avoid a runtime check and use the

smae `if' as in gmon.c. So keep these tests in sync. */

if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {

/* avoid integer divide if possible: */

i = frompc >> p->log_hashfraction;

} else {

i = frompc / (p->hashfraction * sizeof(*p->froms));

}

frompcindex = &p->froms[i];

toindex = *frompcindex;

if (toindex == 0) {

/*

* first time traversing this arc

*/

toindex = ++p->tos[0].link;

if (toindex >= p->tolimit)

/* halt further profiling */

goto overflow;

*frompcindex = toindex;

top = &p->tos[toindex];

top->selfpc = selfpc;

top->count = 1;

top->link = 0;

goto done;

}

top = &p->tos[toindex];

if (top->selfpc == selfpc) {

/*

* arc at front of chain; usual case.

*/

top->count++;

goto done;

}

/*

* have to go looking down chain for it.

* top points to what we are looking at,

* prevtop points to previous top.

* we know it is not at the head of the chain.

*/

for (; /* goto done */; ) {

if (top->link == 0) {

/*

* top is end of the chain and none of the chain

* had top->selfpc == selfpc.

* so we allocate a new tostruct

* and link it to the head of the chain.

*/

toindex = ++p->tos[0].link;

if (toindex >= p->tolimit)

goto overflow;

top = &p->tos[toindex];

top->selfpc = selfpc;

top->count = 1;

top->link = *frompcindex;

*frompcindex = toindex;

goto done;

}

/*

* otherwise, check the next arc on the chain.

*/

prevtop = top;

top = &p->tos[top->link];

if (top->selfpc == selfpc) {

/*

* there it is.

* increment its count

* move it to the head of the chain.

*/

top->count++;

toindex = prevtop->link;

prevtop->link = top->link;

top->link = *frompcindex;

*frompcindex = toindex;

goto done;

}

}

done:

p->state = GMON_PROF_ON;

return;

overflow:

p->state = GMON_PROF_ERROR;

return;

}

static void

profil_counter (int signo, SIGCONTEXT scp)

{

profil_count ((void *) GET_PC (scp));

/* This is a hack to prevent the compiler from implementing the

above function call as a sibcall. The sibcall would overwrite

the signal context. */

asm volatile ("");

}

static inline void

profil_count (void *pc)

{

size_t i = (pc - pc_offset - (void *) 0) / 2;

if (sizeof (unsigned long long int) > sizeof (size_t))

i = (unsigned long long int) i * pc_scale / 65536;

else

i = i / 65536 * pc_scale + i % 65536 * pc_scale / 65536;

if (i < nsamples)

++samples[i];

}

void

_mcleanup (void)

{

__moncontrol (0);

if (_gmonparam.state != GMON_PROF_ERROR)

write_gmon ();

/* free the memory. */

free (_gmonparam.tos);

}

static void

write_gmon (void)

{

struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int))));

int fd = -1;

char *env;

#ifndef O_NOFOLLOW

# define O_NOFOLLOW 0

#endif

env = getenv ("GMON_OUT_PREFIX");

if (env != NULL && !__libc_enable_secure)

{

size_t len = strlen (env);

char buf[len + 20];

__snprintf (buf, sizeof (buf), "%s.%u", env, __getpid ());

fd = open_not_cancel (buf, O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW, 0666);

}

if (fd == -1)

{

fd = open_not_cancel ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW,

0666);

if (fd < 0)

{

char buf[300];

int errnum = errno;

__fxprintf (NULL, "_mcleanup: gmon.out: %s\n",

__strerror_r (errnum, buf, sizeof buf));

return;

}

}

/* write gmon.out header: */

memset (&ghdr, '\0', sizeof (struct gmon_hdr));

memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie));

*(int32_t *) ghdr.version = GMON_VERSION;

write_not_cancel (fd, &ghdr, sizeof (struct gmon_hdr));

/* write PC histogram: */

write_hist (fd);

/* write call-graph: */

write_call_graph (fd);

/* write basic-block execution counts: */

write_bb_counts (fd);

close_not_cancel_no_status (fd);

}

The output from gprof gives no indication of parts of your programthat are limited by I/O or swapping bandwidth. This is because samplesof the program counter are taken at fixed intervals of the program'srun time. Therefore, the time measurements in gprof output say nothingabout time that your program was not running. For example, a part ofthe program that creates so much data that it cannot all fit inphysical memory at once may run very slowly due to thrashing, but gprofwill say it uses little time. On the other hand, sampling by run timehas the advantage that the amount of load due to other users won'tdirectly affect the output you get.

The run-time figures that gprof gives you are based on a samplingprocess, so they are subject to statistical inaccuracy. If a functionruns only a small amount of time, so that on the average the samplingprocess ought to catch that function in the act only once, there is apretty good chance it will actually find that function zero times, ortwice.

By contrast, the number-of-calls figures are derived by counting,not sampling. They are completely accurate and will not vary from runto run if your program is deterministic.

The sampling period that is printed at the beginning of theflat profile says how often samples are taken. The rule of thumb isthat a run-time figure is accurate if it is considerably bigger thanthe sampling period.

The actual amount of error is usually more than one sampling period. In fact, if a value is n times the sampling period, the expected error in it is the square-root of nsampling periods. If the sampling period is 0.01 seconds and foo'srun-time is 1 second, the expected error in foo's run-time is 0.1seconds. It is likely to vary this much on the average from one profiling run to the next. (Sometimes it will vary more.)

This does not mean that a small run-time figure is devoid of information. If the program's totalrun-time is large, a small run-time for one function does tell you thatthat function used an insignificant fraction of the whole program'stime. Usually this means it is not worth optimizing.