1 #include "Python.h"

     2 #include "compile.h"

     3 #include "frameobject.h"

     4 #include "structseq.h"

     5 #include "rotatingtree.h"

     6 

     7 #if !defined(HAVE_LONG_LONG)

     8 #error "This module requires long longs!"

     9 #endif

    10 

    11 /*** Selection of a high-precision timer ***/

    12 

    13 #ifdef MS_WINDOWS

    14 

    15 #include <windows.h>

    16 

    17 static PY_LONG_LONG

    18 hpTimer(void)

    19 {

    20 	LARGE_INTEGER li;

    21 	QueryPerformanceCounter(&li);

    22 	return li.QuadPart;

    23 }

    24 

    25 static double

    26 hpTimerUnit(void)

    27 {

    28 	LARGE_INTEGER li;

    29 	if (QueryPerformanceFrequency(&li))

    30 		return 1.0 / li.QuadPart;

    31 	else

    32 		return 0.000001;  /* unlikely */

    33 }

    34 

    35 #else  /* !MS_WINDOWS */

    36 

    37 #ifndef HAVE_GETTIMEOFDAY

    38 #error "This module requires gettimeofday() on non-Windows platforms!"

    39 #endif

    40 

    41 #if (defined(PYOS_OS2) && defined(PYCC_GCC))

    42 #include <sys/time.h>

    43 #else

    44 #include <sys/resource.h>

    45 #include <sys/times.h>

    46 #endif

    47 

    48 static PY_LONG_LONG

    49 hpTimer(void)

    50 {

    51 	struct timeval tv;

    52 	PY_LONG_LONG ret;

    53 #ifdef GETTIMEOFDAY_NO_TZ

    54 	gettimeofday(&tv);

    55 #else

    56 	gettimeofday(&tv, (struct timezone *)NULL);

    57 #endif

    58 	ret = tv.tv_sec;

    59 	ret = ret * 1000000 + tv.tv_usec;

    60 	return ret;

    61 }

    62 

    63 static double

    64 hpTimerUnit(void)

    65 {

    66 	return 0.000001;

    67 }

    68 

    69 #endif  /* MS_WINDOWS */

    70 

    71 /************************************************************/

    72 /* Written by Brett Rosen and Ted Czotter */

    73 

    74 struct _ProfilerEntry;

    75 

    76 /* represents a function called from another function */

    77 typedef struct _ProfilerSubEntry {

    78 	rotating_node_t header;

    79 	PY_LONG_LONG tt;

    80 	PY_LONG_LONG it;

    81 	long callcount;

    82 	long recursivecallcount;

    83 	long recursionLevel;

    84 } ProfilerSubEntry;

    85 

    86 /* represents a function or user defined block */

    87 typedef struct _ProfilerEntry {

    88 	rotating_node_t header;

    89 	PyObject *userObj; /* PyCodeObject, or a descriptive str for builtins */

    90 	PY_LONG_LONG tt; /* total time in this entry */

    91 	PY_LONG_LONG it; /* inline time in this entry (not in subcalls) */

    92 	long callcount; /* how many times this was called */

    93 	long recursivecallcount; /* how many times called recursively */

    94 	long recursionLevel;

    95 	rotating_node_t *calls;

    96 } ProfilerEntry;

    97 

    98 typedef struct _ProfilerContext {

    99 	PY_LONG_LONG t0;

   100 	PY_LONG_LONG subt;

   101 	struct _ProfilerContext *previous;

   102 	ProfilerEntry *ctxEntry;

   103 } ProfilerContext;

   104 

   105 typedef struct {

   106 	PyObject_HEAD

   107 	rotating_node_t *profilerEntries;

   108 	ProfilerContext *currentProfilerContext;

   109 	ProfilerContext *freelistProfilerContext;

   110 	int flags;

   111 	PyObject *externalTimer;

   112 	double externalTimerUnit;

   113 } ProfilerObject;

   114 

   115 #define POF_ENABLED     0x001

   116 #define POF_SUBCALLS    0x002

   117 #define POF_BUILTINS    0x004

   118 #define POF_NOMEMORY    0x100

   119 

   120 staticforward PyTypeObject PyProfiler_Type;

   121 

   122 #define PyProfiler_Check(op) PyObject_TypeCheck(op, &PyProfiler_Type)

   123 #define PyProfiler_CheckExact(op) (Py_TYPE(op) == &PyProfiler_Type)

   124 

   125 /*** External Timers ***/

   126 

   127 #define DOUBLE_TIMER_PRECISION   4294967296.0

   128 static PyObject *empty_tuple;

   129 

   130 static PY_LONG_LONG CallExternalTimer(ProfilerObject *pObj)

   131 {

   132 	PY_LONG_LONG result;

   133 	PyObject *o = PyObject_Call(pObj->externalTimer, empty_tuple, NULL);

   134 	if (o == NULL) {

   135 		PyErr_WriteUnraisable(pObj->externalTimer);

   136 		return 0;

   137 	}

   138 	if (pObj->externalTimerUnit > 0.0) {

   139 		/* interpret the result as an integer that will be scaled

   140 		   in profiler_getstats() */

   141 		result = PyLong_AsLongLong(o);

   142 	}

   143 	else {

   144 		/* interpret the result as a double measured in seconds.

   145 		   As the profiler works with PY_LONG_LONG internally

   146 		   we convert it to a large integer */

   147 		double val = PyFloat_AsDouble(o);

   148 		/* error handling delayed to the code below */

   149 		result = (PY_LONG_LONG) (val * DOUBLE_TIMER_PRECISION);

   150 	}

   151 	Py_DECREF(o);

   152 	if (PyErr_Occurred()) {

   153 		PyErr_WriteUnraisable(pObj->externalTimer);

   154 		return 0;

   155 	}

   156 	return result;

   157 }

   158 

   159 #define CALL_TIMER(pObj)	((pObj)->externalTimer ?		\

   160 					CallExternalTimer(pObj) :	\

   161 					hpTimer())

   162 

   163 /*** ProfilerObject ***/

   164 

   165 static PyObject *

   166 normalizeUserObj(PyObject *obj)

   167 {

   168 	PyCFunctionObject *fn;

   169 	if (!PyCFunction_Check(obj)) {

   170 		Py_INCREF(obj);

   171 		return obj;

   172 	}

   173 	/* Replace built-in function objects with a descriptive string

   174 	   because of built-in methods -- keeping a reference to

   175 	   __self__ is probably not a good idea. */

   176 	fn = (PyCFunctionObject *)obj;

   177 

   178 	if (fn->m_self == NULL) {

   179 		/* built-in function: look up the module name */

   180 		PyObject *mod = fn->m_module;

   181 		char *modname;

   182 		if (mod && PyString_Check(mod)) {

   183 			modname = PyString_AS_STRING(mod);

   184 		}

   185 		else if (mod && PyModule_Check(mod)) {

   186 			modname = PyModule_GetName(mod);

   187 			if (modname == NULL) {

   188 				PyErr_Clear();

   189 				modname = "__builtin__";

   190 			}

   191 		}

   192 		else {

   193 			modname = "__builtin__";

   194 		}

   195 		if (strcmp(modname, "__builtin__") != 0)

   196 			return PyString_FromFormat("<%s.%s>",

   197 						   modname,

   198 						   fn->m_ml->ml_name);

   199 		else

   200 			return PyString_FromFormat("<%s>",

   201 						   fn->m_ml->ml_name);

   202 	}

   203 	else {

   204 		/* built-in method: try to return

   205 			repr(getattr(type(__self__), __name__))

   206 		*/

   207 		PyObject *self = fn->m_self;

   208 		PyObject *name = PyString_FromString(fn->m_ml->ml_name);

   209 		if (name != NULL) {

   210 			PyObject *mo = _PyType_Lookup(Py_TYPE(self), name);

   211 			Py_XINCREF(mo);

   212 			Py_DECREF(name);

   213 			if (mo != NULL) {

   214 				PyObject *res = PyObject_Repr(mo);

   215 				Py_DECREF(mo);

   216 				if (res != NULL)

   217 					return res;

   218 			}

   219 		}

   220 		PyErr_Clear();

   221 		return PyString_FromFormat("<built-in method %s>",

   222 					   fn->m_ml->ml_name);

   223 	}

   224 }

   225 

   226 static ProfilerEntry*

   227 newProfilerEntry(ProfilerObject *pObj, void *key, PyObject *userObj)

   228 {

   229 	ProfilerEntry *self;

   230 	self = (ProfilerEntry*) malloc(sizeof(ProfilerEntry));

   231 	if (self == NULL) {

   232 		pObj->flags |= POF_NOMEMORY;

   233 		return NULL;

   234 	}

   235 	userObj = normalizeUserObj(userObj);

   236 	if (userObj == NULL) {

   237 		PyErr_Clear();

   238 		free(self);

   239 		pObj->flags |= POF_NOMEMORY;

   240 		return NULL;

   241 	}

   242 	self->header.key = key;

   243 	self->userObj = userObj;

   244 	self->tt = 0;

   245 	self->it = 0;

   246 	self->callcount = 0;

   247 	self->recursivecallcount = 0;

   248 	self->recursionLevel = 0;

   249 	self->calls = EMPTY_ROTATING_TREE;

   250 	RotatingTree_Add(&pObj->profilerEntries, &self->header);

   251 	return self;

   252 }

   253 

   254 static ProfilerEntry*

   255 getEntry(ProfilerObject *pObj, void *key)

   256 {

   257 	return (ProfilerEntry*) RotatingTree_Get(&pObj->profilerEntries, key);

   258 }

   259 

   260 static ProfilerSubEntry * 

   261 getSubEntry(ProfilerObject *pObj, ProfilerEntry *caller, ProfilerEntry* entry)

   262 {

   263 	return (ProfilerSubEntry*) RotatingTree_Get(&caller->calls,

   264 						    (void *)entry);

   265 }

   266 

   267 static ProfilerSubEntry *

   268 newSubEntry(ProfilerObject *pObj,  ProfilerEntry *caller, ProfilerEntry* entry)

   269 {

   270 	ProfilerSubEntry *self;

   271 	self = (ProfilerSubEntry*) malloc(sizeof(ProfilerSubEntry));

   272 	if (self == NULL) {

   273 		pObj->flags |= POF_NOMEMORY;

   274 		return NULL;

   275 	}

   276 	self->header.key = (void *)entry;

   277 	self->tt = 0;

   278 	self->it = 0;

   279 	self->callcount = 0;

   280 	self->recursivecallcount = 0;

   281 	self->recursionLevel = 0;

   282 	RotatingTree_Add(&caller->calls, &self->header);

   283 	return self;

   284 }

   285 

   286 static int freeSubEntry(rotating_node_t *header, void *arg)

   287 {

   288 	ProfilerSubEntry *subentry = (ProfilerSubEntry*) header;

   289 	free(subentry);

   290 	return 0;

   291 }

   292 

   293 static int freeEntry(rotating_node_t *header, void *arg)

   294 {

   295 	ProfilerEntry *entry = (ProfilerEntry*) header;

   296 	RotatingTree_Enum(entry->calls, freeSubEntry, NULL);

   297 	Py_DECREF(entry->userObj);

   298 	free(entry);

   299 	return 0;

   300 }

   301 

   302 static void clearEntries(ProfilerObject *pObj)

   303 {

   304 	RotatingTree_Enum(pObj->profilerEntries, freeEntry, NULL);

   305 	pObj->profilerEntries = EMPTY_ROTATING_TREE;

   306 	/* release the memory hold by the free list of ProfilerContexts */

   307 	while (pObj->freelistProfilerContext) {

   308 		ProfilerContext *c = pObj->freelistProfilerContext;

   309 		pObj->freelistProfilerContext = c->previous;

   310 		free(c);

   311 	}

   312 }

   313 

   314 static void

   315 initContext(ProfilerObject *pObj, ProfilerContext *self, ProfilerEntry *entry)

   316 {

   317 	self->ctxEntry = entry;

   318 	self->subt = 0;

   319 	self->previous = pObj->currentProfilerContext;

   320 	pObj->currentProfilerContext = self;

   321 	++entry->recursionLevel;

   322 	if ((pObj->flags & POF_SUBCALLS) && self->previous) {

   323 		/* find or create an entry for me in my caller's entry */

   324 		ProfilerEntry *caller = self->previous->ctxEntry;

   325 		ProfilerSubEntry *subentry = getSubEntry(pObj, caller, entry);

   326 		if (subentry == NULL)

   327 			subentry = newSubEntry(pObj, caller, entry);

   328 		if (subentry)

   329 			++subentry->recursionLevel;

   330 	}

   331 	self->t0 = CALL_TIMER(pObj);

   332 }

   333 

   334 static void

   335 Stop(ProfilerObject *pObj, ProfilerContext *self, ProfilerEntry *entry)

   336 {

   337 	PY_LONG_LONG tt = CALL_TIMER(pObj) - self->t0;

   338 	PY_LONG_LONG it = tt - self->subt;

   339 	if (self->previous)

   340 		self->previous->subt += tt;

   341 	pObj->currentProfilerContext = self->previous;

   342 	if (--entry->recursionLevel == 0)

   343 		entry->tt += tt;

   344 	else

   345 		++entry->recursivecallcount;

   346 	entry->it += it;

   347 	entry->callcount++;

   348 	if ((pObj->flags & POF_SUBCALLS) && self->previous) {

   349 		/* find or create an entry for me in my caller's entry */

   350 		ProfilerEntry *caller = self->previous->ctxEntry;

   351 		ProfilerSubEntry *subentry = getSubEntry(pObj, caller, entry);

   352 		if (subentry) {

   353 			if (--subentry->recursionLevel == 0)

   354 				subentry->tt += tt;

   355 			else

   356 				++subentry->recursivecallcount;

   357 			subentry->it += it;

   358 			++subentry->callcount;

   359 		}

   360 	}

   361 }

   362 

   363 static void

   364 ptrace_enter_call(PyObject *self, void *key, PyObject *userObj)

   365 {

   366 	/* entering a call to the function identified by 'key'

   367 	   (which can be a PyCodeObject or a PyMethodDef pointer) */

   368 	ProfilerObject *pObj = (ProfilerObject*)self;

   369 	ProfilerEntry *profEntry;

   370 	ProfilerContext *pContext;

   371 

   372 	/* In the case of entering a generator expression frame via a

   373 	 * throw (gen_send_ex(.., 1)), we may already have an

   374 	 * Exception set here. We must not mess around with this

   375 	 * exception, and some of the code under here assumes that

   376 	 * PyErr_* is its own to mess around with, so we have to

   377 	 * save and restore any current exception. */

   378 	PyObject *last_type, *last_value, *last_tb;

   379 	PyErr_Fetch(&last_type, &last_value, &last_tb);

   380 

   381 	profEntry = getEntry(pObj, key);

   382 	if (profEntry == NULL) {

   383 		profEntry = newProfilerEntry(pObj, key, userObj);

   384 		if (profEntry == NULL)

   385 			goto restorePyerr;

   386 	}

   387 	/* grab a ProfilerContext out of the free list */

   388 	pContext = pObj->freelistProfilerContext;

   389 	if (pContext) {

   390 		pObj->freelistProfilerContext = pContext->previous;

   391 	}

   392 	else {

   393 		/* free list exhausted, allocate a new one */

   394 		pContext = (ProfilerContext*)

   395 			malloc(sizeof(ProfilerContext));

   396 		if (pContext == NULL) {

   397 			pObj->flags |= POF_NOMEMORY;

   398 			goto restorePyerr;

   399 		}

   400 	}

   401 	initContext(pObj, pContext, profEntry);

   402 

   403 restorePyerr:

   404 	PyErr_Restore(last_type, last_value, last_tb);

   405 }

   406 

   407 static void

   408 ptrace_leave_call(PyObject *self, void *key)

   409 {

   410 	/* leaving a call to the function identified by 'key' */

   411 	ProfilerObject *pObj = (ProfilerObject*)self;

   412 	ProfilerEntry *profEntry;

   413 	ProfilerContext *pContext;

   414 

   415 	pContext = pObj->currentProfilerContext;

   416 	if (pContext == NULL)

   417 		return;

   418 	profEntry = getEntry(pObj, key);

   419 	if (profEntry) {

   420 		Stop(pObj, pContext, profEntry);

   421 	}

   422 	else {

   423 		pObj->currentProfilerContext = pContext->previous;

   424 	}

   425 	/* put pContext into the free list */

   426 	pContext->previous = pObj->freelistProfilerContext;

   427 	pObj->freelistProfilerContext = pContext;

   428 }

   429 

   430 static int

   431 profiler_callback(PyObject *self, PyFrameObject *frame, int what,

   432 		  PyObject *arg)

   433 {

   434 	switch (what) {

   435 

   436 	/* the 'frame' of a called function is about to start its execution */

   437 	case PyTrace_CALL:

   438 		ptrace_enter_call(self, (void *)frame->f_code,

   439 				        (PyObject *)frame->f_code);

   440 		break;

   441 

   442 	/* the 'frame' of a called function is about to finish

   443 	   (either normally or with an exception) */

   444 	case PyTrace_RETURN:

   445 		ptrace_leave_call(self, (void *)frame->f_code);

   446 		break;

   447 

   448 	/* case PyTrace_EXCEPTION:

   449 		If the exception results in the function exiting, a

   450 		PyTrace_RETURN event will be generated, so we don't need to

   451 		handle it. */

   452 

   453 #ifdef PyTrace_C_CALL	/* not defined in Python <= 2.3 */

   454 	/* the Python function 'frame' is issuing a call to the built-in

   455 	   function 'arg' */

   456 	case PyTrace_C_CALL:

   457 		if ((((ProfilerObject *)self)->flags & POF_BUILTINS)

   458 		    && PyCFunction_Check(arg)) {

   459 			ptrace_enter_call(self,

   460 					  ((PyCFunctionObject *)arg)->m_ml,

   461 					  arg);

   462 		}

   463 		break;

   464 

   465 	/* the call to the built-in function 'arg' is returning into its

   466 	   caller 'frame' */

   467 	case PyTrace_C_RETURN:		/* ...normally */

   468 	case PyTrace_C_EXCEPTION:	/* ...with an exception set */

   469 		if ((((ProfilerObject *)self)->flags & POF_BUILTINS)

   470 		    && PyCFunction_Check(arg)) {

   471 			ptrace_leave_call(self,

   472 					  ((PyCFunctionObject *)arg)->m_ml);

   473 		}

   474 		break;

   475 #endif

   476 

   477 	default:

   478 		break;

   479 	}

   480 	return 0;

   481 }

   482 

   483 static int

   484 pending_exception(ProfilerObject *pObj)

   485 {

   486 	if (pObj->flags & POF_NOMEMORY) {

   487 		pObj->flags -= POF_NOMEMORY;

   488 		PyErr_SetString(PyExc_MemoryError,

   489 				"memory was exhausted while profiling");

   490 		return -1;

   491 	}

   492 	return 0;

   493 }

   494 

   495 /************************************************************/

   496 

   497 static PyStructSequence_Field profiler_entry_fields[] = {

   498 	{"code",         "code object or built-in function name"},

   499 	{"callcount",    "how many times this was called"},

   500 	{"reccallcount", "how many times called recursively"},

   501 	{"totaltime",    "total time in this entry"},

   502 	{"inlinetime",   "inline time in this entry (not in subcalls)"},

   503 	{"calls",        "details of the calls"},

   504 	{0}

   505 };

   506 

   507 static PyStructSequence_Field profiler_subentry_fields[] = {

   508 	{"code",         "called code object or built-in function name"},

   509 	{"callcount",    "how many times this is called"},

   510 	{"reccallcount", "how many times this is called recursively"},

   511 	{"totaltime",    "total time spent in this call"},

   512 	{"inlinetime",   "inline time (not in further subcalls)"},

   513 	{0}

   514 };

   515 

   516 static PyStructSequence_Desc profiler_entry_desc = {

   517 	"_lsprof.profiler_entry", /* name */

   518 	NULL, /* doc */

   519 	profiler_entry_fields,

   520 	6

   521 };

   522 

   523 static PyStructSequence_Desc profiler_subentry_desc = {

   524 	"_lsprof.profiler_subentry", /* name */

   525 	NULL, /* doc */

   526 	profiler_subentry_fields,

   527 	5

   528 };

   529 

   530 static int initialized;

   531 static PyTypeObject StatsEntryType;

   532 static PyTypeObject StatsSubEntryType;

   533 

   534 

   535 typedef struct {

   536 	PyObject *list;

   537 	PyObject *sublist;

   538 	double factor;

   539 } statscollector_t;

   540 

   541 static int statsForSubEntry(rotating_node_t *node, void *arg)

   542 {

   543 	ProfilerSubEntry *sentry = (ProfilerSubEntry*) node;

   544 	statscollector_t *collect = (statscollector_t*) arg;

   545 	ProfilerEntry *entry = (ProfilerEntry*) sentry->header.key;

   546 	int err;

   547 	PyObject *sinfo;

   548 	sinfo = PyObject_CallFunction((PyObject*) &StatsSubEntryType,

   549 				      "((Olldd))",

   550 				      entry->userObj,

   551 				      sentry->callcount,

   552 				      sentry->recursivecallcount,

   553 				      collect->factor * sentry->tt,

   554 				      collect->factor * sentry->it);

   555 	if (sinfo == NULL)

   556 		return -1;

   557 	err = PyList_Append(collect->sublist, sinfo);

   558 	Py_DECREF(sinfo);

   559 	return err;

   560 }

   561 

   562 static int statsForEntry(rotating_node_t *node, void *arg)

   563 {

   564 	ProfilerEntry *entry = (ProfilerEntry*) node;

   565 	statscollector_t *collect = (statscollector_t*) arg;

   566 	PyObject *info;

   567 	int err;

   568 	if (entry->callcount == 0)

   569 		return 0;   /* skip */

   570 

   571 	if (entry->calls != EMPTY_ROTATING_TREE) {

   572 		collect->sublist = PyList_New(0);

   573 		if (collect->sublist == NULL)

   574 			return -1;

   575 		if (RotatingTree_Enum(entry->calls,

   576 				      statsForSubEntry, collect) != 0) {

   577 			Py_DECREF(collect->sublist);

   578 			return -1;

   579 		}

   580 	}

   581 	else {

   582 		Py_INCREF(Py_None);

   583 		collect->sublist = Py_None;

   584 	}

   585 

   586 	info = PyObject_CallFunction((PyObject*) &StatsEntryType,

   587 				     "((OllddO))",

   588 				     entry->userObj,

   589 				     entry->callcount,

   590 				     entry->recursivecallcount,

   591 				     collect->factor * entry->tt,

   592 				     collect->factor * entry->it,

   593 				     collect->sublist);

   594 	Py_DECREF(collect->sublist);

   595 	if (info == NULL)

   596 		return -1;

   597 	err = PyList_Append(collect->list, info);

   598 	Py_DECREF(info);

   599 	return err;

   600 }

   601 

   602 PyDoc_STRVAR(getstats_doc, "\

   603 getstats() -> list of profiler_entry objects\n\

   604 \n\

   605 Return all information collected by the profiler.\n\

   606 Each profiler_entry is a tuple-like object with the\n\

   607 following attributes:\n\

   608 \n\

   609     code          code object\n\

   610     callcount     how many times this was called\n\

   611     reccallcount  how many times called recursively\n\

   612     totaltime     total time in this entry\n\

   613     inlinetime    inline time in this entry (not in subcalls)\n\

   614     calls         details of the calls\n\

   615 \n\

   616 The calls attribute is either None or a list of\n\

   617 profiler_subentry objects:\n\

   618 \n\

   619     code          called code object\n\

   620     callcount     how many times this is called\n\

   621     reccallcount  how many times this is called recursively\n\

   622     totaltime     total time spent in this call\n\

   623     inlinetime    inline time (not in further subcalls)\n\

   624 ");

   625 

   626 static PyObject*

   627 profiler_getstats(ProfilerObject *pObj, PyObject* noarg)

   628 {

   629 	statscollector_t collect;

   630 	if (pending_exception(pObj))

   631 		return NULL;

   632 	if (!pObj->externalTimer)

   633 		collect.factor = hpTimerUnit();

   634 	else if (pObj->externalTimerUnit > 0.0)

   635 		collect.factor = pObj->externalTimerUnit;

   636 	else

   637 		collect.factor = 1.0 / DOUBLE_TIMER_PRECISION;

   638 	collect.list = PyList_New(0);

   639 	if (collect.list == NULL)

   640 		return NULL;

   641 	if (RotatingTree_Enum(pObj->profilerEntries, statsForEntry, &collect)

   642 	    != 0) {

   643 		Py_DECREF(collect.list);

   644 		return NULL;

   645 	}

   646 	return collect.list;

   647 }

   648 

   649 static int

   650 setSubcalls(ProfilerObject *pObj, int nvalue)

   651 {

   652 	if (nvalue == 0)

   653 		pObj->flags &= ~POF_SUBCALLS;

   654 	else if (nvalue > 0)

   655 		pObj->flags |=  POF_SUBCALLS;

   656 	return 0;

   657 }

   658 

   659 static int

   660 setBuiltins(ProfilerObject *pObj, int nvalue)

   661 {

   662 	if (nvalue == 0)

   663 		pObj->flags &= ~POF_BUILTINS;

   664 	else if (nvalue > 0) {

   665 #ifndef PyTrace_C_CALL

   666 		PyErr_SetString(PyExc_ValueError,

   667 				"builtins=True requires Python >= 2.4");

   668 		return -1;

   669 #else

   670 		pObj->flags |=  POF_BUILTINS;

   671 #endif

   672 	}

   673 	return 0;

   674 }

   675 

   676 PyDoc_STRVAR(enable_doc, "\

   677 enable(subcalls=True, builtins=True)\n\

   678 \n\

   679 Start collecting profiling information.\n\

   680 If 'subcalls' is True, also records for each function\n\

   681 statistics separated according to its current caller.\n\

   682 If 'builtins' is True, records the time spent in\n\

   683 built-in functions separately from their caller.\n\

   684 ");

   685 

   686 static PyObject*

   687 profiler_enable(ProfilerObject *self, PyObject *args, PyObject *kwds)

   688 {

   689 	int subcalls = -1;

   690         int builtins = -1;

   691 	static char *kwlist[] = {"subcalls", "builtins", 0};

   692 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ii:enable",

   693 					 kwlist, &subcalls, &builtins))

   694 		return NULL;

   695 	if (setSubcalls(self, subcalls) < 0 || setBuiltins(self, builtins) < 0)

   696 		return NULL;

   697 	PyEval_SetProfile(profiler_callback, (PyObject*)self);

   698 	self->flags |= POF_ENABLED;

   699 	Py_INCREF(Py_None);

   700 	return Py_None;

   701 }

   702 

   703 static void

   704 flush_unmatched(ProfilerObject *pObj)

   705 {

   706 	while (pObj->currentProfilerContext) {

   707 		ProfilerContext *pContext = pObj->currentProfilerContext;

   708 		ProfilerEntry *profEntry= pContext->ctxEntry;

   709 		if (profEntry)

   710 			Stop(pObj, pContext, profEntry);

   711 		else

   712 			pObj->currentProfilerContext = pContext->previous;

   713 		if (pContext)

   714 			free(pContext);

   715 	}

   716 

   717 }

   718 

   719 PyDoc_STRVAR(disable_doc, "\

   720 disable()\n\

   721 \n\

   722 Stop collecting profiling information.\n\

   723 ");

   724 

   725 static PyObject*

   726 profiler_disable(ProfilerObject *self, PyObject* noarg)

   727 {

   728 	self->flags &= ~POF_ENABLED;

   729 	PyEval_SetProfile(NULL, NULL);

   730 	flush_unmatched(self);

   731 	if (pending_exception(self))

   732 		return NULL;

   733 	Py_INCREF(Py_None);

   734 	return Py_None;

   735 }

   736 

   737 PyDoc_STRVAR(clear_doc, "\

   738 clear()\n\

   739 \n\

   740 Clear all profiling information collected so far.\n\

   741 ");

   742 

   743 static PyObject*

   744 profiler_clear(ProfilerObject *pObj, PyObject* noarg)

   745 {

   746 	clearEntries(pObj);

   747 	Py_INCREF(Py_None);

   748 	return Py_None;

   749 }

   750 

   751 static void

   752 profiler_dealloc(ProfilerObject *op)

   753 {

   754 	if (op->flags & POF_ENABLED)

   755 		PyEval_SetProfile(NULL, NULL);

   756 	flush_unmatched(op);

   757 	clearEntries(op);

   758 	Py_XDECREF(op->externalTimer);

   759 	Py_TYPE(op)->tp_free(op);

   760 }

   761 

   762 static int

   763 profiler_init(ProfilerObject *pObj, PyObject *args, PyObject *kw)

   764 {

   765 	PyObject *o;

   766 	PyObject *timer = NULL;

   767 	double timeunit = 0.0;

   768 	int subcalls = 1;

   769 #ifdef PyTrace_C_CALL

   770 	int builtins = 1;

   771 #else

   772 	int builtins = 0;

   773 #endif

   774 	static char *kwlist[] = {"timer", "timeunit",

   775 				       "subcalls", "builtins", 0};

   776 

   777 	if (!PyArg_ParseTupleAndKeywords(args, kw, "|Odii:Profiler", kwlist,

   778 					 &timer, &timeunit,

   779 					 &subcalls, &builtins))

   780 		return -1;

   781 

   782 	if (setSubcalls(pObj, subcalls) < 0 || setBuiltins(pObj, builtins) < 0)

   783 		return -1;

   784 	o = pObj->externalTimer;

   785 	pObj->externalTimer = timer;

   786 	Py_XINCREF(timer);

   787 	Py_XDECREF(o);

   788 	pObj->externalTimerUnit = timeunit;

   789 	return 0;

   790 }

   791 

   792 static PyMethodDef profiler_methods[] = {

   793 	{"getstats",    (PyCFunction)profiler_getstats,

   794 			METH_NOARGS,			getstats_doc},

   795 	{"enable",	(PyCFunction)profiler_enable,

   796 			METH_VARARGS | METH_KEYWORDS,	enable_doc},

   797 	{"disable",	(PyCFunction)profiler_disable,

   798 			METH_NOARGS,			disable_doc},

   799 	{"clear",	(PyCFunction)profiler_clear,

   800 			METH_NOARGS,			clear_doc},

   801 	{NULL, NULL}

   802 };

   803 

   804 PyDoc_STRVAR(profiler_doc, "\

   805 Profiler(custom_timer=None, time_unit=None, subcalls=True, builtins=True)\n\

   806 \n\

   807     Builds a profiler object using the specified timer function.\n\

   808     The default timer is a fast built-in one based on real time.\n\

   809     For custom timer functions returning integers, time_unit can\n\

   810     be a float specifying a scale (i.e. how long each integer unit\n\

   811     is, in seconds).\n\

   812 ");

   813 

   814 statichere PyTypeObject PyProfiler_Type = {

   815 	PyObject_HEAD_INIT(NULL)

   816 	0,                                      /* ob_size */

   817 	"_lsprof.Profiler",                     /* tp_name */

   818 	sizeof(ProfilerObject),                 /* tp_basicsize */

   819 	0,                                      /* tp_itemsize */

   820 	(destructor)profiler_dealloc,           /* tp_dealloc */

   821 	0,                                      /* tp_print */

   822 	0,                                      /* tp_getattr */

   823 	0,                                      /* tp_setattr */

   824 	0,                                      /* tp_compare */

   825 	0,                                      /* tp_repr */

   826 	0,                                      /* tp_as_number */

   827 	0,                                      /* tp_as_sequence */

   828 	0,                                      /* tp_as_mapping */

   829 	0,                                      /* tp_hash */

   830 	0,                                      /* tp_call */

   831 	0,                                      /* tp_str */

   832 	0,                                      /* tp_getattro */

   833 	0,                                      /* tp_setattro */

   834 	0,                                      /* tp_as_buffer */

   835 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */

   836 	profiler_doc,                           /* tp_doc */

   837 	0,                                      /* tp_traverse */

   838 	0,                                      /* tp_clear */

   839 	0,                                      /* tp_richcompare */

   840 	0,                                      /* tp_weaklistoffset */

   841 	0,                                      /* tp_iter */

   842 	0,                                      /* tp_iternext */

   843 	profiler_methods,                       /* tp_methods */

   844 	0,                                      /* tp_members */

   845 	0,                                      /* tp_getset */

   846 	0,                                      /* tp_base */

   847 	0,                                      /* tp_dict */

   848 	0,                                      /* tp_descr_get */

   849 	0,                                      /* tp_descr_set */

   850 	0,                                      /* tp_dictoffset */

   851 	(initproc)profiler_init,                /* tp_init */

   852 	PyType_GenericAlloc,                    /* tp_alloc */

   853 	PyType_GenericNew,                      /* tp_new */

   854 	PyObject_Del,                           /* tp_free */

   855 };

   856 

   857 static PyMethodDef moduleMethods[] = {

   858 	{NULL, NULL}

   859 };

   860 

   861 PyMODINIT_FUNC

   862 init_lsprof(void)

   863 {

   864 	PyObject *module, *d;

   865 	module = Py_InitModule3("_lsprof", moduleMethods, "Fast profiler");

   866 	if (module == NULL)

   867 		return;

   868 	d = PyModule_GetDict(module);

   869 	if (PyType_Ready(&PyProfiler_Type) < 0)

   870 		return;

   871 	PyDict_SetItemString(d, "Profiler", (PyObject *)&PyProfiler_Type);

   872 

   873 	if (!initialized) {

   874 		PyStructSequence_InitType(&StatsEntryType, 

   875 					  &profiler_entry_desc);

   876 		PyStructSequence_InitType(&StatsSubEntryType, 

   877 					  &profiler_subentry_desc);

   878 	}

   879 	Py_INCREF((PyObject*) &StatsEntryType);

   880 	Py_INCREF((PyObject*) &StatsSubEntryType);

   881 	PyModule_AddObject(module, "profiler_entry",

   882 			   (PyObject*) &StatsEntryType);

   883 	PyModule_AddObject(module, "profiler_subentry",

   884 			   (PyObject*) &StatsSubEntryType);

   885 	empty_tuple = PyTuple_New(0);

   886 	initialized = 1;

   887 }