mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-07-09 04:27:12 +00:00
util: Add interval-tree.c
Copy and simplify the Linux kernel's interval_tree_generic.h, instantiating for uint64_t. Reviewed-by: Alex Bennée <alex.bennee@linaro.org> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson
parent
8540a1f695
commit
0d99d37a82
99
include/qemu/interval-tree.h
Normal file
99
include/qemu/interval-tree.h
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
/*
|
||||
* Interval trees.
|
||||
*
|
||||
* Derived from include/linux/interval_tree.h and its dependencies.
|
||||
*/
|
||||
|
||||
#ifndef QEMU_INTERVAL_TREE_H
|
||||
#define QEMU_INTERVAL_TREE_H
|
||||
|
||||
/*
|
||||
* For now, don't expose Linux Red-Black Trees separately, but retain the
|
||||
* separate type definitions to keep the implementation sane, and allow
|
||||
* the possibility of disentangling them later.
|
||||
*/
|
||||
typedef struct RBNode
|
||||
{
|
||||
/* Encodes parent with color in the lsb. */
|
||||
uintptr_t rb_parent_color;
|
||||
struct RBNode *rb_right;
|
||||
struct RBNode *rb_left;
|
||||
} RBNode;
|
||||
|
||||
typedef struct RBRoot
|
||||
{
|
||||
RBNode *rb_node;
|
||||
} RBRoot;
|
||||
|
||||
typedef struct RBRootLeftCached {
|
||||
RBRoot rb_root;
|
||||
RBNode *rb_leftmost;
|
||||
} RBRootLeftCached;
|
||||
|
||||
typedef struct IntervalTreeNode
|
||||
{
|
||||
RBNode rb;
|
||||
|
||||
uint64_t start; /* Start of interval */
|
||||
uint64_t last; /* Last location _in_ interval */
|
||||
uint64_t subtree_last;
|
||||
} IntervalTreeNode;
|
||||
|
||||
typedef RBRootLeftCached IntervalTreeRoot;
|
||||
|
||||
/**
|
||||
* interval_tree_is_empty
|
||||
* @root: root of the tree.
|
||||
*
|
||||
* Returns true if the tree contains no nodes.
|
||||
*/
|
||||
static inline bool interval_tree_is_empty(const IntervalTreeRoot *root)
|
||||
{
|
||||
return root->rb_root.rb_node == NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* interval_tree_insert
|
||||
* @node: node to insert,
|
||||
* @root: root of the tree.
|
||||
*
|
||||
* Insert @node into @root, and rebalance.
|
||||
*/
|
||||
void interval_tree_insert(IntervalTreeNode *node, IntervalTreeRoot *root);
|
||||
|
||||
/**
|
||||
* interval_tree_remove
|
||||
* @node: node to remove,
|
||||
* @root: root of the tree.
|
||||
*
|
||||
* Remove @node from @root, and rebalance.
|
||||
*/
|
||||
void interval_tree_remove(IntervalTreeNode *node, IntervalTreeRoot *root);
|
||||
|
||||
/**
|
||||
* interval_tree_iter_first:
|
||||
* @root: root of the tree,
|
||||
* @start, @last: the inclusive interval [start, last].
|
||||
*
|
||||
* Locate the "first" of a set of nodes within the tree at @root
|
||||
* that overlap the interval, where "first" is sorted by start.
|
||||
* Returns NULL if no overlap found.
|
||||
*/
|
||||
IntervalTreeNode *interval_tree_iter_first(IntervalTreeRoot *root,
|
||||
uint64_t start, uint64_t last);
|
||||
|
||||
/**
|
||||
* interval_tree_iter_next:
|
||||
* @node: previous search result
|
||||
* @start, @last: the inclusive interval [start, last].
|
||||
*
|
||||
* Locate the "next" of a set of nodes within the tree that overlap the
|
||||
* interval; @next is the result of a previous call to
|
||||
* interval_tree_iter_{first,next}. Returns NULL if @next was the last
|
||||
* node in the set.
|
||||
*/
|
||||
IntervalTreeNode *interval_tree_iter_next(IntervalTreeNode *node,
|
||||
uint64_t start, uint64_t last);
|
||||
|
||||
#endif /* QEMU_INTERVAL_TREE_H */
|
||||
|
|
@ -47,6 +47,7 @@ tests = {
|
|||
'ptimer-test': ['ptimer-test-stubs.c', meson.project_source_root() / 'hw/core/ptimer.c'],
|
||||
'test-qapi-util': [],
|
||||
'test-smp-parse': [qom, meson.project_source_root() / 'hw/core/machine-smp.c'],
|
||||
'test-interval-tree': [],
|
||||
}
|
||||
|
||||
if have_system or have_tools
|
||||
|
|
|
|||
209
tests/unit/test-interval-tree.c
Normal file
209
tests/unit/test-interval-tree.c
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
/*
|
||||
* Test interval trees
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/interval-tree.h"
|
||||
|
||||
static IntervalTreeNode nodes[20];
|
||||
static IntervalTreeRoot root;
|
||||
|
||||
static void rand_interval(IntervalTreeNode *n, uint64_t start, uint64_t last)
|
||||
{
|
||||
gint32 s_ofs, l_ofs, l_max;
|
||||
|
||||
if (last - start > INT32_MAX) {
|
||||
l_max = INT32_MAX;
|
||||
} else {
|
||||
l_max = last - start;
|
||||
}
|
||||
s_ofs = g_test_rand_int_range(0, l_max);
|
||||
l_ofs = g_test_rand_int_range(s_ofs, l_max);
|
||||
|
||||
n->start = start + s_ofs;
|
||||
n->last = start + l_ofs;
|
||||
}
|
||||
|
||||
static void test_empty(void)
|
||||
{
|
||||
g_assert(root.rb_root.rb_node == NULL);
|
||||
g_assert(root.rb_leftmost == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 0, UINT64_MAX) == NULL);
|
||||
}
|
||||
|
||||
static void test_find_one_point(void)
|
||||
{
|
||||
/* Create a tree of a single node, which is the point [1,1]. */
|
||||
nodes[0].start = 1;
|
||||
nodes[0].last = 1;
|
||||
|
||||
interval_tree_insert(&nodes[0], &root);
|
||||
|
||||
g_assert(interval_tree_iter_first(&root, 0, 9) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_next(&nodes[0], 0, 9) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 0, 0) == NULL);
|
||||
g_assert(interval_tree_iter_next(&nodes[0], 0, 0) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 0, 1) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 1, 1) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 1, 2) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 2, 2) == NULL);
|
||||
|
||||
interval_tree_remove(&nodes[0], &root);
|
||||
g_assert(root.rb_root.rb_node == NULL);
|
||||
g_assert(root.rb_leftmost == NULL);
|
||||
}
|
||||
|
||||
static void test_find_two_point(void)
|
||||
{
|
||||
IntervalTreeNode *find0, *find1;
|
||||
|
||||
/* Create a tree of a two nodes, which are both the point [1,1]. */
|
||||
nodes[0].start = 1;
|
||||
nodes[0].last = 1;
|
||||
nodes[1] = nodes[0];
|
||||
|
||||
interval_tree_insert(&nodes[0], &root);
|
||||
interval_tree_insert(&nodes[1], &root);
|
||||
|
||||
find0 = interval_tree_iter_first(&root, 0, 9);
|
||||
g_assert(find0 == &nodes[0] || find0 == &nodes[1]);
|
||||
|
||||
find1 = interval_tree_iter_next(find0, 0, 9);
|
||||
g_assert(find1 == &nodes[0] || find1 == &nodes[1]);
|
||||
g_assert(find0 != find1);
|
||||
|
||||
interval_tree_remove(&nodes[1], &root);
|
||||
|
||||
g_assert(interval_tree_iter_first(&root, 0, 9) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_next(&nodes[0], 0, 9) == NULL);
|
||||
|
||||
interval_tree_remove(&nodes[0], &root);
|
||||
}
|
||||
|
||||
static void test_find_one_range(void)
|
||||
{
|
||||
/* Create a tree of a single node, which is the range [1,8]. */
|
||||
nodes[0].start = 1;
|
||||
nodes[0].last = 8;
|
||||
|
||||
interval_tree_insert(&nodes[0], &root);
|
||||
|
||||
g_assert(interval_tree_iter_first(&root, 0, 9) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_next(&nodes[0], 0, 9) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 0, 0) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 0, 1) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 1, 1) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 4, 6) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 8, 8) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 9, 9) == NULL);
|
||||
|
||||
interval_tree_remove(&nodes[0], &root);
|
||||
}
|
||||
|
||||
static void test_find_one_range_many(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Create a tree of many nodes in [0,99] and [200,299],
|
||||
* but only one node with exactly [110,190].
|
||||
*/
|
||||
nodes[0].start = 110;
|
||||
nodes[0].last = 190;
|
||||
|
||||
for (i = 1; i < ARRAY_SIZE(nodes) / 2; ++i) {
|
||||
rand_interval(&nodes[i], 0, 99);
|
||||
}
|
||||
for (; i < ARRAY_SIZE(nodes); ++i) {
|
||||
rand_interval(&nodes[i], 200, 299);
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(nodes); ++i) {
|
||||
interval_tree_insert(&nodes[i], &root);
|
||||
}
|
||||
|
||||
/* Test that we find exactly the one node. */
|
||||
g_assert(interval_tree_iter_first(&root, 100, 199) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_next(&nodes[0], 100, 199) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 100, 109) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 100, 110) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 111, 120) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 111, 199) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 190, 199) == &nodes[0]);
|
||||
g_assert(interval_tree_iter_first(&root, 192, 199) == NULL);
|
||||
|
||||
/*
|
||||
* Test that if there are multiple matches, we return the one
|
||||
* with the minimal start.
|
||||
*/
|
||||
g_assert(interval_tree_iter_first(&root, 100, 300) == &nodes[0]);
|
||||
|
||||
/* Test that we don't find it after it is removed. */
|
||||
interval_tree_remove(&nodes[0], &root);
|
||||
g_assert(interval_tree_iter_first(&root, 100, 199) == NULL);
|
||||
|
||||
for (i = 1; i < ARRAY_SIZE(nodes); ++i) {
|
||||
interval_tree_remove(&nodes[i], &root);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_find_many_range(void)
|
||||
{
|
||||
IntervalTreeNode *find;
|
||||
int i, n;
|
||||
|
||||
n = g_test_rand_int_range(ARRAY_SIZE(nodes) / 3, ARRAY_SIZE(nodes) / 2);
|
||||
|
||||
/*
|
||||
* Create a fair few nodes in [2000,2999], with the others
|
||||
* distributed around.
|
||||
*/
|
||||
for (i = 0; i < n; ++i) {
|
||||
rand_interval(&nodes[i], 2000, 2999);
|
||||
}
|
||||
for (; i < ARRAY_SIZE(nodes) * 2 / 3; ++i) {
|
||||
rand_interval(&nodes[i], 1000, 1899);
|
||||
}
|
||||
for (; i < ARRAY_SIZE(nodes); ++i) {
|
||||
rand_interval(&nodes[i], 3100, 3999);
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(nodes); ++i) {
|
||||
interval_tree_insert(&nodes[i], &root);
|
||||
}
|
||||
|
||||
/* Test that we find all of the nodes. */
|
||||
find = interval_tree_iter_first(&root, 2000, 2999);
|
||||
for (i = 0; find != NULL; i++) {
|
||||
find = interval_tree_iter_next(find, 2000, 2999);
|
||||
}
|
||||
g_assert_cmpint(i, ==, n);
|
||||
|
||||
g_assert(interval_tree_iter_first(&root, 0, 999) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 1900, 1999) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 3000, 3099) == NULL);
|
||||
g_assert(interval_tree_iter_first(&root, 4000, UINT64_MAX) == NULL);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(nodes); ++i) {
|
||||
interval_tree_remove(&nodes[i], &root);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
g_test_init(&argc, &argv, NULL);
|
||||
|
||||
g_test_add_func("/interval-tree/empty", test_empty);
|
||||
g_test_add_func("/interval-tree/find-one-point", test_find_one_point);
|
||||
g_test_add_func("/interval-tree/find-two-point", test_find_two_point);
|
||||
g_test_add_func("/interval-tree/find-one-range", test_find_one_range);
|
||||
g_test_add_func("/interval-tree/find-one-range-many",
|
||||
test_find_one_range_many);
|
||||
g_test_add_func("/interval-tree/find-many-range", test_find_many_range);
|
||||
|
||||
return g_test_run();
|
||||
}
|
||||
882
util/interval-tree.c
Normal file
882
util/interval-tree.c
Normal file
|
|
@ -0,0 +1,882 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/interval-tree.h"
|
||||
#include "qemu/atomic.h"
|
||||
|
||||
/*
|
||||
* Red Black Trees.
|
||||
*
|
||||
* For now, don't expose Linux Red-Black Trees separately, but retain the
|
||||
* separate type definitions to keep the implementation sane, and allow
|
||||
* the possibility of separating them later.
|
||||
*
|
||||
* Derived from include/linux/rbtree_augmented.h and its dependencies.
|
||||
*/
|
||||
|
||||
/*
|
||||
* red-black trees properties: https://en.wikipedia.org/wiki/Rbtree
|
||||
*
|
||||
* 1) A node is either red or black
|
||||
* 2) The root is black
|
||||
* 3) All leaves (NULL) are black
|
||||
* 4) Both children of every red node are black
|
||||
* 5) Every simple path from root to leaves contains the same number
|
||||
* of black nodes.
|
||||
*
|
||||
* 4 and 5 give the O(log n) guarantee, since 4 implies you cannot have two
|
||||
* consecutive red nodes in a path and every red node is therefore followed by
|
||||
* a black. So if B is the number of black nodes on every simple path (as per
|
||||
* 5), then the longest possible path due to 4 is 2B.
|
||||
*
|
||||
* We shall indicate color with case, where black nodes are uppercase and red
|
||||
* nodes will be lowercase. Unknown color nodes shall be drawn as red within
|
||||
* parentheses and have some accompanying text comment.
|
||||
*
|
||||
* Notes on lockless lookups:
|
||||
*
|
||||
* All stores to the tree structure (rb_left and rb_right) must be done using
|
||||
* WRITE_ONCE [qatomic_set for QEMU]. And we must not inadvertently cause
|
||||
* (temporary) loops in the tree structure as seen in program order.
|
||||
*
|
||||
* These two requirements will allow lockless iteration of the tree -- not
|
||||
* correct iteration mind you, tree rotations are not atomic so a lookup might
|
||||
* miss entire subtrees.
|
||||
*
|
||||
* But they do guarantee that any such traversal will only see valid elements
|
||||
* and that it will indeed complete -- does not get stuck in a loop.
|
||||
*
|
||||
* It also guarantees that if the lookup returns an element it is the 'correct'
|
||||
* one. But not returning an element does _NOT_ mean it's not present.
|
||||
*
|
||||
* NOTE:
|
||||
*
|
||||
* Stores to __rb_parent_color are not important for simple lookups so those
|
||||
* are left undone as of now. Nor did I check for loops involving parent
|
||||
* pointers.
|
||||
*/
|
||||
|
||||
typedef enum RBColor
|
||||
{
|
||||
RB_RED,
|
||||
RB_BLACK,
|
||||
} RBColor;
|
||||
|
||||
typedef struct RBAugmentCallbacks {
|
||||
void (*propagate)(RBNode *node, RBNode *stop);
|
||||
void (*copy)(RBNode *old, RBNode *new);
|
||||
void (*rotate)(RBNode *old, RBNode *new);
|
||||
} RBAugmentCallbacks;
|
||||
|
||||
static inline RBNode *rb_parent(const RBNode *n)
|
||||
{
|
||||
return (RBNode *)(n->rb_parent_color & ~1);
|
||||
}
|
||||
|
||||
static inline RBNode *rb_red_parent(const RBNode *n)
|
||||
{
|
||||
return (RBNode *)n->rb_parent_color;
|
||||
}
|
||||
|
||||
static inline RBColor pc_color(uintptr_t pc)
|
||||
{
|
||||
return (RBColor)(pc & 1);
|
||||
}
|
||||
|
||||
static inline bool pc_is_red(uintptr_t pc)
|
||||
{
|
||||
return pc_color(pc) == RB_RED;
|
||||
}
|
||||
|
||||
static inline bool pc_is_black(uintptr_t pc)
|
||||
{
|
||||
return !pc_is_red(pc);
|
||||
}
|
||||
|
||||
static inline RBColor rb_color(const RBNode *n)
|
||||
{
|
||||
return pc_color(n->rb_parent_color);
|
||||
}
|
||||
|
||||
static inline bool rb_is_red(const RBNode *n)
|
||||
{
|
||||
return pc_is_red(n->rb_parent_color);
|
||||
}
|
||||
|
||||
static inline bool rb_is_black(const RBNode *n)
|
||||
{
|
||||
return pc_is_black(n->rb_parent_color);
|
||||
}
|
||||
|
||||
static inline void rb_set_black(RBNode *n)
|
||||
{
|
||||
n->rb_parent_color |= RB_BLACK;
|
||||
}
|
||||
|
||||
static inline void rb_set_parent_color(RBNode *n, RBNode *p, RBColor color)
|
||||
{
|
||||
n->rb_parent_color = (uintptr_t)p | color;
|
||||
}
|
||||
|
||||
static inline void rb_set_parent(RBNode *n, RBNode *p)
|
||||
{
|
||||
rb_set_parent_color(n, p, rb_color(n));
|
||||
}
|
||||
|
||||
static inline void rb_link_node(RBNode *node, RBNode *parent, RBNode **rb_link)
|
||||
{
|
||||
node->rb_parent_color = (uintptr_t)parent;
|
||||
node->rb_left = node->rb_right = NULL;
|
||||
|
||||
qatomic_set(rb_link, node);
|
||||
}
|
||||
|
||||
static RBNode *rb_next(RBNode *node)
|
||||
{
|
||||
RBNode *parent;
|
||||
|
||||
/* OMIT: if empty node, return null. */
|
||||
|
||||
/*
|
||||
* If we have a right-hand child, go down and then left as far as we can.
|
||||
*/
|
||||
if (node->rb_right) {
|
||||
node = node->rb_right;
|
||||
while (node->rb_left) {
|
||||
node = node->rb_left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
/*
|
||||
* No right-hand children. Everything down and left is smaller than us,
|
||||
* so any 'next' node must be in the general direction of our parent.
|
||||
* Go up the tree; any time the ancestor is a right-hand child of its
|
||||
* parent, keep going up. First time it's a left-hand child of its
|
||||
* parent, said parent is our 'next' node.
|
||||
*/
|
||||
while ((parent = rb_parent(node)) && node == parent->rb_right) {
|
||||
node = parent;
|
||||
}
|
||||
|
||||
return parent;
|
||||
}
|
||||
|
||||
static inline void rb_change_child(RBNode *old, RBNode *new,
|
||||
RBNode *parent, RBRoot *root)
|
||||
{
|
||||
if (!parent) {
|
||||
qatomic_set(&root->rb_node, new);
|
||||
} else if (parent->rb_left == old) {
|
||||
qatomic_set(&parent->rb_left, new);
|
||||
} else {
|
||||
qatomic_set(&parent->rb_right, new);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void rb_rotate_set_parents(RBNode *old, RBNode *new,
|
||||
RBRoot *root, RBColor color)
|
||||
{
|
||||
RBNode *parent = rb_parent(old);
|
||||
|
||||
new->rb_parent_color = old->rb_parent_color;
|
||||
rb_set_parent_color(old, new, color);
|
||||
rb_change_child(old, new, parent, root);
|
||||
}
|
||||
|
||||
static void rb_insert_augmented(RBNode *node, RBRoot *root,
|
||||
const RBAugmentCallbacks *augment)
|
||||
{
|
||||
RBNode *parent = rb_red_parent(node), *gparent, *tmp;
|
||||
|
||||
while (true) {
|
||||
/*
|
||||
* Loop invariant: node is red.
|
||||
*/
|
||||
if (unlikely(!parent)) {
|
||||
/*
|
||||
* The inserted node is root. Either this is the first node, or
|
||||
* we recursed at Case 1 below and are no longer violating 4).
|
||||
*/
|
||||
rb_set_parent_color(node, NULL, RB_BLACK);
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If there is a black parent, we are done. Otherwise, take some
|
||||
* corrective action as, per 4), we don't want a red root or two
|
||||
* consecutive red nodes.
|
||||
*/
|
||||
if (rb_is_black(parent)) {
|
||||
break;
|
||||
}
|
||||
|
||||
gparent = rb_red_parent(parent);
|
||||
|
||||
tmp = gparent->rb_right;
|
||||
if (parent != tmp) { /* parent == gparent->rb_left */
|
||||
if (tmp && rb_is_red(tmp)) {
|
||||
/*
|
||||
* Case 1 - node's uncle is red (color flips).
|
||||
*
|
||||
* G g
|
||||
* / \ / \
|
||||
* p u --> P U
|
||||
* / /
|
||||
* n n
|
||||
*
|
||||
* However, since g's parent might be red, and 4) does not
|
||||
* allow this, we need to recurse at g.
|
||||
*/
|
||||
rb_set_parent_color(tmp, gparent, RB_BLACK);
|
||||
rb_set_parent_color(parent, gparent, RB_BLACK);
|
||||
node = gparent;
|
||||
parent = rb_parent(node);
|
||||
rb_set_parent_color(node, parent, RB_RED);
|
||||
continue;
|
||||
}
|
||||
|
||||
tmp = parent->rb_right;
|
||||
if (node == tmp) {
|
||||
/*
|
||||
* Case 2 - node's uncle is black and node is
|
||||
* the parent's right child (left rotate at parent).
|
||||
*
|
||||
* G G
|
||||
* / \ / \
|
||||
* p U --> n U
|
||||
* \ /
|
||||
* n p
|
||||
*
|
||||
* This still leaves us in violation of 4), the
|
||||
* continuation into Case 3 will fix that.
|
||||
*/
|
||||
tmp = node->rb_left;
|
||||
qatomic_set(&parent->rb_right, tmp);
|
||||
qatomic_set(&node->rb_left, parent);
|
||||
if (tmp) {
|
||||
rb_set_parent_color(tmp, parent, RB_BLACK);
|
||||
}
|
||||
rb_set_parent_color(parent, node, RB_RED);
|
||||
augment->rotate(parent, node);
|
||||
parent = node;
|
||||
tmp = node->rb_right;
|
||||
}
|
||||
|
||||
/*
|
||||
* Case 3 - node's uncle is black and node is
|
||||
* the parent's left child (right rotate at gparent).
|
||||
*
|
||||
* G P
|
||||
* / \ / \
|
||||
* p U --> n g
|
||||
* / \
|
||||
* n U
|
||||
*/
|
||||
qatomic_set(&gparent->rb_left, tmp); /* == parent->rb_right */
|
||||
qatomic_set(&parent->rb_right, gparent);
|
||||
if (tmp) {
|
||||
rb_set_parent_color(tmp, gparent, RB_BLACK);
|
||||
}
|
||||
rb_rotate_set_parents(gparent, parent, root, RB_RED);
|
||||
augment->rotate(gparent, parent);
|
||||
break;
|
||||
} else {
|
||||
tmp = gparent->rb_left;
|
||||
if (tmp && rb_is_red(tmp)) {
|
||||
/* Case 1 - color flips */
|
||||
rb_set_parent_color(tmp, gparent, RB_BLACK);
|
||||
rb_set_parent_color(parent, gparent, RB_BLACK);
|
||||
node = gparent;
|
||||
parent = rb_parent(node);
|
||||
rb_set_parent_color(node, parent, RB_RED);
|
||||
continue;
|
||||
}
|
||||
|
||||
tmp = parent->rb_left;
|
||||
if (node == tmp) {
|
||||
/* Case 2 - right rotate at parent */
|
||||
tmp = node->rb_right;
|
||||
qatomic_set(&parent->rb_left, tmp);
|
||||
qatomic_set(&node->rb_right, parent);
|
||||
if (tmp) {
|
||||
rb_set_parent_color(tmp, parent, RB_BLACK);
|
||||
}
|
||||
rb_set_parent_color(parent, node, RB_RED);
|
||||
augment->rotate(parent, node);
|
||||
parent = node;
|
||||
tmp = node->rb_left;
|
||||
}
|
||||
|
||||
/* Case 3 - left rotate at gparent */
|
||||
qatomic_set(&gparent->rb_right, tmp); /* == parent->rb_left */
|
||||
qatomic_set(&parent->rb_left, gparent);
|
||||
if (tmp) {
|
||||
rb_set_parent_color(tmp, gparent, RB_BLACK);
|
||||
}
|
||||
rb_rotate_set_parents(gparent, parent, root, RB_RED);
|
||||
augment->rotate(gparent, parent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void rb_insert_augmented_cached(RBNode *node,
|
||||
RBRootLeftCached *root, bool newleft,
|
||||
const RBAugmentCallbacks *augment)
|
||||
{
|
||||
if (newleft) {
|
||||
root->rb_leftmost = node;
|
||||
}
|
||||
rb_insert_augmented(node, &root->rb_root, augment);
|
||||
}
|
||||
|
||||
static void rb_erase_color(RBNode *parent, RBRoot *root,
|
||||
const RBAugmentCallbacks *augment)
|
||||
{
|
||||
RBNode *node = NULL, *sibling, *tmp1, *tmp2;
|
||||
|
||||
while (true) {
|
||||
/*
|
||||
* Loop invariants:
|
||||
* - node is black (or NULL on first iteration)
|
||||
* - node is not the root (parent is not NULL)
|
||||
* - All leaf paths going through parent and node have a
|
||||
* black node count that is 1 lower than other leaf paths.
|
||||
*/
|
||||
sibling = parent->rb_right;
|
||||
if (node != sibling) { /* node == parent->rb_left */
|
||||
if (rb_is_red(sibling)) {
|
||||
/*
|
||||
* Case 1 - left rotate at parent
|
||||
*
|
||||
* P S
|
||||
* / \ / \
|
||||
* N s --> p Sr
|
||||
* / \ / \
|
||||
* Sl Sr N Sl
|
||||
*/
|
||||
tmp1 = sibling->rb_left;
|
||||
qatomic_set(&parent->rb_right, tmp1);
|
||||
qatomic_set(&sibling->rb_left, parent);
|
||||
rb_set_parent_color(tmp1, parent, RB_BLACK);
|
||||
rb_rotate_set_parents(parent, sibling, root, RB_RED);
|
||||
augment->rotate(parent, sibling);
|
||||
sibling = tmp1;
|
||||
}
|
||||
tmp1 = sibling->rb_right;
|
||||
if (!tmp1 || rb_is_black(tmp1)) {
|
||||
tmp2 = sibling->rb_left;
|
||||
if (!tmp2 || rb_is_black(tmp2)) {
|
||||
/*
|
||||
* Case 2 - sibling color flip
|
||||
* (p could be either color here)
|
||||
*
|
||||
* (p) (p)
|
||||
* / \ / \
|
||||
* N S --> N s
|
||||
* / \ / \
|
||||
* Sl Sr Sl Sr
|
||||
*
|
||||
* This leaves us violating 5) which
|
||||
* can be fixed by flipping p to black
|
||||
* if it was red, or by recursing at p.
|
||||
* p is red when coming from Case 1.
|
||||
*/
|
||||
rb_set_parent_color(sibling, parent, RB_RED);
|
||||
if (rb_is_red(parent)) {
|
||||
rb_set_black(parent);
|
||||
} else {
|
||||
node = parent;
|
||||
parent = rb_parent(node);
|
||||
if (parent) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* Case 3 - right rotate at sibling
|
||||
* (p could be either color here)
|
||||
*
|
||||
* (p) (p)
|
||||
* / \ / \
|
||||
* N S --> N sl
|
||||
* / \ \
|
||||
* sl Sr S
|
||||
* \
|
||||
* Sr
|
||||
*
|
||||
* Note: p might be red, and then bot
|
||||
* p and sl are red after rotation (which
|
||||
* breaks property 4). This is fixed in
|
||||
* Case 4 (in rb_rotate_set_parents()
|
||||
* which set sl the color of p
|
||||
* and set p RB_BLACK)
|
||||
*
|
||||
* (p) (sl)
|
||||
* / \ / \
|
||||
* N sl --> P S
|
||||
* \ / \
|
||||
* S N Sr
|
||||
* \
|
||||
* Sr
|
||||
*/
|
||||
tmp1 = tmp2->rb_right;
|
||||
qatomic_set(&sibling->rb_left, tmp1);
|
||||
qatomic_set(&tmp2->rb_right, sibling);
|
||||
qatomic_set(&parent->rb_right, tmp2);
|
||||
if (tmp1) {
|
||||
rb_set_parent_color(tmp1, sibling, RB_BLACK);
|
||||
}
|
||||
augment->rotate(sibling, tmp2);
|
||||
tmp1 = sibling;
|
||||
sibling = tmp2;
|
||||
}
|
||||
/*
|
||||
* Case 4 - left rotate at parent + color flips
|
||||
* (p and sl could be either color here.
|
||||
* After rotation, p becomes black, s acquires
|
||||
* p's color, and sl keeps its color)
|
||||
*
|
||||
* (p) (s)
|
||||
* / \ / \
|
||||
* N S --> P Sr
|
||||
* / \ / \
|
||||
* (sl) sr N (sl)
|
||||
*/
|
||||
tmp2 = sibling->rb_left;
|
||||
qatomic_set(&parent->rb_right, tmp2);
|
||||
qatomic_set(&sibling->rb_left, parent);
|
||||
rb_set_parent_color(tmp1, sibling, RB_BLACK);
|
||||
if (tmp2) {
|
||||
rb_set_parent(tmp2, parent);
|
||||
}
|
||||
rb_rotate_set_parents(parent, sibling, root, RB_BLACK);
|
||||
augment->rotate(parent, sibling);
|
||||
break;
|
||||
} else {
|
||||
sibling = parent->rb_left;
|
||||
if (rb_is_red(sibling)) {
|
||||
/* Case 1 - right rotate at parent */
|
||||
tmp1 = sibling->rb_right;
|
||||
qatomic_set(&parent->rb_left, tmp1);
|
||||
qatomic_set(&sibling->rb_right, parent);
|
||||
rb_set_parent_color(tmp1, parent, RB_BLACK);
|
||||
rb_rotate_set_parents(parent, sibling, root, RB_RED);
|
||||
augment->rotate(parent, sibling);
|
||||
sibling = tmp1;
|
||||
}
|
||||
tmp1 = sibling->rb_left;
|
||||
if (!tmp1 || rb_is_black(tmp1)) {
|
||||
tmp2 = sibling->rb_right;
|
||||
if (!tmp2 || rb_is_black(tmp2)) {
|
||||
/* Case 2 - sibling color flip */
|
||||
rb_set_parent_color(sibling, parent, RB_RED);
|
||||
if (rb_is_red(parent)) {
|
||||
rb_set_black(parent);
|
||||
} else {
|
||||
node = parent;
|
||||
parent = rb_parent(node);
|
||||
if (parent) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
/* Case 3 - left rotate at sibling */
|
||||
tmp1 = tmp2->rb_left;
|
||||
qatomic_set(&sibling->rb_right, tmp1);
|
||||
qatomic_set(&tmp2->rb_left, sibling);
|
||||
qatomic_set(&parent->rb_left, tmp2);
|
||||
if (tmp1) {
|
||||
rb_set_parent_color(tmp1, sibling, RB_BLACK);
|
||||
}
|
||||
augment->rotate(sibling, tmp2);
|
||||
tmp1 = sibling;
|
||||
sibling = tmp2;
|
||||
}
|
||||
/* Case 4 - right rotate at parent + color flips */
|
||||
tmp2 = sibling->rb_right;
|
||||
qatomic_set(&parent->rb_left, tmp2);
|
||||
qatomic_set(&sibling->rb_right, parent);
|
||||
rb_set_parent_color(tmp1, sibling, RB_BLACK);
|
||||
if (tmp2) {
|
||||
rb_set_parent(tmp2, parent);
|
||||
}
|
||||
rb_rotate_set_parents(parent, sibling, root, RB_BLACK);
|
||||
augment->rotate(parent, sibling);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void rb_erase_augmented(RBNode *node, RBRoot *root,
|
||||
const RBAugmentCallbacks *augment)
|
||||
{
|
||||
RBNode *child = node->rb_right;
|
||||
RBNode *tmp = node->rb_left;
|
||||
RBNode *parent, *rebalance;
|
||||
uintptr_t pc;
|
||||
|
||||
if (!tmp) {
|
||||
/*
|
||||
* Case 1: node to erase has no more than 1 child (easy!)
|
||||
*
|
||||
* Note that if there is one child it must be red due to 5)
|
||||
* and node must be black due to 4). We adjust colors locally
|
||||
* so as to bypass rb_erase_color() later on.
|
||||
*/
|
||||
pc = node->rb_parent_color;
|
||||
parent = rb_parent(node);
|
||||
rb_change_child(node, child, parent, root);
|
||||
if (child) {
|
||||
child->rb_parent_color = pc;
|
||||
rebalance = NULL;
|
||||
} else {
|
||||
rebalance = pc_is_black(pc) ? parent : NULL;
|
||||
}
|
||||
tmp = parent;
|
||||
} else if (!child) {
|
||||
/* Still case 1, but this time the child is node->rb_left */
|
||||
pc = node->rb_parent_color;
|
||||
parent = rb_parent(node);
|
||||
tmp->rb_parent_color = pc;
|
||||
rb_change_child(node, tmp, parent, root);
|
||||
rebalance = NULL;
|
||||
tmp = parent;
|
||||
} else {
|
||||
RBNode *successor = child, *child2;
|
||||
tmp = child->rb_left;
|
||||
if (!tmp) {
|
||||
/*
|
||||
* Case 2: node's successor is its right child
|
||||
*
|
||||
* (n) (s)
|
||||
* / \ / \
|
||||
* (x) (s) -> (x) (c)
|
||||
* \
|
||||
* (c)
|
||||
*/
|
||||
parent = successor;
|
||||
child2 = successor->rb_right;
|
||||
|
||||
augment->copy(node, successor);
|
||||
} else {
|
||||
/*
|
||||
* Case 3: node's successor is leftmost under
|
||||
* node's right child subtree
|
||||
*
|
||||
* (n) (s)
|
||||
* / \ / \
|
||||
* (x) (y) -> (x) (y)
|
||||
* / /
|
||||
* (p) (p)
|
||||
* / /
|
||||
* (s) (c)
|
||||
* \
|
||||
* (c)
|
||||
*/
|
||||
do {
|
||||
parent = successor;
|
||||
successor = tmp;
|
||||
tmp = tmp->rb_left;
|
||||
} while (tmp);
|
||||
child2 = successor->rb_right;
|
||||
qatomic_set(&parent->rb_left, child2);
|
||||
qatomic_set(&successor->rb_right, child);
|
||||
rb_set_parent(child, successor);
|
||||
|
||||
augment->copy(node, successor);
|
||||
augment->propagate(parent, successor);
|
||||
}
|
||||
|
||||
tmp = node->rb_left;
|
||||
qatomic_set(&successor->rb_left, tmp);
|
||||
rb_set_parent(tmp, successor);
|
||||
|
||||
pc = node->rb_parent_color;
|
||||
tmp = rb_parent(node);
|
||||
rb_change_child(node, successor, tmp, root);
|
||||
|
||||
if (child2) {
|
||||
rb_set_parent_color(child2, parent, RB_BLACK);
|
||||
rebalance = NULL;
|
||||
} else {
|
||||
rebalance = rb_is_black(successor) ? parent : NULL;
|
||||
}
|
||||
successor->rb_parent_color = pc;
|
||||
tmp = successor;
|
||||
}
|
||||
|
||||
augment->propagate(tmp, NULL);
|
||||
|
||||
if (rebalance) {
|
||||
rb_erase_color(rebalance, root, augment);
|
||||
}
|
||||
}
|
||||
|
||||
static void rb_erase_augmented_cached(RBNode *node, RBRootLeftCached *root,
|
||||
const RBAugmentCallbacks *augment)
|
||||
{
|
||||
if (root->rb_leftmost == node) {
|
||||
root->rb_leftmost = rb_next(node);
|
||||
}
|
||||
rb_erase_augmented(node, &root->rb_root, augment);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Interval trees.
|
||||
*
|
||||
* Derived from lib/interval_tree.c and its dependencies,
|
||||
* especially include/linux/interval_tree_generic.h.
|
||||
*/
|
||||
|
||||
#define rb_to_itree(N) container_of(N, IntervalTreeNode, rb)
|
||||
|
||||
static bool interval_tree_compute_max(IntervalTreeNode *node, bool exit)
|
||||
{
|
||||
IntervalTreeNode *child;
|
||||
uint64_t max = node->last;
|
||||
|
||||
if (node->rb.rb_left) {
|
||||
child = rb_to_itree(node->rb.rb_left);
|
||||
if (child->subtree_last > max) {
|
||||
max = child->subtree_last;
|
||||
}
|
||||
}
|
||||
if (node->rb.rb_right) {
|
||||
child = rb_to_itree(node->rb.rb_right);
|
||||
if (child->subtree_last > max) {
|
||||
max = child->subtree_last;
|
||||
}
|
||||
}
|
||||
if (exit && node->subtree_last == max) {
|
||||
return true;
|
||||
}
|
||||
node->subtree_last = max;
|
||||
return false;
|
||||
}
|
||||
|
||||
static void interval_tree_propagate(RBNode *rb, RBNode *stop)
|
||||
{
|
||||
while (rb != stop) {
|
||||
IntervalTreeNode *node = rb_to_itree(rb);
|
||||
if (interval_tree_compute_max(node, true)) {
|
||||
break;
|
||||
}
|
||||
rb = rb_parent(&node->rb);
|
||||
}
|
||||
}
|
||||
|
||||
static void interval_tree_copy(RBNode *rb_old, RBNode *rb_new)
|
||||
{
|
||||
IntervalTreeNode *old = rb_to_itree(rb_old);
|
||||
IntervalTreeNode *new = rb_to_itree(rb_new);
|
||||
|
||||
new->subtree_last = old->subtree_last;
|
||||
}
|
||||
|
||||
static void interval_tree_rotate(RBNode *rb_old, RBNode *rb_new)
|
||||
{
|
||||
IntervalTreeNode *old = rb_to_itree(rb_old);
|
||||
IntervalTreeNode *new = rb_to_itree(rb_new);
|
||||
|
||||
new->subtree_last = old->subtree_last;
|
||||
interval_tree_compute_max(old, false);
|
||||
}
|
||||
|
||||
static const RBAugmentCallbacks interval_tree_augment = {
|
||||
.propagate = interval_tree_propagate,
|
||||
.copy = interval_tree_copy,
|
||||
.rotate = interval_tree_rotate,
|
||||
};
|
||||
|
||||
/* Insert / remove interval nodes from the tree */
|
||||
void interval_tree_insert(IntervalTreeNode *node, IntervalTreeRoot *root)
|
||||
{
|
||||
RBNode **link = &root->rb_root.rb_node, *rb_parent = NULL;
|
||||
uint64_t start = node->start, last = node->last;
|
||||
IntervalTreeNode *parent;
|
||||
bool leftmost = true;
|
||||
|
||||
while (*link) {
|
||||
rb_parent = *link;
|
||||
parent = rb_to_itree(rb_parent);
|
||||
|
||||
if (parent->subtree_last < last) {
|
||||
parent->subtree_last = last;
|
||||
}
|
||||
if (start < parent->start) {
|
||||
link = &parent->rb.rb_left;
|
||||
} else {
|
||||
link = &parent->rb.rb_right;
|
||||
leftmost = false;
|
||||
}
|
||||
}
|
||||
|
||||
node->subtree_last = last;
|
||||
rb_link_node(&node->rb, rb_parent, link);
|
||||
rb_insert_augmented_cached(&node->rb, root, leftmost,
|
||||
&interval_tree_augment);
|
||||
}
|
||||
|
||||
void interval_tree_remove(IntervalTreeNode *node, IntervalTreeRoot *root)
|
||||
{
|
||||
rb_erase_augmented_cached(&node->rb, root, &interval_tree_augment);
|
||||
}
|
||||
|
||||
/*
|
||||
* Iterate over intervals intersecting [start;last]
|
||||
*
|
||||
* Note that a node's interval intersects [start;last] iff:
|
||||
* Cond1: node->start <= last
|
||||
* and
|
||||
* Cond2: start <= node->last
|
||||
*/
|
||||
|
||||
static IntervalTreeNode *interval_tree_subtree_search(IntervalTreeNode *node,
|
||||
uint64_t start,
|
||||
uint64_t last)
|
||||
{
|
||||
while (true) {
|
||||
/*
|
||||
* Loop invariant: start <= node->subtree_last
|
||||
* (Cond2 is satisfied by one of the subtree nodes)
|
||||
*/
|
||||
if (node->rb.rb_left) {
|
||||
IntervalTreeNode *left = rb_to_itree(node->rb.rb_left);
|
||||
|
||||
if (start <= left->subtree_last) {
|
||||
/*
|
||||
* Some nodes in left subtree satisfy Cond2.
|
||||
* Iterate to find the leftmost such node N.
|
||||
* If it also satisfies Cond1, that's the
|
||||
* match we are looking for. Otherwise, there
|
||||
* is no matching interval as nodes to the
|
||||
* right of N can't satisfy Cond1 either.
|
||||
*/
|
||||
node = left;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (node->start <= last) { /* Cond1 */
|
||||
if (start <= node->last) { /* Cond2 */
|
||||
return node; /* node is leftmost match */
|
||||
}
|
||||
if (node->rb.rb_right) {
|
||||
node = rb_to_itree(node->rb.rb_right);
|
||||
if (start <= node->subtree_last) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL; /* no match */
|
||||
}
|
||||
}
|
||||
|
||||
IntervalTreeNode *interval_tree_iter_first(IntervalTreeRoot *root,
|
||||
uint64_t start, uint64_t last)
|
||||
{
|
||||
IntervalTreeNode *node, *leftmost;
|
||||
|
||||
if (!root->rb_root.rb_node) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fastpath range intersection/overlap between A: [a0, a1] and
|
||||
* B: [b0, b1] is given by:
|
||||
*
|
||||
* a0 <= b1 && b0 <= a1
|
||||
*
|
||||
* ... where A holds the lock range and B holds the smallest
|
||||
* 'start' and largest 'last' in the tree. For the later, we
|
||||
* rely on the root node, which by augmented interval tree
|
||||
* property, holds the largest value in its last-in-subtree.
|
||||
* This allows mitigating some of the tree walk overhead for
|
||||
* for non-intersecting ranges, maintained and consulted in O(1).
|
||||
*/
|
||||
node = rb_to_itree(root->rb_root.rb_node);
|
||||
if (node->subtree_last < start) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
leftmost = rb_to_itree(root->rb_leftmost);
|
||||
if (leftmost->start > last) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return interval_tree_subtree_search(node, start, last);
|
||||
}
|
||||
|
||||
IntervalTreeNode *interval_tree_iter_next(IntervalTreeNode *node,
|
||||
uint64_t start, uint64_t last)
|
||||
{
|
||||
RBNode *rb = node->rb.rb_right, *prev;
|
||||
|
||||
while (true) {
|
||||
/*
|
||||
* Loop invariants:
|
||||
* Cond1: node->start <= last
|
||||
* rb == node->rb.rb_right
|
||||
*
|
||||
* First, search right subtree if suitable
|
||||
*/
|
||||
if (rb) {
|
||||
IntervalTreeNode *right = rb_to_itree(rb);
|
||||
|
||||
if (start <= right->subtree_last) {
|
||||
return interval_tree_subtree_search(right, start, last);
|
||||
}
|
||||
}
|
||||
|
||||
/* Move up the tree until we come from a node's left child */
|
||||
do {
|
||||
rb = rb_parent(&node->rb);
|
||||
if (!rb) {
|
||||
return NULL;
|
||||
}
|
||||
prev = &node->rb;
|
||||
node = rb_to_itree(rb);
|
||||
rb = node->rb.rb_right;
|
||||
} while (prev == rb);
|
||||
|
||||
/* Check if the node intersects [start;last] */
|
||||
if (last < node->start) { /* !Cond1 */
|
||||
return NULL;
|
||||
}
|
||||
if (start <= node->last) { /* Cond2 */
|
||||
return node;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Occasionally useful for calling from within the debugger. */
|
||||
#if 0
|
||||
static void debug_interval_tree_int(IntervalTreeNode *node,
|
||||
const char *dir, int level)
|
||||
{
|
||||
printf("%4d %*s %s [%" PRIu64 ",%" PRIu64 "] subtree_last:%" PRIu64 "\n",
|
||||
level, level + 1, dir, rb_is_red(&node->rb) ? "r" : "b",
|
||||
node->start, node->last, node->subtree_last);
|
||||
|
||||
if (node->rb.rb_left) {
|
||||
debug_interval_tree_int(rb_to_itree(node->rb.rb_left), "<", level + 1);
|
||||
}
|
||||
if (node->rb.rb_right) {
|
||||
debug_interval_tree_int(rb_to_itree(node->rb.rb_right), ">", level + 1);
|
||||
}
|
||||
}
|
||||
|
||||
void debug_interval_tree(IntervalTreeNode *node);
|
||||
void debug_interval_tree(IntervalTreeNode *node)
|
||||
{
|
||||
if (node) {
|
||||
debug_interval_tree_int(node, "*", 0);
|
||||
} else {
|
||||
printf("null\n");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
@ -57,6 +57,7 @@ util_ss.add(files('guest-random.c'))
|
|||
util_ss.add(files('yank.c'))
|
||||
util_ss.add(files('int128.c'))
|
||||
util_ss.add(files('memalign.c'))
|
||||
util_ss.add(files('interval-tree.c'))
|
||||
|
||||
if have_user
|
||||
util_ss.add(files('selfmap.c'))
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user