_hotshot.c

/*
 * This is the High Performance Python Profiler portion of HotShot.
 */

#include"Python.h"
#include"code.h"
#include"eval.h"
#include"frameobject.h"
#include"structmember.h"

/*
 * Which timer to use should be made more configurable, but that should not
 * be difficult. This will do for now.
 */
#ifdefMS_WINDOWS
#include<windows.h>

#ifdefHAVE_DIRECT_H
#include<direct.h>/* for getcwd() */
#endif

typedef__int64hs_time;
#defineGETTIMEOFDAY(P_HS_TIME) \
 { LARGE_INTEGER _temp; \
 QueryPerformanceCounter(&_temp); \
 *(P_HS_TIME) = _temp.QuadPart; }


#else
#ifndefHAVE_GETTIMEOFDAY
#error "This module requires gettimeofday() on non-Windows platforms!"
#endif
#if (defined(PYOS_OS2) && defined(PYCC_GCC)) || defined(__QNX__)
#include<sys/time.h>
#else
#include<sys/resource.h>
#include<sys/times.h>
#endif
typedefstructtimevalhs_time;
#endif

#if !defined(__cplusplus) && !defined(inline)
#ifdef__GNUC__
#defineinline __inline
#endif
#endif

#ifndefinline
#defineinline
#endif

#defineBUFFERSIZE 10240

#if defined(PYOS_OS2) && defined(PYCC_GCC)
#definePATH_MAX 260
#endif

#if defined(__sgi) &&_COMPILER_VERSION>700&& !defined(PATH_MAX)
/* fix PATH_MAX not being defined with MIPSPro 7.x
 if mode is ANSI C (default) */
#definePATH_MAX 1024
#endif

#ifndefPATH_MAX
# ifdefMAX_PATH
# definePATH_MAX MAX_PATH
# elif defined (_POSIX_PATH_MAX)
# definePATH_MAX _POSIX_PATH_MAX
# else
# error "Need a defn. for PATH_MAX in _hotshot.c"
# endif
#endif

typedefstruct {
PyObject_HEAD
PyObject*filemap;
PyObject*logfilename;
Py_ssize_tindex;
unsigned charbuffer[BUFFERSIZE];
FILE*logfp;
intlineevents;
intlinetimings;
intframetimings;
/* size_t filled; */
intactive;
intnext_fileno;
hs_timeprev_timeofday;
} ProfilerObject;

typedefstruct {
PyObject_HEAD
PyObject*info;
FILE*logfp;
intlinetimings;
intframetimings;
} LogReaderObject;

staticPyObject*ProfilerError=NULL;


#ifndefMS_WINDOWS
#ifdefGETTIMEOFDAY_NO_TZ
#defineGETTIMEOFDAY(ptv) gettimeofday((ptv))
#else
#defineGETTIMEOFDAY(ptv) gettimeofday((ptv), (struct timezone *)NULL)
#endif
#endif


/* The log reader... */

PyDoc_STRVAR(logreader_close__doc__,
"close()\n"
"Close the log file, preventing additional records from being read.");

staticPyObject*
logreader_close(LogReaderObject*self, PyObject*args)
{
if (self->logfp!=NULL) {
fclose(self->logfp);
self->logfp=NULL;
 }
Py_INCREF(Py_None);

returnPy_None;
}

PyDoc_STRVAR(logreader_fileno__doc__,
"fileno() -> file descriptor\n"
"Returns the file descriptor for the log file, if open.\n"
"Raises ValueError if the log file is closed.");

staticPyObject*
logreader_fileno(LogReaderObject*self)
{
if (self->logfp==NULL) {
PyErr_SetString(PyExc_ValueError,
"logreader's file object already closed");
returnNULL;
 }
returnPyInt_FromLong(fileno(self->logfp));
}


