home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / sdk / bin / cap.txt < prev    next >
Encoding:
Text File  |  1995-07-11  |  23.9 KB  |  656 lines
  1.  
  2.                 Microsoft Windows NT Call Profiler README File
  3.  
  4.                              written:  March 06, 1992
  5.                        last modified:  May   13, 1995
  6.  
  7.  
  8.  
  9. 1.  Description:
  10. ----------------
  11.  
  12.         Windows NT (32-bit) Call/Attributive Profiler (CAP) for x86, Mips,
  13.         Alpha, and PowerPC platforms.
  14.  
  15.         CAP is a general purpose profiling tool that can be used to measure
  16.         the function call performance of .EXE's and .DLL's, (AKA modules),
  17.         in a variety of ways.  The following measurement methods are
  18.         supported:
  19.  
  20.             a)  Measuring calls from within an .EXE.
  21.  
  22.             b)  Measuring calls from within a .DLL.
  23.  
  24.             c)  Measuring calls from an .EXE to all of it's DLLs.
  25.  
  26.             d)  Measuring calls from one .DLL to all of its DLLs.
  27.  
  28.             e)  Measuring all the calls to specified .DLL's, from
  29.                 any .EXE or .DLL.
  30.  
  31.             f)  Any arbitrary combination of a) through e).
  32.  
  33.         CAP creates a call tree of all the functions called in the EXE(s)/
  34.         DLL(s) being profiled.
  35.  
  36.         Profiling Data can be collected only for functions in C programs by
  37.         using the attributed profiling hook provided by the Microsoft C
  38.         compiler (compiling with the "-Gh" option).  Data is *NOT* collected
  39.         for functions in assembler language programs.
  40.  
  41.  
  42.  
  43. 2.  Profiling Files:
  44. --------------------
  45.  
  46.         o  cap.ini       -- Call Profiler initialization file.
  47.         o  cap.dll       -- Call Profiler DLL.
  48.         o  cap.lib       -- Profiler library file containing profiling entry
  49.                             points.
  50.         o  capdump.exe   -- Dump utility for dumping/clearing profiling
  51.                             data, and stopping profiling at any time.
  52.         o  capsetup.exe  -- Allows attaching/detaching cap.dll to/from all
  53.                             Windows applications.
  54.         o  penter.lib    -- An empty library containing a dummy CAP entry point.
  55.                             This can be used instead of CAP.lib to link with an
  56.                             already CAP ready executable object modules
  57.                             (recompiled with the -Gh option) so the application
  58.                             can run without recompiling and without any of the
  59.                             CAP overheads.
  60.         o  sol.end       -- A sample CAP data file generated by a sample
  61.                             profile run of sol.exe.
  62.         o  cap.txt       -- Call Profiler README document (this file).
  63.  
  64.         o  capview       -- CapView is a program which provides a visual method
  65.                             of looking at the output from the CAP profiler.
  66.         o  Capstats      -- Capstats is a utility for parsing and summarizing
  67.                             data in .cap files.  See capstats.txt.
  68.  
  69.  
  70.  
  71.  
  72. 3.  Using the Call Profiler:
  73. ----------------------------
  74.  
  75.  
  76.  
  77.         o  Place a copy of CAP.INI in one of the following area where it
  78.            suits your need:
  79.            - the CURRENT directory
  80.            - the Windows directory (ie: c:\windows\cap.ini)
  81.            - the root of the current drive (\cap.ini)
  82.            - the root dir of C: drive (c:\cap.ini)
  83.  
  84.            list all the DLL/EXE images to be profiled as follows:
  85.  
  86.            (Note:  CAP.INI and all its three section headers must exist but the
  87.             sections could be left blank)
  88.  
  89.            [EXES]
  90.            Name of applications to be profiled. Each name should be on a
  91.            new line.
  92.  
  93.            [PATCH IMPORTS]
  94.            List of DLLs/EXEs to be profiled for all of their imported entries.
  95.            Each name should be on a new line.
  96.  
  97.            [PATCH CALLERS]
  98.            List of DLLs to be profiled for their exported entries if called
  99.            from the applications (listed in the [EXE] section) or any of their
  100.            DLLs.  Each name should be on a new line.
  101.  
  102.            [NAME LENGTH]
  103.            This is an optional section allowing to specify the maximum number of
  104.            characters to be printed for the routine name in the output data
  105.            files.  If the value is not specified or 0, default length of 40 is
  106.            used.  Length can be any value between 20 and 2048.
  107.  
  108.            [CHRONO FUNCS]
  109.            List of modules and corresponding functions that start the dump
  110.            of the chronological listing.  For example, if "test=SomeFunc" is
  111.            listed under this section then all functions that are called
  112.            inside of test!SomeFunc... will be listed until the call depth
  113.            is less than or equal to the depth of the listed function.
  114.  
  115.            [EXCLUDE FUNCS]
  116.            List of modules and corresponding functions that will be excluded
  117.            from the profiling process.  The [call _penter] at the beginning
  118.            of the function will be NOPed.  But if these functions call
  119.            some other functions and if these children functions are not listed
  120.            under this section, they will still be included in the profiling
  121.            process.  To correctly take a function out of the profiling
  122.            process, him and his children must all be included under this
  123.            section.  If not, the timing of the Excluded function will be
  124.            included with its parent routine while the timing of its children
  125.            routine will still be computed separately.
  126.  
  127.            [OUTPUT FILE]
  128.            filename=xxxxx
  129.            This option allows the user to specify a different drive for the
  130.            output listing.  This file can be over the net somewhere or just
  131.            a different name than xxxx.END or xxxx.CAP.  For example:
  132.                 filename=c:\results\explorer\explorer.cap            or
  133.                 filename=\\Results\CAP\explorer\explorer.pro
  134.  
  135.            [CAP FLAGS]
  136.            - profile
  137.              "on" or "off".  Turn on or off profiling initially without
  138.              altering the code.
  139.            - dumpbinary
  140.              "on" or "off".  This is to allow the dumping of the data in binary form,
  141.              not in the regular text form.  This feature is there to allow faster
  142.              dumping and require less space.
  143.            - capthread
  144.              "on" or "off".  If on, this switch will start the 3 threads that will
  145.              interact with CAPDUMP to Clear, Start and Stop the collection of data.
  146.              This is made into an option so if the user does not need CAPDUMP, he/she
  147.              does not have to start 3 additional threads everytime CAP is initialized.
  148.              This is quite expensive when profiling a number of processes at the same
  149.              time.
  150.            - loadlibrary
  151.              "on" or "off".  If on, CAP will intercept all LoadLibrary calls from the
  152.              profiled binary and correctly initializes its symbol table.
  153.            - setjump
  154.              "on" or "off".  If on, CAP will also intercept longjmp instructions and
  155.              handled it accordingly.
  156.            - undecoratename
  157.              "on" or "off".  Turn on or off the undecoration of function
  158.              names.
  159.            - excelaware
  160.              "on" or "off". Turn on or off the addition of delimiters so
  161.              the output listing can be imported into Excel.
  162.            - regular dump
  163.              "on" or "off".  Turn on or off the regular data that CAP dumps out.
  164.              This is to shorten the output listing if you are only interested in
  165.              the chronological listings.
  166.            - chronocollect
  167.              "on" or "off".  Turn on or off the collection of the chronological
  168.              listing of the functions. This could be very lengthy.
  169.            - chronodump
  170.              "on" or "off".  Turn on or off the output for the chrono listing.
  171.              This switch is independent of [chronocollect] since sometimes you
  172.              just want to turn off the dumping but leaving the collection alone.
  173.            - slowsymbols
  174.              "on" or "off".  Turn on or off exhaustive lookup of symbols.  If
  175.              off, addresses for which symbols cannot be quickly found (e.g.
  176.              static symbols) are printed as absolute addresses versus a symbol
  177.              plus offset in the on case.
  178.  
  179.         o  Attach CAP.DLL to the application process. This can be done in two
  180.            ways:
  181.  
  182.            1)  Recompile your EXE/DLL using the "-Gh" and "-Zd" compiler
  183.                options.  (NOTE - on Mips platform, use "-Od" to disable
  184.                compiler optimization.)
  185.  
  186.                Link it with CAP.LIB using the "-debugtype:coff" and
  187.                "-debug:mapped,partial" linker options.
  188.  
  189.                This method will cause all the C functions in the recompiled
  190.                sources to be profiled.
  191.  
  192.                NOTE:  The win32.mak file in the Win32 SDK will set these
  193.                options correctly for your application if you build it with
  194.                the profile=1 switch.  I.e.  "nmake -all profile=1".
  195.  
  196.                NOTE:-  If symbols have been removed from your exe
  197.                or dll, Cap will try to locate the symbols files (DBG
  198.                files) using the path as specified in the environment
  199.                variable "_nt_symbol_path".
  200.                E.G. if the DBG file of your exe is in c:\symbols\exe, set
  201.                _nt_symbol_path to c:\symbols.
  202.  
  203.            2)  Run CapSetup.exe to attach CAP.DLL to all Windows applications.
  204.                Note that only those EXEs listed in the [EXES] section of
  205.                CAP.INI will be profiled.  Overhead for the non-profiled
  206.                applications is minimal.  See section 8, "Using CapSetup",
  207.                for CapSetup.exe usage.  You need to have Administrative
  208.                privileges in order to run CapSetup.
  209.  
  210.                *** Please be extremely careful with this option since turning
  211.                *** it on could resulted in the system being totally thrashed
  212.                *** if CAP.DLL could not run correctly.  Thus causing the
  213.                *** profiled binary to fail to load also.  And if the binary
  214.                *** is as important as WINLOGON, then the only thing to do
  215.                *** is to reload NT or use a dummy cap.dll or remove the 
  216.                *** CAP.INI file.
  217.  
  218.                NOTE:  If you use this second (capsetup) method with the default
  219.                cap.ini you will get an empty log file at the end.  Unlike the
  220.                first method, it is necessary to explicitly list the modules
  221.                whose functions you want profiled in the PATCH IMPORTS or PATCH
  222.                CALLERS sections of cap.ini.
  223.  
  224.  
  225.         o  Place CAP.DLL in your SYSTEM directory (i.e. ..\nt\system32).
  226.  
  227.         o  Run your applications.
  228.  
  229.         o  All the applications specified in the [EXES] section of the CAP.INI
  230.            will be profiled.
  231.  
  232.         o  Exit the application to dump the profiling data, or run CapDump.exe
  233.            to dump the data.  See section 6 "Profiling Data" for details.
  234.  
  235.  
  236.  
  237. 4.  Examples for Supported Measurement Methods:
  238. ----------------------------------------------
  239.  
  240.         Suppose we have Windows .EXE's called ZOOMAN and HUNTED, and .DLLs
  241.         called ELEPHANT, MONKEY, SNAKE, WATER, and FOOD.  Let's assume the
  242.         following intercall dependencies exist:
  243.  
  244.         zooman.exe
  245.             - water.dll
  246.             - food.dll
  247.  
  248.         hunted.exe
  249.             - elephant.dll
  250.                 -- water.dll
  251.                 -- food.dll
  252.             - monkey.dll
  253.                 -- water.dll
  254.                 -- food.dll
  255.             - snake.dll
  256.  
  257.  
  258.  
  259.         a) Measuring calls from within ZOOMAN.EXE:
  260.  
  261.             o Recompile ZOOMAN and link it with CAP.LIB as described in
  262.               section 3.
  263.  
  264.             o Setup CAP.INI as follows:
  265.  
  266.               [EXES]
  267.               zooman.exe
  268.  
  269.               [PATCH IMPORTS]
  270.  
  271.               [PATCH CALLERS]
  272.  
  273.               [NAME LENGTH]
  274.               60
  275.  
  276.             o All the C functions in ZOOMAN.EXE will be profiled by CAP.
  277.  
  278.  
  279.  
  280.         b) Measuring calls from within WATER.DLL:
  281.  
  282.             o Recompile WATER and link it with CAP.LIB as described in
  283.               section 3.
  284.  
  285.             o Setup CAP.INI as follows:
  286.  
  287.               [EXES]
  288.               zooman.exe
  289.               hunted.exe
  290.  
  291.               [PATCH IMPORTS]
  292.  
  293.               [PATCH CALLERS]
  294.  
  295.               [NAME LENGTH]
  296.  
  297.             o Both ZOOMAN.EXE and HUNTED.EXE will be profiled for all the
  298.               C functions within WATER.DLL.
  299.  
  300.  
  301.  
  302.          c) Measuring calls from HUNTED.EXE to it's DLLs:
  303.  
  304.             o Run CapSetup.exe to attach cap.dll to all Windows Applications,
  305.               and reboot the system.
  306.  
  307.             o Setup CAP.INI as follows:
  308.  
  309.               [EXES]
  310.               hunted.exe
  311.  
  312.               [PATCH IMPORTS]
  313.               hunted.exe
  314.  
  315.               [PATCH CALLERS]
  316.  
  317.               [NAME LENGTH]
  318.  
  319.             o All the calls from HUNTED.EXE to ELEPHANT.DLL, MONKEY.DLL,
  320.               and SNAKE.DLL will be profiled.  These are all the C functions
  321.               exported by ELEPHANT, MONKEY, and SNAKE DLLs which are used
  322.               by HUNTED.exe.
  323.  
  324.  
  325.  
  326.          d) Measuring calls from ELEPHANT.DLL and MONKEY.DLL to their DLLs:
  327.  
  328.             o Run CapSetup.exe to attach cap.dll to all Windows Applications,
  329.               and reboot the system.
  330.  
  331.             o Setup CAP.INI as follows:
  332.  
  333.               [EXES]
  334.               hunted.exe
  335.  
  336.               [PATCH IMPORTS]
  337.               elephant.dll
  338.               monkey.dll
  339.  
  340.               [PATCH CALLERS]
  341.  
  342.               [NAME LENGTH]
  343.  
  344.             o All calls from ELEPHANT.DLL and MONKEY.DLL to WATER.DLL and
  345.               FOOD.DLL will be measured.  These are all the C functions
  346.               exported by WATER and FOOD DLLs which are used by either
  347.               ELEPHANT.DLL or MONKEY.DLL.
  348.  
  349.  
  350.  
  351.          e) Measuring all the calls to FOOD.DLL:
  352.  
  353.             o Run CapSetup.exe to attach cap.dll to all Windows Applications,
  354.               and reboot the system.
  355.  
  356.             o Setup CAP.INI as follows:
  357.  
  358.               [EXES]
  359.               zooman.exe
  360.               hunted.exe
  361.  
  362.               [PATCH IMPORTS]
  363.  
  364.               [PATCH CALLERS]
  365.               food.dll
  366.  
  367.               [NAME LENGTH]
  368.  
  369.             o Both ZOOMAN.EXE and HUNTED.EXE will be profiled separately for
  370.               all the calls to FOOD.DLL.  For ZOOMAN.EXE, these are all the
  371.               C functions exported by FOOD.DLL which are used by ZOOMAN.EXE.
  372.               And for HUNTED.EXE these are all the C functions exported by
  373.               FODD.DLL which are used by either ELEPAHNT.DLL or MONKEY.DLL.
  374.  
  375.  
  376.          f) Any arbitrary combination of a) through e):
  377.  
  378.             a+c) Measuring calls from within ZOOMAN.EXE and calls to it's DLLs:
  379.  
  380.             o Recompile ZOOMAN and link it with CAP.LIB as described in
  381.               section 3.
  382.  
  383.             o Setup CAP.INI as follows:
  384.  
  385.               [EXES]
  386.               zooman.exe
  387.  
  388.               [PATCH IMPORTS]
  389.               zooman.exe
  390.  
  391.               [PATCH CALLERS]
  392.  
  393.               [NAME LENGTH]
  394.  
  395.  
  396.             c+d) Measuring calls from HUNTED.EXE to it's DLLs and calls from
  397.                  ELEPHANT and MONKEY DLLs to their DLLs:
  398.  
  399.             o Run CapSetup.exe to attach cap.dll to all Windows Applications,
  400.               and reboot the system.
  401.  
  402.             o Setup CAP.INI as follows:
  403.  
  404.               [EXES]
  405.               hunted.exe
  406.  
  407.               [PATCH IMPORTS]
  408.               hunted.exe
  409.               elephant.dll
  410.               monkey.dll
  411.  
  412.               [PATCH CALLERS]
  413.  
  414.               [NAME LENGTH]
  415.  
  416.  
  417.             a+c+d) Measuring calls from within HUNTED.EXE and calls to its DLLs
  418.                    plus calls from ELEPHANT and MONKEY DLLs to their DLLs:
  419.  
  420.             o Recompile HUNTED and link it with CAP.LIB as described in
  421.               section 3.
  422.  
  423.             o Setup CAP.INI as follows:
  424.  
  425.               [EXES]
  426.               hunted.exe
  427.  
  428.               [PATCH IMPORTS]
  429.               hunted.exe
  430.               elephant.dll
  431.               monkey.dll
  432.  
  433.               [PATCH CALLERS]
  434.  
  435.               [NAME LENGTH]
  436.  
  437.  
  438.             b+d) Measuring calls from within ELEPHANT.DLL and calls to its DLLs:
  439.  
  440.             o Recompile ELEPHANT and link it with CAP.LIB as described in
  441.               section 3.
  442.  
  443.             o Setup CAP.INI as follows:
  444.  
  445.               [EXES]
  446.               hunted.exe
  447.  
  448.               [PATCH IMPORTS]
  449.               elephant.dll
  450.  
  451.               [PATCH CALLERS]
  452.  
  453.               [NAME LENGTH]
  454.  
  455.  
  456.               * * * * * * * * * * * * *
  457.          * * *  R E S T R I C T I O N  * * *
  458.               * * * * * * * * * * * * *
  459.  
  460.          Do NOT measure calls within a DLL if the DLL's exported functions
  461.          are being measured from another EXE/DLL.  The following example shows
  462.          this incorrect combination which should be avoided:
  463.  
  464.             x) Measuring calls from ZOOMAN.EXE to its DLLs and calls within
  465.                WATER.DLL:
  466.  
  467.             o Recompile WATER and link it with CAP.LIB as described in
  468.               section 3.
  469.  
  470.             o Setup CAP.INI as follows:
  471.  
  472.               [EXES]
  473.               zooman.exe
  474.  
  475.               [PATCH IMPORTS]
  476.               zooman.exe
  477.  
  478.               [PATCH CALLERS]
  479.  
  480.               [NAME LENGTH]
  481.  
  482.             o Note that in addition to measuring all C functions (including the
  483.               exported routines) within WATER.DLL, all the C functions exported
  484.               by WATER.DLL which are used by ZOOMAN.EXE are measured.  This
  485.               means that the same function within WATER.DLL will be measured
  486.               twice. These types of scenarios are not supported and will result
  487.               in unexpected behavior.
  488.  
  489.  
  490.  
  491.  
  492. 5.  Exported Routines:
  493. ----------------------
  494.  
  495.         The exported entry points listed below can be used to control
  496.         profiling certain sections of code.  They can be combined with
  497.         any of the supported measurement methods mentioned above.
  498.  
  499.         o  StartCAP() : Clears profiling data & starts profiling
  500.         o  StopCAP()  : Stops profiling
  501.         o  DumpCAP()  : Dumps data for the current CAP.DLL instance
  502.  
  503.         A typical example (foo.exe):
  504.  
  505.             StartCAP();         // Clear existing profiling data and restart
  506.                                 // profiling.
  507.             ..
  508.             ..                  // application's code
  509.             ..
  510.  
  511.             StopCAP();          // Stop profiling without dumping data.
  512.             DumpCAP();          // Dump profiling data to FOO.CAP file.
  513.  
  514.         Prototypes for these routines are:
  515.  
  516.         extern void _stdcall StartCAP(void);
  517.         extern void _stdcall StopCAP(void);
  518.         extern void _stdcall DumpCAP(void);
  519.  
  520.  
  521. 6.  Profiling Data:
  522. -------------------
  523.  
  524.         o  Profiling data can be captured in three ways:
  525.  
  526.            1)  Upon termination of the application profiling data is dumped
  527.                into a text file using the application name with .END
  528.                extension.
  529.  
  530.            2)  Using the dump utility, CapDump.exe, profiling data can be
  531.                dumped at any time.  Application name with .CAP extension will
  532.                be the data file name.  See section 7 "Using CapDump" for more
  533.                details.
  534.  
  535.            3)  Using exported routine DumpCAP().  Application name with .CAP
  536.                extension will be the data file name.
  537.  
  538.  
  539.         o  Data files are created in the same directory as the application
  540.            that is being profiled.
  541.  
  542.         o  Data is appended to data files with each data dump.
  543.  
  544.         o  A separate call tree is generated for each thread in the process
  545.            context.  Different sections in the data file indicates data for
  546.            different threads in the process.
  547.  
  548.         o  The following data is dumped:
  549.  
  550.            - Call depth in the tree
  551.            - Function name
  552.            - Number of calls
  553.            - Total time for the function+callees
  554.            - Time per call for the function+callees
  555.            - Total time of the function only
  556.            - Time per call of the function only
  557.            - First time (function+callees)
  558.            - Minimum time (function+callees)
  559.            - Maximum time (function+callees)
  560.  
  561.         o  See SOL.END as a sample output file.
  562.  
  563.  
  564.  
  565. 7.  Using CapDump:
  566. ------------------
  567.  
  568.         o  CapDump.exe can be used to stop profiling and clear/dump
  569.            profiling data for all the applications being profiled, at
  570.            any time.
  571.  
  572.         o  The following options are available via CapDump.exe:
  573.  
  574.               - Stop : Stops profiling (applications continue to run).
  575.  
  576.               - Clear and Restart : Clears any existing profiling data and
  577.                                     restarts profiling.
  578.  
  579.               - Dump and Stop : Dumps any existing profiling data and stops
  580.                                 profiling (applications continue to run).
  581.  
  582.         o  Data is dumped to a text file using the profiling applications name
  583.            with .CAP extension. All fields are tab separated.   Data is
  584.            appended to data files with each dump.
  585.  
  586.         o  If calls are being profiled when data clearing is requested,
  587.            the time of clearing is used as the starting time for those
  588.            calls.
  589.  
  590.         o  A log file, capdump.log, is generated when capdump.exe is run.  It
  591.            will contain any errors that might occur during capdump.exe operation
  592.            and for normal error free operation, capdump.log will be empty.
  593.  
  594.  
  595.  
  596. 8.  Using CapSetup:
  597. -------------------
  598.  
  599.         Usage:  CapSetup  -A | -D
  600.  
  601.           -A    Attaches CAP.dll to all Windows applications
  602.           -D    Detaches CAP.dll from all Windows applications
  603.  
  604.           Notes:  1)  Administrative privileges are required in order to run
  605.                       CapSetup.
  606.                   2)  System needs to be rebooted in order for the change to
  607.                       take effect.
  608.  
  609.           This works by writing cap.dll to the HKEY_LOCAL_MACHINE\SOFTWARE\
  610.           Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs key in the
  611.           registry, which causes cap.dll to be loaded into the address space
  612.           of every executable.
  613.  
  614.           *** Please be extremely careful with this option since turning
  615.           *** it on could resulted in the system being totally thrashed
  616.           *** if CAP.DLL could not run correctly.  Thus causing the
  617.           *** profiled binary to fail to load also.  And if the binary
  618.           *** is as important as WINLOGON, then the only thing to do
  619.           *** is to reload NT or use a dummy cap.dll, or remove
  620.           *** the CAP.INI file.
  621.  
  622. 9.  Caveats:
  623. ------------
  624.  
  625.         o  Mips and Alpha Cap - if a routine being profiled is within try-except 
  626.            block and it crashes,  the stack will NOT unwind.  This is because 
  627.            there is no prolog code in the Cap penter to support this.
  628.  
  629.         o  For Mips only - Mips Cap cannot profile static functions. 
  630.  
  631.         o  If symbols are not available in an EXE/DLL that is being profiled,
  632.            ??? is displayed as the function name.
  633.  
  634.         o  Non-local GOTOs (i.e. setjmp/longjmp calls) are not currently
  635.            supported.  Profiling an application containing any non-local GOTOs
  636.            will result in unexpected results.
  637.  
  638.         o  Profiling data in *NOT* collected for functions in assembler
  639.            language programs.
  640.  
  641.         o  Paging file size will increase while profiling.
  642.  
  643.         o  For Alpha only - setjump, loadlibrary, and Exclude Funcs are not
  644.            implemented in this release.
  645.  
  646.         o  It may take a long time when cap is dumping data to the
  647.            cap file.  In some cases, it may take up to 30 minutes,
  648.            depending on how many symbols and the level of nesting
  649.            calls.
  650.  
  651.         o  If you are using GDI calls, you may want to add GdiSetBatchLimit(1)
  652.            for each thread before you re-compile with cap.lib. This is to disable
  653.            batching so each GDI call will be performed and profiled correctly.
  654.  
  655. ** END OF README **
  656.