Subversion Repositories HelenOS

Rev

Rev 4055 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4055 Rev 4296
Line 39... Line 39...
39
/*
39
/*
40
 * avl tree nodes in array for faster allocation
40
 * avl tree nodes in array for faster allocation
41
 */
41
 */
42
static avltree_node_t avltree_nodes[NODE_COUNT];
42
static avltree_node_t avltree_nodes[NODE_COUNT];
43
 
43
 
44
/*
44
/*
45
 * head of free nodes' list:
45
 * head of free nodes' list:
46
 */
46
 */
47
static avltree_node_t *first_free_node = NULL;
47
static avltree_node_t *first_free_node = NULL;
48
 
48
 
49
static int test_tree_balance(avltree_node_t *node);
49
static int test_tree_balance(avltree_node_t *node);
Line 56... Line 56...
56
{
56
{
57
    avltree_node_t *tmp;
57
    avltree_node_t *tmp;
58
   
58
   
59
    if (!node)
59
    if (!node)
60
        return NULL;
60
        return NULL;
61
 
61
   
62
    if (node->lft) {
62
    if (node->lft) {
63
        tmp = test_tree_parents(node->lft);
63
        tmp = test_tree_parents(node->lft);
64
        if (tmp != node) {
64
        if (tmp != node) {
65
            printf("Bad parent pointer key: %" PRIu64
65
            TPRINTF("Bad parent pointer key: %" PRIu64
66
                ", address: %p\n", tmp->key, node->lft);
66
                ", address: %p\n", tmp->key, node->lft);
67
        }
67
        }
68
    }
68
    }
69
    if (node->rgt) {
69
    if (node->rgt) {
70
        tmp = test_tree_parents(node->rgt);
70
        tmp = test_tree_parents(node->rgt);
71
        if (tmp != node) {
71
        if (tmp != node) {
72
            printf("Bad parent pointer key: %" PRIu64
72
            TPRINTF("Bad parent pointer key: %" PRIu64
73
                ", address: %p\n",
73
                ", address: %p\n",
74
                tmp->key,node->rgt);
74
                tmp->key,node->rgt);
75
        }
75
        }
76
    }
76
    }
77
    return node->par;
77
    return node->par;
78
}
78
}
79
 
79
 
80
int test_tree_balance(avltree_node_t *node)
80
int test_tree_balance(avltree_node_t *node)
81
{
81
{
82
    int h1, h2, diff;
82
    int h1, h2, diff;
83
 
83
   
84
    if (!node)
84
    if (!node)
85
        return 0;
85
        return 0;
-
 
86
   
86
    h1 = test_tree_balance(node->lft);
87
    h1 = test_tree_balance(node->lft);
87
    h2 = test_tree_balance(node->rgt);
88
    h2 = test_tree_balance(node->rgt);
88
    diff = h2 - h1;
89
    diff = h2 - h1;
-
 
90
   
89
    if (diff != node->balance || (diff != -1 && diff != 0 && diff != 1)) {
91
    if ((diff != node->balance) || ((diff != -1) && (diff != 0) && (diff != 1)))
90
        printf("Bad balance\n");
92
        TPRINTF("Bad balance\n");
91
    }
93
   
92
    return h1 > h2 ? h1 + 1 : h2 + 1;
94
    return ((h1 > h2) ? (h1 + 1) : (h2 + 1));
93
}
95
}
94
 
96
 
95
/**
97
/**
96
 * Prints the structure of the node, which is level levels from the top of the
98
 * Prints the structure of the node, which is level levels from the top of the
97
 * tree.
99
 * tree.
98
 */
100
 */
99
static void
-
 
