Changeset 305 in svn


Ignore:
Timestamp:
2006-12-08T17:11:19+01:00 (8 years ago)
Author:
Xuefer
Message:

TRACE() instead of ifdef/fprintf

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/coverager.c

    r288 r305  
    2727{
    2828    coverager_t cov = *(coverager_t*) pDest;
    29 #ifdef DEBUG
    30     fprintf(stderr, "destroy %p\n", cov);
    31 #endif
     29    TRACE("destroy %p", cov);
    3230    zend_hash_destroy(cov);
    3331    efree(cov);
     
    3937    struct stat st;
    4038
    41 #ifdef DEBUG
    42     fprintf(stderr, "mkdirs %s %d %s %d\n", root, rootlen, path, pathlen);
    43 #endif
     39    TRACE("mkdirs %s %d %s %d", root, rootlen, path, pathlen);
    4440    fullpath = do_alloca(rootlen + pathlen + 1);
    4541    memcpy(fullpath, root, rootlen);
     
    5652            *chr = PHP_DIR_SEPARATOR;
    5753        }
    58 #ifdef DEBUG
    59         fprintf(stderr, "mkdir %s\n", fullpath);
    60 #endif
     54        TRACE("mkdir %s", fullpath);
    6155#if PHP_MAJOR_VERSION > 5
    6256        php_stream_mkdir(fullpath, 0700, REPORT_ERRORS, NULL);
     
    113107
    114108    if (newfile) {
    115 #ifdef DEBUG
    116         fprintf(stderr, "new file\n");
    117 #endif
     109        TRACE("%s", "new file");
    118110    }
    119111    else if (outstat.st_size) {
     
    123115            goto bailout;
    124116        }
    125 #ifdef DEBUG
    126         fprintf(stderr, "oldsize %d\n", (int) len);
    127 #endif
     117        TRACE("oldsize %d", (int) len);
    128118        do {
    129119            p = (long *) contents;
     
    133123            }
    134124            if (*p++ != PCOV_HEADER_MAGIC) {
    135 #ifdef DEBUG
    136                 fprintf(stderr, "wrong magic in file %s\n", outfilename);
    137 #endif
     125                TRACE("wrong magic in file %s", outfilename);
    138126                break;
    139127            }
     
    290278            strcpy(outfilename + dumpdir_len + size - 1, ".pcov");
    291279
    292 #ifdef DEBUG
    293             fprintf(stderr, "outfilename %s\n", outfilename);
    294 #endif
     280            TRACE("outfilename %s", outfilename);
    295281            xc_coverager_save_cov(ZSTR_S(s), outfilename, *pcov TSRMLS_CC);
    296282            zend_hash_move_forward_ex(XG(coverages), &pos);
     
    354340
    355341    if (zend_hash_find(XG(coverages), filename, len, (void **) &pcov) == SUCCESS) {
    356 #ifdef DEBUG
    357         fprintf(stderr, "got coverage %s %p\n", filename, *pcov);
    358 #endif
     342        TRACE("got coverage %s %p", filename, *pcov);
    359343        return *pcov;
    360344    }
     
    363347        zend_hash_init(cov, 0, NULL, NULL, 0);
    364348        zend_hash_add(XG(coverages), filename, len, (void **) &cov, sizeof(cov), NULL);
    365 #ifdef DEBUG
    366         fprintf(stderr, "new coverage %s %p\n", filename, cov);
    367 #endif
     349        TRACE("new coverage %s %p", filename, cov);
    368350        return cov;
    369351    }
     
    534516    }
    535517    if (*p++ != PCOV_HEADER_MAGIC) {
    536 #ifdef DEBUG
    537         fprintf(stderr, "wrong magic in xcache_coverager_decode");
    538 #endif
     518        TRACE("%s", "wrong magic in xcache_coverager_decode");
    539519        return;
    540520    }
  • trunk/mem.c

    r302 r305  
    1515
    1616#ifdef TEST
    17 #   define ALLOC_DEBUG
    18 #endif
    19 #ifdef ALLOC_DEBUG
     17#   define DEBUG
     18#endif
     19#ifdef DEBUG
    2020#   define ALLOC_DEBUG_BLOCK_CHECK
    2121#endif
     
    9191    realsize = ALIGN(realsize);
    9292
    93 #ifdef ALLOC_DEBUG
    94     fprintf(stderr, "avail: %d (%dKB). Allocate size: %d realsize: %d (%dKB)"
     93    TRACE("avail: %d (%dKB). Allocate size: %d realsize: %d (%dKB)"
    9594            , mem->avail, mem->avail / 1024
    9695            , size
    9796            , realsize, realsize / 1024
    9897            );
    99 #endif
    10098    do {
    10199        p = NULL;
    102100        if (mem->avail < realsize) {
    103 #ifdef ALLOC_DEBUG
    104             fprintf(stderr, " oom\n");
    105 #endif
     101            TRACE(" oom");
    106102            break;
    107103        }
     
    132128
    133129        if (b == NULL) {
    134 #ifdef ALLOC_DEBUG
    135             fprintf(stderr, " no fit chunk\n");
    136 #endif
     130            TRACE(" no fit chunk");
    137131            break;
    138132        }
     
    149143        if (cur->size == realsize) {
    150144            prev->next = cur->next;
    151 #ifdef ALLOC_DEBUG
    152             fprintf(stderr, " perfect fit. Got: %p\n", p);
    153 #endif
     145            TRACE(" perfect fit. Got: %p", p);
    154146            break;
    155147        }
     
    169161         */
    170162
    171 #ifdef ALLOC_DEBUG
    172         fprintf(stderr, " -> avail: %d (%dKB). new next: %p offset: %d %dKB. Got: %p\n"
     163        TRACE(" -> avail: %d (%dKB). new next: %p offset: %d %dKB. Got: %p"
    173164                , mem->avail, mem->avail / 1024
    174165                , newb
     
    176167                , p
    177168                );
    178 #endif
    179169        prev->next = newb;
    180170        /* prev|cur|newb|next
     
    193183
    194184    cur = (xc_block_t *) (CHAR_PTR(p) - BLOCK_HEADER_SIZE());
    195 #ifdef ALLOC_DEBUG
    196     fprintf(stderr, "freeing: %p", p);
    197     fprintf(stderr, ", size=%d", cur->size);
    198 #endif
     185    TRACE("freeing: %p, size=%d", p, cur->size);
    199186    xc_block_check(cur);
    200187    assert((char*)mem < (char*)cur && (char*)cur < (char*)mem + mem->size);
     
    211198    size = cur->size;
    212199
    213 #ifdef ALLOC_DEBUG
    214     fprintf(stderr, ", avail %d (%dKB)", mem->avail, mem->avail / 1024);
    215 #endif
     200    TRACE(" avail %d (%dKB)", mem->avail, mem->avail / 1024);
    216201    mem->avail += size;
    217202
     
    221206        b->next = cur->next;
    222207        cur = b;
    223 #ifdef ALLOC_DEBUG
    224         fprintf(stderr, ", combine prev");
    225 #endif
     208        TRACE(" combine prev");
    226209    }
    227210
     
    231214        cur->size += b->size;
    232215        cur->next = b->next;
    233 #ifdef ALLOC_DEBUG
    234         fprintf(stderr, ", combine next");
    235 #endif
    236     }
    237 #ifdef ALLOC_DEBUG
    238     fprintf(stderr, " -> avail %d (%dKB)\n", mem->avail, mem->avail / 1024);
    239 #endif
     216        TRACE(" combine next");
     217    }
     218    TRACE(" -> avail %d (%dKB)", mem->avail, mem->avail / 1024);
    240219    return size;
    241220}
  • trunk/mmap.c

    r302 r305  
    1 
    2 #undef ALLOC_DEBUG
    31
    42#include <stdio.h>
     
    3432#define XC_SHM_IMPL
    3533#include "xc_shm.h"
     34#include "utils.h"
    3635
    3736#ifndef max
     
    5554};
    5655
    57 #undef NDEBUG
    58 #ifdef ALLOC_DEBUG
    59 #   define inline
    60 #else
    61 #   define NDEBUG
    62 #endif
    63 #include <assert.h>
    6456/* }}} */
    6557#define CHECK(x, e) do { if ((x) == NULL) { zend_error(E_ERROR, "XCache: " e); goto err; } } while (0)
  • trunk/utils.c

    r295 r305  
    331331    zend_op *opline;
    332332
    333 #ifdef DEBUG
    334     fprintf(stderr, "binding %d\n", oplineno);
    335 #endif
     333    TRACE("binding %d", oplineno);
    336334    assert(oplineno >= 0);
    337335
     
    352350
    353351            parent_name = &(opline - 1)->op2.u.constant;
    354 #   ifdef DEBUG
    355             fprintf(stderr, "binding with parent %s\n", Z_STRVAL_P(parent_name));
    356 #   endif
     352            TRACE("binding with parent %s", Z_STRVAL_P(parent_name));
    357353            if (zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) {
    358354                return FAILURE;
     
    369365            zend_op *fetch_class_opline = opline - 1;
    370366
    371 #   ifdef DEBUG
    372             fprintf(stderr, "%s %p\n", Z_STRVAL(fetch_class_opline->op2.u.constant), Z_STRVAL(fetch_class_opline->op2.u.constant));
    373 #   endif
     367            TRACE("%s %p", Z_STRVAL(fetch_class_opline->op2.u.constant), Z_STRVAL(fetch_class_opline->op2.u.constant));
    374368            OP_ZVAL_DTOR(fetch_class_opline->op2);
    375369            fetch_class_opline->opcode = ZEND_NOP;
     
    707701}
    708702/* }}} */
     703int xc_vtrace(const char *fmt, va_list args) /* {{{ */
     704{
     705    vfprintf(stderr, fmt, args);
     706    return 0;
     707}
     708/* }}} */
     709int xc_trace(const char *fmt, ...) /* {{{ */
     710{
     711    va_list args;
     712
     713    va_start(args, fmt);
     714    xc_vtrace(fmt, args);
     715    va_end(args);
     716    return 0;
     717}
     718/* }}} */
  • trunk/utils.h

    r268 r305  
    11#include "php.h"
     2#include "xcache.h"
     3
     4#ifdef DEBUG
     5#   define IFDEBUG(x) (x)
     6#   define TRACE(fmt, ...) \
     7    xc_trace("%s:%d: " fmt "\r\n", __FILE__, __LINE__, __VA_ARGS__)
     8int xc_trace(const char *fmt, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
     9#   undef NDEBUG
     10#   undef inline
     11#   define inline
     12#else
     13#   define TRACE(fmt, ...) do { } while (0)
     14#   define IFDEBUG(x) do { } while (0)
     15#   ifndef NDEBUG
     16#       define NDEBUG
     17#   endif
     18#endif
     19#include <assert.h>
    220
    321typedef struct {
  • trunk/xc_malloc.c

    r302 r305  
    77#include "php.h"
    88#include "align.h"
     9#include "utils.h"
    910
    1011struct _xc_mem_t {
     
    112113    xc_shmsize_t       memoffset;
    113114};
    114 
    115 #undef NDEBUG
    116 #ifdef ALLOC_DEBUG
    117 #   define inline
    118 #else
    119 #   define NDEBUG
    120 #endif
    121 #include <assert.h>
    122115/* }}} */
    123116
  • trunk/xc_shm.h

    r163 r305  
     1#ifndef XC_SHM_H
     2#define XC_SHM_H
    13typedef struct _xc_shm_t xc_shm_t;
    24typedef size_t xc_shmsize_t;
     
    6365xc_shm_t *xc_shm_init(const char *type, xc_shmsize_t size, int readonly_protection, const void *arg1, const void *arg2);
    6466void xc_shm_destroy(xc_shm_t *shm);
     67#endif
  • trunk/xcache.c

    r299 r305  
    3030#include "xcache_globals.h"
    3131#include "processor.h"
    32 #include "utils.h"
    3332#include "const_string.h"
    3433#include "opcode_spec.h"
    35 
    36 #ifdef DEBUG
    37 #   undef NDEBUG
    38 #   undef inline
    39 #   define inline
    40 #else
    41 #   ifndef NDEBUG
    42 #       define NDEBUG
    43 #   endif
    44 #endif
    45 #include <assert.h>
     34#include "utils.h"
    4635
    4736#define VAR_ENTRY_EXPIRED(pentry) ((pentry)->ttl && XG(request_time) > pentry->ctime + (pentry)->ttl)
     
    243232static void xc_entry_hold_php_dmz(xc_entry_t *xce TSRMLS_DC) /* {{{ */
    244233{
    245 #ifdef DEBUG
    246     fprintf(stderr, "hold %s\n", xce->name.str.val);
    247 #endif
     234    TRACE("hold %s", xce->name.str.val);
    248235    xce->refcount ++;
    249236    xc_stack_push(&XG(php_holds)[xce->cache->cacheid], (void *)xce);
     
    290277static XC_ENTRY_APPLY_FUNC(xc_gc_expires_php_entry_dmz) /* {{{ */
    291278{
    292 #ifdef DEBUG
    293     fprintf(stderr, "ttl %lu, %lu %lu\n", (zend_ulong) XG(request_time), (zend_ulong) entry->atime, xc_php_ttl);
    294 #endif
     279    TRACE("ttl %lu, %lu %lu", (zend_ulong) XG(request_time), (zend_ulong) entry->atime, xc_php_ttl);
    295280    if (XG(request_time) > entry->atime + xc_php_ttl) {
    296281        return 1;
     
    309294static void xc_gc_expires_one(xc_cache_t *cache, zend_ulong gc_interval, cache_apply_dmz_func_t apply_func TSRMLS_DC) /* {{{ */
    310295{
    311 #ifdef DEBUG
    312     fprintf(stderr, "interval %lu, %lu %lu\n", (zend_ulong) XG(request_time), (zend_ulong) cache->last_gc_expires, gc_interval);
    313 #endif
     296    TRACE("interval %lu, %lu %lu", (zend_ulong) XG(request_time), (zend_ulong) cache->last_gc_expires, gc_interval);
    314297    if (XG(request_time) - cache->last_gc_expires >= gc_interval) {
    315298        ENTER_LOCK(cache) {
     
    623606    for (i = 0; i < cachecount; i ++) {
    624607        s = &holds[i];
    625 #ifdef DEBUG
    626         fprintf(stderr, "holded %d\n", xc_stack_size(s));
    627 #endif
     608        TRACE("holded %d", xc_stack_size(s));
    628609        if (xc_stack_size(s)) {
    629610            cache = ((xc_entry_t *)xc_stack_top(s))->cache;
     
    631612                while (xc_stack_size(s)) {
    632613                    xce = (xc_entry_t*) xc_stack_pop(s);
    633 #ifdef DEBUG
    634                     fprintf(stderr, "unhold %s\n", xce->name.str.val);
    635 #endif
     614                    TRACE("unhold %s", xce->name.str.val);
    636615                    xce->refcount --;
    637616                    assert(xce->refcount >= 0);
     
    811790        assert(0);
    812791    }
    813 #ifdef DEBUG
    814     fprintf(stderr, "got ZEND_DECLARE_INHERITED_CLASS: %s\n", class_name + 1);
    815 #endif
     792    TRACE("got ZEND_DECLARE_INHERITED_CLASS: %s", class_name + 1);
    816793    /* let's see which class */
    817794    for (i = 0; i < php->classinfo_cnt; i ++) {
     
    891868        /* found */
    892869        if (stored_xce) {
    893 #ifdef DEBUG
    894             fprintf(stderr, "found %s, catch it\n", stored_xce->name.str.val);
    895 #endif
     870            TRACE("found %s, catch it", stored_xce->name.str.val);
    896871            xc_entry_hold_php_dmz(stored_xce TSRMLS_CC);
    897872            cache->hits ++;
     
    920895
    921896    /* {{{ compile */
    922 #ifdef DEBUG
    923     fprintf(stderr, "compiling %s\n", filename);
    924 #endif
     897    TRACE("compiling %s", filename);
    925898
    926899    /* make compile inside sandbox */
     
    10881061    } LEAVE_LOCK_EX(cache);
    10891062    /* }}} */
    1090 #ifdef DEBUG
    1091     fprintf(stderr, "stored\n");
    1092 #endif
     1063    TRACE("%s", "stored");
    10931064
    10941065#define X_FREE(var) \
     
    11461117    CG(compiled_filename) = stored_xce->name.str.val;
    11471118    CG(zend_lineno)       = 0;
    1148 #ifdef DEBUG
    1149     fprintf(stderr, "restoring %s\n", stored_xce->name.str.val);
    1150 #endif
     1119    TRACE("restoring %s", stored_xce->name.str.val);
    11511120    xc_processor_restore_xc_entry_t(&xce, stored_xce, xc_readonly_protection TSRMLS_CC);
    11521121#ifdef SHOW_DPRINT
     
    11811150    CG(in_compilation)    = 0;
    11821151    CG(compiled_filename) = NULL;
    1183 #ifdef DEBUG
    1184     fprintf(stderr, "restored  %s\n", stored_xce->name.str.val);
    1185 #endif
     1152    TRACE("restored  %s", stored_xce->name.str.val);
    11861153    return op_array;
    11871154}
     
    18751842        stored_xce = xc_entry_find_dmz(&xce TSRMLS_CC);
    18761843        if (stored_xce) {
    1877 #ifdef DEBUG
    1878             fprintf(stderr, "incdec: gotxce %s\n", xce.name.str.val);
    1879 #endif
     1844            TRACE("incdec: gotxce %s", xce.name.str.val);
    18801845            /* timeout */
    18811846            if (VAR_ENTRY_EXPIRED(stored_xce)) {
    1882 #ifdef DEBUG
    1883                 fprintf(stderr, "incdec: expired\n");
    1884 #endif
     1847                TRACE("%s", "incdec: expired");
    18851848                xc_entry_remove_dmz(stored_xce TSRMLS_CC);
    18861849                stored_xce = NULL;
     
    18921855                    stored_xce->ctime = XG(request_time);
    18931856                    stored_xce->ttl   = xce.ttl;
    1894 #ifdef DEBUG
    1895                     fprintf(stderr, "incdec: islong\n");
    1896 #endif
     1857                    TRACE("%s", "incdec: islong");
    18971858                    value = Z_LVAL_P(stored_var->value);
    18981859                    value += (inc == 1 ? count : - count);
     
    19021863                }
    19031864                else {
    1904 #ifdef DEBUG
    1905                     fprintf(stderr, "incdec: notlong\n");
    1906 #endif
     1865                    TRACE("%s", "incdec: notlong");
    19071866                    xc_processor_restore_zval(&oldzval, stored_xce->data.var->value, stored_xce->have_references TSRMLS_CC);
    19081867                    convert_to_long(&oldzval);
     
    19121871            }
    19131872        }
    1914 #ifdef DEBUG
    19151873        else {
    1916             fprintf(stderr, "incdec: %s not found\n", xce.name.str.val);
    1917         }
    1918 #endif
     1874            TRACE("incdec: %s not found", xce.name.str.val);
     1875        }
    19191876
    19201877        value += (inc == 1 ? count : - count);
     
    23602317
    23612318    zend_llist_prepend_element(&zend_extensions, &extension);
    2362 #ifdef DEBUG
    2363     fprintf(stderr, "registered\n");
    2364 #endif
     2319    TRACE("%s", "registered");
    23652320}
    23662321
Note: See TracChangeset for help on using the changeset viewer.