Happy new year
[idzebra-moved-to-github.git] / isamb / benchisamb.c
1 /* This file is part of the Zebra server.
2    Copyright (C) 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_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <yaz/options.h>
24 #if HAVE_SYS_TIMES_H
25 #include <sys/times.h>
26 #endif
27 #if HAVE_SYS_TIME_H
28 #include <sys/time.h>
29 #endif
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <yaz/log.h>
34 #include <yaz/xmalloc.h>
35 #include <yaz/timing.h>
36 #include <idzebra/isamb.h>
37 #include <assert.h>
38
39 static void log_item(int level, const void *b, const char *txt)
40 {
41     int x;
42     memcpy(&x, b, sizeof(int));
43     yaz_log(YLOG_LOG, "%s %d", txt, x);
44 }
45
46 static void log_pr(const char *txt)
47 {
48     yaz_log(YLOG_LOG, "%s", txt);
49 }
50
51 int compare_item(const void *a, const void *b)
52 {
53     int ia, ib;
54
55     memcpy(&ia, (const char *) a + 1, sizeof(int));
56     memcpy(&ib, (const char *) b + 1, sizeof(int));
57     if (ia > ib)
58         return 1;
59     if (ia < ib)
60         return -1;
61    return 0;
62 }
63
64 void *code_start(void)
65 {
66     return 0;
67 }
68
69 void code_item(void *p, char **dst, const char **src)
70 {
71     int sz = **src;
72     memcpy (*dst, *src, sz);
73     (*dst) += sz;
74     (*src) += sz;
75 }
76
77 void code_reset(void *p)
78 {
79 }
80 void code_stop(void *p)
81 {
82 }
83
84 struct read_info {
85     int val;
86     int step;
87
88     int no;
89     int max;
90     int insertMode;
91     int sz;
92 };
93
94 int code_read(void *vp, char **dst, int *insertMode)
95 {
96     struct read_info *ri = (struct read_info *)vp;
97     int x;
98
99     if (ri->no >= ri->max)
100         return 0;
101     ri->no++;
102
103     x = ri->val;
104     memset(*dst, 0, ri->sz);
105     **dst = ri->sz;
106     memcpy(*dst + 1, &x, sizeof(int));
107
108     (*dst) += ri->sz;
109
110     ri->val = ri->val + ri->step;
111     *insertMode = ri->insertMode;
112
113 #if 0
114     yaz_log(YLOG_LOG, "%d %5d", ri->insertMode, x);
115 #endif
116     return 1;
117 }
118
119 void bench_insert(ISAMB isb, int number_of_trees,
120                   int number_of_rounds, int number_of_elements,
121                   int extra_size)
122 {
123     ISAMC_I isamc_i;
124     ISAM_P *isamc_p = xmalloc(sizeof(ISAM_P) * number_of_trees);
125     struct read_info ri;
126     int round, i;
127
128     for (i = 0; i<number_of_trees; i++)
129         isamc_p[i] = 0; /* initially, is empty */
130
131     ri.val = 0;
132     ri.step = 1;
133     ri.insertMode = 1;
134     ri.sz = sizeof(int) + 1 + extra_size;
135
136     for (round = 0; round < number_of_rounds; round++)
137     {
138         yaz_timing_t t = yaz_timing_create();
139
140         yaz_timing_start(t);
141         for (i = 0; i<number_of_trees; i++)
142         {
143
144             /* insert a number of entries */
145             ri.no = 0;
146
147             ri.val = (rand());
148             if (RAND_MAX < 65536)
149                 ri.val = ri.val + 65536*rand();
150
151             // ri.val = number_of_elements * round;
152             ri.max = number_of_elements;
153
154             isamc_i.clientData = &ri;
155             isamc_i.read_item = code_read;
156
157             isamb_merge (isb, &isamc_p[i] , &isamc_i);
158
159             if (0)
160                 isamb_dump(isb, isamc_p[i], log_pr);
161         }
162         yaz_timing_stop(t);
163         printf("%3d %8.6f %5.2f %5.2f\n",
164                round+1,
165                yaz_timing_get_real(t),
166                yaz_timing_get_user(t),
167                yaz_timing_get_sys(t));
168         yaz_timing_destroy(&t);
169     }
170     xfree(isamc_p);
171 }
172
173 void exit_usage(void)
174 {
175     fprintf(stderr, "benchisamb [-r rounds] [-n items] [-i isams]\n");
176     exit(1);
177 }
178
179 int main(int argc, char **argv)
180 {
181     BFiles bfs;
182     ISAMB isb;
183     ISAMC_M method;
184     int ret;
185     char *arg;
186     int number_of_rounds = 10;
187     int number_of_items = 1000;
188     int number_of_isams = 1000;
189     int extra_size = 0;
190     yaz_timing_t t = 0;
191
192     while ((ret = options("z:r:n:i:", argv, argc, &arg)) != -2)
193     {
194         switch(ret)
195         {
196         case 'r':
197             number_of_rounds = atoi(arg);
198             break;
199         case 'n':
200             number_of_items = atoi(arg);
201             break;
202         case 'i':
203             number_of_isams = atoi(arg);
204             break;
205         case 'z':
206             extra_size = atoi(arg);
207             break;
208         case 0:
209             fprintf(stderr, "bad arg: %s\n", arg);
210             exit_usage();
211         default:
212             fprintf(stderr, "bad option.\n");
213             exit_usage();
214         }
215     }
216
217     /* setup method (attributes) */
218     method.compare_item = compare_item;
219     method.log_item = log_item;
220     method.codec.start = code_start;
221     method.codec.encode = code_item;
222     method.codec.decode = code_item;
223     method.codec.reset = code_reset;
224     method.codec.stop = code_stop;
225
226     t = yaz_timing_create();
227
228     yaz_timing_start(t);
229
230     /* create block system */
231     bfs = bfs_create(0, 0);
232     if (!bfs)
233     {
234         yaz_log(YLOG_WARN, "bfs_create failed");
235         exit(1);
236     }
237
238     bf_reset(bfs);
239
240     /* create isam handle */
241     isb = isamb_open (bfs, "isamb", 1, &method, 0);
242     if (!isb)
243     {
244         yaz_log(YLOG_WARN, "isamb_open failed");
245         exit(2);
246     }
247     bench_insert(isb, number_of_isams, number_of_rounds, number_of_items,
248                  extra_size);
249
250     isamb_close(isb);
251
252     /* exit block system */
253     bfs_destroy(bfs);
254
255     yaz_timing_stop(t);
256     printf("Total %8.6f %5.2f %5.2f\n",
257            yaz_timing_get_real(t),
258            yaz_timing_get_user(t),
259            yaz_timing_get_sys(t));
260     yaz_timing_destroy(&t);
261     exit(0);
262     return 0;
263 }
264 /*
265  * Local variables:
266  * c-basic-offset: 4
267  * c-file-style: "Stroustrup"
268  * indent-tabs-mode: nil
269  * End:
270  * vim: shiftwidth=4 tabstop=8 expandtab
271  */
272