mux/src/attrcache.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"

Include dependency graph for attrcache.cpp:

Go to the source code of this file.

Data Structures
struct	tagAttrRecord
struct	tagCacheEntryHeader
Defines
#define	N_TEMP_FILES   8
Typedefs
typedef tagAttrRecord	ATTR_RECORD
typedef tagAttrRecord *	PATTR_RECORD
typedef tagCacheEntryHeader	CENT_HDR
typedef tagCacheEntryHeader *	PCENT_HDR
Functions
int	cache_init (const char *game_dir_file, const char *game_pag_file, int nCachePages)
void	cache_redirect (void)
void	cache_pass2 (void)
void	cache_close (void)
void	cache_tick (void)
static void	REMOVE_ENTRY (PCENT_HDR pEntry)
static void	ADD_ENTRY (PCENT_HDR pEntry)
static void	TrimCache (void)
const char *	cache_get (Aname *nam, int *pLen)
bool	cache_put (Aname *nam, const char *value, size_t len)
bool	cache_sync (void)
void	cache_del (Aname *nam)
Variables
static CHashFile	hfAttributeFile
static bool	cache_initted = false
static bool	cache_redirected = false
static FILE *	TempFiles [N_TEMP_FILES]
CLinearTimeAbsolute	cs_ltime
static ATTR_RECORD	TempRecord
static PCENT_HDR	pCacheHead = 0
static PCENT_HDR	pCacheTail = 0
static unsigned int	CacheSize = 0

---

Define Documentation

#define N_TEMP_FILES   8

Definition at line 18 of file attrcache.cpp.

Referenced by cache_pass2(), cache_put(), and cache_redirect().

---

Typedef Documentation

typedef struct tagAttrRecord ATTR_RECORD

typedef struct tagCacheEntryHeader CENT_HDR

typedef struct tagAttrRecord * PATTR_RECORD

typedef struct tagCacheEntryHeader * PCENT_HDR

---

Function Documentation

static void ADD_ENTRY

(

PCENT_HDR

pEntry

)

[static]

Definition at line 182 of file attrcache.cpp.

References pCacheHead, pCacheTail, tagCacheEntryHeader::pNextEntry, and tagCacheEntryHeader::pPrevEntry.

Referenced by cache_get(), and cache_put().

{
    if (pCacheHead)
    {
        pCacheHead->pPrevEntry = pEntry;
    }
    pEntry->pNextEntry = pCacheHead;
    pEntry->pPrevEntry = 0;
    pCacheHead = pEntry;
    if (!pCacheTail)
    {
        pCacheTail = pCacheHead;
    }
}

void cache_close

(

void

)

Definition at line 115 of file attrcache.cpp.

References cache_initted, CHashFile::CloseAll(), and hfAttributeFile.

{
    hfAttributeFile.CloseAll();
    cache_initted = false;
}

void cache_del

(

Aname *

nam

)

Definition at line 432 of file attrcache.cpp.

References statedata::acache_htab, tagAttrRecord::attrKey, Aname::attrnum, statedata::bStandAlone, cache_initted, CacheSize, CHashFile::Copy(), CRC32_ProcessInteger2(), ENDLINE, CHashFile::FindFirstKey(), CHashFile::FindNextKey(), hashdeleteLEN(), hashfindLEN(), HF_FIND_END, hfAttributeFile, Log, MEMFREE, mudstate, Aname::object, CHashFile::Remove(), REMOVE_ENTRY(), TempRecord, CLogFile::tinyprintf(), and statedata::write_protect.

Referenced by atr_clr().

