[unix-history] / usr / source / s2 / sa.c

#define size 2000
/* interpret command time accounting */

int	lflg;
int	cflg;
int	jflg;
int	nflg;
int	aflg;
int	rflg;
int	tflg;
int	vflg;
int	uflg;
int	thres	1;
int	sflg;
int	bflg;
int	mflg;
int	fout;

struct	user {
	int	ncomm;
	int	fill;
	float	fctime;
} user[256];
struct tab {
	char name[8];
	int count;
	float realt;
	float cput;
	float syst;
} tab[size];

struct ftab {
	char	fname[14];
	char	shf;
	char	uid;
	int	fdatet[2];
	int	frealt[2];
	int	fcput[2];
	int	fsyst[2];
};
float	treal;
float	tcpu;
float	tsys;
int	junkp -1;
char	*sname;
float	ncom;

main(argc, argv)
char **argv;
{
	int i, j, k;
	extern tcmp(), ncmp(), bcmp();
	extern float sum();
	float ft;

	init();
	if (argc>1)
	if (argv[1][0]=='-') {
		argv++;
		argc--;
		for(i=1; argv[0][i]; i++)
		switch(argv[0][i]) {

		case 'b':
			bflg++;
			break;

		case 'l':
			lflg++;
			break;

		case 'c':
			cflg++;
			break;

		case 'j':
			jflg++;
			break;

		case 'n':
			nflg++;
			break;

		case 'a':
			aflg++;
			break;

		case 'r':
			rflg++;
			break;

		case 't':
			tflg++;
			break;

		case 's':
			sflg++;
			aflg++;
			break;

		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			thres = argv[0][i]-'0';
			break;

		case 'v':
			vflg++;
			break;

		case 'u':
			uflg++;
			break;

		case 'm':
			mflg++;
			break;
		}
	}
	fout = dup(1);
	if (argc<2)
		acct("/usr/adm/sha");
	else while (--argc)
		acct(*++argv);
	if (uflg) {
		flush();
		return;
	}

/*
 * cleanup pass
 * put junk together
 */

	if (vflg)
		strip();
	if(!aflg)
	for (i=0; i<size; i++)
	if (tab[i].name[0]) {
		for(j=0; j<8; j++)
			if(tab[i].name[j] == '?')
				goto yes;
		if(tab[i].count != 1)
			continue;
	yes:
		if(junkp == -1)
			junkp = enter("***other");
		tab[junkp].count =+ tab[i].count;
		tab[junkp].realt =+ tab[i].realt;
		tab[junkp].cput =+ tab[i].cput;
		tab[junkp].syst =+ tab[i].syst;
		tab[i].name[0] = 0;
	}
	for(i=k=0; i<size; i++)
	if(tab[i].name[0]) {
		for(j=0; j<8; j++)
			tab[k].name[j] = tab[i].name[j];
		tab[k].count = tab[i].count;
		tab[k].realt = tab[i].realt;
		tab[k].cput = tab[i].cput;
		tab[k].syst = tab[i].syst;
		k++;
	}
	if (sflg) {
		signal(2, 1);
		i = creat("/usr/adm/shm", 0666);
		write(i, user, sizeof(user));
		close(i);
		if ((i = creat("/usr/adm/sht", 0666))<0) {
			printf("Can't save\n");
			exit();
		}
		write(i, tab, k*sizeof(*tab));
		close(i);
		if (sname) {
			if ((i = creat(sname, 0666))<0)
				printf("Can't truncate\n");
			close(i);
		}
		signal(2, 0);
	}
/*
 * sort and print
 */

	if (mflg) {
		printmoney();
		flush();
		exit();
	}
	qsort(tab, k, 22, nflg? &ncmp: (bflg?&bcmp:&tcmp));
	printf("%8s", "");
	column(ncom, treal, tcpu, tsys);
	for (i=0; i<k; i++)
	if (tab[i].name[0]) {
		ft = tab[i].count;
		printf("%-8.8s", tab[i].name);
		column(ft, tab[i].realt, tab[i].cput, tab[i].syst);
	}
	flush();
}

printmoney()
{
	register i;
	char buf[128];
	register char *cp;

	for (i=0; i<256; i++) {
		if (user[i].ncomm) {
			if (getpw(i, buf)!=0)
				printf("%-8d", i);
			else {
				cp = buf;
				while (*cp!=':' &&*cp!='\n' && *cp)
					cp++;
				*cp = 0;
				printf("%-8s", buf);
			}
			printf("%5l %7.2f\n",
			    user[i].ncomm, user[i].fctime/60);
		}
	}
}

