New directory of profiling code, incorporated from 4.4BSD-Lite and modified.
authorroland <roland>
Tue, 26 Sep 1995 20:52:54 +0000 (20:52 +0000)
committerroland <roland>
Tue, 26 Sep 1995 20:52:54 +0000 (20:52 +0000)
gmon/Makefile [new file with mode: 0644]
gmon/gmon.c [new file with mode: 0644]
gmon/mcount.c [new file with mode: 0644]
gmon/sys/gmon.h [new file with mode: 0644]

diff --git a/gmon/Makefile b/gmon/Makefile
new file mode 100644 (file)
index 0000000..3bd4201
--- /dev/null
@@ -0,0 +1,28 @@
+# Copyright (C) 1995 Free Software Foundation, Inc.
+# This file is part of the GNU C Library.
+
+# The GNU C Library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+
+# The GNU C Library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Library General Public License for more details.
+
+# You should have received a copy of the GNU Library General Public
+# License along with the GNU C Library; see the file COPYING.LIB.  If
+# not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+# Cambridge, MA 02139, USA.
+
+#
+#      Sub-makefile for gmon portion of the library.
+#
+subdir := gmon
+
+headers        := sys/gmon.h machine-gmon.h
+
+routines := gmon mcount profil
+
+include ../Rules
diff --git a/gmon/gmon.c b/gmon/gmon.c
new file mode 100644 (file)
index 0000000..df528e2
--- /dev/null
@@ -0,0 +1,232 @@
+/*-
+ * Copyright (c) 1983, 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if !defined(lint) && defined(LIBC_SCCS)
+static char sccsid[] = "@(#)gmon.c     8.1 (Berkeley) 6/4/93";
+#endif
+
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/gmon.h>
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+struct gmonparam _gmonparam = { GMON_PROF_OFF };
+
+static int     s_scale;
+/* see profil(2) where this is describe (incorrectly) */
+#define                SCALE_1_TO_1    0x10000L
+
+#define ERR(s) write(2, s, sizeof(s) - 1)
+
+void   moncontrol __P((int));
+static int hertz __P((void));
+
+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 = p->textsize / HISTFRACTION;
+       p->hashfraction = HASHFRACTION;
+       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 = malloc (p->kcountsize + p->fromssize + p->tossize);
+       if (! cp) {
+               ERR("monstartup: out of memory\n");
+               return;
+       }
+       bzero(cp, p->kcountsize + p->fromssize + p->tossize);
+       p->tos = (struct tostruct *)cp;
+       cp += p->tossize;
+       p->kcount = (u_short *)cp;
+       cp += p->kcountsize;
+       p->froms = (u_short *)cp;
+
+       p->tos[0].link = 0;
+
+       o = p->highpc - p->lowpc;
+       if (p->kcountsize < o) {
+#ifndef hp300
+               s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
+#else /* avoid floating point */
+               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);
+}
+
+void
+_mcleanup()
+{
+       int fd;
+       int fromindex;
+       int endfrom;
+       u_long frompc;
+       int toindex;
+       struct rawarc rawarc;
+       struct gmonparam *p = &_gmonparam;
+       struct gmonhdr gmonhdr, *hdr;
+#ifdef DEBUG
+       int log, len;
+       char buf[200];
+#endif
+
+       if (p->state == GMON_PROF_ERROR)
+               ERR("_mcleanup: tos overflow\n");
+
+       moncontrol(0);
+       fd = open("gmon.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
+       if (fd < 0) {
+               perror("mcount: gmon.out");
+               return;
+       }
+#ifdef DEBUG
+       log = open("gmon.log", O_CREAT|O_TRUNC|O_WRONLY, 0664);
+       if (log < 0) {
+               perror("mcount: gmon.log");
+               return;
+       }
+       len = sprintf(buf, "[mcleanup1] kcount 0x%x ssiz %d\n",
+           p->kcount, p->kcountsize);
+       write(log, buf, len);
+#endif
+       hdr = (struct gmonhdr *)&gmonhdr;
+       hdr->lpc = p->lowpc;
+       hdr->hpc = p->highpc;
+       hdr->ncnt = p->kcountsize + sizeof(gmonhdr);
+       hdr->version = GMONVERSION;
+       hdr->profrate = hertz();
+       write(fd, (char *)hdr, sizeof *hdr);
+       write(fd, p->kcount, p->kcountsize);
+       endfrom = p->fromssize / sizeof(*p->froms);
+       for (fromindex = 0; fromindex < endfrom; fromindex++) {
+               if (p->froms[fromindex] == 0)
+                       continue;
+
+               frompc = p->lowpc;
+               frompc += fromindex * p->hashfraction * sizeof(*p->froms);
+               for (toindex = p->froms[fromindex]; toindex != 0;
+                    toindex = p->tos[toindex].link) {
+#ifdef DEBUG
+                       len = sprintf(buf,
+                       "[mcleanup2] frompc 0x%x selfpc 0x%x count %d\n" ,
+                               frompc, p->tos[toindex].selfpc,
+                               p->tos[toindex].count);
+                       write(log, buf, len);
+#endif
+                       rawarc.raw_frompc = frompc;
+                       rawarc.raw_selfpc = p->tos[toindex].selfpc;
+                       rawarc.raw_count = p->tos[toindex].count;
+                       write(fd, &rawarc, sizeof rawarc);
+               }
+       }
+       close(fd);
+}
+
+/*
+ * Control profiling
+ *     profiling is what mcount checks to see if
+ *     all the data structures are ready.
+ */
+void
+moncontrol(mode)
+       int mode;
+{
+       struct gmonparam *p = &_gmonparam;
+
+       if (mode) {
+               /* start */
+               profil((char *)p->kcount, p->kcountsize, (int)p->lowpc,
+                   s_scale);
+               p->state = GMON_PROF_ON;
+       } else {
+               /* stop */
+               profil((char *)0, 0, 0, 0);
+               p->state = GMON_PROF_OFF;
+       }
+}
+
+/*
+ * discover the tick frequency of the machine
+ * if something goes wrong, we return 0, an impossible hertz.
+ */
+static int
+hertz()
+{
+       struct itimerval tim;
+       
+       tim.it_interval.tv_sec = 0;
+       tim.it_interval.tv_usec = 1;
+       tim.it_value.tv_sec = 0;
+       tim.it_value.tv_usec = 0;
+       setitimer(ITIMER_REAL, &tim, 0);
+       setitimer(ITIMER_REAL, 0, &tim);
+       if (tim.it_interval.tv_usec < 2)
+               return(0);
+       return (1000000 / tim.it_interval.tv_usec);
+}
+
+
diff --git a/gmon/mcount.c b/gmon/mcount.c
new file mode 100644 (file)
index 0000000..523217d
--- /dev/null
@@ -0,0 +1,178 @@
+/*-
+ * Copyright (c) 1983, 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if !defined(lint) && !defined(KERNEL) && defined(LIBC_SCCS)
+static char sccsid[] = "@(#)mcount.c   8.1 (Berkeley) 6/4/93";
+#endif
+
+#include <sys/param.h>
+#include <sys/gmon.h>
+
+/*
+ * mcount is called on entry to each function compiled with the profiling
+ * switch set.  _mcount(), which is declared in a machine-dependent way
+ * with _MCOUNT_DECL, does the actual work and is either inlined into a
+ * C routine or called by an assembly stub.  In any case, this magic is
+ * taken care of by the MCOUNT definition in <machine/profile.h>.
+ *
+ * _mcount updates data structures that represent traversals of the
+ * program's call graph edges.  frompc and selfpc are the return
+ * address and function address that represents the given call graph edge.
+ * 
+ * Note: the original BSD code used the same variable (frompcindex) for
+ * both frompcindex and frompc.  Any reasonable, modern compiler will
+ * perform this optimization.
+ */
+_MCOUNT_DECL(frompc, selfpc)   /* _mcount; may be static, inline, etc */
+       register u_long frompc, selfpc;
+{
+       register u_short *frompcindex;
+       register struct tostruct *top, *prevtop;
+       register struct gmonparam *p;
+       register long toindex;
+#ifdef KERNEL
+       register int s;
+#endif
+
+       p = &_gmonparam;
+       /*
+        * check that we are profiling
+        * and that we aren't recursively invoked.
+        */
+       if (p->state != GMON_PROF_ON)
+               return;
+#ifdef KERNEL
+       MCOUNT_ENTER;
+#else
+       p->state = GMON_PROF_BUSY;
+#endif
+       /*
+        * 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;
+
+       frompcindex = &p->froms[frompc / (p->hashfraction * sizeof(*p->froms))];
+       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:
+#ifdef KERNEL
+       MCOUNT_EXIT;
+#else
+       p->state = GMON_PROF_ON;
+#endif
+       return;
+overflow:
+       p->state = GMON_PROF_ERROR;
+#ifdef KERNEL
+       MCOUNT_EXIT;
+#endif
+       return;
+}
+
+/*
+ * Actual definition of mcount function.  Defined in <machine/profile.h>,
+ * which is included by <sys/gmon.h>.
+ */
+MCOUNT
diff --git a/gmon/sys/gmon.h b/gmon/sys/gmon.h
new file mode 100644 (file)
index 0000000..6a682d0
--- /dev/null
@@ -0,0 +1,159 @@
+/*-
+ * Copyright (c) 1982, 1986, 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)gmon.h      8.2 (Berkeley) 1/4/94
+ */
+
+#ifndef _SYS_GMON_H_
+#define _SYS_GMON_H_
+
+#include <machine-gmon.h>
+
+/*
+ * Structure prepended to gmon.out profiling data file.
+ */
+struct gmonhdr {
+       u_long  lpc;            /* base pc address of sample buffer */
+       u_long  hpc;            /* max pc address of sampled buffer */
+       int     ncnt;           /* size of sample buffer (plus this header) */
+       int     version;        /* version number */
+       int     profrate;       /* profiling clock rate */
+       int     spare[3];       /* reserved */
+};
+#define GMONVERSION    0x00051879
+
+/*
+ * histogram counters are unsigned shorts (according to the kernel).
+ */
+#define        HISTCOUNTER     unsigned short
+
+/*
+ * fraction of text space to allocate for histogram counters here, 1/2
+ */
+#define        HISTFRACTION    2
+
+/*
+ * Fraction of text space to allocate for from hash buckets.
+ * The value of HASHFRACTION is based on the minimum number of bytes
+ * of separation between two subroutine call points in the object code.
+ * Given MIN_SUBR_SEPARATION bytes of separation the value of
+ * HASHFRACTION is calculated as:
+ *
+ *     HASHFRACTION = MIN_SUBR_SEPARATION / (2 * sizeof(short) - 1);
+ *
+ * For example, on the VAX, the shortest two call sequence is:
+ *
+ *     calls   $0,(r0)
+ *     calls   $0,(r0)
+ *
+ * which is separated by only three bytes, thus HASHFRACTION is 
+ * calculated as:
+ *
+ *     HASHFRACTION = 3 / (2 * 2 - 1) = 1
+ *
+ * Note that the division above rounds down, thus if MIN_SUBR_FRACTION
+ * is less than three, this algorithm will not work!
+ *
+ * In practice, however, call instructions are rarely at a minimal 
+ * distance.  Hence, we will define HASHFRACTION to be 2 across all
+ * architectures.  This saves a reasonable amount of space for 
+ * profiling data structures without (in practice) sacrificing
+ * any granularity.
+ */
+#define        HASHFRACTION    2
+
+/*
+ * percent of text space to allocate for tostructs with a minimum.
+ */
+#define ARCDENSITY     2
+#define MINARCS                50
+#define MAXARCS                ((1 << (8 * sizeof(HISTCOUNTER))) - 2)
+
+struct tostruct {
+       u_long  selfpc;
+       long    count;
+       u_short link;
+       u_short pad;
+};
+
+/*
+ * a raw arc, with pointers to the calling site and 
+ * the called site and a count.
+ */
+struct rawarc {
+       u_long  raw_frompc;
+       u_long  raw_selfpc;
+       long    raw_count;
+};
+
+/*
+ * general rounding functions.
+ */
+#define ROUNDDOWN(x,y) (((x)/(y))*(y))
+#define ROUNDUP(x,y)   ((((x)+(y)-1)/(y))*(y))
+
+/*
+ * The profiling data structures are housed in this structure.
+ */
+struct gmonparam {
+       int             state;
+       u_short         *kcount;
+       u_long          kcountsize;
+       u_short         *froms;
+       u_long          fromssize;
+       struct tostruct *tos;
+       u_long          tossize;
+       long            tolimit;
+       u_long          lowpc;
+       u_long          highpc;
+       u_long          textsize;
+       u_long          hashfraction;
+};
+extern struct gmonparam _gmonparam;
+
+/*
+ * Possible states of profiling.
+ */
+#define        GMON_PROF_ON    0
+#define        GMON_PROF_BUSY  1
+#define        GMON_PROF_ERROR 2
+#define        GMON_PROF_OFF   3
+
+/*
+ * Sysctl definitions for extracting profiling information from the kernel.
+ */
+#define        GPROF_STATE     0       /* int: profiling enabling variable */
+#define        GPROF_COUNT     1       /* struct: profile tick count buffer */
+#define        GPROF_FROMS     2       /* struct: from location hash bucket */
+#define        GPROF_TOS       3       /* struct: destination/count structure */
+#define        GPROF_GMONPARAM 4       /* struct: profiling parameters (see above) */
+#endif /* !_SYS_GMON_H_ */