[unix-history] / usr / src / contrib / mprof / mpstruct.c

/*	mpstruct.c 2.2 9/14/90 11:54:22	*/
/*	Copyright (c) 1987, Benjamin G. Zorn */

#include	<stdio.h>
#include	"mprof.h"

extern	mpcell	hmem[];
extern	bool	mprofing;

mpcell	hmem[MP_HASH_SIZE];

int	mprof_fmemC;
int	mprof_dmemC;
int	mprof_lmemC;


mpcell
mp_cons(a, d)
int	a;
mpcell	d;
{
    mpcell result = (mpcell) malloc(MPCELL_SIZE);
    
    mprof_lmemC++;
    mp_car(result) = a;
    mp_cdr(result) = d;
    return result;
}

mpsym
mp_new_fn(addr)
unsigned	addr;
{
    mpsym	newfn = (mpsym) malloc(MPSYM_SIZE);

    mprof_fmemC++;
    fn_lcount(newfn) = mp_new_data();
    fn_addr(newfn) = addr;
    fn_parents(newfn) = (mpcell) MP_NIL;
    fn_name(newfn) = NULL;
    return newfn;
}

mpdata
mp_new_data()
{
    mpdata 	result = (mpdata) malloc(MPDATA_SIZE);
    
    mprof_dmemC++;

    dt_b_small(result) = 0;
    dt_b_med(result) = 0;
    dt_b_large(result) = 0;
    dt_b_xlarge(result) = 0;
    dt_n_small(result) = 0;
    dt_n_med(result) = 0;
    dt_n_large(result) = 0;
    dt_n_xlarge(result) = 0;
    dt_d_small(result) = 0;
    dt_d_med(result) = 0;
    dt_d_large(result) = 0;
    dt_d_xlarge(result) = 0;
    return result;
}

mpdata
mp_add_data(ddest, dsrc)
mpdata	ddest, dsrc;
{
    dt_b_small(ddest) += dt_b_small(dsrc);
    dt_b_med(ddest) += dt_b_med(dsrc);
    dt_b_large(ddest) += dt_b_large(dsrc);
    dt_b_xlarge(ddest) += dt_b_xlarge(dsrc);
    dt_n_small(ddest) += dt_n_small(dsrc);
    dt_n_med(ddest) += dt_n_med(dsrc);
    dt_n_large(ddest) += dt_n_large(dsrc);
    dt_n_xlarge(ddest) += dt_n_xlarge(dsrc);
    dt_d_small(ddest) += dt_d_small(dsrc);
    dt_d_med(ddest) += dt_d_med(dsrc);
    dt_d_large(ddest) += dt_d_large(dsrc);
    dt_d_xlarge(ddest) += dt_d_xlarge(dsrc);
    return ddest;
}

int
mp_sum_data(d)
mpdata	d;
{
    return (dt_b_small(d) + dt_b_med(d) + dt_b_large(d) + dt_b_xlarge(d));
}

int
mp_sum_calls(d)
mpdata	d;
{
    return (dt_n_small(d) + dt_n_med(d) + dt_n_large(d) + dt_n_xlarge(d));
}

int
mp_sum_kept(d)
mpdata	d;
{
    return (dt_d_small(d) + dt_d_med(d) + dt_d_large(d) + dt_d_xlarge(d));
}

mpcell
mp_has_parent(c, p)
mpsym	c, p;
{
    mpcell	plist = fn_parents(c);
    unsigned	pname;
    mpcell	pair;
    mpsym	f;

    pname = fn_addr(p);
    while (!mp_null(plist)) {
	pair = (mpcell) mp_car(plist);
	f = (mpsym) mp_car(pair);
	if (fn_addr(f) == pname)
	  return pair;
	plist = (mpcell) mp_cdr(plist);
    }
    return (mpcell) MP_NIL;
}

int
mp_hash(pc)
unsigned	pc;
{
    int		hash = (pc >> 24 | (pc & 0xff00)) ^
      		       (((pc & 0xff) << 8) | (pc & 0xff0000) >> 16);
    return (hash % MP_HASH_SIZE);
}

void
mp_puthash(pc, f)
unsigned	pc;
mpsym		f;
{
    int		hash = mp_hash(pc);

    hmem[hash] = mp_cons((int) f, hmem[hash]);
}