column(n, a, b, c)
double n, a, b, c;
{

	printf("%6.0f", n);
	if(cflg) {
		if(n == ncom)
			printf("%7s", ""); else
			printf("%6.2f%%", 100.*n/ncom);
	}
	col(n, a, treal);
	if(lflg) {
		col(n, b, tcpu);
		col(n, c, tsys);
	} else
		col(n, b+c, tcpu+tsys);
	if(tflg)
		printf("%6.1f", a/(b+c));
	putchar('\n');
}

col(n, a, m)
double n, a, m;
{

	if(jflg)
		printf("%9.2f", a/(n*60.)); else
		printf("%9.2f", a/3600.);
	if(cflg) {
		if(a == m)
			printf("%7s", ""); else
			printf("%6.2f%%", 100.*a/m);
	}
}

acct(f)
char *f;
{
	int ff, i, j;
	float x;
	struct ftab fbuf;
	register char *cp;
	register int c;
	extern double ltod();

	if (sflg && sname) {
		printf("Only 1 file with -s\n");
		exit();
	}
	if (sflg)
		sname = f;
	if ((ff=open(f, 0))<0) {
		printf("Can't open %s\n", f);
		return;
	}
	while (read(ff, &fbuf, sizeof(fbuf))==sizeof(fbuf)) {
		for (cp = fbuf.name; cp < &fbuf.name[8]; cp++) {
			c = *cp & 0377;
			if (c && (c < ' ' || c >= 0200))
				*cp = '?';
		}
		if (uflg) {
			printdate(fbuf.fdatet);
			printf(" %3d %.8s\n", fbuf.uid, fbuf.name);
			continue;
		}
		if (fbuf.shf==0) {
			c = fbuf.uid&0377;
			user[c].ncomm++;
			user[c].fctime =+ (ltod(fbuf.fcput)+ltod(fbuf.fsyst))/60;
		}
		ncom =+ 1.0;
		i = enter(&fbuf);
		tab[i].count++;
		x = ltod(fbuf.frealt);
		x =* 60.;
		tab[i].realt =+ x;
		treal =+ x;
		x = ltod(fbuf.fcput);
		tab[i].cput =+ x;
		tcpu =+ x;
		x = ltod(fbuf.fsyst);
		tab[i].syst =+ x;
		tsys =+ x;
	}
	close(ff);
}

ncmp(p1, p2)
struct tab *p1, *p2;
{

	if(p1->count == p2->count)
		return(tcmp(p1, p2));
	if(rflg)
		return(p1->count - p2->count);
	return(p2->count - p1->count);
}

bcmp(p1, p2)
struct tab *p1, *p2;
{
	float f1, f2;
	float sum();

	f1 = sum(p1)/p1->count;
	f2 = sum(p2)/p2->count;
	if(f1 < f2) {
		if(rflg)
			return(-1);
		return(1);
	}
	if(f1 > f2) {
		if(rflg)
			return(1);
		return(-1);
	}
	return(0);
}
tcmp(p1, p2)
struct tab *p1, *p2;
{
	extern float sum();
	float f1, f2;

	f1 = sum(p1);
	f2 = sum(p2);
	if(f1 < f2) {
		if(rflg)
			return(-1);
		return(1);
	}
	if(f1 > f2) {
		if(rflg)
			return(1);
		return(-1);
	}
	return(0);
}

float sum(p)
struct tab *p;
{

	if(p->name[0] == 0)
		return(0.0);
	return(
		p->cput+
		p->syst);
}

init()
{
	struct tab tbuf;
	int i, j, f;

	if ((f=open("/usr/adm/sht", 0))<0)
		goto gshm;
	while (read(f, &tbuf, sizeof(tbuf)) == sizeof(tbuf)) {
		i = enter(&tbuf);
		ncom =+ tbuf.count;
		tab[i].count = tbuf.count;
		treal =+ tbuf.realt;
		tab[i].realt = tbuf.realt;
		tcpu =+ tbuf.cput;
		tab[i].cput = tbuf.cput;
		tsys =+ tbuf.syst;
		tab[i].syst = tbuf.syst;
	}
	close(f);
 gshm:
	if ((f=open("/usr/adm/shm", 0)) < 0)
		return;
	read(f, user, sizeof(user));
	close(f);
}

enter(fbuf)
struct ftab *fbuf;
{
	int i, j;

