Chunk Class Reference

#include <Allocator.h>

Collaboration diagram for Chunk:

[legend]

Public Member Functions
void	setSize (size_t size)
size_t	getSize ()
void	setChunkID (unsigned int id)
int	getChunkID ()
void	setAllocType (AllocType type)
AllocType	getAllocType ()
PageInfo *	getPageInfo (Database *db, void *ptr)
void *	allocate (Database *db, DbRetVal *status=NULL)
void *	allocate (Database *db, size_t size, DbRetVal *status=NULL)
void	free (Database *db, void *ptr)
ChunkIterator	getIterator ()
void	print ()
long	getTotalDataNodes ()
int	totalPages ()
int	compact ()
Friends
class	Database
class	DatabaseManagerImpl

---

Detailed Description

Definition at line 95 of file Allocator.h.

---

Member Function Documentation

void * Chunk::allocate	(	Database *	db,
		size_t	size,
		DbRetVal *	status = NULL
	)

Definition at line 355 of file Chunk.cxx.

References os::align(), ErrLockTimeOut, ErrNoMemory, PAGE_SIZE, printError, and Database::procSlot.

{
    if (0 == size) return NULL;
    //check if the size is more than PAGE_SIZE
    //if it is more than the PAGE_SIZE, then allocate new
    //page using database and then link the curPage to the
    //newly allocated page
    //if it is less than PAGE_SIZE, then check the curpage for
    //free memory of specified size
    //if not available, then scan from the firstPage for the free
    //space

    //TODO::During the scan, merge nearby nodes if both are free
    //if not available then allocate new page

    size_t alignedSize = os::align(size);
    void *data = NULL;
    int ret = getChunkMutex(db->procSlot);
    if (ret != 0)
    {
        printError(ErrLockTimeOut,"Unable to acquire chunk Mutex");
        *status = ErrLockTimeOut;
        return NULL;
    }
    if (alignedSize > PAGE_SIZE)
    {
        data =  allocateForLargeDataSize(db, alignedSize);
    }
    else
    {
        data = allocateFromCurPageForVarSize(alignedSize);
        if (NULL == data) {
            //No available spaces in the current page.
            //allocate new page
            data= allocFromNewPageForVarSize(db, alignedSize);
            if (NULL == data) {
                printError(ErrNoMemory, "No memory in any of the pages:Increase db size");
                if (status != NULL) *status = ErrNoMemory;
            }
        }
    }
    releaseChunkMutex(db->procSlot);
    return data;
}

Here is the call graph for this function:

void * Chunk::allocate	(	Database *	db,
		DbRetVal *	status = NULL
	)

Definition at line 163 of file Chunk.cxx.

References DM_Alloc, ErrLockTimeOut, ErrNoMemory, os::floor(), PageInfo::hasFreeSpace_, LockTableId, PAGE_SIZE, printDebug, printError, Database::procSlot, and TransHasTableId.

Referenced by Database::allocLockHashBuckets(), Transaction::createUndoLog(), CatalogTableUSER::insert(), CatalogTableINDEXFIELD::insert(), CatalogTableINDEX::insert(), CatalogTableFIELD::insert(), CatalogTableTABLE::insert(), BucketList::insert(), and Transaction::insertIntoHasList().

