![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to profile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / debug|
Return to profile.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / debug |
1.1 root 1: /*
2: * Hatari - profile.c
3: *
4: * Copyright (C) 2010 by Eero Tamminen
5: *
6: * This file is distributed under the GNU Public License, version 2 or at
7: * your option any later version. Read the file gpl.txt for details.
8: *
9: * profile.c - functions for profiling CPU and DSP and showing the results.
10: */
11: const char Profile_fileid[] = "Hatari profile.c : " __DATE__ " " __TIME__;
12:
13: #include <stdio.h>
14: #include "main.h"
15: #include "debug_priv.h"
16: #include "dsp.h"
17: #include "m68000.h"
18: #include "profile.h"
19: #include "stMemory.h"
20: #include "symbols.h"
21: #include "tos.h"
22:
23: #define MAX_PROFILE_VALUE 0xFFFFFFFF
24:
25: typedef struct {
26: Uint32 count; /* how many times this address is used */
27: Uint32 cycles; /* what address this is (for sorting) */
28: } profile_item_t;
29:
30: typedef struct {
31: unsigned long long all_cycles, all_count;
32: Uint32 max_cycles, max_cycles_addr;
33: Uint32 max_count, max_count_addr;
34: Uint32 lowest, highest; /* active address range within memory area */
35: Uint32 active; /* number of active addresses */
36: } profile_area_t;
37:
38: static struct {
39: unsigned long long all_cycles, all_count;
40: Uint32 size; /* number of allocated profile data items */
41: profile_item_t *data; /* profile data items */
42: profile_area_t ram; /* normal RAM stats */
43: profile_area_t rom; /* cartridge ROM stats */
44: profile_area_t tos; /* ROM TOS stats */
45: Uint32 active; /* number of active data items in all areas */
46: Uint32 *sort_arr; /* data indexes used for sorting */
47: bool enabled; /* true when profiling enabled */
48: } cpu_profile;
49:
50:
51: #define DSP_PROFILE_ARR_SIZE 0x10000
52:
53: static struct {
54: profile_item_t *data; /* profile data */
55: profile_area_t ram; /* normal RAM stats */
56: Uint16 *sort_arr; /* data indexes used for sorting */
57: bool enabled; /* true when profiling enabled */
58: } dsp_profile;
59:
60:
61: /* ------------------ CPU profile results ----------------- */
62:
63: /**
64: * convert Atari memory address to sorting array profile data index.
65: */
66: static inline Uint32 address2index(Uint32 pc)
67: {
68: if (unlikely(pc & 1)) {
69: fprintf(stderr, "WARNING: odd CPU profile instruction address 0x%x!\n", pc);
70: }
71: if (pc >= TosAddress && pc < TosAddress + TosSize) {
72: /* TOS, put it after RAM & ROM data */
73: pc = pc - TosAddress + STRamEnd + 0x20000;
74:
75: } else if (pc >= 0xFA0000 && pc < 0xFC0000) {
76: /* ROM, put it after RAM data */
77: pc = pc - 0xFA0000 + STRamEnd;
78:
79: } else {
80: /* if in RAM, use as-is */
81: if (unlikely(pc >= STRamEnd)) {
82: fprintf(stderr, "WARNING: 'invalid' CPU PC profile instruction address 0x%x, skipping!\n", pc);
83: /* extra entry at end reserved for invalid PC values */
84: pc = STRamEnd + 0x20000 + TosSize;
85: }
86: }
87: /* CPU instructions are at even addresses, save space by halving */
88: return (pc >> 1);
89: }
90:
91:
92: /**
93: * Get CPU cycles & count for given address.
94: * Return true if data was available and non-zero, false otherwise.
95: */
96: bool Profile_CpuAddressData(Uint32 addr, Uint32 *count, Uint32 *cycles)
97: {
98: Uint32 idx;
99: if (!cpu_profile.data) {
100: return false;
101: }
102: idx = address2index(addr);
103: *cycles = cpu_profile.data[idx].cycles;
104: *count = cpu_profile.data[idx].count;
105: return (*count > 0);
106: }
107:
108:
109: /**
110: * convert sorting array profile data index to Atari memory address.
111: */
112: static Uint32 index2address(Uint32 idx)
113: {
114: idx <<= 1;
115: /* RAM */
116: if (idx < STRamEnd) {
117: return idx;
118: }
119: /* ROM */
120: idx -= STRamEnd;
121: if (idx < 0x20000) {
122: return idx + 0xFA0000;
123: }
124: /* TOS */
125: return idx - 0x20000 + TosAddress;
126: }
127:
128:
129: /**
130: * Helper to show statistics for specified CPU profile area.
131: */
132: static void show_cpu_area_stats(profile_area_t *area)
133: {
134: if (!area->active) {
135: fprintf(stderr, "- no activity\n");
136: return;
137: }
138: fprintf(stderr, "- active address range:\n 0x%06x-0x%06x\n",
139: index2address(area->lowest),
140: index2address(area->highest));
141: fprintf(stderr, "- active instruction addresses:\n %d (%.2f%% of all)\n",
142: area->active,
143: (float)area->active/cpu_profile.active*100);
144: fprintf(stderr, "- executed instructions:\n %llu (%.2f%% of all)\n",
145: area->all_count,
146: (float)area->all_count/cpu_profile.all_count*100);
147: fprintf(stderr, "- used cycles:\n %llu (%.2f%% of all)\n",
148: area->all_cycles,
149: (float)area->all_cycles/cpu_profile.all_cycles*100);
150: fprintf(stderr, "- address with most cycles:\n 0x%06x, %d cycles (%.2f%% of all in area)\n",
151: index2address(area->max_cycles_addr),
152: area->max_cycles,
153: (float)area->max_cycles/area->all_cycles*100);
154: fprintf(stderr, "- address with most hits:\n 0x%06x, %d hits (%.2f%% of all in area)\n",
155: index2address(area->max_count_addr),
156: area->max_count,
157: (float)area->max_count/area->all_count*100);
158: if (area->max_cycles == MAX_PROFILE_VALUE) {
159: fprintf(stderr, "- Counters OVERFLOW!\n");
160: }
161: }
162:
163:
164: /**
165: * show CPU area (RAM, ROM, TOS) specific statistics.
166: */
167: void Profile_CpuShowStats(void)
168: {
169: fprintf(stderr, "Normal RAM (0-0x%X):\n", STRamEnd);
170: show_cpu_area_stats(&cpu_profile.ram);
171:
172: fprintf(stderr, "Cartridge ROM (0xFA0000-0xFC0000):\n");
173: show_cpu_area_stats(&cpu_profile.rom);
174:
175: fprintf(stderr, "ROM TOS (0x%X-0x%X):\n", TosAddress, TosAddress+TosSize);
176: show_cpu_area_stats(&cpu_profile.tos);
177: }
178:
179:
180: /**
181: * compare function for qsort() to sort CPU profile data by descdending
182: * address cycles counts.
183: */
184: static int profile_by_cpu_cycles(const void *p1, const void *p2)
185: {
186: Uint32 count1 = cpu_profile.data[*(const Uint32*)p1].cycles;
187: Uint32 count2 = cpu_profile.data[*(const Uint32*)p2].cycles;
188: if (count1 > count2) {
189: return -1;
190: }
191: if (count1 < count2) {
192: return 1;
193: }
194: return 0;
195: }
196:
197: /**
198: * Sort CPU profile data addresses by cycle counts and show the results.
199: */
200: void Profile_CpuShowCycles(unsigned int show)
201: {
202: unsigned int active;
203: Uint32 *sort_arr, *end, addr;
204: profile_item_t *data = cpu_profile.data;
205: float percentage;
206: Uint32 count;
207:
208: if (!data) {
209: fprintf(stderr, "ERROR: no CPU profiling data available!\n");
210: return;
211: }
212:
213: active = cpu_profile.active;
214: sort_arr = cpu_profile.sort_arr;
215: qsort(sort_arr, active, sizeof(*sort_arr), profile_by_cpu_cycles);
216:
217: printf("addr:\t\tcycles:\n");
218: show = (show < active ? show : active);
219: for (end = sort_arr + show; sort_arr < end; sort_arr++) {
220: addr = index2address(*sort_arr);
221: count = data[*sort_arr].cycles;
222: percentage = 100.0*count/cpu_profile.all_cycles;
223: printf("0x%06x\t%.2f%%\t%d%s\n", addr, percentage, count,
224: count == MAX_PROFILE_VALUE ? " (OVERFLOW)" : "");
225: }
226: printf("%d CPU addresses listed.\n", show);
227: }
228:
229:
230: /**
231: * compare function for qsort() to sort CPU profile data by descdending
232: * address access counts.
233: */
234: static int profile_by_cpu_count(const void *p1, const void *p2)
235: {
236: Uint32 count1 = cpu_profile.data[*(const Uint32*)p1].count;
237: Uint32 count2 = cpu_profile.data[*(const Uint32*)p2].count;
238: if (count1 > count2) {
239: return -1;
240: }
241: if (count1 < count2) {
242: return 1;
243: }
244: return 0;
245: }
246:
247: /**
248: * Sort CPU profile data addresses by call counts and show the results.
249: * If symbols are requested and symbols are loaded, show (only) addresses
250: * matching a symbol.
251: */
252: void Profile_CpuShowCounts(unsigned int show, bool only_symbols)
253: {
254: profile_item_t *data = cpu_profile.data;
255: unsigned int symbols, matched, active;
256: Uint32 *sort_arr, *end, addr;
257: const char *name;
258: float percentage;
259: Uint32 count;
260:
261: if (!data) {
262: fprintf(stderr, "ERROR: no CPU profiling data available!\n");
263: return;
264: }
265: active = cpu_profile.active;
266: show = (show < active ? show : active);
267:
268: sort_arr = cpu_profile.sort_arr;
269: qsort(sort_arr, active, sizeof(*sort_arr), profile_by_cpu_count);
270:
271: if (!only_symbols) {
272: printf("addr:\t\tcount:\n");
273: for (end = sort_arr + show; sort_arr < end; sort_arr++) {
274: addr = index2address(*sort_arr);
275: count = data[*sort_arr].count;
276: percentage = 100.0*count/cpu_profile.all_count;
277: printf("0x%06x\t%.2f%%\t%d%s\n",
278: addr, percentage, count,
279: count == MAX_PROFILE_VALUE ? " (OVERFLOW)" : "");
280: }
281: printf("%d CPU addresses listed.\n", show);
282: return;
283: }
284:
285: symbols = Symbols_CpuCount();
286: if (!symbols) {
287: fprintf(stderr, "ERROR: no CPU symbols loaded!\n");
288: return;
289: }
290: matched = 0;
291:
292: printf("addr:\t\tcount:\t\tsymbol:\n");
293: for (end = sort_arr + active; sort_arr < end; sort_arr++) {
294:
295: addr = index2address(*sort_arr);
296: name = Symbols_GetByCpuAddress(addr);
297: if (!name) {
298: continue;
299: }
300: count = data[*sort_arr].count;
301: percentage = 100.0*count/cpu_profile.all_count;
302: printf("0x%06x\t%.2f%%\t%d\t%s%s\n",
303: addr, percentage, count, name,
304: count == MAX_PROFILE_VALUE ? " (OVERFLOW)" : "");
305:
306: matched++;
307: if (matched >= show || matched >= symbols) {
308: break;
309: }
310: }
311: printf("%d CPU symbols listed.\n", matched);
312: }
313:
314:
315: /* ------------------ CPU profile control ----------------- */
316:
317: /**
318: * Initialize CPU profiling when necessary. Return true if profiling.
319: */
320: bool Profile_CpuStart(void)
321: {
322: if (cpu_profile.sort_arr) {
323: /* remove previous results */
324: free(cpu_profile.sort_arr);
325: free(cpu_profile.data);
326: cpu_profile.sort_arr = NULL;
327: cpu_profile.data = NULL;
328: printf("Freed previous CPU profile buffers.\n");
329: }
330: if (!cpu_profile.enabled) {
331: return false;
332: }
333: /* Shouldn't change within same debug session */
334: cpu_profile.size = (STRamEnd + 0x20000 + TosSize) / 2;
335:
336: /* Add one entry for catching invalid PC values */
337: cpu_profile.data = calloc(cpu_profile.size+1, sizeof(*cpu_profile.data));
338: if (cpu_profile.data) {
339: printf("Allocated CPU profile buffer (%d MB).\n",
340: (int)sizeof(*cpu_profile.data)*cpu_profile.size/1024/1024);
341: } else {
342: perror("ERROR, new CPU profile buffer alloc failed");
343: cpu_profile.enabled = false;
344: }
345: return cpu_profile.enabled;
346: }
347:
348:
349: /**
350: * Update CPU cycle and count statistics for PC address.
351: */
352: void Profile_CpuUpdate(void)
353: {
354: Uint32 idx, opcode, cycles;
355:
356: idx = address2index(M68000_GetPC());
357:
358: if (likely(cpu_profile.data[idx].count < MAX_PROFILE_VALUE)) {
359: cpu_profile.data[idx].count++;
360: }
361:
362: opcode = get_iword_prefetch (0);
363: cycles = (*cpufunctbl[opcode])(opcode) + nWaitStateCycles;
364:
365: if (likely(cpu_profile.data[idx].cycles < MAX_PROFILE_VALUE - cycles)) {
366: cpu_profile.data[idx].cycles += cycles;
367: }
368: }
369:
370:
371: /**
372: * Helper for collecting profile area statistics.
373: */
374: static void update_area(Uint32 i, profile_item_t *item, profile_area_t *area)
375: {
376: Uint32 cycles, count = item->count;
377: if (!count) {
378: return;
379: }
380:
381: area->all_count += count;
382: if (count > area->max_count) {
383: area->max_count = count;
384: area->max_count_addr = i;
385: }
386:
387: cycles = item->cycles;
388: area->all_cycles += cycles;
389: if (cycles > area->max_cycles) {
390: area->max_cycles = cycles;
391: area->max_cycles_addr = i;
392: }
393:
394: if (i < area->lowest) {
395: area->lowest = i;
396: }
397: area->highest = i;
398:
399: area->active++;
400: }
401:
402:
403: /**
404: * Stop and process the CPU profiling data; collect stats and
405: * prepare for more optimal sorting.
406: */
407: void Profile_CpuStop(void)
408: {
409: profile_item_t *item;
410: profile_area_t *area;
411: Uint32 *sort_arr;
412: Uint32 i, active;
413:
414: if (!cpu_profile.enabled) {
415: return;
416: }
417: /* user didn't change RAM or TOS size in the meanwhile? */
418: assert(cpu_profile.size == (STRamEnd + 0x20000 + TosSize) / 2);
419:
420: /* find lowest and highest addresses executed... */
421: item = cpu_profile.data;
422:
423: /* ...for normal RAM */
424: area = &cpu_profile.ram;
425: memset(area, 0, sizeof(profile_area_t));
426: area->lowest = cpu_profile.size;
427:
428: for (i = 0; i < STRamEnd/2; i++, item++) {
429: update_area(i, item, area);
430: }
431:
432: /* ... for Cartridge ROM */
433: area = &cpu_profile.rom;
434: memset(area, 0, sizeof(profile_area_t));
435: area->lowest = cpu_profile.size;
436:
437: for (; i < (STRamEnd + 0x20000)/2; i++, item++) {
438: update_area(i, item, area);
439: }
440:
441: /* ...for ROM TOS */
442: area = &cpu_profile.tos;
443: memset(area, 0, sizeof(profile_area_t));
444: area->lowest = cpu_profile.size;
445:
446: for (; i < cpu_profile.size; i++, item++) {
447: update_area(i, item, area);
448: }
449:
450: cpu_profile.all_cycles = cpu_profile.ram.all_cycles + cpu_profile.rom.all_cycles + cpu_profile.tos.all_cycles;
451: cpu_profile.all_count = cpu_profile.ram.all_count + cpu_profile.rom.all_count + cpu_profile.tos.all_count;
452:
453: /* allocate address array for sorting */
454: active = cpu_profile.ram.active + cpu_profile.rom.active + cpu_profile.tos.active;
455: sort_arr = calloc(active, sizeof(*sort_arr));
456:
457: if (!sort_arr) {
458: perror("ERROR: allocating CPU profile address data");
459: free(cpu_profile.data);
460: cpu_profile.data = NULL;
461: return;
462: }
463: printf("Allocated CPU profile address buffer (%d KB).\n",
464: (int)sizeof(*sort_arr)*(active+512)/1024);
465: cpu_profile.sort_arr = sort_arr;
466: cpu_profile.active = active;
467:
468: /* and fill addresses for used instructions... */
469:
470: /* ...for normal RAM */
471: area = &cpu_profile.ram;
472: item = cpu_profile.data + area->lowest;
473: for (i = area->lowest; i <= area->highest; i++, item++) {
474: if (item->count) {
475: *sort_arr++ = i;
476: }
477: }
478:
479: /* ...for Cartridge ROM */
480: area = &cpu_profile.rom;
481: item = cpu_profile.data + area->lowest;
482: for (i = area->lowest; i <= area->highest; i++, item++) {
483: if (item->count) {
484: *sort_arr++ = i;
485: }
486: }
487:
488: /* ...for TOS ROM */
489: area = &cpu_profile.tos;
490: item = cpu_profile.data + area->lowest;
491: for (i = area->lowest; i <= area->highest; i++, item++) {
492: if (item->count) {
493: *sort_arr++ = i;
494: }
495: }
496: //printf("%d/%d/%d\n", area->active, sort_arr-cpu_profile.sort_arr, active);
497:
498: Profile_CpuShowStats();
499: return;
500: }
501:
502:
503: /* ------------------ DSP profile results ----------------- */
504:
505: /**
506: * Get DSP cycles & count for given address.
507: * Return true if data was available and non-zero, false otherwise.
508: */
509: bool Profile_DspAddressData(Uint16 addr, Uint32 *count, Uint32 *cycles)
510: {
511: if (!dsp_profile.data) {
512: return false;
513: }
514: *cycles = dsp_profile.data[addr].cycles;
515: *count = dsp_profile.data[addr].count;
516: return (*count > 0);
517: }
518:
519: /**
520: * show DSP specific profile statistics.
521: */
522: void Profile_DspShowStats(void)
523: {
524: profile_area_t *area = &dsp_profile.ram;
525: fprintf(stderr, "DSP profile statistics (0x0-0xFFFF):\n");
526: if (!area->active) {
527: fprintf(stderr, "- no activity\n");
528: return;
529: }
530: fprintf(stderr, "- active address range:\n 0x%04x-0x%04x\n",
531: area->lowest, area->highest);
532: fprintf(stderr, "- active instruction addresses:\n %d\n",
533: area->active);
534: fprintf(stderr, "- executed instructions:\n %llu\n",
535: area->all_count);
536: fprintf(stderr, "- used cycles:\n %llu\n",
537: area->all_cycles);
538: fprintf(stderr, "- address with most cycles:\n 0x%04x, %d cycles (%.2f%% of all)\n",
539: area->max_cycles_addr,
540: area->max_cycles,
541: (float)area->max_cycles/area->all_cycles*100);
542: fprintf(stderr, "- address with most hits:\n 0x%04x, %d hits (%.2f%% of all)\n",
543: area->max_count_addr,
544: area->max_count,
545: (float)area->max_count/area->all_count*100);
546: if (area->max_cycles == MAX_PROFILE_VALUE) {
547: fprintf(stderr, "- Counters OVERFLOW!\n");
548: }
549: }
550:
551:
552: /**
553: * compare function for qsort() to sort DSP profile data by descdending
554: * address cycles counts.
555: */
556: static int profile_by_dsp_cycles(const void *p1, const void *p2)
557: {
558: Uint32 count1 = dsp_profile.data[*(const Uint16*)p1].cycles;
559: Uint32 count2 = dsp_profile.data[*(const Uint16*)p2].cycles;
560: if (count1 > count2) {
561: return -1;
562: }
563: if (count1 < count2) {
564: return 1;
565: }
566: return 0;
567: }
568:
569: /**
570: * Sort DSP profile data addresses by cycle counts and show the results.
571: */
572: void Profile_DspShowCycles(unsigned int show)
573: {
574: unsigned int active;
575: Uint16 *sort_arr, *end, addr;
576: profile_item_t *data = dsp_profile.data;
577: float percentage;
578: Uint32 count;
579:
580: if (!data) {
581: fprintf(stderr, "ERROR: no DSP profiling data available!\n");
582: return;
583: }
584:
585: active = dsp_profile.ram.active;
586: sort_arr = dsp_profile.sort_arr;
587: qsort(sort_arr, active, sizeof(*sort_arr), profile_by_dsp_cycles);
588:
589: printf("addr:\tcycles:\n");
590: show = (show < active ? show : active);
591: for (end = sort_arr + show; sort_arr < end; sort_arr++) {
592: addr = *sort_arr;
593: count = data[addr].cycles;
594: percentage = 100.0*count/dsp_profile.ram.all_cycles;
595: printf("0x%04x\t%.2f%%\t%d%s\n", addr, percentage, count,
596: count == MAX_PROFILE_VALUE ? " (OVERFLOW)" : "");
597: }
598: printf("%d DSP addresses listed.\n", show);
599: }
600:
601:
602: /**
603: * compare function for qsort() to sort DSP profile data by descdending
604: * address access counts.
605: */
606: static int profile_by_dsp_count(const void *p1, const void *p2)
607: {
608: Uint32 count1 = dsp_profile.data[*(const Uint16*)p1].count;
609: Uint32 count2 = dsp_profile.data[*(const Uint16*)p2].count;
610: if (count1 > count2) {
611: return -1;
612: }
613: if (count1 < count2) {
614: return 1;
615: }
616: return 0;
617: }
618:
619: /**
620: * Sort DSP profile data addresses by call counts and show the results.
621: * If symbols are requested and symbols are loaded, show (only) addresses
622: * matching a symbol.
623: */
624: void Profile_DspShowCounts(unsigned int show, bool only_symbols)
625: {
626: profile_item_t *data = dsp_profile.data;
627: unsigned int symbols, matched, active;
628: Uint16 *sort_arr, *end, addr;
629: const char *name;
630: float percentage;
631: Uint32 count;
632:
633: if (!data) {
634: fprintf(stderr, "ERROR: no DSP profiling data available!\n");
635: return;
636: }
637: active = dsp_profile.ram.active;
638: show = (show < active ? show : active);
639:
640: sort_arr = dsp_profile.sort_arr;
641: qsort(sort_arr, active, sizeof(*sort_arr), profile_by_dsp_count);
642:
643: if (!only_symbols) {
644: printf("addr:\tcount:\n");
645: for (end = sort_arr + show; sort_arr < end; sort_arr++) {
646: addr = *sort_arr;
647: count = data[addr].count;
648: percentage = 100.0*count/dsp_profile.ram.all_count;
649: printf("0x%04x\t%.2f%%\t%d%s\n",
650: addr, percentage, count,
651: count == MAX_PROFILE_VALUE ? " (OVERFLOW)" : "");
652: }
653: printf("%d DSP addresses listed.\n", show);
654: return;
655: }
656:
657: symbols = Symbols_DspCount();
658: if (!symbols) {
659: fprintf(stderr, "ERROR: no DSP symbols loaded!\n");
660: return;
661: }
662: matched = 0;
663:
664: printf("addr:\tcount:\t\tsymbol:\n");
665: for (end = sort_arr + active; sort_arr < end; sort_arr++) {
666:
667: addr = *sort_arr;
668: name = Symbols_GetByDspAddress(addr);
669: if (!name) {
670: continue;
671: }
672: count = data[addr].count;
673: percentage = 100.0*count/dsp_profile.ram.all_count;
674: printf("0x%04x\t%.2f%%\t%d\t%s%s\n",
675: addr, percentage, count, name,
676: count == MAX_PROFILE_VALUE ? " (OVERFLOW)" : "");
677:
678: matched++;
679: if (matched >= show || matched >= symbols) {
680: break;
681: }
682: }
683: printf("%d DSP symbols listed.\n", matched);
684: }
685:
686:
687: /* ------------------ DSP profile control ----------------- */
688:
689: /**
690: * Initialize DSP profiling when necessary. Return true if profiling.
691: */
692: bool Profile_DspStart(void)
693: {
694: if (dsp_profile.sort_arr) {
695: /* remove previous results */
696: free(dsp_profile.sort_arr);
697: free(dsp_profile.data);
698: dsp_profile.sort_arr = NULL;
699: dsp_profile.data = NULL;
700: printf("Freed previous DSP profile buffers.\n");
701: }
702: if (!dsp_profile.enabled) {
703: return false;
704: }
705:
706: dsp_profile.data = calloc(DSP_PROFILE_ARR_SIZE, sizeof(*dsp_profile.data));
707: if (dsp_profile.data) {
708: printf("Allocated DSP profile buffer (%d KB).\n",
709: (int)sizeof(*dsp_profile.data)*DSP_PROFILE_ARR_SIZE/1024);
710: } else {
711: perror("ERROR, new DSP profile buffer alloc failed");
712: dsp_profile.enabled = false;
713: }
714: return dsp_profile.enabled;
715: }
716:
717: /**
718: * Update DSP cycle and count statistics for PC address.
719: */
720: void Profile_DspUpdate(void)
721: {
722: Uint16 pc, cycles;
723:
724: pc = DSP_GetPC();
725: if (likely(dsp_profile.data[pc].count < MAX_PROFILE_VALUE)) {
726: dsp_profile.data[pc].count++;
727: }
728:
729: cycles = DSP_GetInstrCycles();
730: if (likely(dsp_profile.data[pc].cycles < MAX_PROFILE_VALUE - cycles)) {
731: dsp_profile.data[pc].cycles += cycles;
732: }
733: }
734:
735:
736: /**
737: * Stop and process the DSP profiling data; collect stats and
738: * prepare for more optimal sorting.
739: */
740: void Profile_DspStop(void)
741: {
742: profile_item_t *item;
743: profile_area_t *area;
744: Uint16 *sort_arr;
745: Uint32 i;
746:
747: if (!dsp_profile.enabled) {
748: return;
749: }
750: /* find lowest and highest addresses executed */
751: item = dsp_profile.data;
752: area = &dsp_profile.ram;
753: memset(area, 0, sizeof(profile_area_t));
754: area->lowest = DSP_PROFILE_ARR_SIZE;
755:
756: for (i = 0; i < DSP_PROFILE_ARR_SIZE; i++, item++) {
757: update_area(i, item, area);
758: }
759:
760: /* allocate address array for sorting */
761: sort_arr = calloc(dsp_profile.ram.active, sizeof(*sort_arr));
762:
763: if (!sort_arr) {
764: perror("ERROR: allocating DSP profile address data");
765: free(dsp_profile.data);
766: dsp_profile.data = NULL;
767: return;
768: }
769: printf("Allocated DSP profile address buffer (%d KB).\n",
770: (int)sizeof(*sort_arr)*(dsp_profile.ram.active+512)/1024);
771: dsp_profile.sort_arr = sort_arr;
772:
773: /* ...and fill addresses for used instructions... */
774: area = &dsp_profile.ram;
775: item = dsp_profile.data + area->lowest;
776: for (i = area->lowest; i <= area->highest; i++, item++) {
777: if (item->count) {
778: *sort_arr++ = i;
779: }
780: }
781: //printf("%d/%d/%d\n", area->active, sort_arr-dsp_profile.sort_arr, active);
782:
783: Profile_DspShowStats();
784: return;
785: }
786:
787:
788: /* ------------------- command parsing ---------------------- */
789:
790: /**
791: * Readline match callback to list profile subcommand names.
792: * STATE = 0 -> different text from previous one.
793: * Return next match or NULL if no matches.
794: */
795: char *Profile_Match(const char *text, int state)
796: {
797: static const char *names[] = {
798: "on", "off", "counts", "cycles", "symbols", "stats"
799: };
800: static int i, len;
801:
802: if (!state)
803: {
804: /* first match */
805: i = 0;
806: len = strlen(text);
807: }
808: /* next match */
809: while (i < ARRAYSIZE(names)) {
810: if (strncasecmp(names[i++], text, len) == 0)
811: return (strdup(names[i-1]));
812: }
813: return NULL;
814: }
815:
816: const char Profile_Description[] =
817: "<on|off|counts|cycles|symbols|stats> [show count]\n"
818: "\ton & off enable and disable profiling. Data is collected\n"
819: "\tuntil debugger is entered again after which you can view\n"
820: "\tstatistics about the data or view PC addresses that took\n"
821: "\tmost cycles or functions/symbols called most often.\n"
822: "\tYou can specify how many items are shown at most.";
823:
824:
825: /**
826: * Command: CPU/DSP profiling enabling, exec stats, cycle and call stats.
827: * Return for succesful command and false for incorrect ones.
828: */
829: bool Profile_Command(int nArgc, char *psArgs[], bool bForDsp)
830: {
831: static int show = 16;
832: bool *enabled;
833:
834: if (nArgc < 2) {
835: DebugUI_PrintCmdHelp(psArgs[0]);
836: return true;
837: }
838: if (nArgc > 2) {
839: show = atoi(psArgs[2]);
840: }
841:
842: if (bForDsp) {
843: enabled = &dsp_profile.enabled;
844: } else {
845: enabled = &cpu_profile.enabled;
846: }
847: if (strcmp(psArgs[1], "on") == 0) {
848: *enabled = true;
849: fprintf(stderr, "Profiling enabled.\n");
850: return true;
851: }
852: if (strcmp(psArgs[1], "off") == 0) {
853: *enabled = false;
854: fprintf(stderr, "Profiling disabled.\n");
855: return true;
856: }
857:
858: if (strcmp(psArgs[1], "stats") == 0) {
859: if (bForDsp) {
860: Profile_DspShowStats();
861: } else {
862: Profile_CpuShowStats();
863: }
864: } else if (strcmp(psArgs[1], "cycles") == 0) {
865: if (bForDsp) {
866: Profile_DspShowCycles(show);
867: } else {
868: Profile_CpuShowCycles(show);
869: }
870: } else if (strcmp(psArgs[1], "counts") == 0) {
871: if (bForDsp) {
872: Profile_DspShowCounts(show, false);
873: } else {
874: Profile_CpuShowCounts(show, false);
875: }
876: } else if (strcmp(psArgs[1], "symbols") == 0) {
877: if (bForDsp) {
878: Profile_DspShowCounts(show, true);
879: } else {
880: Profile_CpuShowCounts(show, true);
881: }
882: } else {
883: DebugUI_PrintCmdHelp(psArgs[0]);
884: return false;
885: }
886: return true;
887: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.