src/mem/stack_dist_calc.hh

62   * layers, tree[0][5] gives a leaf node pointer for key=5 tree[1][1]
63   * gives an intermediate node pointer for key=1 tree[2][0] gives the
64   * root node in the tree.
71   * mark an old node in the tree is added. This is useful if it is
83   * At every unique transaction a new leaf node is added at tree[0](leaf layer)
89   * leaf at the returned index to the root, the old node is deleted
92   * found node. If this node was marked then a bool flag set to True
93   * is returned with the stack_distance. During this operation a node
96   * node is found with no children connected to it, then that is
104   * just inspect the tree, and mark a leaf node (if mark flag is set). The
105   * functionality to add a new node is removed.
113   * the found node.
115   * This function does NOT Modify the stack. (No node is added or
116   * deleted).  It is just used to mark a node already created and get
155   * updateTree() operation called when an intermediate node is
159   * tree and a new root node is initialized. The old node at the lower
160   * layer is connected to this.  In an intermediate node update
161   * operation a new intermediate node is added to the required layer.
186      * Gets sum from the node upwards recursively till the root.  This
190      * @param node pointer to the node which is updated
194      * @param level level in the tree the calling node is located
195      * @param stack_dist stack distance of the node below
199     uint64_t getSum(Node* node, bool from_left, uint64_t sum_from_below,
203      * Gets the sum from the leaf node specified. This function
206      * @param node pointer to the node which is updated
210     uint64_t getSumsLeavesToRoot(Node* node) const;
217      * @param node pointer to the node which is updated
221      * @param level level in the tree the calling node is located
222      * @param stack_dist stack distance of the node below
223      * @param discard_node whether the calling node was discarded or not
227     uint64_t updateSum(Node* node,
235      * @param node pointer to the node which is updated
236      * @param is_new_leaf is true if this is a newly added node
240     uint64_t updateSumsLeavesToRoot(Node* node, bool is_new_leaf);
247      * OP1. Moving the root node one layer up if index counter
256      * It recursively traverses upwards from the given node till
257      * the root to check if the ultimate parent node (root-node) points
260      * @param node pointer to the node whose sanity is being checked
261      * @param level the level at which this node is located in the tree
264     void sanityCheckTree(const Node* node, uint64_t level = 0) const;
320      * mark flag of the leaf node.
334      *  - delete old node if found in tree
335      *  - add a new node (if addNewNode flag is set)
340      * @param addNewNode If true, a new node is added to the tree
370         // Flag to mark the node as the right/left child
381          * the node is reached again in a future lookup.
394      * counter is incremented and a new leaf node is added in the tree