Mercurial > cpython-lru_cache-weakref
annotate Modules/_lsprof.c @ 58765:2ba7677bfa95 legacy-trunk
testCopysign was defined twice in test_math; combine the definitions
| author | Mark Dickinson <dickinsm@gmail.com> |
|---|---|
| date | Sat, 06 Feb 2010 23:11:25 +0000 |
| parents | 7f1f9e18cdfa |
| children | d5fbda03c603 |
| rev | line source |
|---|---|
| 36459 | 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)) | |
|
36471
165389b14d6b
The default timer unit was incorrectly measured in milliseconds instead
Armin Rigo <arigo@tunes.org>
parents:
36459
diff
changeset
|
30 return 1.0 / li.QuadPart; |
| 36459 | 31 else |
|
36471
165389b14d6b
The default timer unit was incorrectly measured in milliseconds instead
Armin Rigo <arigo@tunes.org>
parents:
36459
diff
changeset
|
32 return 0.000001; /* unlikely */ |
| 36459 | 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 { | |
|
36471
165389b14d6b
The default timer unit was incorrectly measured in milliseconds instead
Armin Rigo <arigo@tunes.org>
parents:
36459
diff
changeset
|
66 return 0.000001; |
| 36459 | 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) | |
|
44350
26384b8180c7
#1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents:
43258
diff
changeset
|
123 #define PyProfiler_CheckExact(op) (Py_TYPE(op) == &PyProfiler_Type) |
| 36459 | 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()) { | |
|
49358
7f1f9e18cdfa
Fix a refleak introduced by r66677.
Brett Cannon <bcannon@gmail.com>
parents:
49335
diff
changeset
|
153 PyErr_WriteUnraisable(pObj->externalTimer); |
| 36459 | 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; | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
182 if (mod && PyString_Check(mod)) { |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
183 modname = PyString_AS_STRING(mod); |
| 36459 | 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) | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
196 return PyString_FromFormat("<%s.%s>", |
| 36459 | 197 modname, |
| 198 fn->m_ml->ml_name); | |
| 199 else | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
200 return PyString_FromFormat("<%s>", |
| 36459 | 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; | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
208 PyObject *name = PyString_FromString(fn->m_ml->ml_name); |
| 36459 | 209 if (name != NULL) { |
|
44350
26384b8180c7
#1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents:
43258
diff
changeset
|
210 PyObject *mo = _PyType_Lookup(Py_TYPE(self), name); |
| 36459 | 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(); | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
221 return PyString_FromFormat("<built-in method %s>", |
| 36459 | 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 | |
| 43258 | 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 | |
| 36459 | 381 profEntry = getEntry(pObj, key); |
| 382 if (profEntry == NULL) { | |
| 383 profEntry = newProfilerEntry(pObj, key, userObj); | |
| 384 if (profEntry == NULL) | |
| 43258 | 385 goto restorePyerr; |
| 36459 | 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; | |
| 43258 | 398 goto restorePyerr; |
| 36459 | 399 } |
| 400 } | |
| 401 initContext(pObj, pContext, profEntry); | |
| 43258 | 402 |
| 403 restorePyerr: | |
| 404 PyErr_Restore(last_type, last_value, last_tb); | |
| 36459 | 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 | |
|
37772
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
530 static int initialized; |
| 36459 | 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; | |
|
36675
dba6494735d0
Revert backwards-incompatible const changes.
Martin v. Löwis <martin@v.loewis.de>
parents:
36471
diff
changeset
|
691 static char *kwlist[] = {"subcalls", "builtins", 0}; |
| 36459 | 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); | |
|
44350
26384b8180c7
#1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents:
43258
diff
changeset
|
759 Py_TYPE(op)->tp_free(op); |
| 36459 | 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 | |
|
36675
dba6494735d0
Revert backwards-incompatible const changes.
Martin v. Löwis <martin@v.loewis.de>
parents:
36471
diff
changeset
|
774 static char *kwlist[] = {"timer", "timeunit", |
| 36459 | 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"); | |
|
36861
895074e5ed3a
Thanks to Coverity, these were all reported by their Prevent tool.
Neal Norwitz <nnorwitz@gmail.com>
parents:
36675
diff
changeset
|
866 if (module == NULL) |
|
895074e5ed3a
Thanks to Coverity, these were all reported by their Prevent tool.
Neal Norwitz <nnorwitz@gmail.com>
parents:
36675
diff
changeset
|
867 return; |
| 36459 | 868 d = PyModule_GetDict(module); |
| 869 if (PyType_Ready(&PyProfiler_Type) < 0) | |
| 870 return; | |
| 871 PyDict_SetItemString(d, "Profiler", (PyObject *)&PyProfiler_Type); | |
| 872 | |
|
37772
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
873 if (!initialized) { |
|
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
874 PyStructSequence_InitType(&StatsEntryType, |
|
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
875 &profiler_entry_desc); |
|
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
876 PyStructSequence_InitType(&StatsSubEntryType, |
|
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
877 &profiler_subentry_desc); |
|
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
878 } |
| 36459 | 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); | |
|
37772
b90a7c6021bc
Initialize structseq types only once.
Martin v. Löwis <martin@v.loewis.de>
parents:
36861
diff
changeset
|
886 initialized = 1; |
| 36459 | 887 } |