mpsym
mp_lookup(pc)
unsigned	pc;
{
    int		hash = mp_hash(pc);
    mpcell	c = hmem[hash];
    mpsym	s;
    
    while (!mp_null(c)) {
	s = (mpsym) mp_car(c);
	if (pc == fn_addr(s))
	  return s;
	c = (mpcell) mp_cdr(c);
    }
    return (mpsym) MP_NIL;
}
	

bool	mp_pprint = FALSE;

void
mp_print_fn(mprof_file, f)
int	mprof_file;
mpsym	f;
{
    mpcell	plist;

    plist = fn_parents(f);
    if (fn_name(f) != NULL)
      mp_pprint = TRUE;

    /* print name, lcount, and parents
     */

    if (mp_pprint) {
	write(mprof_file, "(\"", 2);
	write(mprof_file, fn_name(f), strlen(fn_name(f)));
	write(mprof_file, "\" ", 2);
	mp_print_data(mprof_file, fn_lcount(f));
	write(mprof_file, " ", 1);
	mp_print_parents(mprof_file, plist);
	write(mprof_file, ")\n", 2);
    } else {
	mp_print_addr(mprof_file, f);
	mp_print_data(mprof_file, fn_lcount(f));
	mp_print_parents(mprof_file, plist);
    }
}

void
mp_print_addr(mprof_file, f)
int	mprof_file;
mpsym	f;
{
    char	digits[14];

    sprintf(digits, "%d\n", fn_addr(f));
    write(mprof_file, digits, strlen(digits));
}

char *
mp_sprint_data(d)
mpdata	d;
{
    char	digits[255];
    char	*result;

    sprintf(digits, "(%d %d %d %d %d %d %d %d %d %d %d %d)",
	    dt_b_small(d),
	    dt_b_med(d),
	    dt_b_large(d),
	    dt_b_xlarge(d),
	    dt_n_small(d),
	    dt_n_med(d),
	    dt_n_large(d),
	    dt_n_xlarge(d),
	    dt_d_small(d),
	    dt_d_med(d),
	    dt_d_large(d),
	    dt_d_xlarge(d));
    result = malloc(strlen(digits) + 1);
    strcpy(result, digits);
    return result;
}

void
mp_print_data(mprof_file, d)
int	mprof_file;
mpdata	d;
{
    char	digits[255];

    if (mp_pprint) {
	sprintf(digits, "(%d %d %d %d %d %d %d %d %d %d %d %d)",
		dt_b_small(d),
		dt_b_med(d),
		dt_b_large(d),
		dt_b_xlarge(d),
		dt_n_small(d),
		dt_n_med(d),
		dt_n_large(d),
		dt_n_xlarge(d),
		dt_d_small(d),
		dt_d_med(d),
		dt_d_large(d),
		dt_d_xlarge(d));
    } else {
	sprintf(digits, "%d %d %d %d %d %d %d %d %d %d %d %d\n",
		dt_b_small(d),
		dt_b_med(d),
		dt_b_large(d),
		dt_b_xlarge(d),
		dt_n_small(d),
		dt_n_med(d),
		dt_n_large(d),
		dt_n_xlarge(d),
		dt_d_small(d),
		dt_d_med(d),
		dt_d_large(d),
		dt_d_xlarge(d));
    }
    write(mprof_file, digits, strlen(digits));
}

void
mp_print_parents(mprof_file, l)
int	mprof_file;
mpcell	l;
{
    mpcell	rest = l;
    mpcell	p;

    if (mp_pprint) {
	write(mprof_file, "(", 1);
	while (!mp_null(rest)) {
	    p = (mpcell) mp_car(rest);
	    write(mprof_file, "(\"", 2);
	    write(mprof_file,
		  fn_name((mpsym) mp_car(p)),
		  strlen(fn_name((mpsym) mp_car(p))));
	    write(mprof_file, "\" ", 2);
	    mp_print_data(mprof_file, (mpdata) mp_cdr(p));
	    write(mprof_file, ")", 1);
	    rest = mp_cdr(rest);
	    if (!mp_null(rest)) {
		write(mprof_file, " ", 1);
	    }
	}
	write(mprof_file, ")", 1);
    } else {
	while (!mp_null(rest)) {
	    p = (mpcell) mp_car(rest);
	    mp_print_addr(mprof_file, (mpsym) mp_car(p));
	    mp_print_data(mprof_file, (mpdata) mp_cdr(p));
	    rest = (mpcell) mp_cdr(rest);
	}
	write(mprof_file, "-1\n", 3);
    }
}


