#include "common.h"

#define NO_CACHEID -1

static int userTopicCacheHead = NO_CACHEID; // our marker for last allocated cache, used to find next free one

static USERCACHE* userTopicCacheIndex = NULL; // data ring of the user topic caches + timestamp/volley info

char* cacheBase = NULL; // start of contiguous cache block of caches

char* cacheDataEnd = NULL; // end of cached data

char* cacheFree = NULL; // next free in cache

char* fileBuffer = NULL; // stack pointer

static int currentCache = NO_CACHEID; // the current user file buffer

unsigned int userCacheCount = 1; // holds 1 user by default

unsigned int userCacheSize = DEFAULT_USER_CACHE; // size of user file buffer (our largest buffers)

unsigned int fileCacheCount = 0; // number of read only files cached

unsigned int fileCacheSize = 0; // amount of cache given over to files

static USERCACHE* fileCacheIndex = NULL; // index of recent cached files

USERCACHE* fileCacheIndexFree = NULL; // index of recent cached files

unsigned int fileCacheTargetSize = 0; // target size for recency cache

static int fileCacheRecencyHead = NO_CACHEID;

static int fileCacheFrequencyHead = NO_CACHEID;

static int fileCacheRecencyHistoryHead = NO_CACHEID;

static int fileCacheFrequencyHistoryHead = NO_CACHEID;

static unsigned int fileCacheRecencySize = 0;

static unsigned int fileCacheFrequencySize = 0;

static unsigned int fileCacheRecencyHistorySize = 0;

static unsigned int fileCacheFrequencyHistorySize = 0;

int volleyLimit = -1; // default save user records to file every n volley (use default 0 if this value is unchanged by user)

unsigned int userTopicStoreSize = 0;

unsigned int userTableSize = 0; // memory used which we will display

void InitUserCache()

{

if (cacheBase) return; // no need to reallocate on reload

// Cache divided as:

// | cached topic + file data | user topic index | imported file indexes |

// all files read into stack, and if needed to be cached then copied into free slot in cache

userTopicStoreSize = (userCacheCount * (userCacheSize + 2)) + fileCacheSize; // minimum file cache spot

userTopicStoreSize /= 64;

userTopicStoreSize = (userTopicStoreSize * 64) + 64;

userTableSize = (userCacheCount * sizeof(USERCACHE)) + (fileCacheCount * 2 * sizeof(USERCACHE));

userTableSize /= 64;

userTableSize = (userTableSize * 64) + 64; // 64 bit align both ends

cacheBase = (char*) malloc( userTopicStoreSize + userTableSize );

if (!cacheBase)

{

(*printer)((char*)"Out of memory space for user cache %d %d %d\r\n",userTopicStoreSize,userTableSize,MAX_DICTIONARY);

ReportBug((char*)"FATAL: Cannot allocate memory space for user cache %ld\r\n",(long int) userTopicStoreSize);

}

// start of actual data cache

cacheDataEnd = cacheBase + userTopicStoreSize;

*cacheBase = 0;

cacheFree = cacheBase + 1;

// initialize the user topic index - simple LRU circular list

userTopicCacheIndex = (USERCACHE *)cacheDataEnd;

if (userCacheCount > 0)

{

USERCACHE* C = userTopicCacheIndex;

for (unsigned int i = 0; i < userCacheCount; ++i)

{

C->prior = (i == 0 ? userCacheCount : i) - 1; // before ptr

C->next = ( i == (userCacheCount-1) ? 0 : i + 1); // after ptr

C->timestamp = 0;

C->hash = 0;

C->buffer = 0;

++C;

}

userTopicCacheHead = 0;

}

// initialize data file index - CAR: Clock with Adaptive Replacement

// https://www.usenix.org/legacy/publications/library/proceedings/fast04/tech/full_papers/bansal/bansal.pdf

// need to split the cache into 2 halfs, recent and frequent

if (fileCacheCount > 1)

{

fileCacheIndex = userTopicCacheIndex + userCacheCount;

fileCacheIndexFree = fileCacheIndex;

}

}

void CloseUserCache()

{

if (cacheBase) free(cacheBase);

cacheBase = NULL;

cacheFree = NULL;

}

static bool IsUserTopicFile(char* name)