/* Log File Format
 * ---------------
 *
 * The log file consists of a sequence of variable-length records.
 * Each record is identified with a record type identifier in two
 * bits of the first byte. The two bits are the "least significant"
 * bits of the byte.
 *
 * Low bits: Opcode: Meaning:
 * 0x00 ENTER enter a frame
 * 0x01 EXIT exit a frame
 * 0x02 LINENO execution moved onto a different line
 * 0x03 OTHER more bits are needed to deecode
 *
 * If the type is OTHER, the record is not packed so tightly, and the
 * remaining bits are used to disambiguate the record type. These
 * records are not used as frequently so compaction is not an issue.
 * Each of the first three record types has a highly tailored
 * structure that allows it to be packed tightly.
 *
 * The OTHER records have the following identifiers:
 *
 * First byte: Opcode: Meaning:
 * 0x13 ADD_INFO define a key/value pair
 * 0x23 DEFINE_FILE define an int->filename mapping
 * 0x33 LINE_TIMES indicates if LINENO events have tdeltas
 * 0x43 DEFINE_FUNC define a (fileno,lineno)->funcname mapping
 * 0x53 FRAME_TIMES indicates if ENTER/EXIT events have tdeltas
 *
 * Packed Integers
 *
 * "Packed integers" are non-negative integer values encoded as a
 * sequence of bytes. Each byte is encoded such that the most
 * significant bit is set if the next byte is also part of the
 * integer. Each byte provides bits to the least-significant end of
 * the result; the accumulated value must be shifted up to place the
 * new bits into the result.
 *
 * "Modified packed integers" are packed integers where only a portion
 * of the first byte is used. In the rest of the specification, these
 * are referred to as "MPI(n,name)", where "n" is the number of bits
 * discarded from the least-signicant positions of the byte, and
 * "name" is a name being given to those "discarded" bits, since they
 * are a field themselves.
 *
 * ENTER records:
 *
 * MPI(2,type) fileno -- type is 0x00
 * PI lineno
 * PI tdelta -- iff frame times are enabled
 *
 * EXIT records
 *
 * MPI(2,type) tdelta -- type is 0x01; tdelta will be 0
 * if frame times are disabled
 *
 * LINENO records
 *
 * MPI(2,type) lineno -- type is 0x02
 * PI tdelta -- iff LINENO includes it
 *
 * ADD_INFO records
 *
 * BYTE type -- always 0x13
 * PI len1 -- length of first string
 * BYTE string1[len1] -- len1 bytes of string data
 * PI len2 -- length of second string
 * BYTE string2[len2] -- len2 bytes of string data
 *
 * DEFINE_FILE records
 *
 * BYTE type -- always 0x23
 * PI fileno
 * PI len -- length of filename
 * BYTE filename[len] -- len bytes of string data
 *
 * DEFINE_FUNC records
 *
 * BYTE type -- always 0x43
 * PI fileno
 * PI lineno
 * PI len -- length of funcname
 * BYTE funcname[len] -- len bytes of string data
 *
 * LINE_TIMES records
 *
 * This record can be used only before the start of ENTER/EXIT/LINENO
 * records. If have_tdelta is true, LINENO records will include the
 * tdelta field, otherwise it will be omitted. If this record is not
 * given, LINENO records will not contain the tdelta field.
 *
 * BYTE type -- always 0x33
 * BYTE have_tdelta -- 0 if LINENO does *not* have
 * timing information
 * FRAME_TIMES records
 *
 * This record can be used only before the start of ENTER/EXIT/LINENO
 * records. If have_tdelta is true, ENTER and EXIT records will
 * include the tdelta field, otherwise it will be omitted. If this
 * record is not given, ENTER and EXIT records will contain the tdelta
 * field.
 *
 * BYTE type -- always 0x53
 * BYTE have_tdelta -- 0 if ENTER/EXIT do *not* have
 * timing information
 */