	i = 0;
	for (j=0; j<8; j++) {
		i = i*7 + fbuf->fname[j];
	}
	if(i < 0)
		i = -i;
	for (i=%size; tab[i].name[0]; i = (i+1)%size) {
		for (j=0; j<8; j++)
			if (tab[i].name[j]!=fbuf->fname[j])
				goto no;
		goto yes;
	no:;
	}
	for (j=0; j<8; j++)
		tab[i].name[j] = fbuf->fname[j];
yes:
	return(i);
}

strip()
{
	int i, j, k, c;

	j = enter("**junk**");
	for (i = 0; i<size; i++) {
		if (tab[i].name[0] && tab[i].count<=thres) {
			printf("%.8s--", tab[i].name);
			flush();
			if ((c=getchar())=='y') {
				tab[i].name[0] = '\0';
				tab[j].count =+ tab[i].count;
				tab[j].realt =+ tab[i].realt;
				tab[j].cput =+ tab[i].cput;
				tab[j].syst =+ tab[i].syst;
			}
			while (c && c!='\n')
				c = getchar();
		}
	}
}

printdate(tvec)
int tvec[2];
{
	int *lt;
	int *localtime();

	lt = localtime(tvec);
	printf("%3d %c%c%c %d", lt[7], 
		pair(lt[2]), pair(lt[1]), pair(lt[0]), lt[6]);
}

