Context Navigation

_lsprof.c

Visit:

Last change on this file was 3225, checked in by bird, 18 years ago
Python 2.5
File size: 23.0 KB

Line
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) ((op)->ob_type == &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((PyObject *) pObj);
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(self->ob_type, 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	profEntry = getEntry(pObj, key);
373	if (profEntry == NULL) {
374	profEntry = newProfilerEntry(pObj, key, userObj);
375	if (profEntry == NULL)
376	return;
377	}
378	/* grab a ProfilerContext out of the free list */
379	pContext = pObj->freelistProfilerContext;
380	if (pContext) {
381	pObj->freelistProfilerContext = pContext->previous;
382	}
383	else {
384	/* free list exhausted, allocate a new one */
385	pContext = (ProfilerContext*)
386	malloc(sizeof(ProfilerContext));
387	if (pContext == NULL) {
388	pObj->flags \|= POF_NOMEMORY;
389	return;
390	}
391	}
392	initContext(pObj, pContext, profEntry);
393	}
394
395	static void
396	ptrace_leave_call(PyObject self, void key)
397	{
398	/* leaving a call to the function identified by 'key' */
399	ProfilerObject pObj = (ProfilerObject)self;
400	ProfilerEntry *profEntry;
401	ProfilerContext *pContext;
402
403	pContext = pObj->currentProfilerContext;
404	if (pContext == NULL)
405	return;
406	profEntry = getEntry(pObj, key);
407	if (profEntry) {
408	Stop(pObj, pContext, profEntry);
409	}
410	else {
411	pObj->currentProfilerContext = pContext->previous;
412	}
413	/* put pContext into the free list */
414	pContext->previous = pObj->freelistProfilerContext;
415	pObj->freelistProfilerContext = pContext;
416	}
417
418	static int
419	profiler_callback(PyObject self, PyFrameObject frame, int what,
420	PyObject *arg)
421	{
422	switch (what) {
423
424	/* the 'frame' of a called function is about to start its execution */
425	case PyTrace_CALL:
426	ptrace_enter_call(self, (void *)frame->f_code,
427	(PyObject *)frame->f_code);
428	break;
429
430	/* the 'frame' of a called function is about to finish
431	(either normally or with an exception) */
432	case PyTrace_RETURN:
433	ptrace_leave_call(self, (void *)frame->f_code);
434	break;
435
436	/* case PyTrace_EXCEPTION:
437	If the exception results in the function exiting, a
438	PyTrace_RETURN event will be generated, so we don't need to
439	handle it. */
440
441	#ifdef PyTrace_C_CALL /* not defined in Python <= 2.3 */
442	/* the Python function 'frame' is issuing a call to the built-in
443	function 'arg' */
444	case PyTrace_C_CALL:
445	if ((((ProfilerObject *)self)->flags & POF_BUILTINS)
446	&& PyCFunction_Check(arg)) {
447	ptrace_enter_call(self,
448	((PyCFunctionObject *)arg)->m_ml,
449	arg);
450	}
451	break;
452
453	/* the call to the built-in function 'arg' is returning into its
454	caller 'frame' */
455	case PyTrace_C_RETURN: /* ...normally */
456	case PyTrace_C_EXCEPTION: /* ...with an exception set */
457	if ((((ProfilerObject *)self)->flags & POF_BUILTINS)
458	&& PyCFunction_Check(arg)) {
459	ptrace_leave_call(self,
460	((PyCFunctionObject *)arg)->m_ml);
461	}
462	break;
463	#endif
464
465	default:
466	break;
467	}
468	return 0;
469	}
470
471	static int
472	pending_exception(ProfilerObject *pObj)
473	{
474	if (pObj->flags & POF_NOMEMORY) {
475	pObj->flags -= POF_NOMEMORY;
476	PyErr_SetString(PyExc_MemoryError,
477	"memory was exhausted while profiling");
478	return -1;
479	}
480	return 0;
481	}
482
483	/************************************************************/
484
485	static PyStructSequence_Field profiler_entry_fields[] = {
486	{"code", "code object or built-in function name"},
487	{"callcount", "how many times this was called"},
488	{"reccallcount", "how many times called recursively"},
489	{"totaltime", "total time in this entry"},
490	{"inlinetime", "inline time in this entry (not in subcalls)"},
491	{"calls", "details of the calls"},
492	{0}
493	};
494
495	static PyStructSequence_Field profiler_subentry_fields[] = {
496	{"code", "called code object or built-in function name"},
497	{"callcount", "how many times this is called"},
498	{"reccallcount", "how many times this is called recursively"},
499	{"totaltime", "total time spent in this call"},
500	{"inlinetime", "inline time (not in further subcalls)"},
501	{0}
502	};
503
504	static PyStructSequence_Desc profiler_entry_desc = {
505	"_lsprof.profiler_entry", /* name */
506	NULL, /* doc */
507	profiler_entry_fields,
508	6
509	};
510
511	static PyStructSequence_Desc profiler_subentry_desc = {
512	"_lsprof.profiler_subentry", /* name */
513	NULL, /* doc */
514	profiler_subentry_fields,
515	5
516	};
517
518	static int initialized;
519	static PyTypeObject StatsEntryType;
520	static PyTypeObject StatsSubEntryType;
521
522
523	typedef struct {
524	PyObject *list;
525	PyObject *sublist;
526	double factor;
527	} statscollector_t;
528
529	static int statsForSubEntry(rotating_node_t node, void arg)
530	{
531	ProfilerSubEntry sentry = (ProfilerSubEntry) node;
532	statscollector_t collect = (statscollector_t) arg;
533	ProfilerEntry entry = (ProfilerEntry) sentry->header.key;
534	int err;
535	PyObject *sinfo;
536	sinfo = PyObject_CallFunction((PyObject*) &StatsSubEntryType,
537	"((Olldd))",
538	entry->userObj,
539	sentry->callcount,
540	sentry->recursivecallcount,
541	collect->factor * sentry->tt,
542	collect->factor * sentry->it);
543	if (sinfo == NULL)
544	return -1;
545	err = PyList_Append(collect->sublist, sinfo);
546	Py_DECREF(sinfo);
547	return err;
548	}
549
550	static int statsForEntry(rotating_node_t node, void arg)
551	{
552	ProfilerEntry entry = (ProfilerEntry) node;
553	statscollector_t collect = (statscollector_t) arg;
554	PyObject *info;
555	int err;
556	if (entry->callcount == 0)
557	return 0; /* skip */
558
559	if (entry->calls != EMPTY_ROTATING_TREE) {
560	collect->sublist = PyList_New(0);
561	if (collect->sublist == NULL)
562	return -1;
563	if (RotatingTree_Enum(entry->calls,
564	statsForSubEntry, collect) != 0) {
565	Py_DECREF(collect->sublist);
566	return -1;
567	}
568	}
569	else {
570	Py_INCREF(Py_None);
571	collect->sublist = Py_None;
572	}
573
574	info = PyObject_CallFunction((PyObject*) &StatsEntryType,
575	"((OllddO))",
576	entry->userObj,
577	entry->callcount,
578	entry->recursivecallcount,
579	collect->factor * entry->tt,
580	collect->factor * entry->it,
581	collect->sublist);
582	Py_DECREF(collect->sublist);
583	if (info == NULL)
584	return -1;
585	err = PyList_Append(collect->list, info);
586	Py_DECREF(info);
587	return err;
588	}
589
590	PyDoc_STRVAR(getstats_doc, "\
591	getstats() -> list of profiler_entry objects\n\
592	\n\
593	Return all information collected by the profiler.\n\
594	Each profiler_entry is a tuple-like object with the\n\
595	following attributes:\n\
596	\n\
597	code code object\n\
598	callcount how many times this was called\n\
599	reccallcount how many times called recursively\n\
600	totaltime total time in this entry\n\
601	inlinetime inline time in this entry (not in subcalls)\n\
602	calls details of the calls\n\
603	\n\
604	The calls attribute is either None or a list of\n\
605	profiler_subentry objects:\n\
606	\n\
607	code called code object\n\
608	callcount how many times this is called\n\
609	reccallcount how many times this is called recursively\n\
610	totaltime total time spent in this call\n\
611	inlinetime inline time (not in further subcalls)\n\
612	");
613
614	static PyObject*
615	profiler_getstats(ProfilerObject pObj, PyObject noarg)
616	{
617	statscollector_t collect;
618	if (pending_exception(pObj))
619	return NULL;
620	if (!pObj->externalTimer)
621	collect.factor = hpTimerUnit();
622	else if (pObj->externalTimerUnit > 0.0)
623	collect.factor = pObj->externalTimerUnit;
624	else
625	collect.factor = 1.0 / DOUBLE_TIMER_PRECISION;
626	collect.list = PyList_New(0);
627	if (collect.list == NULL)
628	return NULL;
629	if (RotatingTree_Enum(pObj->profilerEntries, statsForEntry, &collect)
630	!= 0) {
631	Py_DECREF(collect.list);
632	return NULL;
633	}
634	return collect.list;
635	}
636
637	static int
638	setSubcalls(ProfilerObject *pObj, int nvalue)
639	{
640	if (nvalue == 0)
641	pObj->flags &= ~POF_SUBCALLS;
642	else if (nvalue > 0)
643	pObj->flags \|= POF_SUBCALLS;
644	return 0;
645	}
646
647	static int
648	setBuiltins(ProfilerObject *pObj, int nvalue)
649	{
650	if (nvalue == 0)
651	pObj->flags &= ~POF_BUILTINS;
652	else if (nvalue > 0) {
653	#ifndef PyTrace_C_CALL
654	PyErr_SetString(PyExc_ValueError,
655	"builtins=True requires Python >= 2.4");
656	return -1;
657	#else
658	pObj->flags \|= POF_BUILTINS;
659	#endif
660	}
661	return 0;
662	}
663
664	PyDoc_STRVAR(enable_doc, "\
665	enable(subcalls=True, builtins=True)\n\
666	\n\
667	Start collecting profiling information.\n\
668	If 'subcalls' is True, also records for each function\n\
669	statistics separated according to its current caller.\n\
670	If 'builtins' is True, records the time spent in\n\
671	built-in functions separately from their caller.\n\
672	");
673
674	static PyObject*
675	profiler_enable(ProfilerObject self, PyObject args, PyObject *kwds)
676	{
677	int subcalls = -1;
678	int builtins = -1;
679	static char *kwlist[] = {"subcalls", "builtins", 0};
680	if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|ii:enable",
681	kwlist, &subcalls, &builtins))
682	return NULL;
683	if (setSubcalls(self, subcalls) < 0 \|\| setBuiltins(self, builtins) < 0)
684	return NULL;
685	PyEval_SetProfile(profiler_callback, (PyObject*)self);
686	self->flags \|= POF_ENABLED;
687	Py_INCREF(Py_None);
688	return Py_None;
689	}
690
691	static void
692	flush_unmatched(ProfilerObject *pObj)
693	{
694	while (pObj->currentProfilerContext) {
695	ProfilerContext *pContext = pObj->currentProfilerContext;
696	ProfilerEntry *profEntry= pContext->ctxEntry;
697	if (profEntry)
698	Stop(pObj, pContext, profEntry);
699	else
700	pObj->currentProfilerContext = pContext->previous;
701	if (pContext)
702	free(pContext);
703	}
704
705	}
706
707	PyDoc_STRVAR(disable_doc, "\
708	disable()\n\
709	\n\
710	Stop collecting profiling information.\n\
711	");
712
713	static PyObject*
714	profiler_disable(ProfilerObject self, PyObject noarg)
715	{
716	self->flags &= ~POF_ENABLED;
717	PyEval_SetProfile(NULL, NULL);
718	flush_unmatched(self);
719	if (pending_exception(self))
720	return NULL;
721	Py_INCREF(Py_None);
722	return Py_None;
723	}
724
725	PyDoc_STRVAR(clear_doc, "\
726	clear()\n\
727	\n\
728	Clear all profiling information collected so far.\n\
729	");
730
731	static PyObject*
732	profiler_clear(ProfilerObject pObj, PyObject noarg)
733	{
734	clearEntries(pObj);
735	Py_INCREF(Py_None);
736	return Py_None;
737	}
738
739	static void
740	profiler_dealloc(ProfilerObject *op)
741	{
742	if (op->flags & POF_ENABLED)
743	PyEval_SetProfile(NULL, NULL);
744	flush_unmatched(op);
745	clearEntries(op);
746	Py_XDECREF(op->externalTimer);
747	op->ob_type->tp_free(op);
748	}
749
750	static int
751	profiler_init(ProfilerObject pObj, PyObject args, PyObject *kw)
752	{
753	PyObject *o;
754	PyObject *timer = NULL;
755	double timeunit = 0.0;
756	int subcalls = 1;
757	#ifdef PyTrace_C_CALL
758	int builtins = 1;
759	#else
760	int builtins = 0;
761	#endif
762	static char *kwlist[] = {"timer", "timeunit",
763	"subcalls", "builtins", 0};
764
765	if (!PyArg_ParseTupleAndKeywords(args, kw, "\|Odii:Profiler", kwlist,
766	&timer, &timeunit,
767	&subcalls, &builtins))
768	return -1;
769
770	if (setSubcalls(pObj, subcalls) < 0 \|\| setBuiltins(pObj, builtins) < 0)
771	return -1;
772	o = pObj->externalTimer;
773	pObj->externalTimer = timer;
774	Py_XINCREF(timer);
775	Py_XDECREF(o);
776	pObj->externalTimerUnit = timeunit;
777	return 0;
778	}
779
780	static PyMethodDef profiler_methods[] = {
781	{"getstats", (PyCFunction)profiler_getstats,
782	METH_NOARGS, getstats_doc},
783	{"enable", (PyCFunction)profiler_enable,
784	METH_VARARGS \| METH_KEYWORDS, enable_doc},
785	{"disable", (PyCFunction)profiler_disable,
786	METH_NOARGS, disable_doc},
787	{"clear", (PyCFunction)profiler_clear,
788	METH_NOARGS, clear_doc},
789	{NULL, NULL}
790	};
791
792	PyDoc_STRVAR(profiler_doc, "\
793	Profiler(custom_timer=None, time_unit=None, subcalls=True, builtins=True)\n\
794	\n\
795	Builds a profiler object using the specified timer function.\n\
796	The default timer is a fast built-in one based on real time.\n\
797	For custom timer functions returning integers, time_unit can\n\
798	be a float specifying a scale (i.e. how long each integer unit\n\
799	is, in seconds).\n\
800	");
801
802	statichere PyTypeObject PyProfiler_Type = {
803	PyObject_HEAD_INIT(NULL)
804	0, /* ob_size */
805	"_lsprof.Profiler", /* tp_name */
806	sizeof(ProfilerObject), /* tp_basicsize */
807	0, /* tp_itemsize */
808	(destructor)profiler_dealloc, /* tp_dealloc */
809	0, /* tp_print */
810	0, /* tp_getattr */
811	0, /* tp_setattr */
812	0, /* tp_compare */
813	0, /* tp_repr */
814	0, /* tp_as_number */
815	0, /* tp_as_sequence */
816	0, /* tp_as_mapping */
817	0, /* tp_hash */
818	0, /* tp_call */
819	0, /* tp_str */
820	0, /* tp_getattro */
821	0, /* tp_setattro */
822	0, /* tp_as_buffer */
823	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
824	profiler_doc, /* tp_doc */
825	0, /* tp_traverse */
826	0, /* tp_clear */
827	0, /* tp_richcompare */
828	0, /* tp_weaklistoffset */
829	0, /* tp_iter */
830	0, /* tp_iternext */
831	profiler_methods, /* tp_methods */
832	0, /* tp_members */
833	0, /* tp_getset */
834	0, /* tp_base */
835	0, /* tp_dict */
836	0, /* tp_descr_get */
837	0, /* tp_descr_set */
838	0, /* tp_dictoffset */
839	(initproc)profiler_init, /* tp_init */
840	PyType_GenericAlloc, /* tp_alloc */
841	PyType_GenericNew, /* tp_new */
842	PyObject_Del, /* tp_free */
843	};
844
845	static PyMethodDef moduleMethods[] = {
846	{NULL, NULL}
847	};
848
849	PyMODINIT_FUNC
850	init_lsprof(void)
851	{
852	PyObject module, d;
853	module = Py_InitModule3("_lsprof", moduleMethods, "Fast profiler");
854	if (module == NULL)
855	return;
856	d = PyModule_GetDict(module);
857	if (PyType_Ready(&PyProfiler_Type) < 0)
858	return;
859	PyDict_SetItemString(d, "Profiler", (PyObject *)&PyProfiler_Type);
860
861	if (!initialized) {
862	PyStructSequence_InitType(&StatsEntryType,
863	&profiler_entry_desc);
864	PyStructSequence_InitType(&StatsSubEntryType,
865	&profiler_subentry_desc);
866	}
867	Py_INCREF((PyObject*) &StatsEntryType);
868	Py_INCREF((PyObject*) &StatsSubEntryType);
869	PyModule_AddObject(module, "profiler_entry",
870	(PyObject*) &StatsEntryType);
871	PyModule_AddObject(module, "profiler_subentry",
872	(PyObject*) &StatsSubEntryType);
873	empty_tuple = PyTuple_New(0);
874	initialized = 1;
875	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: vendor/python/2.5/Modules/_lsprof.c

Download in other formats: