Return to temp.h CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove

Annotation of 43BSDReno/contrib/jove/temp.h, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
                      3:  * is provided to you without charge, and with no warranty.  You may give  *
                      4:  * away copies of JOVE, including sources, provided that this notice is    *
                      5:  * included in all the files.                                              *
                      6:  ***************************************************************************/
                      7: 
                      8: /* The tmp file is indexed in chunks of CH_SIZE characters.  CH_SIZE is
                      9:    (1 << CH_BITS).  New lines are added to the end of the tmp file.  The
                     10:    file is not garbage collected because that would be too painful.  As a
                     11:    result, commands like Yank and Kill are really easy; basically all we
                     12:    do is make copies of the disk addresses of the lines (as opposed to
                     13:    the contents).  So, putline(buf) writes BUF to the disk and returns a
                     14:    new disk address.  Getline(addr, buf) is the opposite of putline().
                     15:    f_getputl(line, fp) reads from open FP directly into the tmp file (into
                     16:    the buffer cache (see below)) and stores the address in LINE.  This is
                     17:    used during read_file to minimize compying.
                     18: 
                     19:    Lines do NOT cross block bounderies in the tmp file so that accessing
                     20:    the contents of lines can be much faster.  Pointers to offsets into
                     21:    disk buffers are returned instead of copying the contents into local
                     22:    arrays and then using them.  This cuts down on the amount of copying a
                     23:    great deal, at the expense of less efficiency.  The lower bit of disk
                     24:    addresses is used for marking lines as needing redisplay done.
                     25: 
                     26:    There is a buffer cache of NBUF buffers (64 on !SMALL machines and the
                     27:    3 on small ones).  The blocks are stored in LRU order and each block
                     28:    is also stored in a hash table by block #.  When a block is requested
                     29:    it can quickly be looked up in the hash table.  If it's not there the
                     30:    LRU block is assigned the new block #.  If it finds that the LRU block
                     31:    is dirty (i.e., has pending IO) it syncs the WHOLE tmp file, i.e.,
                     32:    does all the pending writes.  This works much better on floppy disk
                     33:    systems, like the IBM PC, if the blocks are sorted before sync'ing. */
                     34: 
                     35: #ifdef SMALL
                     36: # define CH_BITS               4
                     37: # if JBUFSIZ == 512
                     38: #  define MAX_BLOCKS           1024
                     39: # else
                     40: #  define MAX_BLOCKS           512
                     41: # endif
                     42: #else
                     43: # define CH_BITS               0
                     44: # define MAX_BLOCKS            4096    /* basically unlimited */
                     45: #endif /* SMALL */
                     46: 
                     47: #if JBUFSIZ == 512
                     48: # define BNO_SHIFT             (9 - CH_BITS)
                     49: #else
                     50: # define BNO_SHIFT             (10 - CH_BITS)
                     51: #endif
                     52: 
                     53: /* CH_SIZE is how big each chunk is.  For each 1 the DFree pointer
                     54:    is incremented we extend the tmp file by CH_SIZE characters.
                     55:    CH_PBLOCK is the # of chunks per block.  RND_MASK is used to mask
                     56:    off the lower order bits of the daddr to round down to the beginning
                     57:    of a block.  OFF_MASK masks off the higher order bits so we can get
                     58:    at the offset into the disk buffer.
                     59: 
                     60:    NOTE:  It's pretty important that these numbers be multiples of
                     61:          2.  Be careful if you change things. */
                     62: 
                     63: #define CH_SIZE                        ((daddr) 1 << CH_BITS)
                     64: #define CH_PBLOCK              ((daddr) JBUFSIZ / CH_SIZE)
                     65: #define RND_MASK               ((daddr) CH_PBLOCK - 1)
                     66: #define OFF_MASK               ((daddr) JBUFSIZ - 1)
                     67: #define BNO_MASK               ((daddr) MAX_BLOCKS - 1)
                     68: #define blk_round(addr)                ((daddr) (addr) & ~RND_MASK)
                     69: #define forward_block(addr)    ((daddr) (addr) + CH_PBLOCK)
                     70: #define da_to_bno(addr)                ((daddr) ((addr) >> BNO_SHIFT) & BNO_MASK)
                     71: #define da_to_off(addr)                ((daddr) ((addr) << CH_BITS) & OFF_MASK)
                     72: #define da_too_huge(addr)      ((daddr) ((addr) >> BNO_SHIFT) >= MAX_BLOCKS)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.