AppPkg/Applications/Python/Python-2.7.2/Modules/_lsprof.c

   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 }