home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume4 / bm1.2speedup < prev    next >
Text File  |  1986-11-30  |  3KB  |  117 lines
  1. Subject: speedup for bm on some machines
  2. Newsgroups: mod.sources
  3. Approved: jpn@panda.UUCP
  4.  
  5. Mod.sources:  Volume 4, Issue 32
  6. Submitted by: genrad!decvax!utzoo!henry (Henry Spencer)
  7.  
  8. On some machines with some Unix implementations (PDP11 running V7 for
  9. example, but there probably are others), bulk data copying from system
  10. to user space which is not aligned on word boundaries is a terrible
  11. performance disaster.  Bm, Peter Bain's Boyer-Moore grep program, suffers
  12. from this.  Fortunately, it's easy to fix:
  13.  
  14. 1. In line 43 of Execute.c (this is for bm version 1.2, recently posted),
  15.     change "read" to "xread".
  16.  
  17. 2. Add the following source file, xread.c, to the compilation.
  18.  
  19. This code could probably be improved a bit, but as it is it makes a
  20. difference of a factor of 4 (!) in bm's performance on utzoo.
  21.  
  22.                 Henry Spencer @ U of Toronto Zoology
  23.                 {allegra,ihnp4,linus,decvax}!utzoo!henry
  24.  
  25. P.S. I've thrown in a quickie version of bcopy() for people who don't have it.
  26.  
  27. ----------
  28. /*
  29.  * Fast-read routine.  Tries to do read(2)s at block boundaries on disk, and
  30.  * always does them at word boundaries in core.
  31.  *
  32.  * This code assumes that BUFSIZ is reasonable for internal buffering and
  33.  * that one can test a pointer for alignment by casting to int and ANDing
  34.  * with (sizeof(int)-1).
  35.  */
  36.  
  37. #include <stdio.h>
  38.  
  39. static char xbuf[BUFSIZ];
  40. static int xleft = 0;
  41. static char *xrest = NULL;
  42.  
  43. int
  44. xread(desc, buf, len)
  45. int desc;
  46. char *buf;
  47. int len;
  48. {
  49.     register int todo;
  50.     register int n;
  51.     char *place;
  52.     int ndone;
  53.     register int ret;
  54.  
  55.     ndone = 0;
  56.     place = buf;
  57.     todo = len;
  58.  
  59.     while (todo > 0) {
  60.         if (xleft > 0) {
  61.             /* Data available in our internal buffer. */
  62.             n = (xleft > todo) ? todo : xleft;
  63.             bcopy(xrest, place, n);
  64.             todo -= n;
  65.             xleft -= n;
  66.             xrest += n;
  67.             ndone += n;
  68.             place += n;
  69.         } else if (todo >= BUFSIZ && (((int)place)&(sizeof(int)-1)) == 0) {
  70.             /* Conditions suitable for a direct read. */
  71.             n = todo / BUFSIZ;
  72.             ret = read(desc, place, n*BUFSIZ);
  73.             if (ret < 0)
  74.                 return(ret);
  75.             if (ret == 0)
  76.                 return(ndone);
  77.             ndone += ret;
  78.             place += ret;
  79.             todo -= ret;
  80.         } else {
  81.             /* None of the above, refill the internal buffer. */
  82.             ret = read(desc, xbuf, BUFSIZ);
  83.             if (ret < 0)
  84.                 return(ret);
  85.             if (ret == 0)
  86.                 return(ndone);
  87.             xleft = ret;
  88.             xrest = xbuf;
  89.         }
  90.     }
  91.     return(ndone);
  92. }
  93. ----------
  94. /*
  95.  * bcopy - copy n bytes from a to b
  96.  */
  97.  
  98. bcopy(a, b, n)
  99. char *a;
  100. char *b;
  101. int n;
  102. {
  103.     register char *from;
  104.     register char *to;
  105.     register int count;
  106.  
  107.     from = a;
  108.     to = b;
  109.     count = n;
  110.  
  111.     while (--count >= 0)
  112.         *to++ = *from++;
  113. }
  114. ----------
  115.  
  116.  
  117.