{
    if (  !nam
       || !cache_initted)
    {
        return;
    }

#ifndef WIN32
    if (mudstate.write_protect)
    {
        Log.tinyprintf("cache_del((%d,%d)) while database is write-protected" ENDLINE,
            nam->object, nam->attrnum);
        return;
    }
#endif

    UINT32 nHash = CRC32_ProcessInteger2(nam->object, nam->attrnum);

    HP_DIRINDEX iDir = hfAttributeFile.FindFirstKey(nHash);
    while (iDir != HF_FIND_END)
    {
        HP_HEAPLENGTH nRecord;
        hfAttributeFile.Copy(iDir, &nRecord, &TempRecord);

        if (  TempRecord.attrKey.attrnum == nam->attrnum
           && TempRecord.attrKey.object == nam->object)
        {
            hfAttributeFile.Remove(iDir);
        }
        iDir = hfAttributeFile.FindNextKey(iDir, nHash);
    }

    if (!mudstate.bStandAlone)
    {
        // Update cache.
        //
        PCENT_HDR pCacheEntry = (PCENT_HDR)hashfindLEN(nam, sizeof(Aname),
            &mudstate.acache_htab);
        if (pCacheEntry)
        {
            // It was in the cache, so delete it.
            //
            REMOVE_ENTRY(pCacheEntry);
            CacheSize -= pCacheEntry->nSize;;
            hashdeleteLEN((char *)nam, sizeof(Aname), &mudstate.acache_htab);
            MEMFREE(pCacheEntry);
            pCacheEntry = NULL;
        }
    }
}

const char* cache_get	(	Aname *	nam,
		int *	pLen
	)

Definition at line 221 of file attrcache.cpp.

References statedata::acache_htab, ADD_ENTRY(), tagAttrRecord::attrKey, tagCacheEntryHeader::attrKey, Aname::attrnum, tagAttrRecord::attrText, statedata::bStandAlone, cache_initted, CacheSize, CHashFile::Copy(), CRC32_ProcessInteger2(), CHashFile::FindFirstKey(), CHashFile::FindNextKey(), hashaddLEN(), hashfindLEN(), HF_FIND_END, hfAttributeFile, MEMALLOC, mudstate, tagCacheEntryHeader::nSize, Aname::object, REMOVE_ENTRY(), TempRecord, and TrimCache().

Referenced by atr_get_raw_LEN().

{
    if (  nam == (Aname *) 0
       || !cache_initted)
    {
        *pLen = 0;
        return NULL;
    }

    PCENT_HDR pCacheEntry = NULL;
    if (!mudstate.bStandAlone)
    {
        // Check the cache, first.
        //
        pCacheEntry = (PCENT_HDR)hashfindLEN(nam, sizeof(Aname),
            &mudstate.acache_htab);
        if (pCacheEntry)
        {
            // It was in the cache, so move this entry to the head of the queue.
            // and return a pointer to it.
            //
            REMOVE_ENTRY(pCacheEntry);
            ADD_ENTRY(pCacheEntry);
            if (sizeof(CENT_HDR) < pCacheEntry->nSize)
            {
                *pLen = pCacheEntry->nSize - sizeof(CENT_HDR);
                return (char *)(pCacheEntry+1);
            }
            else
            {
                *pLen = 0;
                return NULL;
            }
        }
    }

    UINT32 nHash = CRC32_ProcessInteger2(nam->object, nam->attrnum);

    HP_DIRINDEX iDir;
    iDir = hfAttributeFile.FindFirstKey(nHash);
    while (iDir != HF_FIND_END)
    {
        HP_HEAPLENGTH nRecord;
        hfAttributeFile.Copy(iDir, &nRecord, &TempRecord);

        if (  TempRecord.attrKey.attrnum == nam->attrnum
           && TempRecord.attrKey.object == nam->object)
        {
            int nLength = nRecord - sizeof(Aname);
            *pLen = nLength;
            if (!mudstate.bStandAlone)
            {
                // Add this information to the cache.
                //
                pCacheEntry = (PCENT_HDR)MEMALLOC(sizeof(CENT_HDR)+nLength);
                if (pCacheEntry)
                {
                    pCacheEntry->attrKey = *nam;
                    pCacheEntry->nSize = nLength + sizeof(CENT_HDR);
                    CacheSize += pCacheEntry->nSize;
                    memcpy((char *)(pCacheEntry+1), TempRecord.attrText, nLength);
                    ADD_ENTRY(pCacheEntry);
                    hashaddLEN(nam, sizeof(Aname), pCacheEntry,
                        &mudstate.acache_htab);

                    TrimCache();
                }
            }
            return TempRecord.attrText;
        }
        iDir = hfAttributeFile.FindNextKey(iDir, nHash);
    }

    // We didn't find that one.
    //
    if (!mudstate.bStandAlone)
    {
        // Add this information to the cache.
        //
        pCacheEntry = (PCENT_HDR)MEMALLOC(sizeof(CENT_HDR));
        if (pCacheEntry)
        {
            pCacheEntry->attrKey = *nam;
            pCacheEntry->nSize = sizeof(CENT_HDR);
            CacheSize += pCacheEntry->nSize;
            ADD_ENTRY(pCacheEntry);
            hashaddLEN(nam, sizeof(Aname), pCacheEntry,
                &mudstate.acache_htab);

            TrimCache();
        }
    }

    *pLen = 0;
    return NULL;
}