#defineWHAT_ENTER 0x00
#defineWHAT_EXIT 0x01
#defineWHAT_LINENO 0x02
#defineWHAT_OTHER 0x03 /* only used in decoding */
#defineWHAT_ADD_INFO 0x13
#defineWHAT_DEFINE_FILE 0x23
#defineWHAT_LINE_TIMES 0x33
#defineWHAT_DEFINE_FUNC 0x43
#defineWHAT_FRAME_TIMES 0x53

#defineERR_NONE 0
#defineERR_EOF -1
#defineERR_EXCEPTION -2
#defineERR_BAD_RECTYPE -3

#definePISIZE (sizeof(int) + 1)
#defineMPISIZE (PISIZE + 1)

/* Maximum size of "normal" events -- nothing that contains string data */
#defineMAXEVENTSIZE (MPISIZE + PISIZE*2)


/* Unpack a packed integer; if "discard" is non-zero, unpack a modified
 * packed integer with "discard" discarded bits.
 */
staticint
unpack_packed_int(LogReaderObject*self, int*pvalue, intdiscard)
{
intc;
intaccum=0;
intbits=0;
intcont;

do {
/* read byte */
if ((c=fgetc(self->logfp)) ==EOF)
returnERR_EOF;
accum |= ((c&0x7F) >> discard) << bits;
bits+= (7-discard);
cont=c&0x80;
discard=0;
 } while (cont);

*pvalue=accum;

return0;
}

/* Unpack a string, which is encoded as a packed integer giving the
 * length of the string, followed by the string data.
 */
staticint
unpack_string(LogReaderObject*self, PyObject**pvalue)
{
inti;
intlen;
interr;
intch;
char*buf;

if ((err=unpack_packed_int(self, &len, 0)))
returnerr;

buf= (char*)malloc(len);
if (!buf) {
PyErr_NoMemory();
returnERR_EXCEPTION;
 }

for (i=0; i<len; i++) {
ch=fgetc(self->logfp);
buf[i] =ch;
if (ch==EOF) {
free(buf);
returnERR_EOF;
 }
 }
*pvalue=PyString_FromStringAndSize(buf, len);
free(buf);
if (*pvalue==NULL) {
returnERR_EXCEPTION;
 }
return0;
}


staticint
unpack_add_info(LogReaderObject*self)
{
PyObject*key=NULL;
PyObject*value=NULL;
PyObject*list;
interr;

err=unpack_string(self, &key);
if (err)
 goto finally;
err=unpack_string(self, &value);
if (err)
 goto finally;
list=PyDict_GetItem(self->info, key);
if (list==NULL) {
list=PyList_New(0);
if (list==NULL) {
err=ERR_EXCEPTION;
 goto finally;
 }
if (PyDict_SetItem(self->info, key, list)) {
Py_DECREF(list);
err=ERR_EXCEPTION;
 goto finally;
 }
Py_DECREF(list);
 }
if (PyList_Append(list, value))
err=ERR_EXCEPTION;

finally:
Py_XDECREF(key);
Py_XDECREF(value);
returnerr;
}


staticvoid
eof_error(LogReaderObject*self)
{
fclose(self->logfp);
self->logfp=NULL;
PyErr_SetString(PyExc_EOFError,
"end of file with incomplete profile record");
}

