Changeset 18

Show
Ignore:
Timestamp:
04/10/06 18:55:09 (9 years ago)
Author:
george
Message:

friendster changes. numerous stability fixes.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/fastxsl.c

    r17 r18  
    4141#endif 
    4242#include <sys/types.h> 
     43#include <sys/file.h> 
    4344#include <unistd.h> 
    4445 
     
    5152ZEND_DECLARE_MODULE_GLOBALS(fastxsl); 
    5253 
     54static int inshm = 0; 
     55 
    5356static int le_fastxsl_stylesheet; 
    5457#define le_fastxsl_stylesheet_name "FastXSL Stylesheet" 
     
    6063 
    6164void fastxsl_errorfunc(void *ctx, const char *msg, ...); 
     65static void ShmCache_Stylesheet_Free(php_ss_wrapper *wrapper TSRMLS_DC); 
     66static void _SS_Wrapper_Dtor(php_ss_wrapper *wrapper); 
     67static void _XD_Wrapper_Dtor(php_xd_wrapper *wrapper); 
     68 
     69static unsigned int pool_hash(void *ptr) 
     70{ 
     71  unsigned long i = (unsigned long) ptr; 
     72  i /= 8; 
     73  i *= 99961; 
     74  return i % 31907; 
     75} 
     76static void pool_init(zend_fastxsl_globals *globals) 
     77{ 
     78  int i; 
     79 
     80  globals->pool = calloc(1, sizeof(void **) * 31907); 
     81  globals->pool_offset = calloc(1, sizeof(int) * 31907); 
     82  globals->pool_allocd = calloc(1, sizeof(int) * 31907); 
     83 
     84  for(i = 0; i < 31907; i++) { 
     85    globals->pool[i] = calloc(1, sizeof(void *) * 100); 
     86    globals->pool_allocd[i] = 100; 
     87  } 
     88} 
     89 
     90static void pool_add(void *ptr) 
     91{ 
     92  unsigned int slot = pool_hash(ptr); 
     93  if(FASTXSL_G(pool_offset)[slot] == FASTXSL_G(pool_allocd)[slot] - 1) { 
     94    FASTXSL_G(pool_allocd)[slot] *= 2; 
     95    FASTXSL_G(pool)[slot] = realloc(FASTXSL_G(pool)[slot], sizeof(void *) * FASTXSL_G(pool_allocd)[slot]); 
     96  } 
     97  FASTXSL_G(pool)[slot][FASTXSL_G(pool_offset)[slot]++] = ptr; 
     98} 
     99 
     100static void pool_remove( void *ptr) 
     101{ 
     102  int i; 
     103  unsigned int slot = pool_hash(ptr); 
     104  for(i = 0; i < FASTXSL_G(pool_offset)[slot]; i++) { 
     105    if(FASTXSL_G(pool)[slot][i] == ptr) { 
     106      FASTXSL_G(pool)[slot][i] = NULL; 
     107    } 
     108  } 
     109} 
     110 
     111static void pool_clear() 
     112{ 
     113  int i; 
     114  for(i = 0; i < 31907; i++) { 
     115    FASTXSL_G(pool_offset)[i] = 0; 
     116  } 
     117} 
     118 
     119static void pool_destroy( FL_Free   free_func ) 
     120{ 
     121  int i, j; 
     122  for(i = 0; i < 31907; i++) { 
     123    for(j = 0; j < FASTXSL_G(pool_offset)[i]; j++) { 
     124      if(FASTXSL_G(pool)[i][j]) { 
     125        free_func(FASTXSL_G(pool)[i][j]); 
     126      } 
     127    } 
     128  } 
     129} 
    62130 
    63131static php_ss_wrapper * 
     
    73141                        wrapper = (php_ss_wrapper *) calloc(1, sizeof(php_ss_wrapper)); 
    74142                } 
     143                if(!wrapper) { 
     144                        mm_display_info(FASTXSL_G(cache)->mm); 
     145                } 
    75146                wrapper->persistant = 1; 
    76147#else 
     
    96167static xmlFreeFunc    free_ptr; 
    97168static xmlMallocFunc  malloc_ptr; 
     169static xmlMallocFunc  mallocatomic_ptr; 
    98170static xmlReallocFunc realloc_ptr; 
    99171static xmlStrdupFunc  strdup_ptr; 
     
    104176{ 
    105177        TSRMLS_FETCH(); 
     178        if(!inshm) assert(0); 
    106179        FASTXSL_G(tmp_allocated_size) -= mm_sizeof(FASTXSL_G(cache)->mm, ptr); 
    107          
    108180        mm_free(FASTXSL_G(cache)->mm, ptr); 
     181        //pool_remove(ptr); 
    109182} 
    110183 
     
    114187        void *ptr; 
    115188        TSRMLS_FETCH(); 
    116  
     189        if(!inshm) assert(0); 
    117190        ptr = mm_malloc(FASTXSL_G(cache)->mm, size); 
    118191        if (!ptr) { 
    119192                php_error(E_ERROR, "Ran out of Shared memory to allocate data for FastXSL cache, " 
    120                                            "in function %s() cannot allocate %d bytes (%d available, %d allocated)",  
     193                                           "in function %s() cannot allocate %ld bytes (%ld available, %ld allocated)",  
    121194                                                   get_active_function_name(TSRMLS_C), size, mm_available(FASTXSL_G(cache)->mm),  
    122195                                                   mm_maxsize() - mm_available(FASTXSL_G(cache)->mm)); 
     
    125198 
    126199        FASTXSL_G(tmp_allocated_size) += size; 
    127  
     200        //pool_add(ptr); 
    128201        return ptr; 
    129202} 
     
    134207        void *ptr; 
    135208 
     209        if(!inshm) assert(0); 
    136210        ptr = ShmCache_Malloc(nmemb * size); 
    137211        memset(ptr, 0, nmemb * size); 
    138  
     212        //pool_add(ptr); 
    139213        return ptr; 
    140214} 
     
    147221        TSRMLS_FETCH(); 
    148222 
     223        if(!inshm) assert(0); 
    149224        oldsize = mm_sizeof(FASTXSL_G(cache)->mm, ptr); 
    150225        newptr = mm_realloc(FASTXSL_G(cache)->mm, ptr, size); 
     
    158233        } 
    159234        FASTXSL_G(tmp_allocated_size) += (size - oldsize); 
    160  
     235        //pool_remove(ptr); 
     236        //pool_add(newptr); 
    161237        return newptr; 
    162238} 
     
    168244        int   string_length; 
    169245 
     246        if(!inshm) assert(0); 
    170247        string_length = strlen(string); 
    171         newstring = ShmCache_Malloc(string_length); 
     248        newstring = ShmCache_Malloc(string_length + 1); 
    172249        memcpy(newstring, string, string_length); 
    173250        newstring[string_length] = 0; 
     
    205282ShmCache_UseAllocationFunctions(void) 
    206283{ 
     284        //xmlGcMemSetup(ShmCache_Free, ShmCache_Malloc, ShmCache_Malloc, ShmCache_Realloc, ShmCache_Strdup); 
    207285        xmlMemSetup(ShmCache_Free, ShmCache_Malloc, ShmCache_Realloc, ShmCache_Strdup); 
    208286} 
     
    212290Php_UseAllocationFunctions(void) 
    213291{ 
     292        //xmlGcMemSetup(Php_Free, Php_Malloc, Php_Malloc, Php_Realloc, Php_Strdup); 
    214293        xmlMemSetup(Php_Free, Php_Malloc, Php_Realloc, Php_Strdup); 
    215294} 
     
    218297Xml_UseAllocationFunctions(void) 
    219298{ 
    220         xmlMemSetup(free_ptr, malloc_ptr, realloc_ptr, strdup_ptr); 
     299        //xmlGcMemSetup(free_ptr, malloc_ptr, mallocatomic_ptr, realloc_ptr, strdup); 
     300        xmlMemSetup(free_ptr, malloc_ptr,  realloc_ptr, strdup); 
    221301} 
    222302 
     
    226306{ 
    227307        php_ss_wrapper *wrapper; 
    228          
     308        int rv; 
    229309        wrapper = SS_Wrapper_Alloc(FASTXSL_SHARED_ALLOC TSRMLS_CC); 
    230310 
     311        //xmlCleanupParserr(); 
    231312        ShmCache_UseAllocationFunctions(); 
     313        wrapper->alloc_type = FASTXSL_SHMALLOC; 
    232314        FASTXSL_G(tmp_allocated_size) = 0; 
     315inshm = 1; 
     316        zend_set_timeout(0); 
     317        //pool_clear(); 
    233318        wrapper->ss = xsltParseStylesheetFile(filename); 
     319inshm = 0; 
     320        Xml_UseAllocationFunctions(); 
    234321        if (!wrapper->ss) { 
    235                 Xml_UseAllocationFunctions(); 
     322                //pool_destroy(ShmCache_Free); 
     323                _SS_Wrapper_Dtor(wrapper); 
    236324                return NULL; 
    237325        } 
    238         Xml_UseAllocationFunctions(); 
    239326        wrapper->mtime = mtime; 
    240327        wrapper->allocsize = FASTXSL_G(tmp_allocated_size); 
    241          
    242         fl_hash_add(FASTXSL_G(cache)->table, filename, filename_len, wrapper); 
     328        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     329        rv = fl_hash_add(FASTXSL_G(cache)->table, filename, filename_len, wrapper); 
     330        mm_unlock(FASTXSL_G(cache)->mm); 
     331        if(rv == 0) { 
     332                /* we failed */ 
     333                php_ss_wrapper *fallback; 
     334                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     335                fallback = fl_hash_find(FASTXSL_G(cache)->table, filename, filename_len); 
     336                mm_unlock(FASTXSL_G(cache)->mm); 
     337                if(fallback) { 
     338                        ShmCache_Stylesheet_Free(wrapper); 
     339                        wrapper = fallback; 
     340                } else { 
     341                } 
     342        } else { 
     343        } 
    243344 
    244345        return wrapper; 
     
    249350{ 
    250351        if (wrapper->ss) { 
     352                //xmlCleanupParserr(); 
    251353                ShmCache_UseAllocationFunctions(); 
     354inshm = 1; 
    252355                xsltFreeStylesheet(wrapper->ss); 
     356inshm = 0; 
     357                //xmlCleanupParserr(); 
    253358                Xml_UseAllocationFunctions(); 
    254359        } 
     
    261366        php_ss_wrapper *wrapper; 
    262367 
     368        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
    263369        wrapper = fl_hash_find(FASTXSL_G(cache)->table, filename, filename_len); 
     370        mm_unlock(FASTXSL_G(cache)->mm); 
    264371        if (wrapper) { 
     372                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
    265373                fl_hash_delete(FASTXSL_G(cache)->table, filename, filename_len); 
     374                mm_unlock(FASTXSL_G(cache)->mm); 
    266375                ShmCache_Stylesheet_Free(wrapper); 
    267376        } 
     
    275384 
    276385        wrapper = (php_ss_wrapper *) SS_Wrapper_Alloc(FASTXSL_PRM_ALLOC TSRMLS_CC); 
     386        wrapper->alloc_type = FASTXSL_PRMALLOC; 
    277387 
    278388        wrapper->ss = xsltParseStylesheetFile(filename); 
     389        ////xmlCleanupParserr(); 
    279390        if (!wrapper->ss) { 
    280391                return NULL; 
     
    282393        wrapper->mtime = mtime; 
    283394         
    284         fl_hash_add(FASTXSL_G(cache)->prmtable, filename, filename_len, wrapper); 
     395        if(fl_hash_add(FASTXSL_G(cache)->prmtable, filename, filename_len, wrapper) == 0) { 
     396                /* we failed */ 
     397                php_ss_wrapper *fallback; 
     398                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     399                fallback = fl_hash_find(FASTXSL_G(cache)->table, filename, filename_len); 
     400                mm_unlock(FASTXSL_G(cache)->mm); 
     401                if(fallback) { 
     402                        ShmCache_Stylesheet_Free(wrapper); 
     403                        wrapper = fallback; 
     404                } 
     405        } 
    285406 
    286407        return wrapper; 
     
    352473 
    353474                        add_assoc_long(info_array, "allocated", ss_wrapper->allocsize); 
     475                        add_assoc_long(info_array, "hits", ss_wrapper->hits); 
    354476                        add_assoc_long(info_array, "mtime", ss_wrapper->mtime); 
    355477 
     
    361483        add_assoc_zval(return_value, "files", files_array); 
    362484 
    363         add_assoc_long(return_value, "shm_allocated", allocated_bytes); 
     485        add_assoc_long(return_value, "apparent_allocated", allocated_bytes); 
     486        add_assoc_long(return_value, "real_allocated", mm_maxsize() - mm_available(FASTXSL_G(cache)->mm)); 
    364487        add_assoc_long(return_value, "shm_maxsize", (long) mm_maxsize()); 
    365  
    366488        mm_unlock(FASTXSL_G(cache)->mm); 
     489} 
     490 
     491PHP_FUNCTION(fastxsl_xmlMemoryDump) 
     492{ 
     493  chdir("/tmp"); 
     494  xmlMemDisplay(stderr); 
    367495} 
    368496#endif 
     
    383511 
    384512        wrapper = (php_ss_wrapper *) SS_Wrapper_Alloc(0 TSRMLS_CC); 
     513        wrapper->alloc_type = FASTXSL_PRMALLOC; 
     514        Xml_UseAllocationFunctions(); 
    385515        wrapper->ss = xsltParseStylesheetFile(filename); 
    386516        if (!wrapper->ss) { 
     
    405535 
    406536        wrapper = XD_Wrapper_Alloc(); 
     537        wrapper->alloc_type = FASTXSL_PRMALLOC; 
     538        Xml_UseAllocationFunctions(); 
    407539        wrapper->xd = xmlParseDoc(text); 
    408540        if (!wrapper->xd) { 
     541                _XD_Wrapper_Dtor(wrapper); 
    409542                RETURN_FALSE; 
    410543        } 
     
    428561 
    429562        wrapper = XD_Wrapper_Alloc(); 
     563        wrapper->alloc_type = FASTXSL_PRMALLOC; 
    430564        wrapper->xd = xmlParseFile((const xmlChar *) filename); 
    431565        if (!wrapper->xd) { 
     566                _XD_Wrapper_Dtor(wrapper); 
    432567                RETURN_FALSE; 
    433568        } 
     
    499634        zval             *z_parameters; 
    500635        struct stat       sb; 
     636        int lockfd; 
    501637         
    502638        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|z", &ss_filename, &ss_filename_len, 
     
    515651 
    516652        result_wrapper = XD_Wrapper_Alloc(); 
    517  
    518         mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
     653        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
     654        lockfd = open(ss_filename, O_RDONLY); 
     655        if(lockfd < 0) { 
     656                /* FIXME non-existent file */ 
     657                RETURN_FALSE; 
     658        } 
    519659        if (!FASTXSL_G(nostat)) { 
    520                 if (stat(ss_filename, &sb) == -1) { 
     660                if (fstat(lockfd, &sb) == -1) { 
     661                        ShmCache_UseAllocationFunctions(); 
     662inshm = 1; 
    521663                        ShmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    522                         mm_unlock(FASTXSL_G(cache)->mm); 
     664inshm = 0; 
     665                        Xml_UseAllocationFunctions(); 
     666                        _XD_Wrapper_Dtor(result_wrapper); 
    523667                        free(parameters); 
     668                        close(lockfd); 
    524669                        RETURN_FALSE; 
    525670                } 
     
    527672                sb.st_mtime = 0; 
    528673        } 
    529          
     674        flock(lockfd, LOCK_EX); 
     675        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
    530676        ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     677        mm_unlock(FASTXSL_G(cache)->mm); 
    531678        if (!ss_wrapper) { 
     679                ShmCache_UseAllocationFunctions(); 
     680inshm = 1; 
    532681                ss_wrapper = ShmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime); 
     682inshm = 0; 
    533683                if (!ss_wrapper) { 
    534                         mm_unlock(FASTXSL_G(cache)->mm); 
     684                        flock(lockfd, LOCK_UN); 
     685                        close(lockfd); 
     686                        //xmlCleanupParserr(); 
     687                        Xml_UseAllocationFunctions(); 
     688                        _XD_Wrapper_Dtor(result_wrapper); 
    535689                        free(parameters); 
    536690                        RETURN_FALSE; 
     
    539693                if (!FASTXSL_G(nostat)) { 
    540694                        if (ss_wrapper->mtime != sb.st_mtime) { 
     695                                //xmlCleanupParserr(); 
     696                                ShmCache_UseAllocationFunctions(); 
     697inshm = 1; 
    541698                                ShmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    542699                                ss_wrapper = ShmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime TSRMLS_CC); 
     700inshm = 0; 
     701                                //xmlCleanupParserr(); 
     702                                Xml_UseAllocationFunctions(); 
    543703                                if (!ss_wrapper) { 
    544                                         mm_unlock(FASTXSL_G(cache)->mm); 
     704                                        flock(lockfd, LOCK_UN); 
     705                                        close(lockfd); 
     706                                        _XD_Wrapper_Dtor(result_wrapper); 
    545707                                        free(parameters); 
    546708                                        RETURN_FALSE; 
     
    549711                } 
    550712        } 
    551  
     713        ss_wrapper->hits++; 
     714        //xmlCleanupParserr(); 
     715        Xml_UseAllocationFunctions(); 
     716        flock(lockfd, LOCK_UN); 
     717        close(lockfd); 
    552718        result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
    553719                        (const char **) parameters); 
    554720 
    555         mm_unlock(FASTXSL_G(cache)->mm); 
    556721         
    557722        if (parameters)  
     
    595760 
    596761        result_wrapper = XD_Wrapper_Alloc(); 
     762        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
    597763 
    598764        if (!FASTXSL_G(nostat)) { 
    599765                if (stat(ss_filename, &sb) == -1) { 
    600766                        PrmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     767                        _XD_Wrapper_Dtor(result_wrapper); 
    601768                        free(parameters); 
    602769                        RETURN_FALSE; 
     
    610777                ss_wrapper = PrmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime TSRMLS_CC); 
    611778                if (!ss_wrapper) { 
     779                        _XD_Wrapper_Dtor(result_wrapper); 
    612780                        free(parameters); 
    613781                        RETURN_FALSE; 
     
    619787                                ss_wrapper = PrmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime TSRMLS_CC); 
    620788                                if (!ss_wrapper) { 
     789                                        _XD_Wrapper_Dtor(result_wrapper); 
    621790                                        free(parameters); 
    622791                                        RETURN_FALSE; 
     
    625794                } 
    626795        } 
    627  
     796        ss_wrapper->hits++; 
    628797        result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
    629798                        (const char **) parameters); 
     799        ////xmlCleanupParserr(); 
    630800 
    631801        if (parameters)  
     
    633803         
    634804        if (!result_wrapper->xd) { 
     805                _XD_Wrapper_Dtor(result_wrapper); 
    635806                RETURN_FALSE; 
    636807        }        
     
    667838 
    668839        result_wrapper = XD_Wrapper_Alloc(); 
    669          
     840        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
    670841        result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
    671842                        (const char **) parameters); 
     
    674845 
    675846        if (!result_wrapper->xd) { 
     847                _XD_Wrapper_Dtor(result_wrapper); 
    676848                RETURN_FALSE; 
    677849        }        
     
    721893 
    722894        result_wrapper = XD_Wrapper_Alloc(); 
     895        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
    723896 
    724897        result_wrapper->xd = xsltProfileStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
    725898                        (const char **) parameters, dbgprof); 
    726          
    727899        if (parameters)  
    728900                free(parameters); 
     
    731903         
    732904        if (!result_wrapper->xd) { 
     905                _XD_Wrapper_Dtor(result_wrapper); 
    733906                RETURN_FALSE; 
    734907        }        
     
    788961        ZEND_FETCH_RESOURCE(xd_wrapper, php_xd_wrapper *, &z_xd_wrapper, -1, "FastXSL XML Document",  
    789962                        le_fastxsl_document); 
    790  
     963        Xml_UseAllocationFunctions(); 
    791964        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
    792965        ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     966        mm_unlock(FASTXSL_G(cache)->mm); 
    793967        if (!ss_wrapper) { 
    794                 mm_unlock(FASTXSL_G(cache)->mm); 
    795968                RETURN_FALSE; 
    796969        } 
     970        ss_wrapper->hits++; 
    797971        xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->ss); 
    798         mm_unlock(FASTXSL_G(cache)->mm); 
    799972        if (result) { 
    800973                RETVAL_STRINGL((char *) result, length, 1); 
    801974                xmlFree(result); 
    802975        } else { 
    803                 RETURN_FALSE; 
    804         } 
     976                RETVAL_FALSE; 
     977        } 
     978        Xml_UseAllocationFunctions(); 
    805979} 
    806980#endif 
     
    8301004                RETURN_FALSE; 
    8311005        } 
     1006        ss_wrapper->hits++; 
    8321007        xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->ss); 
    8331008         
     
    8491024        PHP_FE(fastxsl_shmcache_tostring,            NULL) 
    8501025        PHP_FE(fastxsl_shmcache_getstatistics,       NULL) 
     1026        PHP_FE(fastxsl_xmlMemoryDump,                NULL) 
    8511027#endif 
    8521028        PHP_FE(fastxsl_prmcache_transform,           NULL) 
     
    8671043        fastxsl_functions, 
    8681044        PHP_MINIT(fastxsl), 
    869         NULL
    870         NULL,   
    871         NULL
     1045        PHP_MSHUTDOWN(fastxsl)
     1046        PHP_RINIT(fastxsl), 
     1047        PHP_RSHUTDOWN(fastxsl)
    8721048        PHP_MINFO(fastxsl), 
    8731049#if ZEND_MODULE_API_NO >= 20010901 
     
    8831059 
    8841060static void 
     1061_SS_Wrapper_Dtor(php_ss_wrapper *wrapper) 
     1062{ 
     1063        if(wrapper->ss) { 
     1064                if(wrapper->alloc_type == FASTXSL_SHMALLOC) { 
     1065                        //xmlCleanupParserr(); 
     1066                        ShmCache_UseAllocationFunctions(); 
     1067                } else { 
     1068                        Xml_UseAllocationFunctions(); 
     1069                } 
     1070                inshm = 1; 
     1071                xsltFreeStylesheet(wrapper->ss); 
     1072                inshm = 0; 
     1073                if(wrapper->alloc_type == FASTXSL_SHMALLOC) { 
     1074                        //xmlCleanupParserr(); 
     1075                        Xml_UseAllocationFunctions(); 
     1076                } 
     1077        } 
     1078        if(wrapper->persistant) { 
     1079                mm_free(FASTXSL_G(cache)->mm, wrapper); 
     1080        } else { 
     1081                free(wrapper); 
     1082        } 
     1083} 
     1084 
     1085static void 
    8851086SS_Wrapper_Dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) 
    8861087{ 
    8871088        php_ss_wrapper *wrapper = (php_ss_wrapper *) rsrc->ptr; 
    888          
    8891089        if (wrapper->persistant) { 
    8901090                return; 
    8911091        } 
    892          
    893         if (wrapper->ss) 
    894                 xsltFreeStylesheet(wrapper->ss); 
    895  
     1092        _SS_Wrapper_Dtor(wrapper); 
     1093
     1094 
     1095static void _XD_Wrapper_Dtor(php_xd_wrapper *wrapper) { 
     1096        if (wrapper->xd) { 
     1097                if(wrapper->alloc_type == FASTXSL_SHMALLOC) { 
     1098                        ShmCache_UseAllocationFunctions(); 
     1099                } else { 
     1100                        Xml_UseAllocationFunctions(); 
     1101                } 
     1102inshm = 1; 
     1103                xmlFreeDoc(wrapper->xd); 
     1104inshm = 0; 
     1105                Xml_UseAllocationFunctions(); 
     1106        } 
    8961107        free(wrapper); 
    8971108} 
     
    9011112{ 
    9021113        php_xd_wrapper *wrapper = (php_xd_wrapper *) rsrc->ptr; 
    903          
    904         if (wrapper->xd) 
    905                 xmlFreeDoc(wrapper->xd); 
    906         free(wrapper); 
     1114        _XD_Wrapper_Dtor(wrapper); 
    9071115} 
    9081116 
     
    9821190         
    9831191        globals->cache = calloc(1, sizeof(fl_cache)); 
     1192        //pool_init(globals); 
    9841193} 
    9851194 
     
    9951204                        return; 
    9961205                } 
    997 #ifdef FASTXSL_MM 
    998                 mm_lock(cache->mm, MM_LOCK_RW); 
    999                 fl_hash_free(cache->table); 
    1000                 mm_unlock(cache->mm); 
    1001  
    1002                 mm_destroy(cache->mm); 
    1003 #endif 
    10041206                fl_hash_free(cache->prmtable); 
    10051207        } 
     1208        if(globals->pool) { free(globals->pool); } 
    10061209} 
    10071210 
     
    10221225         
    10231226        tctxt = (xsltTransformContextPtr) xsltXPathGetTransformContext(ctxt); 
     1227        ////xmlCleanupParserr(); 
    10241228        if (tctxt == NULL) { 
    10251229                xsltGenericError(xsltGenericErrorContext, 
     
    11371341        le_fastxsl_document   = zend_register_list_destructors_ex(XD_Wrapper_Dtor, NULL,  
    11381342                        le_fastxsl_document_name,   module_number); 
    1139  
     1343#ifdef FASTXSL_MM 
     1344        if (!sprintf(euid, "%d", geteuid())) { 
     1345                return FAILURE; 
     1346        } 
     1347 
     1348        shmpath_len = strlen(FASTXSL_G(shmpath)) + strlen(euid); 
     1349        shmpath = do_alloca(shmpath_len + 1); 
     1350 
     1351        strcpy(shmpath, FASTXSL_G(shmpath)); 
     1352        strcat(shmpath, euid); 
     1353         
     1354        FASTXSL_G(cache)->owner = getpid(); 
     1355        FASTXSL_G(cache)->mm = mm_create(0, shmpath); 
     1356        free_alloca(shmpath); 
     1357        if (!FASTXSL_G(cache)->mm) { 
     1358                return FAILURE; 
     1359        } 
     1360 
     1361        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
     1362        FASTXSL_G(cache)->table = fl_hash_new(&mm_allocators, NULL); 
     1363        mm_unlock(FASTXSL_G(cache)->mm); 
     1364#endif 
     1365        FASTXSL_G(cache)->prmtable = fl_hash_new(&normal_allocators, NULL); 
     1366        //xmlGcMemGet(&free_ptr, &malloc_ptr, &mallocatomic_ptr, &realloc_ptr, &strdup_ptr); 
     1367        xmlMemGet(&free_ptr, &malloc_ptr, &realloc_ptr, &strdup_ptr); 
     1368        //xmlCleanupParserr(); 
     1369        ShmCache_UseAllocationFunctions(); 
     1370inshm = 1; 
    11401371        xsltRegisterAllExtras(); 
    11411372#if HAVE_DOMEXSLT 
     
    11451376        xmlLoadExtDtdDefaultValue = 1; 
    11461377 
    1147         xmlMemGet(&free_ptr, &malloc_ptr, &realloc_ptr, &strdup_ptr); 
    11481378        xmlRegisterOutputCallbacks(Stream_MatchWrapper, Stream_XmlWrite_OpenWrapper,  
    11491379                                           Stream_XmlWrite_WriteWrapper, Stream_CloseWrapper); 
    11501380        xsltSetGenericErrorFunc(NULL, fastxsl_errorfunc); 
    11511381        xmlSetGenericErrorFunc(NULL, fastxsl_errorfunc); 
    1152 #ifdef FASTXSL_MM 
    1153         if (!sprintf(euid, "%d", geteuid())) { 
    1154                 return FAILURE; 
    1155         } 
    1156  
    1157         shmpath_len = strlen(FASTXSL_G(shmpath)) + strlen(euid); 
    1158         shmpath = do_alloca(shmpath_len + 1); 
    1159  
    1160         strcpy(shmpath, FASTXSL_G(shmpath)); 
    1161         strcat(shmpath, euid); 
    1162          
    1163         FASTXSL_G(cache)->owner = getpid(); 
    1164         FASTXSL_G(cache)->mm = mm_create(0, shmpath); 
    1165  
    1166         free_alloca(shmpath); 
    1167         if (!FASTXSL_G(cache)->mm) { 
    1168                 return FAILURE; 
    1169         } 
    1170  
    1171         mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
    1172         FASTXSL_G(cache)->table = fl_hash_new(&mm_allocators, NULL); 
    1173         mm_unlock(FASTXSL_G(cache)->mm); 
    1174 #endif 
    1175         FASTXSL_G(cache)->prmtable = fl_hash_new(&normal_allocators, NULL); 
    11761382         
    11771383        if(FASTXSL_G(register_functions)) { 
     
    11801386                                           fastxsl_ext_function); 
    11811387        } 
     1388        //xmlCleanupParserr(); 
     1389inshm = 0; 
     1390        Xml_UseAllocationFunctions(); 
    11821391        return SUCCESS; 
     1392} 
     1393 
     1394PHP_MSHUTDOWN_FUNCTION(fastxsl) 
     1395{ 
     1396  UNREGISTER_INI_ENTRIES(); 
     1397} 
     1398PHP_RINIT_FUNCTION(fastxsl) 
     1399{ 
     1400#ifdef FASTXSL_MM 
     1401  /* just in case, set back the allocators */ 
     1402  Xml_UseAllocationFunctions(); 
     1403#endif 
     1404} 
     1405PHP_RSHUTDOWN_FUNCTION(fastxsl) 
     1406{ 
     1407#ifdef FASTXSL_MM 
     1408  /* just in case, set back the allocators */ 
     1409  Xml_UseAllocationFunctions(); 
     1410#endif 
    11831411} 
    11841412 
  • trunk/fl_hash.c

    r17 r18  
    7474        FL_Bucket       *b; 
    7575        unsigned int  hash = hash_hash(key, length) % FL_HASH_SIZE; 
    76  
    7776        for (b = table->buckets[ hash ]; b; b = b->next) { 
    7877                if (hash != b->hash) continue; 
    7978                if (length != b->length) continue; 
    8079                if (memcmp(key, b->key, length)) continue; 
    81  
    8280                return b->data; 
    8381        } 
     
    8684} 
    8785 
    88 void fl_hash_add(FL_Hash *table, char *key, int length, void *data) 
     86int fl_hash_add(FL_Hash *table, char *key, int length, void *data) 
    8987{ 
    90         FL_Bucket       *b
     88        FL_Bucket       *b, *ptr
    9189        unsigned int  hash; 
    9290         
    9391        hash = hash_hash(key, length) % FL_HASH_SIZE; 
     92        /* check hash for dupes */ 
     93        ptr = table->buckets[ hash ]; 
     94        while(ptr) { 
     95                if(!strcmp(ptr->key, key)) { 
     96                        return 0; 
     97                } 
     98                ptr = ptr->next; 
     99        } 
    94100 
    95101        b = table->mems->malloc_func(sizeof(FL_Bucket)); 
     
    100106        b->hash = hash; 
    101107        b->data = data; 
    102  
    103108        b->next = table->buckets[ hash ]; 
    104109 
    105110        table->buckets[ hash ] = b; 
    106111        table->nElements++; 
     112        return 1; 
    107113} 
    108114 
  • trunk/fl_hash.h

    r1 r18  
    5353void fl_hash_free(FL_Hash *table); 
    5454void *fl_hash_find(FL_Hash *table, const void *key, int length); 
    55 void fl_hash_add(FL_Hash *table, char *key, int length, void *data); 
     55int fl_hash_add(FL_Hash *table, char *key, int length, void *data); 
    5656void fl_hash_delete(FL_Hash *table, char *key, int length); 
    5757#endif 
  • trunk/php_fastxsl.h

    r11 r18  
    6565PHP_MINIT_FUNCTION(fastxsl); 
    6666PHP_MSHUTDOWN_FUNCTION(fastxsl); 
     67PHP_RINIT_FUNCTION(fastxsl); 
     68PHP_RSHUTDOWN_FUNCTION(fastxsl); 
    6769PHP_MINFO_FUNCTION(fastxsl); 
     70 
     71#define FASTXSL_PRMALLOC 0 
     72#define FASTXSL_SHMALLOC 1 
    6873 
    6974typedef struct { 
     
    7883typedef struct { 
    7984        xmlDocPtr xd; 
     85        int alloc_type; 
    8086} php_xd_wrapper; 
    8187 
     
    8490        int allocsize; 
    8591        time_t mtime; 
     92        int hits; 
    8693        int persistant; 
     94        int alloc_type; 
    8795} php_ss_wrapper; 
    8896 
     
    94102        long      register_functions; 
    95103        long      tmp_allocated_size; 
     104        void     ***pool; 
     105        int      *pool_offset; 
     106        int      *pool_allocd; 
    96107} zend_fastxsl_globals; 
    97108