ovsdb-idl: Simplify transaction retry.
[openvswitch] / tests / test-heap.c
1 /*
2  * Copyright (c) 2012 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /* A test for for functions and macros declared in heap.h. */
18
19 #include <config.h>
20 #include "heap.h"
21 #include <inttypes.h>
22 #include <limits.h>
23 #include <stdlib.h>
24 #include "command-line.h"
25 #include "random.h"
26 #include "util.h"
27
28 #undef NDEBUG
29 #include <assert.h>
30
31 /* Sample heap element. */
32 struct element {
33     uint32_t full_pri;
34     struct heap_node heap_node;
35 };
36
37 static struct element *
38 element_from_heap_node(const struct heap_node *node)
39 {
40     return CONTAINER_OF(node, struct element, heap_node);
41 }
42
43 static int
44 compare_uint32s(const void *a_, const void *b_)
45 {
46     const uint32_t *a = a_;
47     const uint32_t *b = b_;
48     return *a < *b ? -1 : *a > *b;
49 }
50
51 /* Verifies that 'heap' is internally consistent and contains all 'n' of the
52  * 'priorities'. */
53 static void
54 check_heap(const struct heap *heap, const uint32_t priorities[], size_t n)
55 {
56     uint32_t *priorities_copy;
57     uint32_t *elements_copy;
58     struct element *element;
59     size_t i;
60
61     assert(heap_count(heap) == n);
62     assert(heap_is_empty(heap) == !n);
63     if (n > 0) {
64         assert(heap_max(heap) == heap->array[1]);
65     }
66
67     /* Check indexes. */
68     for (i = 1; i <= n; i++) {
69         assert(heap->array[i]->idx == i);
70     }
71
72     /* Check that priority values are internally consistent. */
73     for (i = 1; i <= n; i++) {
74         element = element_from_heap_node(heap->array[i]);
75         assert(element->heap_node.priority == (element->full_pri >> 16));
76     }
77
78     /* Check the heap property. */
79     for (i = 1; i <= n; i++) {
80         size_t parent = heap_parent__(i);
81         size_t left = heap_left__(i);
82         size_t right = heap_right__(i);
83
84         if (parent >= 1) {
85             assert(heap->array[parent]->priority >= heap->array[i]->priority);
86         }
87         if (left <= n) {
88             assert(heap->array[left]->priority <= heap->array[i]->priority);
89         }
90         if (right <= n) {
91             assert(heap->array[right]->priority <= heap->array[i]->priority);
92         }
93     }
94
95     /* Check that HEAP_FOR_EACH iterates all the nodes in order. */
96     i = 0;
97     HEAP_FOR_EACH (element, heap_node, heap) {
98         assert(i < n);
99         assert(&element->heap_node == heap->array[i + 1]);
100         i++;
101     }
102     assert(i == n);
103
104     priorities_copy = xmemdup(priorities, n * sizeof *priorities);
105     elements_copy = xmalloc(n * sizeof *priorities);
106     i = 0;
107     HEAP_FOR_EACH (element, heap_node, heap) {
108         elements_copy[i++] = element->heap_node.priority;
109     }
110
111     qsort(priorities_copy, n, sizeof *priorities_copy, compare_uint32s);
112     qsort(elements_copy, n, sizeof *elements_copy, compare_uint32s);
113     for (i = 0; i < n; i++) {
114         assert((priorities_copy[i] >> 16) == elements_copy[i]);
115     }
116
117     free(priorities_copy);
118     free(elements_copy);
119 }
120
121 static void
122 shuffle(uint32_t *p, size_t n)
123 {
124     for (; n > 1; n--, p++) {
125         uint32_t *q = &p[random_range(n)];
126         uint32_t tmp = *p;
127         *p = *q;
128         *q = tmp;
129     }
130 }
131
132 /* Prints the values in 'heap', plus 'name' as a title. */
133 static void OVS_UNUSED
134 print_heap(const char *name, struct heap *heap)
135 {
136     struct element *e;
137
138     printf("%s:", name);
139     HEAP_FOR_EACH (e, heap_node, heap) {
140         printf(" %"PRIu32":%"PRIu32, e->full_pri >> 16, e->full_pri & 0xffff);
141     }
142     printf("\n");
143 }
144
145 static int
146 factorial(int n_items)
147 {
148     int n, i;
149
150     n = 1;
151     for (i = 2; i <= n_items; i++) {
152         n *= i;
153     }
154     return n;
155 }
156
157 static void
158 swap(uint32_t *a, uint32_t *b)
159 {
160     uint32_t tmp = *a;
161     *a = *b;
162     *b = tmp;
163 }
164
165 static void
166 reverse(uint32_t *a, int n)
167 {
168     int i;
169
170     for (i = 0; i < n / 2; i++) {
171         int j = n - (i + 1);
172         swap(&a[i], &a[j]);
173     }
174 }
175
176 static bool
177 next_permutation(uint32_t *a, int n)
178 {
179     int k;
180
181     for (k = n - 2; k >= 0; k--) {
182         if ((a[k] >> 16) < (a[k + 1] >> 16)) {
183             int l;
184
185             for (l = n - 1; ; l--) {
186                 if ((a[l] >> 16) > (a[k] >> 16)) {
187                     swap(&a[k], &a[l]);
188                     reverse(a + (k + 1), n - (k + 1));
189                     return true;
190                 }
191             }
192         }
193     }
194     return false;
195 }
196
197 static void
198 test_insert_delete__(struct element *elements,
199                      const uint32_t *insert,
200                      const uint32_t *delete,
201                      size_t n)
202 {
203     struct heap heap;
204     size_t i;
205
206     heap_init(&heap);
207     check_heap(&heap, NULL, 0);
208     for (i = 0; i < n; i++) {
209         uint32_t priority = insert[i];
210
211         elements[i].full_pri = priority;
212         heap_insert(&heap, &elements[i].heap_node, priority >> 16);
213         check_heap(&heap, insert, i + 1);
214     }
215
216     for (i = 0; i < n; i++) {
217         struct element *element;
218
219         HEAP_FOR_EACH (element, heap_node, &heap) {
220             if (element->full_pri == delete[i]) {
221                 goto found;
222             }
223         }
224         NOT_REACHED();
225
226     found:
227         heap_remove(&heap, &element->heap_node);
228         check_heap(&heap, delete + i + 1, n - (i + 1));
229     }
230     heap_destroy(&heap);
231 }
232
233 static void
234 test_insert_delete_raw__(struct element *elements,
235                          const uint32_t *insert, unsigned int insert_pattern,
236                          const uint32_t *delete, unsigned int delete_pattern,
237                          size_t n)
238 {
239     struct heap heap;
240     size_t i;
241
242     heap_init(&heap);
243     check_heap(&heap, NULL, 0);
244     for (i = 0; i < n; i++) {
245         uint32_t priority = insert[i];
246
247         elements[i].full_pri = priority;
248         heap_raw_insert(&heap, &elements[i].heap_node, priority >> 16);
249         if (insert_pattern & (1u << i)) {
250             heap_rebuild(&heap);
251             check_heap(&heap, insert, i + 1);
252         }
253     }
254
255     for (i = 0; i < n; i++) {
256         struct element *element;
257
258         HEAP_FOR_EACH (element, heap_node, &heap) {
259             if (element->full_pri == delete[i]) {
260                 goto found;
261             }
262         }
263         NOT_REACHED();
264
265     found:
266         heap_raw_remove(&heap, &element->heap_node);
267         if (delete_pattern & (1u << i)) {
268             heap_rebuild(&heap);
269             check_heap(&heap, delete + i + 1, n - (i + 1));
270         }
271     }
272     heap_destroy(&heap);
273 }
274
275 static void
276 test_heap_insert_delete_same_order(int argc OVS_UNUSED,
277                                    char *argv[] OVS_UNUSED)
278 {
279     enum { N_ELEMS = 7 };
280
281     uint32_t insert[N_ELEMS];
282     int n_permutations;
283     size_t i;
284
285     for (i = 0; i < N_ELEMS; i++) {
286         insert[i] = i << 16;
287     }
288
289     n_permutations = 0;
290     do {
291         struct element elements[N_ELEMS];
292
293         n_permutations++;
294         test_insert_delete__(elements, insert, insert, N_ELEMS);
295     } while (next_permutation(insert, N_ELEMS));
296     assert(n_permutations == factorial(N_ELEMS));
297 }
298
299 static void
300 test_heap_insert_delete_reverse_order(int argc OVS_UNUSED,
301                                       char *argv[] OVS_UNUSED)
302 {
303     enum { N_ELEMS = 7 };
304
305     uint32_t insert[N_ELEMS];
306     int n_permutations;
307     size_t i;
308
309     for (i = 0; i < N_ELEMS; i++) {
310         insert[i] = i << 16;
311     }
312
313     n_permutations = 0;
314     do {
315         struct element elements[N_ELEMS];
316         uint32_t delete[N_ELEMS];
317
318         n_permutations++;
319
320         for (i = 0; i < N_ELEMS; i++) {
321             delete[N_ELEMS - i - 1] = insert[i];
322         }
323
324         test_insert_delete__(elements, insert, delete, N_ELEMS);
325     } while (next_permutation(insert, N_ELEMS));
326     assert(n_permutations == factorial(N_ELEMS));
327 }
328
329 static void
330 test_heap_insert_delete_every_order(int argc OVS_UNUSED,
331                                     char *argv[] OVS_UNUSED)
332 {
333     enum { N_ELEMS = 5 };
334
335     uint32_t insert[N_ELEMS];
336     int outer_permutations;
337     size_t i;
338
339     for (i = 0; i < N_ELEMS; i++) {
340         insert[i] = i << 16;
341     }
342
343     outer_permutations = 0;
344     do {
345         struct element elements[N_ELEMS];
346         uint32_t delete[N_ELEMS];
347         int inner_permutations;
348
349         outer_permutations++;
350
351         for (i = 0; i < N_ELEMS; i++) {
352             delete[i] = i << 16;
353         }
354
355         inner_permutations = 0;
356         do {
357             inner_permutations++;
358             test_insert_delete__(elements, insert, delete, N_ELEMS);
359         } while (next_permutation(delete, N_ELEMS));
360         assert(inner_permutations == factorial(N_ELEMS));
361     } while (next_permutation(insert, N_ELEMS));
362     assert(outer_permutations == factorial(N_ELEMS));
363 }
364
365 static void
366 test_heap_insert_delete_same_order_with_dups(int argc OVS_UNUSED,
367                                              char *argv[] OVS_UNUSED)
368 {
369     enum { N_ELEMS = 7 };
370
371     unsigned int pattern;
372     size_t i;
373
374     for (pattern = 0; pattern < (1u << N_ELEMS); pattern += 2) {
375         int n_permutations, expected_permutations;
376         uint32_t insert[N_ELEMS];
377         int j;
378
379         j = 0;
380         for (i = 0; i < N_ELEMS; i++) {
381             if (i && !(pattern & (1u << i))) {
382                 j++;
383             }
384             insert[i] = (j << 16) | i;
385         }
386
387         expected_permutations = factorial(N_ELEMS);
388         for (i = 0; i < N_ELEMS; ) {
389             j = i + 1;
390             if (pattern & (1u << i)) {
391                 for (; j < N_ELEMS; j++) {
392                     if (!(pattern & (1u << j))) {
393                         break;
394                     }
395                 }
396                 expected_permutations /= factorial(j - i + 1);
397             }
398             i = j;
399         }
400
401         n_permutations = 0;
402         do {
403             struct element elements[N_ELEMS];
404
405             n_permutations++;
406             test_insert_delete__(elements, insert, insert, N_ELEMS);
407         } while (next_permutation(insert, N_ELEMS));
408         assert(n_permutations == expected_permutations);
409     }
410 }
411
412 static void
413 test_heap_raw_insert(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
414 {
415     enum { N_ELEMS = 7 };
416
417     uint32_t insert[N_ELEMS];
418     int n_permutations;
419     size_t i;
420
421     for (i = 0; i < N_ELEMS; i++) {
422         insert[i] = i << 16;
423     }
424
425     n_permutations = 0;
426     do {
427         struct element elements[N_ELEMS];
428
429         n_permutations++;
430         test_insert_delete_raw__(elements,
431                                  insert, 1u << (N_ELEMS - 1),
432                                  insert, UINT_MAX,
433                                  N_ELEMS);
434     } while (next_permutation(insert, N_ELEMS));
435     assert(n_permutations == factorial(N_ELEMS));
436 }
437
438 static void
439 test_heap_raw_delete(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
440 {
441     enum { N_ELEMS = 16 };
442
443     uint32_t insert[N_ELEMS];
444     uint32_t delete[N_ELEMS];
445     size_t i;
446
447     for (i = 0; i < N_ELEMS; i++) {
448         insert[i] = i << 16;
449         delete[i] = i << 16;
450     }
451
452     for (i = 0; i < 1000; i++) {
453         struct element elements[N_ELEMS];
454
455         shuffle(insert, N_ELEMS);
456         shuffle(delete, N_ELEMS);
457
458         test_insert_delete_raw__(elements,
459                                  insert, 0,
460                                  delete,
461                                  (1u << (N_ELEMS - 1)) | (1u << (N_ELEMS / 2)),
462                                  N_ELEMS);
463     }
464 }
465
466 static const struct command commands[] = {
467     { "insert-delete-same-order", 0, 0, test_heap_insert_delete_same_order, },
468     { "insert-delete-reverse-order", 0, 0,
469       test_heap_insert_delete_reverse_order, },
470     { "insert-delete-every-order", 0, 0,
471       test_heap_insert_delete_every_order, },
472     { "insert-delete-same-order-with-dups", 0, 0,
473       test_heap_insert_delete_same_order_with_dups, },
474     { "raw-insert", 0, 0, test_heap_raw_insert, },
475     { "raw-delete", 0, 0, test_heap_raw_delete, },
476 };
477
478 int
479 main(int argc, char *argv[])
480 {
481     set_program_name(argv[0]);
482
483     run_command(argc - 1, argv + 1, commands);
484
485     return 0;
486 }