home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / comp / protocol / appletal / 4330 < prev    next >
Encoding:
Text File  |  1993-01-06  |  18.5 KB  |  809 lines
  1. Path: sparky!uunet!gatech!usenet.ins.cwru.edu!agate!ucbvax!RUDY.FAC.CS.CMU.EDU!Rudy_Nedved
  2. From: Rudy_Nedved@RUDY.FAC.CS.CMU.EDU
  3. Newsgroups: comp.protocols.appletalk
  4. Subject: Re: recent CAP STAT_CACHE patches
  5. Message-ID: <1552.726260326@RUDY.FAC.CS.CMU.EDU>
  6. Date: 5 Jan 93 18:58:46 GMT
  7. References: <1i9o60INNjq1@phantom.gatech.edu>
  8. Sender: daemon@ucbvax.BERKELEY.EDU
  9. Distribution: world
  10. Organization: The Internet
  11. Lines: 796
  12.  
  13.  
  14. I have submitted the patches to the cap@mun... folks. No response from them.
  15.  
  16. So what the heck...here they are:
  17.  
  18. Patch #:    rudy2
  19. Type:        performance improvement
  20. Priority:    none
  21. Modification:    expand a cache and reduce byte compares
  22. Submitted:    Rudy Nedved (ern) <ern+@h.gp.cs.cmu.edu>
  23. Summary:    ENUM cache has been expanded from 30 to 100.
  24. Summary:    a hash value added to IDirP to speed up child lookup
  25. Summary:    ipathstr re-done to minimize strlen byte operations
  26. File:        cap60/applications/aufs/afps.h
  27. File:        cap60/applications/aufs/afpdid.c
  28.  
  29. *** applications/aufs/afps.h.orig    Fri Dec  4 11:42:57 1992
  30. --- applications/aufs/afps.h        Fri Dec  4 12:01:06 1992
  31. ***************
  32. *** 1,7 ****
  33.   /*
  34. !  * $Author: djh $ $Date: 1992/06/23 23:28:08 $
  35. !  * $Header: /mac/src/cap60/applications/aufs/RCS/afps.h,v 2.3 1992/06/23 23:28:08 djh Rel djh $
  36. !  * $Revision: 2.3 $
  37.   */
  38.   
  39.   /*
  40. --- 1,7 ----
  41.   /*
  42. !  * $oAuthor: djh $ $oDate: 1992/06/23 23:28:08 $
  43. !  * $oHeader: /mac/src/cap60/applications/aufs/RCS/afps.h,v 2.3 1992/06/23 23:28:08 djh Rel djh $
  44. !  * $oRevision: 2.3 $
  45.   */
  46.   
  47.   /*
  48. ***************
  49. *** 85,90 ****
  50. --- 85,91 ----
  51.   
  52.   typedef struct idir {        /* local directory info (internal) */
  53.     char *name;            /* the directory name */
  54. +   long hash;            /* hash of the directory name */
  55.     struct idir *next;        /* ptr to next at same level */
  56.     struct idir *subs;        /* ptr to children */
  57.     struct idir *pdir;        /* ptr to parent */
  58. ***************
  59. *** 178,184 ****
  60.   
  61.   #define NOECIDX (-1)
  62.   
  63. ! #define NECSIZE 30        /* size of the enum cache */
  64.   
  65.   void ECacheInit();
  66.   char *OSEnumGet();
  67. --- 179,185 ----
  68.   
  69.   #define NOECIDX (-1)
  70.   
  71. ! #define NECSIZE 100        /* size of the enum cache */
  72.   
  73.   void ECacheInit();
  74.   char *OSEnumGet();
  75.  
  76. *** applications/aufs/afpdid.c.orig    Fri Dec  4 11:43:29 1992
  77. --- applications/aufs/afpdid.c        Fri Dec  4 12:03:23 1992
  78. ***************
  79. *** 1,7 ****
  80.   /*
  81. !  * $Author: djh $ $Date: 1992/07/27 15:29:09 $
  82. !  * $Header: /mac/src/cap60/applications/aufs/RCS/afpdid.c,v 2.3 1992/07/27 15:29:09 djh Rel djh $
  83. !  * $Revision: 2.3 $
  84.   */
  85.   
  86.   /*
  87. --- 1,7 ----
  88.   /*
  89. !  * $oAuthor: djh $ $oDate: 1992/07/27 15:29:09 $
  90. !  * $oHeader: /mac/src/cap60/applications/aufs/RCS/afpdid.c,v 2.3 1992/07/27 15:29:09 djh Rel djh $
  91. !  * $oRevision: 2.3 $
  92.   */
  93.   
  94.   /*
  95. ***************
  96. *** 107,114 ****
  97.   IDirP dir;
  98.   char *nam;
  99.   {
  100. !   for (; dir != (IDirP) 0 && strcmp(dir->name,nam) != 0; dir = dir->next)
  101. !     /* NULL */;
  102.     return(dir);
  103.   }
  104.    
  105. --- 107,127 ----
  106.   IDirP dir;
  107.   char *nam;
  108.   {
  109. !   register long hash;
  110. !   register char *p;
  111. ! 
  112. !   p = nam;
  113. !   hash = 0;
  114. !   while (*p) {
  115. !     hash <<= 2;
  116. !     hash += *p++;
  117. !   }
  118. !   for(;dir != (IDirP) 0; dir = dir->next) {
  119. !     if (dir->hash != hash)
  120. !     continue;
  121. !     if (strcmp(dir->name,nam) == 0)
  122. !     break;
  123. !   }
  124.     return(dir);
  125.   }
  126.    
  127. ***************
  128. *** 124,132 ****
  129. --- 137,154 ----
  130.   char *name;
  131.   {
  132.     IDirP dir;
  133. +   register long hash;
  134. +   register char *p;
  135.   
  136.     dir = (IDirP) malloc(sizeof(IDir));
  137.     dir->name = (char *) malloc((unsigned) strlen(name)+1);
  138. +   hash = 0;
  139. +   p = name;
  140. +   while (*p) {
  141. +     hash <<= 2;
  142. +     hash += *p++;
  143. +   }
  144. +   dir->hash = hash;
  145.     strcpy(dir->name,name);
  146.     dir->pdir = parent;            /* set pointer to parent in node */
  147.     dir->subs = NILDIR;            /* no children */
  148. ***************
  149. *** 145,150 ****
  150. --- 167,173 ----
  151.     OSValidateDIDDirInfo(dir);        /* validate directory info */
  152.     if (parent && (dir->flags & DID_DATA) == 0) {
  153.       parent->subs = dir->next;    /* unlink it */
  154. +     dir->hash = 0;
  155.       free(dir->name);        /* nada */
  156.       free(dir);            /* nada */
  157.       return(NILDIR);
  158. ***************
  159. *** 177,203 ****
  160.     if (lastcd == cd)            /* same as last request? */
  161.       return(paths);            /* yes.. just return old paths */
  162.     lastcd = cd;                /* else set new dir */
  163. !   return(ipathstr(cd,paths));        /* and do the work... */
  164.   }
  165.   
  166.   private char *
  167.   ipathstr(cd,p)
  168.   IDirP cd;
  169. ! char *p;
  170.   {
  171. !   int len;
  172.   
  173. !   if (cd == rootd)             /* check for root directory  */
  174. !     strcpy(p,"/");            /* at top of tree, init path */
  175. !   else {
  176. !     (void)ipathstr(cd->pdir,p);        /* recurse on parent until root */
  177. !     len = strlen(p);
  178.       if (cd->pdir != rootd) 
  179. !       p[len++] = '/';            /* add path component */
  180. !     strcpy(p+len, cd->name);        /* concatenate current dir to path */
  181.     }
  182. -   return(p);                /* and return a pointer... */
  183. - }
  184.   
  185.   /*
  186.    * return a path relative to vroot
  187. --- 200,238 ----
  188.     if (lastcd == cd)            /* same as last request? */
  189.       return(paths);            /* yes.. just return old paths */
  190.     lastcd = cd;                /* else set new dir */
  191. !   ipathstr(cd,paths);            /* and do the work... */
  192. !   return(paths);            /* return new path */
  193.   }
  194.   
  195.   private char *
  196.   ipathstr(cd,p)
  197.   IDirP cd;
  198. ! register char *p;
  199.   {
  200. !   register char *t;
  201.   
  202. !   /* check for root directory  */
  203. !   if (cd == rootd) {
  204. !     /* at top of tree, init path */
  205. !     *p++ = '/';
  206. !     *p = '\0';
  207. !     return (p);
  208. !   }
  209. ! 
  210. !   /* recurse on parent until root, get new insertion pointer */
  211. !   p = ipathstr(cd->pdir,p);
  212. ! 
  213. !   /* insert new path component */
  214.     if (cd->pdir != rootd)
  215. !     *p++ = '/';
  216. !   t = cd->name;
  217. !   while (*t)
  218. !     *p++ = *t++;
  219. !   *p = '\0';
  220. ! 
  221. !   /* return new insertion pointer */
  222. !   return(p);
  223.   }
  224.   
  225.   /*
  226.    * return a path relative to vroot
  227. ***************
  228. *** 529,535 ****
  229.   }
  230.   
  231.   /*
  232. !  * OSErr EtoIFile(char *file, IDirP *idir, IDirP *ipdir, int *ivol
  233.    *          sdword edir, word evol, byte eptype, byte *epath);
  234.    *
  235.    * Convert external arguments which specify a file/dir into internal
  236. --- 564,570 ----
  237.   }
  238.   
  239.   /*
  240. !  * OSErr EtoIfile(char *file, IDirP *idir, IDirP *ipdir, int *ivol
  241.    *          sdword edir, word evol, byte eptype, byte *epath);
  242.    *
  243.    * Convert external arguments which specify a file/dir into internal
  244. ***************
  245. *** 816,821 ****
  246. --- 851,865 ----
  247.     }
  248.   
  249.     if (strcmp(from,to) != 0) {        /* if different names then... */
  250. +     register long hash;
  251. +     register char *p;
  252. +     hash = 0;
  253. +     p = to;
  254. +     while (*p) {
  255. +       hash <<= 2;
  256. +       hash += *p++;
  257. +     }
  258. +     fdir->hash = hash;
  259.       free(fdir->name);            /* release the old name */
  260.       fdir->name = (char *) malloc((unsigned) strlen(to)+1);
  261.       strcpy(fdir->name,to);        /* copy new name */
  262.  
  263. Patch #:    rudy3
  264. Type:        performance improvement to STAT_CACHE code
  265. Priority:    none
  266. Modification:    add module init call, use internal buffer
  267. Submitted:    Rudy Nedved (ern) <ern+@h.gp.cs.cmu.edu>
  268. Summary:    initialize things by adding an init call
  269. Summary:    eliminate malloc/free calls
  270. Summary:    allow stat of parent and root without loss of info
  271. File:        cap60/applications/aufs/afpserver.c
  272. File:        cap60/applications/aufs/afpspd.c
  273.  
  274. *** applications/aufs/afpserver.c.orig    Wed Mar 13 05:29:40 1991
  275. --- applications/aufs/afpserver.c    Fri Dec  4 12:36:30 1992
  276. ***************
  277. *** 1,7 ****
  278.   /*
  279. !  * $Author: djh $ $Date: 91/03/13 20:29:21 $
  280. !  * $Header: afpserver.c,v 2.2 91/03/13 20:29:21 djh Exp $
  281. !  * $Revision: 2.2 $
  282.   */
  283.   
  284.   /*
  285. --- 1,7 ----
  286.   /*
  287. !  * $oAuthor: djh $ $oDate: 91/03/13 20:29:21 $
  288. !  * $oHeader: afpserver.c,v 2.2 91/03/13 20:29:21 djh Exp $
  289. !  * $oRevision: 2.2 $
  290.   */
  291.   
  292.   /*
  293. ***************
  294. *** 222,227 ****
  295. --- 222,230 ----
  296.     ECacheInit();            /* init afposenum cache */
  297.     InitIconCache();        /* init afpdt cache */
  298.     InitDID();            /* init directory stuff  */
  299. + #ifdef STAT_CACHE
  300. +   OSstat_Init();        /* init stat cache */
  301. + #endif STAT_CACHE
  302.   }
  303.   
  304.   private int loggedin = FALSE;
  305.  
  306. *** applications/aufs/afpspd.c.orig    Fri Dec  4 11:43:29 1992
  307. --- applications/aufs/afpspd.c        Fri Dec  4 12:34:50 1992
  308. ***************
  309. *** 18,24 ****
  310.   
  311.   #ifdef STAT_CACHE
  312.   
  313. ! struct statobj {
  314.       char * NAME;
  315.       struct stat STAT;
  316.       int FN,RS;
  317. --- 18,24 ----
  318.   
  319.   #ifdef STAT_CACHE
  320.   
  321. ! private struct statobj {
  322.       char * NAME;
  323.       struct stat STAT;
  324.       int FN,RS;
  325. ***************
  326. *** 41,47 ****
  327. --- 41,65 ----
  328.   private char CUR_DIR_STR[1024];
  329.   private char * CUR_DIR = NULL;
  330.   private int CUR_DIR_LEN;
  331. + private char CUR_STAT_STR[1024];
  332. + private int CUR_STAT_LEVEL=0;
  333.   
  334. + OSstat_Init()
  335. + {
  336. +     register int P;
  337. + 
  338. +     for(P = 0;P <= MAX_LEVEL;P++) {
  339. +         STATS[P].NAME = NULL;
  340. +         STATS[P].STAT.st_nlink = -1;
  341. +         STATS[P].FN = VAL_INVALID;
  342. +         STATS[P].RS = VAL_INVALID;
  343. +     }
  344. + 
  345. +     STATS[0].NAME = "<root>";
  346. + 
  347. +     time(&CUR_TIME);
  348. + }
  349. + 
  350.   OScd(path)
  351.       char * path;
  352.   {
  353. ***************
  354. *** 96,108 ****
  355.   private release_stats(K)
  356.       int K;
  357.   {
  358. !     int P;
  359.   
  360.       if (DBOSI)
  361.           printf("release_stats=%d\n",K);
  362.   
  363. !     for (P = K; STATS[P].NAME != NULL; P++) {
  364. !         free(STATS[P].NAME);
  365.           STATS[P].STAT.st_nlink = -1;
  366.           STATS[P].FN = VAL_INVALID;
  367.           STATS[P].RS = VAL_INVALID;
  368. --- 114,125 ----
  369.   private release_stats(K)
  370.       int K;
  371.   {
  372. !     register int P;
  373.   
  374.       if (DBOSI)
  375.           printf("release_stats=%d\n",K);
  376.   
  377. !     for (P = K; P <= CUR_STAT_LEVEL; P++) {
  378.           STATS[P].STAT.st_nlink = -1;
  379.           STATS[P].FN = VAL_INVALID;
  380.           STATS[P].RS = VAL_INVALID;
  381. ***************
  382. *** 113,191 ****
  383.   private int EXPIRE_REQ;
  384.   
  385.   private expire_stats(K)
  386. !     int K;
  387.   {
  388.       if (!EXPIRE_REQ)
  389.           return;
  390.       EXPIRE_REQ = 0;
  391. !     for (K = 0; STATS[K].NAME != NULL; K++) {
  392. !         if (STATS[K].VAL_TIME > CUR_TIME) {
  393.               STATS[K].STAT.st_nlink = -1;
  394.               STATS[K].FN = VAL_INVALID;
  395.               STATS[K].RS = VAL_INVALID;
  396.               if (DBOSI)
  397. !                 printf("expired=%d(%s)\n",K,STATS[K].NAME);
  398.           }
  399.       }
  400.   }
  401.   
  402. ! private char * newstr(STR)
  403. !     char * STR;
  404.   {
  405. !     char * P;
  406.   
  407. !     P = (char *) malloc(strlen(STR)+1);
  408. !     if (P != NULL) {
  409. !         strcpy(P,STR);
  410. !         return P;
  411.       }
  412.       return NULL;
  413.   }
  414.   
  415. ! private struct statobj * locate_statobj(path)
  416. !     char * path;
  417. ! {
  418. !     char STR[1024];
  419. !     char * PART[20];
  420. !     int K,P,LC;
  421. !     char * S;
  422.   
  423. !     if (*path != '/' || strcmp(path,"/") == 0)
  424.           return NULL;
  425. -     strcpy(STR,path);
  426. -     S = STR+1;
  427. -     K = 0;
  428. -     PART[K] = S;
  429. -     while ((S = (char*)index(S,'/')) != NULL) {
  430. -         *S++ = 0;
  431. -         PART[++K] = S;
  432. -         if (K >= MAX_LEVEL)
  433. -             return NULL;
  434.       }
  435. -     LC = K+1;
  436. -     expire_stats();
  437.       
  438. !     for (K = 0; K < LC && STATS[K].NAME != NULL && strcmp(STATS[K].NAME,PART[K]) == 0; K++);
  439. !     if (K == LC) {
  440. !         K--;
  441.           return &STATS[K];
  442. -     } else {
  443. -         release_stats(K);
  444. -         for (P = K; P < LC; P++) {
  445. -             STATS[P].NAME = newstr(PART[P]);
  446. -             STATS[P].STAT.st_nlink = -1;
  447. -             STATS[P].FN = VAL_INVALID;
  448. -             STATS[P].RS = VAL_INVALID;
  449.           }
  450. !         return &STATS[LC-1];
  451.       }
  452.   }
  453.       
  454.   OSstat(path,buf)
  455.       char * path;
  456.       struct stat *buf;
  457.   {
  458. -     struct stat B;
  459.       struct statobj * CE;
  460.   
  461.       if (DBOSI)
  462. --- 130,298 ----
  463.   private int EXPIRE_REQ;
  464.   
  465.   private expire_stats(K)
  466. !     register int K;
  467.   {
  468.       if (!EXPIRE_REQ)
  469.           return;
  470.       EXPIRE_REQ = 0;
  471. !     for (K = 0; K <= CUR_STAT_LEVEL; K++) {
  472. !         if (STATS[K].STAT.st_nlink < 0)
  473. !             continue;
  474. !         if (STATS[K].VAL_TIME <= CUR_TIME) {
  475. !             if (DBOSI)
  476. !                 printf("time delta %d vs %d (%d)\n",
  477. !                     CUR_TIME,STATS[K].VAL_TIME,
  478. !                     CUR_TIME - STATS[K].VAL_TIME);
  479.               STATS[K].STAT.st_nlink = -1;
  480.               STATS[K].FN = VAL_INVALID;
  481.               STATS[K].RS = VAL_INVALID;
  482.               if (DBOSI)
  483. !                 printf("expired=%d(%s) t=%d\n",K,STATS[K].NAME,
  484. !                        STATS[K].VAL_TIME - CUR_TIME);
  485.           }
  486.       }
  487.   }
  488.   
  489. ! private struct statobj * locate_statobj(path)
  490. !     char * path;
  491.   {
  492. !     register char *NEW,*OLD;
  493. !     register char *TMP;
  494. !     char *REPLACE;
  495. !     register int K;
  496.   
  497. !     if (DBOSI)
  498. !         printf("locate_statobj: path '%s'\n", path);
  499. ! 
  500. !     /* get the path and make sure it is an absolute one */
  501. !     NEW = path;
  502. !     if (*NEW++ != '/')
  503. !         return NULL;
  504. ! 
  505. !     /* get rid of old information */
  506. !     expire_stats();
  507. ! 
  508. !     /* record what we are replacing */
  509. !     REPLACE = CUR_STAT_STR;
  510. ! 
  511. !     /* loop thru each path component and check against current */
  512. !     for(K=0;;) {
  513. !         /* strip leading slashes */
  514. !         while (*NEW == '/') NEW++;
  515. ! 
  516. !         /* handle root */
  517. !         if (K == 0) {
  518. !             if (*NEW == '\0') {
  519. !                 if (DBOSI)
  520. !                     printf("locate_statobj: root\n");
  521. !                 return &STATS[0];
  522.               }
  523. +             /* something more */
  524. +             K++;
  525. +         }
  526. + 
  527. +         /* do we have info for this level? */
  528. +         if (K > CUR_STAT_LEVEL)
  529. +             break;    /* nope */
  530. + 
  531. +         /* do we have a name for this level */
  532. +         if ((OLD = STATS[K].NAME) == NULL)
  533. +             break;    /* nope */
  534. + 
  535. +         /* record buffer name */
  536. +         REPLACE = OLD;
  537. + 
  538. +         /* compare name */
  539. +         TMP = NEW;
  540. +         while (*OLD && *OLD == *TMP) {
  541. +             OLD++;
  542. +             TMP++;
  543. +         }
  544. + 
  545. +         /* did we end cleanly? */
  546. +         if (*OLD != '\0')
  547. +             break;    /* nope */
  548. + 
  549. +         /* did NEW path end? */
  550. +         if (*TMP == '\0') {
  551. +             /* yes */
  552. +             if (DBOSI)
  553. +                 printf("locate_statobj: found %d: '%s'\n",
  554. +                        K,STATS[K].NAME);
  555. +             return &STATS[K];
  556. +         }
  557. + 
  558. +         /* did NEW path end on slash? */
  559. +         if (*TMP != '/')
  560. +             break;    /* nope */
  561. + 
  562. +         /* about to loop, see if too many levels */
  563. +         if (++K >= MAX_LEVEL) {
  564. +             if (DBOSI)
  565. +                 printf("locate_statobj: too many '%s'\n",
  566. +                        path);
  567.               return NULL;
  568.           }
  569.   
  570. !         /* loop again */
  571. !         REPLACE = ++OLD;
  572. !         NEW = TMP;
  573. !     }
  574.   
  575. !     /* add components */
  576. !     release_stats(K);
  577. ! 
  578. !     OLD = REPLACE;
  579. !     for(;;) {
  580. !         /* strip leading slashes */
  581. !         while (*NEW == '/') NEW++;
  582. ! 
  583. !         /* make sure we have something */
  584. !         if (*NEW == '\0') {
  585. !             /* must be trailing slash */
  586. !             if (DBOSI)
  587. !                 printf("locate_statobj: trailing / in '%s'\n",
  588. !                        path);
  589.               return NULL;
  590.           }
  591.   
  592. !         /* record and copy component */
  593. !         STATS[K].NAME = OLD;
  594. ! 
  595. !         while (*NEW && *NEW != '/')
  596. !             *OLD++ = *NEW++;
  597. !         *OLD++ = '\0';
  598. ! 
  599. !         /* record new stat level */
  600. !         CUR_STAT_LEVEL = K;
  601. ! 
  602. !         /* are we done? */
  603. !         if (*NEW == '\0') {
  604. !             /* yep */
  605. !             if (DBOSI)
  606. !                 printf("locate_statobj: return %d: '%s'\n",
  607. !                        K,STATS[K].NAME);
  608.               return &STATS[K];
  609.           }
  610. ! 
  611. !         /* about to loop, see if too many levels */
  612. !         if (++K >= MAX_LEVEL) {
  613. !             if (DBOSI)
  614. !                 printf("locate_statobj: too many (add) '%s'\n",
  615. !                        path);
  616. !             return NULL;
  617.           }
  618. + 
  619. +         /* loop again */
  620.       }
  621.   
  622. +     /* NEVER REACHED */
  623. + }
  624. +     
  625.   OSstat(path,buf)
  626.       char * path;
  627.       struct stat *buf;
  628.   {
  629.       struct statobj * CE;
  630.   
  631.       if (DBOSI)
  632. ***************
  633. *** 193,210 ****
  634.   
  635.       CE = locate_statobj(path);
  636.       if (CE != NULL) {
  637. !         if (CE->STAT.st_nlink != -1) {
  638.               if (DBOSI)
  639.                   printf("OSstat=cache path\n");
  640.               bcopy(&CE->STAT,buf,sizeof(struct stat));
  641.               return 0;
  642.           }
  643. !         if (cwd_stat(path,&B) == 0) {
  644.               if (DBOSI)
  645.                   printf("OSstat=caching path\n");
  646. !             bcopy(&B,&CE->STAT,sizeof(struct stat));
  647.               CE->VAL_TIME = CUR_TIME+EXP_TIME;
  648. -             bcopy(&B,buf,sizeof(struct stat));
  649.               return 0;
  650.           }
  651.           return -1;
  652. --- 300,316 ----
  653.   
  654.       CE = locate_statobj(path);
  655.       if (CE != NULL) {
  656. !         if (CE->STAT.st_nlink >= 0) {
  657.               if (DBOSI)
  658.                   printf("OSstat=cache path\n");
  659.               bcopy(&CE->STAT,buf,sizeof(struct stat));
  660.               return 0;
  661.           }
  662. !         if (cwd_stat(path,buf) == 0) {
  663.               if (DBOSI)
  664.                   printf("OSstat=caching path\n");
  665. !             bcopy(buf,&CE->STAT,sizeof(struct stat));
  666.               CE->VAL_TIME = CUR_TIME+EXP_TIME;
  667.               return 0;
  668.           }
  669.           return -1;
  670.  
  671. Patch #:    rudy4
  672. Type:        performance improvement to file cache
  673. Priority:    none
  674. Modification:    add hash value for lookups
  675. Submitted:    Rudy Nedved (ern) <ern+@h.gp.cs.cmu.edu>
  676. Summary:    minimize byte comparisons on frequent name lookups in cache
  677. File:        cap60/applications/aufs/afpposfi.c
  678.  
  679. *** applications/aufs/afposfi.c.orig    Fri Dec  4 11:42:58 1992
  680. --- applications/aufs/afposfi.c        Fri Dec  4 12:43:37 1992
  681. ***************
  682. *** 1,7 ****
  683.   /*
  684. !  * $Author: djh $ $Date: 1992/06/23 23:29:41 $
  685. !  * $Header: /mac/src/cap60/applications/aufs/RCS/afposfi.c,v 2.3 1992/06/23 23:29:41 djh Rel djh $
  686. !  * $Revision: 2.3 $
  687.   */
  688.   
  689.   /*
  690. --- 1,7 ----
  691.   /*
  692. !  * $oAuthor: djh $ $oDate: 1992/06/23 23:29:41 $
  693. !  * $oHeader: /mac/src/cap60/applications/aufs/RCS/afposfi.c,v 2.3 1992/06/23 23:29:41 djh Rel djh $
  694. !  * $oRevision: 2.3 $
  695.   */
  696.   
  697.   /*
  698. ***************
  699. *** 50,55 ****
  700. --- 50,56 ----
  701.     IDirP fe_pdir;        /* directory */
  702.     int fe_okay;            /* last internal modify count */
  703.     char  *fe_fnam;        /* file */
  704. +   long   fe_hash;        /* hash value of file name */
  705.     /* should we use ctime instead perhaps? */
  706.     time_t fe_mtime;        /* last modify time: file system */
  707.     time_t fe_vtime;        /* last time validated */
  708. ***************
  709. *** 219,224 ****
  710. --- 220,226 ----
  711.     
  712.     free(fe->fe_fnam);            /* always free the name */
  713.     fe->fe_fnam = (char *) 0;        /*  and zero... */
  714. +   fe->fe_hash = 0;            /* (and clear the hash value)
  715.     fe->next = NULL;            /* trash it here since want in both */
  716.     if (fce == (FCacheEnt *) 0)        /* check for recycled entry */
  717.       lfce = fce = fe;            /* if none then save */
  718. ***************
  719. *** 235,240 ****
  720. --- 237,244 ----
  721.   fc_compare(fe,key)
  722.   FCacheEnt *fe,*key;
  723.   {
  724. +   if (fe->fe_hash != key->fe_hash)
  725. +     return(FALSE);
  726.     if (fe->fe_pdir != key->fe_pdir)
  727.       return(FALSE);
  728.     return(strcmp(fe->fe_fnam,key->fe_fnam) == 0);
  729. ***************
  730. *** 257,262 ****
  731. --- 261,267 ----
  732.   
  733.     fe->fe_pdir = key->fe_pdir;
  734.     fe->fe_fnam = (char *) malloc(strlen(key->fe_fnam)+1);
  735. +   fe->fe_hash = key->fe_hash;
  736.     fe->fe_okay = TRUE;
  737.     fe->fe_mtime = 0;
  738.     time(&fe->fe_vtime);            /* validate time stamp */
  739. ***************
  740. *** 484,493 ****
  741. --- 489,507 ----
  742.   IDirP pdir;
  743.   char *fn;
  744.   {
  745. +   register long hash;
  746. +   register char *p;
  747.     FCacheEnt key;
  748.   
  749.     key.fe_pdir = pdir;
  750.     key.fe_fnam = fn;
  751. +   p = fn;
  752. +   hash = 0;
  753. +   while (*p) {
  754. +     hash <<= 2;
  755. +     hash += *p++;
  756. +   }
  757. +   key.fe_hash = hash;
  758.     
  759.     /* do the "quick" check first */
  760.     if (getfe == 0 || !fc_compare(getfe,&key)) {
  761. ***************
  762. *** 501,511 ****
  763. --- 515,534 ----
  764.   IDirP pdir;     
  765.   char *fn;
  766.   {
  767. +   register long hash;
  768. +   register char *p;
  769.     FCacheEnt key;
  770.     int idx;
  771.   
  772.     key.fe_pdir = pdir;
  773.     key.fe_fnam = fn;
  774. +   p = fn;
  775. +   hash = 0;
  776. +   while (*p) {
  777. +     hash <<= 2;
  778. +     hash += *p++;
  779. +   }
  780. +   key.fe_hash = hash;
  781.   
  782.     EModified(pdir);        /* make parent directory as modified */
  783.     if (getfe == 0 || !fc_compare(getfe,&key)) {
  784. Patch #:    rudy5
  785. Type:        documentation update
  786. Priority:    none
  787. Modification:    Add performance comment about -s switch to aufs
  788. Submitted:    Rudy Nedved (ern) <ern+@h.gp.cs.cmu.edu>
  789. File:        cap60/man/AUFS.8
  790.  
  791. *** man/AUFS.8.orig    Fri Dec  4 11:43:42 1992
  792. --- man/AUFS.8        Fri Dec  4 13:04:33 1992
  793. ***************
  794. *** 199,204 ****
  795. --- 199,205 ----
  796.   to report usage statistics such as system time use and
  797.   number of times encountered for the various AFP commands.
  798.   These statistics are recorded in the log file at the end of a run.
  799. + NOTE: Recording these statistics slows down the server operations.
  800.   .TP 10
  801.   .BI \-d " <flags>"
  802.   specifies debugging flags for the cap libraries.  See cap(3) for a
  803.  
  804.  
  805.  
  806.  
  807.  
  808.  
  809.