pair(n)
{
	return(n/10+'0' | (n%10+'0')<<8);
}
Commit	Line	Data
f41b2dd0 KT	1	#define size 2000
	2	/* interpret command time accounting */
	3
	4	int lflg;
	5	int cflg;
	6	int jflg;
	7	int nflg;
	8	int aflg;
	9	int rflg;
	10	int tflg;
	11	int vflg;
	12	int uflg;
	13	int thres 1;
	14	int sflg;
	15	int bflg;
	16	int mflg;
	17	int fout;
	18
	19	struct user {
	20	int ncomm;
	21	int fill;
	22	float fctime;
	23	} user[256];
	24	struct tab {
	25	char name[8];
	26	int count;
	27	float realt;
	28	float cput;
	29	float syst;
	30	} tab[size];
	31
	32	struct ftab {
	33	char fname[14];
	34	char shf;
	35	char uid;
	36	int fdatet[2];
	37	int frealt[2];
	38	int fcput[2];
	39	int fsyst[2];
	40	};
	41	float treal;
	42	float tcpu;
	43	float tsys;
	44	int junkp -1;
	45	char *sname;
	46	float ncom;
	47
	48	main(argc, argv)
	49	char **argv;
	50	{
	51	int i, j, k;
	52	extern tcmp(), ncmp(), bcmp();
	53	extern float sum();
	54	float ft;
	55
	56	init();
	57	if (argc>1)
	58	if (argv[1][0]=='-') {
	59	argv++;
	60	argc--;
	61	for(i=1; argv[0][i]; i++)
	62	switch(argv[0][i]) {
	63
	64	case 'b':
65	bflg++;
66	break;
67
68	case 'l':
69	lflg++;
70	break;
71
72	case 'c':
73	cflg++;
74	break;
75
76	case 'j':
77	jflg++;
78	break;
79
80	case 'n':
81	nflg++;
82	break;
83
84	case 'a':
85	aflg++;
86	break;
87
88	case 'r':
89	rflg++;
90	break;
91
92	case 't':
93	tflg++;
94	break;
95
96	case 's':
97	sflg++;
98	aflg++;
99	break;
100
101	case '0':
102	case '1':
103	case '2':
104	case '3':
105	case '4':
106	case '5':
107	case '6':
108	case '7':
109	case '8':
110	case '9':
111	thres = argv[0][i]-'0';
112	break;
113
114	case 'v':
115	vflg++;
116	break;
117
118	case 'u':
119	uflg++;
120	break;
121
122	case 'm':
123	mflg++;
124	break;
125	}
126	}
127	fout = dup(1);
128	if (argc<2)
129	acct("/usr/adm/sha");
130	else while (--argc)
131	acct(*++argv);
132	if (uflg) {
133	flush();
134	return;
135	}
136
137	/*
138	* cleanup pass
139	* put junk together
140	*/
141
142	if (vflg)
143	strip();
144	if(!aflg)
145	for (i=0; i<size; i++)
146	if (tab[i].name[0]) {
147	for(j=0; j<8; j++)
148	if(tab[i].name[j] == '?')
149	goto yes;
150	if(tab[i].count != 1)
151	continue;
152	yes:
153	if(junkp == -1)
154	junkp = enter("***other");
155	tab[junkp].count =+ tab[i].count;
156	tab[junkp].realt =+ tab[i].realt;
157	tab[junkp].cput =+ tab[i].cput;
158	tab[junkp].syst =+ tab[i].syst;
159	tab[i].name[0] = 0;
160	}
161	for(i=k=0; i<size; i++)
162	if(tab[i].name[0]) {
163	for(j=0; j<8; j++)
164	tab[k].name[j] = tab[i].name[j];
165	tab[k].count = tab[i].count;
166	tab[k].realt = tab[i].realt;
167	tab[k].cput = tab[i].cput;
168	tab[k].syst = tab[i].syst;
169	k++;
170	}
171	if (sflg) {
172	signal(2, 1);
173	i = creat("/usr/adm/shm", 0666);
174	write(i, user, sizeof(user));
175	close(i);
176	if ((i = creat("/usr/adm/sht", 0666))<0) {
177	printf("Can't save\n");
178	exit();
179	}
180	write(i, tab, ksizeof(tab));
181	close(i);
182	if (sname) {
183	if ((i = creat(sname, 0666))<0)
184	printf("Can't truncate\n");
185	close(i);
186	}
187	signal(2, 0);
188	}
189	/*
190	* sort and print
191	*/
192
193	if (mflg) {
194	printmoney();
195	flush();
196	exit();
197	}
198	qsort(tab, k, 22, nflg? &ncmp: (bflg?&bcmp:&tcmp));
199	printf("%8s", "");
200	column(ncom, treal, tcpu, tsys);
201	for (i=0; i<k; i++)
202	if (tab[i].name[0]) {
203	ft = tab[i].count;
204	printf("%-8.8s", tab[i].name);
205	column(ft, tab[i].realt, tab[i].cput, tab[i].syst);
206	}
207	flush();
208	}
209
210	printmoney()
211	{
212	register i;
213	char buf[128];
214	register char *cp;
215
216	for (i=0; i<256; i++) {
217	if (user[i].ncomm) {
218	if (getpw(i, buf)!=0)
219	printf("%-8d", i);
220	else {
221	cp = buf;
222	while (cp!=':' &&cp!='\n' && *cp)
223	cp++;
224	*cp = 0;
225	printf("%-8s", buf);
226	}
227	printf("%5l %7.2f\n",
228	user[i].ncomm, user[i].fctime/60);
229	}
230	}
231	}
232
233	column(n, a, b, c)
234	double n, a, b, c;
235	{
236
237	printf("%6.0f", n);
238	if(cflg) {
239	if(n == ncom)
240	printf("%7s", ""); else
241	printf("%6.2f%%", 100.*n/ncom);
242	}
243	col(n, a, treal);
244	if(lflg) {
245	col(n, b, tcpu);
246	col(n, c, tsys);
247	} else
248	col(n, b+c, tcpu+tsys);
249	if(tflg)
250	printf("%6.1f", a/(b+c));
251	putchar('\n');
252	}
253
254	col(n, a, m)
255	double n, a, m;
256	{
257
258	if(jflg)
259	printf("%9.2f", a/(n*60.)); else
260	printf("%9.2f", a/3600.);
261	if(cflg) {
262	if(a == m)
263	printf("%7s", ""); else
264	printf("%6.2f%%", 100.*a/m);
265	}
266	}
267
268	acct(f)
269	char *f;
270	{
271	int ff, i, j;
272	float x;
273	struct ftab fbuf;
274	register char *cp;
275	register int c;
276	extern double ltod();
277
278	if (sflg && sname) {
279	printf("Only 1 file with -s\n");
280	exit();
281	}
282	if (sflg)
283	sname = f;
284	if ((ff=open(f, 0))<0) {
285	printf("Can't open %s\n", f);
286	return;
287	}
288	while (read(ff, &fbuf, sizeof(fbuf))==sizeof(fbuf)) {
289	for (cp = fbuf.name; cp < &fbuf.name[8]; cp++) {
290	c = *cp & 0377;
291	if (c && (c < ' ' \|\| c >= 0200))
292	*cp = '?';
293	}
294	if (uflg) {
295	printdate(fbuf.fdatet);
296	printf(" %3d %.8s\n", fbuf.uid, fbuf.name);
297	continue;
298	}
299	if (fbuf.shf==0) {
300	c = fbuf.uid&0377;
301	user[c].ncomm++;
302	user[c].fctime =+ (ltod(fbuf.fcput)+ltod(fbuf.fsyst))/60;
303	}
304	ncom =+ 1.0;
305	i = enter(&fbuf);
306	tab[i].count++;
307	x = ltod(fbuf.frealt);
308	x =* 60.;
309	tab[i].realt =+ x;
310	treal =+ x;
311	x = ltod(fbuf.fcput);
312	tab[i].cput =+ x;
313	tcpu =+ x;
314	x = ltod(fbuf.fsyst);
315	tab[i].syst =+ x;
316	tsys =+ x;
317	}
318	close(ff);
319	}
320
321	ncmp(p1, p2)
322	struct tab p1, p2;
323	{
324
325	if(p1->count == p2->count)
326	return(tcmp(p1, p2));
327	if(rflg)
328	return(p1->count - p2->count);
329	return(p2->count - p1->count);
330	}
331
332	bcmp(p1, p2)
333	struct tab p1, p2;
334	{
335	float f1, f2;
336	float sum();
337
338	f1 = sum(p1)/p1->count;
339	f2 = sum(p2)/p2->count;
340	if(f1 < f2) {
341	if(rflg)
342	return(-1);
343	return(1);
344	}
345	if(f1 > f2) {
346	if(rflg)
347	return(1);
348	return(-1);
349	}
350	return(0);
351	}
352	tcmp(p1, p2)
353	struct tab p1, p2;
354	{
355	extern float sum();
356	float f1, f2;
357
358	f1 = sum(p1);
359	f2 = sum(p2);
360	if(f1 < f2) {
361	if(rflg)
362	return(-1);
363	return(1);
364	}
365	if(f1 > f2) {
366	if(rflg)
367	return(1);
368	return(-1);
369	}
370	return(0);
371	}
372
373	float sum(p)
374	struct tab *p;
375	{
376
377	if(p->name[0] == 0)
378	return(0.0);
379	return(
380	p->cput+
381	p->syst);
382	}
383
384	init()
385	{
386	struct tab tbuf;
387	int i, j, f;
388
389	if ((f=open("/usr/adm/sht", 0))<0)
390	goto gshm;
391	while (read(f, &tbuf, sizeof(tbuf)) == sizeof(tbuf)) {
392	i = enter(&tbuf);
393	ncom =+ tbuf.count;
394	tab[i].count = tbuf.count;
395	treal =+ tbuf.realt;
396	tab[i].realt = tbuf.realt;
397	tcpu =+ tbuf.cput;
398	tab[i].cput = tbuf.cput;
399	tsys =+ tbuf.syst;
400	tab[i].syst = tbuf.syst;
401	}
402	close(f);
403	gshm:
404	if ((f=open("/usr/adm/shm", 0)) < 0)
405	return;
406	read(f, user, sizeof(user));
407	close(f);
408	}
409
410	enter(fbuf)
411	struct ftab *fbuf;
412	{
413	int i, j;
414
415	i = 0;
416	for (j=0; j<8; j++) {
417	i = i*7 + fbuf->fname[j];
418	}
419	if(i < 0)
420	i = -i;
421	for (i=%size; tab[i].name[0]; i = (i+1)%size) {
422	for (j=0; j<8; j++)
423	if (tab[i].name[j]!=fbuf->fname[j])
424	goto no;
425	goto yes;
426	no:;
427	}
428	for (j=0; j<8; j++)
429	tab[i].name[j] = fbuf->fname[j];
430	yes:
431	return(i);
432	}
433
434	strip()
435	{
436	int i, j, k, c;
437
438	j = enter("junk");
439	for (i = 0; i<size; i++) {
440	if (tab[i].name[0] && tab[i].count<=thres) {
441	printf("%.8s--", tab[i].name);
442	flush();
443	if ((c=getchar())=='y') {
444	tab[i].name[0] = '\0';
445	tab[j].count =+ tab[i].count;
446	tab[j].realt =+ tab[i].realt;
447	tab[j].cput =+ tab[i].cput;
448	tab[j].syst =+ tab[i].syst;
449	}
450	while (c && c!='\n')
451	c = getchar();
452	}
453	}
454	}
455
456	printdate(tvec)
457	int tvec[2];
458	{
459	int *lt;
460	int *localtime();
461
462	lt = localtime(tvec);
463	printf("%3d %c%c%c %d", lt[7],
464	pair(lt[2]), pair(lt[1]), pair(lt[0]), lt[6]);
465	}
466
467	pair(n)
468	{
469	return(n/10+'0' \| (n%10+'0')<<8);
470	}