Optimizer

Compiling
  DEBUG MODE
      Set the preprocessor constant OPTIMIZER_DEBUG_COMPILE to 1 to turn debug 
    code on in the optimizer. This is mainly used for development.
    
    NOTE: When compiling with debug mode, the VLD extension is required. 
    
  STASTICS MODE
      Set the preprocessor constant OPTIMIZER_STATS_COMPILE to 1 to turn on 
    statistics gathering in the optimizer. This will gather information on the 
    op-array before and after the optimizer in order to gauge effectiveness of 
    the optimizer. In addition it will keep track of the number of optimizations
    that occur. 
    
    NOTE: if both OPTIMIZER_DEBUG_COMPILE and OPTIMIZER_STATS_COMPILE are set to
      1 then the optimizer will build a list of optimizations that occurred on a 
      given op-array and bump that. This is a great tool to see what is actually 
      going on inside the optimizer.
    
  TEST MODE
      In order to run the automated tests (by running "make test") the optimizer 
    must be compiled with OPTIMIZER_TEST_COMPILE set to 1. 
    
  STANDARD
      Standard compiling doesn't make use of any preprocessor constants and 
    should provide for a transparent running of the optimizer that does not 
    print out any data. BOTH DEBUG MODE and STAISTICS MODE will print extra 
    information out to stdout or stderr. 
    
    
Dependencies
  The optimizer is dependent on a few other PECL extensions to run.
  
  APC: Currently the optimizer only works with the APC opcode cache. 
  VLD: If you plan on compiling and running the optimizer in debug mode the VLD 
         extension is required.
    
INI values
  optimizer.enabled: Turns the optimizer on or off. When enabled=0 the optimizer 
      will NOT register hooks with APC.
      
  optimizer.verbose_debug: Allows for the printing of debug information (This 
      will probably be removed... but its handy to specify on the command line 
      while developing)
      
  optimizer.detect_static_function_calls: Used for building the optimizer (and 
      maybe an analyzer), this will output a line to indicate that a function 
      call with all static params was NOT optimized out.
      
  optimizer.report_constants:
  
  optimizer.report_only_native_func:
  
  optimizer.optimize_define: If set to 1 define() statements will be optimized 
      (this is a little bit buggy right now...)
  
  optimizer.optimize_assert: If set to 1 assert() statements will be removed.
  
  optimizer.inline_server: _SERVER variables that are safe to fold into static 
      literal values.
      
  optimizer.optimize_file_ops: If set to 1 some file operations will be 
      performed at compile time as opposed to execution time. These 
      optimizations will ONLY occur when a all static parameters are being 
      passed to one of the file functions (for example... a string literal for a
      file name/path). Constant folding and DFA might effect this and therefore, 
      these optimizations may occur on more then just for functions with all 
      static parameters in source. It is important that this is ONLY done in 
      cases that you know the state of certain files will NOT change on the 
      server after compilation time and during the life cycle of the cached 
      op-code. 
      
      The optimizable file functions are as follows:
        file_exists()
        is_link()
        is_dir()
        is_file()
        is_executable()
        is_readable()
        is_writeable()
        fileatime()
        filectime()
        filegroup()
        fileinode()
        filemtime()
        fileowner()
        fileperms()
        filesize()
        filetype()
  
  
  
Testing
    To run the automated testing the optimizer must be compiled with 
  OPTIMIZER_TESTS_COMPILE set to 1. In addition it helps to add 
  "-d optimizer.enabled=0" to the Makefile in order to prevent run-tests from 
  being optimized. Then just run "make test"

