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