trunk/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	dpavlin	22	/*
2	dpavlin	24	* Copyright (C) 2005-2006 Anders Gavare. All rights reserved.
3	dpavlin	22	*
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	dpavlin	28	* $Id: ic_statistics.c,v 1.4 2006/07/15 09:44:13 debug Exp $
29	dpavlin	22	*
30			* This program is not optimized for speed, but it should work.
31			*
32	dpavlin	28	* Run gxemul -s i:log.txt blahblahblah, and then
33			*
34	dpavlin	22	* 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	dpavlin	28	* ./ic_statistics log.txt $a \|sort -n > statistics.$a.txt; done
36	dpavlin	22	*/
37
38			#include <stdio.h>
39			#include <stdlib.h>
40			#include <string.h>
41			#include <sys/types.h>
42	dpavlin	24	#include <inttypes.h>
43	dpavlin	22
44
45			struct entry {
46	dpavlin	28	uint64_t *ptrs;
47	dpavlin	22	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	dpavlin	28	char *cached_size_t_to_symbol(uint64_t s)
61	dpavlin	22	{
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	dpavlin	28	snprintf(tmp, sizeof(tmp), "nm ../gxemul \| grep %"PRIx64, s);
79	dpavlin	22	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	dpavlin	28	uint64_t *pp = entries[i].ptrs;
110	dpavlin	22	int j = 0;
111
112			printf("%lli\t", (long long)entries[i].count);
113			while (j < n) {
114	dpavlin	28	uint64_t s = pp[j];
115	dpavlin	22
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	dpavlin	28	void add_count(uint64_t *icpointers, int n)
130	dpavlin	22	{
131			int i = 0;
132
133			/* Scan all existing entries. */
134			while (i < n_entries) {
135	dpavlin	28	if (memcmp(icpointers, entries[i].ptrs,
136			sizeof(uint64_t) * n) == 0) {
137	dpavlin	22	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	dpavlin	28	memcpy(entries[n_entries-1].ptrs, &icpointers[0], n * sizeof(uint64_t));
148	dpavlin	22	entries[n_entries-1].count = 1;
149			}
150
151
152			void try_len(FILE *f, int len)
153			{
154	dpavlin	28	uint64_t *icpointers;
155			off_t off, n_read = 0;
156	dpavlin	22
157	dpavlin	28	icpointers = malloc(sizeof(uint64_t) * len);
158	dpavlin	22
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	dpavlin	28	char buf[100];
167
168	dpavlin	22	yo ++;
169			if ((yo & 0xfffff) == 0) {
170			fprintf(stderr, "[ len=%i, %i%% done ]\n",
171			len, 100 * yo * sizeof(void *) / off);
172			}
173
174	dpavlin	28	/* Make room for next icpointer value: */
175	dpavlin	22	if (len > 1)
176	dpavlin	28	memmove(&icpointers[0], &icpointers[1],
177			(len-1) * sizeof(uint64_t));
178	dpavlin	22
179	dpavlin	28	/* Read one value into icpointers[len-1]: */
180			fgets(buf, sizeof(buf), f);
181			icpointers[len-1] = strtoull(buf, NULL, 0);
182	dpavlin	22
183	dpavlin	28	n_read ++;
184
185			if (n_read >= len)
186			add_count(&icpointers[0], len);
187	dpavlin	22	}
188
189	dpavlin	28	free(icpointers);
190	dpavlin	22	}
191
192
193			int main(int argc, char *argv[])
194			{
195			FILE *f;
196			int len = 1;
197
198	dpavlin	28	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	dpavlin	22	if (f == NULL) {
205	dpavlin	28	perror(argv[1]);
206			exit(1);
207	dpavlin	22	}
208
209	dpavlin	28	len = atoi(argv[2]);
210	dpavlin	22
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