int cache_init	(	const char *	game_dir_file,
		const char *	game_pag_file,
		int	nCachePages
	)

Definition at line 45 of file attrcache.cpp.

References cache_initted, cs_ltime, CLinearTimeAbsolute::GetUTC(), HF_OPEN_STATUS_ERROR, hfAttributeFile, and CHashFile::Open().

Referenced by init_dbfile().

{
    if (cache_initted)
    {
        return HF_OPEN_STATUS_ERROR;
    }

    int cc = hfAttributeFile.Open(game_dir_file, game_pag_file, nCachePages);
    if (cc != HF_OPEN_STATUS_ERROR)
    {
        // Mark caching system live
        //
        cache_initted = true;
        cs_ltime.GetUTC();
    }
    return cc;
}

void cache_pass2

(

void

)

Definition at line 77 of file attrcache.cpp.

References tagAttrRecord::attrKey, tagAttrRecord::attrText, cache_put(), cache_redirected, cnt, ENDLINE, mux_assert, N_TEMP_FILES, tagCacheEntryHeader::nSize, RemoveFile(), and TempFiles.

Referenced by dbconvert().

{
    ATTR_RECORD Record;
    cache_redirected = false;
    fprintf(stderr, "2nd Pass:\n");
    for (int i = 0; i < N_TEMP_FILES; i++)
    {
        fprintf(stderr, "File %d: ", i);
        long int li = fseek(TempFiles[i], 0, SEEK_SET);
        mux_assert(0L == li);

        int cnt = 1000;
        size_t nSize;
        for (;;)
        {
            size_t cc = fread(&nSize, 1, sizeof(nSize), TempFiles[i]);
            if (cc != sizeof(nSize))
            {
                break;
            }
            cc = fread(&Record, 1, nSize, TempFiles[i]);
            mux_assert(cc == nSize);
            cache_put(&Record.attrKey, Record.attrText, nSize - sizeof(Aname));
            if (cnt-- == 0)
            {
                fputc('.', stderr);
                fflush(stderr);
                cnt = 1000;
            }
        }
        fclose(TempFiles[i]);
        char TempFileName[20];
        sprintf(TempFileName, "$convtemp.%d", i);
        RemoveFile(TempFileName);
        fprintf(stderr, ENDLINE);
    }
}

bool cache_put	(	Aname *	nam,
		const char *	value,
		size_t	len
	)

Definition at line 321 of file attrcache.cpp.

References statedata::acache_htab, ADD_ENTRY(), tagAttrRecord::attrKey, tagCacheEntryHeader::attrKey, Aname::attrnum, tagAttrRecord::attrText, statedata::bStandAlone, cache_initted, cache_redirected, CacheSize, CHashFile::Copy(), CRC32_ProcessInteger2(), ENDLINE, CHashFile::FindFirstKey(), CHashFile::FindNextKey(), hashaddLEN(), hashdeleteLEN(), hashfindLEN(), HF_FIND_END, hfAttributeFile, CHashFile::Insert(), Log, MEMALLOC, MEMFREE, mudstate, N_TEMP_FILES, tagCacheEntryHeader::nSize, Aname::object, CHashFile::Remove(), REMOVE_ENTRY(), TempFiles, TempRecord, CLogFile::tinyprintf(), TrimCache(), and statedata::write_protect.

Referenced by atr_add_raw_LEN(), and cache_pass2().