void
mprof_print(mprof_file)
int	mprof_file;
{
    mpsym	s;
    int		i;
    mpcell	chain;

    for (i = 0; i < MP_HASH_SIZE; i++) {
	chain = hmem[i];
	while (!mp_null(chain)) {
	    s = (mpsym) mp_car(chain);
	    mp_print_fn(mprof_file, s);
	    chain = (mpcell) mp_cdr(chain);
	}
    }
}


mpsym
pc_lookup(pc)
unsigned	pc;
{
    mpsym	s;
    
    s = mp_lookup(pc);
    if (!mp_null(s)) {
	return s;
    } else {
	/*
	 *  create a new function
	 */
	s = mp_new_fn(pc);
	mp_puthash(pc, s);
	return s;
    }
}

void
mpstruct_init()
{
    int		i;
    
    for (i = 0; i < MP_HASH_SIZE; i++) {
	hmem[i] = (mpcell) MP_NIL;
    }
    mprof_lmemC = 0;
    mprof_fmemC = 0;
    mprof_dmemC = 0;
}
Commit	Line	Data
5718e5f3 C	1	/* mpstruct.c 2.2 9/14/90 11:54:22 */
	2	/* Copyright (c) 1987, Benjamin G. Zorn */
	3
	4	#include <stdio.h>
	5	#include "mprof.h"
	6
	7	extern mpcell hmem[];
	8	extern bool mprofing;
	9
	10	mpcell hmem[MP_HASH_SIZE];
	11
	12	int mprof_fmemC;
	13	int mprof_dmemC;
	14	int mprof_lmemC;
	15
	16
	17	mpcell
	18	mp_cons(a, d)
	19	int a;
	20	mpcell d;
	21	{
	22	mpcell result = (mpcell) malloc(MPCELL_SIZE);
	23
	24	mprof_lmemC++;
	25	mp_car(result) = a;
	26	mp_cdr(result) = d;
	27	return result;
	28	}
	29
	30	mpsym
	31	mp_new_fn(addr)
	32	unsigned addr;
	33	{
	34	mpsym newfn = (mpsym) malloc(MPSYM_SIZE);
	35
	36	mprof_fmemC++;
	37	fn_lcount(newfn) = mp_new_data();
	38	fn_addr(newfn) = addr;
	39	fn_parents(newfn) = (mpcell) MP_NIL;
	40	fn_name(newfn) = NULL;
	41	return newfn;
	42	}
	43
	44	mpdata
	45	mp_new_data()
	46	{
	47	mpdata result = (mpdata) malloc(MPDATA_SIZE);
	48
	49	mprof_dmemC++;
	50
	51	dt_b_small(result) = 0;
	52	dt_b_med(result) = 0;
	53	dt_b_large(result) = 0;
	54	dt_b_xlarge(result) = 0;
	55	dt_n_small(result) = 0;
	56	dt_n_med(result) = 0;
	57	dt_n_large(result) = 0;
	58	dt_n_xlarge(result) = 0;
	59	dt_d_small(result) = 0;
	60	dt_d_med(result) = 0;
	61	dt_d_large(result) = 0;
	62	dt_d_xlarge(result) = 0;
	63	return result;
	64	}
