trunk/experiments/ic_statistics.c

/*
 *  Copyright (C) 2005  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.2 2005/12/19 02:16:39 debug Exp $
 *
 *  This program is not optimized for speed, but it should work.
 *
 *  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 $a |sort -n > statistics.$a.txt; done
 */

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


struct entry {
        void            **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(size_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 "
            "%llx", (long long)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) {
                void **pp = entries[i].ptrs;
                int j = 0;

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

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

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

                i++;
        }
}


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

        /*  Scan all existing entries.  */
        while (i < n_entries) {
                if (memcmp(pointers, entries[i].ptrs, sizeof(void*) * 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, &pointers[0], n * sizeof(void *));
        entries[n_entries-1].count = 1;
}


void try_len(FILE *f, int len)
{
        void **pointers;
        off_t off;

        pointers = malloc(sizeof(void *) * len);

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

        fseek(f, 0, SEEK_SET);
        if (len > 1)
                fread(&pointers[1], sizeof(void *), len-1, f);

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

                /*  Make room for next pointer value:  */
                if (len > 1)
                        memmove(&pointers[0], &pointers[1],
                            (len-1) * sizeof(void *));

                /*  Read one pointer into pointers[len-1]:  */
                fread(&pointers[len-1], sizeof(void *), 1, f);

                add_count(&pointers[0], len);
        }

        free(pointers);
}


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

        f = fopen("instruction_call_statistics.raw", "r");
        if (f == NULL) {
                f = fopen("../instruction_call_statistics.raw", "r");
                if (f == NULL) {
                        perror("instruction_call_statistics.raw");
                        exit(1);
                }
        }

        if (argc > 1)
                len = atoi(argv[1]);

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

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

        return 0;
}

1	dpavlin	22	/*
2			* Copyright (C) 2005 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.2 2005/12/19 02:16:39 debug Exp $
29			*
30			* This program is not optimized for speed, but it should work.
31			*
32			* for a in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
33			* ./ic_statistics $a \|sort -n > statistics.$a.txt; done
34			*/
35
36			#include <stdio.h>
37			#include <stdlib.h>
38			#include <string.h>
39			#include <sys/types.h>
40
41
42			struct entry {
43			void **ptrs;
44			long long count;
45			};
46
47
48			struct entry *entries = NULL;
49			int n_entries = 0;
50
51
52			size_t *cache_s = NULL;
53			char **cache_symbol = NULL;
54			int n_cached_symbols = 0;
55
56
57			char *cached_size_t_to_symbol(size_t s)
58			{
59			int i = 0;
60			FILE *q;
61			char tmp[200];
62			char urk, urk2;
63
64			while (i < n_cached_symbols) {
65			if (cache_s[i] == s)
66			return cache_symbol[i];
67			i++;
68			}
69
70			n_cached_symbols ++;
71			cache_s = realloc(cache_s, sizeof(size_t) * n_cached_symbols);
72			cache_symbol = realloc(cache_symbol, sizeof(char ) n_cached_symbols);
73			cache_s[n_cached_symbols - 1] = s;
74
75			snprintf(tmp, sizeof(tmp), "nm ../gxemul \| grep "
76			"%llx", (long long)s);
77			q = popen(tmp, "r");
78			if (q == NULL) {
79			perror("popen()");
80			exit(1);
81			}
82			fgets(tmp, sizeof(tmp), q);
83			pclose(q);
84
85			while (tmp[0] && (tmp[strlen(tmp)-1] == '\n' \|\|
86			tmp[strlen(tmp)-1] == '\r'))
87			tmp[strlen(tmp)-1] = '\0';
88
89			urk = strrchr(tmp, ' ');
90			if (urk == NULL)
91			urk = tmp;
92			else
93			urk ++;
94
95			urk2 = strstr(urk, "instr_");
96			if (urk2 != NULL)
97			urk = urk2 + 6;
98
99			cache_symbol[n_cached_symbols - 1] = strdup(urk);
100			}
101
102
103			void print_all(int n)
104			{
105			int i = 0;
106			while (i < n_entries) {
107			void **pp = entries[i].ptrs;
108			int j = 0;
109
110			printf("%lli\t", (long long)entries[i].count);
111			while (j < n) {
112			size_t s = (size_t)pp[j];
113
114			if (j > 0)
115			printf(", ");
116			printf("%s", cached_size_t_to_symbol(s));
117
118			j++;
119			}
120			printf("\n");
121
122			i++;
123			}
124			}
125
126
127			void add_count(void **pointers, int n)
128			{
129			int i = 0;
130
131			/* Scan all existing entries. */
132			while (i < n_entries) {
133			if (memcmp(pointers, entries[i].ptrs, sizeof(void) n) == 0) {
134			entries[i].count ++;
135			return;
136			}
137			i++;
138			}
139
140			/* Add new entry: */
141			n_entries ++;
142			entries = realloc(entries, sizeof(struct entry) * n_entries);
143			entries[n_entries-1].ptrs = malloc(sizeof(void ) n);
144			memcpy(entries[n_entries-1].ptrs, &pointers[0], n * sizeof(void *));
145			entries[n_entries-1].count = 1;
146			}
147
148
149			void try_len(FILE *f, int len)
150			{
151			void **pointers;
152			off_t off;
153
154			pointers = malloc(sizeof(void ) len);
155
156			fseek(f, 0, SEEK_END);
157			off = ftello(f);
158
159			fseek(f, 0, SEEK_SET);
160			if (len > 1)
161			fread(&pointers[1], sizeof(void *), len-1, f);
162
163			while (!feof(f)) {
164			static long long yo = 0;
165			yo ++;
166			if ((yo & 0xfffff) == 0) {
167			fprintf(stderr, "[ len=%i, %i%% done ]\n",
168			len, 100 * yo * sizeof(void *) / off);
169			}
170
171			/* Make room for next pointer value: */
172			if (len > 1)
173			memmove(&pointers[0], &pointers[1],
174			(len-1) * sizeof(void *));
175
176			/* Read one pointer into pointers[len-1]: */
177			fread(&pointers[len-1], sizeof(void *), 1, f);
178
179			add_count(&pointers[0], len);
180			}
181
182			free(pointers);
183			}
184
185
186			int main(int argc, char *argv[])
187			{
188			FILE *f;
189			int len = 1;
190
191			f = fopen("instruction_call_statistics.raw", "r");
192			if (f == NULL) {
193			f = fopen("../instruction_call_statistics.raw", "r");
194			if (f == NULL) {
195			perror("instruction_call_statistics.raw");
196			exit(1);
197			}
198			}
199
200			if (argc > 1)
201			len = atoi(argv[1]);
202
203			if (len < 1) {
204			fprintf(stderr, "bad len\n");
205			exit(1);
206			}
207
208			try_len(f, len);
209			print_all(len);
210
211			return 0;
212			}
213