t/axmap.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <inttypes.h>
   4
   5 #include "../lib/lfsr.h"
   6 #include "../lib/axmap.h"
   7
   8 static int test_regular(size_t size, int seed)
   9 {
  10         struct fio_lfsr lfsr;
  11         struct axmap *map;
  12         size_t osize;
  13         uint64_t ff;
  14         int err;
  15
  16         printf("Using %llu entries...", (unsigned long long) size);
  17         fflush(stdout);
  18
  19         lfsr_init(&lfsr, size, seed, seed & 0xF);
  20         map = axmap_new(size);
  21         osize = size;
  22         err = 0;
  23
  24         while (size--) {
  25                 uint64_t val;
  26
  27                 if (lfsr_next(&lfsr, &val)) {
  28                         printf("lfsr: short loop\n");
  29                         err = 1;
  30                         break;
  31                 }
  32                 if (axmap_isset(map, val)) {
  33                         printf("bit already set\n");
  34                         err = 1;
  35                         break;
  36                 }
  37                 axmap_set(map, val);
  38                 if (!axmap_isset(map, val)) {
  39                         printf("bit not set\n");
  40                         err = 1;
  41                         break;
  42                 }
  43         }
  44
  45         if (err)
  46                 return err;
  47
  48         ff = axmap_next_free(map, osize);
  49         if (ff != (uint64_t) -1ULL) {
  50                 printf("axmap_next_free broken: got %llu\n", (unsigned long long) ff);
  51                 return 1;
  52         }
  53
  54         printf("pass!\n");
  55         axmap_free(map);
  56         return 0;
  57 }
  58
  59 static int test_multi(size_t size, unsigned int bit_off)
  60 {
  61         unsigned int map_size = size;
  62         struct axmap *map;
  63         uint64_t val = bit_off;
  64         int i, err;
  65
  66         printf("Test multi %llu entries %u offset...", (unsigned long long) size, bit_off);
  67         fflush(stdout);
  68
  69         map = axmap_new(map_size);
  70         while (val + 128 <= map_size) {
  71                 err = 0;
  72                 for (i = val; i < val + 128; i++) {
  73                         if (axmap_isset(map, val + i)) {
  74                                 printf("bit already set\n");
  75                                 err = 1;
  76                                 break;
  77                         }
  78                 }
  79
  80                 if (err)
  81                         break;
  82
  83                 err = axmap_set_nr(map, val, 128);
  84                 if (err != 128) {
  85                         printf("only set %u bits\n", err);
  86                         break;
  87                 }
  88
  89                 err = 0;
  90                 for (i = 0; i < 128; i++) {
  91                         if (!axmap_isset(map, val + i)) {
  92                                 printf("bit not set: %llu\n", (unsigned long long) val + i);
  93                                 err = 1;
  94                                 break;
  95                         }
  96                 }
  97
  98                 val += 128;
  99                 if (err)
 100                         break;
 101         }
 102
 103         if (!err)
 104                 printf("pass!\n");
 105
 106         axmap_free(map);
 107         return err;
 108 }
 109
 110 static int test_overlap(void)
 111 {
 112         struct axmap *map;
 113         int ret;
 114
 115         printf("Test overlaps...");
 116         fflush(stdout);
 117
 118         map = axmap_new(200);
 119
 120         ret = axmap_set_nr(map, 16, 16);
 121         if (ret != 16) {
 122                 printf("fail 0 16: %d\n", ret);
 123                 return 1;
 124         }
 125
 126         ret = axmap_set_nr(map, 0, 32);
 127         if (ret != 16) {
 128                 printf("fail 0 32: %d\n", ret);
 129                 return 1;
 130         }
 131
 132         ret = axmap_set_nr(map, 48, 32);
 133         if (ret != 32) {
 134                 printf("fail 48 32: %d\n", ret);
 135                 return 1;
 136         }
 137
 138         ret = axmap_set_nr(map, 32, 32);
 139         if (ret != 16) {
 140                 printf("fail 32 32: %d\n", ret);
 141                 return 1;
 142         }
 143
 144         ret = axmap_set_nr(map, 102, 1);
 145         if (ret != 1) {
 146                 printf("fail 102 1: %d\n", ret);
 147                 return 1;
 148         }
 149
 150         ret = axmap_set_nr(map, 101, 3);
 151         if (ret != 1) {
 152                 printf("fail 102 1: %d\n", ret);
 153                 return 1;
 154         }
 155
 156         ret = axmap_set_nr(map, 106, 4);
 157         if (ret != 4) {
 158                 printf("fail 106 4: %d\n", ret);
 159                 return 1;
 160         }
 161
 162         ret = axmap_set_nr(map, 105, 3);
 163         if (ret != 1) {
 164                 printf("fail 105 3: %d\n", ret);
 165                 return 1;
 166         }
 167
 168         ret = axmap_set_nr(map, 120, 4);
 169         if (ret != 4) {
 170                 printf("fail 120 4: %d\n", ret);
 171                 return 1;
 172         }
 173
 174         ret = axmap_set_nr(map, 118, 2);
 175         if (ret != 2) {
 176                 printf("fail 118 2: %d\n", ret);
 177                 return 1;
 178         }
 179
 180         ret = axmap_set_nr(map, 118, 2);
 181         if (ret != 0) {
 182                 printf("fail 118 2: %d\n", ret);
 183                 return 1;
 184         }
 185
 186         printf("pass!\n");
 187         axmap_free(map);
 188         return 0;
 189 }
 190
 191 int main(int argc, char *argv[])
 192 {
 193         size_t size = (1UL << 23) - 200;
 194         int seed = 1;
 195
 196         if (argc > 1) {
 197                 size = strtoul(argv[1], NULL, 10);
 198                 if (argc > 2)
 199                         seed = strtoul(argv[2], NULL, 10);
 200         }
 201
 202         if (test_regular(size, seed))
 203                 return 1;
 204         if (test_multi(size, 0))
 205                 return 2;
 206         if (test_multi(size, 17))
 207                 return 3;
 208         if (test_overlap())
 209                 return 4;
 210
 211         return 0;
 212 }