home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 12 / CD_ASCQ_12_0294.iso / news / 2381 / fcc110 / fcc.doc < prev    next >
Text File  |  1993-10-12  |  29KB  |  743 lines
  1.  
  2.  
  3.  
  4.      FCC Version 1.10
  5.      10/5/93
  6.      
  7.      
  8.      What is FCC
  9.      -------------------------------------------------------------------------
  10.      FCC is a file access library which may be used in place of 'standard'
  11.      file access functions.  FCC performs the functions of a disk cache and
  12.      disk doubler.  FCC enhances standard file access functions in two ways:
  13.      
  14.         -  FCC uses an efficient LRU write back cache.  FCC supports cache
  15.            block sizes as small as 128 bytes for increased performance
  16.            when randomly accessing small blocks.
  17.      
  18.         -  FCC can optionaly provide sequential and random read/write access
  19.            to a compressed file.  Like a disk doubler, FCC performs these
  20.            functions transparently.  All you our your application is aware
  21.            of is that the physical size of the FCC file is smaller.
  22.      
  23.      
  24.      Uses for FCC
  25.      -------------------------------------------------------------------------
  26.         -  To speedup file access.  FCC is much faster than a disk cache, and
  27.            the cache parameters are under program control.  Programs which
  28.            randomly access small blocks of information will benefit the most.
  29.      
  30.         -  To reduce the disk requirements of applications.  Both for
  31.            distribution, and when installed.  FCC may be used in place of
  32.            the Windows LZ functions.
  33.      
  34.         -  To hide sensitive data.  Data compression ensures that proprietary
  35.            data can not be easily decoded.
  36.      
  37.         -  To update existing products.  Many database type programs waste
  38.            a lot of disk space.  FCC can remove this waste with file
  39.            compression, requiring only minor changes to the application.
  40.      
  41.         -  To efficiently store flat file databases.  With FCC, you do not
  42.            need to be concerned about balancing field lengths with disk
  43.            usage.
  44.      
  45.      
  46.      Why use FCC
  47.      -------------------------------------------------------------------------
  48.      FCC does not have any runtime royalties, and does not require a separate
  49.      compression program (like COMPRESS.EXE).  In addition, FCC provides full
  50.      write access to compressed files.
  51.      
  52.  
  53.  
  54.  
  55.      
  56.      Programming Interface
  57.      -------------------------------------------------------------------------
  58.      The following programming interface is not language specific.  FCC
  59.      may be used by almost all Windows languages and tools.  For language
  60.      specific interface information see the files:
  61.      
  62.         FCC.H
  63.         FCC.BAS
  64.      
  65.      The FCC functions closely resemble the standard C file access functions
  66.      (open, close, lseek, read, write).  This is also the model used by
  67.      many operating systems.  An internal file pointer is kept for each opened
  68.      file.  It is used to direct the file positioning used in read and write
  69.      operations.
  70.      
  71.      In the standard model there are 7 functions:
  72.      
  73.         open     -  open or create a file for reading and/or writing
  74.         close    -  close an opened file
  75.         seek     -  set the internal file pointer to a specific file location
  76.         read     -  read from a file
  77.         write    -  write to a file
  78.         tell     -  retrieve the position of the internal file pointer
  79.         length   -  retrieve the length of a file
  80.      
  81.      The open function returns a handle to the opened file, which is used
  82.      to identify the file to the other functions.
  83.      
  84.      FCC also has 5 additional functions:
  85.         
  86.         version  -  determine the version of FCC being used
  87.         exists   -  determine whether a file exists and/or is compressed
  88.         plength  -  retrieve physical length of a compressed file
  89.         flush    -  write dirty cache blocks to disk
  90.         copy     -  copy one file to another
  91.      
  92.      The main difference between the FCC model and the standard model is in
  93.      file opening.  The additions to the standard open function are:
  94.      
  95.         -  A way to indicate the cache size.
  96.         -  A way to indicate the cache block size.
  97.         -  A way to indicate whether or not a created file should be a
  98.            compressed file.
  99.      
  100.      The FCC functions are presented below:
  101.      
  102.  
  103.  
  104.  
  105.         FCC_open
  106.         ----------------------------------------------------------------------
  107.         PURPOSE:
  108.            Open or create (and open) a file.
  109.      
  110.         PARAMETERS:
  111.            handle   -  Filled in with a FCC file handle (if no error).
  112.            name     -  Name of file to open or create.
  113.            flags    -  Open flags.  May be one of:
  114.      
  115.               FCC_READ    -  Open for reading.
  116.               FCC_WRITE   -  Open for reading and writing.
  117.               FCC_CREATE  -  Create and open for reading and writing.
  118.      
  119.            compress -  Compression method (only used with FCC_CREATE).
  120.                        May be one of:
  121.      
  122.               FCC_CDEFAULT   -  Default compression.
  123.               FCC_CNONE      -  No compression.
  124.      
  125.            kbytes   -  The size of the file cache in kilobytes (1 - 2048).
  126.            blcksize -  The size of cache blocks in bytes (128 - 16384).
  127.      
  128.         RETURN:
  129.            0     -  No error.
  130.            else  -  An FCC error code.
  131.      
  132.         NOTES:
  133.            The blksize used when creating a compressed file will be used
  134.            in all subsequent access to the file.  To change the blksize,
  135.            copy the file with a different block size.
  136.      
  137.            When a file is opened, the internal file pointer is set to 0.
  138.      
  139.         FCC_close
  140.         ----------------------------------------------------------------------
  141.         PURPOSE:
  142.            Close an opened FCC file.
  143.      
  144.         PARAMETERS:
  145.            handle   -  FCC file handle.
  146.      
  147.         RETURN:
  148.            0     -  No error.
  149.            else  -  An FCC error code.
  150.      
  151.         NOTES:
  152.            All dirty cache buffers will be written to disk before the file
  153.            is closed.  This may take some time if the cache used is very
  154.            large.
  155.      
  156.  
  157.  
  158.  
  159.      
  160.         FCC_seek
  161.         ----------------------------------------------------------------------
  162.         PURPOSE:
  163.            Set the internal file pointer to a specific location.
  164.      
  165.         PARAMETERS:
  166.            handle   -  FCC file handle.
  167.            pos      -  File position offset.
  168.            where    -  May be one of the following:
  169.         
  170.               FCC_SEEKSET    -  Seek to position.
  171.               FCC_SEEKCUR    -  Seek from current position.
  172.               FCC_SEEKEND    -  Seek from end of file.
  173.      
  174.            newpos   -  Filled in with the new internal file pointer position.
  175.      
  176.         RETURN:
  177.            0     -  No error.
  178.            else  -  An FCC error code.
  179.      
  180.         NOTES:
  181.            The internal file pointer is 0 based (i.e. the first byte in a
  182.            file is located at position 0.)
  183.      
  184.            To position the file pointer for appending, use 
  185.      
  186.               FCC_seek(handle, 0, FCC_SEEKEND, NULL).
  187.      
  188.            If newpos is set to NULL, it will not be filled in.
  189.           
  190.         FCC_read
  191.         ----------------------------------------------------------------------
  192.         PURPOSE:
  193.            Read from a file.
  194.      
  195.         PARAMETERS:
  196.            handle   -  FCC file handle.
  197.            buff     -  Memory buffer where data should be placed.
  198.            bytes    -  Bytes to read (0-FFFE).
  199.            rbytes   -  Filled in with number of bytes read (if no error).
  200.      
  201.         RETURN:
  202.            0     -  No error.
  203.            else  -  An FCC error code.
  204.      
  205.         NOTES:
  206.            rbytes may be filled in with a value which is less than the
  207.            actual number of bytes requested.
  208.      
  209.  
  210.  
  211.  
  212.         
  213.         FCC_write
  214.         ----------------------------------------------------------------------
  215.         PURPOSE:
  216.            Write to a file.
  217.      
  218.         PARAMETERS:
  219.            handle   -  FCC file handle.
  220.            buff     -  Memory buffer containing data to write.
  221.            bytes    -  Bytes to write (0-FFFE).
  222.            wbytes   -  Filled in with number of bytes written (if no error).
  223.      
  224.         RETURN:
  225.            0     -  No error.
  226.            else  -  An FCC error code.
  227.      
  228.         NOTES:
  229.            wbytes may be filled in with a value which is less than the
  230.            actual number of bytes requested.
  231.            
  232.         FCC_tell
  233.         ----------------------------------------------------------------------
  234.         PURPOSE:
  235.            Retrieve the current internal file pointer position.
  236.      
  237.         PARAMETERS:
  238.            handle   -  FCC file handle.
  239.            pos      -  Filled in with the current file pointer position
  240.                        (if no error).
  241.      
  242.         RETURN:
  243.            0     -  No error.
  244.            else  -  An FCC error code.
  245.      
  246.         NOTES:
  247.            The value placed in pos is 0-based relative to the beginning of
  248.            the file.  If the file pointer is positioned at the first byte
  249.            of the file, pos contains 0.
  250.      
  251.            FCC_tell functions identically to:
  252.      
  253.               FCC_seek(handle, 0, SEEK_CUR, &pos);
  254.      
  255.  
  256.  
  257.  
  258.      
  259.         FCC_length
  260.         FCC_plength
  261.         ----------------------------------------------------------------------
  262.         PURPOSE:
  263.            Retrieve the logical (FCC_length) or physical (FCC_plength) length
  264.            of a file.
  265.      
  266.         PARAMETERS:
  267.            handle   -  FCC file handle.
  268.            length   -  Filled in with the file length (if no error).
  269.      
  270.         RETURN:
  271.            0     -  No error.
  272.            else  -  An FCC error code.
  273.      
  274.         NOTES:
  275.            If the file is not compressed, FCC_plength functions identically
  276.            to FCC_length.  If the file is compressed, FCC_plength will
  277.            typically return a value smaller than FCC_length.
  278.      
  279.         FCC_exists
  280.         ----------------------------------------------------------------------
  281.         PURPOSE:
  282.            Determine if a file exists and/or is compressed.  In addition,
  283.            FCC_exists may be used to determine a files length.
  284.      
  285.         PARAMETERS:
  286.            name     -  Name of file.
  287.            version  -  Filled in with:
  288.      
  289.               -1    -  The file does not exits.
  290.                0    -  The file exists but is not FCC compressed.
  291.               else  -  The FCC version used to compress (if no error).
  292.      
  293.            length   -  If not NULL, filled in with the logical file length.
  294.            plength  -  If not NULL, filled in with the physical file length.
  295.      
  296.         RETURN:
  297.            0     -  No error.
  298.            else  -  An FCC error code.
  299.      
  300.         NOTES:
  301.            The value placed in version will be the integer equivalent of the
  302.            FCC version used to compress.  Version 1.00 will be 100, version
  303.            10.15 will be 1015.  All versions numbers will be between 100 and
  304.            9999.
  305.      
  306.  
  307.  
  308.  
  309.      
  310.         FCC_version
  311.         ----------------------------------------------------------------------
  312.         PURPOSE:
  313.            Determine the FCC_version
  314.      
  315.         PARAMETERS: none
  316.      
  317.         RETURN:
  318.            The version of the FCC library.  The version is the same as
  319.            described in FCC_exists.
  320.      
  321.         FCC_copy
  322.         ----------------------------------------------------------------------
  323.         PURPOSE:
  324.            Copy one file to another.  The source file may be any file,
  325.            including FCC compressed files.  The destination file may
  326.            optionaly be compressed.
  327.      
  328.         PARAMETERS:
  329.            src      -  Source file.
  330.            dst      -  Destination file (or NULL, or "").
  331.            blksize  -  Block size parameter to both FCC_open calls.  Choose
  332.                        the largest block size for maximum compression, and
  333.                        the fastest copy.
  334.            compress -  Indicates whether the destination file should be
  335.                        compressed.  May be one of:
  336.      
  337.               FCC_CDEFAULT   -  Compress destination file.
  338.               FCC_CNONE      -  Do not compress destination file.
  339.      
  340.            progress -  See section Copy Progress below.
  341.            
  342.         RETURN:
  343.            0     -  No error.
  344.            else  -  An FCC error code.
  345.      
  346.         NOTES:
  347.            The destination file will have the same date and time of the
  348.            source file (if no error).
  349.      
  350.            If dst is NULL or "", the file will be copied in place.  In
  351.            other words, src will be copied to itself.
  352.      
  353.               -  To decompress a file:
  354.      
  355.                     FCC_copy(filename, "", blksize, FC_CNONE, NULL)
  356.      
  357.               -  To compress or de-fragment a file:
  358.      
  359.                     FCC_copy(filename, "", blksize, FCC_CDEFAULT, NULL)
  360.      
  361.  
  362.  
  363.  
  364.      
  365.      Copy Progress
  366.      -------------------------------------------------------------------------
  367.      This section is only relevant to the function FCC_copy.
  368.      
  369.      When copying a file using FCC_copy, you may want your application to
  370.      be able to abort the copy and/or display progress information to the
  371.      operator.  The progress parameter to FCC_copy is used for this purpose.
  372.      
  373.      If you do not want any progress information, you may pass a NULL
  374.      parameter for progress.  In MS Visual Basic this is equivalent to
  375.      passing ByVal 0&. 
  376.      
  377.      The structure FCC_COPYT is used for progress/abort purposes.  The fields
  378.      in FCC_COPYT are:
  379.      
  380.            wHnd     -  window handle
  381.            message  -  message to be sent to wHnd
  382.            wparam   -  first message parameter
  383.            lparam   -  second message parameter
  384.            
  385.            cancel   -  if not zero, copy will be aborted
  386.            length   -  logical length of input file
  387.            plength  -  physical length of input file
  388.            curpos   -  bytes copied so far
  389.      
  390.      Periodically, FCC_copy will send the following Windows message:
  391.      
  392.         SendMessage(wHnd, message, wparam, lparam)
  393.      
  394.      If, after sending this message, the cancel field of progress has been
  395.      set to a value other than 0 by the application, FCC_copy will return
  396.      with the 'error' FCC_ERR_CANCELED.  In addition, the application may
  397.      use the values in length, plength and curpos to display progress
  398.      information.
  399.      
  400.      The MS Visual Basic example demonstrates how the progress parameter
  401.      to FCC_copy is used.
  402.      
  403.      There are several important notes about the VB example:
  404.         
  405.         -  The message sent in this example is WM_KEYUP with wparam set to 256.
  406.            In other words, a false key up message is sent to the main VB
  407.            Window.  The false key is 256, which will not conflict with any
  408.            Windows keystrokes.
  409.      
  410.         -  DoEvents is called to process any user input.  If DoEvents is not
  411.            called, Windows will not be able to process any user input or
  412.            display progress information.
  413.      
  414.         -  When the false WM_KEYUP message is sent, progress information is not
  415.            automatically displayed.  The display of progress information is
  416.            done by a timer control.  This is done to reduce CPU overhead
  417.            and for an 'aestheticly pleasing' once/per half second display.
  418.      
  419.  
  420.  
  421.  
  422.      FCC Error Codes
  423.      -------------------------------------------------------------------------
  424.         FCC_ERR_OPEN
  425.            Could not open a file.  This error will typically be encountered
  426.            when trying to open a file which does not exist.
  427.      
  428.         FCC_ERR_WRITE
  429.            Could not write to a file.  This error will typically be encountered
  430.            if a disk drive fails or becomes full.
  431.      
  432.         FCC_ERR_READ
  433.            Could not read from a file.  This error will typically be encountered
  434.            if a disk drive fails.
  435.      
  436.         FCC_ERR_CLOSE
  437.            A file could not be closed.  This error will typically be encountered
  438.            if a disk drive fails.
  439.      
  440.         FCC_ERR_SEEK
  441.            A seek could not be performed.  Because seek operations should not
  442.            generate an error, this error is very unlikely.
  443.      
  444.         FCC_ERR_CACCESS
  445.            Data in a compressed file could not be retrieved.  This error
  446.            will typically be encountered if a FCC compressed file has become
  447.            corrupt or has been altered without FCC.
  448.      
  449.         FCC_ERR_VERSION
  450.            A file could not be opened because it is recognized as a
  451.            compressed FCC file, but the version is not supported.
  452.      
  453.         FCC_ERR_NOMEM
  454.            Insufficient memory.
  455.      
  456.         FCC_ERR_PARAM
  457.            An invalid parameter was passed to a FCC function.  This error
  458.            will typically only be encountered when a program is being written.
  459.            Make sure each of the passed parameters is valid.
  460.      
  461.         FCC_ERR_CANCELED
  462.            The cancel field of progress in FCC_copy was set to a value other
  463.            than 0.
  464.      
  465.         FCC_ERR_UNKNOWN
  466.            An unknown error occurred.
  467.      
  468.  
  469.  
  470.  
  471.      Disabling the Write Back Cache
  472.      -------------------------------------------------------------------------
  473.      There is no way to explicitly disable the write back cache.  You may,
  474.      however, write a function which does so.  In C:
  475.      
  476.         int   FCC_writeflush(int handle, void *buff, long bytes, long *wbytes)
  477.         {
  478.            int   err;
  479.      
  480.            err = FCC_write(handle, buff, bytes, wbytes);
  481.            if (err == 0)
  482.               err = FCC_flush(handle);
  483.            else
  484.               FCC_flush(handle);
  485.      
  486.            return (err);
  487.         }
  488.      
  489.      This function writes and flushes in one operation.
  490.      
  491.            
  492.      Choosing Cache and Block Sizes
  493.      -------------------------------------------------------------------------
  494.      When opening a file with FCC, you have to tell FCC how much memory to
  495.      use for the cache, and what cache block size to use.  The cache will
  496.      have (kbytes * 1024) / blksize blocks.  In other words, if you specify
  497.      a 1MB (1024K) cache and a 256 byte block size, there will be 4096
  498.      cache blocks.  Each cache block can contain blksize bytes of file data.
  499.      A least recently used (LRU) block allocation mechanism is used.
  500.      
  501.      In general, you should make the cache size as big as possible (up to
  502.      the size of the file of course).  Choosing the block size is more
  503.      difficult.  The following rules will usually work in most cases:
  504.      
  505.         -  When accessing a file sequentially, choose a block size as
  506.            big as possible (up to the size of the cache size).
  507.      
  508.         -  When accessing a file randomly, choose a block size between 1/2
  509.            and 4 times the size of the typical access size (the bytes
  510.            parameter to FCC_read and FCC_write).
  511.      
  512.      The other consideration when choosing a block size is compression.  The
  513.      larger the block size, the smaller the file will be.  The penalty, however,
  514.      is slower random access.  For example, suppose you randomly access a
  515.      compressed file, and the typical access size is 128 bytes.  File access
  516.      using a block size of 32K will be much slower than with a block size of
  517.      2K.  A block size of less than 1K for compressed files is not
  518.      recommended.
  519.      
  520.      It is best to experiment with different combinations until an adequate
  521.      size vs. speed tradeoff is reached.
  522.      
  523.      
  524.  
  525.  
  526.  
  527.      Zeroing Unused Data
  528.      -------------------------------------------------------------------------
  529.      When writing to a compressed file, all unused space should be set to one
  530.      value (zero is suggested).  For example: Suppose you are writing an
  531.      address book database.  For each record you are reserving 30 bytes for
  532.      the last name.  Since most last names have less than 30 letters, a lot of
  533.      space will be unused in each record.  By setting this unused space to
  534.      one value, it may be compressed by FCC.  The last name 'Jones' should
  535.      be stored as 'Jones' followed by 25 0's.  
  536.      
  537.      
  538.      Fragmentation
  539.      -------------------------------------------------------------------------
  540.      When randomly accessing a compressed file, it may become fragmented.
  541.      This causes the physical file size to become larger than it needs to
  542.      be.  By simply copying the FCC file, the physical size will be become
  543.      as small as possible.  For example:  Suppose you have been randomly
  544.      accessing the file MY.DAT, and now you want to make it as small as
  545.      possible.  FCC_copy may be used for this purpose:
  546.      
  547.            FCC_copy("MY.DAT", "", blksize, FCC_CDEFAULT, NULL)
  548.      
  549.      
  550.      Other Versions / Other Products
  551.      -------------------------------------------------------------------------
  552.      There are other versions and products which do not have a
  553.      standard pricing plan:
  554.      
  555.         -  Other versions of FCC with faster and/or better data compression.
  556.      
  557.         -  Buffer based data compression algorithms.
  558.      
  559.         -  Stream based data compression algorithms.
  560.      
  561.         -  MS-DOS and OS/2 libraries.
  562.      
  563.      
  564.  
  565.  
  566.  
  567.      Ordering Information
  568.      -------------------------------------------------------------------------
  569.      To purchase FCC 1.10, print (or copy) this ordering
  570.      form.  You will receive the commercial version of FCC 1.10, and
  571.      the right to distribute FCCWIN.DLL for use with your applications.
  572.      The price shown is an introductory price, valid through 12/31/93.
  573.      After this date, call for the current pricing.
  574.      
  575.         Product ID:          FCC110
  576.      
  577.         Price:               $95 US  (non-US shipping add $5 US)
  578.      
  579.         Make Payment To:     Four Lakes Computing
  580.      
  581.         Payment Methods:     US Check, US Money Order, US Dollars,
  582.                              American Express International Money Order.
  583.      
  584.         Send Payment To:     Four Lakes Computing
  585.                              1135 Williamson #4
  586.                              Madison, WI 53703 USA
  587.      
  588.      
  589.         Address:  __________________________________________________
  590.      
  591.      
  592.                   __________________________________________________
  593.      
  594.      
  595.                   __________________________________________________
  596.      
  597.      
  598.                   __________________________________________________
  599.      
  600.      
  601.         Phone:    _____________________  Disk:  ___ 5 1/4  ___ 3 1/2
  602.                              
  603.      
  604.      If you have any questions, contact:
  605.      
  606.         US Phone:            608-256-3382
  607.         Compuserve ID:       70662,2501
  608.      
  609.  
  610.  
  611.  
  612.      
  613.      
  614.      The Test Program FCCTST.EXE
  615.      -------------------------------------------------------------------------
  616.      FCCTST.EXE is a Windows program which may be used to test FCC.  It
  617.      is written in Microsoft Visual BASIC.  The source code for FCCTST.EXE
  618.      is contained in the files:
  619.      
  620.         FCC.BAS     -  FCC BASIC Interface
  621.         FCCERR.BAS  -  Converts FCC error codes to English messages.
  622.         FCCTST.FRM  -  Visual BASIC form.
  623.         FCCTST.MAK  -  Visual BASIC project file.
  624.      
  625.      FCCTST.EXE allows you to copy files.  The source file may be any file,
  626.      including FCC compressed files.  You may choose for the destination
  627.      file to be compressed.
  628.      
  629.      FCCTST.EXE also allows you to test random read and write access to both
  630.      compressed and uncompressed files.
  631.      
  632.      The controls in FCCTST.EXE are explained below:
  633.      
  634.         Source File:
  635.         ----------------------------------------------------------------------
  636.         This is the source file for a copy operation.  The file you specify
  637.         will NOT be modified by FCCTST.EXE.  The choice of Source File is not
  638.         really important if compression is not being used (any file of the
  639.         desired size will work).  If compression is being used, Source File
  640.         should contain the type of data you are interested in compressing.
  641.      
  642.         Destination File:
  643.         ----------------------------------------------------------------------
  644.         This is the destination file for the copy operation, and the file that
  645.         will be modified during random access.  THIS FILE MAY BE CREATED OR
  646.         MODIFIED BY FCCTST.EXE.  The default destination file is c:\fcc.tmp.
  647.      
  648.         Copy
  649.         ----------------------------------------------------------------------
  650.         Copies the source file to the destination file.
  651.      
  652.         Random
  653.         ----------------------------------------------------------------------
  654.         Randomly accesses the destination file until cancel is pressed.
  655.      
  656.         Cancel
  657.         ----------------------------------------------------------------------
  658.         Cancels a file copy or random access.
  659.      
  660.         Cache Size (K):
  661.         ----------------------------------------------------------------------
  662.         Used to determine the cache size for the destination file.
  663.      
  664.  
  665.  
  666.  
  667.         Block Size
  668.         ----------------------------------------------------------------------
  669.         Used to determine the block size for FCC_copy and FCC_open.
  670.         When accessing a compressed file, it is suggested that block
  671.         size be no less than 1024.  For maximum compression, choose the
  672.         maximum Block Size for the destination file (16384).
  673.      
  674.         Compress
  675.         ----------------------------------------------------------------------
  676.         Determines whether the destination file in a copy operation should
  677.         be compressed.
  678.      
  679.         Random Size
  680.         ----------------------------------------------------------------------
  681.         Indicates the size of reads (and possibly writes) used in a random
  682.         access operation.  A random number between 1 and Random Size will
  683.         be used for each access.  Data will be read from the destination file,
  684.         and if Random Writes is enabled, will be written to another location
  685.         in the destination file.
  686.      
  687.         This parameter is important for testing cache efficiency during
  688.         random access.  If the average size of access you want to test is
  689.         1024 bytes, choose a Random Size of 2048.
  690.      
  691.         Random Writes
  692.         ----------------------------------------------------------------------
  693.         Indicates that random writes (as well as reads) should be performed
  694.         in a random access operation.  It is interesting to note that the
  695.         physical size of a compressed file will increase for awhile when
  696.         accessed randomly with Random Writes enabled.  This is because of
  697.         file fragmentation.
  698.      
  699.         Random %
  700.         ----------------------------------------------------------------------
  701.         Indicates the location of random access:
  702.      
  703.            10 - 90% of the random access requests will be made to the first
  704.                 10% of the file.  The other 10% will come from the entire file.
  705.      
  706.            30 - 70% of the random access requests will be made to the first
  707.                 30% of the file.  The other 30% will come from the entire file.
  708.      
  709.           100 - The file is accessed randomly.
  710.      
  711.         This is an important parameter for testing the effectiveness of the
  712.         cache.  As most files are not accessed truly randomly, this parameter
  713.         allows you to test typical file access, and adjust the cache parameters
  714.         for the best performance.
  715.      
  716.  
  717.  
  718.  
  719.      
  720.         Progress Information
  721.         ----------------------------------------------------------------------
  722.         Source File Size
  723.            Indicates how big the input file is.  The logical size will be in
  724.            parentheses if it differs from the physical size.
  725.      
  726.         Destination File Size
  727.            Indicates how big the destination file is.  Note that this may
  728.            grow during randow access (with writes enabled) due to fragmentation.
  729.      
  730.         Bytes Processed
  731.            Indicates how many bytes have been copied, or how many bytes have
  732.            been processed in a random access operation.
  733.      
  734.         K/Sec
  735.            Indicates how may kilobytes have been processed per second.  This
  736.            is the main indicator to you of cache/compression efficiency.  It
  737.            will typically range between 5 and 2000.  This is the gauge you
  738.            use to select optimal FCC parameters.
  739.      
  740.  
  741.  
  742.  
  743.