100
print_tree_structure_flat(avltree_node_t *node, int level)
101
static void print_tree_structure_flat(avltree_node_t *node, int level)
101
{
102
{
102
    /*
103
    /*
103
     * You can set the maximum level as high as you like.
104
     * You can set the maximum level as high as you like.
104
         * Most of the time, you'll want to debug code using small trees,
105
     * Most of the time, you'll want to debug code using small trees,
105
         * so that a large level indicates a loop, which is a bug.
106
     * so that a large level indicates a loop, which is a bug.
106
     */
107
     */
107
    if (level > 16) {
108
    if (level > 16) {
108
        printf("[...]");
109
        TPRINTF("[...]");
109
        return;
110
        return;
110
    }
111
    }
111
 
112
   
112
    if (node == NULL)
113
    if (node == NULL)
113
        return;
114
        return;
114
 
115
   
115
    printf("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance);
116
    TPRINTF("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance);
116
    if (node->lft != NULL || node->rgt != NULL) {
117
    if (node->lft != NULL || node->rgt != NULL) {
117
        printf("(");
118
        TPRINTF("(");
118
 
119
       
119
        print_tree_structure_flat(node->lft, level + 1);
120
        print_tree_structure_flat(node->lft, level + 1);
120
        if (node->rgt != NULL) {
121
        if (node->rgt != NULL) {
121
            printf(",");
122
            TPRINTF(",");
122
            print_tree_structure_flat(node->rgt, level + 1);
123
            print_tree_structure_flat(node->rgt, level + 1);
123
        }
124
        }
124
 
125
       
125
        printf(")");
126
        TPRINTF(")");
126
    }
127
    }
127
}
128
}
128
 
129
 
129
static void alloc_avltree_node_prepare(void)
130
static void alloc_avltree_node_prepare(void)
130
{
131
{
131
    int i;
132
    int i;
132
 
133
   
133
    for (i = 0; i < NODE_COUNT - 1; i++) {
134
    for (i = 0; i < NODE_COUNT - 1; i++)
134
        avltree_nodes[i].par = &avltree_nodes[i + 1];
135
        avltree_nodes[i].par = &avltree_nodes[i + 1];
135
    }
136
   
136
    avltree_nodes[i].par = NULL;
137
    avltree_nodes[i].par = NULL;
137
   
138
   
138
    /*
139
    /*
139
     * Node keys which will be used for insertion. Up to NODE_COUNT size of
140
     * Node keys which will be used for insertion. Up to NODE_COUNT size of
140
     * array.
141
     * array.
141
     */
142
     */
142
 
143
   
143
    /* First tree node and same key */
144
    /* First tree node and same key */
144
    avltree_nodes[0].key = 60;
145
    avltree_nodes[0].key = 60;
145
    avltree_nodes[1].key = 60;
146
    avltree_nodes[1].key = 60;
146
    avltree_nodes[2].key = 60;
147
    avltree_nodes[2].key = 60;
-
 
148
   
147
    /* LL rotation */
149
    /* LL rotation */
148
    avltree_nodes[3].key = 50;
150
    avltree_nodes[3].key = 50;
149
    avltree_nodes[4].key = 40;
151
    avltree_nodes[4].key = 40;
150
    avltree_nodes[5].key = 30;
152
    avltree_nodes[5].key = 30;
-
 
153
   
151
    /* LR rotation */
154
    /* LR rotation */
152
    avltree_nodes[6].key = 20;
155
    avltree_nodes[6].key = 20;
153
    avltree_nodes[7].key = 20;
156
    avltree_nodes[7].key = 20;
154
    avltree_nodes[8].key = 25;
157
    avltree_nodes[8].key = 25;
155
    avltree_nodes[9].key = 25;
158
    avltree_nodes[9].key = 25;
-
 
159
   
156
    /* LL rotation in lower floor */
160
    /* LL rotation in lower floor */
157
    avltree_nodes[10].key = 35;
161
    avltree_nodes[10].key = 35;
-
 
162
   
158
    /* RR rotation */
163
    /* RR rotation */
159
    avltree_nodes[11].key = 70;
164
    avltree_nodes[11].key = 70;
160
    avltree_nodes[12].key = 80;
165
    avltree_nodes[12].key = 80;
-
 
166
   
161
    /* RL rotation */
167
    /* RL rotation */
162
    avltree_nodes[13].key = 90;
168
    avltree_nodes[13].key = 90;
163
    avltree_nodes[14].key = 85;
169
    avltree_nodes[14].key = 85;
-
 
170
   
164
    /* Insert 0 key */
171
    /* Insert 0 key */
165
    avltree_nodes[15].key = 0;
172
    avltree_nodes[15].key = 0;
166
    avltree_nodes[16].key = 0;
173
    avltree_nodes[16].key = 0;
-
 
174
   
167
    /* Insert reverse */
175
    /* Insert reverse */
168
    avltree_nodes[17].key = 600;
176
    avltree_nodes[17].key = 600;
169
    avltree_nodes[18].key = 500;
177
    avltree_nodes[18].key = 500;
170
    avltree_nodes[19].key = 400;
178
    avltree_nodes[19].key = 400;
171
    avltree_nodes[20].key = 300;
179
    avltree_nodes[20].key = 300;
172
 
180
   
173
    for (i = 21; i < NODE_COUNT; i++)
181
    for (i = 21; i < NODE_COUNT; i++)
174
        avltree_nodes[i].key = i * 3;
182
        avltree_nodes[i].key = i * 3;
175
   
183
   
176
    first_free_node = &avltree_nodes[0];
184
    first_free_node = &avltree_nodes[0];
177
}
185
}
178
 
186
 
179
static avltree_node_t *alloc_avltree_node(void)
187
static avltree_node_t *alloc_avltree_node(void)
180
{
188
{
181
    avltree_node_t *node;
189
    avltree_node_t *node;
182
 
190
   
183
    node = first_free_node;
191
    node = first_free_node;
184
    first_free_node = first_free_node->par;
192
    first_free_node = first_free_node->par;
185
 
193
   
186
    return node;
194
    return node;
187
}
195
}
188
 
196
 
189
static void test_tree_insert(avltree_t *tree, count_t node_count, bool quiet)
197
static void test_tree_insert(avltree_t *tree, count_t node_count)
190
{
198
{
191
    unsigned int i;
199
    unsigned int i;
192
    avltree_node_t *newnode;
200
    avltree_node_t *newnode;
193
 
201
   
194
    avltree_create(tree);
202
    avltree_create(tree);
195
   
203
   
196
    if (!quiet)
-
 
197
        printf("Inserting %" PRIc " nodes...", node_count);
204
    TPRINTF("Inserting %" PRIc " nodes...", node_count);
198
 
205
   
199
    for (i = 0; i < node_count; i++) {
206
    for (i = 0; i < node_count; i++) {
200
        newnode = alloc_avltree_node();
207
        newnode = alloc_avltree_node();
201
       
208
       
202
        avltree_insert(tree, newnode);
209
        avltree_insert(tree, newnode);
203
        if (!quiet) {
-
 
204
            test_tree_parents(tree->root);
210
        test_tree_parents(tree->root);
205
            test_tree_balance(tree->root);
211
        test_tree_balance(tree->root);
206
        }
-
 
207
    }
212
    }
208
       
213
   
209
    if (!quiet)
-
 
210
        printf("done.\n");
214
    TPRINTF("done.\n");
211
}
215
}
212
 
216
 
213
 
-
 
214
static void test_tree_delete(avltree_t *tree, count_t node_count,
217
static void test_tree_delete(avltree_t *tree, count_t node_count,
215
    int node_position, bool quiet)
218
    int node_position)
216
{
219
{
217
    avltree_node_t *delnode;
220
    avltree_node_t *delnode;
218
    unsigned int i;
221
    unsigned int i;
219
   
222
   
220
    switch (node_position) {
223
    switch (node_position) {
221
    case 0:
224
    case 0:
222
        if (!quiet)
-
 
223
            printf("Deleting root nodes...");
225
        TPRINTF("Deleting root nodes...");
-
 
226
       
224
        while (tree->root != NULL) {
227
        while (tree->root != NULL) {
225
            delnode = tree->root;
228
            delnode = tree->root;
226
            avltree_delete(tree, delnode);
229
            avltree_delete(tree, delnode);
227
            if (!quiet) {
-
 
228
                test_tree_parents(tree->root);
230
            test_tree_parents(tree->root);
229
                test_tree_balance(tree->root);
231
            test_tree_balance(tree->root);
230
            }
-
 
231
        }
232
        }
232
        break;
233
        break;
233
    case 1:
234
    case 1:
234
        if (!quiet)
-
 
235
            printf("Deleting nodes according to creation time...");
235
        TPRINTF("Deleting nodes according to creation time...");
-
 
236
       
236
        for (i = 0; i < node_count; i++) {
237
        for (i = 0; i < node_count; i++) {
237
            avltree_delete(tree, &avltree_nodes[i]);
238
            avltree_delete(tree, &avltree_nodes[i]);
238
            if (!quiet) {
-
 
239
                test_tree_parents(tree->root);
239
            test_tree_parents(tree->root);
240
                test_tree_balance(tree->root);
240
            test_tree_balance(tree->root);
241
            }
-
 
242
        }
241
        }
243
        break; 
242
        break;
244
    }
243
    }
245
   
244
   
246
    if (!quiet)
-
 
247
        printf("done.\n");
245
    TPRINTF("done.\n");
248
}
246
}
249
 
247
 
250
static void test_tree_delmin(avltree_t *tree, count_t node_count, bool quiet)
248
static void test_tree_delmin(avltree_t *tree, count_t node_count)
251
{
249
{
252
    unsigned int i = 0;
250
    unsigned int i = 0;
253
   
251
   
254
    if (!quiet)
-
 
255
        printf("Deleting minimum nodes...");
252
    TPRINTF("Deleting minimum nodes...");
256
   
253
   
257
    while (tree->root != NULL) {
254
    while (tree->root != NULL) {
258
        i++;
255
        i++;
259
        avltree_delete_min(tree);
256
        avltree_delete_min(tree);
260
        if (!quiet) {
-
 
261
            test_tree_parents(tree->root);
257
        test_tree_parents(tree->root);
262
            test_tree_balance(tree->root);
258
        test_tree_balance(tree->root);
263
        }
-
 
264
    }
259
    }
265
 
260
   
266
    if (!quiet && (i != node_count))
261
    if (i != node_count)
267
        printf("Bad node count. Some nodes have been lost!\n");
262
        TPRINTF("Bad node count. Some nodes have been lost!\n");
268
 
263
   
269
    if (!quiet)
-
 
270
        printf("done.\n");
264
    TPRINTF("done.\n");
271
}
265
}
272
 
266
 
273
char *test_avltree1(bool quiet)
267
char *test_avltree1(void)
274
{
268
{
275
    alloc_avltree_node_prepare();
269
    alloc_avltree_node_prepare();
276
    test_tree_insert(&avltree, NODE_COUNT, quiet);
270
    test_tree_insert(&avltree, NODE_COUNT);
277
    test_tree_delete(&avltree, NODE_COUNT, 0, quiet);
271
    test_tree_delete(&avltree, NODE_COUNT, 0);
278
 
272
   
279
    alloc_avltree_node_prepare();
273
    alloc_avltree_node_prepare();
280
    test_tree_insert(&avltree, NODE_COUNT, quiet);
274
    test_tree_insert(&avltree, NODE_COUNT);
281
    test_tree_delete(&avltree, NODE_COUNT, 1, quiet);
275
    test_tree_delete(&avltree, NODE_COUNT, 1);
282
 
276
   
283
    alloc_avltree_node_prepare();
277
    alloc_avltree_node_prepare();
284
    test_tree_insert(&avltree, NODE_COUNT, quiet);
278
    test_tree_insert(&avltree, NODE_COUNT);
285
    test_tree_delmin(&avltree, NODE_COUNT, quiet);
279
    test_tree_delmin(&avltree, NODE_COUNT);
286
 
280
   
287
    return NULL;
281
    return NULL;
288
}
282
}
289
 
-