inline void BTree<KeyType, KeyComparator>::insert(KeyType key, TID tid) {
size_t currHeight = 0;
uint64_t currPageId = rootPageId;
BufferFrame *parentFrame = nullptr;
BufferFrame *currFrame = nullptr;
InnerNode<KeyType, KeyComparator> *parentNode = nullptr;
InnerNode<KeyType, KeyComparator> *currNode = nullptr;
while (!isLeafHeight(currHeight)) {
if (parentFrame != nullptr) {
bufferManager.unfixPage(*parentFrame, true);
}
parentFrame = currFrame;
parentNode = currNode;
currFrame = &bufferManager.fixPage(this->segmentId, currPageId, true);
currNode = reinterpret_cast<InnerNode<KeyType, KeyComparator> *>(currFrame->getData());
if (!currNode->hasSpaceForOneMoreEntry()) {
if (parentNode == nullptr) {
auto newNode = createEmptyNode(currPageId);
parentFrame = newNode.first;
parentNode = newNode.second;
currHeight++;
}
auto splitResult = splitInnerNode(currNode, currFrame, currPageId,
parentNode, key);
currFrame = splitResult.first;
currNode = splitResult.second;
}
currPageId = currNode->getNextNode(key, this->smallerComparator);
currHeight++;
}
// we are now at leaf height - the currPageId points to a leaf
if (parentFrame != nullptr) {
bufferManager.unfixPage(*parentFrame, true);
}
parentFrame = currFrame;
parentNode = currNode;
currNode = nullptr;
currFrame = &bufferManager.fixPage(this->segmentId, currPageId, true);
auto leaf = reinterpret_cast<Leaf<KeyType, KeyComparator> *>(currFrame->getData());
if (!leaf->hasSpaceForOneMoreEntry()) {
if (parentNode == nullptr) {
auto newNode = createEmptyNode(currPageId);
parentFrame = newNode.first;
parentNode = newNode.second;
}
auto splitResult = splitLeaf(leaf, currFrame, currPageId, parentNode, key);
currFrame = splitResult.first;
leaf = splitResult.second;
}
if (parentFrame != nullptr) {
bufferManager.unfixPage(*parentFrame, true);
}
leaf->insertDefiniteFit(key, tid, smallerComparator);
bufferManager.unfixPage(*currFrame, true);
treeSize++;
}
bool Tree::splitNode(size_t nodeID) {
// Select random subset of variables to possibly split at
std::vector<size_t> possible_split_varIDs;
createPossibleSplitVarSubset(possible_split_varIDs);
// Call subclass method, sets split_varIDs and split_values
bool stop = splitNodeInternal(nodeID, possible_split_varIDs);
if (stop) {
// Terminal node
return true;
}
size_t split_varID = split_varIDs[nodeID];
double split_value = split_values[nodeID];
// Create child nodes
size_t left_child_nodeID = sampleIDs.size();
child_nodeIDs[0][nodeID] = left_child_nodeID;
createEmptyNode();
size_t right_child_nodeID = sampleIDs.size();
child_nodeIDs[1][nodeID] = right_child_nodeID;
createEmptyNode();
// For each sample in node, assign to left or right child
if ((*is_ordered_variable)[split_varID]) {
// Ordered: left is <= splitval and right is > splitval
for (auto& sampleID : sampleIDs[nodeID]) {
if (data->get(sampleID, split_varID) <= split_value) {
sampleIDs[left_child_nodeID].push_back(sampleID);
} else {
sampleIDs[right_child_nodeID].push_back(sampleID);
}
}
} else {
// Unordered: If bit at position is 1 -> right, 0 -> left
for (auto& sampleID : sampleIDs[nodeID]) {
double level = data->get(sampleID, split_varID);
size_t factorID = floor(level) - 1;
size_t splitID = floor(split_value);
// Left if 0 found at position factorID
if (!(splitID & (1 << factorID))) {
sampleIDs[left_child_nodeID].push_back(sampleID);
} else {
sampleIDs[right_child_nodeID].push_back(sampleID);
}
}
}
// No terminal node
return false;
}
void Tree::init(Data* data, uint mtry, size_t dependent_varID, size_t num_samples, uint seed,
std::vector<size_t>* deterministic_varIDs, std::vector<size_t>* split_select_varIDs,
std::vector<double>* split_select_weights, ImportanceMode importance_mode, uint min_node_size,
std::vector<size_t>* no_split_variables, bool sample_with_replacement, std::vector<bool>* is_unordered,
bool memory_saving_splitting, SplitRule splitrule, std::vector<double>* case_weights, bool keep_inbag,
double sample_fraction) {
this->data = data;
this->mtry = mtry;
this->dependent_varID = dependent_varID;
this->num_samples = num_samples;
this->memory_saving_splitting = memory_saving_splitting;
// Create root node, assign bootstrap sample and oob samples
child_nodeIDs.push_back(std::vector<size_t>());
child_nodeIDs.push_back(std::vector<size_t>());
createEmptyNode();
// Initialize random number generator and set seed
random_number_generator.seed(seed);
this->deterministic_varIDs = deterministic_varIDs;
this->split_select_varIDs = split_select_varIDs;
this->split_select_weights = split_select_weights;
this->importance_mode = importance_mode;
this->min_node_size = min_node_size;
this->no_split_variables = no_split_variables;
this->is_ordered_variable = is_unordered;
this->sample_with_replacement = sample_with_replacement;
this->splitrule = splitrule;
this->case_weights = case_weights;
this->keep_inbag = keep_inbag;
this->sample_fraction = sample_fraction;
initInternal();
}
void pushToHeap(List l) {
end->L = l;
end->next = createEmptyNode();
end = end->next;
N++;
}
void initialize_SCHEME_HEAP() {
N = 0;
heap = createEmptyNode();
heap->next = createEmptyNode();
end = heap->next;
}
