0.4.4/experiments/ic_statistics.c

/*
 *  Copyright (C) 2005-2006  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: ic_statistics.c,v 1.4 2006/07/15 09:44:13 debug Exp $
 *
 *  This program is not optimized for speed, but it should work.
 *
 *  Run  gxemul -s i:log.txt blahblahblah, and then
 *
 *  for a in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
 *      ./ic_statistics log.txt $a |sort -n > statistics.$a.txt; done
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <inttypes.h>


struct entry {
        uint64_t        *ptrs;
        long long       count;
};


struct entry *entries = NULL;
int n_entries = 0;


size_t *cache_s = NULL;
char **cache_symbol = NULL;
int n_cached_symbols = 0;


char *cached_size_t_to_symbol(uint64_t s)
{
        int i = 0;
        FILE *q;
        char tmp[200];
        char *urk, *urk2;

        while (i < n_cached_symbols) {
                if (cache_s[i] == s)
                        return cache_symbol[i];
                i++;
        }

        n_cached_symbols ++;
        cache_s = realloc(cache_s, sizeof(size_t) * n_cached_symbols);
        cache_symbol = realloc(cache_symbol, sizeof(char *) * n_cached_symbols);
        cache_s[n_cached_symbols - 1] = s;

        snprintf(tmp, sizeof(tmp), "nm ../gxemul | grep %"PRIx64, s);
        q = popen(tmp, "r");
        if (q == NULL) {
                perror("popen()");
                exit(1);
        }
        fgets(tmp, sizeof(tmp), q);
        pclose(q);

        while (tmp[0] && (tmp[strlen(tmp)-1] == '\n' ||
            tmp[strlen(tmp)-1] == '\r'))
                tmp[strlen(tmp)-1] = '\0';

        urk = strrchr(tmp, ' ');
        if (urk == NULL)
                urk = tmp;
        else
                urk ++;

        urk2 = strstr(urk, "instr_");
        if (urk2 != NULL)
                urk = urk2 + 6;

        cache_symbol[n_cached_symbols - 1] = strdup(urk);
}


void print_all(int n)
{
        int i = 0;
        while (i < n_entries) {
                uint64_t *pp = entries[i].ptrs;
                int j = 0;

                printf("%lli\t", (long long)entries[i].count);
                while (j < n) {
                        uint64_t s = pp[j];

                        if (j > 0)
                                printf(", ");
                        printf("%s", cached_size_t_to_symbol(s));

                        j++;
                }
                printf("\n");

                i++;
        }
}


void add_count(uint64_t *icpointers, int n)
{
        int i = 0;

        /*  Scan all existing entries.  */
        while (i < n_entries) {
                if (memcmp(icpointers, entries[i].ptrs,
                    sizeof(uint64_t) * n) == 0) {
                        entries[i].count ++;
                        return;
                }
                i++;
        }

        /*  Add new entry:  */
        n_entries ++;
        entries = realloc(entries, sizeof(struct entry) * n_entries);
        entries[n_entries-1].ptrs = malloc(sizeof(void *) * n);
        memcpy(entries[n_entries-1].ptrs, &icpointers[0], n * sizeof(uint64_t));
        entries[n_entries-1].count = 1;
}


void try_len(FILE *f, int len)
{
        uint64_t *icpointers;
        off_t off, n_read = 0;

        icpointers = malloc(sizeof(uint64_t) * len);

        fseek(f, 0, SEEK_END);
        off = ftello(f);

        fseek(f, 0, SEEK_SET);

        while (!feof(f)) {
                static long long yo = 0;
                char buf[100];

                yo ++;
                if ((yo & 0xfffff) == 0) {
                        fprintf(stderr, "[ len=%i, %i%% done ]\n",
                            len, 100 * yo * sizeof(void *) / off);
                }

                /*  Make room for next icpointer value:  */
                if (len > 1)
                        memmove(&icpointers[0], &icpointers[1],
                            (len-1) * sizeof(uint64_t));

                /*  Read one value into icpointers[len-1]:  */
                fgets(buf, sizeof(buf), f);
                icpointers[len-1] = strtoull(buf, NULL, 0);

                n_read ++;

                if (n_read >= len)
                        add_count(&icpointers[0], len);
        }

        free(icpointers);
}


int main(int argc, char *argv[])
{
        FILE *f;
        int len = 1;

        if (argc < 3) {
                fprintf(stderr, "usage: %s input.log n\n", argv[0]);
                exit(1);
        }

        f = fopen(argv[1], "r");
        if (f == NULL) {
                perror(argv[1]);
                exit(1);
        }

        len = atoi(argv[2]);

        if (len < 1) {
                fprintf(stderr, "bad len\n");
                exit(1);
        }

        try_len(f, len);
        print_all(len);

        return 0;
}

