You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-11-03 17:13:17 +03:00
1652 lines
49 KiB
C++
1652 lines
49 KiB
C++
/* 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_freemgr.cpp 4450 2013-01-21 14:13:24Z rdempsey $
|
|
*
|
|
******************************************************************************************/
|
|
/** @file */
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <iostream>
|
|
#include "we_freemgr.h"
|
|
using namespace std;
|
|
|
|
namespace WriteEngine
|
|
{
|
|
/**
|
|
* Constructor
|
|
*/
|
|
FreeMgr::FreeMgr()
|
|
{
|
|
//memset( m_workBlock.data, 0, BYTE_PER_BLOCK );
|
|
|
|
|
|
// use 0 for old style, 1 for new without block list and 2 for new with block list
|
|
initType = 2;
|
|
// setDebugLevel( DEBUG_1 );
|
|
allowExtend = 1;
|
|
}
|
|
|
|
/**
|
|
* Default Destructor
|
|
*/
|
|
FreeMgr::~FreeMgr()
|
|
{}
|
|
|
|
|
|
/**
|
|
*
|
|
* blank out all stats, set types and groups of null pointers in block zero
|
|
*/
|
|
const int FreeMgr::initBlockzero( DataBlock* blockZero)
|
|
{
|
|
IdxEmptyListEntry Pointer;
|
|
uint64_t blankVal = 0;
|
|
|
|
memset(blockZero->data, 0, sizeof(blockZero->data));
|
|
|
|
nullPtr( &Pointer );
|
|
Pointer.type = EMPTY_LIST;
|
|
|
|
Pointer.group = ENTRY_BLK;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_BLK), 8, &Pointer);
|
|
|
|
Pointer.group = ENTRY_32;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_32), 8, &Pointer);
|
|
|
|
Pointer.group = ENTRY_16;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_16), 8, &Pointer);
|
|
|
|
Pointer.group = ENTRY_8;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_8), 8, &Pointer);
|
|
|
|
Pointer.group = ENTRY_4;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_4), 8, &Pointer);
|
|
|
|
Pointer.group = ENTRY_2;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_2), 8, &Pointer);
|
|
|
|
Pointer.group = ENTRY_1;
|
|
setSubBlockEntry( blockZero->data, 0, calcPtrOffset(ENTRY_1 + ENTRY_1), 8, &Pointer);
|
|
|
|
//all stat locations are contiguous and after the pointers in block zero
|
|
|
|
for (int idx = calcStatOffset( ENTRY_1 ); idx < calcStatOffset( ENTRY_32 ) + 1; idx++)
|
|
{
|
|
setSubBlockEntry( blockZero->data, 0, idx, 8, &blankVal);
|
|
}
|
|
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
const int FreeMgr::init(CommBlock& cb, DataBlock* blockZero, int freemgrType, IdxTreeGroupType chainType, int startBlock, int numberBlocks)
|
|
{
|
|
|
|
/**
|
|
* Use this to allocate a group of blocks or sub blocks to a free list
|
|
* startBlock is fbo NOT lbid
|
|
* This allows us to use a simple for loop to traverese the full range of blocks
|
|
*
|
|
**/
|
|
|
|
int blkIdx, sbIdx;
|
|
int rc;
|
|
IdxEmptyListEntry emptyEntry; // populate the chains with pointer to empty entries
|
|
FILE* indexFile;
|
|
|
|
indexFile = cb.file.pFile;
|
|
|
|
nullPtr(&emptyEntry);
|
|
emptyEntry.type = EMPTY_PTR;
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("\nNew style Init v2, file: %u startBlock: %i num: %i \n", cb.file.oid, (unsigned int)startBlock, (unsigned int)numberBlocks);
|
|
}
|
|
|
|
int lastBlock = numberBlocks + startBlock;
|
|
|
|
if (chainType == ENTRY_BLK)
|
|
{
|
|
emptyEntry.group = ENTRY_BLK;
|
|
|
|
for ( blkIdx = lastBlock ; blkIdx > startBlock ; blkIdx-- )
|
|
{
|
|
// if( isDebug( DEBUG_1 )) { printf("Initing block %u\n", blkIdx-1);}
|
|
emptyEntry.fbo = mapLBID( cb, blkIdx - 1, rc ); // map fbo to lbid before storage
|
|
|
|
if (rc != NO_ERROR )
|
|
{
|
|
printf("DBG: Init 1: Error resolving LBID for OID: %u FBO: %u\n", cb.file.oid, blkIdx - 1 );
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
cout << "DBG: Working on block " << emptyEntry.fbo << "\n";
|
|
}
|
|
|
|
emptyEntry.sbid = 0;
|
|
emptyEntry.type = EMPTY_PTR;
|
|
rc = releaseSegment( cb, blockZero, freemgrType, chainType, &emptyEntry );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("Error releasing sb\n");
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (chainType == ENTRY_32 )
|
|
{
|
|
|
|
emptyEntry.group = ENTRY_32;
|
|
|
|
for ( blkIdx = lastBlock ; blkIdx > startBlock ; blkIdx-- )
|
|
{
|
|
// if( isDebug( DEBUG_1 )) { printf("Initing block %u\n", blkIdx-1);}
|
|
emptyEntry.fbo = mapLBID( cb, blkIdx - 1, rc ); // map fbo to lbid before storage
|
|
|
|
if (rc != NO_ERROR )
|
|
{
|
|
printf("DBG: Init 2: Error resolving LBID for OID: %u FBO: %u\n", cb.file.oid, blkIdx - 1 );
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
cout << "DBG: Working on block " << emptyEntry.fbo << "\n";
|
|
}
|
|
|
|
for (sbIdx = BYTE_PER_BLOCK / BYTE_PER_SUBBLOCK - 1; sbIdx > -1; sbIdx--)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Working on subblock %u\n", sbIdx);
|
|
}
|
|
|
|
emptyEntry.sbid = sbIdx;
|
|
emptyEntry.type = EMPTY_PTR;
|
|
rc = releaseSubblock( cb, blockZero, freemgrType, &emptyEntry );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("Error releasing sb\n");
|
|
return rc;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Invalid segment size %i (should be ENTRY_32 or ENTRY_BLK)\n", chainType);
|
|
}
|
|
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
// now write sb0 back to disk
|
|
uint64_t lbid = mapLBID( cb, 0, rc);
|
|
|
|
if (rc != NO_ERROR )
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
rc = writeDBFile( cb, blockZero, lbid );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
/***********************************************************
|
|
* DESCRIPTION:
|
|
* Initializes free space lists in an new index file
|
|
* PARAMETERS:
|
|
* indexFile - file pointer for new index file
|
|
* freemgr_type - type of free mgr to init
|
|
* RETURN:
|
|
* NO_ERROR if success
|
|
*
|
|
***********************************************************/
|
|
|
|
|
|
const int FreeMgr::init( CommBlock& cb, int freemgrType)
|
|
{
|
|
|
|
/**
|
|
* Tree has 6 chains, (1,2,4,8,16,32 entries) starting at entry 1 in sb0 of block0
|
|
* List has 3 chains (4,32,1024 entries) starting at first entry of file
|
|
*
|
|
* Starting at Block 1, add each subblock after sb0 to the free list in sb0
|
|
* then go back and build the smaller chains on demand. This way we make sure all SBs
|
|
* are in a chain somewhere.. but this is not best behaviour when allocating blocks
|
|
*
|
|
**/
|
|
|
|
int rc; // return code from file ops
|
|
DataBlock blockZero;
|
|
DataBlock workBlock;
|
|
int sbIdx;
|
|
uint64_t blkIdx;
|
|
IdxEmptyListEntry emptyEntry; // populate the chains with pointer to empty entries
|
|
IdxEmptyListEntry nextPointer; // pointer at end of sub-block of pointers to emptyEntries
|
|
uint64_t numBlocks;
|
|
FILE* indexFile;
|
|
|
|
indexFile = cb.file.pFile;
|
|
|
|
if (!indexFile) // Make sure that we have non-null filehandle
|
|
{
|
|
// printf("DBG: File handle is null\n");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
if (freemgrType != TREE && freemgrType != LIST)
|
|
{
|
|
// printf("DBG: Bad type in freeMgr Init\n");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
numBlocks = getFileSize( indexFile ) / BYTE_PER_BLOCK ;
|
|
|
|
// printf ("DBG: File size: %lu Total blocks: %llu (%u)\n", getFileSize( indexFile ), numBlocks, BYTE_PER_BLOCK);
|
|
// printf ("DBG: Adding sub-blocks: %llu \n", numBlocks * 32);
|
|
|
|
// Clear the list of pointers in sb0
|
|
initBlockzero( &blockZero );
|
|
|
|
// initialize the non varying fields
|
|
nullPtr(&emptyEntry);
|
|
emptyEntry.type = EMPTY_PTR;
|
|
emptyEntry.group = ENTRY_32;
|
|
|
|
// nextPointer identifies next sub-block with empty pointers
|
|
// initially there is no next sub-block so zero it out
|
|
nullPtr(&nextPointer);
|
|
nextPointer.type = EMPTY_LIST;
|
|
nextPointer.group = ENTRY_32;
|
|
nextPointer.entry = ENTRY_PER_SUBBLOCK - 1; // last entry on the list.. think of the list as a stack
|
|
|
|
if (initType == 0)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("\nOld style init\n");
|
|
}
|
|
|
|
for ( blkIdx = numBlocks - 1; blkIdx > 0; blkIdx-- )
|
|
{
|
|
emptyEntry.fbo = blkIdx;// map fbo to lbid before storage
|
|
// emptyEntry.fbo = mapLBID( cb, blkIdx, rc );// map fbo to lbid before storage
|
|
// if (rc != NO_ERROR ){ printf("DBG: Error resolving LBID for OID: %u FBO: %llu\n", cb.file.oid, blkIdx-1 ); return rc; }
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
cout << "DBG: Working on block " << emptyEntry.fbo << "\n";
|
|
}
|
|
|
|
memset(workBlock.data, 0, sizeof(workBlock.data));
|
|
|
|
/**
|
|
* each block after zeroth block uses sb0 to store entry list
|
|
* first entry (#0) is the llp to additional sblks with entries
|
|
* entries 1-31 are pointers
|
|
**/
|
|
|
|
// sb0 is used for initial map, so start at sb1
|
|
for (sbIdx = 1; sbIdx < BYTE_PER_BLOCK / BYTE_PER_SUBBLOCK; sbIdx++)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Working on subblock %u\n", sbIdx);
|
|
}
|
|
|
|
emptyEntry.sbid = sbIdx;
|
|
emptyEntry.type = EMPTY_PTR;
|
|
// store pointer in sb0 - replace this with a releaseSubblock call
|
|
setSubBlockEntry( workBlock.data, 0, sbIdx, 8, &emptyEntry);
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Init sb fbo " << emptyEntry.fbo << " sbid " << emptyEntry.sbid << " entry " << emptyEntry.entry << "\n";
|
|
}
|
|
}
|
|
|
|
// having stored all pointers, store linkptr
|
|
setSubBlockEntry( workBlock.data, 0, 0, 8, &nextPointer);
|
|
// nextPointer.fbo = mapLBID( cb, blkIdx, rc ); // remember this block ID
|
|
nextPointer.fbo = blkIdx; // remember this block ID
|
|
// if (rc != NO_ERROR ){ printf("DBG: Error resolving LBID for OID: %u FBO: %llu\n", cb.file.oid, blkIdx-1 ); return rc; }
|
|
|
|
rc = writeDBFile( cb, workBlock.data, emptyEntry.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
}
|
|
|
|
// chain for segments of sub block size
|
|
setSubBlockEntry( blockZero.data, 0, calcPtrOffset(ENTRY_32), 8, &nextPointer);
|
|
|
|
/**
|
|
* the next algorithm uses the release sub-block method and does not layout the map on particular boundaries.
|
|
**/
|
|
|
|
}
|
|
else if (initType == 1) // new style - use release
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("\nNew style\n");
|
|
}
|
|
|
|
for ( blkIdx = numBlocks - 1; blkIdx > 0; blkIdx-- )
|
|
{
|
|
|
|
emptyEntry.fbo = blkIdx;// map fbo to lbid before storage
|
|
|
|
// emptyEntry.fbo = mapLBID( cb, blkIdx, rc );// map fbo to lbid before storage
|
|
// if (rc != NO_ERROR ){ printf("DBG: Error resolving LBID for OID: %u FBO: %llu\n", cb.file.oid, blkIdx-1 ); return rc; }
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
cout << "DBG: Working on block " << emptyEntry.fbo << "\n";
|
|
}
|
|
|
|
memset(workBlock.data, 0, sizeof(workBlock.data));
|
|
|
|
for (sbIdx = BYTE_PER_BLOCK / BYTE_PER_SUBBLOCK - 1; sbIdx > -1; sbIdx--)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Working on subblock %u\n", sbIdx);
|
|
}
|
|
|
|
emptyEntry.sbid = sbIdx;
|
|
emptyEntry.type = EMPTY_PTR;
|
|
// store pointer in sb0 - replace this with a releaseSubblock call
|
|
rc = releaseSubblock( cb, &blockZero, freemgrType, &emptyEntry );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("Error releasing sb\n");
|
|
return rc;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* the next algorithm uses the release sub-block method and does not layout the map on particular boundaries.
|
|
* It also allows pieces to be allocated
|
|
**/
|
|
|
|
|
|
}
|
|
else if (initType == 2)
|
|
{
|
|
/** The following calls to init accept FBO not LBID..
|
|
* This makes it easier to work on a range of blocks
|
|
**/
|
|
// use the first block of the new range for sub-block chain
|
|
// and the rest for block chain
|
|
rc = init( cb, &blockZero, freemgrType, ENTRY_32, 1, 50);
|
|
|
|
if ( rc != NO_ERROR )
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
rc = init( cb, &blockZero, freemgrType, ENTRY_BLK, 51, numBlocks - 52);
|
|
|
|
if ( rc != NO_ERROR )
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
}
|
|
|
|
// now write sb0 back to disk
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
printf("Writing SB0 back to disk\n");
|
|
printMemSubBlock( &blockZero, 0 );
|
|
}
|
|
|
|
uint64_t lbid = mapLBID( cb, 0, rc);
|
|
|
|
if (rc != NO_ERROR )
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
rc = writeDBFile( cb, blockZero.data, lbid );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
|
|
}
|
|
|
|
/**
|
|
* DESCRIPTION:
|
|
* Assign segment- public method used to get a free segment for use
|
|
* PARAMETERS:
|
|
* indexFile - file pointer
|
|
* blockZero - in memory copy of blockZero
|
|
* freemgr_type - either TREE or LIST
|
|
* segmentType - group type
|
|
* assignPtr - the assigned ptr
|
|
*
|
|
* RETURN:
|
|
* NO_ERROR if success
|
|
* error no if fail
|
|
**/
|
|
|
|
const int FreeMgr::assignSegment( CommBlock& cb, DataBlock* blockZero, const int freemgr_type, const IdxTreeGroupType segmentType, IdxEmptyListEntry* assignPtr )
|
|
{
|
|
int rc; // return code from file ops
|
|
DataBlock workBlock;
|
|
int listOffset; // entry in block zero of head pointer
|
|
IdxEmptyListEntry emptyEntry;
|
|
IdxEmptyListEntry emptyPtr;
|
|
IdxEmptyListEntry emptyMap;
|
|
uint64_t numBlocks;
|
|
IdxEmptyListEntry newSb;
|
|
FILE* indexFile;
|
|
|
|
indexFile = cb.file.pFile;
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Assign ENTRY_%i segment in %s\n", 1 << (unsigned int)segmentType, (freemgr_type == LIST) ? "LIST" : "TREE");
|
|
}
|
|
|
|
/* Check all input parameters are ok */
|
|
if (!blockZero)
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf ("DBG: Bad pointer: blockZero is zero\n");
|
|
}
|
|
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
if (!assignPtr)
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf ("DBG: Bad pointer: assignPtr is zero\n");
|
|
}
|
|
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
if (freemgr_type != TREE && freemgr_type != LIST)
|
|
{
|
|
if ( isDebug( DEBUG_0 ))
|
|
{
|
|
printf ("DBG: assignSegment: Must be TREE or LIST\n");
|
|
}
|
|
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
numBlocks = getFileSize( indexFile ) / BYTE_PER_BLOCK ;
|
|
|
|
//find the start of the chain
|
|
if (segmentType == ENTRY_32)
|
|
{
|
|
rc = assignSubblock( cb, blockZero, freemgr_type, assignPtr);
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Error assigning sb (rc=%i)\n", rc);
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
listOffset = calcPtrOffset( segmentType );
|
|
|
|
if (freemgr_type == LIST && !(segmentType == ENTRY_4 || segmentType == ENTRY_BLK))
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Assign segment size illegal %i\n", (unsigned int)segmentType);
|
|
}
|
|
|
|
return ERR_INVALID_PARAM; // should not have got here so quit with error
|
|
}
|
|
|
|
// read Empty Map in sb0
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Empty map ENTRY_" << (1 << segmentType) << " was fbo " << emptyPtr.fbo << " sbid " << (unsigned int)emptyPtr.sbid << " entry " << (unsigned int)emptyPtr.entry << "\n";
|
|
}
|
|
|
|
/* if (emptyPtr.fbo > numBlocks)
|
|
{
|
|
printf("DBG: Weirdness in assignSegment.. emptyPtr.fbo > numBlocks\n");
|
|
return ERR_FM_BAD_FBO;
|
|
}*/
|
|
|
|
// check to see if queue has been built
|
|
// if not then assign a container block, add LLP in entry 0 pointing to nothing
|
|
if (emptyPtr.fbo == 0)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Need to add sb to chain and entries to sb\n");
|
|
}
|
|
|
|
// cannot assign more space to block list from a smaller list.. need to extend the file
|
|
if ( segmentType == ENTRY_BLK )
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("Out of space in BLOCK list, quitting\n");
|
|
}
|
|
|
|
rc = extendFreespace( cb, blockZero, freemgr_type );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Error extending file\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
rc = assignSubblock( cb, blockZero, freemgr_type, &emptyPtr);
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("DBG: Error extending chain\n");
|
|
return rc;
|
|
}
|
|
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR) /*printf("DBG: Error reading newly allocated sb\n");*/
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
// update map to point to new bucket
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr);
|
|
|
|
nullPtr(&emptyEntry);
|
|
emptyEntry.type = EMPTY_LIST;
|
|
emptyEntry.group = segmentType;
|
|
|
|
setSubBlockEntry( workBlock.data, emptyPtr.sbid, 0, 8, &emptyEntry); // store head ptr
|
|
|
|
rc = writeDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Added fbo " << emptyPtr.fbo << " sbid " << (unsigned int)emptyPtr.sbid << " as bucket to chain ENTRY_" << (1 << segmentType) << "in" << ((freemgr_type == LIST) ? "LIST" : "TREE") << "\n";
|
|
}
|
|
}
|
|
|
|
// follow the chain to the head container
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
cout << "DBG: Error reading block (" << emptyPtr.fbo << ") during segmentAssign: rc is " << rc;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
getSubBlockEntry( &workBlock, emptyPtr.sbid, emptyPtr.entry, 8, &emptyEntry );
|
|
|
|
if ((emptyEntry.type != EMPTY_LIST) && (emptyEntry.type != EMPTY_PTR))
|
|
{
|
|
if ( isDebug( DEBUG_0 ))
|
|
{
|
|
printf("WTF: Bad entry in ENTRY_%i chain - type is %i (expected %i or %i)\n", 1 << segmentType, (unsigned int)emptyEntry.type, EMPTY_PTR, EMPTY_LIST );
|
|
printMemSubBlock( &workBlock, emptyPtr.sbid );
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: fbo " << emptyEntry.fbo << " sbid " << (unsigned int)emptyEntry.sbid << " entry " << (unsigned int)emptyEntry.entry << " chain ENTRY_" << (1 << segmentType) << "in" << ((freemgr_type == LIST) ? "LIST" : "TREE") << "\n";
|
|
}
|
|
|
|
return ERR_FM_BAD_TYPE;
|
|
}
|
|
|
|
if ((emptyEntry.fbo == 0) && (emptyEntry.type == EMPTY_PTR))
|
|
{
|
|
if ( isDebug( DEBUG_0 ))
|
|
{
|
|
printf("DBG: Bad entry in %i list - found EMPTY_PTR but indicates block 0\n", 1 << segmentType );
|
|
}
|
|
|
|
return ERR_FM_BAD_TYPE;
|
|
}
|
|
|
|
if ((emptyEntry.fbo == 0) && (emptyEntry.type == EMPTY_LIST))
|
|
{
|
|
/**
|
|
* if at the end of the rainbow, in a bucket with no entries, fill the bucket
|
|
* Allocate a sub block and split it into parts
|
|
**/
|
|
|
|
// cannot assign more space to block list from a smaller list.. need to extend the file
|
|
if ( segmentType == ENTRY_BLK )
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("\nNeed to extend block\n");
|
|
}
|
|
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("Out of space in BLOCK list\n");
|
|
}
|
|
|
|
rc = extendFreespace( cb, blockZero, freemgr_type );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Error extending file\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
getSubBlockEntry( &workBlock, emptyPtr.sbid, emptyPtr.entry, 8, &emptyEntry );
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
rc = assignSubblock( cb, blockZero, freemgr_type, &newSb);
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
// printf("DBG: Error extending chain\n");
|
|
return rc;
|
|
}
|
|
|
|
if (newSb.entry != 0)
|
|
{
|
|
printf("WTF: Entry should be 0 after assign from sb list, instead is %i", (unsigned int)newSb.entry);
|
|
return ERR_FM_ASSIGN_ERR;
|
|
}
|
|
|
|
if (isDebug(DEBUG_2))
|
|
{
|
|
cout << "DBG: added fbo " << newSb.fbo << " sbid " << (unsigned int)newSb.sbid << " entry " << (unsigned) newSb.entry << " to " << segmentType << " list - need to split " << (1 << (ENTRY_32 - segmentType)) << "times\n";
|
|
}
|
|
|
|
newSb.entry = 0;
|
|
newSb.group = segmentType;
|
|
newSb.type = EMPTY_PTR;
|
|
emptyEntry = newSb;
|
|
|
|
int idx, inc;
|
|
inc = 1 << segmentType;
|
|
|
|
for (idx = 0; idx < ENTRY_PER_SUBBLOCK - inc; idx += inc)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf ("DBG: split..%i-%i\n", idx, idx + inc - 1 );
|
|
}
|
|
|
|
newSb.entry = idx;
|
|
releaseSegment( cb, blockZero, freemgr_type, segmentType, &newSb );
|
|
}
|
|
|
|
emptyEntry.entry = idx;
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf ("DBG: split and return..%i-%i\n", idx, idx + inc - 1);
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Assigned fbo " << emptyEntry.fbo << " sbid " << (unsigned int)emptyEntry.sbid << " entry " << (unsigned int)emptyEntry.entry << " to chain ENTRY_" << (1 << segmentType) << "\n";
|
|
}
|
|
|
|
memcpy(assignPtr, &emptyEntry, 8);
|
|
|
|
uint64_t count;
|
|
getSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
count--;
|
|
setSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* got here because we didn't need to populate a chain and did not fall into any traps
|
|
* so either we are at the end of bucket or we have a valid entry
|
|
**/
|
|
if (emptyEntry.type == EMPTY_LIST) // reached end of this segment (should release it for re-use)
|
|
{
|
|
/**
|
|
* release bucket
|
|
**/
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Need to release sb fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " from chain ENTRY_" << (1 << segmentType) << " in " << ((freemgr_type == LIST) ? "LIST" : "TREE") << "\n";
|
|
}
|
|
|
|
// when we stored the ptr in the empty map, we tweaked group, must change it back
|
|
emptyPtr.type = EMPTY_PTR;
|
|
emptyPtr.group = ENTRY_32;
|
|
rc = releaseSubblock( cb, blockZero, freemgr_type, &emptyPtr );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("Error releasing sb\n");
|
|
return rc;
|
|
}
|
|
|
|
emptyPtr = emptyEntry;
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("DBG: Error following chain\n");
|
|
return rc;
|
|
}
|
|
|
|
getSubBlockEntry( &workBlock, emptyPtr.sbid, emptyPtr.entry, 8, &emptyEntry );
|
|
|
|
}
|
|
|
|
if (emptyEntry.type == EMPTY_PTR)
|
|
{
|
|
|
|
emptyPtr.entry--;
|
|
blockZero->dirty = 1;
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Empty entry is now %u\n", (unsigned int)emptyPtr.entry);
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Assigned fbo " << emptyEntry.fbo << " sbid " << emptyEntry.sbid << " entry " << emptyEntry.entry << " from chain ENTRY_" << (1 << segmentType) << "\n";
|
|
cout << "DBG: Empty map ENTRY_" << (1 << segmentType) << " now fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
memcpy(assignPtr, &emptyEntry, 8);
|
|
|
|
// -- workblock may have changed on disk since it was read.. making the writeDBfile dangerous without a readDBfile first
|
|
nullPtr(&emptyMap); // zero out the entry
|
|
readDBFile( cb, &workBlock, emptyPtr.fbo );
|
|
setSubBlockEntry( workBlock.data, emptyPtr.sbid, emptyPtr.entry + 1, 8, &emptyMap );
|
|
rc = writeDBFile( cb, &workBlock, emptyPtr.fbo );
|
|
// --
|
|
|
|
uint64_t count;
|
|
getSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
count--;
|
|
setSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return ERR_FM_ASSIGN_ERR;
|
|
}
|
|
|
|
/**
|
|
* DESCRIPTION:
|
|
* Assign sub-block - private method used to manage sub-blocks in list
|
|
* PARAMETERS:
|
|
* indexFile - file pointer
|
|
* blockZero - in memory copy of blockZero
|
|
* freemgr_type - either TREE or LIST
|
|
* assignPtr - the assigned ptr
|
|
*
|
|
* RETURN:
|
|
* NO_ERROR if success
|
|
* error no if fail
|
|
**/
|
|
|
|
const int FreeMgr::assignSubblock( CommBlock& cb, DataBlock* blockZero, const int freemgrType, IdxEmptyListEntry* assignPtr )
|
|
{
|
|
int rc; // return code from file ops
|
|
DataBlock workBlock, tempBlock;
|
|
int listOffset; // entry in block zero of head pointer
|
|
IdxEmptyListEntry emptyEntry;
|
|
IdxEmptyListEntry emptyPtr, emptyMap;
|
|
IdxEmptyListEntry newBlock;
|
|
uint64_t numBlocks;
|
|
FILE* indexFile;
|
|
|
|
indexFile = cb.file.pFile;
|
|
|
|
/**
|
|
* Separated subblock assignment out from general segment assignment
|
|
* Reduces the hoops to jump through
|
|
**/
|
|
|
|
numBlocks = getFileSize( indexFile ) / BYTE_PER_BLOCK ;
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: Assign subblock \n");
|
|
}
|
|
|
|
//find the start of the chain
|
|
listOffset = calcPtrOffset( ENTRY_32 );
|
|
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: EM (start assign) sb fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
if (emptyPtr.type != EMPTY_LIST )
|
|
{
|
|
return ERR_FM_BAD_TYPE;
|
|
}
|
|
|
|
// if (emptyPtr.fbo > numBlocks)
|
|
// {
|
|
// if( isDebug( DEBUG_1 )) { printf("DBG: Weirdness in assignSubblock.. emptyPtr.fbo > numBlocks\n"); }
|
|
// return ERR_FM_BAD_FBO;
|
|
// }
|
|
|
|
// follow the chain to the empty entry
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
// printf("DBG: RC Weirdness: rc is %i", rc);
|
|
return rc;
|
|
}
|
|
|
|
getSubBlockEntry( &workBlock, emptyPtr.sbid, emptyPtr.entry, 8, &emptyEntry );
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Next avail sb fbo " << emptyEntry.fbo << " sbid " << " entry " << emptyEntry.entry << "\n";
|
|
}
|
|
|
|
if (emptyEntry.fbo == 0) // then nowhere to go.. exit
|
|
{
|
|
//if( isDebug( DEBUG_1 )) { printf("DBG: No space in subblock list\n"); }
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: fbo " << emptyEntry.fbo << " sbid " << emptyEntry.sbid << " entry " << emptyEntry.entry << "\n";
|
|
}
|
|
|
|
//-- try and assign from BLOCK list
|
|
// printf("Go ask for a block\n");
|
|
rc = assignSegment( cb, blockZero, freemgrType, ENTRY_BLK, &newBlock);
|
|
|
|
// rc = extendFreespace( indexFile, blockZero, freemgrType );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Could not get block from block list\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
// got a block so now split it
|
|
newBlock.entry = 0;
|
|
newBlock.group = ENTRY_32;
|
|
newBlock.type = EMPTY_PTR;
|
|
emptyEntry = newBlock;
|
|
|
|
//-- assign almost all sub blocks - keep last one
|
|
int sbIdx;
|
|
|
|
for (sbIdx = BYTE_PER_BLOCK / BYTE_PER_SUBBLOCK - 1; sbIdx > 0; sbIdx--)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
cout << "DBG: Working on fbo " << newBlock.fbo << " sbid " << sbIdx << "\n";
|
|
}
|
|
|
|
emptyEntry.sbid = sbIdx;
|
|
emptyEntry.type = EMPTY_PTR;
|
|
rc = releaseSubblock( cb, blockZero, freemgrType, &emptyEntry );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("DBG: Error releasing sb\n");
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
emptyEntry.sbid = 0;
|
|
}
|
|
|
|
if ((emptyEntry.type != EMPTY_LIST) && (emptyEntry.type != EMPTY_PTR))
|
|
{
|
|
if ( isDebug( DEBUG_0 ))
|
|
{
|
|
printf("WTF: Bad entry in in subblock list- type is %i (expected %i or %i)\n", (unsigned int)emptyEntry.type, EMPTY_PTR, EMPTY_LIST);
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: fbo " << emptyEntry.fbo << " sbid " << emptyEntry.sbid << " entry " << emptyEntry.entry << "\n";
|
|
}
|
|
|
|
return ERR_FM_BAD_TYPE;
|
|
}
|
|
|
|
if (emptyEntry.type == EMPTY_PTR)
|
|
{
|
|
// this is what we expect normally
|
|
emptyPtr.entry--; // only decrement if we didn't just drain a bucket
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
memcpy(assignPtr, &emptyEntry, 8);
|
|
|
|
}
|
|
else if (emptyEntry.type == EMPTY_LIST && emptyPtr.entry == 0 )
|
|
{
|
|
if (emptyPtr.entry > 0) printf("\nWTF!! %i\n", (unsigned int) emptyPtr.entry);
|
|
|
|
// reached end of this bucket (should release it for re-use)
|
|
// this is not the typical case..
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
cout << "DBG: Drained bucket sb fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
//blank the llp
|
|
rc = readDBFile( cb, tempBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_1 ))
|
|
{
|
|
cout << "DBG: File error during releaseSubblock, fbo/lbid: " << emptyPtr.fbo << "\n";
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
nullPtr(&emptyMap); // zero out the entry
|
|
|
|
setSubBlockEntry( tempBlock.data, emptyPtr.sbid, 0, 8, &emptyMap );
|
|
rc = writeDBFile( cb, &tempBlock, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
memcpy(assignPtr, &emptyPtr, 8);
|
|
assignPtr->type = EMPTY_PTR;
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Change head pointer to fbo " << emptyEntry.fbo << " sbid " << emptyEntry.sbid << " entry " << emptyEntry.entry << "\n";
|
|
}
|
|
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &emptyEntry );
|
|
}
|
|
else
|
|
{
|
|
printf("DBG: Weirdness - not list and not ptr\n");
|
|
}
|
|
|
|
// printf("DBG: Assigned sb fbo %llu sbid %u entry %u\n", assignPtr->fbo, (unsigned int)assignPtr->sbid, (unsigned int)assignPtr->entry);
|
|
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyMap );
|
|
|
|
if (isDebug(DEBUG_3))
|
|
{
|
|
cout << "DBG: EM (sb assign 1) sb fbo " << emptyMap.fbo << " sbid " << emptyMap.sbid << " entry " << emptyMap.entry << "\n";
|
|
}
|
|
|
|
blockZero->dirty = 1;
|
|
|
|
uint64_t count;
|
|
getSubBlockEntry( blockZero, 0, calcStatOffset(ENTRY_32), 8, &count );
|
|
count--;
|
|
setSubBlockEntry( blockZero, 0, calcStatOffset(ENTRY_32), 8, &count );
|
|
|
|
|
|
// -- workblock may have changed on disk since it was read.. making the writeDBfile dangerous without a readDBfile first
|
|
nullPtr(&emptyMap); // zero out the entry
|
|
readDBFile( cb, &workBlock, emptyPtr.fbo );
|
|
setSubBlockEntry( workBlock.data, emptyPtr.sbid, emptyPtr.entry + 1, 8, &emptyMap );
|
|
rc = writeDBFile( cb, &workBlock, emptyPtr.fbo );
|
|
// --
|
|
// if( isDebug( DEBUG_3 )) { printf("DBG: Assign subblock -- all done\n"); }
|
|
|
|
return NO_ERROR;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* DESCRIPTION:
|
|
* Release a segment back to the list
|
|
* PARAMETERS:
|
|
* indexFile - file pointer
|
|
* blockZero - in memory copy of blockZero
|
|
* freemgr_type - either TREE or LIST
|
|
* segmentType - group type
|
|
* assignPtr - the assigned ptr
|
|
*
|
|
* RETURN:
|
|
* NO_ERROR if success
|
|
* error no if fail
|
|
**/
|
|
|
|
|
|
const int FreeMgr::releaseSegment( CommBlock& cb, DataBlock* blockZero, const int freemgr_type, const IdxTreeGroupType segmentType, IdxEmptyListEntry* assignPtr )
|
|
{
|
|
int rc; // return code from file ops
|
|
DataBlock workBlock;
|
|
DataBlock extraBlock;
|
|
int listOffset; // entry in block zero of head pointer
|
|
IdxEmptyListEntry emptyPtr;
|
|
IdxEmptyListEntry newSb;
|
|
uint64_t numBlocks;
|
|
FILE* indexFile;
|
|
|
|
indexFile = cb.file.pFile;
|
|
|
|
if (!assignPtr)
|
|
{
|
|
// printf ("DBG: Bad pointer: assignPtr is zero\n");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
if (!blockZero)
|
|
{
|
|
// printf ("DBG: Bad pointer: blockZero is zero\n");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: release ENTRY_%i segment \n", 1 << (unsigned int)segmentType);
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: releasing fbo " << assignPtr->fbo << " sbid " << assignPtr->sbid << " entry " << assignPtr->entry << " from " << ((freemgr_type == LIST) ? "LIST" : "TREE") << " chain ENTRY_" << (1 << segmentType) << " (type is " << ((assignPtr->type == EMPTY_PTR) ? "EMPTY_PTR" : "Not EMPTY_PTR") << ")\n";
|
|
}
|
|
|
|
numBlocks = getFileSize( indexFile ) / BYTE_PER_BLOCK ;
|
|
|
|
/* if (assignPtr->fbo > numBlocks)
|
|
{
|
|
if( isDebug( DEBUG_1 )) { printf("DBG: Weirdness in releaseSegment.. assignPtr.fbo > numBlocks (%llu %llu)\n", assignPtr->fbo, numBlocks );};
|
|
return ERR_FM_BAD_FBO;
|
|
}*/
|
|
|
|
if (assignPtr->type != EMPTY_PTR)
|
|
{
|
|
// printf("DBG: Weirdness in releaseSegment.. tried to return a pointer with type %i (expected %i)\n", (unsigned int)assignPtr->type, EMPTY_PTR );
|
|
assignPtr->type = EMPTY_PTR;
|
|
// return ERR_FM_BAD_TYPE; // do not exit
|
|
}
|
|
|
|
if ( assignPtr->group != (uint64_t)segmentType )
|
|
{
|
|
// printf("DBG: Weirdness in releaseSegment.. tried to return a pointer from group %i to group %i\n", (unsigned int)assignPtr->group, segmentType );
|
|
return ERR_FM_RELEASE_ERR;
|
|
}
|
|
|
|
//find the start of the chain
|
|
if (segmentType == ENTRY_32)
|
|
{
|
|
rc = releaseSubblock( cb, blockZero, freemgr_type, assignPtr);
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
// printf("DBG: Error releasing sb\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
listOffset = calcPtrOffset( segmentType );
|
|
|
|
if (freemgr_type == LIST && !(segmentType == ENTRY_4 || segmentType == ENTRY_BLK))
|
|
{
|
|
printf("DBG: Assign segment size illegal %i\n", (unsigned int)segmentType);
|
|
return ERR_INVALID_PARAM; // should not have got here so quit with error
|
|
}
|
|
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
|
|
/* if (emptyPtr.fbo > numBlocks)
|
|
{
|
|
if( isDebug( DEBUG_1 )) { printf("DBG: Weirdness in releaseSegment.. emptyPtr.fbo > numBlocks (%llu %llu)\n", emptyPtr.fbo, numBlocks );}
|
|
return ERR_FM_BAD_FBO;
|
|
}*/
|
|
|
|
//sub block is full or chain never started
|
|
if (emptyPtr.entry == ENTRY_PER_SUBBLOCK - 1 || emptyPtr.fbo == 0)
|
|
{
|
|
if ( isDebug( DEBUG_3 ))
|
|
{
|
|
printf("DBG: No room in chain %i - need to add a sub-block\n", (unsigned int)segmentType);
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Empty ptr fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
//ask for a new sb to extend chain
|
|
rc = assignSubblock( cb, blockZero, freemgr_type, &newSb);
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
printf("DBG: Error extending chain\n");
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: release segment, new SB is fbo " << newSb.fbo << " sbid " << newSb.sbid << " entry " << newSb.entry << "\n";
|
|
}
|
|
|
|
rc = readDBFile( cb, extraBlock.data, newSb.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: File error during releaseSegment (3)\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
emptyPtr.type = EMPTY_LIST; // writing into the LLP field so set type accordingly
|
|
setSubBlockEntry( extraBlock.data, newSb.sbid, 0, 8, &emptyPtr );
|
|
setSubBlockEntry( extraBlock.data, newSb.sbid, 1, 8, assignPtr );
|
|
rc = writeDBFile( cb, &extraBlock, newSb.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: File error during releaseSegment (4)\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
newSb.entry = 1;
|
|
newSb.type = EMPTY_LIST;
|
|
newSb.group = segmentType;
|
|
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &newSb );
|
|
blockZero->dirty = 1;
|
|
|
|
uint64_t count;
|
|
getSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
count++;
|
|
setSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
|
|
|
|
return NO_ERROR ;
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
emptyPtr.entry++;
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: File error during releaseSegment\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Empty map ENTRY_" << ( 1 << segmentType) << " is fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
setSubBlockEntry( workBlock.data, emptyPtr.sbid, emptyPtr.entry, 8, assignPtr );
|
|
rc = writeDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
emptyPtr.type = EMPTY_LIST;
|
|
emptyPtr.group = segmentType;
|
|
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
blockZero->dirty = 1;//sub block is full or chain never started
|
|
|
|
}
|
|
|
|
uint64_t count;
|
|
getSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
count++;
|
|
setSubBlockEntry( blockZero, 0, calcStatOffset(segmentType), 8, &count );
|
|
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
const int FreeMgr::releaseSubblock( CommBlock& cb, DataBlock* blockZero, const int freemgr_type, IdxEmptyListEntry* assignPtr )
|
|
{
|
|
int rc; // return code from file ops
|
|
DataBlock workBlock;
|
|
DataBlock extraBlock;
|
|
int listOffset; // entry in block zero of head pointer
|
|
IdxEmptyListEntry emptyPtr, emptyMap ;
|
|
uint64_t numBlocks;
|
|
FILE* indexFile;
|
|
|
|
indexFile = cb.file.pFile;
|
|
/**
|
|
* Release sub-block - handle de-allocation of only sub-blocks
|
|
* This makes the assign/release code for smaller segments simpler and
|
|
* separates the tasks of handling the list containers and the list contents
|
|
* When called, we look at the bucket indicated as head of chain and if it full
|
|
* or not present (no room left in chain) then insert the returned SB as a bucket and
|
|
* move the head pointer
|
|
**/
|
|
|
|
|
|
//if( isDebug( DEBUG_1 )) { printf("DBG: releaseSubblock\n"); }
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: releasing sb fbo " << assignPtr->fbo << " sbid " << assignPtr->sbid << " entry " << assignPtr->entry << " from " << ((freemgr_type == LIST) ? "LIST" : "TREE") << " (type is " << ((assignPtr->type == EMPTY_PTR) ? "EMPTY_PTR" : "Not EMPTY_PTR") << ")\n";
|
|
}
|
|
|
|
if (!assignPtr)
|
|
{
|
|
// printf ("DBG: Bad pointer: assignPtr is zero\n");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
if (!blockZero)
|
|
{
|
|
printf ("DBG: Bad pointer: pointer for blockZero is zero\n");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
numBlocks = getFileSize( indexFile ) / BYTE_PER_BLOCK ;
|
|
|
|
/* if (assignPtr->fbo > numBlocks)
|
|
{
|
|
if( isDebug( DEBUG_1 )) { printf("DBG: Weirdness in releaseSubblock.. assignPtr.fbo > numBlocks (%llu %llu)\n", assignPtr->fbo, numBlocks );}
|
|
return ERR_FM_BAD_FBO;
|
|
}*/
|
|
if (assignPtr->type != EMPTY_PTR)
|
|
{
|
|
printf("DBG: Weirdness in releaseSubblock.. tried to return a pointer with type %i (expected %i)\n", (unsigned int)assignPtr->type, EMPTY_PTR );
|
|
return ERR_FM_BAD_TYPE;
|
|
}
|
|
|
|
if ( assignPtr->group != ENTRY_32 )
|
|
{
|
|
printf("DBG: Weirdness in releaseSubblock.. tried to return a pointer from group %i to subblock group\n", (unsigned int)assignPtr->group );
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
|
|
//find the start of the chain
|
|
listOffset = calcPtrOffset( ENTRY_32 );
|
|
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: EM (sb release 1) sb fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
//sub block is full or chain empty
|
|
if (emptyPtr.entry == ENTRY_PER_SUBBLOCK - 1 || emptyPtr.fbo == 0)
|
|
{
|
|
// change type from EMPTY_PTR to EMPTY_LIST
|
|
assignPtr->type = EMPTY_LIST;
|
|
|
|
//if( isDebug( DEBUG_1 )) { printf("DBG: No room in subblock chain - need to add a sub-block\n"); }
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Change head pointer to fbo " << assignPtr->fbo << " sbid " << assignPtr->sbid << " entry " << assignPtr->entry << "\n";
|
|
}
|
|
|
|
// change head pointer to released segment
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, assignPtr );
|
|
blockZero->dirty = 1;
|
|
|
|
// read in released segment to set llp of new block to point to current head of chain
|
|
rc = readDBFile( cb, extraBlock.data, assignPtr->fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_1 ))
|
|
{
|
|
cout << "DBG: File error during releaseSegment (2), rc: " << rc << " fbo/lbid: " << assignPtr->fbo << "\n";
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: Set LLP for fbo " << assignPtr->fbo << " sbid " << assignPtr->sbid << " entry " << assignPtr->entry << "to fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3))
|
|
{
|
|
printf("Before\n");
|
|
printMemSubBlock( &extraBlock, assignPtr->sbid );
|
|
}
|
|
|
|
emptyPtr.type = EMPTY_LIST;
|
|
//memset( extraBlock.data, 0, BYTE_PER_SUBBLOCK);
|
|
setSubBlockEntry( extraBlock.data, assignPtr->sbid, 0, 8, &emptyPtr );
|
|
rc = writeDBFile( cb, &extraBlock, assignPtr->fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
getSubBlockEntry( blockZero, 0, listOffset, 8, &emptyMap );
|
|
cout << "DBG: EM (sb release 2) sb fbo " << emptyMap.fbo << " sbid " << emptyMap.sbid << " entry " << emptyMap.entry << "\n";
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3))
|
|
{
|
|
printf("After\n");
|
|
printMemSubBlock( &extraBlock, assignPtr->sbid );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
emptyPtr.entry++;
|
|
rc = readDBFile( cb, workBlock.data, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: File error during releaseSubblock\n");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3))
|
|
{
|
|
printf("Before\n");
|
|
printMemSubBlock( &workBlock, emptyPtr.sbid );
|
|
}
|
|
|
|
setSubBlockEntry( workBlock.data, emptyPtr.sbid, emptyPtr.entry, 8, assignPtr );
|
|
rc = writeDBFile( cb, &workBlock, emptyPtr.fbo );
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_2 ))
|
|
{
|
|
cout << "DBG: setting emptyPtr sb fbo " << emptyPtr.fbo << " sbid " << emptyPtr.sbid << " entry " << emptyPtr.entry << "\n";
|
|
}
|
|
|
|
if ( isDebug( DEBUG_3))
|
|
{
|
|
printf("After\n");
|
|
printMemSubBlock( &workBlock, emptyPtr.sbid );
|
|
}
|
|
|
|
emptyPtr.type = EMPTY_LIST;
|
|
emptyPtr.group = ENTRY_32;
|
|
|
|
setSubBlockEntry( blockZero, 0, listOffset, 8, &emptyPtr );
|
|
blockZero->dirty = 1;
|
|
|
|
}
|
|
|
|
uint64_t count;
|
|
|
|
getSubBlockEntry( blockZero, 0, calcStatOffset(ENTRY_32), 8, &count );
|
|
count++;
|
|
setSubBlockEntry( blockZero, 0, calcStatOffset(ENTRY_32), 8, &count );
|
|
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
const void FreeMgr::nullPtr(WriteEngine::IdxEmptyListEntry* assignPtr ) const
|
|
{
|
|
|
|
|
|
assignPtr->fbo = 0;
|
|
assignPtr->sbid = 0;
|
|
assignPtr->entry = 0;
|
|
assignPtr->type = 0;
|
|
assignPtr->group = 0;
|
|
assignPtr->spare = 0;
|
|
assignPtr->spare2 = 0;
|
|
}
|
|
|
|
/**
|
|
* extendFreeSpace - Having reached the end of the available freespace or exhausted the block/subblock chain
|
|
* add extra space by extending the file and calling the Init function for the new space
|
|
*
|
|
* @param indexFile
|
|
* @param blockZero
|
|
* @param freemgrType
|
|
* @return
|
|
*/
|
|
const int FreeMgr::extendFreespace( CommBlock& cb, DataBlock* blockZero, int freemgrType )
|
|
{
|
|
DataBlock workBlock;
|
|
int rc = NO_ERROR; // result code from file ops
|
|
FILE* indexFile;
|
|
int allocSize = 0;
|
|
|
|
indexFile = cb.file.pFile;
|
|
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf ("Extending File\n");
|
|
}
|
|
|
|
int numBlocks = 1024; // default number - should ask BRM for extentsize
|
|
int currSize = getFileSize( indexFile ) / BYTE_PER_BLOCK ;
|
|
|
|
if (!allowExtend)
|
|
{
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Extension denied\n");
|
|
}
|
|
|
|
return ERR_FM_EXTEND;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Extending free space in file\n");
|
|
}
|
|
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: File is currently: %i blocks Asking for: %i blocks\n", currSize, numBlocks);
|
|
}
|
|
|
|
#ifdef BROKEN_BY_MULTIPLE_FILES_PER_OID
|
|
rc = extendFile( indexFile, cb.file.oid, numBlocks, allocSize, 0, 8, false );
|
|
#endif
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
if ( isDebug( DEBUG_1 ))
|
|
{
|
|
printf("DBG: Extended file by %i blocks\n", allocSize);
|
|
}
|
|
|
|
|
|
rc = init( cb, blockZero, freemgrType, ENTRY_32, currSize, 50 );
|
|
|
|
if ( rc != NO_ERROR )
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
rc = init( cb, blockZero, freemgrType, ENTRY_BLK, currSize + 50, allocSize - 50 );
|
|
|
|
if ( rc != NO_ERROR )
|
|
{
|
|
return rc;
|
|
}
|
|
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/**
|
|
* Quick utility function to map LBID if BRM in use, return original FBO otherwise
|
|
* @param cb
|
|
* @param fbo
|
|
* @return
|
|
*/
|
|
const uint64_t FreeMgr::mapLBID( CommBlock& cb, const uint64_t fbo, int& rc )
|
|
{
|
|
uint64_t lbid = 0;
|
|
|
|
rc = NO_ERROR;
|
|
#ifdef BROKEN_BY_MULTIPLE_FILES_PER_OID
|
|
rc = BRMWrapper::getInstance()->getBrmInfo( cb.file.oid, fbo, lbid );
|
|
#endif
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if (isDebug( DEBUG_0 ))
|
|
{
|
|
cout << "BRM Failure looking up lbid for oid: " << cb.file.oid << " fbo: " << fbo << ", returning unchanged value\n";
|
|
}
|
|
|
|
return fbo;
|
|
}
|
|
else
|
|
{
|
|
return lbid;
|
|
}
|
|
}
|
|
|
|
|
|
const void FreeMgr::printMemSubBlock( DataBlock* curBlock, const int sbid )
|
|
{
|
|
int off;
|
|
// DataBlock curBlock;
|
|
unsigned char* curPos;
|
|
IdxEmptyListEntry curEntry, testZero;
|
|
|
|
nullPtr( &testZero );
|
|
// readDBFile( m_pTreeFile, &curBlock, fbo );
|
|
curPos = curBlock->data + BYTE_PER_SUBBLOCK * sbid;
|
|
printf( "\n======================== sbid: %i", sbid );
|
|
|
|
for ( int i = 0; i < ENTRY_PER_SUBBLOCK; i++ )
|
|
{
|
|
memcpy( &curEntry, curPos, MAX_COLUMN_BOUNDARY );
|
|
off = memcmp( &testZero, &curEntry, MAX_COLUMN_BOUNDARY );
|
|
// if( /*bNoZero &&*/ off == 0 )
|
|
// continue;
|
|
printf( "\n Entry %2d : ", i );
|
|
|
|
for ( int j = 0; j < MAX_COLUMN_BOUNDARY; j++ )
|
|
printf( " %2X", *(curPos + j) );
|
|
|
|
cout << " fbo=" << curEntry.fbo << " sbid=" << curEntry.sbid << " entry=" << curEntry.entry << " group=" << curEntry.group << " type=" << curEntry.type;
|
|
|
|
curPos += MAX_COLUMN_BOUNDARY;
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
|
|
} //end of namespace
|
|
|