The HotShot core: look, ma, no hands!

1 files changed, 1368 insertions, 0 deletions

diff --git a/Modules/_hotshot.c b/Modules/_hotshot.c
new file mode 100644
index 0000000000..8b95c3cc74
--- /dev/null
+++ b/Modules/_hotshot.c
@@ -0,0 +1,1368 @@
+/*
+ * This is the High Performance Python Profiler portion of HotShot.
+ */
+
+#include <Python.h>
+#include <compile.h>
+#include <eval.h>
+#include <frameobject.h>
+#include <structmember.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+/*
+ * Which timer to use should be made more configurable, but that should not
+ * be difficult.  This will do fo now.
+ */
+#ifdef MS_WIN32
+#include <windows.h>
+#include <largeint.h>
+typedef LARGE_INTEGER hs_time;
+#else
+#ifndef HAVE_GETTIMEOFDAY
+#error "This module requires gettimeofday() on non-Windows platforms!"
+#endif
+#include <sys/resource.h>
+#include <sys/times.h>
+typedef struct timeval hs_time;
+#endif
+
+#if !defined(__cplusplus) && !defined(inline)
+#ifdef __GNUC__
+#define inline __inline
+#endif
+#endif
+
+#ifndef inline
+#define inline
+#endif
+
+#define BUFFERSIZE 10240
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *filemap;
+    PyObject *logfilename;
+    int index;
+    unsigned char buffer[BUFFERSIZE];
+    FILE *logfp;
+    int lineevents;
+    int linetimings;
+    /* size_t filled; */
+    int active;
+    int next_fileno;
+    long callcount;
+    hs_time prev_timeofday;
+} ProfilerObject;
+
+typedef struct {
+    PyObject_HEAD
+    FILE *logfp;
+    int filled;
+    int index;
+    int linetimings;
+    unsigned char buffer[BUFFERSIZE];
+} LogReaderObject;
+
+static PyObject * ProfilerError = NULL;
+
+
+#ifndef MS_WIN32
+#ifdef GETTIMEOFDAY_NO_TZ
+#define GETTIMEOFDAY(ptv) gettimeofday((ptv))
+#else
+#define GETTIMEOFDAY(ptv) gettimeofday((ptv), (struct timezone *)NULL)
+#endif
+#endif
+
+
+/* The log reader... */
+
+static char logreader_close__doc__[] = "\
+close()\n\
+Close the log file, preventing additional records from being read.";
+
+static PyObject *
+logreader_close(LogReaderObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+    if (PyArg_ParseTuple(args, ":close")) {
+        if (self->logfp != NULL) {
+            fclose(self->logfp);
+            self->logfp = NULL;
+        }
+        result = Py_None;
+        Py_INCREF(result);
+    }
+    return result;
+}
+
+#if Py_TPFLAGS_HAVE_ITER
+/* This is only used if the interpreter has iterator support; the
+ * iternext handler is also used as a helper for other functions, so
+ * does not need to be included in this conditional section.
+ */
+static PyObject *
+logreader_tp_iter(LogReaderObject *self)
+{
+    Py_INCREF(self);
+    return (PyObject *) self;
+}
+#endif
+
+
+/* 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     SET_LINENO instruction was executed
+ *       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
+ *
+ * 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           tdelta
+ *      PI           lineno
+ *
+ * EXIT records
+ *
+ *      MPI(2,type)  tdelta          -- type is 0x01
+ *
+ * LINENO records
+ *
+ *      MPI(2,type)  lineno          -- type is 0x02
+ *      PI           tdelta          -- iff LINENO includes it
+ *
+ * ADD_INFO records
+ *
+ *      BYTE         type            -- always 0x03
+ *      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 0x13
+ *      PI           fileno
+ *      PI           len             -- length of filename
+ *      BYTE         filename[len]   -- len bytes of string data
+ *
+ * LINE_TIMES records
+ *      BYTE         type            -- always 0x23
+ *      BYTE         have_tdelta     -- 0 if LINENO does *not* have
+ *                                      timing information
+ */
+
+#define WHAT_ENTER        0x00
+#define WHAT_EXIT         0x01
+#define WHAT_LINENO       0x02
+#define WHAT_OTHER        0x03  /* only used in decoding */
+#define WHAT_ADD_INFO     0x13
+#define WHAT_DEFINE_FILE  0x23
+#define WHAT_LINE_TIMES   0x33
+
+#define ERR_NONE          0
+#define ERR_EOF          -1
+#define ERR_EXCEPTION    -2
+
+#define PISIZE            (sizeof(int) + 1)
+#define MPISIZE           (PISIZE + 1)
+
+/* Maximum size of "normal" events -- nothing that contains string data */
+#define MAXEVENTSIZE      (MPISIZE + PISIZE*2)
+
+
+/* Unpack a packed integer; if "discard" is non-zero, unpack a modified
+ * packed integer with "discard" discarded bits.
+ */
+static int
+unpack_packed_int(LogReaderObject *self, int *pvalue, int discard)
+{
+    int accum = 0;
+    int bits = 0;
+    int index = self->index;
+    int cont;
+
+    do {
+        if (index >= self->filled)
+            return ERR_EOF;
+        /* read byte */
+        accum |= ((self->buffer[index] & 0x7F) >> discard) << bits;
+        bits += (7 - discard);
+        cont = self->buffer[index] & 0x80;
+        /* move to next */
+        discard = 0;
+        index++;
+    } while (cont);
+
+    /* save state */
+    self->index = index;
+    *pvalue = accum;
+
+    return 0;
+}
+
+/* Unpack a string, which is encoded as a packed integer giving the
+ * length of the string, followed by the string data.
+ */
+static int
+unpack_string(LogReaderObject *self, PyObject **pvalue)
+{
+    int len;
+    int oldindex = self->index;
+    int err = unpack_packed_int(self, &len, 0);
+
+    if (!err) {
+        /* need at least len bytes in buffer */
+        if (len > (self->filled - self->index)) {
+            self->index = oldindex;
+            err = ERR_EOF;
+        }
+        else {
+            *pvalue = PyString_FromStringAndSize(self->buffer + self->index,
+                                                 len);
+            if (*pvalue == NULL) {
+                self->index = oldindex;
+                err = ERR_EXCEPTION;
+            }
+            else
+                self->index += len;
+        }
+    }
+    return err;
+}
+
+
+static PyObject *
+logreader_tp_iternext(LogReaderObject *self)
+{
+    int what, oldindex;
+    int err = ERR_NONE;
+    int lineno = -1;
+    int fileno = -1;
+    int tdelta = -1;
+    PyObject *s1 = NULL, *s2 = NULL;
+    PyObject *result = NULL;
+#if 0
+    unsigned char b0, b1;
+#endif
+
+    if (self->logfp == NULL) {
+        PyErr_SetString(ProfilerError,
+                        "cannot iterate over closed LogReader object");
+        return NULL;
+    }
+ restart:
+    if ((self->filled - self->index) < MAXEVENTSIZE) {
+        /* add a little to the buffer */
+        int needed;
+        size_t res;
+    refill:
+        if (self->index) {
+            memmove(self->buffer, &self->buffer[self->index],
+                    self->filled - self->index);
+            self->filled = self->filled - self->index;
+            self->index = 0;
+        }
+        needed = BUFFERSIZE - self->filled;
+        res = fread(&self->buffer[self->filled], 1, needed, self->logfp);
+        self->filled += res;
+    }
+    /* end of input */
+    if (self->filled == 0)
+        return NULL;
+
+    oldindex = self->index;
+
+    /* decode the record type */
+    what = self->buffer[self->index] & WHAT_OTHER;
+    if (what == WHAT_OTHER) {
+        what = self->buffer[self->index];
+        self->index++;
+    }
+    switch (what) {
+    case WHAT_ENTER:
+        err = unpack_packed_int(self, &fileno, 2);
+        if (!err) {
+            err = unpack_packed_int(self, &tdelta, 0);
+            if (!err)
+                err = unpack_packed_int(self, &lineno, 0);
+        }
+        break;
+    case WHAT_EXIT:
+        err = unpack_packed_int(self, &tdelta, 2);
+        break;
+    case WHAT_LINENO:
+        err = unpack_packed_int(self, &lineno, 2);
+        if (self->linetimings && !err)
+            err = unpack_packed_int(self, &tdelta, 0);
+        break;
+    case WHAT_ADD_INFO:
+        err = unpack_string(self, &s1);
+        if (!err) {
+            err = unpack_string(self, &s2);
+            if (err) {
+                Py_DECREF(s1);
+                s1 = NULL;
+            }
+        }
+        break;
+    case WHAT_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;
+    case WHAT_LINE_TIMES:
+        if (self->index >= self->filled)
+            err = ERR_EOF;
+        else {
+            self->linetimings = self->buffer[self->index] ? 1 : 0;
+            self->index++;
+            goto restart;
+        }
+    default:
+    }
+    if (err == ERR_EOF && oldindex != 0) {
+        /* It looks like we ran out of data before we had it all; this
+         * could easily happen with large packed integers or string
+         * data.  Try forcing the buffer to be re-filled before failing.
+         */
+        err = ERR_NONE;
+        goto refill;
+    }
+    if (err == ERR_EOF) {
+        /* Could not avoid end-of-buffer error. */
+        PyErr_SetString(PyExc_EOFError,
+                        "end of file with incomplete profile record");
+    }
+    else if (!err) {
+        result = PyTuple_New(4);
+        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));
+            PyTuple_SET_ITEM(result, 3, PyInt_FromLong(lineno));
+        }
+        else {
+            PyTuple_SET_ITEM(result, 1, s1);
+            PyTuple_SET_ITEM(result, 3, s2);
+        }
+    }
+    /* The only other case is err == ERR_EXCEPTION, in which case the
+     * exception is already set.
+     */
+#if 0
+    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
+    return result;
+}
+
+static void
+logreader_dealloc(LogReaderObject *self)
+{
+    if (self->logfp != NULL) {
+        fclose(self->logfp);
+        self->logfp = NULL;
+    }
+    PyObject_Del(self);
+}
+
+static PyObject *
+logreader_sq_item(LogReaderObject *self, int index)
+{
+    PyObject *result = logreader_tp_iternext(self);
+    if (result == NULL && !PyErr_Occurred()) {
+        PyErr_SetString(PyExc_IndexError, "no more events in log");
+        return NULL;
+    }
+    return result;
+}
+
+static char next__doc__[] = "\
+next() -> event-info\n\
+Return the next event record from the log file.";
+
+static PyObject *
+logreader_next(LogReaderObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+
+    if (PyArg_ParseTuple(args, ":next")) {
+        result = logreader_tp_iternext(self);
+        /* XXX return None if there's nothing left */
+        /* tp_iternext does the right thing, though */
+        if (result == NULL && !PyErr_Occurred()) {
+            result = Py_None;
+            Py_INCREF(result);
+        }
+    }
+    return result;
+}
+
+
+static int
+flush_data(ProfilerObject *self)
+{
+    /* Need to dump data to the log file... */
+    size_t written = fwrite(self->buffer, 1, self->index, self->logfp);
+    if (written == 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);
+            return -1;
+        }
+    }
+    if (written > 0) {
+        if (fflush(self->logfp)) {
+            char *s = PyString_AsString(self->logfilename);
+            PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static inline void
+pack_packed_int(ProfilerObject *self, int value)
+{
+    unsigned char partial;
+
+    do {
+        partial = value & 0x7F;
+        value >>= 7;
+        if (value)
+            partial |= 0x80;
+        self->buffer[self->index] = partial;
+        self->index++;
+    } while (value);
+}
+
+/* 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.
+ */
+static inline void
+pack_modified_packed_int(ProfilerObject *self, int value,
+                         int modsize, int subfield)
+{
+    const int maxvalues[] = {-1, 1, 3, 7, 15, 31, 63, 127};
+
+    int bits = 7 - modsize;
+    int partial = value & maxvalues[bits];
+    unsigned char b = subfield | (partial << modsize);
+
+    if (partial != value) {
+        b |= 0x80;
+        self->buffer[self->index] = b;
+        self->index++;
+        pack_packed_int(self, value >> bits);
+    }
+    else {
+        self->buffer[self->index] = b;
+        self->index++;
+    }
+}
+
+static void
+pack_string(ProfilerObject *self, const char *s)
+{
+    int len = strlen(s);
+
+    pack_packed_int(self, len);
+    if (len + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    memcpy(self->buffer + self->index, s, len);
+    self->index += len;
+}
+
+static void
+pack_add_info(ProfilerObject *self, const char *s1, const char *s2)
+{
+    int len1 = strlen(s1);
+    int len2 = strlen(s2);
+
+    if (len1 + len2 + PISIZE*2 + 1 + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    self->buffer[self->index] = WHAT_ADD_INFO;
+    self->index++;
+    pack_string(self, s1);
+    pack_string(self, s2);
+}
+
+static void
+pack_define_file(ProfilerObject *self, int fileno, const char *filename)
+{
+    int len = strlen(filename);
+
+    if (len + PISIZE*2 + 1 + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    self->buffer[self->index] = WHAT_DEFINE_FILE;
+    self->index++;
+    pack_packed_int(self, fileno);
+    pack_string(self, filename);
+}
+
+static void
+pack_line_times(ProfilerObject *self)
+{
+    if (2 + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    self->buffer[self->index] = WHAT_LINE_TIMES;
+    self->buffer[self->index + 1] = self->linetimings ? 1 : 0;
+    self->index += 2;
+}
+
+static inline void
+pack_enter(ProfilerObject *self, int fileno, int tdelta, int lineno)
+{
+    if (MPISIZE + PISIZE*2 + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    pack_modified_packed_int(self, fileno, 2, WHAT_ENTER);
+    pack_packed_int(self, tdelta);
+    pack_packed_int(self, lineno);
+}
+
+static inline void
+pack_exit(ProfilerObject *self, int tdelta)
+{
+    if (MPISIZE + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    pack_modified_packed_int(self, tdelta, 2, WHAT_EXIT);
+}
+
+static inline void
+pack_lineno(ProfilerObject *self, int lineno)
+{
+    if (MPISIZE + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    pack_modified_packed_int(self, lineno, 2, WHAT_LINENO);
+}
+
+static inline void
+pack_lineno_tdelta(ProfilerObject *self, int lineno, int tdelta)
+{
+    if (MPISIZE + PISIZE + self->index >= BUFFERSIZE)
+        (void) flush_data(self);
+    pack_modified_packed_int(self, lineno, 2, WHAT_LINENO);
+    pack_packed_int(self, tdelta);
+}
+
+static inline int
+get_fileno(ProfilerObject *self, PyCodeObject *fcode)
+{
+    PyObject *idobj;
+    int fileno;
+
+    idobj = PyDict_GetItem(self->filemap, fcode->co_filename);
+    if (idobj == NULL) {
+        /* first sighting of this file */
+        fileno = self->next_fileno;
+        idobj = PyInt_FromLong(fileno);
+        if (idobj == NULL) {
+            return -1;
+        }
+        if (PyDict_SetItem(self->filemap, fcode->co_filename, idobj)) {
+            Py_DECREF(idobj);
+            return -1;
+        }
+        self->next_fileno++;
+        Py_DECREF(idobj);
+        pack_define_file(self, fileno, PyString_AS_STRING(fcode->co_filename));
+    }
+    else {
+        /* already know this ID */
+        fileno = PyInt_AS_LONG(idobj);
+    }
+    return fileno;
+}
+
+static inline int
+get_tdelta(ProfilerObject *self)
+{
+    int tdelta;
+#ifdef MS_WIN32
+    hs_time tv;
+    LARGE_INTEGER diff;
+
+    QueryPerformanceCounter(&tv);
+    diff = LargeIntegerSubtract(tv, self->prev_timeofday);
+
+    tdelta = diff.LowPart;
+#else
+    struct timeval tv;
+
+    GETTIMEOFDAY(&tv);
+
+    if (tv.tv_sec == self->prev_timeofday.tv_sec)
+        tdelta = tv.tv_usec - self->prev_timeofday.tv_usec;
+    else
+        tdelta = ((tv.tv_sec - self->prev_timeofday.tv_sec) * 1000000
+                  + tv.tv_usec);
+#endif
+    self->prev_timeofday = tv;
+    return tdelta;
+}
+
+
+/* The workhorse:  the profiler callback function. */
+
+static int
+profiler_callback(ProfilerObject *self, PyFrameObject *frame, int what,
+                  PyObject *arg)
+{
+    int tdelta = get_tdelta(self);
+    int fileno;
+
+    self->callcount++;
+    switch (what) {
+    case PyTrace_CALL:
+        fileno = get_fileno(self, frame->f_code);
+        if (fileno < 0)
+            return -1;
+        pack_enter(self, fileno, tdelta,
+                   frame->f_code->co_firstlineno);
+        break;
+    case PyTrace_RETURN:
+        pack_exit(self, tdelta);
+        break;
+    default:
+        /* should never get here */
+        break;
+    }
+    return 0;
+}
+
+
+/* Alternate callback when we want PyTrace_LINE events */
+
+static int
+tracer_callback(ProfilerObject *self, PyFrameObject *frame, int what,
+                PyObject *arg)
+{
+    int fileno;
+
+    self->callcount++;
+    switch (what) {
+    case PyTrace_CALL:
+        fileno = get_fileno(self, frame->f_code);
+        if (fileno < 0)
+            return -1;
+        pack_enter(self, fileno, get_tdelta(self),
+                   frame->f_code->co_firstlineno);
+        break;
+    case PyTrace_RETURN:
+        pack_exit(self, get_tdelta(self));
+        break;
+    case PyTrace_LINE: 
+        if (self->linetimings)
+            pack_lineno_tdelta(self, frame->f_lineno, get_tdelta(self));
+        else
+            pack_lineno(self, frame->f_lineno);
+        break;
+    default:
+        /* ignore PyTrace_EXCEPTION */
+        break;
+    }
+    return 0;
+}
+
+
+/* A couple of useful helper functions. */
+
+#ifdef MS_WIN32
+static LARGE_INTEGER frequency = {0,0};
+#endif
+
+static unsigned long timeofday_diff = 0;
+static unsigned long rusage_diff = 0;
+
+static void
+calibrate(void)
+{
+    hs_time tv1, tv2;
+
+#ifdef MS_WIN32
+    LARGE_INTEGER diff;
+    QueryPerformanceFrequency(&frequency);
+#endif
+
+    GETTIMEOFDAY(&tv1);
+    while (1) {
+        GETTIMEOFDAY(&tv2);
+#ifdef MS_WIN32
+        diff = LargeIntegerSubtract(tv2, tv1);
+        if (!LargeIntegerEqualToZero(diff)) {
+            timeofday_diff = diff.LowPart;
+            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
+    }
+#ifdef MS_WIN32
+    rusage_diff = -1;
+#else
+    {
+        struct rusage ru1, 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;
+            }
+            else if (ru1.ru_utime.tv_usec != ru2.ru_utime.tv_usec) {
+                rusage_diff = ru2.ru_utime.tv_usec - ru1.ru_utime.tv_usec;
+                break;
+            }
+            else if (ru1.ru_stime.tv_sec != ru2.ru_stime.tv_sec) {
+                rusage_diff = ((1000000 - ru1.ru_stime.tv_usec)
+                               + ru2.ru_stime.tv_usec);
+                break;
+            }
+            else if (ru1.ru_stime.tv_usec != ru2.ru_stime.tv_usec) {
+                rusage_diff = ru2.ru_stime.tv_usec - ru1.ru_stime.tv_usec;
+                break;
+            }
+        }
+    }
+#endif
+}
+
+static void
+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) profiler_callback, (PyObject *)self);
+}
+
+static void
+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);
+    }
+}
+
+static int
+is_available(ProfilerObject *self)
+{
+    if (self->active) {
+        PyErr_SetString(ProfilerError, "profiler already active");
+        return 0;
+    }
+    if (self->logfp == NULL) {
+        PyErr_SetString(ProfilerError, "profiler already closed");
+        return 0;
+    }
+    return 1;
+}
+
+
+/* Profiler object interface methods. */
+
+static char close__doc__[] = "\
+close()\n\
+Shut down this profiler and close the log files, even if its active.";
+
+static PyObject *
+profiler_close(ProfilerObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+
+    if (PyArg_ParseTuple(args, ":close")) {
+        do_stop(self);
+        if (self->logfp != NULL) {
+            fclose(self->logfp);
+            self->logfp = NULL;
+        }
+        Py_INCREF(Py_None);
+        result = Py_None;
+    }
+    return result;
+}
+
+static char runcall__doc__[] = "\
+runcall(callable[, args[, kw]]) -> callable()\n\
+Profile a specific function call, returning the result of that call.";
+
+static PyObject *
+profiler_runcall(ProfilerObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+    PyObject *callargs = NULL;
+    PyObject *callkw = NULL;
+    PyObject *callable;
+
+    if (PyArg_ParseTuple(args, "O|OO:runcall",
+                         &callable, &callargs, &callkw)) {
+        if (is_available(self)) {
+            do_start(self);
+            result = PyEval_CallObjectWithKeywords(callable, callargs, callkw);
+            do_stop(self);
+        }
+    }
+    return result;
+}
+
+static char runcode__doc__[] = "\
+runcode(code, globals[, locals])\n\
+Execute a code object while collecting profile data.  If locals is omitted,\n\
+globals is used for the locals as well.";
+
+static PyObject *
+profiler_runcode(ProfilerObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+    PyCodeObject *code;
+    PyObject *globals;
+    PyObject *locals = NULL;
+
+    if (PyArg_ParseTuple(args, "O!O!|O:runcode",
+                         &PyCode_Type, &code,
+                         &PyDict_Type, &globals,
+                         &locals)) {
+        if (is_available(self)) {
+            if (locals == NULL || locals == Py_None)
+                locals = globals;
+            else if (!PyDict_Check(locals)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "locals must be a dictionary or None");
+                return NULL;
+            }
+            do_start(self);
+            result = PyEval_EvalCode(code, globals, locals);
+            do_stop(self);
+#if 0
+            if (!PyErr_Occurred()) {
+                result = Py_None;
+                Py_INCREF(result);
+            }
+#endif
+        }
+    }
+    return result;
+}
+
+static char start__doc__[] = "\
+start()\n\
+Install this profiler for the current thread.";
+
+static PyObject *
+profiler_start(ProfilerObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+
+    if (PyArg_ParseTuple(args, ":start")) {
+        if (is_available(self))
+            do_start(self);
+    }
+    return result;
+}
+
+static char stop__doc__[] = "\
+stop()\n\
+Remove this profiler from the current thread.";
+
+static PyObject *
+profiler_stop(ProfilerObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+
+    if (PyArg_ParseTuple(args, ":stop")) {
+        if (!self->active)
+            PyErr_SetString(ProfilerError, "profiler not active");
+        else
+            do_stop(self);
+    }
+    return result;
+}
+
+
+/* Python API support. */
+
+static void
+profiler_dealloc(ProfilerObject *self)
+{
+    do_stop(self);
+    if (self->logfp != NULL)
+        fclose(self->logfp);
+    Py_XDECREF(self->filemap);
+    Py_XDECREF(self->logfilename);
+    PyObject_Del((PyObject *)self);
+}
+
+/* Always use METH_VARARGS even though some of these could be METH_NOARGS;
+ * this allows us to maintain compatibility with Python versions < 2.2
+ * more easily, requiring only the changes to the dispatcher to be made.
+ */
+static PyMethodDef profiler_methods[] = {
+    {"close",   (PyCFunction)profiler_close,   METH_VARARGS, close__doc__},
+    {"runcall", (PyCFunction)profiler_runcall, METH_VARARGS, runcall__doc__},
+    {"runcode", (PyCFunction)profiler_runcode, METH_VARARGS, runcode__doc__},
+    {"start",   (PyCFunction)profiler_start,   METH_VARARGS, start__doc__},
+    {"stop",    (PyCFunction)profiler_stop,    METH_VARARGS, stop__doc__},
+    {NULL, NULL}
+};
+
+/* Use a table even though there's only one "simple" member; this allows
+ * __members__ and therefore dir() to work.
+ */
+static struct memberlist profiler_members[] = {
+    {"callcount",   T_LONG, offsetof(ProfilerObject, callcount), READONLY},
+    {"closed",      T_INT,  -1, READONLY},
+    {"lineevents",  T_LONG, offsetof(ProfilerObject, lineevents), READONLY},
+    {"linetimings", T_LONG, offsetof(ProfilerObject, linetimings), READONLY},
+    {NULL}
+};
+
+static PyObject *
+profiler_getattr(ProfilerObject *self, char *name)
+{
+    PyObject *result;
+    if (strcmp(name, "closed") == 0) {
+        result = (self->logfp == NULL) ? Py_True : Py_False;
+        Py_INCREF(result);
+    }
+    else {
+        result = PyMember_Get((char *)self, profiler_members, name);
+        if (result == NULL) {
+            PyErr_Clear();
+            result = Py_FindMethod(profiler_methods, (PyObject *)self, name);
+        }
+    }
+    return result;
+}
+
+
+static char profiler_object__doc__[] = "\
+High-performance profiler object.\n\
+\n\
+Methods:\n\
+\n\
+close():     Stop the profiler and close the log files.\n\
+runcall():   Run a single function call with profiling enabled.\n\
+runcode():   Execute a code object with profiling enabled.\n\
+start():     Install the profiler and return.\n\
+stop():      Remove the profiler.\n\
+\n\
+Attributes (read-only):\n\
+\n\
+callcount:   The number of low-level calls to the profiler.\n\
+closed:      True if the profiler has already been closed.\n\
+lineevents:  True if SET_LINENO events are reported to the profiler.\n\
+linetimings: True if SET_LINENO events collect timing information.";
+
+static PyTypeObject ProfilerType = {
+    PyObject_HEAD_INIT(NULL)
+    0,					/* ob_size		*/
+    "HotShot-profiler",			/* tp_name		*/
+    (int) sizeof(ProfilerObject),	/* tp_basicsize		*/
+    0,					/* tp_itemsize		*/
+    (destructor)profiler_dealloc,	/* tp_dealloc		*/
+    0,					/* tp_print		*/
+    (getattrfunc)profiler_getattr,	/* tp_getattr		*/
+    0,					/* tp_setattr		*/
+    0,					/* tp_compare		*/
+    0,					/* tp_repr		*/
+    0,					/* tp_as_number		*/
+    0,					/* tp_as_sequence	*/
+    0,					/* tp_as_mapping	*/
+    0,					/* tp_hash		*/
+    0,					/* tp_call		*/
+    0,					/* tp_str		*/
+    0,					/* tp_getattro		*/
+    0,					/* tp_setattro		*/
+    0,					/* tp_as_buffer		*/
+    0,					/* tp_flags		*/
+    profiler_object__doc__,		/* tp_doc		*/
+};
+
+
+static PyMethodDef logreader_methods[] = {
+    {"close",   (PyCFunction)logreader_close,  METH_VARARGS,
+     logreader_close__doc__},
+    {"next",    (PyCFunction)logreader_next,   METH_VARARGS,
+     next__doc__},
+    {NULL, NULL}
+};
+
+static PyObject *
+logreader_getattr(ProfilerObject *self, char *name)
+{
+    return Py_FindMethod(logreader_methods, (PyObject *)self, name);
+}
+
+
+static char logreader__doc__[] = "\
+logreader(filename) --> log-iterator\n\
+Create a log-reader for the timing information file.";
+
+static PySequenceMethods logreader_as_sequence = {
+    0,					/* sq_length */
+    0,					/* sq_concat */
+    0,					/* sq_repeat */
+    (intargfunc)logreader_sq_item,	/* sq_item */
+    0,					/* sq_slice */
+    0,					/* sq_ass_item */
+    0,					/* sq_ass_slice */
+    0,					/* sq_contains */
+    0,					/* sq_inplace_concat */
+    0,					/* sq_inplace_repeat */
+};
+
+static PyTypeObject LogReaderType = {
+    PyObject_HEAD_INIT(NULL)
+    0,					/* ob_size		*/
+    "HotShot-logreader",		/* tp_name		*/
+    (int) sizeof(LogReaderObject),	/* tp_basicsize		*/
+    0,					/* tp_itemsize		*/
+    (destructor)logreader_dealloc,	/* tp_dealloc		*/
+    0,					/* tp_print		*/
+    (getattrfunc)logreader_getattr,	/* tp_getattr		*/
+    0,					/* tp_setattr		*/
+    0,					/* tp_compare		*/
+    0,					/* tp_repr		*/
+    0,					/* tp_as_number		*/
+    &logreader_as_sequence,		/* tp_as_sequence	*/
+    0,					/* tp_as_mapping	*/
+    0,					/* tp_hash		*/
+    0,					/* tp_call		*/
+    0,					/* tp_str		*/
+    0,					/* tp_getattro		*/
+    0,					/* tp_setattro		*/
+    0,					/* tp_as_buffer		*/
+    0,					/* tp_flags		*/
+    logreader__doc__,			/* tp_doc		*/
+#if Py_TPFLAGS_HAVE_ITER
+    0,					/* tp_traverse		*/
+    0,					/* tp_clear		*/
+    0,					/* tp_richcompare	*/
+    0,					/* tp_weaklistoffset	*/
+    (getiterfunc)logreader_tp_iter,	/* tp_iter		*/
+    (iternextfunc)logreader_tp_iternext,/* tp_iternext		*/
+#endif
+};
+
+static PyObject *
+hotshot_logreader(PyObject *unused, PyObject *args)
+{
+    LogReaderObject *self = NULL;
+    char *filename;
+
+    if (PyArg_ParseTuple(args, "s:logreader", &filename)) {
+        self = PyObject_New(LogReaderObject, &LogReaderType);
+        if (self != NULL) {
+            self->filled = 0;
+            self->index = 0;
+            self->linetimings = 0;
+            self->logfp = fopen(filename, "rb");
+            if (self->logfp == NULL) {
+                PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
+                Py_DECREF(self);
+                self = NULL;
+            }
+        }
+    }
+    return (PyObject *) self;
+}
+
+
+/* Return a Python string that represents the version number without the
+ * extra cruft added by revision control, even if the right options were
+ * given to the "cvs export" command to make it not include the extra
+ * cruft.
+ */
+static char *
+get_version_string(void)
+{
+    static char *rcsid = "$Revision$";
+    char *rev = rcsid;
+    char *buffer;
+    int i = 0;
+
+    while (*rev && !isdigit(*rev))
+        ++rev;
+    while (rev[i] != ' ' && rev[i] != '\0')
+        ++i;
+    buffer = malloc(i + 1);
+    if (buffer != NULL) {
+        memmove(buffer, rev, i);
+        buffer[i] = '\0';
+    }
+    return buffer;
+}
+
+/* Write out a RFC 822-style header with various useful bits of
+ * information to make the output easier to manage.
+ */
+static int
+write_header(ProfilerObject *self)
+{
+    char *buffer;
+    char cwdbuffer[PATH_MAX];
+    PyObject *temp;
+    int i, len;
+
+    buffer = get_version_string();
+    if (buffer == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    pack_add_info(self, "HotShot-Version", buffer);
+    pack_add_info(self, "Requested-Line-Events",
+                  (self->lineevents ? "yes" : "no"));
+    pack_add_info(self, "Platform", Py_GetPlatform());
+    pack_add_info(self, "Executable", Py_GetProgramFullPath());
+    buffer = (char *) Py_GetVersion();
+    if (buffer == NULL)
+        PyErr_Clear();
+    else
+        pack_add_info(self, "Executable-Version", buffer);
+
+#ifdef MS_WIN32
+    sprintf(cwdbuffer, "%I64d", frequency.QuadPart);
+    pack_add_info(self, "Reported-Performance-Frequency", cwdbuffer);
+#else
+    sprintf(cwdbuffer, "%lu", rusage_diff);
+    pack_add_info(self, "Observed-Interval-getrusage", cwdbuffer);
+    sprintf(cwdbuffer, "%lu", timeofday_diff);
+    pack_add_info(self, "Observed-Interval-gettimeofday", cwdbuffer);
+#endif
+    pack_line_times(self);
+
+    pack_add_info(self, "Current-Directory",
+                  getcwd(cwdbuffer, sizeof cwdbuffer));
+
+    temp = PySys_GetObject("path");
+    len = PyList_GET_SIZE(temp);
+    for (i = 0; i < len; ++i) {
+        PyObject *item = PyList_GET_ITEM(temp, i);
+        buffer = PyString_AsString(item);
+        if (buffer == NULL)
+            return -1;
+        pack_add_info(self, "Sys-Path-Entry", buffer);
+    }
+    return 0;
+}
+
+static char profiler__doc__[] = "\
+profiler(logfilename[, lineevents[, linetimes]]) -> profiler\n\
+Create a new profiler object.";
+
+static PyObject *
+hotshot_profiler(PyObject *unused, PyObject *args)
+{
+    char *logfilename;
+    ProfilerObject *self = NULL;
+    int lineevents = 0;
+    int linetimings = 1;
+
+    if (PyArg_ParseTuple(args, "s|ii:profiler", &logfilename,
+                         &lineevents, &linetimings)) {
+        self = PyObject_New(ProfilerObject, &ProfilerType);
+        if (self == NULL)
+            return NULL;
+        self->callcount = 0;
+        self->lineevents = lineevents ? 1 : 0;
+        self->linetimings = (lineevents && linetimings) ? 1 : 0;
+        self->index = 0;
+        self->active = 0;
+        self->next_fileno = 0;
+        self->logfp = NULL;        
+        self->logfilename = PyTuple_GET_ITEM(args, 0);
+        Py_INCREF(self->logfilename);
+        self->filemap = PyDict_New();
+        if (self->filemap == NULL) {
+            Py_DECREF(self);
+            return NULL;
+        }
+        self->logfp = fopen(logfilename, "wb");
+        if (self->logfp == NULL) {
+            Py_DECREF(self);
+            PyErr_SetFromErrnoWithFilename(PyExc_IOError, logfilename);
+            return NULL;
+        }
+        if (timeofday_diff == 0) {
+            /* Run this several times since sometimes the first
+             * doesn't give the lowest values, and we're really trying
+             * to determine the lowest.
+             */
+            calibrate();
+            calibrate();
+            calibrate();
+        }
+        if (write_header(self))
+            /* some error occurred, exception has been set */
+            self = NULL;
+    }
+    return (PyObject *) self;
+}
+
+static char resolution__doc__[] =
+#ifdef MS_WIN32
+"resolution() -> (performance-counter-ticks, update-frequency)\n\
+Return the resolution of the timer provided by the QueryPerformanceCounter()\n\
+function.  The first value is the smallest observed change, and the second\n\
+if the result of QueryPerformanceFrequency().";
+#else
+"resolution() -> (gettimeofday-usecs, getrusage-usecs)\n\
+Return the resolution of the timers provided by the gettimeofday() and\n\
+getrusage() system calls, or -1 if the call is not supported.";
+#endif
+
+static PyObject *
+hotshot_resolution(PyObject *unused, PyObject *args)
+{
+    PyObject *result = NULL;
+
+    if (PyArg_ParseTuple(args, ":resolution")) {
+        if (timeofday_diff == 0) {
+            calibrate();
+            calibrate();
+            calibrate();
+        }
+#ifdef MS_WIN32
+        result = Py_BuildValue("ii", timeofday_diff, frequency.LowPart);
+#else
+        result = Py_BuildValue("ii", timeofday_diff, rusage_diff);
+#endif
+    }
+    return result;
+}
+
+
+static PyMethodDef functions[] = {
+    {"profiler",   hotshot_profiler,   METH_VARARGS, profiler__doc__},
+    {"logreader",  hotshot_logreader,  METH_VARARGS, logreader__doc__},
+    {"resolution", hotshot_resolution, METH_VARARGS, resolution__doc__},
+    {NULL, NULL}
+};
+
+
+void
+init_hotshot(void)
+{
+    PyObject *module;
+
+    LogReaderType.ob_type = &PyType_Type;
+    ProfilerType.ob_type = &PyType_Type;
+    module = Py_InitModule("_hotshot", functions);
+    if (module != NULL) {
+        char *s = get_version_string();
+
+        PyModule_AddStringConstant(module, "__version__", s);
+        free(s);
+        Py_INCREF(&LogReaderType);
+        PyModule_AddObject(module, "LogReaderType",
+                           (PyObject *)&LogReaderType);
+        Py_INCREF(&ProfilerType);
+        PyModule_AddObject(module, "ProfilerType",
+                           (PyObject *)&ProfilerType);
+
+        if (ProfilerError == NULL)
+            ProfilerError = PyErr_NewException("hotshot.ProfilerError",
+                                               NULL, NULL);
+        if (ProfilerError != NULL) {
+            Py_INCREF(ProfilerError);
+            PyModule_AddObject(module, "ProfilerError", ProfilerError);
+        }
+        PyModule_AddIntConstant(module, "WHAT_ENTER", WHAT_ENTER);
+        PyModule_AddIntConstant(module, "WHAT_EXIT", WHAT_EXIT);
+        PyModule_AddIntConstant(module, "WHAT_LINENO", WHAT_LINENO);
+        PyModule_AddIntConstant(module, "WHAT_OTHER", WHAT_OTHER);
+        PyModule_AddIntConstant(module, "WHAT_ADD_INFO", WHAT_ADD_INFO);
+        PyModule_AddIntConstant(module, "WHAT_DEFINE_FILE", WHAT_DEFINE_FILE);
+        PyModule_AddIntConstant(module, "WHAT_LINE_TIMES", WHAT_LINE_TIMES);
+    }
+}