65
66	mpdata
67	mp_add_data(ddest, dsrc)
68	mpdata ddest, dsrc;
69	{
70	dt_b_small(ddest) += dt_b_small(dsrc);
71	dt_b_med(ddest) += dt_b_med(dsrc);
72	dt_b_large(ddest) += dt_b_large(dsrc);
73	dt_b_xlarge(ddest) += dt_b_xlarge(dsrc);
74	dt_n_small(ddest) += dt_n_small(dsrc);
75	dt_n_med(ddest) += dt_n_med(dsrc);
76	dt_n_large(ddest) += dt_n_large(dsrc);
77	dt_n_xlarge(ddest) += dt_n_xlarge(dsrc);
78	dt_d_small(ddest) += dt_d_small(dsrc);
79	dt_d_med(ddest) += dt_d_med(dsrc);
80	dt_d_large(ddest) += dt_d_large(dsrc);
81	dt_d_xlarge(ddest) += dt_d_xlarge(dsrc);
82	return ddest;
83	}
84
85	int
86	mp_sum_data(d)
87	mpdata d;
88	{
89	return (dt_b_small(d) + dt_b_med(d) + dt_b_large(d) + dt_b_xlarge(d));
90	}
91
92	int
93	mp_sum_calls(d)
94	mpdata d;
95	{
96	return (dt_n_small(d) + dt_n_med(d) + dt_n_large(d) + dt_n_xlarge(d));
97	}
98
99	int
100	mp_sum_kept(d)
101	mpdata d;
102	{
103	return (dt_d_small(d) + dt_d_med(d) + dt_d_large(d) + dt_d_xlarge(d));
104	}
105
106	mpcell
107	mp_has_parent(c, p)
108	mpsym c, p;
109	{
110	mpcell plist = fn_parents(c);
111	unsigned pname;
112	mpcell pair;
113	mpsym f;
114
115	pname = fn_addr(p);
116	while (!mp_null(plist)) {
117	pair = (mpcell) mp_car(plist);
118	f = (mpsym) mp_car(pair);
119	if (fn_addr(f) == pname)
120	return pair;
121	plist = (mpcell) mp_cdr(plist);
122	}
123	return (mpcell) MP_NIL;
124	}
125
126	int
127	mp_hash(pc)
128	unsigned pc;
129	{
130	int hash = (pc >> 24 \| (pc & 0xff00)) ^
131	(((pc & 0xff) << 8) \| (pc & 0xff0000) >> 16);
132	return (hash % MP_HASH_SIZE);
133	}
134
135	void
136	mp_puthash(pc, f)
137	unsigned pc;
138	mpsym f;
139	{
140	int hash = mp_hash(pc);
141
142	hmem[hash] = mp_cons((int) f, hmem[hash]);
143	}
144
145	mpsym
146	mp_lookup(pc)
147	unsigned pc;
148	{
149	int hash = mp_hash(pc);
150	mpcell c = hmem[hash];
151	mpsym s;
152
153	while (!mp_null(c)) {
154	s = (mpsym) mp_car(c);
155	if (pc == fn_addr(s))
156	return s;
157	c = (mpcell) mp_cdr(c);
158	}
159	return (mpsym) MP_NIL;
160	}
161
162
163	bool mp_pprint = FALSE;
164
165	void
166	mp_print_fn(mprof_file, f)
167	int mprof_file;
168	mpsym f;
169	{
170	mpcell plist;
171
172	plist = fn_parents(f);
173	if (fn_name(f) != NULL)
174	mp_pprint = TRUE;
175
176	/* print name, lcount, and parents
177	*/
178
179	if (mp_pprint) {
180	write(mprof_file, "(\"", 2);
181	write(mprof_file, fn_name(f), strlen(fn_name(f)));
182	write(mprof_file, "\" ", 2);
183	mp_print_data(mprof_file, fn_lcount(f));
184	write(mprof_file, " ", 1);
185	mp_print_parents(mprof_file, plist);
186	write(mprof_file, ")\n", 2);
187	} else {
188	mp_print_addr(mprof_file, f);
189	mp_print_data(mprof_file, fn_lcount(f));
190	mp_print_parents(mprof_file, plist);
191	}
192	}
193
194	void
195	mp_print_addr(mprof_file, f)
196	int mprof_file;
197	mpsym f;
198	{
199	char digits[14];
200
201	sprintf(digits, "%d\n", fn_addr(f));
202	write(mprof_file, digits, strlen(digits));
203	}
204
205	char *
206	mp_sprint_data(d)
207	mpdata d;
208	{
209	char digits[255];
210	char *result;
211
212	sprintf(digits, "(%d %d %d %d %d %d %d %d %d %d %d %d)",
213	dt_b_small(d),
214	dt_b_med(d),
215	dt_b_large(d),
216	dt_b_xlarge(d),
217	dt_n_small(d),
218	dt_n_med(d),
219	dt_n_large(d),
220	dt_n_xlarge(d),
221	dt_d_small(d),
222	dt_d_med(d),
223	dt_d_large(d),
224	dt_d_xlarge(d));
225	result = malloc(strlen(digits) + 1);
226	strcpy(result, digits);
227	return result;
228	}
229
230	void
231	mp_print_data(mprof_file, d)
232	int mprof_file;
233	mpdata d;
234	{
235	char digits[255];
236
237	if (mp_pprint) {
238	sprintf(digits, "(%d %d %d %d %d %d %d %d %d %d %d %d)",
239	dt_b_small(d),
240	dt_b_med(d),
241	dt_b_large(d),
242	dt_b_xlarge(d),
243	dt_n_small(d),
244	dt_n_med(d),
245	dt_n_large(d),
246	dt_n_xlarge(d),
247	dt_d_small(d),
248	dt_d_med(d),
249	dt_d_large(d),
250	dt_d_xlarge(d));
251	} else {
252	sprintf(digits, "%d %d %d %d %d %d %d %d %d %d %d %d\n",
253	dt_b_small(d),
254	dt_b_med(d),
255	dt_b_large(d),
256	dt_b_xlarge(d),
257	dt_n_small(d),
258	dt_n_med(d),
259	dt_n_large(d),
260	dt_n_xlarge(d),
261	dt_d_small(d),
262	dt_d_med(d),
263	dt_d_large(d),
264	dt_d_xlarge(d));
265	}
266	write(mprof_file, digits, strlen(digits));
267	}
268
269	void
270	mp_print_parents(mprof_file, l)
271	int mprof_file;
272	mpcell l;
273	{
274	mpcell rest = l;
275	mpcell p;
276
277	if (mp_pprint) {
278	write(mprof_file, "(", 1);
279	while (!mp_null(rest)) {
280	p = (mpcell) mp_car(rest);
281	write(mprof_file, "(\"", 2);
282	write(mprof_file,
283	fn_name((mpsym) mp_car(p)),
284	strlen(fn_name((mpsym) mp_car(p))));
285	write(mprof_file, "\" ", 2);
286	mp_print_data(mprof_file, (mpdata) mp_cdr(p));
287	write(mprof_file, ")", 1);
288	rest = mp_cdr(rest);
289	if (!mp_null(rest)) {
290	write(mprof_file, " ", 1);
291	}
292	}
293	write(mprof_file, ")", 1);
294	} else {
295	while (!mp_null(rest)) {
296	p = (mpcell) mp_car(rest);
297	mp_print_addr(mprof_file, (mpsym) mp_car(p));
298	mp_print_data(mprof_file, (mpdata) mp_cdr(p));
299	rest = (mpcell) mp_cdr(rest);
300	}
301	write(mprof_file, "-1\n", 3);
302	}
303	}
304
305
306	void
307	mprof_print(mprof_file)
308	int mprof_file;
309	{
310	mpsym s;
311	int i;
312	mpcell chain;
313
314	for (i = 0; i < MP_HASH_SIZE; i++) {
315	chain = hmem[i];
316	while (!mp_null(chain)) {
317	s = (mpsym) mp_car(chain);
318	mp_print_fn(mprof_file, s);
319	chain = (mpcell) mp_cdr(chain);
320	}
321	}
322	}
323
324
325	mpsym
326	pc_lookup(pc)
327	unsigned pc;
328	{
329	mpsym s;
330
331	s = mp_lookup(pc);
332	if (!mp_null(s)) {
333	return s;
334	} else {
335	/*
336	* create a new function
337	*/
338	s = mp_new_fn(pc);
339	mp_puthash(pc, s);
340	return s;
341	}
342	}
343
344	void
345	mpstruct_init()
346	{
347	int i;
348
349	for (i = 0; i < MP_HASH_SIZE; i++) {
350	hmem[i] = (mpcell) MP_NIL;
351	}
352	mprof_lmemC = 0;
353	mprof_fmemC = 0;
354	mprof_dmemC = 0;
355	}