17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only
67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance
77c478bd9Sstevel@tonic-gate * with the License.
87c478bd9Sstevel@tonic-gate *
97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
127c478bd9Sstevel@tonic-gate * and limitations under the License.
137c478bd9Sstevel@tonic-gate *
147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
197c478bd9Sstevel@tonic-gate *
207c478bd9Sstevel@tonic-gate * CDDL HEADER END
217c478bd9Sstevel@tonic-gate */
227c478bd9Sstevel@tonic-gate /*
237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
247c478bd9Sstevel@tonic-gate * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate */
267c478bd9Sstevel@tonic-gate
277c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
287c478bd9Sstevel@tonic-gate /* All Rights Reserved */
297c478bd9Sstevel@tonic-gate
307c478bd9Sstevel@tonic-gate /*
317c478bd9Sstevel@tonic-gate * acctcms [-a] [-c] [-j] [-n] [-s] [-p] [-o] [-t] [file...]
327c478bd9Sstevel@tonic-gate * summarize per-process accounting
337c478bd9Sstevel@tonic-gate * -a output in ascii, rather than [pt]cms.h format
347c478bd9Sstevel@tonic-gate * -c sort by total cpu, rather than total kcore-minutes
357c478bd9Sstevel@tonic-gate * -j anything used only once -> ***other
367c478bd9Sstevel@tonic-gate * -n sort by number of processes
377c478bd9Sstevel@tonic-gate * -s any following files already in pcms.h format
387c478bd9Sstevel@tonic-gate * -p output prime time command summary (only with -a)
397c478bd9Sstevel@tonic-gate * -o output non-prime time (offshift) command summary (only
407c478bd9Sstevel@tonic-gate * with -a option)
417c478bd9Sstevel@tonic-gate * -t process records in total (old) style (tcms.h) format
427c478bd9Sstevel@tonic-gate * file file in [pt]cms.h (if -s seen already) or acct.h (if not)
437c478bd9Sstevel@tonic-gate * expected use:
447c478bd9Sstevel@tonic-gate * acctcms /var/adm/pacct? > today; acctcms -s old today >new
457c478bd9Sstevel@tonic-gate * cp new old; rm new
467c478bd9Sstevel@tonic-gate * acctcms -a today; acctcms -a old
477c478bd9Sstevel@tonic-gate */
487c478bd9Sstevel@tonic-gate #include <stdio.h>
497c478bd9Sstevel@tonic-gate #include <sys/types.h>
507c478bd9Sstevel@tonic-gate #include <sys/param.h>
517c478bd9Sstevel@tonic-gate #include "acctdef.h"
527c478bd9Sstevel@tonic-gate #include <ctype.h>
53414388d7Ssl #include <string.h>
547c478bd9Sstevel@tonic-gate #include <sys/acct.h>
55414388d7Ssl #include <stdlib.h>
567c478bd9Sstevel@tonic-gate
577c478bd9Sstevel@tonic-gate int csize = CSIZE;
587c478bd9Sstevel@tonic-gate
597c478bd9Sstevel@tonic-gate /*
607c478bd9Sstevel@tonic-gate * Total cms records format
617c478bd9Sstevel@tonic-gate */
627c478bd9Sstevel@tonic-gate struct tcms {
637c478bd9Sstevel@tonic-gate char tcm_comm[8]; /* command name */
647c478bd9Sstevel@tonic-gate long tcm_pc; /* number of processes */
657c478bd9Sstevel@tonic-gate float tcm_cpu; /* cpu time(min) */
667c478bd9Sstevel@tonic-gate float tcm_real; /* real time(min) */
677c478bd9Sstevel@tonic-gate float tcm_kcore; /* kcore-minutes */
687c478bd9Sstevel@tonic-gate ulong_t tcm_io; /* chars transferred */
697c478bd9Sstevel@tonic-gate ulong_t tcm_rw; /* blocks read */
707c478bd9Sstevel@tonic-gate } ;
717c478bd9Sstevel@tonic-gate struct tcms *tcm;
727c478bd9Sstevel@tonic-gate /*
737c478bd9Sstevel@tonic-gate * prime/nonprime CMS record format
747c478bd9Sstevel@tonic-gate */
757c478bd9Sstevel@tonic-gate struct pcms {
767c478bd9Sstevel@tonic-gate char pcm_comm[8]; /* command name */
777c478bd9Sstevel@tonic-gate long pcm_pc[2]; /* number of processes */
787c478bd9Sstevel@tonic-gate float pcm_cpu[2]; /* cpu time(min) */
797c478bd9Sstevel@tonic-gate float pcm_real[2]; /* real time(min) */
807c478bd9Sstevel@tonic-gate float pcm_kcore[2]; /* kcore-minutes */
817c478bd9Sstevel@tonic-gate float pcm_io[2]; /* chars transferred */
827c478bd9Sstevel@tonic-gate float pcm_rw[2]; /* blocks read */
837c478bd9Sstevel@tonic-gate } ;
847c478bd9Sstevel@tonic-gate struct pcms *pcm;
857c478bd9Sstevel@tonic-gate struct tcms tcmtmp = {{'*','*','*','o','t','h','e','r'}};
867c478bd9Sstevel@tonic-gate struct pcms pcmtmp = {{'*','*','*','o','t','h','e','r'}};
877c478bd9Sstevel@tonic-gate int aflg;
887c478bd9Sstevel@tonic-gate int cflg;
897c478bd9Sstevel@tonic-gate int jflg;
907c478bd9Sstevel@tonic-gate int nflg;
917c478bd9Sstevel@tonic-gate int sflg;
927c478bd9Sstevel@tonic-gate int pflg;
937c478bd9Sstevel@tonic-gate int oflg;
947c478bd9Sstevel@tonic-gate int tflg;
957c478bd9Sstevel@tonic-gate int errflg;
967c478bd9Sstevel@tonic-gate
977c478bd9Sstevel@tonic-gate #ifdef uts
987c478bd9Sstevel@tonic-gate float expand();
997c478bd9Sstevel@tonic-gate #else
1007c478bd9Sstevel@tonic-gate ulong_t expand();
1017c478bd9Sstevel@tonic-gate #endif
1027c478bd9Sstevel@tonic-gate
103414388d7Ssl void outputc(void);
104414388d7Ssl void totprnt(struct pcms *);
105414388d7Ssl void pprint(struct pcms *);
106414388d7Ssl void prnt(struct pcms *, int);
107414388d7Ssl void print(struct pcms *);
108414388d7Ssl void outputa(void);
109414388d7Ssl void toutptc(void);
110414388d7Ssl void tprint(struct tcms *);
111414388d7Ssl void toutpta(void);
112414388d7Ssl int ncmp(struct pcms *, struct pcms *);
113414388d7Ssl int tncmp(struct tcms *, struct tcms *);
114414388d7Ssl int tccmp(struct tcms *, struct tcms *);
115414388d7Ssl int tkcmp(struct tcms *, struct tcms *);
116414388d7Ssl int ccmp(struct pcms *, struct pcms *);
117414388d7Ssl int kcmp(struct pcms *, struct pcms *);
118414388d7Ssl void tdofile(char *);
119414388d7Ssl void dofile(char *);
120414388d7Ssl void tfixjunk(void);
121414388d7Ssl void fixjunk(void);
122414388d7Ssl void tcmadd(struct tcms *, struct tcms *);
123414388d7Ssl void pcmadd(struct pcms *, struct pcms *);
124414388d7Ssl void tsqueeze(void);
125414388d7Ssl void squeeze(void);
1267c478bd9Sstevel@tonic-gate
1277c478bd9Sstevel@tonic-gate /* Format specification for ASCII printing */
1287c478bd9Sstevel@tonic-gate
1297c478bd9Sstevel@tonic-gate char *fmtcmd = "%-8.8s",
1307c478bd9Sstevel@tonic-gate *fmtcnt = "%8ld",
1317c478bd9Sstevel@tonic-gate *fmtkcore = " %11.2f",
1327c478bd9Sstevel@tonic-gate *fmtcpu = " %9.2f",
1337c478bd9Sstevel@tonic-gate *fmtreal = " %12.2f",
1347c478bd9Sstevel@tonic-gate *fmtmsz = " %7.2f",
1357c478bd9Sstevel@tonic-gate *fmtmcpu = " %6.2f",
1367c478bd9Sstevel@tonic-gate *fmthog = " %5.2f",
1377c478bd9Sstevel@tonic-gate *fmtcharx = " %12.0f",
1387c478bd9Sstevel@tonic-gate *fmtblkx = " %10.0f" ;
1397c478bd9Sstevel@tonic-gate
140414388d7Ssl int
main(int argc,char ** argv)141414388d7Ssl main(int argc, char **argv)
1427c478bd9Sstevel@tonic-gate {
1437c478bd9Sstevel@tonic-gate int c;
1447c478bd9Sstevel@tonic-gate
1457c478bd9Sstevel@tonic-gate while((c = getopt(argc, argv, "acjnspot")) != EOF)
1467c478bd9Sstevel@tonic-gate switch(c) {
1477c478bd9Sstevel@tonic-gate case 'a':
1487c478bd9Sstevel@tonic-gate aflg++;
1497c478bd9Sstevel@tonic-gate continue;
1507c478bd9Sstevel@tonic-gate case 'c':
1517c478bd9Sstevel@tonic-gate cflg++;
1527c478bd9Sstevel@tonic-gate continue;
1537c478bd9Sstevel@tonic-gate case 'j':
1547c478bd9Sstevel@tonic-gate jflg++;
1557c478bd9Sstevel@tonic-gate continue;
1567c478bd9Sstevel@tonic-gate case 'n':
1577c478bd9Sstevel@tonic-gate nflg++;
1587c478bd9Sstevel@tonic-gate continue;
1597c478bd9Sstevel@tonic-gate case 's':
1607c478bd9Sstevel@tonic-gate sflg++;
1617c478bd9Sstevel@tonic-gate continue;
1627c478bd9Sstevel@tonic-gate case 'p':
1637c478bd9Sstevel@tonic-gate pflg++;
1647c478bd9Sstevel@tonic-gate continue;
1657c478bd9Sstevel@tonic-gate case 'o':
1667c478bd9Sstevel@tonic-gate oflg++;
1677c478bd9Sstevel@tonic-gate continue;
1687c478bd9Sstevel@tonic-gate case 't':
1697c478bd9Sstevel@tonic-gate tflg++;
1707c478bd9Sstevel@tonic-gate continue;
1717c478bd9Sstevel@tonic-gate default:
1727c478bd9Sstevel@tonic-gate errflg++;
1737c478bd9Sstevel@tonic-gate continue;
1747c478bd9Sstevel@tonic-gate }
1757c478bd9Sstevel@tonic-gate if(errflg){
1767c478bd9Sstevel@tonic-gate fprintf(stderr, "Usage: %s [-acjnspot] [file ...]\n", argv[0]);
1777c478bd9Sstevel@tonic-gate exit(1);
1787c478bd9Sstevel@tonic-gate }
1797c478bd9Sstevel@tonic-gate if(tflg) {
1807c478bd9Sstevel@tonic-gate if( (tcm = (struct tcms *)calloc(CSIZE, sizeof(struct tcms))) == NULL) {
1817c478bd9Sstevel@tonic-gate fprintf(stderr, "%s: Cannot allocate memory\n", argv[0]);
1827c478bd9Sstevel@tonic-gate exit(5);
1837c478bd9Sstevel@tonic-gate }
1847c478bd9Sstevel@tonic-gate for(; optind < argc; optind++)
1857c478bd9Sstevel@tonic-gate tdofile(argv[optind]);
1867c478bd9Sstevel@tonic-gate if (jflg)
1877c478bd9Sstevel@tonic-gate tfixjunk();
1887c478bd9Sstevel@tonic-gate tsqueeze();
189414388d7Ssl qsort(tcm, csize, sizeof(tcm[0]),
190414388d7Ssl (int (*)(const void *, const void *))
191414388d7Ssl ( nflg ? tncmp: (cflg? tccmp: tkcmp)));
1927c478bd9Sstevel@tonic-gate if (aflg)
1937c478bd9Sstevel@tonic-gate toutpta();
1947c478bd9Sstevel@tonic-gate else
1957c478bd9Sstevel@tonic-gate toutptc();
1967c478bd9Sstevel@tonic-gate } else {
1977c478bd9Sstevel@tonic-gate if( (pcm = (struct pcms *)calloc(CSIZE, sizeof(struct pcms))) == NULL) {
1987c478bd9Sstevel@tonic-gate fprintf(stderr, "%s: Cannot allocate memory\n", argv[0]);
1997c478bd9Sstevel@tonic-gate exit(6);
2007c478bd9Sstevel@tonic-gate }
2017c478bd9Sstevel@tonic-gate for(; optind < argc; optind++)
2027c478bd9Sstevel@tonic-gate dofile(argv[optind]);
2037c478bd9Sstevel@tonic-gate if (jflg)
2047c478bd9Sstevel@tonic-gate fixjunk();
2057c478bd9Sstevel@tonic-gate squeeze();
206414388d7Ssl qsort(pcm, csize, sizeof(pcm[0]),
207414388d7Ssl (int (*)(const void *, const void *))
208414388d7Ssl (nflg? ncmp: (cflg? ccmp: kcmp)));
2097c478bd9Sstevel@tonic-gate if (aflg)
2107c478bd9Sstevel@tonic-gate outputa();
2117c478bd9Sstevel@tonic-gate else
2127c478bd9Sstevel@tonic-gate outputc();
2137c478bd9Sstevel@tonic-gate }
2147c478bd9Sstevel@tonic-gate exit(0);
2157c478bd9Sstevel@tonic-gate
2167c478bd9Sstevel@tonic-gate }
2177c478bd9Sstevel@tonic-gate
218414388d7Ssl void
tdofile(char * fname)219414388d7Ssl tdofile(char *fname)
2207c478bd9Sstevel@tonic-gate {
2217c478bd9Sstevel@tonic-gate struct tcms cmt;
2227c478bd9Sstevel@tonic-gate union {
2237c478bd9Sstevel@tonic-gate struct acct ab; /* SVR4 acct structure */
2247c478bd9Sstevel@tonic-gate struct o_acct oab; /* SVR3 acct structure */
2257c478bd9Sstevel@tonic-gate } acct;
2267c478bd9Sstevel@tonic-gate int ver = 0;
2277c478bd9Sstevel@tonic-gate ulong_t mem;
2287c478bd9Sstevel@tonic-gate ulong_t cpu;
2297c478bd9Sstevel@tonic-gate ulong_t real;
2307c478bd9Sstevel@tonic-gate
2317c478bd9Sstevel@tonic-gate if (freopen(fname, "r", stdin) == NULL) {
2327c478bd9Sstevel@tonic-gate fprintf(stderr, "acctcms: cannot open %s\n", fname);
2337c478bd9Sstevel@tonic-gate return;
2347c478bd9Sstevel@tonic-gate }
2357c478bd9Sstevel@tonic-gate
2367c478bd9Sstevel@tonic-gate if (sflg)
2377c478bd9Sstevel@tonic-gate while (fread(&cmt, sizeof(cmt), 1, stdin) == 1)
2387c478bd9Sstevel@tonic-gate tenter(&cmt);
2397c478bd9Sstevel@tonic-gate else {
2407c478bd9Sstevel@tonic-gate if (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1)
2417c478bd9Sstevel@tonic-gate /* check for expanded account structure flag */
2427c478bd9Sstevel@tonic-gate if (acct.ab.ac_flag & AEXPND)
2437c478bd9Sstevel@tonic-gate ver = 2; /* 4.0 acct file */
2447c478bd9Sstevel@tonic-gate else
2457c478bd9Sstevel@tonic-gate ver = 1; /* SVR3.x acct file */
2467c478bd9Sstevel@tonic-gate
2477c478bd9Sstevel@tonic-gate rewind(stdin); /* reset file pointer */
2487c478bd9Sstevel@tonic-gate
2497c478bd9Sstevel@tonic-gate switch(ver) {
2507c478bd9Sstevel@tonic-gate
2517c478bd9Sstevel@tonic-gate default:
2527c478bd9Sstevel@tonic-gate /* this can't happen */
2537c478bd9Sstevel@tonic-gate fprintf(stderr, "acctcms: encountered bad version number\n");
2547c478bd9Sstevel@tonic-gate return;
2557c478bd9Sstevel@tonic-gate case 1 :
2567c478bd9Sstevel@tonic-gate while (fread(&acct.oab, sizeof(acct.oab), 1, stdin) == 1) {
2577c478bd9Sstevel@tonic-gate CPYN(cmt.tcm_comm, acct.oab.ac_comm);
2587c478bd9Sstevel@tonic-gate cmt.tcm_pc = 1;
2597c478bd9Sstevel@tonic-gate cpu = expand(acct.oab.ac_stime)+
2607c478bd9Sstevel@tonic-gate expand(acct.oab.ac_utime);
2617c478bd9Sstevel@tonic-gate cmt.tcm_cpu = MINT(cpu);
2627c478bd9Sstevel@tonic-gate real = expand(acct.oab.ac_etime);
2637c478bd9Sstevel@tonic-gate cmt.tcm_real = MINT(real);
2647c478bd9Sstevel@tonic-gate mem = expand(acct.oab.ac_mem);
2657c478bd9Sstevel@tonic-gate cmt.tcm_kcore = MINT(KCORE(mem));
2667c478bd9Sstevel@tonic-gate cmt.tcm_io = expand(acct.oab.ac_io);
2677c478bd9Sstevel@tonic-gate cmt.tcm_rw = expand(acct.oab.ac_rw);
2687c478bd9Sstevel@tonic-gate tenter(&cmt);
2697c478bd9Sstevel@tonic-gate }
2707c478bd9Sstevel@tonic-gate break;
2717c478bd9Sstevel@tonic-gate case 2 :
2727c478bd9Sstevel@tonic-gate
2737c478bd9Sstevel@tonic-gate while (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1) {
2747c478bd9Sstevel@tonic-gate CPYN(cmt.tcm_comm, acct.ab.ac_comm);
2757c478bd9Sstevel@tonic-gate cmt.tcm_pc = 1;
2767c478bd9Sstevel@tonic-gate cpu = expand(acct.oab.ac_stime)+
2777c478bd9Sstevel@tonic-gate expand(acct.oab.ac_utime);
2787c478bd9Sstevel@tonic-gate cmt.tcm_cpu = MINT(cpu);
2797c478bd9Sstevel@tonic-gate real = expand(acct.ab.ac_etime);
2807c478bd9Sstevel@tonic-gate cmt.tcm_real = MINT(real);
2817c478bd9Sstevel@tonic-gate mem = expand(acct.ab.ac_mem);
2827c478bd9Sstevel@tonic-gate cmt.tcm_kcore = MINT(KCORE(mem));
2837c478bd9Sstevel@tonic-gate cmt.tcm_io = expand(acct.ab.ac_io);
2847c478bd9Sstevel@tonic-gate cmt.tcm_rw = expand(acct.ab.ac_rw);
2857c478bd9Sstevel@tonic-gate tenter(&cmt);
2867c478bd9Sstevel@tonic-gate }
2877c478bd9Sstevel@tonic-gate break;
2887c478bd9Sstevel@tonic-gate }
2897c478bd9Sstevel@tonic-gate }
2907c478bd9Sstevel@tonic-gate }
2917c478bd9Sstevel@tonic-gate
292414388d7Ssl void
dofile(char * fname)293414388d7Ssl dofile(char *fname)
2947c478bd9Sstevel@tonic-gate {
2957c478bd9Sstevel@tonic-gate union {
2967c478bd9Sstevel@tonic-gate struct acct ab;
2977c478bd9Sstevel@tonic-gate struct o_acct oab;
2987c478bd9Sstevel@tonic-gate } acct;
2997c478bd9Sstevel@tonic-gate struct pcms pcmt;
3007c478bd9Sstevel@tonic-gate double ratio;
3017c478bd9Sstevel@tonic-gate long elaps[2];
3027c478bd9Sstevel@tonic-gate ulong_t etime;
3037c478bd9Sstevel@tonic-gate double dtmp;
3047c478bd9Sstevel@tonic-gate unsigned long ltmp;
3057c478bd9Sstevel@tonic-gate ulong_t mem;
3067c478bd9Sstevel@tonic-gate ulong_t cpu;
3077c478bd9Sstevel@tonic-gate ulong_t real;
3087c478bd9Sstevel@tonic-gate
3097c478bd9Sstevel@tonic-gate if (freopen(fname, "r", stdin) == NULL) {
3107c478bd9Sstevel@tonic-gate fprintf(stderr, "acctcms: cannot open %s\n", fname);
3117c478bd9Sstevel@tonic-gate return;
3127c478bd9Sstevel@tonic-gate }
3137c478bd9Sstevel@tonic-gate
3147c478bd9Sstevel@tonic-gate if (sflg)
3157c478bd9Sstevel@tonic-gate while (fread(&pcmt, sizeof(pcmt), 1, stdin) == 1)
3167c478bd9Sstevel@tonic-gate enter(&pcmt);
3177c478bd9Sstevel@tonic-gate else {
3187c478bd9Sstevel@tonic-gate int ver = 0;
3197c478bd9Sstevel@tonic-gate
3207c478bd9Sstevel@tonic-gate if (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1)
3217c478bd9Sstevel@tonic-gate /* check for expanded account structure flag */
3227c478bd9Sstevel@tonic-gate if (acct.ab.ac_flag & AEXPND)
3237c478bd9Sstevel@tonic-gate ver = 2; /* 4.0 acct file */
3247c478bd9Sstevel@tonic-gate else
3257c478bd9Sstevel@tonic-gate ver = 1; /* SVR3.x acct file */
3267c478bd9Sstevel@tonic-gate
3277c478bd9Sstevel@tonic-gate rewind(stdin); /* reset file pointer */
3287c478bd9Sstevel@tonic-gate
3297c478bd9Sstevel@tonic-gate switch(ver) {
3307c478bd9Sstevel@tonic-gate
3317c478bd9Sstevel@tonic-gate default :
3327c478bd9Sstevel@tonic-gate /* this can't happen */
3337c478bd9Sstevel@tonic-gate fprintf(stderr, "acctcms: encountered bad version number\n");
3347c478bd9Sstevel@tonic-gate return;
3357c478bd9Sstevel@tonic-gate case 1 :
336*2a8bcb4eSToomas Soome
3377c478bd9Sstevel@tonic-gate while (fread(&acct.oab, sizeof(acct.oab), 1, stdin) == 1) {
3387c478bd9Sstevel@tonic-gate CPYN(pcmt.pcm_comm, acct.oab.ac_comm);
3397c478bd9Sstevel@tonic-gate /*
3407c478bd9Sstevel@tonic-gate ** Approximate P/NP split as same as elapsed time
3417c478bd9Sstevel@tonic-gate */
3427c478bd9Sstevel@tonic-gate if((etime = SECS(expand(acct.oab.ac_etime))) == 0)
3437c478bd9Sstevel@tonic-gate etime = 1;
3447c478bd9Sstevel@tonic-gate if (pnpsplit(acct.oab.ac_btime, etime, elaps)
3457c478bd9Sstevel@tonic-gate == 0) {
3467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "acctcms: could "
3477c478bd9Sstevel@tonic-gate "not calculate prime/non-prime "
3487c478bd9Sstevel@tonic-gate "hours\n");
3497c478bd9Sstevel@tonic-gate exit(1);
3507c478bd9Sstevel@tonic-gate }
3517c478bd9Sstevel@tonic-gate ratio = (double)elaps[PRIME]/(double)etime;
3527c478bd9Sstevel@tonic-gate if(elaps[PRIME] > elaps[NONPRIME]) {
3537c478bd9Sstevel@tonic-gate pcmt.pcm_pc[PRIME] = 1;
3547c478bd9Sstevel@tonic-gate pcmt.pcm_pc[NONPRIME] = 0;
3557c478bd9Sstevel@tonic-gate } else {
3567c478bd9Sstevel@tonic-gate pcmt.pcm_pc[PRIME] = 0;
3577c478bd9Sstevel@tonic-gate pcmt.pcm_pc[NONPRIME] = 1;
3587c478bd9Sstevel@tonic-gate }
3597c478bd9Sstevel@tonic-gate cpu = expand(acct.oab.ac_stime)+
3607c478bd9Sstevel@tonic-gate expand(acct.oab.ac_utime);
3617c478bd9Sstevel@tonic-gate dtmp = MINT(cpu);
3627c478bd9Sstevel@tonic-gate pcmt.pcm_cpu[PRIME] = dtmp * ratio;
3637c478bd9Sstevel@tonic-gate pcmt.pcm_cpu[NONPRIME] = (ratio == 1.0) ? 0.0 :
3647c478bd9Sstevel@tonic-gate (dtmp - pcmt.pcm_cpu[PRIME]);
3657c478bd9Sstevel@tonic-gate real = expand(acct.oab.ac_etime);
3667c478bd9Sstevel@tonic-gate dtmp = MINT(real);
3677c478bd9Sstevel@tonic-gate pcmt.pcm_real[PRIME] = dtmp * ratio;
3687c478bd9Sstevel@tonic-gate pcmt.pcm_real[NONPRIME] = (ratio == 1.0) ? 0.0 :
3697c478bd9Sstevel@tonic-gate (dtmp - pcmt.pcm_real[PRIME]);
3707c478bd9Sstevel@tonic-gate mem = expand(acct.oab.ac_mem);
3717c478bd9Sstevel@tonic-gate dtmp = MINT(KCORE(mem));
3727c478bd9Sstevel@tonic-gate pcmt.pcm_kcore[PRIME] = dtmp * ratio;
3737c478bd9Sstevel@tonic-gate pcmt.pcm_kcore[NONPRIME] = (ratio == 1.0) ? 0.0 :
3747c478bd9Sstevel@tonic-gate (dtmp - pcmt.pcm_kcore[PRIME]);
3757c478bd9Sstevel@tonic-gate ltmp = expand(acct.oab.ac_io);
3767c478bd9Sstevel@tonic-gate pcmt.pcm_io[PRIME] = (double)ltmp * ratio;
3777c478bd9Sstevel@tonic-gate pcmt.pcm_io[NONPRIME] = (ratio == 1.0) ? 0.0 :
3787c478bd9Sstevel@tonic-gate ((double)ltmp - pcmt.pcm_io[PRIME]);
3797c478bd9Sstevel@tonic-gate ltmp = expand(acct.oab.ac_rw);
3807c478bd9Sstevel@tonic-gate pcmt.pcm_rw[PRIME] = (double)ltmp * ratio;
3817c478bd9Sstevel@tonic-gate pcmt.pcm_rw[NONPRIME] = (ratio == 1.0) ? 0.0 :
3827c478bd9Sstevel@tonic-gate ((double)ltmp - pcmt.pcm_rw[PRIME]);
3837c478bd9Sstevel@tonic-gate enter(&pcmt);
3847c478bd9Sstevel@tonic-gate }
3857c478bd9Sstevel@tonic-gate
3867c478bd9Sstevel@tonic-gate break;
3877c478bd9Sstevel@tonic-gate case 2 :
3887c478bd9Sstevel@tonic-gate while (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1) {
3897c478bd9Sstevel@tonic-gate CPYN(pcmt.pcm_comm, acct.ab.ac_comm);
3907c478bd9Sstevel@tonic-gate /*
3917c478bd9Sstevel@tonic-gate ** Approximate P/NP split as same as elapsed time
3927c478bd9Sstevel@tonic-gate */
3937c478bd9Sstevel@tonic-gate if((etime = SECS(expand(acct.ab.ac_etime))) == 0)
3947c478bd9Sstevel@tonic-gate etime = 1;
3957c478bd9Sstevel@tonic-gate if(pnpsplit(acct.ab.ac_btime, etime, elaps) == 0) {
3967c478bd9Sstevel@tonic-gate fprintf(stderr, "acctcms: could not calculate prime/non-prime hours\n");
3977c478bd9Sstevel@tonic-gate exit(1);
3987c478bd9Sstevel@tonic-gate }
3997c478bd9Sstevel@tonic-gate ratio = (double)elaps[PRIME]/(double)etime;
4007c478bd9Sstevel@tonic-gate if(elaps[PRIME] > elaps[NONPRIME]) {
4017c478bd9Sstevel@tonic-gate pcmt.pcm_pc[PRIME] = 1;
4027c478bd9Sstevel@tonic-gate pcmt.pcm_pc[NONPRIME] = 0;
4037c478bd9Sstevel@tonic-gate } else {
4047c478bd9Sstevel@tonic-gate pcmt.pcm_pc[PRIME] = 0;
4057c478bd9Sstevel@tonic-gate pcmt.pcm_pc[NONPRIME] = 1;
4067c478bd9Sstevel@tonic-gate }
4077c478bd9Sstevel@tonic-gate cpu = expand(acct.ab.ac_stime)+
4087c478bd9Sstevel@tonic-gate expand(acct.ab.ac_utime);
4097c478bd9Sstevel@tonic-gate dtmp = MINT(cpu);
4107c478bd9Sstevel@tonic-gate pcmt.pcm_cpu[PRIME] = dtmp * ratio;
4117c478bd9Sstevel@tonic-gate pcmt.pcm_cpu[NONPRIME] = (ratio == 1.0) ? 0.0 :
4127c478bd9Sstevel@tonic-gate (dtmp - pcmt.pcm_cpu[PRIME]);
4137c478bd9Sstevel@tonic-gate real = expand(acct.ab.ac_etime);
4147c478bd9Sstevel@tonic-gate dtmp = MINT(real);
4157c478bd9Sstevel@tonic-gate pcmt.pcm_real[PRIME] = dtmp * ratio;
4167c478bd9Sstevel@tonic-gate pcmt.pcm_real[NONPRIME] = (ratio == 1.0) ? 0.0 :
4177c478bd9Sstevel@tonic-gate (dtmp - pcmt.pcm_real[PRIME]);
4187c478bd9Sstevel@tonic-gate mem = expand(acct.ab.ac_mem);
4197c478bd9Sstevel@tonic-gate dtmp = MINT(KCORE(mem));
4207c478bd9Sstevel@tonic-gate pcmt.pcm_kcore[PRIME] = dtmp * ratio;
4217c478bd9Sstevel@tonic-gate pcmt.pcm_kcore[NONPRIME] = (ratio == 1.0) ? 0.0 :
4227c478bd9Sstevel@tonic-gate (dtmp - pcmt.pcm_kcore[PRIME]);
4237c478bd9Sstevel@tonic-gate ltmp = expand(acct.ab.ac_io);
4247c478bd9Sstevel@tonic-gate pcmt.pcm_io[PRIME] = (double)ltmp * ratio;
4257c478bd9Sstevel@tonic-gate pcmt.pcm_io[NONPRIME] = (ratio == 1.0) ? 0.0 :
4267c478bd9Sstevel@tonic-gate ((double)ltmp - pcmt.pcm_io[PRIME]);
4277c478bd9Sstevel@tonic-gate ltmp = expand(acct.ab.ac_rw);
4287c478bd9Sstevel@tonic-gate pcmt.pcm_rw[PRIME] = (double)ltmp * ratio;
4297c478bd9Sstevel@tonic-gate pcmt.pcm_rw[NONPRIME] = (ratio == 1.0) ? 0.0 :
4307c478bd9Sstevel@tonic-gate ((double)ltmp - pcmt.pcm_rw[PRIME]);
4317c478bd9Sstevel@tonic-gate enter(&pcmt);
4327c478bd9Sstevel@tonic-gate }
4337c478bd9Sstevel@tonic-gate
4347c478bd9Sstevel@tonic-gate break;
4357c478bd9Sstevel@tonic-gate }
4367c478bd9Sstevel@tonic-gate }
4377c478bd9Sstevel@tonic-gate }
4387c478bd9Sstevel@tonic-gate
439414388d7Ssl int
tenter(struct tcms * p)440414388d7Ssl tenter(struct tcms *p)
4417c478bd9Sstevel@tonic-gate {
442414388d7Ssl int i;
443414388d7Ssl int j;
444414388d7Ssl struct tcms *ntcm;
4457c478bd9Sstevel@tonic-gate for (i = j = 0; j < sizeof(p->tcm_comm); j++) {
4467c478bd9Sstevel@tonic-gate if (p->tcm_comm[j] && p->tcm_comm[j] <= 037)
4477c478bd9Sstevel@tonic-gate p->tcm_comm[j] = '?';
4487c478bd9Sstevel@tonic-gate i = i*7 + p->tcm_comm[j]; /* hash function */
4497c478bd9Sstevel@tonic-gate }
4507c478bd9Sstevel@tonic-gate if (i < 0)
4517c478bd9Sstevel@tonic-gate i = -i;
4527c478bd9Sstevel@tonic-gate for (i %= csize, j = 0; tcm[i].tcm_comm[0] && j != csize; i = (i+1)%csize, j++)
4537c478bd9Sstevel@tonic-gate if (EQN(p->tcm_comm, tcm[i].tcm_comm))
4547c478bd9Sstevel@tonic-gate break;
4557c478bd9Sstevel@tonic-gate if(j == csize) {
4567c478bd9Sstevel@tonic-gate if ((ntcm = (struct tcms *) realloc(tcm,
4577c478bd9Sstevel@tonic-gate (csize + CSIZE - 1) * sizeof (struct tcms))) == NULL) {
4587c478bd9Sstevel@tonic-gate fprintf(stderr,
4597c478bd9Sstevel@tonic-gate "acctcms: Cannot reallocate memory (tcm)\n");
4607c478bd9Sstevel@tonic-gate return(-1);
4617c478bd9Sstevel@tonic-gate } else {
4627c478bd9Sstevel@tonic-gate memset(&ntcm[csize], 0, CSIZE - 1);
4637c478bd9Sstevel@tonic-gate tcm = ntcm;
4647c478bd9Sstevel@tonic-gate if (!EQN(p->tcm_comm, tcm[i].tcm_comm))
4657c478bd9Sstevel@tonic-gate i = csize;
4667c478bd9Sstevel@tonic-gate csize = csize + CSIZE - 1;
4677c478bd9Sstevel@tonic-gate }
4687c478bd9Sstevel@tonic-gate }
4697c478bd9Sstevel@tonic-gate if (tcm[i].tcm_comm[0] == 0)
4707c478bd9Sstevel@tonic-gate CPYN(tcm[i].tcm_comm, p->tcm_comm);
4717c478bd9Sstevel@tonic-gate tcmadd(&tcm[i], p);
4727c478bd9Sstevel@tonic-gate return(i);
4737c478bd9Sstevel@tonic-gate }
474414388d7Ssl
475414388d7Ssl int
enter(struct pcms * p)476414388d7Ssl enter(struct pcms *p)
4777c478bd9Sstevel@tonic-gate {
478414388d7Ssl int i;
479414388d7Ssl int j;
480414388d7Ssl struct pcms *npcm;
4817c478bd9Sstevel@tonic-gate for (i = j = 0; j < sizeof(p->pcm_comm); j++) {
4827c478bd9Sstevel@tonic-gate if (p->pcm_comm[j] && p->pcm_comm[j] <= 037)
4837c478bd9Sstevel@tonic-gate p->pcm_comm[j] = '?';
4847c478bd9Sstevel@tonic-gate i = i*7 + p->pcm_comm[j]; /* hash function */
4857c478bd9Sstevel@tonic-gate }
4867c478bd9Sstevel@tonic-gate if (i < 0)
4877c478bd9Sstevel@tonic-gate i = -i;
4887c478bd9Sstevel@tonic-gate for (i %= csize, j = 0; pcm[i].pcm_comm[0] && j != csize; i = (i+1)%csize, j++)
4897c478bd9Sstevel@tonic-gate if (EQN(p->pcm_comm, pcm[i].pcm_comm))
4907c478bd9Sstevel@tonic-gate break;
4917c478bd9Sstevel@tonic-gate if(j == csize) {
4927c478bd9Sstevel@tonic-gate if ((npcm = (struct pcms *) realloc(pcm,
4937c478bd9Sstevel@tonic-gate (csize + CSIZE - 1) * sizeof (struct pcms))) == NULL) {
4947c478bd9Sstevel@tonic-gate fprintf(stderr,
4957c478bd9Sstevel@tonic-gate "acctcms: Cannot reallocate memory (pcm)\n");
4967c478bd9Sstevel@tonic-gate return(-1);
4977c478bd9Sstevel@tonic-gate } else {
4987c478bd9Sstevel@tonic-gate memset(&npcm[csize], 0, CSIZE - 1);
4997c478bd9Sstevel@tonic-gate pcm = npcm;
5007c478bd9Sstevel@tonic-gate if (!EQN(p->pcm_comm, pcm[i].pcm_comm))
5017c478bd9Sstevel@tonic-gate i = csize;
5027c478bd9Sstevel@tonic-gate csize = csize + CSIZE - 1;
5037c478bd9Sstevel@tonic-gate }
5047c478bd9Sstevel@tonic-gate }
5057c478bd9Sstevel@tonic-gate if (pcm[i].pcm_comm[0] == 0)
5067c478bd9Sstevel@tonic-gate CPYN(pcm[i].pcm_comm, p->pcm_comm);
5077c478bd9Sstevel@tonic-gate pcmadd(&pcm[i], p);
5087c478bd9Sstevel@tonic-gate return(i);
5097c478bd9Sstevel@tonic-gate }
510414388d7Ssl
511414388d7Ssl void
tfixjunk(void)512414388d7Ssl tfixjunk(void) /* combine commands used only once */
5137c478bd9Sstevel@tonic-gate {
514414388d7Ssl int i, j;
515414388d7Ssl j = tenter(&tcmtmp);
5167c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
5177c478bd9Sstevel@tonic-gate if (i != j && tcm[i].tcm_comm[0] && tcm[i].tcm_pc <= 1) {
5187c478bd9Sstevel@tonic-gate tcmadd(&tcm[j], &tcm[i]);
5197c478bd9Sstevel@tonic-gate tcm[i].tcm_comm[0] = 0;
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate }
522414388d7Ssl
523414388d7Ssl void
fixjunk(void)524414388d7Ssl fixjunk(void) /* combine commands used only once */
5257c478bd9Sstevel@tonic-gate {
526414388d7Ssl int i, j;
5277c478bd9Sstevel@tonic-gate j = enter(&pcmtmp);
5287c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
5297c478bd9Sstevel@tonic-gate if (i != j && pcm[i].pcm_comm[0] && (pcm[i].pcm_pc[PRIME] + pcm[i].pcm_pc[NONPRIME]) <= 1) {
5307c478bd9Sstevel@tonic-gate pcmadd(&pcm[j], &pcm[i]);
5317c478bd9Sstevel@tonic-gate pcm[i].pcm_comm[0] = 0;
5327c478bd9Sstevel@tonic-gate }
5337c478bd9Sstevel@tonic-gate }
5347c478bd9Sstevel@tonic-gate
535414388d7Ssl void
tcmadd(struct tcms * p1,struct tcms * p2)536414388d7Ssl tcmadd(struct tcms *p1, struct tcms *p2)
5377c478bd9Sstevel@tonic-gate {
5387c478bd9Sstevel@tonic-gate p1->tcm_pc += p2->tcm_pc;
5397c478bd9Sstevel@tonic-gate p1->tcm_cpu = p1->tcm_cpu + p2->tcm_cpu;
5407c478bd9Sstevel@tonic-gate p1->tcm_real = p1->tcm_real + p2->tcm_real;
5417c478bd9Sstevel@tonic-gate p1->tcm_kcore = p1->tcm_kcore + p2->tcm_kcore;
5427c478bd9Sstevel@tonic-gate p1->tcm_io += p2->tcm_io;
5437c478bd9Sstevel@tonic-gate p1->tcm_rw += p2->tcm_rw;
5447c478bd9Sstevel@tonic-gate }
545414388d7Ssl
546414388d7Ssl void
pcmadd(struct pcms * p1,struct pcms * p2)547414388d7Ssl pcmadd(struct pcms *p1, struct pcms *p2)
5487c478bd9Sstevel@tonic-gate {
5497c478bd9Sstevel@tonic-gate p1->pcm_pc[PRIME] += p2->pcm_pc[PRIME];
5507c478bd9Sstevel@tonic-gate p1->pcm_pc[NONPRIME] += p2->pcm_pc[NONPRIME];
5517c478bd9Sstevel@tonic-gate p1->pcm_cpu[PRIME] += p2->pcm_cpu[PRIME];
5527c478bd9Sstevel@tonic-gate p1->pcm_cpu[NONPRIME] += p2->pcm_cpu[NONPRIME];
5537c478bd9Sstevel@tonic-gate p1->pcm_real[PRIME] += p2->pcm_real[PRIME];
5547c478bd9Sstevel@tonic-gate p1->pcm_real[NONPRIME] += p2->pcm_real[NONPRIME];
5557c478bd9Sstevel@tonic-gate p1->pcm_kcore[PRIME] += p2->pcm_kcore[PRIME];
5567c478bd9Sstevel@tonic-gate p1->pcm_kcore[NONPRIME] += p2->pcm_kcore[NONPRIME];
5577c478bd9Sstevel@tonic-gate p1->pcm_io[PRIME] += p2->pcm_io[PRIME];
5587c478bd9Sstevel@tonic-gate p1->pcm_io[NONPRIME] += p2->pcm_io[NONPRIME];
5597c478bd9Sstevel@tonic-gate p1->pcm_rw[PRIME] += p2->pcm_rw[PRIME];
5607c478bd9Sstevel@tonic-gate p1->pcm_rw[NONPRIME] += p2->pcm_rw[NONPRIME];
5617c478bd9Sstevel@tonic-gate }
5627c478bd9Sstevel@tonic-gate
563414388d7Ssl void
tsqueeze(void)564414388d7Ssl tsqueeze(void) /* get rid of holes in hash table */
5657c478bd9Sstevel@tonic-gate {
566414388d7Ssl int i, k;
5677c478bd9Sstevel@tonic-gate
5687c478bd9Sstevel@tonic-gate for (i = k = 0; i < csize; i++)
5697c478bd9Sstevel@tonic-gate if (tcm[i].tcm_comm[0]) {
5707c478bd9Sstevel@tonic-gate CPYN(tcm[k].tcm_comm, tcm[i].tcm_comm);
5717c478bd9Sstevel@tonic-gate tcm[k].tcm_pc = tcm[i].tcm_pc;
5727c478bd9Sstevel@tonic-gate tcm[k].tcm_cpu = tcm[i].tcm_cpu;
5737c478bd9Sstevel@tonic-gate tcm[k].tcm_real = tcm[i].tcm_real;
5747c478bd9Sstevel@tonic-gate tcm[k].tcm_kcore = tcm[i].tcm_kcore;
5757c478bd9Sstevel@tonic-gate tcm[k].tcm_io = tcm[i].tcm_io;
5767c478bd9Sstevel@tonic-gate tcm[k].tcm_rw = tcm[i].tcm_rw;
5777c478bd9Sstevel@tonic-gate k++;
5787c478bd9Sstevel@tonic-gate }
5797c478bd9Sstevel@tonic-gate csize = k;
5807c478bd9Sstevel@tonic-gate }
581414388d7Ssl
582414388d7Ssl void
squeeze(void)583414388d7Ssl squeeze(void) /* get rid of holes in hash table */
5847c478bd9Sstevel@tonic-gate {
585414388d7Ssl int i, k;
5867c478bd9Sstevel@tonic-gate
5877c478bd9Sstevel@tonic-gate for (i = k = 0; i < csize; i++)
5887c478bd9Sstevel@tonic-gate if (pcm[i].pcm_comm[0]) {
5897c478bd9Sstevel@tonic-gate CPYN(pcm[k].pcm_comm, pcm[i].pcm_comm);
5907c478bd9Sstevel@tonic-gate pcm[k].pcm_pc[PRIME] = pcm[i].pcm_pc[PRIME];
5917c478bd9Sstevel@tonic-gate pcm[k].pcm_pc[NONPRIME] = pcm[i].pcm_pc[NONPRIME];
5927c478bd9Sstevel@tonic-gate pcm[k].pcm_cpu[PRIME] = pcm[i].pcm_cpu[PRIME];
5937c478bd9Sstevel@tonic-gate pcm[k].pcm_cpu[NONPRIME] = pcm[i].pcm_cpu[NONPRIME];
5947c478bd9Sstevel@tonic-gate pcm[k].pcm_real[PRIME] = pcm[i].pcm_real[PRIME];
5957c478bd9Sstevel@tonic-gate pcm[k].pcm_real[NONPRIME] = pcm[i].pcm_real[NONPRIME];
5967c478bd9Sstevel@tonic-gate pcm[k].pcm_kcore[PRIME] = pcm[i].pcm_kcore[PRIME];
5977c478bd9Sstevel@tonic-gate pcm[k].pcm_kcore[NONPRIME] = pcm[i].pcm_kcore[NONPRIME];
5987c478bd9Sstevel@tonic-gate pcm[k].pcm_io[PRIME] = pcm[i].pcm_io[PRIME];
5997c478bd9Sstevel@tonic-gate pcm[k].pcm_io[NONPRIME] = pcm[i].pcm_io[NONPRIME];
6007c478bd9Sstevel@tonic-gate pcm[k].pcm_rw[PRIME] = pcm[i].pcm_rw[PRIME];
6017c478bd9Sstevel@tonic-gate pcm[k].pcm_rw[NONPRIME] = pcm[i].pcm_rw[NONPRIME];
6027c478bd9Sstevel@tonic-gate k++;
6037c478bd9Sstevel@tonic-gate }
6047c478bd9Sstevel@tonic-gate csize = k;
6057c478bd9Sstevel@tonic-gate }
6067c478bd9Sstevel@tonic-gate
607414388d7Ssl int
tccmp(struct tcms * p1,struct tcms * p2)608414388d7Ssl tccmp(struct tcms *p1, struct tcms *p2)
6097c478bd9Sstevel@tonic-gate {
6107c478bd9Sstevel@tonic-gate if (p1->tcm_cpu == p2->tcm_cpu)
6117c478bd9Sstevel@tonic-gate return(0);
6127c478bd9Sstevel@tonic-gate return ((p2->tcm_cpu > p1->tcm_cpu)? 1 : -1);
6137c478bd9Sstevel@tonic-gate }
6147c478bd9Sstevel@tonic-gate
615414388d7Ssl int
ccmp(struct pcms * p1,struct pcms * p2)616414388d7Ssl ccmp(struct pcms *p1, struct pcms *p2)
6177c478bd9Sstevel@tonic-gate {
618414388d7Ssl int index;
6197c478bd9Sstevel@tonic-gate
6207c478bd9Sstevel@tonic-gate if( (pflg && oflg) || (!pflg && !oflg) ) {
6217c478bd9Sstevel@tonic-gate if (p1->pcm_cpu[PRIME] + p1->pcm_cpu[NONPRIME] == p2->pcm_cpu[PRIME] + p2->pcm_cpu[NONPRIME])
6227c478bd9Sstevel@tonic-gate return(0);
6237c478bd9Sstevel@tonic-gate return ((p2->pcm_cpu[PRIME] + p2->pcm_cpu[NONPRIME] > p1->pcm_cpu[PRIME] + p1->pcm_cpu[NONPRIME])? 1 : -1);
6247c478bd9Sstevel@tonic-gate }
6257c478bd9Sstevel@tonic-gate index = pflg ? PRIME : NONPRIME;
6267c478bd9Sstevel@tonic-gate if (p1->pcm_cpu[index] == p2->pcm_cpu[index])
6277c478bd9Sstevel@tonic-gate return(0);
6287c478bd9Sstevel@tonic-gate return ((p2->pcm_cpu[index] > p1->pcm_cpu[index])? 1 : -1);
6297c478bd9Sstevel@tonic-gate }
6307c478bd9Sstevel@tonic-gate
631414388d7Ssl int
tkcmp(struct tcms * p1,struct tcms * p2)632414388d7Ssl tkcmp(struct tcms *p1, struct tcms *p2)
6337c478bd9Sstevel@tonic-gate {
6347c478bd9Sstevel@tonic-gate if (p1->tcm_kcore == p2->tcm_kcore)
6357c478bd9Sstevel@tonic-gate return(0);
6367c478bd9Sstevel@tonic-gate return ((p2->tcm_kcore > p1->tcm_kcore)? 1 : -1);
6377c478bd9Sstevel@tonic-gate }
6387c478bd9Sstevel@tonic-gate
639414388d7Ssl int
kcmp(struct pcms * p1,struct pcms * p2)640414388d7Ssl kcmp(struct pcms *p1, struct pcms *p2)
6417c478bd9Sstevel@tonic-gate {
642414388d7Ssl int index;
6437c478bd9Sstevel@tonic-gate
6447c478bd9Sstevel@tonic-gate if( (pflg && oflg) || (!pflg && !pflg) ){
6457c478bd9Sstevel@tonic-gate if (p1->pcm_kcore[PRIME] + p1->pcm_kcore[NONPRIME] == p2->pcm_kcore[PRIME] + p2->pcm_kcore[NONPRIME])
6467c478bd9Sstevel@tonic-gate return(0);
6477c478bd9Sstevel@tonic-gate return ((p2->pcm_kcore[PRIME] + p2->pcm_kcore[NONPRIME] > p1->pcm_kcore[PRIME] + p1->pcm_kcore[NONPRIME])? 1 : -1);
6487c478bd9Sstevel@tonic-gate }
6497c478bd9Sstevel@tonic-gate index = pflg ? PRIME : NONPRIME;
6507c478bd9Sstevel@tonic-gate if (p1->pcm_kcore[index] == p2->pcm_kcore[index])
6517c478bd9Sstevel@tonic-gate return(0);
6527c478bd9Sstevel@tonic-gate return ((p2->pcm_kcore[index] > p1->pcm_kcore[index])? 1 : -1);
6537c478bd9Sstevel@tonic-gate }
6547c478bd9Sstevel@tonic-gate
655414388d7Ssl int
tncmp(struct tcms * p1,struct tcms * p2)656414388d7Ssl tncmp(struct tcms *p1, struct tcms *p2)
6577c478bd9Sstevel@tonic-gate {
6587c478bd9Sstevel@tonic-gate if (p1->tcm_pc == p2->tcm_pc)
6597c478bd9Sstevel@tonic-gate return(0);
6607c478bd9Sstevel@tonic-gate return ((p2->tcm_pc > p1->tcm_pc)? 1 : -1);
6617c478bd9Sstevel@tonic-gate }
6627c478bd9Sstevel@tonic-gate
663414388d7Ssl int
ncmp(struct pcms * p1,struct pcms * p2)664414388d7Ssl ncmp(struct pcms *p1, struct pcms *p2)
6657c478bd9Sstevel@tonic-gate {
666414388d7Ssl int index;
6677c478bd9Sstevel@tonic-gate
6687c478bd9Sstevel@tonic-gate if( (pflg && oflg) || (!pflg && !oflg) ) {
6697c478bd9Sstevel@tonic-gate if (p1->pcm_pc[PRIME] + p1->pcm_pc[NONPRIME] == p2->pcm_pc[PRIME] + p2->pcm_pc[NONPRIME])
6707c478bd9Sstevel@tonic-gate return(0);
6717c478bd9Sstevel@tonic-gate return ((p2->pcm_pc[PRIME] + p2->pcm_pc[NONPRIME] > p1->pcm_pc[PRIME] + p1->pcm_pc[NONPRIME])? 1 : -1);
6727c478bd9Sstevel@tonic-gate }
6737c478bd9Sstevel@tonic-gate index = pflg ? PRIME : NONPRIME;
6747c478bd9Sstevel@tonic-gate if (p1->pcm_pc[index] == p2->pcm_pc[index])
6757c478bd9Sstevel@tonic-gate return(0);
6767c478bd9Sstevel@tonic-gate return ((p2->pcm_pc[index] > p1->pcm_pc[index])? 1 : -1);
6777c478bd9Sstevel@tonic-gate }
6787c478bd9Sstevel@tonic-gate
6797c478bd9Sstevel@tonic-gate char thd1[] =
6807c478bd9Sstevel@tonic-gate "COMMAND NUMBER TOTAL TOTAL TOTAL MEAN MEAN HOG CHARS BLOCKS\n";
6817c478bd9Sstevel@tonic-gate char thd2[] =
6827c478bd9Sstevel@tonic-gate "NAME CMDS KCOREMIN CPU-MIN REAL-MIN SIZE-K CPU-MIN FACTOR TRNSFD READ\n";
683414388d7Ssl
684414388d7Ssl void
toutpta(void)685414388d7Ssl toutpta(void)
6867c478bd9Sstevel@tonic-gate {
687414388d7Ssl int i;
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate printf(thd1);
6907c478bd9Sstevel@tonic-gate printf(thd2);
6917c478bd9Sstevel@tonic-gate printf("\n");
6927c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
6937c478bd9Sstevel@tonic-gate tcmadd(&tcmtmp, &tcm[i]);
6947c478bd9Sstevel@tonic-gate CPYN(tcmtmp.tcm_comm, "TOTALS");
6957c478bd9Sstevel@tonic-gate tprint(&tcmtmp);
6967c478bd9Sstevel@tonic-gate printf("\n");
6977c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
6987c478bd9Sstevel@tonic-gate tprint(&tcm[i]);
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate
701414388d7Ssl void
tprint(struct tcms * p)702414388d7Ssl tprint(struct tcms *p)
7037c478bd9Sstevel@tonic-gate {
7047c478bd9Sstevel@tonic-gate printf("%-8.8s", p->tcm_comm);
7057c478bd9Sstevel@tonic-gate printf(" %7ld", p->tcm_pc);
7067c478bd9Sstevel@tonic-gate printf(" %11.2f", p->tcm_kcore);
7077c478bd9Sstevel@tonic-gate printf(" %10.2f", p->tcm_cpu);
7087c478bd9Sstevel@tonic-gate printf(" %12.2f", p->tcm_real);
7097c478bd9Sstevel@tonic-gate if(p->tcm_cpu == 0) p->tcm_cpu = 1;
7107c478bd9Sstevel@tonic-gate printf(" %6.2f", p->tcm_kcore/p->tcm_cpu);
7117c478bd9Sstevel@tonic-gate if(p->tcm_pc == 0) p->tcm_pc = 1;
7127c478bd9Sstevel@tonic-gate printf(" %7.2f", p->tcm_cpu/p->tcm_pc);
7137c478bd9Sstevel@tonic-gate if (p->tcm_real == 0)
7147c478bd9Sstevel@tonic-gate p->tcm_real = 1;
7157c478bd9Sstevel@tonic-gate printf(" %8.2f", p->tcm_cpu/p->tcm_real);
7167c478bd9Sstevel@tonic-gate printf(" %11lu", p->tcm_io);
7177c478bd9Sstevel@tonic-gate printf(" %11lu\n", p->tcm_rw);
7187c478bd9Sstevel@tonic-gate }
7197c478bd9Sstevel@tonic-gate
720414388d7Ssl void
toutptc(void)721414388d7Ssl toutptc(void)
7227c478bd9Sstevel@tonic-gate {
723414388d7Ssl int i;
7247c478bd9Sstevel@tonic-gate
7257c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
7267c478bd9Sstevel@tonic-gate fwrite(&tcm[i], sizeof(tcm[i]), 1, stdout);
7277c478bd9Sstevel@tonic-gate }
7287c478bd9Sstevel@tonic-gate
7297c478bd9Sstevel@tonic-gate char hd1[] =
7307c478bd9Sstevel@tonic-gate "COMMAND NUMBER TOTAL TOTAL TOTAL MEAN MEAN HOG CHARS BLOCKS\n";
7317c478bd9Sstevel@tonic-gate char hd2[] =
7327c478bd9Sstevel@tonic-gate "NAME CMDS KCOREMIN CPU-MIN REAL-MIN SIZE-K CPU-MIN FACTOR TRNSFD READ\n";
7337c478bd9Sstevel@tonic-gate char hd3[] =
7347c478bd9Sstevel@tonic-gate "COMMAND NUMBER TOTAL CPU-MIN REAL-MIN MEAN MEAN HOG CHARS BLOCKS\n";
7357c478bd9Sstevel@tonic-gate char hd4[] =
7367c478bd9Sstevel@tonic-gate "NAME (P) (NP) KCOREMIN (P) (NP) (P) (NP) SIZE-K CPU-MIN FACTOR TRNSFD READ\n";
7377c478bd9Sstevel@tonic-gate char hdprime[] =
7387c478bd9Sstevel@tonic-gate " PRIME TIME COMMAND SUMMARY\n";
7397c478bd9Sstevel@tonic-gate char hdnonprime[] =
7407c478bd9Sstevel@tonic-gate " NON-PRIME TIME COMMAND SUMMARY\n";
7417c478bd9Sstevel@tonic-gate char hdtot[] =
7427c478bd9Sstevel@tonic-gate " TOTAL COMMAND SUMMARY\n";
7437c478bd9Sstevel@tonic-gate char hdp[] =
7447c478bd9Sstevel@tonic-gate " PRIME/NON-PRIME TIME COMMAND SUMMARY\n";
7457c478bd9Sstevel@tonic-gate
746414388d7Ssl void
outputa(void)747414388d7Ssl outputa(void)
7487c478bd9Sstevel@tonic-gate {
749414388d7Ssl int i;
7507c478bd9Sstevel@tonic-gate
7517c478bd9Sstevel@tonic-gate if( pflg && oflg ) printf(hdp);
7527c478bd9Sstevel@tonic-gate else if(pflg) printf(hdprime);
7537c478bd9Sstevel@tonic-gate else if(oflg) printf(hdnonprime);
7547c478bd9Sstevel@tonic-gate else printf(hdtot);
7557c478bd9Sstevel@tonic-gate if( (!pflg && !oflg) || (pflg ^ oflg)) {
7567c478bd9Sstevel@tonic-gate printf(hd1);
7577c478bd9Sstevel@tonic-gate printf(hd2);
7587c478bd9Sstevel@tonic-gate }
7597c478bd9Sstevel@tonic-gate else {
7607c478bd9Sstevel@tonic-gate printf(hd3);
7617c478bd9Sstevel@tonic-gate printf(hd4);
7627c478bd9Sstevel@tonic-gate }
7637c478bd9Sstevel@tonic-gate printf("\n");
7647c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
7657c478bd9Sstevel@tonic-gate pcmadd(&pcmtmp, &pcm[i]);
7667c478bd9Sstevel@tonic-gate CPYN(pcmtmp.pcm_comm, "TOTALS");
7677c478bd9Sstevel@tonic-gate print(&pcmtmp);
7687c478bd9Sstevel@tonic-gate printf("\n");
7697c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
7707c478bd9Sstevel@tonic-gate print(&pcm[i]);
7717c478bd9Sstevel@tonic-gate }
7727c478bd9Sstevel@tonic-gate
773414388d7Ssl void
print(struct pcms * p)774414388d7Ssl print(struct pcms *p)
7757c478bd9Sstevel@tonic-gate {
7767c478bd9Sstevel@tonic-gate if(pflg && oflg) pprint(p);
7777c478bd9Sstevel@tonic-gate else if(pflg || oflg) prnt(p, pflg ? PRIME : NONPRIME);
7787c478bd9Sstevel@tonic-gate else totprnt(p);
7797c478bd9Sstevel@tonic-gate }
7807c478bd9Sstevel@tonic-gate
781414388d7Ssl void
prnt(struct pcms * p,int hr)782414388d7Ssl prnt(struct pcms *p, int hr)
7837c478bd9Sstevel@tonic-gate {
7847c478bd9Sstevel@tonic-gate if(p->pcm_pc[hr] == 0) return;
7857c478bd9Sstevel@tonic-gate printf(fmtcmd, p->pcm_comm);
7867c478bd9Sstevel@tonic-gate printf(fmtcnt, p->pcm_pc[hr]);
7877c478bd9Sstevel@tonic-gate printf(fmtkcore, p->pcm_kcore[hr]);
7887c478bd9Sstevel@tonic-gate printf(fmtcpu, p->pcm_cpu[hr]);
7897c478bd9Sstevel@tonic-gate printf(fmtreal, p->pcm_real[hr]);
7907c478bd9Sstevel@tonic-gate if(p->pcm_cpu[hr] == 0) p->pcm_cpu[hr] = 1;
7917c478bd9Sstevel@tonic-gate printf(fmtmsz, p->pcm_kcore[hr]/p->pcm_cpu[hr]);
7927c478bd9Sstevel@tonic-gate if(p->pcm_pc[hr] == 0) p->pcm_pc[hr] = 1;
7937c478bd9Sstevel@tonic-gate printf(fmtmcpu, p->pcm_cpu[hr]/p->pcm_pc[hr]);
7947c478bd9Sstevel@tonic-gate if (p->pcm_real[hr] == 0)
7957c478bd9Sstevel@tonic-gate p->pcm_real[hr] = 1;
7967c478bd9Sstevel@tonic-gate printf(fmthog, p->pcm_cpu[hr]/p->pcm_real[hr]);
7977c478bd9Sstevel@tonic-gate printf(fmtcharx,p->pcm_io[hr]);
7987c478bd9Sstevel@tonic-gate printf(fmtblkx,p->pcm_rw[hr]);
7997c478bd9Sstevel@tonic-gate printf("\n");
8007c478bd9Sstevel@tonic-gate }
8017c478bd9Sstevel@tonic-gate
802414388d7Ssl void
pprint(struct pcms * p)803414388d7Ssl pprint(struct pcms *p)
8047c478bd9Sstevel@tonic-gate {
8057c478bd9Sstevel@tonic-gate printf(fmtcmd, p->pcm_comm);
8067c478bd9Sstevel@tonic-gate printf(fmtcnt, p->pcm_pc[PRIME]);
8077c478bd9Sstevel@tonic-gate printf(fmtcnt, p->pcm_pc[NONPRIME]);
8087c478bd9Sstevel@tonic-gate printf(fmtkcore, TOTAL(p->pcm_kcore));
8097c478bd9Sstevel@tonic-gate printf(fmtcpu, p->pcm_cpu[PRIME]);
8107c478bd9Sstevel@tonic-gate printf(fmtcpu, p->pcm_cpu[NONPRIME]);
8117c478bd9Sstevel@tonic-gate printf(fmtreal, p->pcm_real[PRIME]);
8127c478bd9Sstevel@tonic-gate printf(fmtreal, p->pcm_real[NONPRIME]);
8137c478bd9Sstevel@tonic-gate if(TOTAL(p->pcm_cpu) == 0) p->pcm_cpu[PRIME] = 1;
8147c478bd9Sstevel@tonic-gate printf(fmtmsz, TOTAL(p->pcm_kcore)/TOTAL(p->pcm_cpu));
8157c478bd9Sstevel@tonic-gate if(TOTAL(p->pcm_pc) == 0) p->pcm_pc[PRIME] = 1;
8167c478bd9Sstevel@tonic-gate printf(fmtmcpu, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_pc));
8177c478bd9Sstevel@tonic-gate if ( TOTAL(p->pcm_real) == 0)
8187c478bd9Sstevel@tonic-gate p->pcm_real[PRIME] = 1;
8197c478bd9Sstevel@tonic-gate printf(fmthog, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_real));
8207c478bd9Sstevel@tonic-gate printf(fmtcharx,TOTAL(p->pcm_io));
8217c478bd9Sstevel@tonic-gate printf(fmtblkx, TOTAL(p->pcm_rw));
8227c478bd9Sstevel@tonic-gate printf("\n");
8237c478bd9Sstevel@tonic-gate }
8247c478bd9Sstevel@tonic-gate
825414388d7Ssl void
totprnt(struct pcms * p)826414388d7Ssl totprnt(struct pcms *p)
8277c478bd9Sstevel@tonic-gate {
8287c478bd9Sstevel@tonic-gate printf(fmtcmd, p->pcm_comm);
8297c478bd9Sstevel@tonic-gate printf(fmtcnt, TOTAL(p->pcm_pc));
8307c478bd9Sstevel@tonic-gate printf(fmtkcore, TOTAL(p->pcm_kcore));
8317c478bd9Sstevel@tonic-gate printf(fmtcpu, TOTAL(p->pcm_cpu));
8327c478bd9Sstevel@tonic-gate printf(fmtreal, TOTAL(p->pcm_real));
8337c478bd9Sstevel@tonic-gate if(TOTAL(p->pcm_cpu) == 0) p->pcm_cpu[PRIME] = 1;
8347c478bd9Sstevel@tonic-gate printf(fmtmsz, TOTAL(p->pcm_kcore)/TOTAL(p->pcm_cpu));
8357c478bd9Sstevel@tonic-gate if(TOTAL(p->pcm_pc) == 0) p->pcm_pc[PRIME] = 1;
8367c478bd9Sstevel@tonic-gate printf(fmtmcpu, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_pc));
8377c478bd9Sstevel@tonic-gate if (TOTAL(p->pcm_real) == 0)
8387c478bd9Sstevel@tonic-gate p->pcm_real[PRIME] = 1;
8397c478bd9Sstevel@tonic-gate printf(fmthog, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_real));
8407c478bd9Sstevel@tonic-gate printf(fmtcharx,TOTAL(p->pcm_io));
8417c478bd9Sstevel@tonic-gate printf(fmtblkx,TOTAL(p->pcm_rw));
8427c478bd9Sstevel@tonic-gate printf("\n");
8437c478bd9Sstevel@tonic-gate }
844414388d7Ssl
845414388d7Ssl void
outputc(void)846414388d7Ssl outputc(void)
8477c478bd9Sstevel@tonic-gate {
848414388d7Ssl int i;
8497c478bd9Sstevel@tonic-gate
8507c478bd9Sstevel@tonic-gate for (i = 0; i < csize; i++)
8517c478bd9Sstevel@tonic-gate fwrite(&pcm[i], sizeof(pcm[i]), 1, stdout);
8527c478bd9Sstevel@tonic-gate }
853