staticPyObject*
logreader_tp_iternext(LogReaderObject*self)
{
intc;
intwhat;
interr=ERR_NONE;
intlineno=-1;
intfileno=-1;
inttdelta=-1;
PyObject*s1=NULL, *s2=NULL;
PyObject*result=NULL;
#if0
unsigned charb0, b1;
#endif

if (self->logfp==NULL) {
PyErr_SetString(ProfilerError,
"cannot iterate over closed LogReader object");
returnNULL;
 }

restart:
/* decode the record type */
if ((c=fgetc(self->logfp)) ==EOF) {
fclose(self->logfp);
self->logfp=NULL;
returnNULL;
 }
what=c&WHAT_OTHER;
if (what==WHAT_OTHER)
what=c; /* need all the bits for type */
else
ungetc(c, self->logfp); /* type byte includes packed int */

switch (what) {
caseWHAT_ENTER:
err=unpack_packed_int(self, &fileno, 2);
if (!err) {
err=unpack_packed_int(self, &lineno, 0);
if (self->frametimings&& !err)
err=unpack_packed_int(self, &tdelta, 0);
 }
break;
caseWHAT_EXIT:
err=unpack_packed_int(self, &tdelta, 2);
break;
caseWHAT_LINENO:
err=unpack_packed_int(self, &lineno, 2);
if (self->linetimings&& !err)
err=unpack_packed_int(self, &tdelta, 0);
break;
caseWHAT_ADD_INFO:
err=unpack_add_info(self);
break;
caseWHAT_DEFINE_FILE:
err=unpack_packed_int(self, &fileno, 0);
if (!err) {
err=unpack_string(self, &s1);
if (!err) {
Py_INCREF(Py_None);
s2=Py_None;
 }
 }
break;
caseWHAT_DEFINE_FUNC:
err=unpack_packed_int(self, &fileno, 0);
if (!err) {
err=unpack_packed_int(self, &lineno, 0);
if (!err)
err=unpack_string(self, &s1);
 }
break;
caseWHAT_LINE_TIMES:
if ((c=fgetc(self->logfp)) ==EOF)
err=ERR_EOF;
else {
self->linetimings=c ? 1 : 0;
 goto restart;
 }
break;
caseWHAT_FRAME_TIMES:
if ((c=fgetc(self->logfp)) ==EOF)
err=ERR_EOF;
else {
self->frametimings=c ? 1 : 0;
 goto restart;
 }
break;
default:
err=ERR_BAD_RECTYPE;
 }
if (err==ERR_BAD_RECTYPE) {
PyErr_SetString(PyExc_ValueError,
"unknown record type in log file");
 }
elseif (err==ERR_EOF) {
eof_error(self);
 }
elseif (!err) {
result=PyTuple_New(4);
if (result==NULL) {
Py_XDECREF(s1);
Py_XDECREF(s2);
returnNULL;
 }
PyTuple_SET_ITEM(result, 0, PyInt_FromLong(what));
PyTuple_SET_ITEM(result, 2, PyInt_FromLong(fileno));
if (s1==NULL)
PyTuple_SET_ITEM(result, 1, PyInt_FromLong(tdelta));
else
PyTuple_SET_ITEM(result, 1, s1);
if (s2==NULL)
PyTuple_SET_ITEM(result, 3, PyInt_FromLong(lineno));
else
PyTuple_SET_ITEM(result, 3, s2);
 }
/* The only other case is err == ERR_EXCEPTION, in which case the
 * exception is already set.
 */
#if0
b0=self->buffer[self->index];
b1=self->buffer[self->index+1];
if (b0&1) {
/* This is a line-number event. */
what=PyTrace_LINE;
lineno= ((b0& ~1) << 7) +b1;
self->index+=2;
 }
else {
what= (b0&0x0E) >> 1;
tdelta= ((b0&0xF0) << 4) +b1;
if (what==PyTrace_CALL) {
/* we know there's a 2-byte file ID & 2-byte line number */
fileno= ((self->buffer[self->index+2] << 8)
+self->buffer[self->index+3]);
lineno= ((self->buffer[self->index+4] << 8)
+self->buffer[self->index+5]);
self->index+=6;
 }
else
self->index+=2;
 }
#endif
returnresult;
}

staticvoid
logreader_dealloc(LogReaderObject*self)
{
if (self->logfp!=NULL) {
fclose(self->logfp);
self->logfp=NULL;
 }
Py_XDECREF(self->info);
PyObject_Del(self);
}

staticPyObject*
logreader_sq_item(LogReaderObject*self, Py_ssize_tindex)
{
PyObject*result=logreader_tp_iternext(self);
if (result==NULL&& !PyErr_Occurred()) {
PyErr_SetString(PyExc_IndexError, "no more events in log");
returnNULL;
 }
returnresult;
}

