fixup for older distros + updated Preference/About messages
[goodguy/cinelerra.git] / cinelerra-5.1 / prof2 / profile.c
1 #include <stdio.h>
2 #include <unistd.h>
3 #include <signal.h>
4 #include <ucontext.h>
5 #include <pthread.h>
6 #include <link.h>
7
8 #define smCommand "smap 2> /dev/null < "
9 #ifdef __i386__
10 #define nmAddr 0
11 #define nmType 9
12 #define nmName 11
13 #define _LX "%08lx"
14 #ifndef LIB
15 #define LIB "/lib"
16 #endif
17 #endif
18 #ifdef __x86_64__
19 #define nmAddr 0
20 #define nmType 17
21 #define nmName 19
22 #define _LX "%016lx"
23 #ifndef LIB
24 #define LIB "/lib64"
25 #endif
26 #endif
27
28 #define unlikely(x) __builtin_expect(!!(x), 0)
29 #define dprintf(s...) do { if( unlikely(prof_debug!=0) ) fprintf(s); } while(0)
30
31 int profileMain(int ac,char **av,char **ev);
32 void profileStart(void);
33 void profileStop(void);
34 void profileClear(void);
35 void profileShow(void);
36 void profileDone(void);
37
38 #include <string.h>
39 #include <errno.h>
40 #include <stdlib.h>
41 #include <stdarg.h>
42 #include <fcntl.h>
43 #include <time.h>
44 #include <limits.h>
45 #include <sys/time.h>
46 #include <sys/times.h>
47
48 #define MAP2MAX 256
49 #define MAPINCR 64
50 #define MOD2MAX 256
51 #define MODINCR 64
52 #define SYM2MAX 1024*256
53 #define SYMINCR 1024*16
54 #if 0
55 static volatile long prof_debug = 1;
56 static volatile long prof_type = 0;
57 static volatile long prof_tmrval = 10000;
58 static volatile unsigned long prof_stkptr = INT_MAX-0x1000;
59 static volatile char prof_output[256] = { "-" };
60 #else
61 static volatile long prof_debug; /* enable debug output */
62 static volatile long prof_type; /* 0=usr+sys, 1=usr only, 2=real time */
63 static volatile long prof_tmrval; /* profile timer interval in usecs */
64 static volatile unsigned long prof_stkptr; /* top of stack at profileStart */
65 static volatile char prof_output[256]; /* profile output file name */
66 #endif
67
68 static FILE *prof_fp = NULL;
69
70 typedef struct {
71    char *name;
72    unsigned long offs;
73 } tMap;
74
75 typedef struct {
76    int n, m;
77    tMap map[MAPINCR];
78 } tMapTbl;
79
80 typedef struct {
81    char *name;
82    unsigned long offs;
83    int count;
84    int calls;
85 } tMod;
86
87 typedef struct {
88    int n, m;
89    tMod mod[MODINCR];
90 } tModTbl;
91
92 typedef struct {
93    char *name;
94    unsigned long adr;
95    int count;
96    int calls;
97    int tick;
98    int tcalls;
99    int mod;
100 } tSym;
101
102 typedef struct {
103    int n, m;
104    tSym sym[SYMINCR];
105 } tSymTbl;
106
107 static tSymTbl *tsym = NULL;
108 static tModTbl *tmod = NULL;
109 static tMapTbl *tmap = NULL;
110 static int nTicks;               /* profile timer tick count */
111 static struct tms start_cpu;     /* cpu time at profile_start */
112 static struct tms stop_cpu;      /* cpu time at profile_stop */
113 static struct timeval start_clk; /* real time at profile_start */
114 static struct timeval stop_clk;  /* real time at profile_stop */
115
116 int profileActive = 0;           /* flag, true if profile handler active */
117 static struct sigaction oldSig;  /* orignal profile handler data */
118 static struct sigaction oldSegv; /* orignal segv handler data */
119
120 static tMapTbl *
121 newMapTbl(void)
122 {
123    tMapTbl *tp;
124    if( (tp=malloc(sizeof(*tp))) != NULL ) {
125       tp->n = 0;
126       tp->m = sizeof(tp->map)/sizeof(tp->map[0]);
127    }
128    return tp;
129 }
130
131 static tModTbl *
132 newModTbl(void)
133 {
134    tModTbl *tp;
135    if( (tp=malloc(sizeof(*tp))) != NULL ) {
136       tp->n = 0;
137       tp->m = sizeof(tp->mod)/sizeof(tp->mod[0]);
138    }
139    return tp;
140 }
141
142 static tSymTbl *
143 newSymTbl(void)
144 {
145    tSymTbl *tp;
146    if( (tp=malloc(sizeof(*tp))) != NULL ) {
147       tp->n = 0;
148       tp->m = sizeof(tp->sym)/sizeof(tp->sym[0]);
149    }
150    return tp;
151 }
152
153 static tSym *
154 newSym(tSymTbl **ptp,const char *name,unsigned long adr,int mod)
155 {
156    tSym *sp;
157    tSymTbl *tp = *ptp;
158    int n = tp->n;
159    int m = tp->m;
160    if( n >= m ) {
161       tSymTbl *rp;  int l;
162       m = m < SYM2MAX ? m*2 : m+SYMINCR;
163       l = sizeof(*tp)-sizeof(tp->sym)+m*sizeof(tp->sym[0]);
164       rp = (tSymTbl*) realloc(tp,l);
165       if( rp == NULL ) return NULL;
166       tp = rp;
167       tp->m = m;
168       *ptp = tp;
169    }
170    sp = &tp->sym[n++];
171    tp->n = n;
172    sp->name = strdup(name);
173    sp->adr = adr;
174    sp->mod = mod;
175    sp->count = sp->calls = 0;
176    sp->tick = sp->tcalls = 0;
177    return sp;
178 }
179
180 static int
181 newMod(tModTbl **ptp, const char *name, unsigned long offs)
182 {
183    tMod *mp;
184    tModTbl *tp = *ptp;
185    int n = tp->n;
186    int m = tp->m;
187    if( n >= m ) {
188       tModTbl *rp;  int l;
189       m = m < MOD2MAX ? m*2 : m+MODINCR;
190       l = sizeof(*tp)-sizeof(tp->mod)+m*sizeof(tp->mod[0]);
191       rp = (tModTbl*) realloc(tp,l);
192       if( !rp ) return -1;
193       tp = rp;
194       *ptp = tp;
195    }
196    int ret = n++;
197    mp = &tp->mod[ret];
198    tp->n = n;
199    mp->name = strdup(name);
200    mp->offs = offs;
201    mp->count = mp->calls = 0;
202    return ret;
203 }
204
205 int
206 findMod(tModTbl *tp, const char *nm)
207 {
208    int n = tp->n;
209    while( --n >= 0 && strcmp(nm,tp->mod[n].name) );
210    return n;
211 }
212
213 static int
214 newMap(tMapTbl **ptp, const char *name, unsigned long offs)
215 {
216    tMap *mp;
217    tMapTbl *tp = *ptp;
218    int n = tp->n;
219    int m = tp->m;
220    if( n >= m ) {
221       tMapTbl *rp;  int l;
222       m = m < MAP2MAX ? m*2 : m+MAPINCR;
223       l = sizeof(*tp)-sizeof(tp->map)+m*sizeof(tp->map[0]);
224       rp = (tMapTbl*) realloc(tp,l);
225       if( !rp ) return -1;
226       tp = rp;
227       *ptp = tp;
228    }
229    int ret = n++;
230    mp = &tp->map[ret];
231    tp->n = n;
232    mp->name = strdup(name);
233    mp->offs = offs;
234    return ret;
235 }
236
237 static void
238 delMapTbl(tMapTbl **ptp)
239 {
240    int i;  char *name;
241    tMapTbl *tp;  tMap *mp;
242    if( (tp=*ptp) == NULL ) return;
243    mp = &tp->map[0];
244    for( i=tp->n; --i>=0; ++mp ) {
245       if( (name=mp->name) != NULL )
246          free(name);
247    }
248    free(tp);
249    *ptp = NULL;
250 }
251
252 static void
253 delModTbl(tModTbl **ptp)
254 {
255    int i;  char *name;
256    tModTbl *tp;  tMod *mp;
257    if( (tp=*ptp) == NULL ) return;
258    mp = &tp->mod[0];
259    for( i=tp->n; --i>=0; ++mp ) {
260       if( (name=mp->name) != NULL )
261          free(name);
262    }
263    free(tp);
264    *ptp = NULL;
265 }
266
267 static void
268 delSymTbl(tSymTbl **ptp)
269 {
270    int i;  char *name;
271    tSymTbl *tp;  tSym *sp;
272    if( (tp=*ptp) == NULL ) return;
273    sp = &tp->sym[0];
274    for( i=tp->n; --i>=0; ++sp ) {
275       if( (name=sp->name) != NULL )
276          free(name);
277    }
278    free(tp);
279    *ptp = NULL;
280 }
281
282 static void
283 delAllTbls(void)
284 {
285    delMapTbl(&tmap);
286    delModTbl(&tmod);
287    delSymTbl(&tsym);
288 }
289
290 static int
291 mapLkup(tMapTbl *tp,const char *nm)
292 {
293    tMap *mp = &tp->map[0];
294    int n = tp->n;
295    while( --n >= 0 && strcmp(nm,mp->name)!=0 )
296      ++mp;
297    return n;
298 }
299
300 static int
301 findMap(tMapTbl *tp,char *nm)
302 {
303    int ret = mapLkup(tp,nm);
304    if( ret < 0 )
305       dprintf(stderr,"cant find map '%s'\n",nm);
306    return ret;
307 }
308
309 static int
310 findSymAdr(tSymTbl *tp,const char *nm,unsigned long *adr)
311 {
312   int n = tp->n;
313   while( --n >= 0 && strcmp(nm,tp->sym[n].name) );
314   if( n < 0 ) return 1;
315   *adr = tp->sym[n].adr;
316   return 0;
317 }
318
319 static int
320 isSymNm(char *cp, char *bp)
321 {
322    int ch;
323    while( (ch=*cp++) != 0 ) {
324       if( ch == '\n' ) break;
325       *bp++ = ch;
326       if( ch == '#' || ch == '$' || ch == '.' ) return 0;
327    }
328    *bp = 0;
329    return 1;
330 }
331
332 static int
333 hex(char *cp, unsigned long *val)
334 {
335    char *bp = cp;
336    *val = strtoul(cp,&bp,16);
337    return bp - cp;
338 }
339
340 static int
341 mapMod(char *fn,tSymTbl **ptp, int mod)
342 {
343    char nmLine[512], nmCmd[512], *lp;
344    unsigned long adr, ofs;  int typ;
345    FILE *fp;  tMod *mp;
346    if( access(fn, R_OK) < 0 ) return -1;
347    strcpy(&nmCmd[0],smCommand);
348    strcat(&nmCmd[0],fn);
349    lp = NULL;
350    if( (fp=popen(&nmCmd[0],"r")) == NULL ) return -1;
351    mp = &tmod->mod[mod];  ofs = mp->offs;
352    while((lp=fgets(&nmLine[0],sizeof nmLine,fp)) != NULL ) {
353       typ = nmLine[nmType];
354       if( typ != 'T' && typ != 't' ) continue;
355       if( isSymNm(&nmLine[nmName],&nmCmd[0]) == 0 ) continue;
356       if( hex(&nmLine[nmAddr],&adr) != nmType-1 ) continue;
357       adr += ofs;
358       if( newSym(ptp,&nmCmd[0],adr,mod) == NULL ) break;
359    } while((lp=fgets(&nmLine[0],sizeof nmLine,fp)) != NULL );
360    pclose(fp);
361    return lp != NULL ? -1 : 0;
362 }
363
364 static int
365 adrCmpr(const void *a, const void *b)
366 {
367    unsigned long aadr = ((tSym*)a)->adr;
368    unsigned long badr = ((tSym*)b)->adr;
369    if( aadr > badr ) return 1;
370    if( aadr < badr ) return -1;
371    return 0;
372 }
373
374 static int
375 cntCmpr(const void *a, const void *b)
376 {
377    int acnt = ((tSym*)a)->count;
378    int bcnt = ((tSym*)b)->count;
379    return acnt - bcnt;
380 }
381
382 static int
383 tclCmpr(const void *a, const void *b)
384 {
385    int atcl = ((tSym*)a)->tcalls;
386    int btcl = ((tSym*)b)->tcalls;
387    return atcl - btcl;
388 }
389
390 static int
391 modCmpr(const void *a, const void *b)
392 {
393    int acnt = ((tMod*)a)->count;
394    int bcnt = ((tMod*)b)->count;
395    return acnt - bcnt;
396 }
397
398 static int
399 profile_tally(unsigned long pc, int cnt)
400 {
401    tSym *sp, *tp;
402    int l, m, r;
403    if( tsym == NULL )
404       return -1;
405    sp = tp = &tsym->sym[0];
406    l = -1;  r = tsym->n;
407  /* find function containing pc */
408    while( (r-l) > 1 ) {
409       m = (r+l) >> 1;
410       sp = &tp[m];
411       if( sp->adr == pc ) break;
412       if( sp->adr < pc ) l = m;
413       else r = m;
414    }
415    if( sp->adr != pc ) {
416       if( l < 0 )
417          return -1;
418       sp = &tp[l];
419    }
420    tMod *mp = &tmod->mod[sp->mod];
421 /* incr function/module calls/counts */
422    ++sp->calls;
423    ++mp->calls;
424 /* only 1 call per unwinding */
425    if( sp->tick < nTicks ) {
426       sp->tick = nTicks;
427       ++sp->tcalls;
428    }
429    if( cnt != 0 ) {
430       ++sp->count;
431       ++mp->count;
432    }
433    return 0;
434 }
435
436 struct reg_frame {
437    unsigned long rf_fp;        /* frame pointer */
438    unsigned long rf_rtn;       /* return addr */
439 };
440
441 static int readProcMaps(unsigned long *fwa)
442 {
443    int ret, n, m, fd, len;
444    unsigned long vm_start, vm_end, ino;
445    char mr, mw, mx, ms, *bp;
446    off_t pgoff;
447    unsigned int maj, min;
448    char mfn[PATH_MAX], ifn[PATH_MAX];
449    char bfr[65536];
450    pid_t pid = getpid();
451    ret = 1;
452    snprintf(&mfn[0],sizeof mfn,"/proc/%d/maps",pid);
453    fd = open(&mfn[0],O_RDONLY);
454    if( fd >= 0 ) {
455       len = read(fd,bp=&bfr[0],sizeof bfr);
456       close(fd);
457       while( len > 0 ) {
458          m = sscanf(bp, "%lx-%lx %c%c%c%c %lx %x:%x %lu%n",
459             &vm_start,&vm_end,&mr,&mw,&mx,&ms,&pgoff,&maj,&min,&ino,&n);
460          if( m == 10 && fwa ) { *fwa = vm_start;  fwa = 0; }
461          if( m == 10 && mx == 'x' && pgoff == 0 ) {
462             for( bp+=n,len-=n ; len>0 && *bp!='\n' && *bp==' '; ++bp,--len );
463             for( m=0 ; len>0 && *bp!='\n' && m<PATH_MAX-1; ++bp,--len )
464                ifn[m++] = *bp;
465             ifn[m] = 0;
466             if( maj !=0 || min != 0 ) {
467                dprintf(stderr," map "_LX" %s\n",vm_start,&ifn[0]);
468                newMap(&tmap,&ifn[0],vm_start);
469             }
470          }
471          while( --len>=0 && *bp++!='\n' );
472       }
473       ret = 0;
474    }
475    return ret;
476 }
477
478 static int readNmMaps(unsigned long fwa)
479 {
480    unsigned long adr;
481    int i, k;
482    char dfn[PATH_MAX], efn[PATH_MAX], pfn[PATH_MAX];
483    struct link_map *so;
484    struct r_debug *rdebug = &_r_debug;
485    for( so=rdebug->r_map; so!=NULL; so=so->l_next ) {
486       int n = tsym->n;
487       char *nm = &so->l_name[0];
488       if( nm[0] == 0 ) nm = "/proc/self/exe";
489       dprintf(stderr,"resolving %s\n",nm);
490       if( nm[0] == '.' && nm[1] == '/' ) {
491         getcwd(&pfn[0],sizeof(pfn));
492         strcat(&pfn[0],&nm[1]);
493         nm = &pfn[0];
494       }
495       while( (i=readlink(nm,&efn[0],sizeof(efn)-1)) >= 0 ) {
496         efn[i] = 0;
497         dprintf(stderr,"  link %s\n",&efn[0]);
498         if( efn[0] != '/' ) { /* get dirname */
499            for( k=-1,i=0; i<sizeof(dfn)-1 && (dfn[i++]=*nm)!=0; ++nm )
500              if( *nm == '/' ) k = i;
501            if( k >= 0 ) {     /* add link name */
502              for( i=0; k<sizeof(dfn)-1 && (dfn[k++]=efn[i])!=0; ++i );
503            }
504            strncpy(&efn[0],&dfn[0],sizeof(efn));
505         }
506         nm = &efn[0];
507         dprintf(stderr,"  path %s\n",nm);
508       }
509       if( findMod(tmod,nm) >= 0 ) continue;
510       int map = !so->l_name[0] ? -1 : findMap(tmap, nm);
511       tMap *mp = map>=0 ? &tmap->map[map] : 0;
512       adr = mp ? mp->offs : (unsigned long) so->l_addr;
513       if( !adr ) adr = fwa;
514       dprintf(stderr,"  map %s adr = 0x"_LX" ofs = 0x"_LX"\n",
515           nm,adr,(unsigned long)so->l_addr);
516       int mod = newMod(&tmod,nm,adr);
517       if( mod >= 0 ) {
518          if( mapMod(nm,&tsym,mod) < 0 || tsym->n == n ) {
519             char dfn[PATH_MAX];  memset(dfn,0,sizeof(dfn));
520             strcpy(&dfn[0],"/usr/lib/debug");
521             strncat(&dfn[0],nm,sizeof(dfn)-1);
522             strncat(&dfn[0],".debug",sizeof(dfn)-1);
523             dprintf(stderr,", %s",&dfn[0]);
524             if( mapMod(&dfn[0],&tsym,mod) < 0 )
525               mod = -1;
526          }
527       }
528       dprintf(stderr,", %d symbols\n",tsym->n - n);
529       if( mod < 0 && strncmp("linux-vdso.so.",nm,14) ) {
530          fprintf(stderr,"profile - Cannot map module - %s\n",nm);
531 //         exit(1);
532 //         return -1;
533       }
534    }
535
536    /* sort the symbols by address */
537    qsort(&tsym->sym[0],tsym->n,sizeof(tsym->sym[0]),adrCmpr);
538    if( prof_debug != 0 ) {
539       int i; tSym *sp;
540       sp = &tsym->sym[0];
541       for( i=tsym->n; --i>=0; ++sp ) {
542          tMod *mp = &tmod->mod[sp->mod];
543          fprintf(stdout,_LX" %-24s %s\n",sp->adr,
544             &sp->name[0],&mp->name[0]);
545       }
546    }
547    return 0;
548 }
549
550 /** profile_handler(sign,c)
551  * profile periodic timer signal handler.
552  * decodes pc/fp from sigcontext, and tallys pc (count)
553  *  and stack trace (calls).
554  */
555 #define LOW_TEXT 0x01000UL
556
557 static void profile_handler(int n, siginfo_t * info, void *sc)
558 {
559   ucontext_t *uc = (ucontext_t *)sc;
560   struct sigcontext *c = (struct sigcontext *)&uc->uc_mcontext;
561    struct reg_frame *fp, *last_fp;
562    unsigned long pc;
563    /* tid marks top of thread stack (currently) */
564    unsigned long tid = (unsigned long)pthread_self();
565    ++nTicks;
566    /* tally pc value */
567 #ifdef __i386__
568    pc = (unsigned long)c->eip;
569 #define ARCH_OK
570 #endif
571 #ifdef __x86_64__
572    pc = (unsigned long)c->rip;
573 #define ARCH_OK
574 #endif
575 #ifndef ARCH_OK
576 #error unknown arch
577 #endif
578    if( pc < LOW_TEXT ) return;
579    if( profile_tally(pc,1) != 0 ) return;
580
581    /* access frame pointer and validate */
582 #ifdef __i386__
583    fp = (struct reg_frame *)c->ebp;
584    if( (unsigned long)fp < c->esp ) return;
585 #endif
586 #ifdef __x86_64__
587    fp = (struct reg_frame *)c->rbp;
588    if( (unsigned long)fp < c->rsp ) return;
589 #endif
590    if( (unsigned long)fp > prof_stkptr) return;
591    if( (unsigned long)fp > tid) return;
592    dprintf(stderr,"unwind "_LX"",(unsigned long)pc);
593    /* unwind the stack frames, and tally pc values */
594    while( (last_fp=fp) != 0 ) {
595       pc = fp->rf_rtn;
596       dprintf(stderr," "_LX"",(unsigned long)pc);
597       if( pc < LOW_TEXT ) break;
598       if( profile_tally(pc,0) != 0 ) break;
599       fp = (struct reg_frame *)fp->rf_fp;
600       if( ((long)fp & 3) != 0 ) break;
601       if( fp <= last_fp ) break;
602       if( (unsigned long)fp > prof_stkptr ) break;
603       if( (unsigned long)fp > tid ) break;
604    }
605    dprintf(stderr,"\n");
606
607    return;
608 }
609
610 void profileExit(void)
611 {
612    profileStop();
613    profileShow();
614    profileDone();
615 }
616
617 static void profile_segv(int n, siginfo_t * info, void *sc)
618 {
619   ucontext_t *uc = (ucontext_t *)sc;
620   struct sigcontext *c = (struct sigcontext *)&uc->uc_mcontext;
621   profileExit();
622   fprintf(stderr,"segv at 0x"_LX"\n",
623 #if __i386__
624     c->eip
625 #endif
626 #if __x86_64__
627     c->rip
628 #endif
629     );
630 }
631
632 void profileStart(void)
633 {
634    char *fn;
635    int typ, sig;
636    struct itimerval it;
637    struct timezone tz;
638    struct sigaction act;
639    struct sigaction segv;
640    unsigned long fwa;
641
642    if( profileActive != 0 ) return;
643
644    if( tmod == NULL || tsym == NULL || tmap == NULL ) {
645       setbuf(stderr,NULL);
646       dprintf(stderr,"start profile\n");
647       delAllTbls();
648       unsetenv("LD_PRELOAD");
649       profileDone();
650       fn = (char *)&prof_output[0];
651       if( strcmp("-",&fn[0]) == 0 )
652          prof_fp = stdout;
653       else if( strcmp("--",&fn[0]) == 0 )
654          prof_fp = stderr;
655       else
656          prof_fp = fopen(&fn[0],"w");
657       if( prof_fp == NULL ) {
658          perror(&fn[0]);
659          fprintf(stderr,"profile: no output path\n");
660          exit(1);
661       }
662       tmap = newMapTbl();  fwa = 0;
663       if( tmap != NULL && readProcMaps(&fwa) == 0 ) {
664          tmod = newModTbl();  tsym = newSymTbl();
665          if( tmod == NULL || tsym == NULL || readNmMaps(fwa) != 0 ) {
666             fprintf(stderr,"profile: unable to read nm maps\n");
667             delModTbl(&tmod);  delSymTbl(&tsym);
668          }
669       }
670       else {
671          fprintf(stderr,"profile: unable to read proc maps\n");
672          delMapTbl(&tmap);
673       }
674    }
675    if( tmap == NULL || tmod == NULL || tsym == NULL ) {
676       delAllTbls();
677       return;
678    }
679
680    switch( prof_type ) {
681    case 1:  typ = ITIMER_VIRTUAL;  sig = SIGVTALRM;  break;
682    case 2:  typ = ITIMER_REAL;     sig = SIGALRM;    break;
683    default: typ = ITIMER_PROF;     sig = SIGPROF;    break;
684    }
685
686    /* record the start time (cpu/real). */
687    times(&start_cpu);
688    gettimeofday(&start_clk,&tz);
689
690    /* enable the profile timer signal handler. */
691    profileActive = 1;
692    memset(&act,0,sizeof(act));
693    act.sa_sigaction = profile_handler;
694    act.sa_flags = SA_RESTART + SA_SIGINFO;
695    sigaction(sig, &act, &oldSig);
696    memset(&segv,0,sizeof(segv));
697    segv.sa_sigaction = profile_segv;
698    segv.sa_flags = SA_SIGINFO;
699    sigaction(SIGSEGV,&segv,&oldSegv);
700
701    /* start the periodic profile timer signal */
702    if( prof_tmrval == 0 ) prof_tmrval = 1;
703    it.it_value.tv_sec = 
704    it.it_interval.tv_sec = prof_tmrval / 1000000;
705    it.it_value.tv_usec =
706    it.it_interval.tv_usec = prof_tmrval % 1000000;
707    setitimer(typ, &it, NULL);
708    dprintf(stderr,"starting profile.\n");
709 }
710
711 static void sigusr1(int n)
712 {
713    profileStop();
714    profileShow();
715    delAllTbls();
716    profileStart();
717 }
718
719 int profileMain(int ac,char **av,char **ev)
720 {
721    int (*fmain)(int ac,char **av,char **ev);
722    unsigned long adr;
723    profileStart();
724    if( findSymAdr(tsym,"main",&adr) != 0 ) {
725      fprintf(stderr,"cant locate sym \"main\"\n");
726      exit(1);
727    }
728    atexit(profileExit);
729    signal(SIGUSR1, sigusr1);
730    fmain = (int (*)(int,char **,char **))adr;
731    dprintf(stderr,"starting \"main\" at: %p\n",fmain);
732    int ret = fmain(ac,av,ev);
733    dprintf(stderr,"ended \"main\" = %d\n",ret);
734    exit(ret);
735 }
736
737 void profileStop(void)
738 {
739    struct itimerval it;
740    struct timezone tz;
741    struct sigaction act;
742
743    if( profileActive == 0 ) return;
744    dprintf(stderr,"stopping profile.\n");
745
746    /* records the stop time (cpu/real). */
747    times(&stop_cpu);
748    gettimeofday(&stop_clk,&tz);
749
750    /* disables the profile timer signal handler. */
751    it.it_interval.tv_sec = 0;
752    it.it_interval.tv_usec = 0;
753    it.it_value.tv_sec = 0;
754    it.it_value.tv_usec = 0;
755    setitimer(ITIMER_PROF, &it, NULL);
756
757    /* restore the original profile signal handler. */
758    sigaction(SIGPROF, &oldSig, &act);
759    sigaction(SIGSEGV, &oldSegv, &act);
760    profileActive = 0;
761    return;
762 }
763
764
765 void profileClear(void)
766 {
767    int i;
768    nTicks = 0;
769    if( tsym != NULL ) {
770       tSym *sp = &tsym->sym[0];
771       for( i=tsym->n; --i>=0; ++sp ) {
772          sp->count = sp->calls = 0;
773          sp->tick = sp->tcalls = 0;
774       }
775    }
776    if( tmod != NULL ) {
777       tMod *mp = &tmod->mod[0];
778       for( i=tmod->n; --i>=0; ++mp )
779          mp->count = mp->calls = 0;
780    }
781
782
783
784 void profileShow(void)
785 {
786    FILE *fp; int i;
787    double userDt, systDt;
788    double tickDt, realDt;
789    if( tsym == NULL || tmod == NULL ) return;
790    fp = prof_fp;
791    qsort(&tsym->sym[0],tsym->n,sizeof(tsym->sym[0]),cntCmpr);
792    /* outputs sorted (by count) list of functions called. */
793    fprintf(fp,"---- profile start ----\n");
794    fprintf(fp," %d ticks %d modules %d syms\n",nTicks,tmod->n,tsym->n);
795    tSym *sp = &tsym->sym[0];
796    for( i=tsym->n; --i>=0; ++sp ) {
797       if( !sp->count ) continue;
798       tMod *mp = &tmod->mod[sp->mod];
799       fprintf(fp,"%8.3fs %5.1f%% %-24s %s\n",
800         prof_tmrval*sp->count/1000000.0,
801         sp->count*100.0/nTicks,&sp->name[0],
802         &mp->name[0]);
803    }
804
805    qsort(&tsym->sym[0],tsym->n,sizeof(tsym->sym[0]),tclCmpr);
806    /* outputs sorted (by calls) list of functions called. */
807    fprintf(fp,"---- profile calls ----\n");
808    sp = &tsym->sym[0];
809    for( i=tsym->n; --i>=0; ++sp ) {
810       if( !sp->tcalls ) continue;
811       tMod *mp = &tmod->mod[sp->mod];
812       fprintf(fp,"%8.3fs %5.1f%% %-24s %5.1f %s\n",
813         prof_tmrval*sp->tcalls/1000000.0,
814         sp->tcalls*100.0/nTicks,&sp->name[0],
815         (double)sp->calls/sp->tcalls,&mp->name[0]);
816    }
817
818    realDt = ((stop_clk.tv_sec - start_clk.tv_sec) * 1000000.0 +
819                (stop_clk.tv_usec - start_clk.tv_usec) ) / 1000000.0;
820    /* output sorted (by count) list of modules called. */
821    qsort(&tmod->mod[0],tmod->n,sizeof(tmod->mod[0]),modCmpr);
822    fprintf(fp,"----\n");
823    tMod *mp = &tmod->mod[0];
824    for( i=tmod->n; --i>=0; ++mp ) {
825       if( mp->count != 0 && mp->name != NULL ) {
826          double dt = prof_tmrval*mp->count/1000000.0;
827          fprintf(fp,"%8.3fs %5.1f%%/%5.1f%% %s\n",
828             dt,mp->count*100.0/nTicks,dt*100.0/realDt,mp->name);
829       }
830    }
831
832    /* output tick time, cpu user/kernal time, real time. */
833    tickDt = prof_tmrval*nTicks / 1000000.0;
834    userDt = (stop_cpu.tms_utime - start_cpu.tms_utime) / (double)CLOCKS_PER_SEC;
835    systDt = (stop_cpu.tms_stime - start_cpu.tms_stime) / (double)CLOCKS_PER_SEC;
836
837    fprintf(fp,"%8.3ft %0.3fu+%0.3fs %0.3fr %5.1f%%\n",
838       tickDt, userDt, systDt, realDt, tickDt*100.0/realDt);
839    fprintf(fp,"---- profile end ----\n\n");
840    qsort(&tsym->sym[0],tsym->n,sizeof(tsym->sym[0]),adrCmpr);
841 }
842
843 void profileDone(void)
844 {
845    profileStop();
846    delModTbl(&tmod);
847    delSymTbl(&tsym);
848    if( prof_fp != NULL && prof_fp != stdout && prof_fp != stderr ) {
849       fclose(prof_fp);  prof_fp = NULL;
850    }
851 }
852