{

char word[MAX_WORD_SIZE];

sprintf(word,(char*)"%s/%stopic_", usersfolder, GetUserPath(loginID));

return (!strnicmp(name, word, strlen(word)));

}

static unsigned int FilenameHash(char* filename)

{

size_t len = strlen(filename);

if (len == 0) return 0;

return Hashit((unsigned char*)filename, len, hasUpperCharacters, hasUTF8Characters, hasSeparatorCharacters);

}

static void BufferFilename(char* buffer, char* filename)

{

*filename = 0;

char* at = strchr(buffer,'\r'); // separate off the name from the rest of the data

if (at)

{

*at = 0;

strcpy(filename, buffer);

*at = '\r';

}

}

static char* GetCacheBuffer(USERCACHE* C)

{

return (cacheBase + C->buffer);

}

static char* GetUserTopicCacheBuffer(int which)

{

return (which < 0) ? NULL : (GetCacheBuffer(CACHEITEM(userTopicCacheIndex, which)));

}

static char* GetFileCacheBuffer(int which)

{

return (which < 0) ? NULL : (GetCacheBuffer(CACHEITEM(fileCacheIndex, which)));

}

static void WriteBuffer(char* filename, char* ptr, size_t size)

{

if (!*ptr) return; // nothing to write out

if (size == 0) size = strlen(ptr);// request to compute size

uint64 start_time = (timing & TIME_USERCACHE) ? ElapsedMilliseconds() : 0;

FILE* out = userFileSystem.userCreate(filename); // wb binary file (if external as db write should not fail)

if (!out) // see if we can create the directory (assuming its missing)

{

char call[MAX_WORD_SIZE];

sprintf(call,(char*)"mkdir %s",usersfolder);

MakeDirectory(usersfolder);

out = userFileSystem.userCreate(filename);

if (!out)

{

ReportBug((char*)"cannot open user state file %s to write\r\n", ptr);

if (dieonwritefail) myexit("Failed to open user state file to write");

return;

}

}

#ifdef LOCKUSERFILE

#ifdef LINUX

if (server && filesystemOverride == NORMALFILES)

{

int fd = fileno(out);

if (fd < 0)

{

FClose(out);

return;

}

struct flock fl;

fl.l_type = F_WRLCK; /* F_RDLCK, F_WRLCK, F_UNLCK */

fl.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */

fl.l_start = 0; /* Offset from l_whence */

fl.l_len = 0; /* length, 0 = to EOF */

fl.l_pid = getpid(); /* our PID */

if (fcntl(fd, F_SETLKW, &fl) < 0)

{

userFileSystem.userClose(out);

return;

}

}

#endif

#endif

EncryptableFileWrite(ptr,1,size,out,userEncrypt,"USER"); // user topic file write

userFileSystem.userClose(out);

if (timing & TIME_USERCACHE)

{

int diff = (int)(ElapsedMilliseconds() - start_time);

if (timing & TIME_ALWAYS || diff > 0) Log((server) ? SERVERLOG : STDTIMELOG, (char*)"Write user cache file %s time: %d ms\r\n", filename, diff);

}

}

static void WriteCache(unsigned int which, size_t size)

{

char* ptr = GetUserTopicCacheBuffer(which);

if (!*ptr) return; // nothing to write out

USERCACHE* C = CACHEITEM(userTopicCacheIndex, which);

unsigned int volleys = VOLLEYCOUNT(C);

if (!volleys) return; // unchanged from prior write out

if (size == 0) size = strlen(ptr);// request to compute size

char filename[SMALL_WORD_SIZE];

BufferFilename(ptr, filename);

WriteBuffer(filename, ptr, size);

C->timestamp &= MAX_CACHE_DURATION; // clear volley count since last written but keep time info

if (trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : USERLOG,(char*)"write cache (%d) %s \r\n",which, filename);

}

void FlushCache() // writes out the cache but does not invalidate it

{

if (!cacheBase) return; // never inited

int start = userTopicCacheHead;

while (userCacheCount) // kill all active user topic caches

{

WriteCache(start, 0);

start = CACHEITEM(userTopicCacheIndex, start)->next;

if (start == userTopicCacheHead) break; // been round in a circle

}

}

static void MoveBuffers(USERCACHE* cache, int head, unsigned int after, unsigned int diff)

