![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to profiledsp.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 profiledsp.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / debug |
1.1 root 1: /*
2: * Hatari - profiledsp.c
3: *
4: * Copyright (C) 2010-2013 by Eero Tamminen
5: *
6: * This file is distributed under the GNU General Public License, version 2
7: * or at your option any later version. Read the file gpl.txt for details.
8: *
9: * profiledsp.c - functions for profiling DSP and showing the results.
10: */
11: const char Profiledsp_fileid[] = "Hatari profiledsp.c : " __DATE__ " " __TIME__;
12:
13: #include <stdio.h>
14: #include <inttypes.h>
15: #include <assert.h>
16: #include "main.h"
17: #include "configuration.h"
18: #include "clocks_timings.h"
19: #include "dsp.h"
20: #include "profile.h"
21: #include "profile_priv.h"
22: #include "symbols.h"
23:
24: static callinfo_t dsp_callinfo;
25:
26: #define DSP_PROFILE_ARR_SIZE 0x10000
27: #define MAX_DSP_PROFILE_VALUE 0xFFFFFFFFFFFFFFFFLL
28:
29: typedef struct {
30: Uint64 count; /* how many times this address is used */
31: Uint64 cycles; /* how many DSP cycles was taken at this address */
32: Uint16 min_cycle;
33: Uint16 max_cycle;
34: } dsp_profile_item_t;
35:
36: static struct {
37: dsp_profile_item_t *data; /* profile data */
38: profile_area_t ram; /* statistics for whole memory */
39: Uint16 *sort_arr; /* data indexes used for sorting */
40: Uint16 prev_pc; /* previous PC for which the cycles are for */
41: Uint32 disasm_addr; /* 'dspaddresses' command start address */
42: bool processed; /* true when data is already processed */
43: bool enabled; /* true when profiling enabled */
44: } dsp_profile;
45:
46:
47: /* ------------------ DSP profile results ----------------- */
48:
49: /**
50: * Get DSP cycles, count and count percentage for given address.
51: * Return true if data was available and non-zero, false otherwise.
52: */
53: bool Profile_DspAddressData(Uint16 addr, float *percentage, Uint64 *count, Uint64 *cycles, Uint16 *cycle_diff)
54: {
55: dsp_profile_item_t *item;
56: if (!dsp_profile.data) {
57: return false;
58: }
59: item = dsp_profile.data + addr;
60:
61: *cycles = item->cycles;
62: *count = item->count;
63: if (item->max_cycle) {
64: *cycle_diff = item->max_cycle - item->min_cycle;
65: } else {
66: *cycle_diff = 0;
67: }
68: if (dsp_profile.ram.counters.count) {
69: *percentage = 100.0*(*count)/dsp_profile.ram.counters.count;
70: } else {
71: *percentage = 0.0;
72: }
73: return (*count > 0);
74: }
75:
76: /**
77: * show DSP specific profile statistics.
78: */
79: void Profile_DspShowStats(void)
80: {
81: profile_area_t *area = &dsp_profile.ram;
82: fprintf(stderr, "DSP profile statistics (0x0-0xFFFF):\n");
83: if (!area->active) {
84: fprintf(stderr, "- no activity\n");
85: return;
86: }
87: fprintf(stderr, "- active address range:\n 0x%04x-0x%04x\n",
88: area->lowest, area->highest);
89: fprintf(stderr, "- active instruction addresses:\n %d\n",
90: area->active);
91: fprintf(stderr, "- executed instructions:\n %"PRIu64"\n",
92: area->counters.count);
93: /* indicates either instruction(s) that address different memory areas
94: * (they can have different access costs), or more significantly,
95: * DSP code that has changed during profiling.
96: */
97: fprintf(stderr, "- sum of per instruction cycle changes\n"
98: " (can indicate code change during profiling):\n %"PRIu64"\n",
99: area->counters.misses);
100:
101: fprintf(stderr, "- used cycles:\n %"PRIu64"\n",
102: area->counters.cycles);
103: if (area->overflow) {
104: fprintf(stderr, " *** COUNTERS OVERFLOW! ***\n");
105: }
106: fprintf(stderr, "\n= %.5fs\n", (double)(area->counters.cycles) / MachineClocks.DSP_Freq);
107: }
108:
109: /**
110: * Show DSP instructions which execution was profiled, in the address order,
111: * starting from the given address. Return next disassembly address.
112: */
113: Uint16 Profile_DspShowAddresses(Uint32 addr, Uint32 upper, FILE *out)
114: {
115: int show, shown, active;
116: dsp_profile_item_t *data;
117: Uint16 nextpc;
118: Uint32 end;
119: const char *symbol;
120:
121: data = dsp_profile.data;
122: if (!data) {
123: fprintf(stderr, "ERROR: no DSP profiling data available!\n");
124: return 0;
125: }
126:
127: end = DSP_PROFILE_ARR_SIZE;
128: active = dsp_profile.ram.active;
129: show = ConfigureParams.Debugger.nDisasmLines;
130: if (upper) {
131: if (upper < end) {
132: end = upper;
133: }
134: show = active;
135: } else {
136: show = ConfigureParams.Debugger.nDisasmLines;
137: if (!show || show > active) {
138: show = active;
139: }
140: }
141:
142: fputs("# disassembly with profile data: <instructions percentage>% (<sum of instructions>, <sum of cycles>, <max cycle difference>)\n", out);
143:
144: nextpc = 0;
145: for (shown = 0; shown < show && addr < end; addr++) {
146: if (!data[addr].count) {
147: continue;
148: }
149: if (addr != nextpc && nextpc) {
150: fputs("[...]\n", out);
151: }
152: symbol = Symbols_GetByDspAddress(addr);
153: if (symbol) {
154: fprintf(out, "%s:\n", symbol);
155: }
156: nextpc = DSP_DisasmAddress(out, addr, addr);
157: shown++;
158: }
159: printf("Disassembled %d (of active %d) DSP addresses.\n", shown, active);
160: return nextpc;
161: }
162:
163: /**
164: * compare function for qsort() to sort DSP profile data by descdending
165: * address cycles counts.
166: */
167: static int cmp_dsp_cycles(const void *p1, const void *p2)
168: {
169: Uint64 count1 = dsp_profile.data[*(const Uint16*)p1].cycles;
170: Uint64 count2 = dsp_profile.data[*(const Uint16*)p2].cycles;
171: if (count1 > count2) {
172: return -1;
173: }
174: if (count1 < count2) {
175: return 1;
176: }
177: return 0;
178: }
179:
180: /**
181: * Sort DSP profile data addresses by cycle counts and show the results.
182: */
183: void Profile_DspShowCycles(int show)
184: {
185: int active;
186: Uint16 *sort_arr, *end, addr;
187: dsp_profile_item_t *data = dsp_profile.data;
188: float percentage;
189: Uint64 count;
190:
191: if (!data) {
192: fprintf(stderr, "ERROR: no DSP profiling data available!\n");
193: return;
194: }
195:
196: active = dsp_profile.ram.active;
197: sort_arr = dsp_profile.sort_arr;
198: qsort(sort_arr, active, sizeof(*sort_arr), cmp_dsp_cycles);
199:
200: printf("addr:\tcycles:\n");
201: show = (show < active ? show : active);
202: for (end = sort_arr + show; sort_arr < end; sort_arr++) {
203: addr = *sort_arr;
204: count = data[addr].cycles;
205: percentage = 100.0*count/dsp_profile.ram.counters.cycles;
206: printf("0x%04x\t%5.2f%%\t%"PRIu64"%s\n", addr, percentage, count,
207: count == MAX_DSP_PROFILE_VALUE ? " (OVERFLOW)" : "");
208: }
209: printf("%d DSP addresses listed.\n", show);
210: }
211:
212:
213: /**
214: * compare function for qsort() to sort DSP profile data by descdending
215: * address access counts.
216: */
217: static int cmp_dsp_count(const void *p1, const void *p2)
218: {
219: Uint64 count1 = dsp_profile.data[*(const Uint16*)p1].count;
220: Uint64 count2 = dsp_profile.data[*(const Uint16*)p2].count;
221: if (count1 > count2) {
222: return -1;
223: }
224: if (count1 < count2) {
225: return 1;
226: }
227: return 0;
228: }
229:
230: /**
231: * Sort DSP profile data addresses by call counts and show the results.
232: * If symbols are requested and symbols are loaded, show (only) addresses
233: * matching a symbol.
234: */
235: void Profile_DspShowCounts(int show, bool only_symbols)
236: {
237: dsp_profile_item_t *data = dsp_profile.data;
238: int symbols, matched, active;
239: Uint16 *sort_arr, *end, addr;
240: const char *name;
241: float percentage;
242: Uint64 count;
243:
244: if (!data) {
245: fprintf(stderr, "ERROR: no DSP profiling data available!\n");
246: return;
247: }
248: active = dsp_profile.ram.active;
249: show = (show < active ? show : active);
250:
251: sort_arr = dsp_profile.sort_arr;
252: qsort(sort_arr, active, sizeof(*sort_arr), cmp_dsp_count);
253:
254: if (!only_symbols) {
255: printf("addr:\tcount:\n");
256: for (end = sort_arr + show; sort_arr < end; sort_arr++) {
257: addr = *sort_arr;
258: count = data[addr].count;
259: percentage = 100.0*count/dsp_profile.ram.counters.count;
260: printf("0x%04x\t%5.2f%%\t%"PRIu64"%s\n",
261: addr, percentage, count,
262: count == MAX_DSP_PROFILE_VALUE ? " (OVERFLOW)" : "");
263: }
264: printf("%d DSP addresses listed.\n", show);
265: return;
266: }
267:
268: symbols = Symbols_DspCount();
269: if (!symbols) {
270: fprintf(stderr, "ERROR: no DSP symbols loaded!\n");
271: return;
272: }
273: matched = 0;
274:
275: printf("addr:\tcount:\t\tsymbol:\n");
276: for (end = sort_arr + active; sort_arr < end; sort_arr++) {
277:
278: addr = *sort_arr;
279: name = Symbols_GetByDspAddress(addr);
280: if (!name) {
281: continue;
282: }
283: count = data[addr].count;
284: percentage = 100.0*count/dsp_profile.ram.counters.count;
285: printf("0x%04x\t%.2f%%\t%"PRIu64"\t%s%s\n",
286: addr, percentage, count, name,
287: count == MAX_DSP_PROFILE_VALUE ? " (OVERFLOW)" : "");
288:
289: matched++;
290: if (matched >= show || matched >= symbols) {
291: break;
292: }
293: }
294: printf("%d DSP symbols listed.\n", matched);
295: }
296:
297:
298: static const char * addr2name(Uint32 addr, Uint64 *total)
299: {
300: *total = dsp_profile.data[addr].count;
301: return Symbols_GetByDspAddress(addr);
302: }
303:
304: /**
305: * Output DSP callers info to given file.
306: */
307: void Profile_DspShowCallers(FILE *fp)
308: {
309: Profile_ShowCallers(fp, dsp_callinfo.sites, dsp_callinfo.site, addr2name);
310: }
311:
312: /**
313: * Save DSP profile information to given file.
314: */
315: void Profile_DspSave(FILE *out)
316: {
317: /* Comma separated descriptions for the profile disassembly data fields.
318: * Instructions and cycles need to be first two fields!
319: */
320: fputs("Field names:\tExecuted instructions, Used cycles, Largest cycle differences (= code changes during profiling)\n", out);
321: /* (Python) pegexp that matches address and all describled fields from disassembly:
322: * <space>:<address> <opcodes> (<instr cycles>) <instr> <count>% (<count>, <cycles>)
323: * p:0202 0aa980 000200 (07 cyc) jclr #0,x:$ffe9,p:$0200 0.00% (6, 42)
324: */
325: fputs("Field regexp:\t^p:([0-9a-f]+) .*% \\((.*)\\)$\n", out);
326: Profile_DspShowAddresses(0, DSP_PROFILE_ARR_SIZE, out);
327: Profile_DspShowCallers(out);
328: }
329:
330: /* ------------------ DSP profile control ----------------- */
331:
332: /**
333: * Initialize DSP profiling when necessary. Return true if profiling.
334: */
335: bool Profile_DspStart(void)
336: {
337: dsp_profile_item_t *item;
338: int i;
339:
340: Profile_FreeCallinfo(&(dsp_callinfo));
341: if (dsp_profile.sort_arr) {
342: /* remove previous results */
343: free(dsp_profile.sort_arr);
344: free(dsp_profile.data);
345: dsp_profile.sort_arr = NULL;
346: dsp_profile.data = NULL;
347: printf("Freed previous DSP profile buffers.\n");
348: }
349: if (!dsp_profile.enabled) {
350: return false;
351: }
352: /* zero everything */
353: memset(&dsp_profile, 0, sizeof(dsp_profile));
354:
355: dsp_profile.data = calloc(DSP_PROFILE_ARR_SIZE, sizeof(*dsp_profile.data));
356: if (!dsp_profile.data) {
357: perror("ERROR, new DSP profile buffer alloc failed");
358: return false;
359: }
360: printf("Allocated DSP profile buffer (%d KB).\n",
361: (int)sizeof(*dsp_profile.data)*DSP_PROFILE_ARR_SIZE/1024);
362:
363: Profile_AllocCallinfo(&(dsp_callinfo), Symbols_DspCount(), "DSP");
364:
365: item = dsp_profile.data;
366: for (i = 0; i < DSP_PROFILE_ARR_SIZE; i++, item++) {
367: item->min_cycle = 0xFFFF;
368: }
369: dsp_profile.prev_pc = DSP_GetPC();
370:
371: dsp_profile.disasm_addr = 0;
372: dsp_profile.processed = false;
373: dsp_profile.enabled = true;
374: return dsp_profile.enabled;
375: }
376:
377: /* return true if pc is next instruction for previous pc */
378: static bool is_prev_instr(Uint16 prev_pc, Uint16 pc)
379: {
380: /* just moved to next instruction (1-2 words)? */
381: if (prev_pc < pc && (pc - prev_pc) <= 4) {
382: return true;
383: }
384: return false;
385: }
386:
387: /* return branch type based on caller instruction type */
388: static calltype_t dsp_opcode_type(Uint16 prev_pc, Uint16 pc)
389: {
390: const char *dummy;
391: Uint32 opcode;
392:
393: /* 24-bit instruction opcode */
394: opcode = DSP_ReadMemory(prev_pc, 'P', &dummy) & 0xFFFFFF;
395:
396: /* subroutine returns */
397: if (opcode == 0xC) { /* (just) RTS */
398: return CALL_SUBRETURN;
399: }
400: /* unconditional subroutine calls */
401: if ((opcode & 0xFFF000) == 0xD0000 || /* JSR 00001101 0000aaaa aaaaaaaa */
402: (opcode & 0xFFC0FF) == 0xBC080) { /* JSR 00001011 11MMMRRR 10000000 */
403: return CALL_SUBROUTINE;
404: }
405: /* conditional subroutine calls */
406: if ((opcode & 0xFF0000) == 0xF0000 || /* JSCC 00001111 CCCCaaaa aaaaaaaa */
407: (opcode & 0xFFC0F0) == 0xBC0A0 || /* JSCC 00001011 11MMMRRR 1010CCCC */
408: (opcode & 0xFFC0A0) == 0xB4080 || /* JSCLR 00001011 01MMMRRR 1S0bbbbb */
409: (opcode & 0xFFC0A0) == 0xB0080 || /* JSCLR 00001011 00aaaaaa 1S0bbbbb */
410: (opcode & 0xFFC0A0) == 0xB8080 || /* JSCLR 00001011 10pppppp 1S0bbbbb */
411: (opcode & 0xFFC0E0) == 0xBC000 || /* JSCLR 00001011 11DDDDDD 000bbbbb */
412: (opcode & 0xFFC0A0) == 0xB40A0 || /* JSSET 00001011 01MMMRRR 1S1bbbbb */
413: (opcode & 0xFFC0A0) == 0xB00A0 || /* JSSET 00001011 00aaaaaa 1S1bbbbb */
414: (opcode & 0xFFC0A0) == 0xB80A0 || /* JSSET 00001011 10pppppp 1S1bbbbb */
415: (opcode & 0xFFC0E0) == 0xBC020) { /* JSSET 00001011 11DDDDDD 001bbbbb */
416: /* hopefully fairly safe heuristic:
417: * if previously executed instruction
418: * was one before current one, no
419: * subroutine call was made to next
420: * instruction, the condition just
421: * wasn't met.
422: */
423: if (is_prev_instr(prev_pc, pc)) {
424: return CALL_NEXT;
425: }
426: return CALL_SUBROUTINE;
427: }
428: /* exception handler returns */
429: if (opcode == 0x4) { /* (just) RTI */
430: return CALL_EXCRETURN;
431: }
432:
433: /* Besides CALL_UNKNOWN, rest isn't used by subroutine call
434: * cost collection. However, it's useful info when debugging
435: * code or reading full callgraphs (because optimized code uses
436: * also jumps/branches for subroutine calls).
437: */
438:
439: /* TODO: exception invocation.
440: * Could be detected by PC going through low interrupt vector adresses,
441: * but fast-calls using JSR/RTS would need separate handling.
442: */
443: if (0) { /* TODO */
444: return CALL_EXCEPTION;
445: }
446: /* branches */
447: if ((opcode & 0xFFF000) == 0xC0000 || /* JMP 00001100 0000aaaa aaaaaaaa */
448: (opcode & 0xFFC0FF) == 0xAC080 || /* JMP 00001010 11MMMRRR 10000000 */
449: (opcode & 0xFF0000) == 0xE0000 || /* JCC 00001110 CCCCaaaa aaaaaaaa */
450: (opcode & 0xFFC0F0) == 0xAC0A0 || /* JCC 00001010 11MMMRRR 1010CCCC */
451: (opcode & 0xFFC0A0) == 0xA8080 || /* JCLR 00001010 10pppppp 1S0bbbbb */
452: (opcode & 0xFFC0A0) == 0xA4080 || /* JCLR 00001010 01MMMRRR 1S0bbbbb */
453: (opcode & 0xFFC0A0) == 0xA0080 || /* JCLR 00001010 00aaaaaa 1S0bbbbb */
454: (opcode & 0xFFC0E0) == 0xAC000 || /* JCLR 00001010 11dddddd 000bbbbb */
455: (opcode & 0xFFC0A0) == 0xA80A0 || /* JSET 00001010 10pppppp 1S1bbbbb */
456: (opcode & 0xFFC0A0) == 0xA40A0 || /* JSET 00001010 01MMMRRR 1S1bbbbb */
457: (opcode & 0xFFC0A0) == 0xA00A0 || /* JSET 00001010 00aaaaaa 1S1bbbbb */
458: (opcode & 0xFFC0E0) == 0xAC020 || /* JSET 00001010 11dddddd 001bbbbb */
459: (opcode & 0xFF00F0) == 0x600A0 || /* REP 00000110 iiiiiiii 1010hhhh */
460: (opcode & 0xFFC0FF) == 0x6C020 || /* REP 00000110 11dddddd 00100000 */
461: (opcode & 0xFFC0BF) == 0x64020 || /* REP 00000110 01MMMRRR 0s100000 */
462: (opcode & 0xFFC0BF) == 0x60020 || /* REP 00000110 00aaaaaa 0s100000 */
463: (opcode & 0xFF00F0) == 0x60080 || /* DO/ENDO 00000110 iiiiiiii 1000hhhh */
464: (opcode & 0xFFC0FF) == 0x6C000 || /* DO/ENDO 00000110 11DDDDDD 00000000 */
465: (opcode & 0xFFC0BF) == 0x64000 || /* DO/ENDO 00000110 01MMMRRR 0S000000 */
466: (opcode & 0xFFC0BF) == 0x60000) { /* DO/ENDO 00000110 00aaaaaa 0S000000 */
467: return CALL_BRANCH;
468: }
469: if (is_prev_instr(prev_pc, pc)) {
470: return CALL_NEXT;
471: }
472: return CALL_UNKNOWN;
473: }
474:
475: /**
476: * If call tracking is enabled (there are symbols), collect
477: * information about subroutine and other calls, and their costs.
478: *
479: * Like with profile data, caller info checks need to be for previous
480: * instruction, that's why "pc" argument for this function actually
481: * needs to be previous PC.
482: */
483: static void collect_calls(Uint16 pc, counters_t *counters)
484: {
485: calltype_t flag;
486: Uint16 prev_pc;
487: Uint32 caller_pc;
488: int idx;
489:
490: prev_pc = dsp_callinfo.prev_pc;
491: dsp_callinfo.prev_pc = pc;
492: caller_pc = PC_UNDEFINED;
493:
494: /* address is return address for last subroutine call? */
495: if (unlikely(pc == dsp_callinfo.return_pc) && likely(dsp_callinfo.depth)) {
496:
497: flag = dsp_opcode_type(prev_pc, pc);
498: /* return address is entered either by subroutine return,
499: * or by returning from exception that interrupted
500: * the instruction at return address.
501: */
502: if (likely(flag == CALL_SUBRETURN || flag == CALL_EXCRETURN)) {
503: caller_pc = Profile_CallEnd(&dsp_callinfo, counters);
504: }
505: }
506:
507: /* address is one which we're tracking? */
508: idx = Symbols_GetDspAddressIndex(pc);
509: if (unlikely(idx >= 0)) {
510:
511: flag = dsp_opcode_type(prev_pc, pc);
512: if (flag == CALL_SUBROUTINE) {
513: dsp_callinfo.return_pc = DSP_GetNextPC(prev_pc); /* slow! */
514: } else if (caller_pc != PC_UNDEFINED) {
515: /* returned from function, change return
516: * instruction address to address of
517: * what did the returned call.
518: */
519: prev_pc = caller_pc;
520: assert(is_prev_instr(prev_pc, pc));
521: flag = CALL_NEXT;
522: }
523: Profile_CallStart(idx, &dsp_callinfo, prev_pc, flag, pc, counters);
524:
525: }
526: }
527:
528: /**
529: * Update DSP cycle and count statistics for PC address.
530: *
531: * This is called after instruction is executed and PC points
532: * to next instruction i.e. info is for previous PC address.
533: */
534: void Profile_DspUpdate(void)
535: {
536: dsp_profile_item_t *prev;
537: Uint16 pc, prev_pc, cycles;
538: counters_t *counters;
539:
540: prev_pc = dsp_profile.prev_pc;
541: dsp_profile.prev_pc = pc = DSP_GetPC();
542: prev = dsp_profile.data + prev_pc;
543:
544: if (likely(prev->count < MAX_DSP_PROFILE_VALUE)) {
545: prev->count++;
546: }
547:
548: cycles = DSP_GetInstrCycles();
549: if (likely(prev->cycles < MAX_DSP_PROFILE_VALUE - cycles)) {
550: prev->cycles += cycles;
551: } else {
552: prev->cycles = MAX_DSP_PROFILE_VALUE;
553: }
554:
555: if (unlikely(cycles < prev->min_cycle)) {
556: prev->min_cycle = cycles;
557: }
558: if (unlikely(cycles > prev->max_cycle)) {
559: prev->max_cycle = cycles;
560: }
561:
562: counters = &(dsp_profile.ram.counters);
563: if (dsp_callinfo.sites) {
564: collect_calls(prev_pc, counters);
565: }
566: /* counters are increased after caller info is processed,
567: * otherwise cost for the instruction calling the callee
568: * doesn't get accounted to caller (but callee).
569: */
570: counters->cycles += cycles;
571: counters->count++;
572: }
573:
574: /**
575: * Helper for collecting DSP profile area statistics.
576: */
577: static void update_area_item(profile_area_t *area, Uint16 addr, dsp_profile_item_t *item)
578: {
579: Uint64 cycles = item->cycles;
580: Uint64 count = item->count;
581: Uint16 diff;
582:
583: if (!count) {
584: return;
585: }
586: if (cycles == MAX_DSP_PROFILE_VALUE) {
587: area->overflow = true;
588: }
589: if (item->max_cycle) {
590: diff = item->max_cycle - item->min_cycle;
591: } else {
592: diff = 0;
593: }
594:
595: area->counters.count += count;
596: area->counters.cycles += cycles;
597: area->counters.misses += diff;
598:
599: if (addr < area->lowest) {
600: area->lowest = addr;
601: }
602: area->highest = addr;
603:
604: area->active++;
605: }
606:
607: /**
608: * Stop and process the DSP profiling data; collect stats and
609: * prepare for more optimal sorting.
610: */
611: void Profile_DspStop(void)
612: {
613: dsp_profile_item_t *item;
614: profile_area_t *area;
615: Uint16 *sort_arr;
616: Uint32 addr;
617:
618: if (dsp_profile.processed || !dsp_profile.enabled) {
619: return;
620: }
621:
622: Profile_FinalizeCalls(&(dsp_callinfo), &(dsp_profile.ram.counters), Symbols_GetByDspAddress);
623:
624: /* find lowest and highest addresses executed */
625: area = &dsp_profile.ram;
626: memset(area, 0, sizeof(profile_area_t));
627: area->lowest = DSP_PROFILE_ARR_SIZE;
628:
629: item = dsp_profile.data;
630: for (addr = 0; addr < DSP_PROFILE_ARR_SIZE; addr++, item++) {
631: update_area_item(area, addr, item);
632: }
633:
634: /* allocate address array for sorting */
635: sort_arr = calloc(dsp_profile.ram.active, sizeof(*sort_arr));
636:
637: if (!sort_arr) {
638: perror("ERROR: allocating DSP profile address data");
639: free(dsp_profile.data);
640: dsp_profile.data = NULL;
641: return;
642: }
643: printf("Allocated DSP profile address buffer (%d KB).\n",
644: (int)sizeof(*sort_arr)*(dsp_profile.ram.active+512)/1024);
645: dsp_profile.sort_arr = sort_arr;
646:
647: /* ...and fill addresses for used instructions... */
648: area = &dsp_profile.ram;
649: item = &(dsp_profile.data[area->lowest]);
650: for (addr = area->lowest; addr <= area->highest; addr++, item++) {
651: if (item->count) {
652: *sort_arr++ = addr;
653: }
654: }
655: //printf("%d/%d/%d\n", area->active, sort_arr-dsp_profile.sort_arr, active);
656:
657: Profile_DspShowStats();
658: dsp_profile.processed = true;
659: }
660:
661: /**
662: * Get pointers to DSP profile enabling and disasm address variables
663: * for updating them (in parser).
664: */
665: void Profile_DspGetPointers(bool **enabled, Uint32 **disasm_addr)
666: {
667: *disasm_addr = &dsp_profile.disasm_addr;
668: *enabled = &dsp_profile.enabled;
669: }
670:
671: /**
672: * Get callinfo & symbol search pointers for stack walking.
673: */
674: void Profile_DspGetCallinfo(callinfo_t **callinfo, const char* (**get_symbol)(Uint32))
675: {
676: *callinfo = &(dsp_callinfo);
677: *get_symbol = Symbols_GetByDspAddress;
678: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.