1	/*
2	* Copyright (C) 2005-2006 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: ic_statistics.c,v 1.4 2006/07/15 09:44:13 debug Exp $
29	*
30	* This program is not optimized for speed, but it should work.
31	*
32	* Run gxemul -s i:log.txt blahblahblah, and then
33	*
34	* for a in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
35	* ./ic_statistics log.txt $a \|sort -n > statistics.$a.txt; done
36	*/
37
38	#include <stdio.h>
39	#include <stdlib.h>
40	#include <string.h>
41	#include <sys/types.h>
42	#include <inttypes.h>
43
44
45	struct entry {
46	uint64_t *ptrs;
47	long long count;
48	};
49
50
51	struct entry *entries = NULL;
52	int n_entries = 0;
53
54
55	size_t *cache_s = NULL;
56	char **cache_symbol = NULL;
57	int n_cached_symbols = 0;
58
59
60	char *cached_size_t_to_symbol(uint64_t s)
61	{
62	int i = 0;
63	FILE *q;
64	char tmp[200];
65	char urk, urk2;
66
67	while (i < n_cached_symbols) {
68	if (cache_s[i] == s)
69	return cache_symbol[i];
70	i++;
71	}
72
73	n_cached_symbols ++;
74	cache_s = realloc(cache_s, sizeof(size_t) * n_cached_symbols);
75	cache_symbol = realloc(cache_symbol, sizeof(char ) n_cached_symbols);
76	cache_s[n_cached_symbols - 1] = s;
77
78	snprintf(tmp, sizeof(tmp), "nm ../gxemul \| grep %"PRIx64, s);
79	q = popen(tmp, "r");
80	if (q == NULL) {
81	perror("popen()");
82	exit(1);
83	}
84	fgets(tmp, sizeof(tmp), q);
85	pclose(q);
86
87	while (tmp[0] && (tmp[strlen(tmp)-1] == '\n' \|\|
88	tmp[strlen(tmp)-1] == '\r'))
89	tmp[strlen(tmp)-1] = '\0';
90
91	urk = strrchr(tmp, ' ');
92	if (urk == NULL)
93	urk = tmp;
94	else
95	urk ++;
96
97	urk2 = strstr(urk, "instr_");
98	if (urk2 != NULL)
99	urk = urk2 + 6;
100
101	cache_symbol[n_cached_symbols - 1] = strdup(urk);
102	}
103
104
105	void print_all(int n)
106	{
107	int i = 0;
108	while (i < n_entries) {
109	uint64_t *pp = entries[i].ptrs;
110	int j = 0;
111
112	printf("%lli\t", (long long)entries[i].count);
113	while (j < n) {
114	uint64_t s = pp[j];
115
116	if (j > 0)
117	printf(", ");
118	printf("%s", cached_size_t_to_symbol(s));
119
120	j++;
121	}
122	printf("\n");
123
124	i++;
125	}
126	}
127
128
129	void add_count(uint64_t *icpointers, int n)
130	{
131	int i = 0;
132
133	/* Scan all existing entries. */
134	while (i < n_entries) {
135	if (memcmp(icpointers, entries[i].ptrs,
136	sizeof(uint64_t) * n) == 0) {
137	entries[i].count ++;
138	return;
139	}
140	i++;
141	}
142
143	/* Add new entry: */
144	n_entries ++;
145	entries = realloc(entries, sizeof(struct entry) * n_entries);
146	entries[n_entries-1].ptrs = malloc(sizeof(void ) n);
147	memcpy(entries[n_entries-1].ptrs, &icpointers[0], n * sizeof(uint64_t));
148	entries[n_entries-1].count = 1;
149	}
150
151
152	void try_len(FILE *f, int len)
153	{
154	uint64_t *icpointers;
155	off_t off, n_read = 0;
156
157	icpointers = malloc(sizeof(uint64_t) * len);
158
159	fseek(f, 0, SEEK_END);
160	off = ftello(f);
161
162	fseek(f, 0, SEEK_SET);
163
164	while (!feof(f)) {
165	static long long yo = 0;
166	char buf[100];
167
168	yo ++;
169	if ((yo & 0xfffff) == 0) {
170	fprintf(stderr, "[ len=%i, %i%% done ]\n",
171	len, 100 * yo * sizeof(void *) / off);
172	}
173
174	/* Make room for next icpointer value: */
175	if (len > 1)
176	memmove(&icpointers[0], &icpointers[1],
177	(len-1) * sizeof(uint64_t));
178
179	/* Read one value into icpointers[len-1]: */
180	fgets(buf, sizeof(buf), f);
181	icpointers[len-1] = strtoull(buf, NULL, 0);
182
183	n_read ++;
184
185	if (n_read >= len)
186	add_count(&icpointers[0], len);
187	}
188
189	free(icpointers);
190	}
191
192
193	int main(int argc, char *argv[])
194	{
195	FILE *f;
196	int len = 1;
197
198	if (argc < 3) {
199	fprintf(stderr, "usage: %s input.log n\n", argv[0]);
200	exit(1);
201	}
202
203	f = fopen(argv[1], "r");
204	if (f == NULL) {
205	perror(argv[1]);
206	exit(1);
207	}
208
209	len = atoi(argv[2]);
210
211	if (len < 1) {
212	fprintf(stderr, "bad len\n");
213	exit(1);
214	}
215
216	try_len(f, len);
217	print_all(len);
218
219	return 0;
220	}
221