mariadb-columnstore-engine/writeengine/shared/we_cache.cpp

/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/******************************************************************************************
* $Id: we_cache.cpp 33 2006-10-30 13:45:13Z wzhou  $
*
******************************************************************************************/
/** @file */

#include <we_cache.h>

using namespace std;

namespace WriteEngine
{

CacheControl*  Cache::m_cacheParam = NULL;
FreeBufList*   Cache::m_freeList = NULL;
CacheMap*      Cache::m_lruList = NULL;
CacheMap*      Cache::m_writeList = NULL;
#ifdef _MSC_VER
__declspec(dllexport)
#endif
bool           Cache::m_useCache = false;
/***********************************************************
 * DESCRIPTION:
 *    Clear all list and free memory
 * PARAMETERS:
 *    none
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
void  Cache::clear()
{
    CacheMapIt     it;
    BlockBuffer*   block;
    size_t         i;

    // free list
    if ( m_freeList != NULL )
    {
        for ( i = 0; i < m_freeList->size(); i++ )
        {
            block = m_freeList->at(i);
            block->clear();
        }
    }

    // LRU list
    if ( m_lruList != NULL )
    {
        for ( it = m_lruList->begin(); it != m_lruList->end(); it++ )
        {
            block = it->second;
            block->clear();
            m_freeList->push_back( block );
        }

        m_lruList->clear();
    }

    // Write list
    if ( m_writeList != NULL )
    {
        for ( it = m_writeList->begin(); it != m_writeList->end(); it++ )
        {
            block = it->second;
            block->clear();
            m_freeList->push_back( block );
        }

        m_writeList->clear();
    }
}

/***********************************************************
 * DESCRIPTION:
 *    Flush write cache
 * PARAMETERS:
 *    none
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
const int  Cache::flushCache()
{
    bool           bHasReadBlock = false;
    BlockBuffer*   curBuf;

    // add lock here
    if ( m_lruList && m_lruList->size() > 0 )
    {
        bHasReadBlock = true;

        for ( CacheMapIt it = m_lruList->begin(); it != m_lruList->end(); it++ )
        {
            curBuf = it->second;
            curBuf->clear();
            m_freeList->push_back( curBuf );
        }

        m_lruList->clear();
    }

    // must write to disk first
    if ( m_writeList && m_writeList->size() > 0 )
    {
        if ( !bHasReadBlock )
            for ( CacheMapIt it = m_writeList->begin(); it != m_writeList->end(); it++ )
            {
                curBuf = it->second;
                curBuf->clear();
                m_freeList->push_back( curBuf );
            }
        else
            for ( CacheMapIt it = m_writeList->begin(); it != m_writeList->end(); it++ )
            {
                curBuf = it->second;
                (*curBuf).block.dirty = false;
                processCacheMap( m_lruList, curBuf, INSERT );
            }

        m_writeList->clear();

    } // end of if( m_writeList->size()

    // add unlock here
    return NO_ERROR;
}

/***********************************************************
 * DESCRIPTION:
 *    Free memory
 * PARAMETERS:
 *    none
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
void  Cache::freeMemory()
{
    CacheMapIt     it;
    BlockBuffer*   block;
    size_t         i;

    // free list
    if ( m_freeList != NULL )
    {
        for ( i = 0; i < m_freeList->size(); i++ )
        {
            block = m_freeList->at(i);
            block->freeMem();
            delete block;
        }

        m_freeList->clear();
        delete m_freeList;
        m_freeList = NULL;
    }

    // LRU list
    if ( m_lruList != NULL )
    {
        for ( it = m_lruList->begin(); it != m_lruList->end(); it++ )
        {
            block = it->second;
            block->freeMem();
            delete block;
        }

        m_lruList->clear();
        delete m_lruList;
        m_lruList = NULL;
    }

    // Write list
    if ( m_writeList != NULL )
    {
        for ( it = m_writeList->begin(); it != m_writeList->end(); it++ )
        {
            block = it->second;
            block->freeMem();
            delete block;
        }

        m_writeList->clear();
        delete m_writeList;
        m_writeList = NULL;
    }

    // param
    if ( m_cacheParam != NULL )
    {
        delete m_cacheParam;
        m_cacheParam = NULL;
    }
}

/***********************************************************
 * DESCRIPTION:
 *    get a list size
 * PARAMETERS:
 *    listType - List type
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
const int  Cache::getListSize( const CacheListType listType )
{
    int size = 0;

    if ( !m_useCache )
        return size;

    switch ( listType )
    {
        case FREE_LIST:
            size = m_freeList->size();
            break;

        case LRU_LIST:
            size = m_lruList->size();
            break;

        case WRITE_LIST:
        default:
            size = m_writeList->size();
            break;
    }

    return size;
}

/***********************************************************
 * DESCRIPTION:
 *    Init all parameters and list
 * PARAMETERS:
 *    totalBlock - total blocks
 *    chkPoint - checkpoint interval
 *    pctFree - percentage free
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
void  Cache::init( const int totalBlock, const int chkPoint, const int pctFree )
{
    BlockBuffer*   buffer;

    if ( m_cacheParam && m_freeList && m_lruList && m_writeList )
        return;

    m_cacheParam = new CacheControl();
    m_cacheParam->totalBlock = totalBlock;
    m_cacheParam->checkInterval = chkPoint;
    m_cacheParam->pctFree = pctFree;

    m_freeList = new FreeBufList();
    m_lruList = new CacheMap();
    m_writeList = new CacheMap();

    for ( int i = 0; i < m_cacheParam->totalBlock; i++ )
    {
        buffer = new BlockBuffer();
        buffer->init();
        m_freeList->push_back( buffer );
    }
}

/***********************************************************
 * DESCRIPTION:
 *    Insert a buffer to LRU list
 * PARAMETERS:
 *    cb - Comm Block
 *    lbid - lbid value
 *    fbo - fbo
 *    buf - input buffer
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
const int  Cache::insertLRUList( CommBlock& cb, const uint64_t lbid, const uint64_t fbo, const unsigned char* buf  )
{
    BlockBuffer*      buffer;
    vector<BlockBuffer*>::iterator  it;

    if ( m_freeList->size() == 0 )
        return ERR_FREE_LIST_EMPTY;

    // make sure flush first if necessary
    it = m_freeList->begin();
    buffer = *it;
    memcpy( (*buffer).block.data, buf, BYTE_PER_BLOCK );
    (*buffer).listType = LRU_LIST;
    (*buffer).block.lbid = lbid;
    (*buffer).block.fbo = fbo;
    (*buffer).block.dirty = false;
    (*buffer).block.hitCount = 1;
    (*buffer).cb.file.oid = cb.file.oid;
    (*buffer).cb.file.pFile = cb.file.pFile;

    RETURN_ON_ERROR( processCacheMap( m_lruList, buffer, INSERT ) );
    m_freeList->erase( it );

    return NO_ERROR;
}

/***********************************************************
 * DESCRIPTION:
 *    Load cache block
 * PARAMETERS:
 *    key - Cache key
 *    buf - output buffer
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
const int  Cache::loadCacheBlock( const CacheKey& key, unsigned char* buf  )
{
    BlockBuffer*      buffer;
    CacheMapIt        iter;

    iter = m_lruList->find( key );

    if ( iter != m_lruList->end() )
        buffer = iter->second;
    else
    {
        iter = m_writeList->find( key );

        if ( iter != m_writeList->end() )
            buffer = iter->second;
        else
            return ERR_CACHE_KEY_NOT_EXIST;
    }

    memcpy( buf, (*buffer).block.data, BYTE_PER_BLOCK );
    (*buffer).block.hitCount++;

    return NO_ERROR;
}

/***********************************************************
 * DESCRIPTION:
 *    Modify cache block
 * PARAMETERS:
 *    key - Cache key
 *    buf - output buffer
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
const int  Cache::modifyCacheBlock( const CacheKey& key, const unsigned char* buf  )
{
    BlockBuffer*      buffer;
    CacheMapIt        iter;

    iter = m_lruList->find( key );

    if ( iter != m_lruList->end() )
    {
        buffer = iter->second;
        (*buffer).listType = WRITE_LIST;
        (*buffer).block.dirty = true;

        (*m_writeList)[key] = iter->second;
        m_lruList->erase( iter );

    }
    else
    {
        iter = m_writeList->find( key );

        if ( iter != m_writeList->end() )
            buffer = iter->second;
        else
            return ERR_CACHE_KEY_NOT_EXIST;
    }

    memcpy( (*buffer).block.data, buf, BYTE_PER_BLOCK );
    (*buffer).block.hitCount++;

    return NO_ERROR;
}

/***********************************************************
 * DESCRIPTION:
 *    Print cache list
 * PARAMETERS:
 *    none
 * RETURN:
 *    none
 ***********************************************************/
void  Cache::printCacheList()
{
    BlockBuffer*      buffer;
    int               i = 0;

    if ( !m_useCache )
        return;

    cout << "\nFree List has " << m_freeList->size() << " elements" << endl;
    cout << "LRU List has " << m_lruList->size() << " elements" << endl;

    for ( CacheMapIt it = m_lruList->begin(); it != m_lruList->end(); it++ )
    {
        buffer = it->second;
        cout  << "\t[" << i++ << "] key=" << it->first << " listType=" << buffer->listType
              << " oid=" << (*buffer).cb.file.oid << " fbo=" << (*buffer).block.fbo
              << " dirty=" << (*buffer).block.dirty << " hitCount=" << (*buffer).block.hitCount << endl;
    }

    i = 0;
    cout << "Write List has " << m_writeList->size() << " elements" << endl;

    for ( CacheMapIt it = m_writeList->begin(); it != m_writeList->end(); it++ )
    {
        buffer = it->second;
        cout  << "\t[" << i++ << "] key=" << it->first << " listType=" << buffer->listType
              << " oid=" << (*buffer).cb.file.oid << " fbo=" << (*buffer).block.fbo
              << " dirty=" << (*buffer).block.dirty << " hitCount=" << (*buffer).block.hitCount << endl;
    }
}

/***********************************************************
 * DESCRIPTION:
 *    Process a buffer in a cache map
 * PARAMETERS:
 *    buffer - block buffer
 *    opType - insert or delete
 * RETURN:
 *    NO_ERROR if success, other otherwise
 ***********************************************************/
const int  Cache::processCacheMap( CacheMap* map, BlockBuffer* buffer, OpType opType )
{
    RETURN_ON_NULL( buffer, ERR_NULL_BLOCK );
    CacheMapIt iter;

    CacheKey key = getCacheKey( buffer );
    iter = map->find( key );

    // only handle insert and delete
    if ( iter == map->end() )
    {
        if ( opType == INSERT )
            (*map)[key] = buffer;
        else
            return ERR_CACHE_KEY_NOT_EXIST;
    }
    else
    {
        if ( opType == INSERT )
            return ERR_CACHE_KEY_EXIST;
        else
            map->erase( iter );
    }

    return NO_ERROR;
}



} //end of namespace