#include "afs/afs_osidnlc.h"
/* Forward declarations. */
-static void afs_GetDownD(int anumber, int *aneedSpace);
+static void afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint);
static void afs_FreeDiscardedDCache(void);
static void afs_DiscardDCache(struct dcache *);
static void afs_FreeDCache(struct dcache *);
+/* For split cache */
+static afs_int32 afs_DCGetBucket(struct vcache *);
+static void afs_DCAdjustSize(struct dcache *, afs_int32, afs_int32);
+static void afs_DCMoveBucket(struct dcache *, afs_int32, afs_int32);
+static void afs_DCSizeInit(void);
+static afs_int32 afs_DCWhichBucket(afs_int32, afs_int32);
+
/*
* --------------------- Exported definitions ---------------------
*/
+/* For split cache */
+afs_int32 afs_blocksUsed_0; /*1K blocks in cache - in theory is zero */
+afs_int32 afs_blocksUsed_1; /*1K blocks in cache */
+afs_int32 afs_blocksUsed_2; /*1K blocks in cache */
+afs_int32 afs_pct1 = -1;
+afs_int32 afs_pct2 = -1;
+afs_uint32 afs_tpct1 = 0;
+afs_uint32 afs_tpct2 = 0;
+afs_uint32 splitdcache = 0;
+
afs_lock_t afs_xdcache; /*Lock: alloc new disk cache entries */
afs_int32 afs_freeDCList; /*Free list for disk cache entries */
afs_int32 afs_freeDCCount; /*Count of elts in freeDCList */
int cacheDiskType; /*Type of backing disk for cache */
struct afs_cacheOps *afs_cacheType;
+static afs_int32
+afs_DCGetBucket(struct vcache *avc)
+{
+ /* This should be replaced with some sort of user configurable function */
+ if (avc->states & CRO) {
+ return 2;
+ } else if (avc->states & CBackup) {
+ return 1;
+ } else {
+ /* RW */
+ }
+ /* main bucket */
+ return 1;
+}
+
+static void
+afs_DCAdjustSize(struct dcache *adc, afs_int32 oldSize, afs_int32 newSize)
+{
+ afs_int32 adjustSize = newSize - oldSize;
+
+ if (!splitdcache)
+ return;
+ switch (adc->bucket)
+ {
+ case 0:
+ afs_blocksUsed_0 += adjustSize;
+ afs_stats_cmperf.cacheBucket0_Discarded += oldSize;
+ break;
+ case 1:
+ afs_blocksUsed_1 += adjustSize;
+ afs_stats_cmperf.cacheBucket1_Discarded += oldSize;
+ break;
+ case 2:
+ afs_blocksUsed_2 += adjustSize;
+ afs_stats_cmperf.cacheBucket2_Discarded += oldSize;
+ break;
+ }
+
+ return;
+}
+
+static void
+afs_DCMoveBucket(struct dcache *adc, afs_int32 size, afs_int32 newBucket)
+{
+ if (!splitdcache)
+ return;
+
+ switch (adc->bucket)
+ {
+ case 0:
+ afs_blocksUsed_0 -= size;
+ break;
+ case 1:
+ afs_blocksUsed_1 -= size;
+ break;
+ case 2:
+ afs_blocksUsed_2 -= size;
+ break;
+ }
+
+ adc->bucket = newBucket;
+
+ switch (adc->bucket)
+ {
+ case 0:
+ afs_blocksUsed_0 += size;
+ break;
+ case 1:
+ afs_blocksUsed_1 += size;
+ break;
+ case 2:
+ afs_blocksUsed_2 += size;
+ break;
+ }
+
+ return;
+}
+
+static void
+afs_DCSizeInit(void)
+{
+ afs_blocksUsed_0 = afs_blocksUsed_1 = afs_blocksUsed_2 = 0;
+}
+
+static afs_int32
+afs_DCWhichBucket(afs_int32 phase, afs_int32 bucket)
+{
+ if (!splitdcache)
+ return 0;
+
+ afs_pct1 = afs_blocksUsed_1*100/afs_cacheBlocks;
+ afs_pct2 = afs_blocksUsed_2*100/afs_cacheBlocks;
+
+ /* Short cut: if we don't know about it, try to kill it */
+ if (phase < 2 && afs_blocksUsed_0)
+ return 0;
+
+ if (afs_pct1 > afs_tpct1)
+ return 1;
+ if (afs_pct2 > afs_tpct2)
+ return 2;
+ return 0; /* unlikely */
+}
/*
afs_blocksUsed - afs_blocksDiscarded - cb_lowat;
slots_needed =
dc_hiwat - afs_freeDCCount - afs_discardDCCount;
- afs_GetDownD(slots_needed, &space_needed);
+ afs_GetDownD(slots_needed, &space_needed, 0);
if ((space_needed <= 0) && (slots_needed <= 0)) {
break;
}
if (!newSize)
adc->validPos = 0;
newSize = ((newSize + afs_fsfragsize) ^ afs_fsfragsize) >> 10; /* round up */
+ afs_DCAdjustSize(adc, oldSize, newSize);
if (newSize > oldSize) {
/* We're growing the file, wakeup the daemon */
afs_MaybeWakeupTruncateDaemon();
#define MAXATONCE 16 /* max we can obtain at once */
static void
-afs_GetDownD(int anumber, int *aneedSpace)
+afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint)
{
struct dcache *tdc;
afs_hyper_t maxVictimTime; /* youngest (largest LRU time) victim */
afs_uint32 maxVictimPtr; /* where it is */
int discard;
+ int curbucket;
AFS_STATCNT(afs_GetDownD);
if (CheckLock(&afs_xdcache) != -1)
if (anumber > MAXATONCE)
anumber = MAXATONCE; /* all we can do */
+ /* rewrite so phases include a better eligiblity for gc test*/
/*
* The phase variable manages reclaims. Set to 0, the first pass,
- * we don't reclaim active entries. Set to 1, we reclaim even active
- * ones.
+ * we don't reclaim active entries, or other than target bucket.
+ * Set to 1, we reclaim even active ones in target bucket.
+ * Set to 2, we reclaim any inactive one.
+ * Set to 3, we reclaim even active ones.
*/
- phase = 0;
+ if (splitdcache) {
+ phase = 0;
+ } else {
+ phase = 4;
+ }
+
for (i = 0; i < afs_cacheFiles; i++)
/* turn off all flags */
afs_indexFlags[i] &= ~IFFlag;
/* find oldest entries for reclamation */
maxVictimPtr = victimPtr = 0;
hzero(maxVictimTime);
+ curbucket = afs_DCWhichBucket(phase, buckethint);
/* select victims from access time array */
for (i = 0; i < afs_cacheFiles; i++) {
if (afs_indexFlags[i] & (IFDataMod | IFFree | IFDiscarded)) {
continue;
}
tdc = afs_indexTable[i];
+ if (tdc && (curbucket != tdc->bucket) && (phase < 4))
+ {
+ /* Wrong bucket; can't use it! */
+ continue;
+ }
if (tdc && (tdc->refCount != 0)) {
/* Referenced; can't use it! */
continue;
if (tvc) {
tchunkoffset = AFS_CHUNKTOBASE(tdc->f.chunk);
chunkFlags = afs_indexFlags[tdc->index];
- if (phase == 0 && osi_Active(tvc))
- skip = 1;
- if (phase > 0 && osi_Active(tvc)
- && (tvc->states & CDCLock)
- && (chunkFlags & IFAnyPages))
- skip = 1;
+ if ((((phase / 2) & 1) == 0) && osi_Active(tvc))
+ skip = 1;
+ if ((((phase / 2) & 1) == 1) && osi_Active(tvc)
+ && (tvc->states & CDCLock)
+ && (chunkFlags & IFAnyPages))
+ skip = 1;
if (chunkFlags & IFDataMod)
skip = 1;
afs_Trace4(afs_iclSetp, CM_TRACE_GETDOWND,
afs_PutDCache(tdc);
}
- if (phase == 0) {
+ if (phase < 5) {
/* Phase is 0 and no one was found, so try phase 1 (ignore
* osi_Active flag) */
if (j == 0) {
- phase = 1;
+ phase++;
for (i = 0; i < afs_cacheFiles; i++)
/* turn off all flags */
afs_indexFlags[i] &= ~IFFlag;
}
} else {
- /* found no one in phase 1, we're hosed */
+ /* found no one in phases 0-5, we're hosed */
if (victimPtr == 0)
break;
}
afs_CFileTruncate(tfile, 0);
afs_CFileClose(tfile);
afs_AdjustSize(tdc, 0);
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, 0, 0);
/*
* Free the element we just truncated
break; /* leaving refCount high for caller */
}
afs_PutDCache(tdc);
+ tdc = NULL;
}
index = afs_dcnextTbl[index];
}
while (1) {
if (!setLocks)
avc->states |= CDCLock;
- afs_GetDownD(5, (int *)0); /* just need slots */
+ /* just need slots */
+ afs_GetDownD(5, (int *)0, afs_DCGetBucket(avc));
if (!setLocks)
avc->states &= ~CDCLock;
if (afs_discardDCList != NULLIDX
size =
((tdc->f.chunkBytes +
afs_fsfragsize) ^ afs_fsfragsize) >> 10;
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, size, 0);
afs_blocksDiscarded -= size;
afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
if (aflags & 2) {
*/
afs_indexFlags[tdc->index] &= ~(IFDirtyPages | IFAnyPages);
tdc->f.fid = avc->fid;
+ if (avc->states & CRO)
+ tdc->f.states = DRO;
+ else if (avc->states & CBackup)
+ tdc->f.states = DBackup;
+ else
+ tdc->f.states = DRW;
+ afs_DCMoveBucket(tdc, 0, afs_DCGetBucket(avc));
afs_indexUnique[tdc->index] = tdc->f.fid.Fid.Unique;
hones(tdc->f.versionNo); /* invalid value */
tdc->f.chunk = chunk;
afs_dvhashTbl[i] = tdc->index;
tdc->dflags = DFEntryMod;
tdc->mflags = 0;
- tdc->f.states = 0;
afs_MaybeWakeupTruncateDaemon();
MReleaseWriteLock(&afs_xdcache);
ConvertWToSLock(&tdc->lock);
if (vType(avc) == VDIR) {
DZap(tdc);
}
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, 0, 0);
ReleaseWriteLock(&tdc->lock);
afs_PutDCache(tdc);
ObtainWriteLock(&afs_xcbhash, 454);
* avc->lock(W); assert(!setLocks || slowPass)
*/
osi_Assert(!setLocks || slowPass);
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, 0, 0);
tdc = NULL;
goto done;
}
#endif
lasterrtime = osi_Time();
afs_indexUnique[aslot] = tdc->f.fid.Fid.Unique;
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, 0, 0);
+ } else {
+ if (&tdc->f != 0) {
+ if (tdc->f.states & DRO) {
+ afs_DCMoveBucket(tdc, 0, 2);
+ } else if (tdc->f.states & DBackup) {
+ afs_DCMoveBucket(tdc, 0, 1);
+ } else {
+ afs_DCMoveBucket(tdc, 0, 1);
+ }
+ }
}
tdc->refCount = 1;
tdc->index = aslot;
tdc->f.fid.Fid.Volume = 0; /* not in the hash table */
if (tstat.size != 0)
osi_UFSTruncate(tfile, 0);
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, 0, 0);
/* put entry in free cache slot list */
afs_dvnextTbl[tdc->index] = afs_freeDCList;
afs_freeDCList = index;
afs_dcentries = aDentries;
afs_blocksUsed = 0;
+ afs_stats_cmperf.cacheBucket0_Discarded =
+ afs_stats_cmperf.cacheBucket1_Discarded =
+ afs_stats_cmperf.cacheBucket2_Discarded = 0;
+ afs_DCSizeInit();
QInit(&afs_DLRU);
}
afs_osi_Free(afs_dchashTbl, afs_dhashsize * sizeof(afs_int32));
afs_blocksUsed = afs_dcentries = 0;
+ afs_stats_cmperf.cacheBucket0_Discarded =
+ afs_stats_cmperf.cacheBucket1_Discarded =
+ afs_stats_cmperf.cacheBucket2_Discarded = 0;
hzero(afs_indexCounter);
afs_freeDCCount = 0;
afs_int32 afs_shutdown = 0;
afs_int32 cacheBlocks; /*Num blocks in the cache */
afs_int32 cacheFiles = 1000; /*Optimal # of files in workstation cache */
+afs_int32 rwpct = 0;
+afs_int32 ropct = 0;
afs_int32 cacheStatEntries = 300; /*Number of stat cache entries */
char cacheBaseDir[1024]; /*Where the workstation AFS cache lives */
char confDir[1024]; /*Where the workstation AFS configuration lives */
static int enable_fakestat = 0; /* enable fakestat support */
static int enable_backuptree = 0; /* enable backup tree support */
static int enable_nomount = 0; /* do not mount */
+static int enable_splitcache = 0;
#ifdef notdef
static int inodes = 60; /* VERY conservative, but has to be */
#endif
exit(1);
}
}
-
+ if (as->parms[34].items) {
+ char *c;
+ if (!as->parms[34].items->data ||
+ ((c = strchr(as->parms[34].items->data, '/')) == NULL))
+ printf("ignoring splitcache (specify as RW/RO percentages: 60/40)\n");
+ else {
+ ropct = atoi((char *)c+1);
+ *c = '\0';
+ rwpct = atoi((char *)as->parms[30].items->data);
+ if ((rwpct != 0) && (ropct != 0) && (ropct+rwpct == 100)) {
+ /* -splitcache */
+ enable_splitcache = 1;
+ }
+ }
+ }
/*
* Pull out all the configuration info for the workstation's AFS cache and
* the cellular community we're willing to let our users see.
cparams.inodes = inodes;
#endif
call_syscall(AFSOP_CACHEINIT, &cparams);
+
+ /* do it before we init the cache inodes */
+ if (enable_splitcache) {
+ call_syscall(AFSOP_BUCKETPCT, 1, rwpct);
+ call_syscall(AFSOP_BUCKETPCT, 2, ropct);
+ }
+
if (afsd_CloseSynch)
call_syscall(AFSOP_CLOSEWAIT);
cmd_AddParm(ts, "-settime", CMD_FLAG, CMD_OPTIONAL,
"don't set the time");
cmd_AddParm(ts, "-rxpck", CMD_SINGLE, CMD_OPTIONAL, "set rx_extraPackets to this value");
+ cmd_AddParm(ts, "-splitcache", CMD_SINGLE, CMD_OPTIONAL, "Percentage RW versus RO in cache (specify as 60/40)");
+
return (cmd_Dispatch(argc, argv));
}
git://git.openafs.org / openafs.git / commitdiff