staticvoid
do_stop(ProfilerObject*self);

staticint
flush_data(ProfilerObject*self)
{
/* Need to dump data to the log file... */
size_twritten=fwrite(self->buffer, 1, self->index, self->logfp);
if (written== (size_t)self->index)
self->index=0;
else {
memmove(self->buffer, &self->buffer[written],
self->index-written);
self->index-=written;
if (written==0) {
char*s=PyString_AsString(self->logfilename);
PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
do_stop(self);
return-1;
 }
 }
if (written>0) {
if (fflush(self->logfp)) {
char*s=PyString_AsString(self->logfilename);
PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
do_stop(self);
return-1;
 }
 }
return0;
}

staticinlineint
pack_packed_int(ProfilerObject*self, intvalue)
{
unsigned charpartial;

do {
partial=value&0x7F;
value >>= 7;
if (value)
partial |= 0x80;
self->buffer[self->index] =partial;
self->index++;
 } while (value);
return0;
}

/* Encode a modified packed integer, with a subfield of modsize bits
 * containing the value "subfield". The value of subfield is not
 * checked to ensure it actually fits in modsize bits.
 */
staticinlineint
pack_modified_packed_int(ProfilerObject*self, intvalue,
intmodsize, intsubfield)
{
constintmaxvalues[] = {-1, 1, 3, 7, 15, 31, 63, 127};

intbits=7-modsize;
intpartial=value&maxvalues[bits];
unsigned charb=subfield | (partial << modsize);

if (partial!=value) {
b |= 0x80;
self->buffer[self->index] =b;
self->index++;
returnpack_packed_int(self, value >> bits);
 }
self->buffer[self->index] =b;
self->index++;
return0;
}

staticint
pack_string(ProfilerObject*self, constchar*s, Py_ssize_tlen)
{
if (len+PISIZE+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
if (len+PISIZE+self->index >= BUFFERSIZE) {
PyErr_SetString(PyExc_ValueError, "string too large for internal buffer");
return-1;
 }
 }
assert(len<INT_MAX);
if (pack_packed_int(self, (int)len) <0)
return-1;
memcpy(self->buffer+self->index, s, len);
self->index+=len;
return0;
}

