//NOTICE:this can only be done by one thread
//write out all the elements to hard disk.
bool LRUCache::flush()
{
#ifdef DEBUG_VSTREE
cout<<"to flush in LRUCache"<<endl;
#endif
FILE* filePtr = fopen(this->dataFilePath.c_str(), "r+b");
if (filePtr == NULL)
{
cerr << "error, can't open file. @LRUCache::flush" << endl;
return false;
}
int startIndex = LRUCache::DEFAULT_NUM;
int endIndex = startIndex + this->size;
size_t vNodeSize = VNode::VNODE_SIZE;
//size_t vNodeSize = sizeof(VNode);
//NOTICE:values are continuous
for (int i = startIndex; i < endIndex; ++i)
{
VNode* nodePtr = this->values[i];
int line = this->keys[i];
//cout<<"file line to write "<<line<<endl;
#ifdef DEBUG
if (nodePtr->getFileLine() != line)
{
cout << "line error at !!!" << line << " " << nodePtr->getFileLine() << endl;
}
#endif
if (nodePtr == NULL)
{
cerr << "error, VNode do not exist. @LRUCache::flush" << endl;
return false;
}
if(!nodePtr->isDirty())
{
continue;
}
int flag = 0;
long long seekPos = (long long)line * vNodeSize;
flag = fseek(filePtr, seekPos, SEEK_SET);
if (flag != 0)
{
cerr << "error, can't seek to the fileLine. @LRUCache::flush" << endl;
return false;
}
//fwrite((char *)nodePtr, vNodeSize, 1, filePtr);
nodePtr->writeNode(filePtr);
}
fclose(filePtr);
return true;
}
//just write the values[_pos] to the hard disk, the VNode in memory will not be free.
bool
LRUCache::writeOut(int _pos, int _fileLine)
{
VNode* nodePtr = this->values[_pos];
FILE* filePtr = fopen(this->dataFilePath.c_str(), "r+b");
if (nodePtr == NULL)
{
cerr << "error, VNode do not exist. @LRUCache::writeOut" << endl;
return false;
}
if (filePtr == NULL)
{
cerr << "error, can't open file. @LRUCache::writeOut" << endl;
return false;
}
if (nodePtr->getFileLine() != _fileLine)
{
cerr << "error, fileLine " << _fileLine <<" "<< nodePtr->getFileLine() << " wrong. @LRUCache::writeOut" << endl;
}
if(!nodePtr->isDirty())
{
//cout<<"the node not dirty!"<<endl;
fclose(filePtr);
return true;
}
else //is modified
{
nodePtr->setDirty(false);
}
int line = _fileLine == -1 ? nodePtr->getFileLine() : _fileLine;
size_t vNodeSize = VNode::VNODE_SIZE;
//size_t vNodeSize = sizeof(VNode);
int flag = 0;
long long seekPos = (long long)line * vNodeSize;
flag = fseek(filePtr, seekPos, SEEK_SET);
if (flag != 0)
{
cerr << "error, can't seek to the fileLine. @LRUCache::writeOut" << endl;
return false;
}
//fwrite((char *)nodePtr, vNodeSize, 1, filePtr);
nodePtr->writeNode(filePtr);
fclose(filePtr);
return true;
}
//read the value from hard disk, and put it to the values[_pos].
//before use it, you must make sure that the _pos element in cache is free(unoccupied).
bool LRUCache::readIn(int _pos, int _fileLine)
{
#ifdef DEBUG_LRUCACHE
//cout<<"pos: "<<_pos<<" "<<"fileline: "<<_fileLine<<endl;
#endif
VNode* nodePtr = new VNode(true);
//VNode* nodePtr = NULL;
FILE* filePtr = fopen(this->dataFilePath.c_str(), "rb");
//if (nodePtr == NULL)
//{
//cerr << "error, can not new a VNode. @LRUCache::readIn" << endl;
//return false;
//}
if (filePtr == NULL)
{
cerr << "error, can't open " <<
"[" << this->dataFilePath << "]" <<
". @LRUCache::readIn" << endl;
return false;
}
int line = _fileLine;
size_t vNodeSize = VNode::VNODE_SIZE;
//size_t vNodeSize = sizeof(VNode);
int flag = 0;
long long seekPos = (long long)line * vNodeSize;
flag = fseek(filePtr, seekPos, SEEK_SET);
if (flag != 0)
{
cerr << "error,can't seek to the fileLine. @LRUCache::readIn" << endl;
return false;
}
//bool is_node_read = (fread((char *)nodePtr, vNodeSize, 1, filePtr) == 1);
//fread((char *)nodePtr, vNodeSize, 1, filePtr);
nodePtr->readNode(filePtr);
fclose(filePtr);
if (nodePtr == NULL || nodePtr->getFileLine() != _fileLine)
{
cout<<"node file line: "<<nodePtr->getFileLine()<<endl;
cerr << "error,node fileLine error. @LRUCache::readIn" << endl;
}
this->setElem(_pos, _fileLine, nodePtr);
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;
Util::logging(_ss.str());
}
}
cycle_count ++;
}
}
delete nodePtr;
fclose(filePtr);
return true;
}
bool
LRUCache::freeDisk(int _pos)
{
VNode* nodePtr = this->values[_pos];
FILE* filePtr = fopen(this->dataFilePath.c_str(), "r+b");
if (nodePtr == NULL)
{
cerr << "error, VNode do not exist. @LRUCache::freeDisk" << endl;
return false;
}
if (filePtr == NULL)
{
cerr << "error, can't open file. @LRUCache::freeDisk" << endl;
return false;
}
//size_t vNodeSize = sizeof(VNode);
size_t vNodeSize = VNode::VNODE_SIZE;
int line = nodePtr->getFileLine();
int flag = 0;
long long seekPos = (long long)line * vNodeSize;
flag = fseek(filePtr, seekPos, SEEK_SET);
if (flag != 0)
{
cerr << "error, can't seek to the fileLine. @LRUCache::writeOut" << endl;
return false;
}
nodePtr->setFileLine(-1);
//fwrite((char *)nodePtr, vNodeSize, 1, filePtr);
nodePtr->writeNode(filePtr);
fclose(filePtr);
return true;
}
void
VSTree::split(VNode* _p_node_being_split, const SigEntry& _insert_entry, VNode* _p_insert_node)
{
#ifdef DEBUG_VSTREE
stringstream _ss;
_ss << "**********************split happen at "
<< _p_node_being_split->getFileLine() << endl;
_ss << _p_node_being_split->to_str() << endl;
Util::logging(_ss.str());
#endif
// 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;
//BETTER: use hanming, xor result or the vector included angle to guess the distince.
//And then also use the farest two as seeds.
//
//two seeds to generate two new nodes.
//seedA kernel: the SigEntry with the minimal count of signature.
//seedB kernel: the SigEntry with the maximal count of signature.
int maxCount = 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(maxCount < currentCount)
{
maxCount = currentCount;
entryA_index = i;
}
}
entryA = _p_node_being_split->getChildEntry(entryA_index);
maxCount = 0;
int entryB_index = 0; // record the seedB kernel index.
for(int i = 0; i < VNode::MAX_CHILD_NUM; i++)
{
//NOTICE:I think xOR should be used here to choose the farest two
int currentCount = entryA.xOR(_p_node_being_split->getChildEntry(i));
//int currentCount = entryA.xEpsilen(_p_node_being_split->getChildEntry(i));
if(i != entryA_index && maxCount <= currentCount)
{
maxCount = 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);
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).
//NOTICE:we should expect that the candidate can be almost contained!
//However, the precondition there are not too many 1s
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();
#ifdef DEBUG_VSTREE
stringstream _ss2;
_ss2 << "new Node is :[" << newNodePtr->getFileLine() << "]" << endl;
Util::logging(_ss2.str());
#endif
// 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(unsigned 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.
sort(entryIndex_nearA.begin(), entryIndex_nearA.end(), less<int>());
#ifdef DEBUG_VSTREE
stringstream _ss1;
{
_ss1 << "nearA: ";
for(unsigned i = 0; i < entryIndex_nearA.size(); i++)
{
_ss1 << entryIndex_nearA[i] << " ";
}
_ss1 << endl;
_ss1 << "nearB: ";
for(unsigned i = 0; i < entryIndex_nearB.size(); i++)
{
_ss1 << entryIndex_nearB[i] << " ";
}
_ss1 << endl;
}
Util::logging(_ss1.str());
#endif
for(unsigned 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;
// Util::logging(_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;
// Util::logging(_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));
}
}
//debug
// if (!oldNodePtr->checkState())
// {
// stringstream _ss;
// _ss << "node " << oldNodePtr->getFileLine() << " childFileLine error. oldNode when split" << endl;
// Util::logging(_ss.str());
// }
// if (!newNodePtr->checkState())
// {
// stringstream _ss;
// _ss << "node " << newNodePtr->getFileLine() << " childFileLine error. newNode when split" << endl;
// Util::logging(_ss.str());
// }
// update the entityID2FileLineMap by these two nodes.
this->updateEntityID2FileLineMap(oldNodePtr);
this->updateEntityID2FileLineMap(newNodePtr);
}
//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);
#ifdef DEBUG_VSTREE
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;
}
Util::logging(_ss.str());
}
#endif
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);
//debug
// if (!choosedNodePtr->checkState())
// {
// stringstream _ss;
// _ss << "node " << choosedNodePtr->getFileLine() << " childFileLine error. after split" << endl;
// Util::logging(_ss.str());
// }
}
else
{
choosedNodePtr->addChildEntry(_entry, false);
choosedNodePtr->refreshAncestorSignature(*(this->node_buffer));
//debug
// if (!choosedNodePtr->checkState())
// {
// stringstream _ss;
// _ss << "node " << choosedNodePtr->getFileLine() << " childFileLine error. after addChildEntry" << endl;
// _ss <<"child num=" << choosedNodePtr->getChildNum() << endl;
// _ss <<"node num=" << this->node_num << " entry num=" << this->entry_num << endl;
// Util::logging(_ss.str());
// }
// update the entityID2FileLineMap.
this->entityID2FileLineMap[_entry.getEntityId()] = choosedNodePtr->getFileLine();
}
this->entry_num ++;
return true;
}
//the _entry_index in _child is to be removed.
//node can only be deleted in this function.
void
VSTree::coalesce(VNode* _child, int _entry_index)
{
#ifdef DEBUG
cout << "coalesce happen" <<endl;
#endif
//found the father and index
VNode* _father = _child->getFather(*(this->node_buffer));
int cn = _child->getChildNum();
if(_father == NULL) //this is already root
{
//NOTICE:when root is leaf, at least one key, otherwise the tree is empty
//But when root is internal, at least two key, if one key then shrink
//(1-key internal root is not permitted)
//
//Notice that leaf-root case has been discussed in upper function removeEntry()
//so here the root must be internal node
_child->removeChild(_entry_index);
if(cn == 2)
{
//only one key after remove, shrink root
VNode* newRoot = _child->getChild(0, *(this->node_buffer));
newRoot->setAsRoot(true);
cout<<"shrink root in coalesce() -- to swap node file"<<endl;
this->swapNodeFileLine(newRoot, _child);
this->root_file_line = newRoot->getFileLine();
this->height--;
this->removeNode(_child);
}
return;
}
if(cn > VNode::MIN_CHILD_NUM)
{
cout<<"no need to move or union in coalesce()"<<endl;
_child->removeChild(_entry_index);
_child->refreshAncestorSignature(*(this->node_buffer));
return;
}
int fn = _father->getChildNum();
int i, _child_index = -1;
for (i = 0; i < fn; ++i)
{
if (_father->getChildFileLine(i) == _child->getFileLine())
{
break;
}
}
if(i == fn)
{
cerr << "not found the leaf node in VSTree::coalesce()" << endl;
return;
}
else
{
_child_index = i;
}
//_child->removeChild(_entry_index);
//_child->setChildNum(cn);
//NOTICE:we do not consider the efficiency here, so just ensure the operation is right
//BETTER:find good way to ensure signatures are separated(maybe similar ones together)
int ccase = 0;
VNode* p = NULL;
int n = 0;
if(_child_index < fn - 1)
{
p = _father->getChild(_child_index+1, *(this->node_buffer));
n = p->getChildNum();
if(n > VNode::MIN_CHILD_NUM)
{
ccase = 2;
}
else
{
ccase = 1;
}
}
if(_child_index > 0)
{
VNode* tp = _father->getChild(_child_index-1, *(this->node_buffer));
int tn = tp->getChildNum();
if(ccase < 2)
{
if(ccase == 0)
ccase = 3;
if(tn > VNode::MIN_CHILD_NUM)
ccase = 4;
}
if(ccase > 2)
{
p = tp;
n = tn;
}
}
VNode* tmp = NULL;
int child_no = _child->getFileLine();
int father_no = _father->getFileLine();
#ifdef DEBUG
if(ccase == 1 || ccase == 3)
{
cout << "union happened" << endl;
}
else if(ccase == 2 || ccase == 4)
{
cout << "move happened" << endl;
}
cout<< "father num: "<<fn<<" child num: "<<cn<<" neighbor num: "<<n<<endl;
cout<<"child file line "<<child_no<<endl;
cout<<"neighbor file line "<<p->getFileLine()<<endl;
#endif
switch(ccase)
{
case 1: //union right to this
if(_child->isLeaf())
{
_child->setChildFileLine(_entry_index, p->getChildFileLine(0));
_child->setChildEntry(_entry_index, p->getChildEntry(0));
for(int i = 1; i < n; ++i)
{
_child->setChildFileLine(cn+i-1, p->getChildFileLine(i));
_child->addChildEntry(p->getChildEntry(i));
}
}
else
{
_child->setChildFileLine(_entry_index, p->getChildFileLine(0));
_child->setChildEntry(_entry_index, p->getChildEntry(0));
tmp = p->getChild(0, *(this->node_buffer));
tmp->setFatherFileLine(child_no);
for(int i = 1; i < n; ++i)
{
tmp = p->getChild(i, *(this->node_buffer));
//cout<<i<<" "<<_child->getChildNum()<<endl;
_child->addChildNode(tmp);
//_child->setChildNum(cn+i);
//tmp->setFatherFileLine(child_no);
}
}
this->removeNode(p);
_child->refreshSignature();
//recursive:to remove child index+1 in father
this->coalesce(_father, _child_index+1);
break;
case 2: //move one from right
_child->setChildFileLine(_entry_index, p->getChildFileLine(n-1));
_child->setChildEntry(_entry_index, p->getChildEntry(n-1));
_child->refreshSignature();
if(!_child->isLeaf())
{
tmp = p->getChild(n-1, *(this->node_buffer));
tmp->setFatherFileLine(child_no);
}
p->removeChild(n-1);
p->refreshSignature();
_father->setChildEntry(_child_index, _child->getEntry());
_father->setChildEntry(_child_index+1, p->getEntry());
_father->refreshAncestorSignature(*(this->node_buffer));
break;
case 3: //union left to this
if(_child->isLeaf())
{
_child->setChildFileLine(_entry_index, p->getChildFileLine(0));
_child->setChildEntry(_entry_index, p->getChildEntry(0));
for(int i = 1; i < n; ++i)
{
_child->setChildFileLine(cn+i-1, p->getChildFileLine(i));
_child->addChildEntry(p->getChildEntry(i));
}
}
else
{
_child->setChildFileLine(_entry_index, p->getChildFileLine(0));
_child->setChildEntry(_entry_index, p->getChildEntry(0));
tmp = p->getChild(0, *(this->node_buffer));
tmp->setFatherFileLine(child_no);
for(int i = 1; i < n; ++i)
{
tmp = p->getChild(i, *(this->node_buffer));
//cout<<i<<" "<<_child->getChildNum()<<endl;
_child->addChildNode(tmp);
//_child->setChildNum(cn+i);
//tmp->setFatherFileLine(child_no);
}
}
this->removeNode(p);
_child->refreshSignature();
//recursive:to remove child index-1 in father
this->coalesce(_father, _child_index-1);
break;
case 4: //move one from left
_child->setChildFileLine(_entry_index, p->getChildFileLine(n-1));
_child->setChildEntry(_entry_index, p->getChildEntry(n-1));
_child->refreshSignature();
if(!_child->isLeaf())
{
VNode* tmp = p->getChild(n-1, *(this->node_buffer));
tmp->setFatherFileLine(child_no);
}
p->removeChild(n-1);
p->refreshSignature();
_father->setChildEntry(_child_index, _child->getEntry());
_father->setChildEntry(_child_index-1, p->getEntry());
_father->refreshAncestorSignature(*(this->node_buffer));
break;
default:
cout << "error in coalesce: Invalid case!";
break;
}
//BETTER:this maybe very costly because many entity no need to update
if(_child->isLeaf())
{
this->updateEntityID2FileLineMap(_child);
if(ccase == 2 || ccase == 4)
{
this->updateEntityID2FileLineMap(p);
}
}
}
//NOTICE:this must be done in one thread(and only one time)
//load cache's elements from an exist data file.
bool LRUCache::loadCache(string _filePath)
{
this->dataFilePath = _filePath;
FILE* filePtr = fopen(this->dataFilePath.c_str(), "rb");
if (filePtr == NULL)
{
cerr << "error, can not load an exist data file. @LRUCache::loadCache" << endl;
return false;
}
//NOTICE:here we set it to the maxium, to ensure all VNODE in memory
int defaultLoadSize = this->capacity;
//int defaultLoadSize = this->capacity / 2;
size_t vNodeSize = VNode::VNODE_SIZE;
//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. @LRUCache::loadCache" << endl;
return false;
}
//int _tmp_cycle_count = 0;
while (this->size < defaultLoadSize)
{
bool is_reach_EOF = feof(filePtr);
if(is_reach_EOF)
{
break;
}
VNode* nodePtr = new VNode(true);
//VNode* nodePtr = NULL;
//bool is_node_read = (fread((char *)nodePtr, vNodeSize, 1, filePtr) == 1);
bool is_node_read = nodePtr->readNode(filePtr);
if (!is_node_read)
{
delete nodePtr;
break;
}
//NOTICE:not consider invalid node
if(nodePtr->getFileLine() < 0)
{
//remove invalid node
delete nodePtr;
continue;
}
//this->size if the real size, while DEFAULT_NUM is the prefix
//To maintain a double-linked list, the pos 0 is head, while the pos 1 is tail
int pos = LRUCache::DEFAULT_NUM + this->size;
this->setElem(pos, nodePtr->getFileLine(), nodePtr);
//debug
//{
//if (_tmp_cycle_count != nodePtr->getFileLine())
//{
//stringstream _ss;
//_ss << "error file line: " << _tmp_cycle_count << " " << nodePtr->getFileLine() << " " << nodePtr->getChildNum() << endl;
//Util::logging(_ss.str());
//}
//}
//_tmp_cycle_count++;
}
fclose(filePtr);
return true;
}