{

if (head < 0) return;

int start = head;

while (ALWAYS)

{

USERCACHE* C = CACHEITEM(cache, start);

if (C->hash > 0 && C->buffer > after) C->buffer -= diff;

start = C->next;

if (start == head) break;

}

}

static void ChangeBlockSize(USERCACHE* cache, int which, unsigned int newSize)

{

USERCACHE* C = CACHEITEM(cache, which);

if (C->hash == 0) return;

char* ptr = GetCacheBuffer(C);

if (!ptr) return;

unsigned int curBlock = C->buffer;

unsigned int curSize = strlen(ptr);

unsigned int diff = (newSize == 0 ? curSize : curSize - newSize + 1);

// need to move all the other buffer references from all the other indexes

MoveBuffers(userTopicCacheIndex, userTopicCacheHead, curBlock, diff);

MoveBuffers(fileCacheIndex, fileCacheRecencyHead, curBlock, diff);

MoveBuffers(fileCacheIndex, fileCacheFrequencyHead, curBlock, diff);

char* dst = ptr + newSize;

char* src = ptr + curSize;

size_t len = cacheFree - src;

cacheFree -= diff;

if (newSize > 0)

{

// need string length terminator

++dst;

cacheFree += 2;

}

else

{

// clear cache so it can be reused

*ptr = 0;

C->buffer = 0;

}

memmove(dst, src, len);

}

static void EvictFromUserTopicCache(int which, bool write) // remove an item from the cache

{

char* ptr = GetUserTopicCacheBuffer(which);

if (ptr && CACHEITEM(userTopicCacheIndex, which)->hash > 0)

{

if (write) WriteCache(which, 0);

ChangeBlockSize(userTopicCacheIndex, which, 0);

CACHEITEM(userTopicCacheIndex, which)->hash = 0;

if (trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : USERLOG,(char*)"evicted user topic cache (%d)\r\n",which);

}

}

static USERCACHE* AddFileCacheEntry(USERCACHE* C, int &head)

{

if (!C) C = fileCacheIndexFree++;

unsigned int index = CACHEINDEX(fileCacheIndex, C);

if (head >= 0)

{

USERCACHE* CH = CACHEITEM(fileCacheIndex, head);

unsigned int last = CH->prior;

USERCACHE* CL = CACHEITEM(fileCacheIndex, last);

CH->prior = index;

CL->next = index;

C->prior = last;

C->next = head;

}

else

{

head = index;

C->prior = head;

C->next = head;

}

return C;

}

// shuffles an existing index to the head of an existing list

static void MoveIndexToHead(USERCACHE* cache, USERCACHE* C, unsigned int head)

{

unsigned int index = CACHEINDEX(cache, C);

if (index == head) return;

unsigned int prior = C->prior;

unsigned int next = C->next;

// decouple from where it is

CACHEITEM(cache, prior)->next = next;

CACHEITEM(cache, next)->prior = prior;

// now insert in front

USERCACHE* H = CACHEITEM(cache, head);

prior = H->prior;

H->prior = index;

CACHEITEM(cache, prior)->next = index;

C->prior = prior;

C->next = head;

}

// add an index before a target point

// the index might not be linked in, or target might not exist

static void MoveFileBeforeIndex(USERCACHE* C, int target)

{

int sourceIndex = CACHEINDEX(fileCacheIndex, C);

if (sourceIndex == target || C->next == target) return; // don't move

// detach head from the source cache

USERCACHE* SN = CACHEITEM(fileCacheIndex, C->next);

USERCACHE* SP = CACHEITEM(fileCacheIndex, C->prior);

if (C->next != sourceIndex)

{

int newSourceHead = C->next;

SN->prior = C->prior;

SP->next = newSourceHead;

}

// and add between tail and head of target

if (target < 0)

{

// target doesn't exist

C->prior = sourceIndex;

C->next = sourceIndex;

}

else

{

USERCACHE* TH = CACHEITEM(fileCacheIndex, target);

USERCACHE* TP = CACHEITEM(fileCacheIndex, TH->prior);

TP->next = sourceIndex;

C->prior = TH->prior;

C->next = target;

TH->prior = sourceIndex;

}

}

static void MoveFileCache(int &sourceHead, int &targetHead, bool makeHead, bool clearBuffer)