staticint
pack_add_info(ProfilerObject*self, constchar*s1, constchar*s2)
{
Py_ssize_tlen1=strlen(s1);
Py_ssize_tlen2=strlen(s2);

if (len1+len2+PISIZE*2+1+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
self->buffer[self->index] =WHAT_ADD_INFO;
self->index++;
if (pack_string(self, s1, len1) <0)
return-1;
returnpack_string(self, s2, len2);
}

staticint
pack_define_file(ProfilerObject*self, intfileno, constchar*filename)
{
Py_ssize_tlen=strlen(filename);

if (len+PISIZE*2+1+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
self->buffer[self->index] =WHAT_DEFINE_FILE;
self->index++;
if (pack_packed_int(self, fileno) <0)
return-1;
returnpack_string(self, filename, len);
}

staticint
pack_define_func(ProfilerObject*self, intfileno, intlineno,
constchar*funcname)
{
Py_ssize_tlen=strlen(funcname);

if (len+PISIZE*3+1+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
self->buffer[self->index] =WHAT_DEFINE_FUNC;
self->index++;
if (pack_packed_int(self, fileno) <0)
return-1;
if (pack_packed_int(self, lineno) <0)
return-1;
returnpack_string(self, funcname, len);
}

staticint
pack_line_times(ProfilerObject*self)
{
if (2+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
self->buffer[self->index] =WHAT_LINE_TIMES;
self->buffer[self->index+1] =self->linetimings ? 1 : 0;
self->index+=2;
return0;
}

staticint
pack_frame_times(ProfilerObject*self)
{
if (2+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
self->buffer[self->index] =WHAT_FRAME_TIMES;
self->buffer[self->index+1] =self->frametimings ? 1 : 0;
self->index+=2;
return0;
}

staticinlineint
pack_enter(ProfilerObject*self, intfileno, inttdelta, intlineno)
{
if (MPISIZE+PISIZE*2+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
pack_modified_packed_int(self, fileno, 2, WHAT_ENTER);
pack_packed_int(self, lineno);
if (self->frametimings)
returnpack_packed_int(self, tdelta);
else
return0;
}

staticinlineint
pack_exit(ProfilerObject*self, inttdelta)
{
if (MPISIZE+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
if (self->frametimings)
returnpack_modified_packed_int(self, tdelta, 2, WHAT_EXIT);
self->buffer[self->index] =WHAT_EXIT;
self->index++;
return0;
}

staticinlineint
pack_lineno(ProfilerObject*self, intlineno)
{
if (MPISIZE+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return-1;
 }
returnpack_modified_packed_int(self, lineno, 2, WHAT_LINENO);
}

staticinlineint
pack_lineno_tdelta(ProfilerObject*self, intlineno, inttdelta)
{
if (MPISIZE+PISIZE+self->index >= BUFFERSIZE) {
if (flush_data(self) <0)
return0;
 }
if (pack_modified_packed_int(self, lineno, 2, WHAT_LINENO) <0)
return-1;
returnpack_packed_int(self, tdelta);
}

staticinlineint
get_fileno(ProfilerObject*self, PyCodeObject*fcode)
{
/* This is only used for ENTER events. */

PyObject*obj;
PyObject*dict;
intfileno;

obj=PyDict_GetItem(self->filemap, fcode->co_filename);
if (obj==NULL) {
/* first sighting of this file */
dict=PyDict_New();
if (dict==NULL) {
return-1;
 }
fileno=self->next_fileno;
obj=Py_BuildValue("iN", fileno, dict);
if (obj==NULL) {
return-1;
 }
if (PyDict_SetItem(self->filemap, fcode->co_filename, obj)) {
Py_DECREF(obj);
return-1;
 }
self->next_fileno++;
Py_DECREF(obj);
if (pack_define_file(self, fileno,
PyString_AS_STRING(fcode->co_filename)) <0)
return-1;
 }
else {
/* already know this ID */
fileno=PyInt_AS_LONG(PyTuple_GET_ITEM(obj, 0));
dict=PyTuple_GET_ITEM(obj, 1);
 }
/* make sure we save a function name for this (fileno, lineno) */
obj=PyInt_FromLong(fcode->co_firstlineno);
if (obj==NULL) {
/* We just won't have it saved; too bad. */
PyErr_Clear();
 }
else {
PyObject*name=PyDict_GetItem(dict, obj);
if (name==NULL) {
if (pack_define_func(self, fileno, fcode->co_firstlineno,
PyString_AS_STRING(fcode->co_name)) <0) {
Py_DECREF(obj);
return-1;
 }
if (PyDict_SetItem(dict, obj, fcode->co_name)) {
Py_DECREF(obj);
return-1;
 }
 }
Py_DECREF(obj);
 }
returnfileno;
}

staticinlineint
get_tdelta(ProfilerObject*self)
{
inttdelta;
#ifdefMS_WINDOWS
hs_timetv;
hs_timediff;

GETTIMEOFDAY(&tv);
diff=tv-self->prev_timeofday;
tdelta= (int)diff;
#else
structtimevaltv;

GETTIMEOFDAY(&tv);

tdelta=tv.tv_usec-self->prev_timeofday.tv_usec;
if (tv.tv_sec!=self->prev_timeofday.tv_sec)
tdelta+= (tv.tv_sec-self->prev_timeofday.tv_sec) *1000000;
#endif
/* time can go backwards on some multiprocessor systems or by NTP */
if (tdelta<0)
return0;

self->prev_timeofday=tv;
returntdelta;
}


/* The workhorse: the profiler callback function. */

staticint
tracer_callback(ProfilerObject*self, PyFrameObject*frame, intwhat,
PyObject*arg)
{
intfileno;

switch (what) {
casePyTrace_CALL:
fileno=get_fileno(self, frame->f_code);
if (fileno<0)
return-1;
returnpack_enter(self, fileno,
self->frametimings ? get_tdelta(self) : -1,
frame->f_code->co_firstlineno);

casePyTrace_RETURN:
returnpack_exit(self, get_tdelta(self));

casePyTrace_LINE: /* we only get these events if we asked for them */
if (self->linetimings)
returnpack_lineno_tdelta(self, frame->f_lineno,
get_tdelta(self));
else
returnpack_lineno(self, frame->f_lineno);

default:
/* ignore PyTrace_EXCEPTION */
break;
 }
return0;
}


/* A couple of useful helper functions. */

#ifdefMS_WINDOWS
staticLARGE_INTEGERfrequency= {0, 0};
#endif

staticunsigned longtimeofday_diff=0;
staticunsigned longrusage_diff=0;

staticvoid
calibrate(void)
{
hs_timetv1, tv2;

#ifdefMS_WINDOWS
hs_timediff;
QueryPerformanceFrequency(&frequency);
#endif

GETTIMEOFDAY(&tv1);
while (1) {
GETTIMEOFDAY(&tv2);
#ifdefMS_WINDOWS
diff=tv2-tv1;
if (diff!=0) {
timeofday_diff= (unsigned long)diff;
break;
 }
#else
if (tv1.tv_sec!=tv2.tv_sec||tv1.tv_usec!=tv2.tv_usec) {
if (tv1.tv_sec==tv2.tv_sec)
timeofday_diff=tv2.tv_usec-tv1.tv_usec;
else
timeofday_diff= (1000000-tv1.tv_usec) +tv2.tv_usec;
break;
 }
#endif
 }
#if defined(MS_WINDOWS) || defined(PYOS_OS2) || \
 defined(__VMS) || defined (__QNX__)
rusage_diff=-1;
#else
 {
structrusageru1, ru2;

getrusage(RUSAGE_SELF, &ru1);
while (1) {
getrusage(RUSAGE_SELF, &ru2);
if (ru1.ru_utime.tv_sec!=ru2.ru_utime.tv_sec) {
rusage_diff= ((1000000-ru1.ru_utime.tv_usec)
+ru2.ru_utime.tv_usec);
break;
 }
elseif (ru1.ru_utime.tv_usec!=ru2.ru_utime.tv_usec) {
rusage_diff=ru2.ru_utime.tv_usec-ru1.ru_utime.tv_usec;
break;
 }
elseif (ru1.ru_stime.tv_sec!=ru2.ru_stime.tv_sec) {
rusage_diff= ((1000000-ru1.ru_stime.tv_usec)
+ru2.ru_stime.tv_usec);
break;
 }
elseif (ru1.ru_stime.tv_usec!=ru2.ru_stime.tv_usec) {
rusage_diff=ru2.ru_stime.tv_usec-ru1.ru_stime.tv_usec;
break;
 }
 }
 }
#endif
}

staticvoid
do_start(ProfilerObject*self)
{
self->active=1;
GETTIMEOFDAY(&self->prev_timeofday);
if (self->lineevents)
PyEval_SetTrace((Py_tracefunc) tracer_callback, (PyObject*)self);
else
PyEval_SetProfile((Py_tracefunc) tracer_callback, (PyObject*)self);
}

staticvoid
do_stop(ProfilerObject*self)
{
if (self->active) {
self->active=0;
if (self->lineevents)
PyEval_SetTrace(NULL, NULL);
else
PyEval_SetProfile(NULL, NULL);
 }
if (self->index>0) {
/* Best effort to dump out any remaining data. */
flush_data(self);
 }
}

staticint
is_available(ProfilerObject*self)
{
if (self->active) {
PyErr_SetString(ProfilerError, "profiler already active");