Happy new year.
[idzebra-moved-to-github.git] / isamb / tstisamb.c
1 /* This file is part of the Zebra server.
2    Copyright (C) 1994-2011 Index Data
3
4 Zebra is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 #if HAVE_SYS_TIMES_H
21 #include <sys/times.h>
22 #endif
23 #if HAVE_SYS_TIME_H
24 #include <sys/time.h>
25 #endif
26
27 #include <stdlib.h>
28 #include <string.h>
29 #include <yaz/log.h>
30 #include <yaz/xmalloc.h>
31 #include <idzebra/isamb.h>
32 #include <assert.h>
33
34 static int log_level = 0;
35
36 static void log_item(int level, const void *b, const char *txt)
37 {
38     int x;
39     memcpy(&x, b, sizeof(int));
40     yaz_log(log_level, "%s %d", txt, x);
41 }
42
43 static void log_pr(const char *txt)
44 {
45     yaz_log(log_level, "%s", txt);
46 }
47
48 int compare_item(const void *a, const void *b)
49 {
50     int ia, ib;
51
52     memcpy(&ia, a, sizeof(int));
53     memcpy(&ib, b, sizeof(int));
54     if (ia > ib)
55         return 1;
56     if (ia < ib)
57         return -1;
58    return 0;
59 }
60
61 void *code_start(void)
62 {
63     return 0;
64 }
65
66 void code_item(void *p, char **dst, const char **src)
67 {
68     memcpy (*dst, *src, sizeof(int));
69     (*dst) += sizeof(int);
70     (*src) += sizeof(int);
71 }
72
73 void code_reset(void *p)
74 {
75 }
76 void code_stop(void *p)
77 {
78 }
79
80 struct read_info {
81     int val;
82     int step;
83
84     int no;
85     int max;
86     int insertMode;
87 };
88
89 int code_read(void *vp, char **dst, int *insertMode)
90 {
91     struct read_info *ri = (struct read_info *)vp;
92     int x;
93
94     if (ri->no >= ri->max)
95         return 0;
96     ri->no++;
97
98     x = ri->val;
99     memcpy (*dst, &x, sizeof(int));
100     (*dst)+=sizeof(int);
101
102     ri->val = ri->val + ri->step;
103     *insertMode = ri->insertMode;
104
105 #if 0
106     yaz_log(log_level, "%d %5d", ri->insertMode, x);
107 #endif
108     return 1;
109 }
110
111 void tst_insert(ISAMB isb, int n)
112 {
113     ISAMC_I isamc_i;
114     ISAM_P isamc_p;
115     struct read_info ri;
116     ISAMB_PP pp;
117     char key_buf[20];
118     int nerrs = 0;
119
120     /* insert a number of entries */
121     ri.no = 0;
122     ri.max = n;
123
124     ri.val = 0;
125     ri.step = 1;
126     ri.insertMode = 1;
127
128     isamc_i.clientData = &ri;
129     isamc_i.read_item = code_read;
130     
131     isamc_p = 0; /* new list */
132     isamb_merge (isb, &isamc_p , &isamc_i);
133
134     /* read the entries */
135     pp = isamb_pp_open (isb, isamc_p, 1);
136
137     ri.val = 0;
138     while(isamb_pp_read (pp, key_buf))
139     {
140         int x;
141         memcpy (&x, key_buf, sizeof(int));
142         if (x != ri.val)
143         {
144             yaz_log(YLOG_WARN, "isamb_pp_read. n=%d Got %d (expected %d)",
145                     n, x, ri.val);
146             nerrs++;
147         }
148         else if (nerrs)
149             yaz_log(log_level, "isamb_pp_read. n=%d Got %d",
150                     n, x);
151
152         ri.val++;
153     }
154     if (ri.val != ri.max)
155     {
156         yaz_log(YLOG_WARN, "ri.max != ri.max (%d != %d)", ri.val, ri.max);
157         nerrs++;
158     }
159     isamb_dump(isb, isamc_p, log_pr);
160     isamb_pp_close(pp);
161
162     if (nerrs)
163         exit(3);
164     /* delete a number of entries (even ones) */
165     ri.no = 0;
166     ri.max = n - n/2;
167
168     ri.val = 0;
169     ri.step = 2;
170     ri.insertMode = 0;
171
172     isamc_i.clientData = &ri;
173     isamc_i.read_item = code_read;
174     
175     isamb_merge (isb, &isamc_p , &isamc_i);
176
177     /* delete a number of entries (odd ones) */
178     ri.no = 0;
179     ri.max = n/2;
180
181     ri.val = 1;
182     ri.step = 2;
183     ri.insertMode = 0;
184
185     isamc_i.clientData = &ri;
186     isamc_i.read_item = code_read;
187     
188     isamb_merge (isb, &isamc_p, &isamc_i);
189
190     if (isamc_p)
191     {
192         yaz_log(YLOG_WARN, "isamb_merge did not return empty list n=%d",
193                 n);
194         exit(3);
195     }
196 }
197
198 void tst_forward(ISAMB isb, int n)
199 {
200     ISAMC_I isamc_i;
201     ISAM_P isamc_p;
202     struct read_info ri;
203     int i;
204     ISAMB_PP pp;
205
206     /* insert a number of entries */
207     ri.val = 0;
208     ri.max = n;
209
210     ri.no = 0;
211     ri.step = 1;
212     ri.insertMode = 1;
213
214     isamc_i.clientData = &ri;
215     isamc_i.read_item = code_read;
216     
217     isamc_p = 0;
218     isamb_merge (isb, &isamc_p, &isamc_i);
219
220     /* read the entries */
221     pp = isamb_pp_open (isb, isamc_p, 1);
222     
223     for (i = 0; i<ri.max; i +=2 )
224     {
225         int x = -1;
226         int xu = i;
227         isamb_pp_forward(pp, &x, &xu);
228         if (x != xu && xu != x+1)
229         {
230             yaz_log(YLOG_WARN, "isamb_pp_forward (1). Got %d (expected %d)",
231                     x, xu);
232             exit(4);
233         }
234         ri.no++;
235     }
236     isamb_pp_close(pp);
237     
238     pp = isamb_pp_open (isb, isamc_p, 1);
239     for (i = 0; i<ri.max; i += 100)
240     {
241         int x = -1;
242         int xu = i;
243         isamb_pp_forward(pp, &x, &xu);
244         if (x != xu && xu != x+1)
245         {
246             yaz_log(YLOG_WARN, "isamb_pp_forward (2). Got %d (expected %d)",
247                     x, xu);
248             exit(4);
249         }
250         ri.no++;
251     }
252     isamb_pp_close(pp);
253
254     isamb_unlink(isb, isamc_p);
255 }
256
257 void tst_x(ISAMB isb)
258 {
259     ISAMC_I isamc_i;
260     ISAM_P isamb_p = 0;
261     struct read_info ri;
262
263     isamc_i.clientData = &ri;
264     isamc_i.read_item = code_read;
265     ri.no = 0;
266     ri.max = 500;
267
268     ri.val = 1000;
269     ri.step = 1;
270     ri.insertMode = 1;
271
272     isamb_merge (isb, &isamb_p , &isamc_i);
273
274     ri.no = 0;
275     ri.max = 500;
276
277     ri.val = 1;
278     ri.step = 1;
279     ri.insertMode = 1;
280
281     isamb_merge (isb, &isamb_p , &isamc_i);
282 }
283
284 void tst_append(ISAMB isb, int n)
285 {
286     ISAMC_I isamc_i;
287     ISAM_P isamb_p = 0;
288     struct read_info ri;
289     int i;
290     int chunk = 10;
291
292     for (i = 0; i < n; i += chunk)
293     {
294         /* insert a number of entries */
295         ri.no = 0;
296         ri.max = i + chunk;
297
298         ri.val = 0;
299         ri.step = 1;
300         ri.insertMode = 1;
301         
302         isamc_i.clientData = &ri;
303         isamc_i.read_item = code_read;
304         
305         isamb_merge (isb, &isamb_p , &isamc_i);
306     }
307 }
308
309
310 struct random_read_info {
311     int max;
312     int idx;
313     int level;
314     int *delta;
315 };
316
317 int tst_random_read(void *vp, char **dst, int *insertMode)
318 {
319     struct random_read_info *ri = (struct random_read_info *)vp;
320     int x;
321
322     while(ri->idx < ri->max && ri->delta[ri->idx] == ri->level)
323     {
324         ri->idx++;
325         ri->level = 0;
326     }
327     if (ri->idx >= ri->max)
328         return 0;
329     
330     if (ri->delta[ri->idx] > 0)
331     {
332         ri->level++;
333         *insertMode = 1;
334     }
335     else
336     {
337         ri->level--;
338         *insertMode = 0;
339     }
340     x = ri->idx;
341     memcpy (*dst, &x, sizeof(int));
342     (*dst)+=sizeof(int);
343
344     yaz_log(YLOG_DEBUG, "%d %5d", *insertMode, x);
345     return 1;
346 }
347
348 void tst_random(ISAMB isb, int n, int rounds, int max_dups)
349 {
350     ISAM_P isamb_p = 0;
351
352     int *freq = malloc(sizeof(int) * n);
353     int *delta = malloc(sizeof(int) * n);
354     int i, j;
355     for (i = 0; i<n; i++)
356         freq[i] = 0;
357     
358     for (j = 0; j<rounds; j++)
359     {
360         yaz_log(YLOG_DEBUG, "round %d", j);
361         for (i = 0; i<n; i++)
362         {
363             if (rand() & 1)
364                 delta[i] = (rand() % (1+max_dups)) - freq[i];
365             else
366                 delta[i] = 0;
367         }
368         if (n)
369         {
370             ISAMC_I isamc_i;
371             struct random_read_info ri;
372             
373             ri.delta = delta;
374             ri.idx = 0;
375             ri.max = n;
376             ri.level = 0;
377             
378             isamc_i.clientData = &ri;
379             isamc_i.read_item = tst_random_read;
380
381             isamb_merge (isb, &isamb_p , &isamc_i);
382         }
383         
384         yaz_log(YLOG_DEBUG, "dump %d", j);
385         isamb_dump(isb, isamb_p, log_pr);
386
387         yaz_log(YLOG_DEBUG, "----------------------------");
388         for (i = 0; i<n; i++)
389             freq[i] += delta[i];
390
391         if (!isamb_p)
392         {
393             for (i = 0; i<n; i++)
394                 if (freq[i])
395                 {
396                     yaz_log(YLOG_WARN, "isamb_merge returned 0, but "
397                             "freq is non-empty");
398                     exit(1);
399                 }
400         }
401         else
402         {
403             int level = 0;
404             int idx = 0;
405             char key_buf[20];
406             ISAMB_PP pp = isamb_pp_open (isb, isamb_p, 1);
407
408             yaz_log(YLOG_DEBUG, "test %d", j);
409
410             while(isamb_pp_read (pp, key_buf))
411             {
412                 int x;
413                 memcpy (&x, key_buf, sizeof(int));
414                 yaz_log(YLOG_DEBUG, "Got %d", x);
415                 while (idx < n && freq[idx] == level)
416                 {
417                     idx++;
418                     level = 0;
419                 }
420                 if (idx == n)
421                 {
422                     yaz_log(YLOG_WARN, "tst_random: Extra item: %d", x);
423                     exit(1);
424                 }
425                 if (idx != x)
426                 {
427                     yaz_log(YLOG_WARN, "tst_random: Mismatch %d != %d",
428                             x, idx);
429                     exit(1);
430                 }
431                 level++;
432             }
433             while (idx < n && freq[idx] == level)
434             {
435                 idx++;
436                 level = 0;
437             }
438             if (idx != n)
439             {
440                 yaz_log(YLOG_WARN, "tst_random: Missing item: %d", idx);
441                 exit(1);
442             }
443             isamb_pp_close(pp);
444         }
445     }
446     free(freq);
447     free(delta);
448 }
449
450 /* \fn void tst_minsert(ISAMB isb, int n)
451    \brief insert inserts n identical keys, removes n/2, then n-n/2 ..
452    \param isb ISAMB handle
453    \param n number of keys
454 */
455 void tst_minsert(ISAMB isb, int n)
456 {
457     ISAMC_I isamc_i;
458     ISAM_P isamb_p = 0;
459     struct read_info ri;
460
461     isamc_i.clientData = &ri;
462
463     /* all have same value = 1 */
464     ri.val = 1;  
465     ri.step = 0;
466
467     isamc_i.read_item = code_read;
468
469     ri.no = 0;
470     ri.max = n;
471
472     ri.insertMode = 1;
473
474     isamb_merge (isb, &isamb_p , &isamc_i);
475
476     isamb_dump(isb, isamb_p, log_pr);
477     
478     ri.no = 0;
479     ri.max = n - n/2;
480
481     ri.insertMode = 0;
482
483     isamb_merge (isb, &isamb_p , &isamc_i);
484
485     ri.no = 0;
486     ri.max = n/2;
487
488     ri.insertMode = 0;
489
490     isamb_merge (isb, &isamb_p , &isamc_i);
491     if (isamb_p)
492     {
493         yaz_log(YLOG_WARN, "tst_minsert: isamb_merge should be empty n=%d",
494                 n);
495         exit(1);
496     }
497 }
498
499 /* tests for identical keys.. ISAMB does not handle that, so some of the
500    tests below fails
501 */
502 static void identical_keys_tests(ISAMB isb)
503 {
504 #if 1
505     tst_minsert(isb, 10);
506 #endif
507 #if 0
508     tst_minsert(isb, 600);  /* still fails */
509 #endif
510 #if 1
511     tst_random(isb, 20, 200, 1);
512 #endif
513 #if 1
514     tst_random(isb, 5, 200, 2);
515 #endif
516
517 #if 1
518     tst_random(isb, 250, 10, 4);
519 #endif
520 #if 1
521     /* fails if both are executed */
522     tst_random(isb, 20000, 10, 4);
523     tst_random(isb, 20000, 10, 10);
524 #endif
525 #if 1
526     tst_random(isb, 250, 100, 10);
527 #endif
528 }
529
530 int main(int argc, char **argv)
531 {
532     BFiles bfs;
533     ISAMB isb;
534     ISAMC_M method;
535     
536     if (argc == 2)
537         yaz_log_init_level(YLOG_ALL);
538         
539     /* setup method (attributes) */
540     method.compare_item = compare_item;
541     method.log_item = log_item;
542     method.codec.start = code_start;
543     method.codec.encode = code_item;
544     method.codec.decode = code_item;
545     method.codec.reset = code_reset;
546     method.codec.stop = code_stop;
547
548     /* create block system */
549     bfs = bfs_create(0, 0);
550     if (!bfs)
551     {
552         yaz_log(YLOG_WARN, "bfs_create failed");
553         exit(1);
554     }
555
556     bf_reset(bfs);
557
558     /* create isam handle */
559     isb = isamb_open (bfs, "isamb", 1, &method, 0);
560     if (!isb)
561     {
562         yaz_log(YLOG_WARN, "isamb_open failed");
563         exit(2);
564     }
565     tst_insert(isb, 1);
566     tst_insert(isb, 2);
567     tst_insert(isb, 20);
568     tst_insert(isb, 100);
569     tst_insert(isb, 500);
570     tst_insert(isb, 10000);
571
572     tst_forward(isb, 10000);
573
574     tst_x(isb);
575
576     tst_append(isb, 1000);
577
578     if (0)
579         identical_keys_tests(isb);
580     
581     isamb_close(isb);
582
583     /* exit block system */
584     bfs_destroy(bfs);
585     exit(0);
586     return 0;
587 }
588 /*
589  * Local variables:
590  * c-basic-offset: 4
591  * c-file-style: "Stroustrup"
592  * indent-tabs-mode: nil
593  * End:
594  * vim: shiftwidth=4 tabstop=8 expandtab
595  */
596