{

USERCACHE* C = CACHEITEM(fileCacheIndex, sourceHead);

int newSourceHead = (C->next == sourceHead ? NO_CACHEID : C->next);

// might need to remove the actual cached document

if (clearBuffer) ChangeBlockSize(fileCacheIndex, sourceHead, 0);

MoveFileBeforeIndex(C, targetHead);

if (targetHead < 0 || makeHead) targetHead = sourceHead;

sourceHead = newSourceHead;

}

static void ReplaceFileCache()

{

while(ALWAYS)

{

if (fileCacheRecencySize > fmax(1, fileCacheTargetSize)) {

// size of the recent cache is greater than what we desire

// so need to remove one of its pages

USERCACHE* C = CACHEITEM(fileCacheIndex, fileCacheRecencyHead);

if (VOLLEYCOUNT(C) == 0)

{

// demote an "inactive" recent page to the MRU in the recent history

MoveFileCache(fileCacheRecencyHead, fileCacheRecencyHistoryHead, true, true);

--fileCacheRecencySize;

++fileCacheRecencyHistorySize;

break;

}

else

{

// move an "active" recent page to the end of the frequent cache

C->timestamp = SETTIMESTAMP(0);

MoveFileCache(fileCacheRecencyHead, fileCacheFrequencyHead, false, false);

--fileCacheRecencySize;

++fileCacheFrequencySize;

}

}

else

{

// recent cache is of a desirable size

// so need to remove one of the frequent cached pages instead

USERCACHE* C = CACHEITEM(fileCacheIndex, fileCacheFrequencyHead);

if (VOLLEYCOUNT(C) == 0)

{

// demote an "inactive" frequent page to the MRU of the frequent history

MoveFileCache(fileCacheFrequencyHead, fileCacheFrequencyHistoryHead, true, true);

--fileCacheFrequencySize;

++fileCacheFrequencyHistorySize;

break;

}

else

{

// cycle an "active" page to the end of the frequent queue

// and make it "inactive"

C->timestamp = SETTIMESTAMP(0);

if (fileCacheFrequencySize > 2) MoveFileBeforeIndex(C, fileCacheFrequencyHead);

fileCacheFrequencyHead = C->next;

}

}

}

}

static void RestoreHistoryFileCache(USERCACHE* C, int &sourceHead, int &targetHead)

{

// need to tweak the head of the source if this item is at the head

if (CACHEINDEX(fileCacheIndex, C) == sourceHead) sourceHead = (C->next == sourceHead ? NO_CACHEID : C->next);

MoveFileBeforeIndex(C, targetHead);

// set the page reference to zero

C->timestamp = SETTIMESTAMP(0);

}

static USERCACHE* RemoveTail(USERCACHE* cache, unsigned int head)

{

if (head < 0) return NULL;

USERCACHE* CH = CACHEITEM(cache, head);

USERCACHE* CT = CACHEITEM(cache, CH->prior);

CH->prior = CT->prior;

CACHEITEM(cache, CT->prior)->next = head;

CT->next = NO_CACHEID;

CT->prior = NO_CACHEID;

CT->hash = 0;

return CT;

}

static void UpdateCacheEntry(USERCACHE* C, char* filename, char* buffer, size_t size, unsigned int volley)

{

C->hash = FilenameHash(filename);

C->buffer = (unsigned int)(cacheFree - cacheBase);

C->timestamp = SETTIMESTAMP(volley); // how many cpu seconds since start of program launch

cacheFree += size + 1;

char* ptr = GetCacheBuffer(C);

*ptr = 0;

memcpy(ptr, buffer, size);

ptr[size] = 0;

}

static void AddToUserTopicCache(char* filename, char* buffer, size_t size, unsigned int volley) // allocate backwards from current, so in use is always NEXT from current

