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