cache-size-limit-upping-20050728

based on work from wes chow

allow larger caches without variable overflows.

does not port to 1.4 as-is.

diff --git a/src/afs/VNOPS/afs_vnop_write.c b/src/afs/VNOPS/afs_vnop_write.c
index 4a93e5572b38f36b2cd51de6ea812fc9d8ccc3af..ed1ee645feccf33d58b241b93614ad39ac0b54f1 100644 (file)
--- a/src/afs/VNOPS/afs_vnop_write.c
+++ b/src/afs/VNOPS/afs_vnop_write.c
@@ -197,7 +197,7 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
            if (tdc)
                ObtainWriteLock(&tdc->lock, 653);
        } else if (afs_blocksUsed >
-                  (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                  PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
            tdc = afs_FindDCache(avc, filePos);
            if (tdc) {
                ObtainWriteLock(&tdc->lock, 654);
@@ -211,10 +211,10 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
            if (!tdc) {
                afs_MaybeWakeupTruncateDaemon();
                while (afs_blocksUsed >
-                      (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                      PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
                    ReleaseWriteLock(&avc->lock);
                    if (afs_blocksUsed - afs_blocksDiscarded >
-                       (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                       PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
                        afs_WaitForCacheDrain = 1;
                        afs_osi_Sleep(&afs_WaitForCacheDrain);
                    }
@@ -441,7 +441,7 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
            if (tdc)
                ObtainWriteLock(&tdc->lock, 657);
        } else if (afs_blocksUsed >
-                  (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                  PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
            tdc = afs_FindDCache(avc, filePos);
            if (tdc) {
                ObtainWriteLock(&tdc->lock, 658);
@@ -455,10 +455,10 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
            if (!tdc) {
                afs_MaybeWakeupTruncateDaemon();
                while (afs_blocksUsed >
-                      (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                      PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
                    ReleaseWriteLock(&avc->lock);
                    if (afs_blocksUsed - afs_blocksDiscarded >
-                       (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                       PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
                        afs_WaitForCacheDrain = 1;
                        afs_osi_Sleep(&afs_WaitForCacheDrain);
                    }

diff --git a/src/afs/afs.h b/src/afs/afs.h
index c7ec1fe739711047e8d7a6fa0eb84ac9793c5fe3..99c22162ff6c81a148523511f065499f4596ef03 100644 (file)
--- a/src/afs/afs.h
+++ b/src/afs/afs.h
@@ -1042,7 +1042,7 @@ extern afs_int32 *afs_indexUnique;        /*dcache entry Fid.Unique */
 extern afs_int32 *afs_dvnextTbl;       /*Dcache hash table links */
 extern afs_int32 *afs_dcnextTbl;       /*Dcache hash table links */
 extern afs_int32 afs_cacheFiles;       /*Size of afs_indexTable */
-extern afs_int32 afs_cacheBlocks;      /*1K blocks in cache */
+extern afs_size_t afs_cacheBlocks;     /*1K blocks in cache */
 extern afs_int32 afs_cacheStats;       /*Stat entries in cache */
 extern struct vcache *afs_vhashT[VCSIZE];      /*Stat cache hash table */
 extern struct vcache *afs_vhashTV[VCSIZE]; /* cache hash table on volume */
@@ -1115,11 +1115,15 @@ extern struct brequest afs_brs[NBRS];   /* request structures */
 #define CM_CACHESIZEDRAINEDPCT 95      /* wakeup processes when down to here. */
 #define CM_WAITFORDRAINPCT     98      /* sleep if cache is this full. */
 
+#define PERCENT(p, v) \
+    ( (p)*128/100*(v) / 128 )
+
 #define afs_CacheIsTooFull() \
     (afs_blocksUsed - afs_blocksDiscarded > \
-       (CM_DCACHECOUNTFREEPCT*afs_cacheBlocks)/100 || \
+        PERCENT(CM_DCACHECOUNTFREEPCT, afs_cacheBlocks) || \
      afs_freeDCCount - afs_discardDCCount < \
-       ((100-CM_DCACHECOUNTFREEPCT)*afs_cacheFiles)/100)
+        PERCENT(100-CM_DCACHECOUNTFREEPCT, afs_cacheFiles))
+
 
 /* Handy max length of a numeric string. */
 #define        CVBS    12              /* max afs_int32 is 2^32 ~ 4*10^9, +1 for NULL, +luck */

diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c
index b6496abbd2545ebe1f388c8d22c909010a07eb35..2fa7a2a85635281a5916be31c7211d480f8163f4 100644 (file)
--- a/src/afs/afs_dcache.c
+++ b/src/afs/afs_dcache.c
@@ -23,7 +23,7 @@ RCSID
 #include "afs/afs_osidnlc.h"
 
 /* Forward declarations. */
-static void afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint);
+static void afs_GetDownD(afs_int32 anumber, afs_size_t *aneedSpace, afs_int32 buckethint);
 static void afs_FreeDiscardedDCache(void);
 static void afs_DiscardDCache(struct dcache *);
 static void afs_FreeDCache(struct dcache *);
@@ -70,10 +70,10 @@ unsigned char *afs_indexFlags;      /*(only one) Is there data there? */
 afs_hyper_t afs_indexCounter;  /*Fake time for marking index
                                 * entries */
 afs_int32 afs_cacheFiles = 0;  /*Size of afs_indexTable */
-afs_int32 afs_cacheBlocks;     /*1K blocks in cache */
+afs_size_t afs_cacheBlocks;    /*1K blocks in cache */
 afs_int32 afs_cacheStats;      /*Stat entries in cache */
-afs_int32 afs_blocksUsed;      /*Number of blocks in use */
-afs_int32 afs_blocksDiscarded; /*Blocks freed but not truncated */
+afs_size_t afs_blocksUsed;     /*Number of blocks in use */
+afs_size_t afs_blocksDiscarded;        /*Blocks freed but not truncated */
 afs_int32 afs_fsfragsize = 1023;       /*Underlying Filesystem minimum unit 
                                         *of disk allocation usually 1K
                                         *this value is (truefrag -1 ) to
@@ -344,7 +344,7 @@ afs_CacheTruncateDaemon(void)
 {
     osi_timeval_t CTD_tmpTime;
     u_int counter;
-    u_int cb_lowat;
+    afs_size_t cb_lowat;
     u_int dc_hiwat =
        (100 - CM_DCACHECOUNTFREEPCT +
         CM_DCACHEEXTRAPCT) * afs_cacheFiles / 100;
@@ -354,11 +354,11 @@ afs_CacheTruncateDaemon(void)
     osi_GetuTime(&CTD_stats.CTD_afterSleep);
     afs_TruncateDaemonRunning = 1;
     while (1) {
-       cb_lowat = ((CM_DCACHESPACEFREEPCT - CM_DCACHEEXTRAPCT)
-                   * afs_cacheBlocks) / 100;
+       cb_lowat =  PERCENT(CM_DCACHESPACEFREEPCT-CM_DCACHEEXTRAPCT, afs_cacheBlocks);
        MObtainWriteLock(&afs_xdcache, 266);
        if (afs_CacheTooFull) {
-           int space_needed, slots_needed;
+           afs_size_t space_needed;
+           afs_int32 slots_needed;
            /* if we get woken up, we should try to clean something out */
            for (counter = 0; counter < 10; counter++) {
                space_needed =
@@ -497,7 +497,7 @@ afs_AdjustSize(register struct dcache *adc, register afs_int32 newSize)
 
 #define        MAXATONCE   16          /* max we can obtain at once */
 static void
-afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint)
+afs_GetDownD(afs_int32 anumber, afs_size_t *aneedSpace, afs_int32 buckethint)
 {
 
     struct dcache *tdc;
@@ -916,7 +916,7 @@ afs_FlushDCache(register struct dcache *adc)
 
     if (afs_WaitForCacheDrain) {
        if (afs_blocksUsed <=
-           (CM_CACHESIZEDRAINEDPCT * afs_cacheBlocks) / 100) {
+           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
            afs_WaitForCacheDrain = 0;
            afs_osi_Wakeup(&afs_WaitForCacheDrain);
        }
@@ -949,7 +949,7 @@ afs_FreeDCache(register struct dcache *adc)
 
     if (afs_WaitForCacheDrain) {
        if ((afs_blocksUsed - afs_blocksDiscarded) <=
-           (CM_CACHESIZEDRAINEDPCT * afs_cacheBlocks) / 100) {
+           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
            afs_WaitForCacheDrain = 0;
            afs_osi_Wakeup(&afs_WaitForCacheDrain);
        }
@@ -999,7 +999,7 @@ afs_DiscardDCache(register struct dcache *adc)
 
     if (afs_WaitForCacheDrain) {
        if ((afs_blocksUsed - afs_blocksDiscarded) <=
-           (CM_CACHESIZEDRAINEDPCT * afs_cacheBlocks) / 100) {
+           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
            afs_WaitForCacheDrain = 0;
            afs_osi_Wakeup(&afs_WaitForCacheDrain);
        }
@@ -1082,9 +1082,8 @@ afs_MaybeFreeDiscardedDCache(void)
 
     AFS_STATCNT(afs_MaybeFreeDiscardedDCache);
 
-    while (afs_blocksDiscarded
-          && (afs_blocksUsed >
-              (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100)) {
+    while (afs_blocksDiscarded &&
+          (afs_blocksUsed > PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks))) {
        afs_FreeDiscardedDCache();
     }
     return 0;
@@ -2115,9 +2114,8 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
        }
 
        /* Sleep here when cache needs to be drained. */
-       if (setLocks && !slowPass
-           && (afs_blocksUsed >
-               (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100)) {
+       if (setLocks && !slowPass &&
+           (afs_blocksUsed > PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks))) {
            /* Make sure truncate daemon is running */
            afs_MaybeWakeupTruncateDaemon();
            ObtainWriteLock(&tdc->tlock, 614);
@@ -2126,7 +2124,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
            ReleaseWriteLock(&tdc->lock);
            ReleaseReadLock(&avc->lock);
            while ((afs_blocksUsed - afs_blocksDiscarded) >
-                  (CM_WAITFORDRAINPCT * afs_cacheBlocks) / 100) {
+                  PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
                afs_WaitForCacheDrain = 1;
                afs_osi_Sleep(&afs_WaitForCacheDrain);
            }

diff --git a/src/afs/afs_init.c b/src/afs/afs_init.c
index 219bd8b316000583cd15b0b28ff3f66024f9d1f8..e13c9724a7851d1e5e32b38b563b93133a6bde06 100644 (file)
--- a/src/afs/afs_init.c
+++ b/src/afs/afs_init.c
@@ -174,7 +174,7 @@ afs_CacheInit(afs_int32 astatSize, afs_int32 afiles, afs_int32 ablocks,
 void
 afs_ComputeCacheParms(void)
 {
-    register afs_int32 i;
+    register afs_size_t i;
     afs_int32 afs_maxCacheDirty;
 
     /*

diff --git a/src/afs/afs_prototypes.h b/src/afs/afs_prototypes.h
index b55ff0c9f01542386c5936badb8577754d91b6f4..f997aa4a270ca865de353b3a2123b997abd24464 100644 (file)
--- a/src/afs/afs_prototypes.h
+++ b/src/afs/afs_prototypes.h
@@ -293,8 +293,8 @@ extern afs_int32 *afs_dvhashTbl;
 extern afs_int32 afs_dhashsize;
 extern afs_rwlock_t afs_xdcache;
 extern afs_size_t afs_vmMappingEnd;
-extern afs_int32 afs_blocksUsed;
-extern afs_int32 afs_blocksDiscarded;
+extern afs_size_t afs_blocksUsed;
+extern afs_size_t afs_blocksDiscarded;
 extern int afs_WaitForCacheDrain;
 extern int cacheDiskType;
 extern afs_uint32 afs_tpct1, afs_tpct2, splitdcache;