{

if (!userCacheCount || size == 0) return;

// remove the current version from cache

if (currentCache != NO_CACHEID) EvictFromUserTopicCache(currentCache, false);

// need to find a cache that's free else flush oldest one

unsigned int last = userTopicCacheHead;

char* ptr;

unsigned int blockSize = size + 1;

USERCACHE* C = CACHEITEM(userTopicCacheIndex, last);

do

{

last = C->prior;

C = CACHEITEM(userTopicCacheIndex, last);

ptr = GetUserTopicCacheBuffer(last);

if (C->hash > 0) // this is in use

{

if (IsUserTopicFile(ptr)) EvictFromUserTopicCache(last, true);

}

}

while ((unsigned int)(cacheDataEnd - cacheFree) <= blockSize);

UpdateCacheEntry(C, filename, buffer, size, volley);

currentCache = userTopicCacheHead = last; // just rotate the ring - has more than one block

if (trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : USERLOG,(char*)"added free cache (%d)\r\n",last);

}

void FreeAllUserCaches()

{

if (!cacheBase || userTopicCacheHead == NO_CACHEID) return; // never inited

unsigned int start = userTopicCacheHead;

while (userCacheCount) // kill all active caches

{

EvictFromUserTopicCache(start, true);

start = CACHEITEM(userTopicCacheIndex, start)->next;

if (start == (unsigned int)userTopicCacheHead) break; // been round in a circle

}

currentCache = NO_CACHEID;

}

static USERCACHE* FindCacheEntry(USERCACHE* cache, int head, char* filename, bool move)

{

if (head < 0) return NULL;

unsigned int fullhash = FilenameHash(filename);

int start = head;

while (ALWAYS)

{

USERCACHE* C = CACHEITEM(cache, start);

if (C->hash == fullhash)

{

// make him FIRST on the list

if (move) MoveIndexToHead(cache, C, head);

return C;

}

start = C->next;

if (start == head) break; // reached start again

}

return NULL;

}

static char* FindCachedUserTopic(char* filename, bool recordHit)

{

// already in cache?

size_t len = strlen(filename);

if (len == 0 || !userCacheCount) return NULL;

USERCACHE* C = FindCacheEntry(userTopicCacheIndex, userTopicCacheHead, filename, true);

if (C)

{

if (recordHit)

{

unsigned int volleys = VOLLEYCOUNT(C) + 1;

if (volleys > MAX_VOLLEYCOUNT) volleys = MAX_VOLLEYCOUNT;

unsigned int duration = CPU_TICKS - startSystem; // how many seconds since start of program launch

// dont want to overflow 24bit second store... so reset system start if needed

if (duration > MAX_CACHE_DURATION)

{

startSystem = CPU_TICKS;

duration = 0; // how many seconds since start of program launch

// allow all in cache to stay longer

for (unsigned int i = 0; i < userCacheCount; ++i) CACHEITEM(userTopicCacheIndex, i)->timestamp = duration;

}

C->timestamp = SETTIMESTAMP(volleys);

if (trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : USERLOG,(char*)"user cache (%d) hit %d for %s\r\n", CACHEINDEX(userTopicCacheIndex,C), VOLLEYCOUNT(C), filename);

}

currentCache = userTopicCacheHead = CACHEINDEX(userTopicCacheIndex, C);

return GetCacheBuffer(C);

}

return NULL;

}

static USERCACHE* FindCachedFile(char* filename, bool recordHit)

{

// already in cache?

size_t len = strlen(filename);

if (len == 0 || !fileCacheIndex) return NULL;

USERCACHE* C = NULL;

if (fileCacheRecencySize > 0) C = FindCacheEntry(fileCacheIndex, fileCacheRecencyHead, filename, false);

if (!C && fileCacheFrequencySize > 0) C = FindCacheEntry(fileCacheIndex, fileCacheFrequencyHead, filename, false);

// use volley as page reference bit

if (C && recordHit) C->timestamp = SETTIMESTAMP(1);

return C;

}

char* FindFileCache(char* filename, bool recordHit)

{

if (IsUserTopicFile(filename))

{

return FindCachedUserTopic(filename, recordHit);

}

else

{

USERCACHE* C = FindCachedFile(filename, recordHit);

if (C)

{

if (recordHit && trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : USERLOG,(char*)"user cache (%d) hit %d for %s\r\n", CACHEINDEX(fileCacheIndex,C), VOLLEYCOUNT(C), filename);

return GetCacheBuffer(C);

}

}

return NULL;

}

void ClearFileCache(char* filename)

{

if (IsUserTopicFile(filename))

{

char* ptr = FindCachedUserTopic(filename, false);

if (ptr && currentCache != NO_CACHEID) EvictFromUserTopicCache(currentCache, false);

}

}