{
    PageInfo* pageInfo = ((PageInfo*)curPage_);

    int noOfDataNodes=os::floor((PAGE_SIZE - sizeof(PageInfo))/allocSize_);
    char *data = ((char*)curPage_) + sizeof(PageInfo);
    printDebug(DM_Alloc, "Chunk::allocate id:%d curPage:%x noOfDataNodes:%d",
                         chunkID_, curPage_, noOfDataNodes);
    
    //1.scan through data list and find if any is free to use in current page
    //2.If there is none then
    //    a) get new free page from db. set the prev->next to point
    //       to this new page
    //4.  b) initialize the free page to zero and get first data ptr.
    //5.If there is one, return that

    //For allocation more than PAGE_SIZE
    if (0 == noOfDataNodes)
    {
        data = (char*) allocateForLargeDataSize(db);
        return data;
    }

    int ret = getChunkMutex(db->procSlot);
    if (ret != 0)
    {
        if (status != NULL) *status = ErrLockTimeOut;
        printError(ErrLockTimeOut,"Unable to acquire chunk Mutex");
        return NULL;
    }
    int i = noOfDataNodes;
    if (pageInfo->hasFreeSpace_ == 1)
    {
        for (i = 1; i< noOfDataNodes; i++)
        {
            if (*((int*)data) == 1) data = data + allocSize_;
            else break;
        }

    }
    printDebug(DM_Alloc, "ChunkID:%d Node which might be free is %d",
                                                        chunkID_, i);
    //It comes here if the pageInfo->hasFreeSpace ==0
    //or there are no free data space in this page
    if (i == noOfDataNodes && *((int*)data) == 1)
    {

        printDebug(DM_Alloc, "ChunkID:%d curPage does not have free nodes.", chunkID_);
        //there are no free data space in this page
        pageInfo->hasFreeSpace_ = 0;
        if (chunkID_ == LockTableId || chunkID_ == TransHasTableId) 
        {
           data = (char*) allocateFromFirstPage(db, noOfDataNodes);
           if (NULL == data)
           {
              data = (char*) allocateFromNewPage(db);
              if (data == NULL)
              {
                printError(ErrNoMemory, "No memory in any of the pages:Increase db size");
                if (status != NULL) *status = ErrNoMemory;
              }
           }
        } 
        else 
        {
           data = (char*) allocateFromNewPage(db);
           if (NULL == data)
           {
              data = (char*) allocateFromFirstPage(db, noOfDataNodes);
              if (data == NULL)
              {
                printError(ErrNoMemory, "No memory in any of the pages:Increase db size");
                if (status != NULL) *status = ErrNoMemory;
              }
           }
        }
        releaseChunkMutex(db->procSlot);
        return data;
    }
    *((int*)data) = 1;
    releaseChunkMutex(db->procSlot);
    return data + sizeof(int);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Chunk::compact

(

)

Definition at line 594 of file Chunk.cxx.

References DM_Alloc, DM_VarAlloc, os::floor(), PageInfo::isUsed_, VarSizeInfo::isUsed_, PageInfo::nextPage_, PAGE_SIZE, printDebug, and VarSizeInfo::size_.

{
    PageInfo* pageInfo = ((PageInfo*)firstPage_);
    PageInfo* prevPage = pageInfo;
    if (NULL == pageInfo) 
    {
        return 0;
    }
    pageInfo = (PageInfo*)pageInfo->nextPage_;
    if (0 == allocSize_) 
    {
      while( pageInfo != NULL )
      {
        bool flag = false;
        VarSizeInfo *varInfo = (VarSizeInfo*)(((char*)pageInfo) +
                                            sizeof(PageInfo));
        while ((char*) varInfo < ((char*)pageInfo + PAGE_SIZE))
        {
            if (1 == varInfo->isUsed_) {flag=true; break;}
            varInfo = (VarSizeInfo*)((char*)varInfo + sizeof(VarSizeInfo)
                                   +varInfo->size_);
        }
        if (!flag) {
            printDebug(DM_VarAlloc,"Freeing unused page in varsize allocator %x\n", pageInfo);
            prevPage->nextPage_ = pageInfo->nextPage_;
            pageInfo->isUsed_ = 0;
        }
        prevPage = pageInfo;
        pageInfo = (PageInfo*)(((PageInfo*)pageInfo)->nextPage_) ;
        printDebug(DM_VarAlloc,"compact iter %x\n", pageInfo);
      }
    }else if (allocSize_ < PAGE_SIZE)
    {
      while( pageInfo != NULL )
      {
        bool flag = false;
        int noOfDataNodes=os::floor((PAGE_SIZE - sizeof(PageInfo))/allocSize_);
        char *data = ((char*)pageInfo) + sizeof(PageInfo);
        for (int i = 0; i< noOfDataNodes -1; i++)
        {
            if (1 == *((int*)data)) { flag = true; break; }
            data = data +allocSize_;
        }
        if (!flag) {
            printDebug(DM_Alloc,"Freeing unused page in fixed allocator %x\n", pageInfo);
            prevPage->nextPage_ = pageInfo->nextPage_;
            pageInfo->isUsed_ = 0;
        }
        prevPage = pageInfo;
        pageInfo = (PageInfo*)(((PageInfo*)pageInfo)->nextPage_) ;
        printDebug(DM_Alloc,"compact iter %x\n", pageInfo);
      }
    }
    return 0;
}

Here is the call graph for this function:

void Chunk::free	(	Database *	db,
		void *	ptr
	)

Definition at line 487 of file Chunk.cxx.

References ErrLockTimeOut, ErrSysFatal, os::floor(), getPageInfo(), PageInfo::hasFreeSpace_, PAGE_SIZE, printError, and Database::procSlot.

Referenced by Transaction::applyUndoLogs(), DatabaseManagerImpl::dropTable(), Transaction::releaseAllLocks(), CatalogTableUSER::remove(), CatalogTableINDEXFIELD::remove(), CatalogTableINDEX::remove(), CatalogTableFIELD::remove(), CatalogTableTABLE::remove(), BucketList::remove(), Transaction::removeFromHasList(), and Transaction::removeUndoLogs().

{
    if (0 == allocSize_)
    {
        freeForVarSizeAllocator(ptr, db->procSlot);
        return;
    }
    int noOfDataNodes =os::floor((PAGE_SIZE - sizeof(PageInfo)) / allocSize_);

    if (0 == noOfDataNodes)
    {
        freeForLargeAllocator(ptr, db->procSlot);
        return;
    }
    int ret = getChunkMutex(db->procSlot);
    if (ret != 0)
    {
        printError(ErrLockTimeOut,"Unable to acquire chunk Mutex");
        return;
    }
     //below is the code for freeing in fixed size allocator

     //unset the used flag
    *((int*)ptr -1 ) = 0;
    PageInfo *pageInfo;
    pageInfo = getPageInfo(db, ptr);
    if (NULL == pageInfo)
    {
        printError(ErrSysFatal,"Probable Data corruption: pageInfo is NULL", pageInfo );
        releaseChunkMutex(db->procSlot);
        return;
    }
    //set the pageinfo where this ptr points
    pageInfo->hasFreeSpace_ = 1;
    releaseChunkMutex(db->procSlot);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AllocType Chunk::getAllocType

(

)

[inline]

Definition at line 123 of file Allocator.h.

{ return allocType_; }

int Chunk::getChunkID

(

)

[inline]

Definition at line 121 of file Allocator.h.

{ return chunkID_; }

ChunkIterator Chunk::getIterator

(

)

Definition at line 23 of file ChunkIterator.cxx.

References ChunkIterator::allocSize_, ChunkIterator::allocType_, ChunkIterator::chunkID_, os::floor(), ChunkIterator::iterPage_, ChunkIterator::nodeOffset_, ChunkIterator::noOfNodes_, and PAGE_SIZE.

Referenced by CatalogTableUSER::authenticate(), CatalogTableUSER::changePass(), CatalogTableINDEX::get(), CatalogTableTABLE::getChunkAndTblPtr(), CatalogTableFIELD::getFieldInfo(), CatalogTableINDEXFIELD::getFieldNameAndType(), CatalogTableFIELD::getFieldPtrs(), CatalogTableINDEX::getIndexName(), CatalogTableINDEX::getIndexPtrs(), Database::getLockHashBuckets(), CatalogTableINDEX::getNumIndexes(), CatalogTableTABLE::getTableList(), CatalogTableINDEXFIELD::insert(), CatalogTableINDEX::insert(), CatalogTableUSER::remove(), CatalogTableINDEXFIELD::remove(), CatalogTableINDEX::remove(), CatalogTableFIELD::remove(), and CatalogTableTABLE::remove().

{
    ChunkIterator iter;
    iter.chunkID_ = chunkID_;
    iter.allocSize_ = allocSize_;
    iter.allocType_ = allocType_;
    iter.iterPage_ = firstPage_;
    iter.nodeOffset_ = 0;
    iter.noOfNodes_ = os::floor((PAGE_SIZE - sizeof(PageInfo)) / allocSize_);
    return iter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PageInfo * Chunk::getPageInfo	(	Database *	db,
		void *	ptr
	)

Definition at line 530 of file Chunk.cxx.

References PageInfo::nextPage_, PageInfo::nextPageAfterMerge_, and PAGE_SIZE.

Referenced by free().

{
    if (allocSize_ < PAGE_SIZE - sizeof(PageInfo)) { 
       int rem = (long) ptr % 8192;
       return (PageInfo*)(((char*)ptr) - rem);
    } else {
        //large size allocator
        char *inPtr = (char*)ptr;
        PageInfo* pageInfo = ((PageInfo*)firstPage_);

        while( pageInfo != NULL )
        {
          if (inPtr > (char*) pageInfo && pageInfo->nextPageAfterMerge_ >inPtr)
            return pageInfo;
        pageInfo = (PageInfo*)pageInfo->nextPage_ ;
        }
    }
    return NULL;
}

Here is the caller graph for this function:

size_t Chunk::getSize

(

)

[inline]

Definition at line 119 of file Allocator.h.

Referenced by TableImpl::spaceUsed().

{ return allocSize_; }

Here is the caller graph for this function:

long Chunk::getTotalDataNodes

(

)

Definition at line 552 of file Chunk.cxx.

References os::floor(), VarSizeInfo::isUsed_, PAGE_SIZE, and VarSizeInfo::size_.

Referenced by DatabaseManagerImpl::printIndexInfo(), and TableImpl::spaceUsed().

{
    long totalNodes =0;
    if (0 == allocSize_) //->variable size allocator
    {
        Page *page = ((PageInfo*)firstPage_);
        while(NULL != page)
        {
            VarSizeInfo *varInfo = (VarSizeInfo*)(((char*)page) + sizeof(PageInfo));
            while ((char*) varInfo < ((char*)page + PAGE_SIZE))
            {
                if (1 == varInfo->isUsed_) totalNodes++;
                varInfo = (VarSizeInfo*)((char*)varInfo + sizeof(VarSizeInfo)
                                    +varInfo->size_);
            }
            page = ((PageInfo*) page)->nextPage_;
        }
        return totalNodes;
    }

    //TODO::for large size allocator
    if (allocSize_ >PAGE_SIZE)//->each page has only one data node
        return 0;

    int noOfDataNodes=os::floor((PAGE_SIZE - sizeof(PageInfo))/allocSize_);
    PageInfo* pageInfo = ((PageInfo*)firstPage_);
    char *data = ((char*)firstPage_) + sizeof(PageInfo);
    int i=0;
    while( pageInfo != NULL )
    {
        data = ((char*)pageInfo) + sizeof(PageInfo);
        for (i = 0; i< noOfDataNodes; i++)
        {
            if (*((int*)data) == 1) { totalNodes++;}
            data = data + allocSize_;
        }
        pageInfo = (PageInfo*)(((PageInfo*)pageInfo)->nextPage_) ;
    }
    return totalNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Chunk::print

(

)

[inline]

Definition at line 133 of file Allocator.h.

{}

void Chunk::setAllocType

(

AllocType

type

)

[inline]

Definition at line 122 of file Allocator.h.

Referenced by Database::createSystemDatabaseChunk(), and Database::deleteSystemDatabaseChunk().

{ allocType_ = type; }

Here is the caller graph for this function:

void Chunk::setChunkID

(

unsigned int

id

)

[inline]

Definition at line 120 of file Allocator.h.

Referenced by Database::createSystemDatabaseChunk(), and Database::deleteSystemDatabaseChunk().

{ chunkID_ = id; }

Here is the caller graph for this function:

void Chunk::setSize

(

size_t

size

)

Definition at line 28 of file Chunk.cxx.

References os::floor().

Referenced by Database::createSystemDatabaseChunk(), and Database::deleteSystemDatabaseChunk().

{

    size_t needSize = size + sizeof(int);
    size_t multiple = (size_t) os::floor(needSize / sizeof(size_t));
    size_t rem = needSize % sizeof(size_t);
    if (0 == rem)
        allocSize_ = needSize;
    else
        allocSize_  = (multiple + 1) * sizeof(size_t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Chunk::totalPages

(

)

Definition at line 650 of file Chunk.cxx.

Referenced by TableImpl::pagesUsed(), TransactionManager::printDebugInfo(), Transaction::printDebugInfo(), LockManager::printDebugInfo(), DatabaseManagerImpl::printIndexInfo(), and TableImpl::spaceUsed().

{
    //logic is same for variable size and for large data node allocator. 
    PageInfo* pageInfo = ((PageInfo*)firstPage_);
    int totPages=0;
    while( pageInfo != NULL )
    {
        totPages++;
        pageInfo = (PageInfo*)(((PageInfo*)pageInfo)->nextPage_) ;
    }
    return totPages;
}

Here is the caller graph for this function:

---

Friends And Related Function Documentation

friend class Database [friend]

Definition at line 160 of file Allocator.h.

friend class DatabaseManagerImpl [friend]

Definition at line 161 of file Allocator.h.

---

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

• include/Allocator.h
• src/server/Chunk.cxx
• src/server/ChunkIterator.cxx

---