opensci
/
gStore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
gStore/VSTree/VSTree.cpp

1071 lines
33 KiB
C++
Raw Blame History

/*
* VSTREE.cpp
*
* Created on: 2014-6-20
* Author: liyouhuan
*/
#include"VSTree.h"
#include<stdio.h>
#include<queue>
#include"../Database/Database.h"
#include"../Signature/Signature.h"
#include<algorithm>
#include<vector>
#include<iostream>
using namespace std;
string VSTree::tree_file_foler_path;
string VSTree::tree_node_file_path; // to be determine
string VSTree::tree_info_file_path; // to be determine
VSTree::VSTree(std::string _store_path)
{
this->height = 0;
this->node_num = 0;
this->entry_num = 0;
this->root_file_line = 0;
this->entry_buffer = NULL;
this->node_buffer = NULL;
/* set the store path */
VSTree::tree_file_foler_path = _store_path;
VSTree::tree_node_file_path = VSTree::tree_file_foler_path + "/tree_node_file.dat";
VSTree::tree_info_file_path = VSTree::tree_file_foler_path + "/tree_info_file.dat";
}
VSTree::~VSTree()
{
delete this->node_buffer;
delete this->entry_buffer;
}
int VSTree::getHeight()const
{
return this->height;
}
/* get the tree's root node pointer. */
VNode* VSTree::getRoot()
{
return (this->node_buffer)->get(this->root_file_line);
}
/* get the node pointer by its file line. */
VNode* VSTree::getNode(int _line)
{
if (_line >= this->node_num)
{
cerr << "error, the parameter:_line is bigger than the tree node_num. @VSTree::getNode" << endl;
return NULL;
}
return this->node_buffer->get(_line);
}
/* retrieve candidate result set by the var_sig in the _query. */
void VSTree::retrieve(SPARQLquery& _query)
{
Database::log("IN retrieve");
vector<BasicQuery*>& queryList = _query.getBasicQueryVec();
// enumerate each BasicQuery and retrieve their variables' mapping entity in the VSTree.
vector<BasicQuery*>::iterator iter=queryList.begin();
for ( ;iter!=queryList.end();iter++)
{
int varNum = (*iter)->getVarNum();
for (int i=0;i<varNum;i++)
{
//debug
{
std::stringstream _ss;
_ss << "retrieve of var: " << i << endl;
Database::log(_ss.str());
}
const EntityBitSet& entityBitSet = (*iter)->getVarBitSet(i);
IDList* idListPtr = &( (*iter)->getCandidateList(i) );
this->retrieveEntity(entityBitSet, idListPtr);
//debug
{
std::stringstream _ss;
_ss << "candidate num: " << idListPtr->size() << endl;
//_ss << (idListPtr->isExistID(4000001)?"true":"false") <<endl;
Database::log(_ss.str());
}
}
}
Database::log("OUT retrieve");
}
/* build the VSTree from the _entity_signature_file. */
bool VSTree::buildTree(std::string _entry_file_path)
{
Database::log("IN VSTree::buildTree");
// create the entry buffer and node buffer.
this->entry_buffer = new EntryBuffer(EntryBuffer::DEFAULT_CAPACITY);
this->node_buffer = new LRUCache(LRUCache::DEFAULT_CAPACITY);
// create the root node.
VNode* rootNodePtr = new VNode();
rootNodePtr->setAsRoot(true);
rootNodePtr->setAsLeaf(true);
rootNodePtr->setFileLine(this->root_file_line);
this->node_buffer->set(this->root_file_line, rootNodePtr);
this->node_num ++;
this->height ++;
/* when building a new VSTree,
* we should first create a new tree node file as the external storage
* of the node buffer on hard disk.*/
this->node_buffer->createCache(VSTree::tree_node_file_path);
FILE* filePtr = fopen(_entry_file_path.c_str(), "rb");
if (filePtr == NULL)
{
cerr << "error, can not open file. @VSTree::buildTree" << endl;
return false;
}
/* load the entry file to entry buffer in memory, when the entry buffer is full,
insert them into the tree. */
int n;
n = this->entry_buffer->fillElemsFromFile(filePtr);
while (n != 0)
{
for (int i=0;i<n;i++)
{
SigEntry* entryPtr = this->entry_buffer->getElem(i);
/* the most important part of this function */
this->insertEntry(*entryPtr);
/* insertEntry one by one */
}
n = this->entry_buffer->fillElemsFromFile(filePtr);
}
//debug
Database::log("insert entries to tree done.");
//bool flag = this->node_buffer->flush();
bool flag = this->saveTree();
//debug
{
stringstream _ss;
_ss << "tree height: " << this->getHeight() << endl;
Database::log(_ss.str());
}
Database::log("OUT VSTree::buildTree");
//debug
// {
// Database::log(this->to_str());
// Database::log("\n\n\n");
// }
return flag;
}
bool VSTree::deleteTree()
{
this->height = 0;
this->node_num = 0;
this->entry_num = 0;
this->root_file_line = 0;
delete this->node_buffer;
delete this->entry_buffer;
// backup the tree data file.
if (rename(VSTree::tree_file_foler_path.c_str(), (VSTree::tree_file_foler_path+"_bak").c_str()) == 0)
return true;
else
return false;
}
/* Incrementally update bitset of _entity_id
* conduct OR operation on Entry(_entity_id)'s EntityBitSet with _bitset
* Entry of _entity_id must exists */
bool VSTree::updateEntry(int _entity_id, const EntityBitSet& _bitset)
{
VNode* leafNodePtr = this->getLeafNodeByEntityID(_entity_id);
if (leafNodePtr == NULL)
{
cerr << "error, can not find the mapping leaf node. @VSTree::updateEntry" << endl;
return false;
}
// find the mapping child entry, update it and refresh signature.
int childNum = leafNodePtr->getChildNum();
bool findFlag = false;
for (int i=0;i<childNum;i++)
{
const SigEntry& entry = leafNodePtr->getChildEntry(i);
if (entry.getEntityId() == _entity_id)
{
SigEntry newEntry = entry;
newEntry |= SigEntry(EntitySig(_bitset), _entity_id);
leafNodePtr->setChildEntry(i, newEntry);
leafNodePtr->refreshAncestorSignature(*(this->node_buffer));
findFlag = true;
break;
}
}
if (!findFlag)
{
cerr<< "error, can not find the mapping child entry in the leaf node. @VSTree::updateEntry" << endl;
return false;
}
return true;
}
/* Replace the Entry(_enitty_id)'s EntityBitSet with _bitset
* Entry of _entity_id must exists */
bool VSTree::replaceEntry(int _entity_id, const EntityBitSet& _bitset)
{
VNode* leafNodePtr = this->getLeafNodeByEntityID(_entity_id);
if (leafNodePtr == NULL)
{
cerr << "error, can not find the mapping leaf node. @VSTree::replaceEntry" << endl;
return false;
}
// find the mapping child entry, update it and refresh signature.
int childNum = leafNodePtr->getChildNum();
bool findFlag = false;
for (int i=0;i<childNum;i++)
{
const SigEntry& entry = leafNodePtr->getChildEntry(i);
if (entry.getEntityId() == _entity_id)
{
SigEntry newEntry(EntitySig(_bitset), _entity_id);
leafNodePtr->setChildEntry(i, newEntry);
leafNodePtr->refreshAncestorSignature(*(this->node_buffer));
findFlag = true;
break;
}
}
if (!findFlag)
{
cerr << "error, can not find the mapping child entry in the leaf node. @VSTree::replaceEntry" << endl;
return false;
}
return true;
}
/* insert an new Entry, whose entity doesn't exist before */
bool VSTree::insertEntry(const SigEntry& _entry)
{
/* choose the best leaf node to insert the _entry */
VNode* choosedNodePtr = this->chooseNode(this->getRoot(), _entry);
//debug
// {
// if (_entry.getEntityId() == 4000001)
// {
// stringstream _ss;
// if (choosedNodePtr)
// {
// _ss << "insert " << _entry.getEntityId()
// << " into [" << choosedNodePtr->getFileLine() << "],\t";
// _ss << "whose childnum is " << choosedNodePtr->getChildNum() << endl;
// }
// else
// {
// _ss << "insert " << _entry.getEntityId() << " , can not choose a leaf node to insert entry. @VSTree::insert" << endl;
// }
// Database::log(_ss.str());
// }
// }
if (choosedNodePtr == NULL)
{
cerr << "error, can not choose a leaf node to insert entry. @VSTree::insert" << endl;
return false;
}
if (choosedNodePtr->isFull())
{
/* if the choosed leaf node to insert is full, the node should be split.*/
this->split(choosedNodePtr, _entry, NULL);
}
else
{
choosedNodePtr->addChildEntry(_entry, false);
choosedNodePtr->refreshAncestorSignature(*(this->node_buffer));
// update the entityID2FileLineMap.
this->entityID2FileLineMap[_entry.getEntityId()] = choosedNodePtr->getFileLine();
}
this->entry_num ++;
return true;
}
/* remove an existed Entry(_entity_id) from VSTree */
bool VSTree::removeEntry(int _entity_id)
{
VNode* leafNodePtr = this->getLeafNodeByEntityID(_entity_id);
if (leafNodePtr == NULL)
{
cerr<< "error, can not find the mapping leaf node. @VSTree::removeEntry" << endl;
return false;
}
// seek the entry index of the leaf node.
int entryIndex = -1;
int childNum = leafNodePtr->getChildNum();
for (int i=0;i<childNum;i++)
{
if (leafNodePtr->getChildEntry(i).getEntityId() == _entity_id)
{
entryIndex = i;
break;
}
}
if (entryIndex == -1)
{
cerr << "error, can not find the entry in leaf node. @VSTree::removeEntry" << endl;
return false;
}
// remove the entry in this leaf node and refresh itself and its ancestors' signature.
leafNodePtr->removeChild(entryIndex);
leafNodePtr->refreshAncestorSignature(*(this->node_buffer));
this->entry_num --;
/* we do not consider the situation which the leaf node is to be empty by now...
* in a better way, if the leaf node is empty after removing entry, we should delete it. and recursively judge whether its
* father is empty, and delete its father node if true. to make the VSTree more balanced, we should combine two nodes if
* their child number are less than the MIN_CHILD_NUM. when deleting one node from the tree, we should also remove it from
* tree node file in hard disk by doing some operations on the node_buffer.
*/
return true;
}
/* save the tree information to tree_info_file_path, and flush the tree nodes in memory to tree_node_file_path. */
bool VSTree::saveTree()
{
bool flag = this->saveTreeInfo();
if (flag)
{
flag = this->node_buffer->flush();
}
return flag;
}
bool VSTree::loadTree()
{
cout << "loadTree..." << endl;
(this->node_buffer) = new LRUCache(LRUCache::DEFAULT_CAPACITY);
bool flag = this->loadTreeInfo();
if (flag)
{
this->node_buffer->loadCache(VSTree::tree_node_file_path);
cout << "finish loadCache" << endl;
}
if (flag)
{
flag = loadEntityID2FileLineMap();
cout << "finish loadEntityID2FileLineMap" << endl;
}
return flag;
}
/* choose the best leaf node to insert the _entry,
* return the choosed leaf node's pointer.
* Recursion function! */
VNode* VSTree::chooseNode(VNode* _p_node, const SigEntry& _entry)
{
if (_p_node->isLeaf())
{
return _p_node;
}
else
{
int minDis = Signature::ENTITY_SIG_LENGTH + 1;
int candidateIndex[VNode::MAX_CHILD_NUM];
int candidateNum = 0;
int childNum = _p_node->getChildNum();
for (int i=0;i<childNum;i++)
{
int curDis = _p_node->getChildEntry(i).xEpsilen(_entry);
if (minDis >= curDis)
{
if (minDis > curDis)
{
minDis = curDis;
candidateNum = 0;
}
candidateIndex[candidateNum ++] = i;
}
}
minDis = Signature::ENTITY_SIG_LENGTH + 1;
VNode* ret = NULL;
for (int i=0;i<candidateNum;i++)
{
int child_i = candidateIndex[i];
VNode* p_child = _p_node->getChild(child_i, *(this->node_buffer));
/* Recursion */
VNode *candidateLeafPtr = this->chooseNode(p_child, _entry);
int curDis = candidateLeafPtr->getEntry().xEpsilen(_entry);
if (curDis == 0)
{
return candidateLeafPtr;
}
if (minDis > curDis)
{
minDis = curDis;
ret = candidateLeafPtr;
}
}
return ret;
}
}
void VSTree::split(VNode* _p_node_being_split, const SigEntry& _insert_entry, VNode* _p_insert_node)
{
//debug
// {
// stringstream _ss;
// _ss << "**********************split happen at "
// << _p_node_being_split->getFileLine() << endl;
// _ss << _p_node_being_split->to_str() << endl;
// Database::log(_ss.str());
// }
// first, add the new child node(if not leaf) or child entry(if leaf) to the full node.
bool just_insert_entry = (_p_insert_node == NULL);
if (just_insert_entry)
{
_p_node_being_split->addChildEntry(_insert_entry, true);
}
else
{
_p_node_being_split->addChildNode(_p_insert_node, true);
}
SigEntry entryA, entryB;
/* two seeds to generate two new nodes.
* seedA kernel: the SigEntry with the minimal count of signature.
* seedB kernel: the SigEntry with the second minimal count of signature.
* */
int minCount = 0; // record the minimal signature count.
int entryA_index = 0; // record the seedA kernel index.
for (int i=0;i<VNode::MAX_CHILD_NUM;i++)
{
int currentCount = (int) _p_node_being_split->getChildEntry(i).getSigCount();
if (minCount < currentCount)
{
minCount = currentCount;
entryA_index = i;
}
}
entryA = _p_node_being_split->getChildEntry(entryA_index);
minCount = 0;
int entryB_index = 0; // record the seedB kernel index.
for (int i=0;i<VNode::MAX_CHILD_NUM;i++)
{
int currentCount = entryA.xEpsilen(_p_node_being_split->getChildEntry(i));
if (i != entryA_index && minCount <= currentCount)
{
minCount = currentCount;
entryB_index = i;
}
}
entryB = _p_node_being_split->getChildEntry(entryB_index);
// AEntryIndex: the entry index near seedA.
// BEntryIndex: the entry index near seedB.
std::vector<int> entryIndex_nearA, entryIndex_nearB;
entryIndex_nearA.clear();
entryIndex_nearB.clear();
entryIndex_nearA.push_back(entryA_index);
entryIndex_nearB.push_back(entryB_index);
/* just tmp variables, for more readibility */
int nearA_max_size, nearB_max_size;
bool nearA_tooSmall, nearB_tooSmall;
for (int i=0;i<VNode::MAX_CHILD_NUM;i++)
{
if (i == entryA_index || i == entryB_index) continue;
/* should guarantee that each new node has at least MIN_CHILD_NUM children. */
nearA_max_size = VNode::MAX_CHILD_NUM - entryIndex_nearB.size();
nearA_tooSmall = (nearA_max_size <= VNode::MIN_CHILD_NUM);
if (nearA_tooSmall)
{
for (;i<VNode::MAX_CHILD_NUM;i++)
{
if (i == entryA_index || i == entryB_index) continue;
entryIndex_nearA.push_back(i);
}
break;
}
nearB_max_size = VNode::MAX_CHILD_NUM - entryIndex_nearA.size();
nearB_tooSmall = (nearB_max_size <= VNode::MIN_CHILD_NUM);
if (nearB_tooSmall)
{
for (;i<VNode::MAX_CHILD_NUM;i++)
{
if (i == entryA_index || i == entryB_index) continue;
entryIndex_nearB.push_back(i);
}
break;
}
/* calculate the distance from
* the i-th child entry signature to seedA(or seedB).*/
/*debug target 1*/
int disToSeedA = entryA.xEpsilen(_p_node_being_split->getChildEntry(i));
int disToSeedB = entryB.xEpsilen(_p_node_being_split->getChildEntry(i));
// choose the near one seed to add into
if (disToSeedA <= disToSeedB)
{
entryIndex_nearA.push_back(i);
}
else
{
entryIndex_nearB.push_back(i);
}
}
// then create a new node to act as BEntryIndex's father.
VNode* newNodePtr = this->createNode();
//debug
// {
// stringstream _ss;
// _ss << "new Node is :[" << newNodePtr->getFileLine() << "]" << endl;
// Database::log(_ss.str());
// }
// the old one acts as AEntryIndex's father.
VNode* oldNodePtr = _p_node_being_split;
// if the old node is leaf, set the new node as a leaf.
if (oldNodePtr->isLeaf())
{
newNodePtr->setAsLeaf(true);
}
/* add all the entries in BEntryIndex into the new node child entry array,
and calculate the new node's entry.*/
for (int i=0;i<entryIndex_nearB.size();i++)
{
if (oldNodePtr->isLeaf())
{
newNodePtr->addChildEntry(oldNodePtr->getChildEntry(entryIndex_nearB[i]), false);
}
else
{
/*debug target 2*/
VNode* childPtr = oldNodePtr->getChild(entryIndex_nearB[i], *(this->node_buffer));
newNodePtr->addChildNode(childPtr);
}
}
newNodePtr->refreshSignature();
/* label the child being removed with -1,
* and update the old node's entry.*/
std::sort(entryIndex_nearA.begin(), entryIndex_nearA.end(), less<int>());
//debug
// {
// stringstream _ss;
// {
// _ss << "nearA: ";
// for(int i = 0; i < entryIndex_nearA.size(); i ++)
// {
// _ss << entryIndex_nearA[i] << " ";
// }
// _ss << endl;
//
// _ss << "nearB: ";
// for(int i = 0; i < entryIndex_nearB.size(); i ++)
// {
// _ss << entryIndex_nearB[i] << " ";
// }
// _ss << endl;
// }
// Database::log(_ss.str());
// }
for (int i=0;i<entryIndex_nearA.size();i++)
{
oldNodePtr->setChildEntry(i, oldNodePtr->getChildEntry(entryIndex_nearA[i]));
oldNodePtr->setChildFileLine(i, oldNodePtr->getChildFileLine(entryIndex_nearA[i]));
}
oldNodePtr->setChildNum(entryIndex_nearA.size());
oldNodePtr->refreshSignature();
int oldNode_index = oldNodePtr->getIndexInFatherNode(*(this->node_buffer));
// full node's father pointer.
VNode* oldNodeFatherPtr = oldNodePtr->getFather(*(this->node_buffer));
if (oldNodePtr->isRoot())
{
/* if the old node is root,
* split the root, create a new root,
* and the tree height will be increased.*/
VNode* RootNewPtr = this->createNode();
/* change the old root node to not-root node,
* and set the RootNew to root node.*/
oldNodePtr->setAsRoot(false);
RootNewPtr->setAsRoot(true);
/* set the split two node(old node and new node) as the new root's child,
* and update signatures.*/
RootNewPtr->addChildNode(oldNodePtr);
RootNewPtr->addChildNode(newNodePtr);
RootNewPtr->refreshSignature();
//debug
// {
// stringstream _ss;
// _ss << "create new root:" << endl;
// _ss << "before swap file line, two sons are: " << oldNodePtr->getFileLine() << " " << newNodePtr->getFileLine() << endl;
// Database::log(_ss.str());
// }
/* should keep the root node always being
* at the first line(line zero) of the tree node file.*/
this->swapNodeFileLine(RootNewPtr, oldNodePtr);
this->height ++;
//debug
// {
// stringstream _ss;
// _ss << "create new root:" << endl;
// _ss << "two sons are: " << oldNodePtr->getFileLine() << " " << newNodePtr->getFileLine() << endl;
// _ss << Signature::BitSet2str(oldNodePtr->getEntry().getEntitySig().entityBitSet) << endl;
// _ss << RootNewPtr->to_str() << endl;
// Database::log(_ss.str());
// }
}
else
{
/* if the (OldNode) is not Root,
* change the old node's signature to A's signature.*/
oldNodeFatherPtr->setChildEntry(oldNode_index, oldNodePtr->getEntry());
if (oldNodeFatherPtr->isFull())
{
oldNodeFatherPtr->refreshAncestorSignature(*(this->node_buffer));
this->split(oldNodeFatherPtr, newNodePtr->getEntry(), newNodePtr);
}
else
{
oldNodeFatherPtr->addChildNode(newNodePtr);
oldNodeFatherPtr->refreshAncestorSignature(*(this->node_buffer));
}
}
// update the entityID2FileLineMap by these two nodes.
this->updateEntityID2FileLineMap(oldNodePtr);
this->updateEntityID2FileLineMap(newNodePtr);
}
/* create a new node when one node need splitting. */
VNode* VSTree::createNode()
{
VNode* newNodePtr = new VNode();
newNodePtr->setFileLine(this->node_num);
this->node_buffer->set(this->node_num, newNodePtr);
this->node_num ++;
return newNodePtr;
}
/* swap two nodes' file line, their related nodes(father and children nodes) will also be updated. */
void VSTree::swapNodeFileLine(VNode* _p_node_a, VNode* _p_node_b)
{
int oldNodeAFileLine = _p_node_a->getFileLine();
int oldNodeBFileLine = _p_node_b->getFileLine();
int newNodeAFileLine = oldNodeBFileLine;
int newNodeBFileLine = oldNodeAFileLine;
// at first, we should get their fathers' and children's pointer.
VNode* nodeAFatherPtr = _p_node_a->getFather(*(this->node_buffer));
int nodeARank = _p_node_a->getIndexInFatherNode(*(this->node_buffer));
VNode* nodeBFatherPtr = _p_node_b->getFather(*(this->node_buffer));
int nodeBRank = _p_node_b->getIndexInFatherNode(*(this->node_buffer));
VNode* nodeAChildPtr[VNode::MAX_CHILD_NUM];
VNode* nodeBChildPtr[VNode::MAX_CHILD_NUM];
int nodeAChildNum = _p_node_a->getChildNum();
int nodeBChildNum = _p_node_b->getChildNum();
for (int i=0;i<nodeAChildNum;i++)
{
nodeAChildPtr[i] = _p_node_a->getChild(i, *(this->node_buffer));
}
for (int i=0;i<nodeBChildNum;i++)
{
nodeBChildPtr[i] = _p_node_b->getChild(i, *(this->node_buffer));
}
// update nodes self file line.
_p_node_a->setFileLine(newNodeAFileLine);
_p_node_b->setFileLine(newNodeBFileLine);
// update nodes' fathers' child file line.
if (!_p_node_a->isRoot())
{
nodeAFatherPtr->setChildFileLine(nodeARank, newNodeAFileLine);
}
if (!_p_node_b->isRoot())
{
nodeBFatherPtr->setChildFileLine(nodeBRank, newNodeBFileLine);
}
// update nodes' children's father file line.
if (!_p_node_a->isLeaf())
{
for (int i=0;i<nodeAChildNum;i++)
{
nodeAChildPtr[i]->setFatherFileLine(newNodeAFileLine);
}
}
if (!_p_node_b->isLeaf())
{
for (int i=0;i<nodeBChildNum;i++)
{
nodeBChildPtr[i]->setFatherFileLine(newNodeBFileLine);
}
}
// update the node_buffer.
this->node_buffer->update(newNodeAFileLine, _p_node_a);
this->node_buffer->update(newNodeBFileLine, _p_node_b);
}
/* save VSTree's information to tree_info_file_path, such as node_num, entry_num, height, etc. */
bool VSTree::saveTreeInfo()
{
FILE* filePtr = fopen(VSTree::tree_info_file_path.c_str(), "wb");
if (filePtr == NULL)
{
cerr << "error, can not create tree info file. @VSTree::saveTreeInfo" << endl;
return false;
}
fseek(filePtr, 0, SEEK_SET);
fwrite(&this->node_num, sizeof(int), 1, filePtr);
fwrite(&this->root_file_line, sizeof(int), 1, filePtr);
fwrite(&this->height, sizeof(int), 1, filePtr);
int minChildNum = VNode::MIN_CHILD_NUM;
fwrite(&minChildNum, sizeof(int), 1, filePtr);
int maxChildNum = VNode::MAX_CHILD_NUM;
fwrite(&maxChildNum, sizeof(int), 1, filePtr);
int nodeSize = sizeof(VNode);
fwrite(&nodeSize,sizeof(int), 1, filePtr);
int sigLength = Signature::ENTITY_SIG_LENGTH;
fwrite(&sigLength, sizeof(int), 1, filePtr);
fwrite(&this->entry_num, sizeof(int), 1, filePtr);
int nodeBufferSize = this->node_buffer->getCapacity();
fwrite(&nodeBufferSize, sizeof(int), 1, filePtr);
fclose(filePtr);
return true;
}
/* load VSTree's information from tree_info_file_path. */
bool VSTree::loadTreeInfo()
{
FILE* filePtr = fopen(VSTree::tree_info_file_path.c_str(), "rb");
if (filePtr == NULL)
{
cerr << "error, can not open tree file:[" <<
VSTree::tree_info_file_path <<
"]@VSTree::loadTreeInfo" << endl;
return false;
}
fseek(filePtr, 0, SEEK_SET);
int tmp;
fread(&this->node_num, sizeof(int), 1, filePtr);
fread(&this->root_file_line, sizeof(int), 1, filePtr);
fread(&this->height, sizeof(int), 1, filePtr);
fread(&tmp, sizeof(int), 1, filePtr);
fread(&tmp, sizeof(int), 1, filePtr);
fread(&tmp,sizeof(int), 1, filePtr);
int sigLength = Signature::ENTITY_SIG_LENGTH;
fread(&sigLength, sizeof(int), 1, filePtr);
if (sigLength > Signature::ENTITY_SIG_LENGTH)
{
cerr << "WARNING: signature length is too short. @VSTree::loadTreeInfo" << endl;
}
fread(&this->entry_num, sizeof(int), 1, filePtr);
int nodeBufferSize = this->node_buffer->getCapacity();
fread(&nodeBufferSize, sizeof(int), 1, filePtr);
if (nodeBufferSize > this->node_buffer->getCapacity())
{
cerr << "WARNING: node buffer size may be too small. @VSTree::loadTreeInfo" << endl;
}
fclose(filePtr);
return true;
}
/* traverse the tree_node_file_path file, load the mapping from entity id to file line. */
bool VSTree::loadEntityID2FileLineMap()
{
FILE* filePtr = fopen(VSTree::tree_node_file_path.c_str(), "rb");
if (filePtr == NULL)
{
cerr << "error, can not open tree node file. @VSTree::loadEntityID2FileLineMap" << endl;
return false;
}
size_t vNodeSize = sizeof(VNode);
int flag = 0;
flag = fseek(filePtr, 0, SEEK_SET);
if (flag != 0)
{
cerr << "error,can't seek to the fileLine. @VSTree::loadEntityID2FileLineMap" << endl;
return false;
}
this->entityID2FileLineMap.clear();
VNode* nodePtr = new VNode();
int cycle_count = 0;
while (!feof(filePtr))
{
bool is_node_read = (fread((char *)nodePtr,vNodeSize,1,filePtr) == 1);
if (is_node_read)
{
this->updateEntityID2FileLineMap(nodePtr);
//debug
{
stringstream _ss;
if (cycle_count != nodePtr->getFileLine())
{
_ss << "line=" << cycle_count << " nodeLine=" << nodePtr->getFileLine() << endl;
Database::log(_ss.str());
}
}
cycle_count ++;
}
}
delete nodePtr;
fclose(filePtr);
return true;
}
/* update the entityID2FileLineMap with the _p_node's child entries, the _p_node should be leaf node. */
void VSTree::updateEntityID2FileLineMap(VNode* _p_node)
{
if (_p_node->isLeaf())
{
int line = _p_node->getFileLine();
int childNum = _p_node->getChildNum();
for (int i=0;i<childNum;i++)
{
// update all this node's child entries' entityID to file line mapping.
const SigEntry& entry = _p_node->getChildEntry(i);
int entityID = entry.getEntityId();
this->entityID2FileLineMap[entityID] = line;
//debug
{
if (entityID == 4000001)
{
Database::log("entity(4000001) found in leaf node!!!");
}
}
}
}
}
/* get the leaf node pointer by the given _entityID */
VNode* VSTree::getLeafNodeByEntityID(int _entityID)
{
map<int,int>::iterator iter = this->entityID2FileLineMap.find(_entityID);
if (iter == this->entityID2FileLineMap.end())
{
cerr << "error,can not find the _entityID's mapping fileLine. @VSTree::getLeafNodeByEntityID" << endl;
return NULL;
}
int line = iter->second;
return this->getNode(line);
}
/* retrieve the candidate entity ID which signature can cover the_entity_bit_set, and add them to the _p_id_list. */
void VSTree::retrieveEntity(const EntityBitSet& _entity_bit_set, IDList* _p_id_list)
{
Database::log("IN retrieveEntity");
EntitySig filterSig(_entity_bit_set);
std::queue<int>nodeFileFileQueue; //searching node file line queue.
//debug
{
stringstream _ss;
_ss << "filterSig=" << Signature::BitSet2str(filterSig.entityBitSet) << endl;
Database::log(_ss.str());
}
const SigEntry& root_entry = (this->getRoot())->getEntry();
Database::log("Get Root Entry");
if(root_entry.cover(filterSig))
{
nodeFileFileQueue.push(this->getRoot()->getFileLine());
Database::log("root cover the filter_sig");
}
else
{
Database::log("warning: root is not cover the filter_sig");
}
//debug
// {
// Database::log(this->getRoot()->to_str());
// Database::log("Before BFS");
// }
/* using BFS algorithm to traverse the VSTree and retrieve the entry.*/
while (!nodeFileFileQueue.empty())
{
int currentNodeFileLine = nodeFileFileQueue.front();
nodeFileFileQueue.pop();
VNode* currentNodePtr = this->getNode(currentNodeFileLine);
int childNum = currentNodePtr->getChildNum();
//debug
// {
// std::stringstream _ss;
// _ss << "childNum of ["
// << currentNodePtr->getFileLine()
// << "] is " << childNum << endl;
//
// for (int i=0;i<childNum;i++)
// {
// _ss << currentNodePtr->getChildFileLine(i) << " ";
// }
// _ss << endl;
//
// Database::log(_ss.str());
// }
for (int i=0;i<childNum;i++)
{
const SigEntry& entry = currentNodePtr->getChildEntry(i);
if (entry.cover(filterSig))
{
if (currentNodePtr->isLeaf())
{
// if leaf node, add the satisfying entries' entity id to result list.
_p_id_list->addID(entry.getEntityId());
//debug
// {
// stringstream _ss;
// _ss << "child_" << i << " cover filter sig" << endl;
// _ss << Signature::BitSet2str(entry.getEntitySig().entityBitSet)<< endl;
// Database::log(_ss.str());
// }
}
else
{
// if non-leaf node, add the child node pointer to the searching queue.
//VNode* childPtr = currentNodePtr->getChild(i, *(this->node_buffer));
// if non-leaf node, add the child node file line to the searching queue.
int childNodeFileLine = currentNodePtr->getChildFileLine(i);
nodeFileFileQueue.push(childNodeFileLine);
//debug
// {
// stringstream _ss;
// _ss << "child[" << childPtr->getFileLine() << "] cover filter sig" << endl;
// Database::log(_ss.str());
// }
}
}
}
}
Database::log("OUT retrieveEntity");
}
std::string VSTree::to_str()
{
//debug
{
stringstream _ss;
_ss << "after build tree, root is:" << endl;
_ss << this->getRoot()->to_str() << endl;
Database::log(_ss.str());
}
std::stringstream _ss;
std::queue<int> nodeFileLineQueue;
nodeFileLineQueue.push(this->getRoot()->getFileLine());
while(! nodeFileLineQueue.empty())
{
int currentNodeFileLine = nodeFileLineQueue.front();
nodeFileLineQueue.pop();
VNode* currentNodePtr = this->getNode(currentNodeFileLine);
_ss << currentNodePtr->to_str();
int childNum = currentNodePtr->getChildNum();
for(int i = 0; i < childNum; i ++)
{
if(! currentNodePtr->isLeaf())
{
int childNodeFileLine = currentNodePtr->getChildFileLine(i);
nodeFileLineQueue.push(childNodeFileLine);
}
}
}
return _ss.str();
}
Reference in New Issue View Git Blame Copy Permalink