// Return reference to temporary cache buffer to read files into

char* GetFileBuffer()

{

char* limit;

if (fileBuffer) ReportBug("FATAL: Currently reading one file while trying to read another \r\n");

fileBuffer = InfiniteStack(limit, "user file buffer");

return fileBuffer;

}

void FreeFileBuffer()

{

if (infiniteStack) ReleaseInfiniteStack();

else if (fileBuffer) ReleaseStack(fileBuffer);

fileBuffer = NULL;

}

static void CacheFile(char* filename, char* buffer, size_t size)

{

if (!fileCacheIndex) return; // file cache not enabled

if (size >= userTopicStoreSize)

{

// No chance of caching a file of this size, but don't need to stop the process

Log(BUGLOG, "File cache too small to store %d bytes for %s", size, filename);

Log((server) ? SERVERLOG : USERLOG, "File cache too small to store %d bytes for %s", size, filename);

return;

}

USERCACHE* C = FindCachedFile(filename, true);

if (C)

{

// already in the cache

// if want a new version, then use a different file name

// the CLOCK aspect of the cache just sets page reference bit

// don't need to move pages around in the list

}

else

{

// not in main cache

// check history

USERCACHE* HR = NULL;

USERCACHE* HF = NULL;

if (fileCacheRecencyHistorySize > 0) HR = FindCacheEntry(fileCacheIndex, fileCacheRecencyHistoryHead, filename, false);

if (!HR && fileCacheFrequencyHistorySize > 0) HF = FindCacheEntry(fileCacheIndex, fileCacheFrequencyHistoryHead, filename, false);

if ((fileCacheRecencySize + fileCacheFrequencySize) == fileCacheCount)

{

// cache is full, need to evict a file

// first move files from the main cache to the history

ReplaceFileCache();

// if the file wasn't in the history either then need to evict a

// history index, but only if we know there's space

// otherwise we'll leave a gap in the index sequence

if (!HR && !HF && size < (size_t)(cacheDataEnd - cacheFree))

{

if ((fileCacheRecencySize + fileCacheRecencyHistorySize) == fileCacheCount)

{

// discard tail of recent history

C = RemoveTail(fileCacheIndex, fileCacheRecencyHistoryHead);

--fileCacheRecencyHistorySize;

if (fileCacheRecencyHistorySize == 0) fileCacheRecencyHistoryHead = NO_CACHEID;

}

else if ((fileCacheRecencySize + fileCacheFrequencySize + fileCacheRecencyHistorySize + fileCacheFrequencyHistorySize) == (2 * fileCacheCount))

{

// discard tail of frequent history

C = RemoveTail(fileCacheIndex, fileCacheFrequencyHistoryHead);

--fileCacheFrequencyHistorySize;

if (fileCacheFrequencyHistorySize == 0) fileCacheFrequencyHistoryHead = NO_CACHEID;

}

}

}

if (size >= (size_t)(cacheDataEnd - cacheFree))

{

// not enough space left in file data cache to copy this buffer

// not being able to cache a file is not a grevious failure

// just record it in case the configuration needs to be changed

Log(BUGLOG, "No space left in file cache to store %d bytes for %s", size, filename);

Log((server) ? SERVERLOG : USERLOG, "No space left in file cache to store %d bytes for %s", size, filename);

return;

}

if (!HR && !HF)

{

// not in either history, add to tail of recent cache

// could be reusing the index from history eviction

C = AddFileCacheEntry(C, fileCacheRecencyHead);

++fileCacheRecencySize;

}

else if (HR)

{

// adapt desired target size

fileCacheTargetSize = (unsigned int)fmin(fileCacheTargetSize + fmax(1, fileCacheFrequencyHistorySize / fileCacheRecencyHistorySize), fileCacheCount);

// in recent history, move to tail of frequent cache

RestoreHistoryFileCache(HR, fileCacheRecencyHistoryHead, fileCacheFrequencyHead);

--fileCacheRecencyHistorySize;

++fileCacheFrequencySize;

C = HR;

}

else

{

// adapt desired target size

fileCacheTargetSize = (unsigned int)fmax(fileCacheTargetSize - fmax(1, fileCacheRecencyHistorySize / fileCacheFrequencyHistorySize), fileCacheCount);

// in frequent history, move to tail of frequent cache

RestoreHistoryFileCache(HF, fileCacheFrequencyHistoryHead, fileCacheFrequencyHead);

--fileCacheFrequencyHistorySize;

++fileCacheFrequencySize;

C = HF;

}

// add the details about this file, reset page reference to 0

UpdateCacheEntry(C, filename, buffer, size, 0);

if (trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : USERLOG,(char*)"added file %s cache (%d)\r\n",filename, CACHEINDEX(fileCacheIndex, C));

}

}

