mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-04-18 21:44:02 +03:00
1671 lines
45 KiB
C++
1671 lines
45 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");
|
|
}
|
|
|
|
} // namespace WriteEngine
|