CHashFile Class Reference

#include <svdhash.h>

Collaboration diagram for CHashFile:

[legend]

Public Member Functions
	CHashFile (void)
int	Open (const char *szDirFile, const char *szPageFile, int nCachePages)
bool	Insert (HP_HEAPLENGTH nRecord, UINT32 nHash, void *pRecord)
HP_DIRINDEX	FindFirstKey (UINT32 nHash)
HP_DIRINDEX	FindNextKey (HP_DIRINDEX iDir, UINT32 nHash)
void	Copy (HP_DIRINDEX iDir, HP_PHEAPLENGTH pnRecord, void *pRecord)
void	Remove (HP_DIRINDEX iDir)
void	CloseAll (void)
void	Sync (void)
void	Tick (void)
	~CHashFile (void)
Private Member Functions
bool	DoubleDirectory (void)
int	AllocateEmptyPage (int nSafe, int Safe[])
int	ReadCache (UINT32 iFileDir, int *pHits)
bool	FlushCache (int iCache)
void	WriteDirectory (void)
bool	InitializeDirectory (unsigned int nSize)
void	ResetAge (int iEntry)
void	Init (void)
void	InitCache (int nCachePages)
void	FinalCache (void)
bool	CreateFileSet (const char *szDirFile, const char *szPageFile)
bool	RebuildDirectory (void)
bool	ReadDirectory (void)
Private Attributes
HANDLE	m_hDirFile
HANDLE	m_hPageFile
int	iCache
int	m_iOldest
int	m_iLastFlushed
int *	m_hpCacheLookup
HF_FILEOFFSET	oEndOfFile
unsigned int	m_nDir
unsigned int	m_nDirDepth
HF_CACHE *	m_Cache
int	m_nCache
HF_PFILEOFFSET	m_pDir

---

Detailed Description

Definition at line 196 of file svdhash.h.

---

Constructor & Destructor Documentation

CHashFile::CHashFile

(

void

)

Definition at line 1281 of file svdhash.cpp.

References Init(), m_Cache, m_nCache, and SeedRandomNumberGenerator().

{
    SeedRandomNumberGenerator();
    m_Cache = NULL;
    m_nCache = 0;
    Init();
}

CHashFile::~CHashFile

(

void

)

Definition at line 1747 of file svdhash.cpp.

References CloseAll(), and FinalCache().

{
    FinalCache();
    CloseAll();
}

---

Member Function Documentation

int CHashFile::AllocateEmptyPage	(	int	nSafe,
		int	Safe[]
	)			[private]

Definition at line 2058 of file svdhash.cpp.

References cnt, FlushCache(), CHashPage::GetRange(), HF_CACHE_EMPTY, m_Cache, tagHashFileCache::m_hp, m_hpCacheLookup, m_iOldest, tagHashFileCache::m_iState, m_nCache, m_nDirDepth, and ResetAge().

Referenced by CreateFileSet(), Insert(), ReadCache(), and RebuildDirectory().

{
    int cnt = m_nCache;
    while (cnt--)
    {
        int i = m_iOldest;

        bool bExclude = false;
        for (int j = 0; j < nSafe; j++)
        {
            if (Safe[j] == i)
            {
                bExclude = true;
                break;
            }
        }

        ResetAge(i);

        if (  !bExclude
           && FlushCache(i))
        {
            if (HF_CACHE_EMPTY != m_Cache[i].m_iState)
            {
                UINT32 nStart, nEnd;
                m_Cache[i].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
                for ( ; nStart <= nEnd; nStart++)
                {
                    m_hpCacheLookup[nStart] = -1;
                }
                m_Cache[i].m_iState = HF_CACHE_EMPTY;
            }
            return i;
        }
    }
    return -1;
}

void CHashFile::CloseAll

(

void

)

Definition at line 1704 of file svdhash.cpp.

References Init(), INVALID_HANDLE_VALUE, m_hDirFile, m_hPageFile, m_hpCacheLookup, m_pDir, and Sync().

Referenced by cache_close(), CreateFileSet(), Open(), and ~CHashFile().

{
    if (m_hPageFile != INVALID_HANDLE_VALUE)
    {
        Sync();
        if (m_pDir)
        {
            delete [] m_pDir;
            m_pDir = NULL;
        }
        if (m_hpCacheLookup)
        {
            delete [] m_hpCacheLookup;
            m_hpCacheLookup = NULL;
        }

#ifdef WIN32
        CloseHandle(m_hPageFile);
#else // WIN32
        close(m_hPageFile);
#endif // WIN32
    }
    if (m_hDirFile != INVALID_HANDLE_VALUE)
    {
#ifdef WIN32
        CloseHandle(m_hDirFile);
#else // WIN32
        close(m_hDirFile);
#endif // WIN32
    }
    Init();
}

void CHashFile::Copy	(	HP_DIRINDEX	iDir,
		HP_PHEAPLENGTH	pnRecord,
		void *	pRecord
	)

Definition at line 2024 of file svdhash.cpp.

References CHashPage::HeapCopy(), iCache, m_Cache, and tagHashFileCache::m_hp.

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