void Cache(char* buffer, size_t size) // save a file in a buffer into cache

{

if (!buffer) // ran out of room

{

ReportBug("User write failed, too big for %s", loginID);

return;

}

// is this file already cached?

char filename[SMALL_WORD_SIZE];

BufferFilename(buffer, filename);

if (!*filename) return;

if (IsUserTopicFile(filename))

{

char* ptr = FindCachedUserTopic(filename, true);

int volley = (ptr ? VOLLEYCOUNT(CACHEITEM(userTopicCacheIndex, currentCache)) : 1);

if (volley >= volleyLimit || size >= (size_t)(cacheDataEnd - cacheFree))

{

// large topic files can just be written out instead of cache

WriteBuffer(filename, buffer, size);

volley = 0;

}

if (volleyLimit && userCacheCount && size < (size_t)(cacheDataEnd - cacheFree))

{

// save to cache

AddToUserTopicCache(filename, buffer, size, volley);

}

currentCache = NO_CACHEID;

}

else

{

CacheFile(filename, buffer, size);

}

}

static void DumpFileCache(USERCACHE* cache, unsigned int head, bool showTime)

{

if (head < 0) return;

unsigned int start = head;

while (ALWAYS)

{

USERCACHE* C = CACHEITEM(cache, start);

if (C->hash > 0)

{

char* ptr = GetCacheBuffer(C);

unsigned int volleys = VOLLEYCOUNT(C);

unsigned int timestamp = TIMESTAMP(C);

char filename[SMALL_WORD_SIZE];

BufferFilename(ptr, filename);

if (!*filename) sprintf(filename, "%llu", (long long)C->hash);

if (showTime) Log((server) ? SERVERLOG : USERLOG, " %5d: %5d %6d %s \r\n", start, volleys, timestamp, filename );

else Log((server) ? SERVERLOG : USERLOG, " %5d: %5d %s \r\n", start, volleys, filename );

}

start = C->next;

if (start == head) break; // end of loop when all are in use

}

}

void DumpFileCaches()

{

if (userCacheCount)

{

if (userTopicCacheHead > NO_CACHEID && CACHEITEM(userTopicCacheIndex, userTopicCacheHead)->hash > 0)

{

Log((server) ? SERVERLOG : USERLOG, "User Topic hits time file \r\n");

DumpFileCache(userTopicCacheIndex, userTopicCacheHead, true);

}

else if (volleyLimit) Log((server) ? SERVERLOG : USERLOG, "User topic cache empty \r\n");

}

if (fileCacheCount)

{

bool entries = false;

if (fileCacheRecencyHead > NO_CACHEID)

{

Log((server) ? SERVERLOG : USERLOG, " Recent pref file \r\n");

DumpFileCache(fileCacheIndex, fileCacheRecencyHead, false);

entries = true;

}

if (fileCacheFrequencyHead > NO_CACHEID)

{

Log((server) ? SERVERLOG : USERLOG, " Frequent pref file \r\n");

DumpFileCache(fileCacheIndex, fileCacheFrequencyHead, false);

entries = true;

}

if (fileCacheRecencyHistorySize > 0) Log((server) ? SERVERLOG : USERLOG, "Recent File History: %d \r\n", fileCacheRecencyHistorySize);

if (fileCacheFrequencyHistorySize > 0) Log((server) ? SERVERLOG : USERLOG, "Frequent File History: %d \r\n", fileCacheFrequencyHistorySize);

// cache will not be just history

if (!entries) Log((server) ? SERVERLOG : USERLOG, "File cache empty \r\n");

}

Log((server) ? SERVERLOG : USERLOG, "Free: %dkb \r\n", (unsigned int)((cacheDataEnd - cacheFree)/1000) );

}