mirror of
https://github.com/python/cpython.git
synced 2025-10-31 10:26:02 +00:00
5b222135f8
This affects the parser, various object implementations, and all places that put identifiers into C string literals. In testing, a number of crashes occurred as code would fail when the recursion limit was reached (such as the Unicode interning dictionary having key/value pairs where key is not value). To solve these, I added an overflowed flag, which allows for 50 more recursions after the limit was reached and the exception was raised, and a recursion_critical flag, which indicates that recursion absolutely must be allowed, i.e. that a certain call must not cause a stack overflow exception. There are still some places where both str and str8 are accepted as identifiers; these should eventually be removed.
1647 lines
45 KiB
C
1647 lines
45 KiB
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.
|
|
*/
|
|
#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,
|
|
PyUnicode_AsString(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 = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /* ob_size */
|
|
"_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 = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /* ob_size */
|
|
"_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$";
|
|
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;
|
|
|
|
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_DEFINE_FUNC", WHAT_DEFINE_FUNC);
|
|
PyModule_AddIntConstant(module, "WHAT_LINE_TIMES", WHAT_LINE_TIMES);
|
|
}
|
|
}
|