{
    m_Cache[iCache].m_hp.HeapCopy(iDir, pnRecord, pRecord);
}

bool CHashFile::CreateFileSet	(	const char *	szDirFile,
		const char *	szPageFile
	)			[private]

Definition at line 1374 of file svdhash.cpp.

References AllocateEmptyPage(), CloseAll(), CHashPage::Empty(), FlushCache(), HF_CACHE_UNPROTECTED, HF_SIZEOF_PAGE, iCache, InitializeDirectory(), INVALID_HANDLE_VALUE, m_Cache, m_hDirFile, tagHashFileCache::m_hp, m_hPageFile, m_hpCacheLookup, tagHashFileCache::m_iState, tagHashFileCache::m_o, m_pDir, O_BINARY, oEndOfFile, and WriteDirectory().

Referenced by Open().

{
    CloseAll();
#ifdef WIN32
    m_hPageFile = CreateFile(szPageFile, GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ, 0, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL + FILE_FLAG_RANDOM_ACCESS, NULL);
#else // WIN32
    m_hPageFile = open(szPageFile, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, 0600);
#endif // WIN32

    if (m_hPageFile == INVALID_HANDLE_VALUE)
    {
        return false;
    }

#ifdef WIN32
    m_hDirFile = CreateFile(szDirFile, GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ, 0, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL + FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#else // WIN32
    m_hDirFile = open(szDirFile, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, 0600);
#endif // WIN32

    if (m_hPageFile == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    // Create empty structures in memory and write them out.
    //
    if (!InitializeDirectory(2))
    {
        return false;
    }

    iCache = AllocateEmptyPage(0, 0);
    if (iCache < 0)
    {
        return false;
    }
    m_Cache[iCache].m_hp.Empty(0, 0UL, 100);
    m_Cache[iCache].m_o = 0UL;

    m_pDir[0] = m_pDir[1] = m_Cache[iCache].m_o;
    m_hpCacheLookup[0] = m_hpCacheLookup[1] = iCache;

    m_Cache[iCache].m_iState = HF_CACHE_UNPROTECTED;

    oEndOfFile = HF_SIZEOF_PAGE;

#ifdef DO_COMMIT
    FlushCache(iCache);
#endif // DO_COMMIT
    WriteDirectory();
    return true;
}

bool CHashFile::DoubleDirectory

(

void

)

[private]

Definition at line 1934 of file svdhash.cpp.

References ISOUTOFMEMORY, m_hpCacheLookup, m_nDir, m_nDirDepth, m_pDir, and WriteDirectory().

Referenced by Insert(), and RebuildDirectory().

{
    unsigned int nNewDir     = 2 * m_nDir;
    HP_DIRINDEX nNewDirDepth = m_nDirDepth + 1;

    HF_PFILEOFFSET pNewDir = new HF_FILEOFFSET[nNewDir];
    ISOUTOFMEMORY(pNewDir);

    int *pNewCacheLookup = new int[nNewDir];
    ISOUTOFMEMORY(pNewCacheLookup);

    unsigned int iNewDir = 0;
    for (unsigned int iDir = 0; iDir < m_nDir; iDir++)
    {
        pNewDir[iNewDir]   = m_pDir[iDir];
        pNewDir[iNewDir+1] = m_pDir[iDir];
        pNewCacheLookup[iNewDir]   = m_hpCacheLookup[iDir];
        pNewCacheLookup[iNewDir+1] = m_hpCacheLookup[iDir];
        iNewDir += 2;
    }

    // Write out the new directory. It's always larger than
    // the previous one.
    //
    WriteDirectory();

    delete [] m_pDir;
    m_pDir = pNewDir;

    delete [] m_hpCacheLookup;
    m_hpCacheLookup = pNewCacheLookup;

    m_nDirDepth = nNewDirDepth;
    m_nDir = nNewDir;
    return true;
}

void CHashFile::FinalCache

(

void

)

[private]

Definition at line 1737 of file svdhash.cpp.

References m_Cache, and m_nCache.

Referenced by Open(), and ~CHashFile().

{
    if (m_Cache)
    {
        delete [] m_Cache;
        m_Cache = NULL;
        m_nCache = 0;
    }
}

HP_DIRINDEX CHashFile::FindFirstKey

(

UINT32

nHash

)

Definition at line 1971 of file svdhash.cpp.

References cs_fails, cs_reads, cs_rhits, CHashPage::FindFirstKey(), CHashPage::GetRange(), HF_FIND_END, HP_DIR_EMPTY, iCache, Log, m_Cache, tagHashFileCache::m_hp, m_nDir, m_nDirDepth, ReadCache(), CLogFile::tinyprintf(), and CLogFile::WriteString().

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

{
    cs_reads++;

    UINT32 iFileDir = nHash >> (32-m_nDirDepth);
    if (iFileDir >= m_nDir)
    {
        Log.WriteString("CHashFile::Insert - iFileDir out of range." ENDLINE);
        cs_fails++;
        return HF_FIND_END;
    }
    iCache = ReadCache(iFileDir, &cs_rhits);
    if (iCache < 0)
    {
        cs_fails++;
        return HF_FIND_END;
    }
    UINT32 nStart, nEnd;
    m_Cache[iCache].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
    if (iFileDir < nStart || nEnd < iFileDir)
    {
        Log.tinyprintf("CHashFile::Find - Directory entry (0x%08X) points to the wrong page (0x%08X-0x%08X)." ENDLINE,
            iFileDir, nStart, nEnd);
        return HF_FIND_END;
    }

    unsigned int numchecks;
    HP_DIRINDEX iDir = m_Cache[iCache].m_hp.FindFirstKey(nHash, &numchecks);

    if (iDir == HP_DIR_EMPTY)
    {
        cs_fails++;
        return HF_FIND_END;
    }
    return iDir;
}

HP_DIRINDEX CHashFile::FindNextKey	(	HP_DIRINDEX	iDir,
		UINT32	nHash
	)

Definition at line 2008 of file svdhash.cpp.

References cs_fails, cs_reads, CHashPage::FindNextKey(), HF_FIND_END, HP_DIR_EMPTY, iCache, m_Cache, and tagHashFileCache::m_hp.

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

{
    cs_reads++;

    unsigned int numchecks;

    iDir = m_Cache[iCache].m_hp.FindNextKey(iDir, nHash, &numchecks);

    if (iDir == HP_DIR_EMPTY)
    {
        cs_fails++;
        return HF_FIND_END;
    }
    return iDir;
}

bool CHashFile::FlushCache

(

int

iCache

)

[private]

Definition at line 2036 of file svdhash.cpp.

References HF_CACHE_CLEAN, HF_CACHE_UNPROTECTED, HF_CACHE_UNWRITTEN, m_Cache, tagHashFileCache::m_hp, m_hPageFile, and tagHashFileCache::m_o.

Referenced by AllocateEmptyPage(), CreateFileSet(), Insert(), Sync(), and Tick().

{
    switch (m_Cache[iCache].m_iState)
    {
    case HF_CACHE_UNPROTECTED:
#ifdef HP_PROTECTION
        m_Cache[iCache].m_hp.Protection();
#endif // HP_PROTECTION

    case HF_CACHE_UNWRITTEN:
        if (m_Cache[iCache].m_hp.WritePage(m_hPageFile, m_Cache[iCache].m_o))
        {
            m_Cache[iCache].m_iState = HF_CACHE_CLEAN;
        }
        else
        {
            return false;
        }
    }
    return true;
}

void CHashFile::Init

(

void

)

[private]

Definition at line 1289 of file svdhash.cpp.

References iCache, INVALID_HANDLE_VALUE, m_hDirFile, m_hPageFile, m_hpCacheLookup, m_iLastFlushed, m_nDir, m_nDirDepth, and m_pDir.

Referenced by CHashFile(), and CloseAll().

{
    m_hDirFile = INVALID_HANDLE_VALUE;
    m_hPageFile = INVALID_HANDLE_VALUE;
    m_nDir = 0;
    m_nDirDepth = 0;
    m_pDir = NULL;
    m_hpCacheLookup = NULL;
    iCache = 0;
    m_iLastFlushed = 0;
}

void CHashFile::InitCache

(

int

nCachePages

)

[private]

Definition at line 1528 of file svdhash.cpp.

References HF_CACHE_EMPTY, HF_SIZEOF_PAGE, ISOUTOFMEMORY, m_Cache, tagHashFileCache::m_iOlder, m_iOldest, tagHashFileCache::m_iState, tagHashFileCache::m_iYounger, m_nCache, and tagHashFileCache::m_o.

Referenced by Open().

{
    if (m_Cache)
    {
        return;
    }

    // Allocate hash page cache.
    //
    m_nCache = nCachePages;
    m_Cache = new HF_CACHE[m_nCache];
    ISOUTOFMEMORY(m_Cache);
    for (int i = 0; i < m_nCache; i++)
    {
        m_Cache[i].m_hp.Allocate(HF_SIZEOF_PAGE);
        m_Cache[i].m_iState = HF_CACHE_EMPTY;
        m_Cache[i].m_o = 0UL;
        m_Cache[i].m_iYounger = i-1;
        m_Cache[i].m_iOlder   = i+1;
    }
    m_Cache[0].m_iYounger = m_nCache-1;
    m_Cache[m_nCache-1].m_iOlder = 0;
    m_iOldest = 0;
}

bool CHashFile::InitializeDirectory

(

unsigned int

nSize

)

[private]

Definition at line 1338 of file svdhash.cpp.

References ISOUTOFMEMORY, m_hpCacheLookup, m_nDir, m_nDirDepth, and m_pDir.

Referenced by CreateFileSet(), ReadDirectory(), and RebuildDirectory().

{
    if (m_pDir)
    {
        delete [] m_pDir;
        m_pDir = NULL;
    }
    if (m_hpCacheLookup)
    {
        delete [] m_hpCacheLookup;
        m_hpCacheLookup = NULL;
    }

    m_nDir = n;
    m_nDirDepth = 0;
    n >>= 1;
    while (n)
    {
        m_nDirDepth++;
        n >>= 1;
    }

    m_pDir = new HF_FILEOFFSET[m_nDir];
    ISOUTOFMEMORY(m_pDir);
    m_hpCacheLookup = new int[m_nDir];
    ISOUTOFMEMORY(m_hpCacheLookup);

    for (unsigned int i = 0; i < m_nDir; i++)
    {
        m_pDir[i] = 0xFFFFFFFFUL;
        m_hpCacheLookup[i] = -1;
    }

    return true;
}

bool CHashFile::Insert	(	HP_HEAPLENGTH	nRecord,
		UINT32	nHash,
		void *	pRecord
	)

Definition at line 1753 of file svdhash.cpp.

References AllocateEmptyPage(), statedata::bStandAlone, cs_whits, cs_writes, DoubleDirectory(), statedata::dumping, ENDLOG, FlushCache(), CHashPage::GetRange(), HF_CACHE_EMPTY, HF_CACHE_UNPROTECTED, HF_SIZEOF_PAGE, HP_INSERT_ERROR_ILLEGAL, iCache, CHashPage::Insert(), IS_HP_SUCCESS, Log, LOG_DBSAVES, log_text(), m_Cache, m_hDirFile, tagHashFileCache::m_hp, m_hPageFile, m_hpCacheLookup, tagHashFileCache::m_iState, m_nDir, m_nDirDepth, tagHashFileCache::m_o, m_pDir, mudstate, MuxAlarm, oEndOfFile, ReadCache(), Safe, CMuxAlarm::Sleep(), STARTLOG, time_1s, CLogFile::tinyprintf(), and CLogFile::WriteString().

Referenced by cache_put().

{
    cs_writes++;
    for (;;)
    {
        UINT32 iFileDir = nHash >> (32-m_nDirDepth);
        if (iFileDir >= m_nDir)
        {
            Log.WriteString("CHashFile::Insert - iFileDir out of range." ENDLINE);
            return false;
        }
        iCache = ReadCache(iFileDir, &cs_whits);
        if (iCache < 0)
        {
            Log.WriteString("CHashFile::Insert - Page wasn't valid." ENDLINE);
            return false;
        }

        UINT32 nStart, nEnd;
        m_Cache[iCache].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
        if (iFileDir < nStart || nEnd < iFileDir)
        {
            Log.tinyprintf("CHashFile::Insert - Directory entry (0x%08X) points to the wrong page (0x%08X-0x%08X)." ENDLINE,
                iFileDir, nStart, nEnd);
            return false;
        }
        int errInserted = m_Cache[iCache].m_hp.Insert(nRecord, nHash, pRecord);
        if (IS_HP_SUCCESS(errInserted))
        {
            // The record was inserted successfully, so the page is dirty.
            //
            m_Cache[iCache].m_iState = HF_CACHE_UNPROTECTED;
            break;
        }
        else if (HP_INSERT_ERROR_ILLEGAL == errInserted)
        {
            return false;
        }

#ifndef WIN32
        // First, if we are @dumping, then we have a @forked process
        // that is also reading from the file. We must pause and let
        // this reader process finish.
        //
        if (  !mudstate.bStandAlone
           && mudstate.dumping)
        {
            STARTLOG(LOG_DBSAVES, "DMP", "DUMP");
            log_text("Waiting on previously-forked child before page-splitting... ");
            ENDLOG;
            do
            {
                // We have a forked dump in progress, so we will wait until the
                // child exits.
                //
                MuxAlarm.Sleep(time_1s);
            } while (mudstate.dumping);
        }
#endif // !WIN32

        // If the depth of this page is already as deep as the directory
        // depth,then we must increase depth of the directory, first.
        //
        if (m_nDirDepth == m_Cache[iCache].m_hp.GetDepth())
        {
            if (!DoubleDirectory())
            {
                return false;
            }
        }

        // Split this page into two pages. We become a new one, and we
        // are given a pointer to the other one.
        //
        int Safe[2];
        int nSafe = 0;
        int iEmpty0, iEmpty1;

        Safe[nSafe++] = iCache;
        iEmpty0 = AllocateEmptyPage(nSafe, Safe);
        if (iEmpty0 < 0) return false;

        if (iCache == iEmpty0)
        {
            Log.WriteString("CHashFile::Split - iCache == iEmpty0" ENDLINE);
            return false;
        }

        Safe[nSafe++] = iEmpty0;
        iEmpty1 = AllocateEmptyPage(nSafe, Safe);
        if (iEmpty1 < 0) return false;

        if (iCache == iEmpty1)
        {
            Log.WriteString("CHashFile::Split - iCache == iEmpty1" ENDLINE);
            return false;
        }

        if (iEmpty0 == iEmpty1)
        {
            Log.WriteString("CHashFile::Split - iEmpty0 == iEmpty1" ENDLINE);
            return false;
        }

        if (!m_Cache[iCache].m_hp.Split(m_Cache[iEmpty0].m_hp, m_Cache[iEmpty1].m_hp))
        {
            return false;
        }

        // Tack another page onto the end of the .pag file.
        //
        long oNew = oEndOfFile;
        oEndOfFile += HF_SIZEOF_PAGE;

        // iEmpty0 => iCache. iEmpty1 => end of file
        //
        m_Cache[iCache].m_iState = HF_CACHE_EMPTY;
        m_Cache[iEmpty0].m_o = m_Cache[iCache].m_o;
        m_Cache[iEmpty1].m_o = oNew;
        m_Cache[iEmpty0].m_iState = HF_CACHE_UNPROTECTED;
        m_Cache[iEmpty1].m_iState = HF_CACHE_UNPROTECTED;

        // Update the directory.
        //
        m_Cache[iEmpty0].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
        for ( ; nStart <= nEnd; nStart++)
        {
            m_hpCacheLookup[nStart] = iEmpty0;
        }
        m_Cache[iEmpty1].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
        for ( ; nStart <= nEnd; nStart++)
        {
            m_pDir[nStart] = oNew;
            m_hpCacheLookup[nStart] = iEmpty1;
        }

        // Flush the pages out.
        //
        FlushCache(iEmpty1);
        FlushCache(iEmpty0);

#ifdef DO_COMMIT
        if (!mudstate.bStandAlone)
        {
#ifdef WIN32
            FlushFileBuffers(m_hPageFile);
#else // WIN32
            fsync(m_hPageFile);
#endif // WIN32
        }
#endif // DO_COMMIT

        // Write Directory
        //
#ifdef WIN32
        SetFilePointer(m_hDirFile, 0, 0, FILE_BEGIN);
        DWORD nWritten;
        WriteFile(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir, &nWritten, 0);
#else // WIN32
#ifdef HAVE_PWRITE
        pwrite(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir, 0);
#else
        lseek(m_hDirFile, 0, SEEK_SET);
        write(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir);
#endif // HAVE_PWRITE
#endif // WIN32

#ifdef DO_COMMIT
        if (!mudstate.bStandAlone)
        {
#ifdef WIN32
            FlushFileBuffers(m_hDirFile);
#else // WIN32
            fsync(m_hDirFile);
#endif // WIN32
        }
#endif // DO_COMMIT
    }
    return true;
}

int CHashFile::Open	(	const char *	szDirFile,
		const char *	szPageFile,
		int	nCachePages
	)

Definition at line 1553 of file svdhash.cpp.

References CloseAll(), CreateFileSet(), FinalCache(), HF_OPEN_STATUS_ERROR, HF_OPEN_STATUS_NEW, HF_OPEN_STATUS_OLD, HF_SIZEOF_PAGE, InitCache(), INVALID_HANDLE_VALUE, m_hDirFile, m_hPageFile, O_BINARY, oEndOfFile, ReadDirectory(), and RebuildDirectory().

Referenced by cache_init(), and main().

{
    CloseAll();
    FinalCache();
    InitCache(nCachePages);

    // First let's try to open the page file. This is the more important file.
    //
#ifdef WIN32
    m_hPageFile = CreateFile(szPageFile, GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ, 0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL + FILE_FLAG_RANDOM_ACCESS, NULL);
#else // WIN32
    m_hPageFile = open(szPageFile, O_RDWR|O_BINARY);
#endif // WIN32
    if (m_hPageFile == INVALID_HANDLE_VALUE)
    {
        // The PageFile doesn't exist, so we have'ta create both of them.
        //
        if (!CreateFileSet(szDirFile, szPageFile))
        {
            CloseAll();
            return HF_OPEN_STATUS_ERROR;
        }
        return HF_OPEN_STATUS_NEW;
    }

    // We have a page file open. Let's check how big it is. If it's
    // zero-length, the page file is useless to use, and we need to go through
    // the standard creation process. If the size is not a multiple of
    // HF_SIZEOF_PAGE, we need to fail.
    //
#ifdef WIN32
    oEndOfFile = SetFilePointer(m_hPageFile, 0, 0, FILE_END);
#else // WIN32
    oEndOfFile = lseek(m_hPageFile, 0, SEEK_END);
#endif // WIN32
    if (oEndOfFile == 0xFFFFFFFFUL)
    {
        CloseAll();
        return HF_OPEN_STATUS_ERROR;
    }
    else if (oEndOfFile == 0UL)
    {
        // The PageFile exists, but it's zero-length, so we have'ta create
        // both of them.
        //
        if (!CreateFileSet(szDirFile, szPageFile))
        {
            CloseAll();
            return HF_OPEN_STATUS_ERROR;
        }
        return HF_OPEN_STATUS_NEW;
    }
    else if ((oEndOfFile % HF_SIZEOF_PAGE) != 0)
    {
        // This is not a mulitple of HP_SIZEOF_PAGE. Weird unknown format.
        //
        CloseAll();
        return HF_OPEN_STATUS_ERROR;
    }

    // Now that the page file appears valid so far, let's see if the directory
    // file is there. This file is not strictly necessary, we can rebuild it.
    // However, having it helps us to open faster.
    //
#ifdef WIN32
    m_hDirFile = CreateFile(szDirFile, GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ, 0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL + FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#else // WIN32
    m_hDirFile = open(szDirFile, O_RDWR|O_BINARY);
#endif // WIN32
    if (m_hDirFile == INVALID_HANDLE_VALUE)
    {
        // The Directory doesn't exist, so we create it anew, and rebuild the
        // index.
#ifdef WIN32
        m_hDirFile = CreateFile(szDirFile, GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ, 0, CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL + FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#else // WIN32
        m_hDirFile = open(szDirFile, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, 0600);
#endif // WIN32

        if (m_hPageFile == INVALID_HANDLE_VALUE)
        {
            CloseAll();
            return HF_OPEN_STATUS_ERROR;
        }

        if (!RebuildDirectory())
        {
            CloseAll();
            return HF_OPEN_STATUS_ERROR;
        }
        return HF_OPEN_STATUS_OLD;
    }

    // Read in the directory.
    //
    if (!ReadDirectory())
    {
        CloseAll();
        return HF_OPEN_STATUS_ERROR;
    }
    return HF_OPEN_STATUS_OLD;
}

int CHashFile::ReadCache	(	UINT32	iFileDir,
		int *	pHits
	)			[private]

Definition at line 2161 of file svdhash.cpp.

References AllocateEmptyPage(), CHashPage::GetRange(), HF_CACHE_CLEAN, HF_CACHE_EMPTY, iCache, Log, m_Cache, tagHashFileCache::m_hp, m_hPageFile, m_hpCacheLookup, tagHashFileCache::m_iState, m_nDirDepth, m_pDir, ResetAge(), and CLogFile::WriteString().

Referenced by FindFirstKey(), and Insert().

{
    int iCache = m_hpCacheLookup[iFileDir];
    HF_FILEOFFSET oPage = m_pDir[iFileDir];

    if (  iCache != -1
       && m_Cache[iCache].m_iState != HF_CACHE_EMPTY
       && m_Cache[iCache].m_o == oPage)
    {
        ResetAge(iCache);
        (*phits)++;
        return iCache;
    }

    if ((iCache = AllocateEmptyPage(0, NULL)) >= 0)
    {
        if (m_Cache[iCache].m_hp.ReadPage(m_hPageFile, oPage))
        {
            //if (m_Cache[i].m_hp.Validate())
            //{
                m_Cache[iCache].m_o = oPage;
                m_Cache[iCache].m_iState = HF_CACHE_CLEAN;
                ResetAge(iCache);

                UINT32 nStart, nEnd;
                m_Cache[iCache].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
                for ( ; nStart <= nEnd; nStart++)
                {
                    m_hpCacheLookup[nStart] = iCache;
                }

                return iCache;
            //}
        }
        else
        {
            Log.WriteString("CHashFile::ReadCache.  ReadPage failed to get the page. DB DAMAGE." ENDLINE);
        }
    }
    return -1;
}

bool CHashFile::ReadDirectory

(

void

)

[private]

Definition at line 1499 of file svdhash.cpp.

References HF_SIZEOF_FILEOFFSET, InitializeDirectory(), m_hDirFile, m_nDir, and m_pDir.

Referenced by Open().

{
#ifdef WIN32
    UINT32 cc = SetFilePointer(m_hDirFile, 0, 0, FILE_END);
#else // WIN32
    UINT32 cc = lseek(m_hDirFile, 0, SEEK_END);
#endif // WIN32
    if (cc == 0xFFFFFFFFUL)
    {
        return false;
    }

    InitializeDirectory(cc / HF_SIZEOF_FILEOFFSET);

#ifdef WIN32
    cc = SetFilePointer(m_hDirFile, 0, 0, FILE_BEGIN);
    DWORD nRead;
    ReadFile(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir, &nRead, 0);
#else // WIN32
#ifdef HAVE_PREAD
    pread(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir, 0);
#else
    lseek(m_hDirFile, 0, SEEK_SET);
    read(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir);
#endif // HAVE_PREAD
#endif // WIN32
    return true;
}

bool CHashFile::RebuildDirectory

(

void

)

[private]

Definition at line 1432 of file svdhash.cpp.

References AllocateEmptyPage(), DoubleDirectory(), CHashPage::GetDepth(), CHashPage::GetRange(), HF_CACHE_CLEAN, HF_SIZEOF_PAGE, iCache, InitializeDirectory(), Log, m_Cache, tagHashFileCache::m_hp, m_hPageFile, m_hpCacheLookup, tagHashFileCache::m_iState, m_nDir, m_nDirDepth, m_pDir, oEndOfFile, ResetAge(), WriteDirectory(), and CLogFile::WriteString().

Referenced by Open().

{
    // Initialize in-memory page directory
    //
    if (!InitializeDirectory(2))
    {
        return false;
    }

    // Re-build the directory from CHashPages.
    //
    for (UINT32 oPage = 0; oPage < oEndOfFile; oPage += HF_SIZEOF_PAGE)
    {
        int iCache;
        if ((iCache = AllocateEmptyPage(0, NULL)) < 0)
        {
            Log.WriteString("CHashFile::RebuildDirectory.  AllocateEmptyPage failed. DB DAMAGE." ENDLINE);
            return false;
        }

        if (m_Cache[iCache].m_hp.ReadPage(m_hPageFile, oPage))
        {
            m_Cache[iCache].m_o = oPage;
            m_Cache[iCache].m_iState = HF_CACHE_CLEAN;
            ResetAge(iCache);
        }
        else
        {
            Log.WriteString("CHashFile::RebuildDirectory.  ReadPage failed to get the page. DB DAMAGE." ENDLINE);
        }

        UINT32 nPageDepth = m_Cache[iCache].m_hp.GetDepth();
        while (m_nDirDepth < nPageDepth)
        {
            if (!DoubleDirectory())
            {
                return false;
            }
        }
        UINT32 nStart, nEnd;
        m_Cache[iCache].m_hp.GetRange(m_nDirDepth, nStart, nEnd);
        for ( ; nStart <= nEnd; nStart++)
        {
            if (m_pDir[nStart] != 0xFFFFFFFFUL)
            {
                Log.WriteString("CHashFile::Open - The keyspace of pages in Page File overlap." ENDLINE);
                return false;
            }
            m_pDir[nStart] = oPage;
            m_hpCacheLookup[nStart] = iCache;
        }
    }

    // Validate that the directory does not have holes.
    //
    for (UINT32 iFileDir = 0; iFileDir < m_nDir; iFileDir++)
    {
        if (m_pDir[iFileDir] == 0xFFFFFFFFUL)
        {
            Log.WriteString("CHashFile::Open - Page File is incomplete." ENDLINE);
            return false;
        }
    }
    WriteDirectory();
    return true;
}

void CHashFile::Remove

(

HP_DIRINDEX

iDir

)

Definition at line 2029 of file svdhash.cpp.

References cs_dels, CHashPage::HeapFree(), HF_CACHE_UNPROTECTED, iCache, m_Cache, tagHashFileCache::m_hp, and tagHashFileCache::m_iState.

Referenced by cache_del(), and cache_put().

{
    cs_dels++;
    m_Cache[iCache].m_hp.HeapFree(iDir);
    m_Cache[iCache].m_iState = HF_CACHE_UNPROTECTED;
}

void CHashFile::ResetAge

(

int

iEntry

)

[private]

Definition at line 2096 of file svdhash.cpp.

References m_Cache, tagHashFileCache::m_iOlder, m_iOldest, and tagHashFileCache::m_iYounger.

Referenced by AllocateEmptyPage(), ReadCache(), and RebuildDirectory().

{
    if (iEntry == m_iOldest)
    {
        // Rotate the doubly-linked list to make the oldest entry the
        // youngest.
        //
        m_iOldest = m_Cache[m_iOldest].m_iYounger;
    }
    else if (iEntry == m_Cache[m_iOldest].m_iOlder)
    {
        // This is already the youngest entry.
        //
    }
    else
    {
        // Unlink this entry.
        //
        int iYounger = m_Cache[iEntry].m_iYounger;
        int iOlder   = m_Cache[iEntry].m_iOlder;
        m_Cache[iYounger].m_iOlder = iOlder;
        m_Cache[iOlder].m_iYounger = iYounger;

        // Re-link at the young end of the queue.
        //
        iYounger = m_iOldest;
        iOlder   = m_Cache[iYounger].m_iOlder;
        m_Cache[iEntry].m_iOlder   = iOlder;
        m_Cache[iEntry].m_iYounger = iYounger;
        m_Cache[iYounger].m_iOlder = iEntry;
        m_Cache[iOlder].m_iYounger = iEntry;
    }
}

void CHashFile::Sync

(

void

)

Definition at line 1662 of file svdhash.cpp.

References statedata::bStandAlone, cs_syncs, FlushCache(), INVALID_HANDLE_VALUE, Log, m_hDirFile, m_hPageFile, m_nCache, mudstate, and CLogFile::WriteString().

Referenced by cache_sync(), and CloseAll().

{
    if (m_hPageFile != INVALID_HANDLE_VALUE)
    {
        cs_syncs++;
        bool bAllFlushed = true;
        for (int i = 0; i < m_nCache; i++)
        {
            if (!FlushCache(i))
            {
                bAllFlushed = false;
            }
        }
        if (!bAllFlushed)
        {
            Log.WriteString("CHashFile::Sync. Could not flush all the pages. DB DAMAGE." ENDLINE);
        }

#ifdef DO_COMMIT
        if (!mudstate.bStandAlone)
        {
#ifdef WIN32
            FlushFileBuffers(m_hPageFile);
#else // WIN32
            fsync(m_hPageFile);
#endif // WIN32
        }
#endif // DO_COMMIT
    }
#ifdef DO_COMMIT
    if (  m_hDirFile != INVALID_HANDLE_VALUE
       && !mudstate.bStandAlone)
    {
#ifdef WIN32
        FlushFileBuffers(m_hDirFile);
#else // WIN32
        fsync(m_hDirFile);
#endif // WIN32
    }
#endif // DO_COMMIT
}

void CHashFile::Tick

(

void

)

Definition at line 2130 of file svdhash.cpp.

References confdata::cache_tick_period, confdata::check_interval, confdata::dump_interval, FlushCache(), m_iLastFlushed, m_nCache, mudconf, and CLinearTimeDelta::SetSeconds().

Referenced by cache_tick().

{
    int nCycle = mudconf.check_interval;
    if (mudconf.dump_interval < nCycle)
    {
        nCycle = mudconf.dump_interval;
    }

    CLinearTimeDelta ltdCycle;
    ltdCycle.SetSeconds(nCycle);

    int n = (mudconf.cache_tick_period*m_nCache)/ltdCycle;
    if (n < 1)
    {
        n = 1;
    }

    for (int i = 0; i < n; i++)
    {
        // Go ahead and flush a cache entry...just to keep the sync load
        // down a bit. This gives the cache time to age, and yet, pushes
        // the pages off to the disk eventually and gradually.
        //
        FlushCache(m_iLastFlushed++);
        if (m_iLastFlushed >= m_nCache)
        {
            m_iLastFlushed = 0;
        }
    }
}

void CHashFile::WriteDirectory

(

void

)

[private]

Definition at line 1318 of file svdhash.cpp.

References statedata::bStandAlone, INVALID_HANDLE_VALUE, m_hDirFile, m_nDir, m_pDir, and mudstate.

Referenced by CreateFileSet(), DoubleDirectory(), and RebuildDirectory().

{
    if (m_hDirFile == INVALID_HANDLE_VALUE) return;

#ifdef HAVE_PWRITE
    pwrite(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir, 0);
#else
    lseek(m_hDirFile, 0, SEEK_SET);
    write(m_hDirFile, m_pDir, sizeof(HF_FILEOFFSET)*m_nDir);
#endif // HAVE_PWRITE
    //SetEndOfFile(m_hDirFile);
#ifdef DO_COMMIT
    if (!mudstate.bStandAlone)
    {
        fsync(m_hDirFile);
    }
#endif // DO_COMMIT
}

---

Field Documentation

int CHashFile::iCache [private]

Definition at line 201 of file svdhash.h.

Referenced by Copy(), CreateFileSet(), FindFirstKey(), FindNextKey(), Init(), Insert(), ReadCache(), RebuildDirectory(), and Remove().

HF_CACHE* CHashFile::m_Cache [private]

Definition at line 208 of file svdhash.h.

Referenced by AllocateEmptyPage(), CHashFile(), Copy(), CreateFileSet(), FinalCache(), FindFirstKey(), FindNextKey(), FlushCache(), InitCache(), Insert(), ReadCache(), RebuildDirectory(), Remove(), and ResetAge().

HANDLE CHashFile::m_hDirFile [private]

Definition at line 199 of file svdhash.h.

Referenced by CloseAll(), CreateFileSet(), Init(), Insert(), Open(), ReadDirectory(), Sync(), and WriteDirectory().

HANDLE CHashFile::m_hPageFile [private]

Definition at line 200 of file svdhash.h.

Referenced by CloseAll(), CreateFileSet(), FlushCache(), Init(), Insert(), Open(), ReadCache(), RebuildDirectory(), and Sync().

int* CHashFile::m_hpCacheLookup [private]

Definition at line 204 of file svdhash.h.

Referenced by AllocateEmptyPage(), CloseAll(), CreateFileSet(), DoubleDirectory(), Init(), InitializeDirectory(), Insert(), ReadCache(), and RebuildDirectory().

int CHashFile::m_iLastFlushed [private]

Definition at line 203 of file svdhash.h.

Referenced by Init(), and Tick().

int CHashFile::m_iOldest [private]

Definition at line 202 of file svdhash.h.

Referenced by AllocateEmptyPage(), InitCache(), and ResetAge().

int CHashFile::m_nCache [private]

Definition at line 209 of file svdhash.h.

Referenced by AllocateEmptyPage(), CHashFile(), FinalCache(), InitCache(), Sync(), and Tick().

unsigned int CHashFile::m_nDir [private]

Definition at line 206 of file svdhash.h.

Referenced by DoubleDirectory(), FindFirstKey(), Init(), InitializeDirectory(), Insert(), ReadDirectory(), RebuildDirectory(), and WriteDirectory().

unsigned int CHashFile::m_nDirDepth [private]

Definition at line 207 of file svdhash.h.

Referenced by AllocateEmptyPage(), DoubleDirectory(), FindFirstKey(), Init(), InitializeDirectory(), Insert(), ReadCache(), and RebuildDirectory().

HF_PFILEOFFSET CHashFile::m_pDir [private]

Definition at line 210 of file svdhash.h.

Referenced by CloseAll(), CreateFileSet(), DoubleDirectory(), Init(), InitializeDirectory(), Insert(), ReadCache(), ReadDirectory(), RebuildDirectory(), and WriteDirectory().

HF_FILEOFFSET CHashFile::oEndOfFile [private]

Definition at line 205 of file svdhash.h.

Referenced by CreateFileSet(), Insert(), Open(), and RebuildDirectory().

---

The documentation for this class was generated from the following files:

• mux/src/svdhash.h
• mux/src/svdhash.cpp

---