uuUndo/QuickProfiler.c
2015-02-06 00:56:41 -08:00

1 line
10 KiB
C

//
// When __PROFILE is called, stack frame looks like this:
//
// sp+08 Caller's return address
// sp+04 Address of function name string
// sp Return address to start of function
//
// After we save registers and such, stack frame looks like this:
//
// sp+28 Caller's return address
// sp+24 Address of function name string
// sp+20 Return address to start of function
// sp+16 saved A0
// sp+12 saved A1
// sp+08 saved D0
// sp+04 saved D1
// sp saved D2
//
// Upon returning from __PROFILE, stack frame should look like this:
//
// sp Address of __PROFILEEND
//
//
#include <Profiler.h>
#include <Threads.h>
#include <Timer.h>
#include <stdio.h>
#include <string.h>
#pragma profile off
#if defined(powerc) || defined(__powerc)
extern void Profile_GetTime(UnsignedWide *time);
#else
#define Profile_GetTime(time) Microseconds(time)
#endif
#define THREAD_OFFSET 100
#define NAME_LENGTH 23
#define MAX_FUNCS 1000
#define MAX_THREADS 50
#define STACK_DEPTH 100
typedef struct {
char name[NAME_LENGTH+1];
int calls;
long address;
UnsignedWide totalTime;
} FunctionInfo;
typedef struct {
FunctionInfo *callerFunction;
long returnAddress;
} StackFrame;
typedef struct {
StackFrame stack[STACK_DEPTH];
StackFrame *stackPtr;
FunctionInfo *currentFunction;
UnsignedWide startTime;
} ThreadInfo;
static ThreadInfo gThread[MAX_THREADS];
static FunctionInfo gFunction[MAX_FUNCS];
static long gProfilerOn = false;
static ThreadInfo *gCurrentThread;
static FunctionInfo *gCallerFunction;
static long gSaveArea[5];
static FunctionInfo *GetIndex(char *functionName:__A0, long address:__D0):__A0;
static void StartTime(FunctionInfo *function:__A0, int call:__D0);
static void StopTime(int index:__D0);
static void GetThreadInfo(void);
static void PushFrame(long returnAddress:__D0);
static long PopFrame(void):__D0;
static asm pascal void __PROFILEEND(void);
#pragma parameter AddToWide(__A0, __A1)
void AddToWide(UnsignedWide *a, UnsignedWide *b) = {
0x2011, // move.l 0(a1),d0 ;d0 = hi
0x2229, 0x0004, // move.l 4(a1),d1 ;d1 = lo
0x2410, // move.l 0(a0),d2 ;d2 = hi
0xD2A8, 0x0004, // add.l 4(a0),d1 ;add lo parts
0xD580, // addx.l d0,d2 ;add hi parts with carry
0x2082, // move.l d2,0(a0) ;store high result
0x2141, 0x0004 // move.l d1,4(a0) ;store low result
};
#pragma parameter SubFromWide(__A1, __A0)
void SubFromWide(UnsignedWide *a, UnsignedWide *b) = {
0x2011, // move.l 0(a1),d0 ;d0 = hi
0x2229, 0x0004, // move.l 4(a1),d1 ;d1 = lo
0x2410, // move.l 0(a0),d2 ;d2 = hi
0x92A8, 0x0004, // sub.l 4(a0),d1 ;add lo parts
0x9580, // subx.l d0,d2 ;add hi parts with carry
0x2082, // move.l d2,0(a0) ;store high result
0x2141, 0x0004 // move.l d1,4(a0) ;store low result
};
pascal OSErr ProfilerInit(ProfilerCollectionMethod method, ProfilerTimeBase timeBase, short numFunctions, short stackDepth)
{
int i;
// initialize the function table
memset(gFunction, 0, sizeof(gFunction));
strcpy(gFunction[0].name, "Root_Function");
gFunction[0].address = -1;
gFunction[0].calls = 1;
// initialize the thread table
memset(gThread, 0, sizeof(gThread));
for (i = 0; i < MAX_THREADS; i++) gThread[i].stackPtr = gThread[i].stack;
Profile_GetTime(&gThread[0].startTime);
gThread[0].currentFunction = gFunction;
// make sure we're turned off
gProfilerOn = false;
return noErr;
}
pascal void ProfilerSetStatus(short on)
{
gProfilerOn = (on) ? true : false;
}
pascal OSErr ProfilerDump(StringPtr filename)
{
/*
static char cfile[256];
FunctionInfo *function;
double temp;
FILE *f;
int i;
BlockMoveData(filename + 1, cfile, *filename);
cfile[*filename] = 0;
f = fopen(cfile, "w");
if (f) {
for (i = 0, function = gFunction; i < MAX_FUNCS; i++, function++)
if (function->address) {
temp = ((double)function->totalTime.hi * 65536.0 * 65536.0) + (double)function->totalTime.lo;
fprintf(f, "%-40s %15.0lf ticks, %15.2lf ticks/call, %7d calls\n", function->name,
temp, temp/function->calls, function->calls);
}
fclose(f);
}
return noErr;
*/
}
pascal void ProfilerTerm(void)
{
gProfilerOn = false;
}
static void StartTime(FunctionInfo *function:__A0, int call:__D0)
{
UnsignedWide thisTime, diff;
FunctionInfo *last;
// get the current time
Profile_GetTime(&thisTime);
// if there was another function being timed, update that timer
last = gCurrentThread->currentFunction;
if (last) {
diff = gCurrentThread->startTime;
SubFromWide(&thisTime, &diff);
AddToWide(&last->totalTime, &diff);
}
// if we have a new function to track, reset the start time and increment the calling count
if (function) {
if (call) function->calls++;
gCurrentThread->startTime = thisTime;
}
// update the current thread's function pointer
gCurrentThread->currentFunction = function;
}
static FunctionInfo *GetIndex(char *functionName:__A0, long address:__D0):__A0
{
FunctionInfo *function;
register int i;
// loop over all functions, looking for an address match or an empty space
for (i = 0, function = gFunction; i < MAX_FUNCS; i++, function++) {
long a = function->address;
if (!a) break;
else if (a == address) return function;
}
// if we have space for a new function, create an entry
if (i < MAX_FUNCS) {
strncpy(function->name, functionName, NAME_LENGTH);
function->address = address;
return function;
}
// return nil if nothing could be found
return nil;
}
void GetThreadInfo(void)
{
// get a pointer to the current thread's info
ThreadID thread;
GetCurrentThread(&thread);
gCurrentThread = gThread + thread - THREAD_OFFSET;
}
void PushFrame(long returnAddress:__D0)
{
// get a pointer to the next empty stack frame, and increment the stack pointer
StackFrame *sp = gCurrentThread->stackPtr++;
// save the current function and return address
sp->callerFunction = gCurrentThread->currentFunction;
sp->returnAddress = returnAddress;
}
long PopFrame(void):__D0
{
// get a pointer to the next empty stack frame, and increment the stack pointer
StackFrame *sp = --gCurrentThread->stackPtr;
// save the current function and return address
gCallerFunction = sp->callerFunction;
return sp->returnAddress;
}
// When __PROFILE is called, stack frame looks like this:
//
// sp+0c Return space for Pascal function
// sp+08 Caller's return address
// sp+04 Address of function name string
// sp Return address to start of function
//
// After we save registers and such, stack frame looks like this:
//
// sp+32 Return space for Pascal function
// sp+28 Caller's return address
// sp+24 Address of function name string
// sp+20 Return address to start of function
// sp+16 saved A0
// sp+12 saved A1
// sp+08 saved D0
// sp+04 saved D1
// sp saved D2
//
// Upon returning from __PROFILE, stack frame should look like this:
//
// sp+04 Return space for Pascal function
// sp Address of __PROFILEEND
asm pascal void __PROFILE(char *functionName)
{
tst.l gProfilerOn // is the profiler on?
bne.s @doProfile // if so, go do the work
move.l (sp),4(sp) // otherwise, copy return address over parameter
addq.l #4,sp // adjust the stack pointer accordingly
rts // return
@doProfile:
_Debugger
clr.l gProfilerOn // clear the profiler flag -- we are not reentrant
movem.l a0/a1/d0-d2,-(sp) // save registers
jsr GetThreadInfo // get the current thread info into a global
move.l 28(sp),d0 // get the return address in d0
jsr PushFrame // and push it onto the stack
move.l 24(sp),a0 // now get the function name
move.l 20(sp),d0 // and the function address
move.l d0,24(sp) // (copy the address onto the stack for later)
jsr GetIndex // and return an index into our function table
moveq.l #1,d0 // set the call flag
jsr StartTime // start the timer for this baby (and stop the last one)
lea __PROFILEEND,a0 // point a0 to our profile end routine
move.l a0,28(sp) // store that in place of the real return address
movem.l (sp)+,a0/a1/d0-d2 // restore the registers
addq.l #4,sp // skip over stack space for the functionName parameter
move.l #1,gProfilerOn // turn the profiler flag back on
rts // and return
}
// sequence of events:
//
// call to __PROFILE
// clears profilerOn flag to prevent re-entrancy
// gets a pointer to the current thread info in gCurrentThread
// saves the currentFunction pointer and the real return address as a stack frame
// calculates a pointer to the new currentFunction
// stops the timer for the previous currentFunction and starts it for the new one
// replaces the real return address with a return into __PROFILEEND
// resets profilerOn flag
// returns to the beginning of the function
//
// return to __PROFILEEND
// clears profilerOn flag to prevent re-entrancy
// gets a pointer to the current thread info in gCurrentThread
// pops the stack frame, returning real return address and pointer to caller function
// saves real return address on the stack for returning
// stops the timer for the previous function and starts it back up for the caller function
// resets profilerOn flag
// returns to the calling function
//
// When __PROFILEEND is called, stack frame looks like this:
//
// sp Return space for Pascal function
//
// Upon returning from __PROFILE, stack frame should look like this:
//
// sp Address of __PROFILEEND
asm pascal void __PROFILEEND(void)
{
_Debugger
clr.l gProfilerOn // clear the profiler flag -- we are not reentrant
movem.l a0/d0,gSaveArea // save a0/d0
jsr GetThreadInfo // get the current thread info into a global
jsr PopFrame // pop the frame, returning the real return address
move.l d0,gSaveArea+8 // save return address in a safe place
move.l gCallerFunction,a0 // get pointer to new current function
clr.l d0 // clear the call flag
jsr StartTime // now start the timer
movem.l gSaveArea,a0/d0 // restore a0/d0
move.l gSaveArea+8,a1 // get return address in a1
move.l #1,gProfilerOn // turn the profiler flag back on
jmp (a1) // return to the caller
}