{
    if (  !value
       || !nam
       || !cache_initted
       || len == 0)
    {
        return false;
    }
#ifndef WIN32
    if (mudstate.write_protect)
    {
        Log.tinyprintf("cache_put((%d,%d), '%s', %u) while database is write-protected" ENDLINE,
            nam->object, nam->attrnum, value, len);
        return false;
    }
#endif

    if (len > sizeof(TempRecord.attrText))
    {
        len = sizeof(TempRecord.attrText);
    }

    // Removal from DB.
    //
    UINT32 nHash = CRC32_ProcessInteger2(nam->object, nam->attrnum);

    if (cache_redirected)
    {
        TempRecord.attrKey = *nam;
        memcpy(TempRecord.attrText, value, len);
        TempRecord.attrText[len-1] = '\0';

        int iFile = (N_TEMP_FILES-1) & (nHash >> 29);
        size_t nSize = len+sizeof(Aname);
        fwrite(&nSize, 1, sizeof(nSize), TempFiles[iFile]);
        fwrite(&TempRecord, 1, nSize, TempFiles[iFile]);
        return true;
    }

    HP_DIRINDEX iDir = hfAttributeFile.FindFirstKey(nHash);
    while (iDir != HF_FIND_END)
    {
        HP_HEAPLENGTH nRecord;
        hfAttributeFile.Copy(iDir, &nRecord, &TempRecord);

        if (  TempRecord.attrKey.attrnum == nam->attrnum
           && TempRecord.attrKey.object  == nam->object)
        {
            hfAttributeFile.Remove(iDir);
        }
        iDir = hfAttributeFile.FindNextKey(iDir, nHash);
    }

    TempRecord.attrKey = *nam;
    memcpy(TempRecord.attrText, value, len);
    TempRecord.attrText[len-1] = '\0';

    // Insertion into DB.
    //
    if (!hfAttributeFile.Insert((HP_HEAPLENGTH)(len+sizeof(Aname)), nHash, &TempRecord))
    {
        Log.tinyprintf("cache_put((%d,%d), '%s', %u) failed" ENDLINE,
            nam->object, nam->attrnum, value, len);
    }

    if (!mudstate.bStandAlone)
    {
        // Update cache.
        //
        PCENT_HDR pCacheEntry = (PCENT_HDR)hashfindLEN(nam, sizeof(Aname),
            &mudstate.acache_htab);
        if (pCacheEntry)
        {
            // It was in the cache, so delete it.
            //
            REMOVE_ENTRY(pCacheEntry);
            CacheSize -= pCacheEntry->nSize;
            hashdeleteLEN((char *)nam, sizeof(Aname), &mudstate.acache_htab);
            MEMFREE(pCacheEntry);
            pCacheEntry = NULL;
        }

        // Add information about the new entry back into the cache.
        //
        size_t nSizeOfEntry = sizeof(CENT_HDR) + len;
        pCacheEntry = (PCENT_HDR)MEMALLOC(nSizeOfEntry);
        if (pCacheEntry)
        {
            pCacheEntry->attrKey = *nam;
            pCacheEntry->nSize = nSizeOfEntry;
            CacheSize += pCacheEntry->nSize;
            memcpy((char *)(pCacheEntry+1), TempRecord.attrText, len);
            ADD_ENTRY(pCacheEntry);
            hashaddLEN(nam, sizeof(Aname), pCacheEntry,
                &mudstate.acache_htab);

            TrimCache();
        }
    }
    return true;
}

void cache_redirect

(

void

)

Definition at line 64 of file attrcache.cpp.

References cache_redirected, mux_assert, N_TEMP_FILES, and TempFiles.

Referenced by dbconvert().

{
    for (int i = 0; i < N_TEMP_FILES; i++)
    {
        char TempFileName[20];
        sprintf(TempFileName, "$convtemp.%d", i);
        TempFiles[i] = fopen(TempFileName, "wb+");
        mux_assert(TempFiles[i]);
        setvbuf(TempFiles[i], NULL, _IOFBF, 16384);
    }
    cache_redirected = true;
}

bool cache_sync

(

void

)

Definition at line 424 of file attrcache.cpp.

References hfAttributeFile, and CHashFile::Sync().

{
    hfAttributeFile.Sync();
    return true;
}

void cache_tick

(

void

)

Definition at line 121 of file attrcache.cpp.

References hfAttributeFile, and CHashFile::Tick().

Referenced by dispatch_CacheTick().

{
    hfAttributeFile.Tick();
}

static void REMOVE_ENTRY

(

PCENT_HDR

pEntry

)

[static]

Definition at line 126 of file attrcache.cpp.

References pCacheHead, pCacheTail, tagCacheEntryHeader::pNextEntry, and tagCacheEntryHeader::pPrevEntry.

Referenced by cache_del(), cache_get(), cache_put(), and TrimCache().

