--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Modules/_hotshot.c Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,1645 @@
+/*
+ * 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.
+ */
+#ifdef MS_WINDOWS
+#include <windows.h>
+
+#ifdef HAVE_DIRECT_H
+#include <direct.h> /* for getcwd() */
+#endif
+
+typedef __int64 hs_time;
+#define GETTIMEOFDAY(P_HS_TIME) \
+ { LARGE_INTEGER _temp; \
+ QueryPerformanceCounter(&_temp); \
+ *(P_HS_TIME) = _temp.QuadPart; }
+
+
+#else
+#ifndef HAVE_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
+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
+
+#if defined(PYOS_OS2) && defined(PYCC_GCC)
+#define PATH_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) */
+#define PATH_MAX 1024
+#endif
+
+#ifndef PATH_MAX
+# ifdef MAX_PATH
+# define PATH_MAX MAX_PATH
+# elif defined (_POSIX_PATH_MAX)
+# define PATH_MAX _POSIX_PATH_MAX
+# else
+# error "Need a defn. for PATH_MAX in _hotshot.c"
+# endif
+#endif
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *filemap;
+ PyObject *logfilename;
+ Py_ssize_t index;
+ unsigned char buffer[BUFFERSIZE];
+ FILE *logfp;
+ int lineevents;
+ int linetimings;
+ int frametimings;
+ /* size_t filled; */
+ int active;
+ int next_fileno;
+ hs_time prev_timeofday;
+} ProfilerObject;
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *info;
+ FILE *logfp;
+ int linetimings;
+ int frametimings;
+} LogReaderObject;
+
+static PyObject * ProfilerError = NULL;
+
+
+#ifndef MS_WINDOWS
+#ifdef GETTIMEOFDAY_NO_TZ
+#define GETTIMEOFDAY(ptv) gettimeofday((ptv))
+#else
+#define GETTIMEOFDAY(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.");
+
+static PyObject *
+logreader_close(LogReaderObject *self, PyObject *args)
+{
+ if (self->logfp != NULL) {
+ fclose(self->logfp);
+ self->logfp = NULL;
+ }
+ Py_INCREF(Py_None);
+
+ return Py_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.");
+
+static PyObject *
+logreader_fileno(LogReaderObject *self)
+{
+ if (self->logfp == NULL) {
+ PyErr_SetString(PyExc_ValueError,
+ "logreader's file object already closed");
+ return NULL;
+ }
+ return PyInt_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
+ */
+
+#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 WHAT_DEFINE_FUNC 0x43
+#define WHAT_FRAME_TIMES 0x53
+
+#define ERR_NONE 0
+#define ERR_EOF -1
+#define ERR_EXCEPTION -2
+#define ERR_BAD_RECTYPE -3
+
+#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 c;
+ int accum = 0;
+ int bits = 0;
+ int cont;
+
+ do {
+ /* read byte */
+ if ((c = fgetc(self->logfp)) == EOF)
+ return ERR_EOF;
+ accum |= ((c & 0x7F) >> discard) << bits;
+ bits += (7 - discard);
+ cont = c & 0x80;
+ discard = 0;
+ } while (cont);
+
+ *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 i;
+ int len;
+ int err;
+ int ch;
+ char *buf;
+
+ if ((err = unpack_packed_int(self, &len, 0)))
+ return err;
+
+ buf = (char *)malloc(len);
+ if (!buf) {
+ PyErr_NoMemory();
+ return ERR_EXCEPTION;
+ }
+
+ for (i=0; i < len; i++) {
+ ch = fgetc(self->logfp);
+ buf[i] = ch;
+ if (ch == EOF) {
+ free(buf);
+ return ERR_EOF;
+ }
+ }
+ *pvalue = PyString_FromStringAndSize(buf, len);
+ free(buf);
+ if (*pvalue == NULL) {
+ return ERR_EXCEPTION;
+ }
+ return 0;
+}
+
+
+static int
+unpack_add_info(LogReaderObject *self)
+{
+ PyObject *key;
+ PyObject *value = NULL;
+ int err;
+
+ err = unpack_string(self, &key);
+ if (!err) {
+ err = unpack_string(self, &value);
+ if (err)
+ Py_DECREF(key);
+ else {
+ PyObject *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);
+ return err;
+}
+
+
+static void
+eof_error(LogReaderObject *self)
+{
+ fclose(self->logfp);
+ self->logfp = NULL;
+ PyErr_SetString(PyExc_EOFError,
+ "end of file with incomplete profile record");
+}
+
+static PyObject *
+logreader_tp_iternext(LogReaderObject *self)
+{
+ int c;
+ int what;
+ 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:
+ /* decode the record type */
+ if ((c = fgetc(self->logfp)) == EOF) {
+ fclose(self->logfp);
+ self->logfp = NULL;
+ return NULL;
+ }
+ 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) {
+ case WHAT_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;
+ 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_add_info(self);
+ 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_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;
+ case WHAT_LINE_TIMES:
+ if ((c = fgetc(self->logfp)) == EOF)
+ err = ERR_EOF;
+ else {
+ self->linetimings = c ? 1 : 0;
+ goto restart;
+ }
+ break;
+ case WHAT_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");
+ }
+ else if (err == ERR_EOF) {
+ eof_error(self);
+ }
+ else if (!err) {
+ result = PyTuple_New(4);
+ if (result == NULL)
+ return NULL;
+ 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.
+ */
+#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;
+ }
+ Py_XDECREF(self->info);
+ PyObject_Del(self);
+}
+
+static PyObject *
+logreader_sq_item(LogReaderObject *self, Py_ssize_t 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 void
+do_stop(ProfilerObject *self);
+
+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 == (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;
+ }
+ }
+ return 0;
+}
+
+static inline int
+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);
+ return 0;
+}
+
+/* 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 int
+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++;
+ return pack_packed_int(self, value >> bits);
+ }
+ self->buffer[self->index] = b;
+ self->index++;
+ return 0;
+}
+
+static int
+pack_string(ProfilerObject *self, const char *s, Py_ssize_t len)
+{
+ if (len + PISIZE + self->index >= BUFFERSIZE) {
+ if (flush_data(self) < 0)
+ 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;
+ return 0;
+}
+
+static int
+pack_add_info(ProfilerObject *self, const char *s1, const char *s2)
+{
+ Py_ssize_t len1 = strlen(s1);
+ Py_ssize_t len2 = 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;
+ return pack_string(self, s2, len2);
+}
+
+static int
+pack_define_file(ProfilerObject *self, int fileno, const char *filename)
+{
+ Py_ssize_t len = 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;
+ return pack_string(self, filename, len);
+}
+
+static int
+pack_define_func(ProfilerObject *self, int fileno, int lineno,
+ const char *funcname)
+{
+ Py_ssize_t len = 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;
+ return pack_string(self, funcname, len);
+}
+
+static int
+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;
+ return 0;
+}
+
+static int
+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;
+ return 0;
+}
+
+static inline int
+pack_enter(ProfilerObject *self, int fileno, int tdelta, int lineno)
+{
+ 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)
+ return pack_packed_int(self, tdelta);
+ else
+ return 0;
+}
+
+static inline int
+pack_exit(ProfilerObject *self, int tdelta)
+{
+ if (MPISIZE + self->index >= BUFFERSIZE) {
+ if (flush_data(self) < 0)
+ return -1;
+ }
+ if (self->frametimings)
+ return pack_modified_packed_int(self, tdelta, 2, WHAT_EXIT);
+ self->buffer[self->index] = WHAT_EXIT;
+ self->index++;
+ return 0;
+}
+
+static inline int
+pack_lineno(ProfilerObject *self, int lineno)
+{
+ if (MPISIZE + self->index >= BUFFERSIZE) {
+ if (flush_data(self) < 0)
+ return -1;
+ }
+ return pack_modified_packed_int(self, lineno, 2, WHAT_LINENO);
+}
+
+static inline int
+pack_lineno_tdelta(ProfilerObject *self, int lineno, int tdelta)
+{
+ if (MPISIZE + PISIZE + self->index >= BUFFERSIZE) {
+ if (flush_data(self) < 0)
+ return 0;
+ }
+ if (pack_modified_packed_int(self, lineno, 2, WHAT_LINENO) < 0)
+ return -1;
+ return pack_packed_int(self, tdelta);
+}
+
+static inline int
+get_fileno(ProfilerObject *self, PyCodeObject *fcode)
+{
+ /* This is only used for ENTER events. */
+
+ PyObject *obj;
+ PyObject *dict;
+ int fileno;
+
+ 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);
+ }
+ return fileno;
+}
+
+static inline int
+get_tdelta(ProfilerObject *self)
+{
+ int tdelta;
+#ifdef MS_WINDOWS
+ hs_time tv;
+ hs_time diff;
+
+ GETTIMEOFDAY(&tv);
+ diff = tv - self->prev_timeofday;
+ tdelta = (int)diff;
+#else
+ struct timeval tv;
+
+ 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)
+ return 0;
+
+ self->prev_timeofday = tv;
+ return tdelta;
+}
+
+
+/* The workhorse: the profiler callback function. */
+
+static int
+tracer_callback(ProfilerObject *self, PyFrameObject *frame, int what,
+ PyObject *arg)
+{
+ int fileno;
+
+ switch (what) {
+ case PyTrace_CALL:
+ fileno = get_fileno(self, frame->f_code);
+ if (fileno < 0)
+ return -1;
+ return pack_enter(self, fileno,
+ self->frametimings ? get_tdelta(self) : -1,
+ frame->f_code->co_firstlineno);
+
+ case PyTrace_RETURN:
+ return pack_exit(self, get_tdelta(self));
+
+ case PyTrace_LINE: /* we only get these events if we asked for them */
+ if (self->linetimings)
+ return pack_lineno_tdelta(self, frame->f_lineno,
+ get_tdelta(self));
+ else
+ return pack_lineno(self, frame->f_lineno);
+
+ default:
+ /* ignore PyTrace_EXCEPTION */
+ break;
+ }
+ return 0;
+}
+
+
+/* A couple of useful helper functions. */
+
+#ifdef MS_WINDOWS
+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_WINDOWS
+ hs_time diff;
+ QueryPerformanceFrequency(&frequency);
+#endif
+
+ GETTIMEOFDAY(&tv1);
+ while (1) {
+ GETTIMEOFDAY(&tv2);
+#ifdef MS_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
+ {
+ 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) tracer_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. */
+
+PyDoc_STRVAR(addinfo__doc__,
+"addinfo(key, value)\n"
+"Insert an ADD_INFO record into the log.");
+
+static PyObject *
+profiler_addinfo(ProfilerObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+ char *key, *value;
+
+ if (PyArg_ParseTuple(args, "ss:addinfo", &key, &value)) {
+ if (self->logfp == NULL)
+ PyErr_SetString(ProfilerError, "profiler already closed");
+ else {
+ if (pack_add_info(self, key, value) == 0) {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ }
+ }
+ return result;
+}
+
+PyDoc_STRVAR(close__doc__,
+"close()\n"
+"Shut down this profiler and close the log files, even if its active.");
+
+static PyObject *
+profiler_close(ProfilerObject *self)
+{
+ do_stop(self);
+ if (self->logfp != NULL) {
+ fclose(self->logfp);
+ self->logfp = NULL;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+#define fileno__doc__ logreader_fileno__doc__
+
+static PyObject *
+profiler_fileno(ProfilerObject *self)
+{
+ if (self->logfp == NULL) {
+ PyErr_SetString(PyExc_ValueError,
+ "profiler's file object already closed");
+ return NULL;
+ }
+ return PyInt_FromLong(fileno(self->logfp));
+}
+
+PyDoc_STRVAR(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_UnpackTuple(args, "runcall", 1, 3,
+ &callable, &callargs, &callkw)) {
+ if (is_available(self)) {
+ do_start(self);
+ result = PyEval_CallObjectWithKeywords(callable, callargs, callkw);
+ do_stop(self);
+ }
+ }
+ return result;
+}
+
+PyDoc_STRVAR(runcode__doc__,
+"runcode(code, globals[, locals])\n"
+"Execute a code object while collecting profile data. If locals is\n"
+"omitted, 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;
+}
+
+PyDoc_STRVAR(start__doc__,
+"start()\n"
+"Install this profiler for the current thread.");
+
+static PyObject *
+profiler_start(ProfilerObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+
+ if (is_available(self)) {
+ do_start(self);
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ return result;
+}
+
+PyDoc_STRVAR(stop__doc__,
+"stop()\n"
+"Remove this profiler from the current thread.");
+
+static PyObject *
+profiler_stop(ProfilerObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+
+ if (!self->active)
+ PyErr_SetString(ProfilerError, "profiler not active");
+ else {
+ do_stop(self);
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ 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);
+}
+
+static PyMethodDef profiler_methods[] = {
+ {"addinfo", (PyCFunction)profiler_addinfo, METH_VARARGS, addinfo__doc__},
+ {"close", (PyCFunction)profiler_close, METH_NOARGS, close__doc__},
+ {"fileno", (PyCFunction)profiler_fileno, METH_NOARGS, fileno__doc__},
+ {"runcall", (PyCFunction)profiler_runcall, METH_VARARGS, runcall__doc__},
+ {"runcode", (PyCFunction)profiler_runcode, METH_VARARGS, runcode__doc__},
+ {"start", (PyCFunction)profiler_start, METH_NOARGS, start__doc__},
+ {"stop", (PyCFunction)profiler_stop, METH_NOARGS, stop__doc__},
+ {NULL, NULL}
+};
+
+static PyMemberDef profiler_members[] = {
+ {"frametimings", T_LONG, offsetof(ProfilerObject, linetimings), READONLY},
+ {"lineevents", T_LONG, offsetof(ProfilerObject, lineevents), READONLY},
+ {"linetimings", T_LONG, offsetof(ProfilerObject, linetimings), READONLY},
+ {NULL}
+};
+
+static PyObject *
+profiler_get_closed(ProfilerObject *self, void *closure)
+{
+ PyObject *result = (self->logfp == NULL) ? Py_True : Py_False;
+ Py_INCREF(result);
+ return result;
+}
+
+static PyGetSetDef profiler_getsets[] = {
+ {"closed", (getter)profiler_get_closed, NULL,
+ PyDoc_STR("True if the profiler's output file has already been closed.")},
+ {NULL}
+};
+
+
+PyDoc_STRVAR(profiler_object__doc__,
+"High-performance profiler object.\n"
+"\n"
+"Methods:\n"
+"\n"
+"close(): Stop the profiler and close the log files.\n"
+"fileno(): Returns the file descriptor of the log file.\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"
+"closed: True if the profiler has already been closed.\n"
+"frametimings: True if ENTER/EXIT events collect timing information.\n"
+"lineevents: True if line events are reported to the profiler.\n"
+"linetimings: True if line events collect timing information.");
+
+static PyTypeObject ProfilerType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "_hotshot.ProfilerType", /* tp_name */
+ (int) sizeof(ProfilerObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)profiler_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* 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 */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ profiler_object__doc__, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ profiler_methods, /* tp_methods */
+ profiler_members, /* tp_members */
+ profiler_getsets, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+};
+
+
+static PyMethodDef logreader_methods[] = {
+ {"close", (PyCFunction)logreader_close, METH_NOARGS,
+ logreader_close__doc__},
+ {"fileno", (PyCFunction)logreader_fileno, METH_NOARGS,
+ logreader_fileno__doc__},
+ {NULL, NULL}
+};
+
+static PyMemberDef logreader_members[] = {
+ {"info", T_OBJECT, offsetof(LogReaderObject, info), RO,
+ PyDoc_STR("Dictionary mapping informational keys to lists of values.")},
+ {NULL}
+};
+
+
+PyDoc_STRVAR(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 */
+ (ssizeargfunc)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 PyObject *
+logreader_get_closed(LogReaderObject *self, void *closure)
+{
+ PyObject *result = (self->logfp == NULL) ? Py_True : Py_False;
+ Py_INCREF(result);
+ return result;
+}
+
+static PyGetSetDef logreader_getsets[] = {
+ {"closed", (getter)logreader_get_closed, NULL,
+ PyDoc_STR("True if the logreader's input file has already been closed.")},
+ {NULL}
+};
+
+static PyTypeObject LogReaderType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "_hotshot.LogReaderType", /* tp_name */
+ (int) sizeof(LogReaderObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)logreader_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* 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 */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ logreader__doc__, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ PyObject_SelfIter, /* tp_iter */
+ (iternextfunc)logreader_tp_iternext,/* tp_iternext */
+ logreader_methods, /* tp_methods */
+ logreader_members, /* tp_members */
+ logreader_getsets, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+};
+
+static PyObject *
+hotshot_logreader(PyObject *unused, PyObject *args)
+{
+ LogReaderObject *self = NULL;
+ char *filename;
+ int c;
+ int err = 0;
+
+ if (PyArg_ParseTuple(args, "s:logreader", &filename)) {
+ self = PyObject_New(LogReaderObject, &LogReaderType);
+ if (self != NULL) {
+ self->frametimings = 1;
+ self->linetimings = 0;
+ self->info = NULL;
+ self->logfp = fopen(filename, "rb");
+ if (self->logfp == NULL) {
+ PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
+ Py_DECREF(self);
+ self = NULL;
+ goto finally;
+ }
+ self->info = PyDict_New();
+ if (self->info == NULL) {
+ Py_DECREF(self);
+ goto finally;
+ }
+ /* read initial info */
+ for (;;) {
+ if ((c = fgetc(self->logfp)) == EOF) {
+ eof_error(self);
+ break;
+ }
+ if (c != WHAT_ADD_INFO) {
+ ungetc(c, self->logfp);
+ break;
+ }
+ err = unpack_add_info(self);
+ if (err) {
+ if (err == ERR_EOF)
+ eof_error(self);
+ else
+ PyErr_SetString(PyExc_RuntimeError,
+ "unexpected error");
+ break;
+ }
+ }
+ }
+ }
+ finally:
+ 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: 64048 $";
+ char *rev = rcsid;
+ char *buffer;
+ int i = 0;
+
+ while (*rev && !isdigit(Py_CHARMASK(*rev)))
+ ++rev;
+ while (rev[i] != ' ' && rev[i] != '\0')
+ ++i;
+ buffer = (char *)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;
+ Py_ssize_t 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-frame-timings",
+ (self->frametimings ? "yes" : "no"));
+ pack_add_info(self, "requested-line-events",
+ (self->lineevents ? "yes" : "no"));
+ pack_add_info(self, "requested-line-timings",
+ (self->linetimings ? "yes" : "no"));
+ pack_add_info(self, "platform", Py_GetPlatform());
+ pack_add_info(self, "executable", Py_GetProgramFullPath());
+ free(buffer);
+ buffer = (char *) Py_GetVersion();
+ if (buffer == NULL)
+ PyErr_Clear();
+ else
+ pack_add_info(self, "executable-version", buffer);
+
+#ifdef MS_WINDOWS
+ PyOS_snprintf(cwdbuffer, sizeof(cwdbuffer), "%I64d", frequency.QuadPart);
+ pack_add_info(self, "reported-performance-frequency", cwdbuffer);
+#else
+ PyOS_snprintf(cwdbuffer, sizeof(cwdbuffer), "%lu", rusage_diff);
+ pack_add_info(self, "observed-interval-getrusage", cwdbuffer);
+ PyOS_snprintf(cwdbuffer, sizeof(cwdbuffer), "%lu", timeofday_diff);
+ pack_add_info(self, "observed-interval-gettimeofday", cwdbuffer);
+#endif
+
+ pack_add_info(self, "current-directory",
+ getcwd(cwdbuffer, sizeof cwdbuffer));
+
+ temp = PySys_GetObject("path");
+ if (temp == NULL || !PyList_Check(temp)) {
+ PyErr_SetString(PyExc_RuntimeError, "sys.path must be a list");
+ return -1;
+ }
+ 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) {
+ pack_add_info(self, "sys-path-entry", "<non-string-path-entry>");
+ PyErr_Clear();
+ }
+ else {
+ pack_add_info(self, "sys-path-entry", buffer);
+ }
+ }
+ pack_frame_times(self);
+ pack_line_times(self);
+
+ return 0;
+}
+
+PyDoc_STRVAR(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->frametimings = 1;
+ 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 */
+ Py_DECREF(self);
+ self = NULL;
+ }
+ }
+ return (PyObject *) self;
+}
+
+PyDoc_STRVAR(coverage__doc__,
+"coverage(logfilename) -> profiler\n\
+Returns a profiler that doesn't collect any timing information, which is\n\
+useful in building a coverage analysis tool.");
+
+static PyObject *
+hotshot_coverage(PyObject *unused, PyObject *args)
+{
+ char *logfilename;
+ PyObject *result = NULL;
+
+ if (PyArg_ParseTuple(args, "s:coverage", &logfilename)) {
+ result = hotshot_profiler(unused, args);
+ if (result != NULL) {
+ ProfilerObject *self = (ProfilerObject *) result;
+ self->frametimings = 0;
+ self->linetimings = 0;
+ self->lineevents = 1;
+ }
+ }
+ return result;
+}
+
+PyDoc_VAR(resolution__doc__) =
+#ifdef MS_WINDOWS
+PyDoc_STR(
+"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"
+"is the result of QueryPerformanceFrequency()."
+)
+#else
+PyDoc_STR(
+"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 *self, PyObject *unused)
+{
+ if (timeofday_diff == 0) {
+ calibrate();
+ calibrate();
+ calibrate();
+ }
+#ifdef MS_WINDOWS
+ return Py_BuildValue("ii", timeofday_diff, frequency.LowPart);
+#else
+ return Py_BuildValue("ii", timeofday_diff, rusage_diff);
+#endif
+}
+
+
+static PyMethodDef functions[] = {
+ {"coverage", hotshot_coverage, METH_VARARGS, coverage__doc__},
+ {"profiler", hotshot_profiler, METH_VARARGS, profiler__doc__},
+ {"logreader", hotshot_logreader, METH_VARARGS, logreader__doc__},
+ {"resolution", hotshot_resolution, METH_NOARGS, resolution__doc__},
+ {NULL, NULL}
+};
+
+
+void
+init_hotshot(void)
+{
+ PyObject *module;
+
+ Py_TYPE(&LogReaderType) = &PyType_Type;
+ Py_TYPE(&ProfilerType) = &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_DEFINE_FUNC", WHAT_DEFINE_FUNC);
+ PyModule_AddIntConstant(module, "WHAT_LINE_TIMES", WHAT_LINE_TIMES);
+ }
+}