test/test/test_bitmap.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Cavium, Inc
   3  */
   4
   5 #include <stdio.h>
   6 #include <inttypes.h>
   7
   8 #include <rte_common.h>
   9 #include <rte_bitmap.h>
  10 #include <rte_malloc.h>
  11
  12 #include "test.h"
  13
  14 #define MAX_BITS 1000
  15
  16 static int
  17 test_bitmap_scan_operations(struct rte_bitmap *bmp)
  18 {
  19         uint32_t pos = 0;
  20         uint64_t slab1_magic = 0xBADC0FFEEBADF00D;
  21         uint64_t slab2_magic = 0xFEEDDEADDEADF00D;
  22         uint64_t out_slab = 0;
  23
  24         rte_bitmap_reset(bmp);
  25
  26         rte_bitmap_set_slab(bmp, pos, slab1_magic);
  27         rte_bitmap_set_slab(bmp, pos + RTE_BITMAP_SLAB_BIT_SIZE, slab2_magic);
  28
  29         if (!rte_bitmap_scan(bmp, &pos, &out_slab)) {
  30                 printf("Failed to get slab from bitmap.\n");
  31                 return TEST_FAILED;
  32         }
  33
  34         if (slab1_magic != out_slab) {
  35                 printf("Scan operation sanity failed.\n");
  36                 return TEST_FAILED;
  37         }
  38
  39         if (!rte_bitmap_scan(bmp, &pos, &out_slab)) {
  40                 printf("Failed to get slab from bitmap.\n");
  41                 return TEST_FAILED;
  42         }
  43
  44         if (slab2_magic != out_slab) {
  45                 printf("Scan operation sanity failed.\n");
  46                 return TEST_FAILED;
  47         }
  48
  49         /* Wrap around */
  50         if (!rte_bitmap_scan(bmp, &pos, &out_slab)) {
  51                 printf("Failed to get slab from bitmap.\n");
  52                 return TEST_FAILED;
  53         }
  54
  55         if (slab1_magic != out_slab) {
  56                 printf("Scan operation wrap around failed.\n");
  57                 return TEST_FAILED;
  58         }
  59
  60         /* Scan reset check. */
  61         __rte_bitmap_scan_init(bmp);
  62
  63         if (!rte_bitmap_scan(bmp, &pos, &out_slab)) {
  64                 printf("Failed to get slab from bitmap.\n");
  65                 return TEST_FAILED;
  66         }
  67
  68         if (slab1_magic != out_slab) {
  69                 printf("Scan reset operation failed.\n");
  70                 return TEST_FAILED;
  71         }
  72
  73         return TEST_SUCCESS;
  74 }
  75
  76 static int
  77 test_bitmap_slab_set_get(struct rte_bitmap *bmp)
  78 {
  79         uint32_t pos = 0;
  80         uint64_t slab_magic = 0xBADC0FFEEBADF00D;
  81         uint64_t out_slab = 0;
  82
  83         rte_bitmap_reset(bmp);
  84         rte_bitmap_set_slab(bmp, pos, slab_magic);
  85
  86         if (!rte_bitmap_scan(bmp, &pos, &out_slab)) {
  87                 printf("Failed to get slab from bitmap.\n");
  88                 return TEST_FAILED;
  89         }
  90
  91
  92         if (slab_magic != out_slab) {
  93                 printf("Invalid slab in bitmap.\n");
  94                 return TEST_FAILED;
  95         }
  96
  97
  98         return TEST_SUCCESS;
  99 }
 100
 101 static int
 102 test_bitmap_set_get_clear(struct rte_bitmap *bmp)
 103 {
 104         int i;
 105
 106         rte_bitmap_reset(bmp);
 107         for (i = 0; i < MAX_BITS; i++)
 108                 rte_bitmap_set(bmp, i);
 109
 110         for (i = 0; i < MAX_BITS; i++) {
 111                 if (!rte_bitmap_get(bmp, i)) {
 112                         printf("Failed to get set bit.\n");
 113                         return TEST_FAILED;
 114                 }
 115         }
 116
 117         for (i = 0; i < MAX_BITS; i++)
 118                 rte_bitmap_clear(bmp, i);
 119
 120         for (i = 0; i < MAX_BITS; i++) {
 121                 if (rte_bitmap_get(bmp, i)) {
 122                         printf("Failed to clear set bit.\n");
 123                         return TEST_FAILED;
 124                 }
 125         }
 126
 127         return TEST_SUCCESS;
 128 }
 129
 130 static int
 131 test_bitmap(void)
 132 {
 133         void *mem;
 134         uint32_t bmp_size;
 135         struct rte_bitmap *bmp;
 136
 137         bmp_size =
 138                 rte_bitmap_get_memory_footprint(MAX_BITS);
 139
 140         mem = rte_zmalloc("test_bmap", bmp_size, RTE_CACHE_LINE_SIZE);
 141         if (mem == NULL) {
 142                 printf("Failed to allocate memory for bitmap\n");
 143                 return TEST_FAILED;
 144         }
 145
 146         bmp = rte_bitmap_init(MAX_BITS, mem, bmp_size);
 147         if (bmp == NULL) {
 148                 printf("Failed to init bitmap\n");
 149                 return TEST_FAILED;
 150         }
 151
 152         if (test_bitmap_set_get_clear(bmp) < 0)
 153                 return TEST_FAILED;
 154
 155         if (test_bitmap_slab_set_get(bmp) < 0)
 156                 return TEST_FAILED;
 157
 158         if (test_bitmap_scan_operations(bmp) < 0)
 159                 return TEST_FAILED;
 160
 161         rte_bitmap_free(bmp);
 162         rte_free(mem);
 163
 164         return TEST_SUCCESS;
 165 }
 166
 167 REGISTER_TEST_COMMAND(bitmap_test, test_bitmap);