{
    // How is X positioned?
    //
    if (pEntry == pCacheHead)
    {
        if (pEntry == pCacheTail)
        {
            // HEAD --> X --> 0
            //    0 <--  <-- TAIL
            //
            // ASSERT: pEntry->pNextEntry == 0;
            // ASSERT: pEntry->pPrevEntry == 0;
            //
            pCacheHead = pCacheTail = 0;
        }
        else
        {
            // HEAD  --> X --> Y --> 0
            //    0 <--   <--   <--  TAIL
            //
            // ASSERT: pEntry->pNextEntry != 0;
            // ASSERT: pEntry->pPrevEntry == 0;
            //
            pCacheHead = pEntry->pNextEntry;
            pCacheHead->pPrevEntry = 0;
            pEntry->pNextEntry = 0;
        }
    }
    else if (pEntry == pCacheTail)
    {
        // HEAD  --> Y --> X --> 0
        //    0 <--   <--   <-- TAIL
        //
        // ASSERT: pEntry->pNextEntry == 0;
        // ASSERT: pEntry->pPrevEntry != 0;
        //
        pCacheTail = pEntry->pPrevEntry;
        pCacheTail->pNextEntry = 0;
        pEntry->pPrevEntry = 0;
    }
    else
    {
        // HEAD  --> Y --> X --> Z --> 0
        //    0 <--   <--   <--   <-- TAIL
        //
        // ASSERT: pEntry->pNextEntry != 0;
        // ASSERT: pEntry->pNextEntry != 0;
        //
        pEntry->pNextEntry->pPrevEntry = pEntry->pPrevEntry;
        pEntry->pPrevEntry->pNextEntry = pEntry->pNextEntry;
        pEntry->pNextEntry = 0;
        pEntry->pPrevEntry = 0;
    }
}

static void TrimCache

(

void

)

[static]

Definition at line 197 of file attrcache.cpp.

References statedata::acache_htab, tagCacheEntryHeader::attrKey, CacheSize, hashdeleteLEN(), confdata::max_cache_size, MEMFREE, mudconf, mudstate, tagCacheEntryHeader::nSize, pCacheTail, and REMOVE_ENTRY().

Referenced by cache_get(), and cache_put().

{
    // Check to see if the cache needs to be trimmed.
    //
    while (CacheSize > mudconf.max_cache_size)
    {
        // Blow something away.
        //
        PCENT_HDR pCacheEntry = pCacheTail;
        if (!pCacheEntry)
        {
            CacheSize = 0;
            break;
        }

        REMOVE_ENTRY(pCacheEntry);
        CacheSize -= pCacheEntry->nSize;
        hashdeleteLEN(&(pCacheEntry->attrKey), sizeof(Aname),
            &mudstate.acache_htab);
        MEMFREE(pCacheEntry);
        pCacheEntry = NULL;
    }
}

---

Variable Documentation

bool cache_initted = false [static]

Definition at line 15 of file attrcache.cpp.

Referenced by cache_close(), cache_del(), cache_get(), cache_init(), and cache_put().

bool cache_redirected = false [static]

Definition at line 17 of file attrcache.cpp.

Referenced by cache_pass2(), cache_put(), and cache_redirect().

unsigned int CacheSize = 0 [static]

Definition at line 43 of file attrcache.cpp.

Referenced by cache_del(), cache_get(), cache_put(), and TrimCache().

CLinearTimeAbsolute cs_ltime

Definition at line 21 of file attrcache.cpp.

Referenced by cache_init(), and list_db_stats().

CHashFile hfAttributeFile [static]

Definition at line 14 of file attrcache.cpp.

Referenced by cache_close(), cache_del(), cache_get(), cache_init(), cache_put(), cache_sync(), and cache_tick().

PCENT_HDR pCacheHead = 0 [static]

Definition at line 41 of file attrcache.cpp.

Referenced by ADD_ENTRY(), and REMOVE_ENTRY().

PCENT_HDR pCacheTail = 0 [static]

Definition at line 42 of file attrcache.cpp.

Referenced by ADD_ENTRY(), REMOVE_ENTRY(), and TrimCache().

FILE* TempFiles[N_TEMP_FILES] [static]

Definition at line 19 of file attrcache.cpp.

Referenced by cache_pass2(), cache_put(), and cache_redirect().

ATTR_RECORD TempRecord [static]

Definition at line 31 of file attrcache.cpp.

Referenced by cache_del(), cache_get(), and cache_put().

---