tcutest.c

高性能嵌入式数据库在高并发的环境下使用最好是64位系统比较好

/*************************************************************************************************
 * The test cases of the utility API
 *                                                      Copyright (C) 2006-2008 Mikio Hirabayashi
 * This file is part of Tokyo Cabinet.
 * Tokyo Cabinet is free software; you can redistribute it and/or modify it under the terms of
 * the GNU Lesser General Public License as published by the Free Software Foundation; either
 * version 2.1 of the License or any later version.  Tokyo Cabinet is distributed in the hope
 * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 * You should have received a copy of the GNU Lesser General Public License along with Tokyo
 * Cabinet; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA.
 *************************************************************************************************/


#include <tcutil.h>
#include "myconf.h"

#define RECBUFSIZ      32                // buffer for records


/* global variables */
const char *g_progname;                  // program name


/* function prototypes */
int main(int argc, char **argv);
static void usage(void);
static void iprintf(const char *format, ...);
static void iputchar(int c);
static int myrand(int range);
static int runxstr(int argc, char **argv);
static int runlist(int argc, char **argv);
static int runmap(int argc, char **argv);
static int runtree(int argc, char **argv);
static int runmdb(int argc, char **argv);
static int runndb(int argc, char **argv);
static int runmisc(int argc, char **argv);
static int runwicked(int argc, char **argv);
static int procxstr(int rnum);
static int proclist(int rnum, int anum, bool rd);
static int procmap(int rnum, int bnum, bool rd, bool tr, bool rnd, int dmode);
static int proctree(int rnum, bool rd, bool tr, bool rnd, int dmode);
static int procmdb(int rnum, int bnum, bool rd, bool tr, bool rnd, int dmode);
static int procndb(int rnum, bool rd, bool tr, bool rnd, int dmode);
static int procmisc(int rnum);
static int procwicked(int rnum);


/* main routine */
int main(int argc, char **argv){
  g_progname = argv[0];
  srand((unsigned int)(tctime() * 1000) % UINT_MAX);
  if(argc < 2) usage();
  int rv = 0;
  if(!strcmp(argv[1], "xstr")){
    rv = runxstr(argc, argv);
  } else if(!strcmp(argv[1], "list")){
    rv = runlist(argc, argv);
  } else if(!strcmp(argv[1], "map")){
    rv = runmap(argc, argv);
  } else if(!strcmp(argv[1], "tree")){
    rv = runtree(argc, argv);
  } else if(!strcmp(argv[1], "mdb")){
    rv = runmdb(argc, argv);
  } else if(!strcmp(argv[1], "ndb")){
    rv = runndb(argc, argv);
  } else if(!strcmp(argv[1], "misc")){
    rv = runmisc(argc, argv);
  } else if(!strcmp(argv[1], "wicked")){
    rv = runwicked(argc, argv);
  } else {
    usage();
  }
  return rv;
}


/* print the usage and exit */
static void usage(void){
  fprintf(stderr, "%s: test cases of the utility API of Tokyo Cabinet\n", g_progname);
  fprintf(stderr, "\n");
  fprintf(stderr, "usage:\n");
  fprintf(stderr, "  %s xstr rnum\n", g_progname);
  fprintf(stderr, "  %s list [-rd] rnum [anum]\n", g_progname);
  fprintf(stderr, "  %s map [-rd] [-tr] [-rnd] [-dk|-dc|-dai|-dad] rnum [bnum]\n", g_progname);
  fprintf(stderr, "  %s tree [-rd] [-tr] [-rnd] [-dk|-dc|-dai|-dad] rnum\n", g_progname);
  fprintf(stderr, "  %s mdb [-rd] [-tr] [-rnd] [-dk|-dc|-dai|-dad] rnum [bnum]\n", g_progname);
  fprintf(stderr, "  %s ndb [-rd] [-tr] [-rnd] [-dk|-dc|-dai|-dad] rnum\n", g_progname);
  fprintf(stderr, "  %s misc rnum\n", g_progname);
  fprintf(stderr, "  %s wicked rnum\n", g_progname);
  fprintf(stderr, "\n");
  exit(1);
}


/* print formatted information string and flush the buffer */
static void iprintf(const char *format, ...){
  va_list ap;
  va_start(ap, format);
  vprintf(format, ap);
  fflush(stdout);
  va_end(ap);
}


/* print a character and flush the buffer */
static void iputchar(int c){
  putchar(c);
  fflush(stdout);
}


/* get a random number */
static int myrand(int range){
  return (int)((double)range * rand() / (RAND_MAX + 1.0));
}


/* parse arguments of xstr command */
static int runxstr(int argc, char **argv){
  char *rstr = NULL;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      usage();
    } else if(!rstr){
      rstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int rv = procxstr(rnum);
  return rv;
}


/* parse arguments of list command */
static int runlist(int argc, char **argv){
  char *rstr = NULL;
  char *astr = NULL;
  bool rd = false;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-rd")){
        rd = true;
      } else {
        usage();
      }
    } else if(!rstr){
      rstr = argv[i];
    } else if(!astr){
      astr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int anum = astr ? tcatoi(astr) : -1;
  int rv = proclist(rnum, anum, rd);
  return rv;
}


/* parse arguments of map command */
static int runmap(int argc, char **argv){
  char *rstr = NULL;
  char *bstr = NULL;
  bool rd = false;
  bool tr = false;
  bool rnd = false;
  int dmode = 0;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-rd")){
        rd = true;
      } else if(!strcmp(argv[i], "-tr")){
        tr = true;
      } else if(!strcmp(argv[i], "-rnd")){
        rnd = true;
      } else if(!strcmp(argv[i], "-dk")){
        dmode = -1;
      } else if(!strcmp(argv[i], "-dc")){
        dmode = 1;
      } else if(!strcmp(argv[i], "-dai")){
        dmode = 10;
      } else if(!strcmp(argv[i], "-dad")){
        dmode = 11;
      } else {
        usage();
      }
    } else if(!rstr){
      rstr = argv[i];
    } else if(!bstr){
      bstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int bnum = bstr ? tcatoi(bstr) : -1;
  int rv = procmap(rnum, bnum, rd, tr, rnd, dmode);
  return rv;
}


/* parse arguments of tree command */
static int runtree(int argc, char **argv){
  char *rstr = NULL;
  bool rd = false;
  bool tr = false;
  bool rnd = false;
  int dmode = 0;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-rd")){
        rd = true;
      } else if(!strcmp(argv[i], "-tr")){
        tr = true;
      } else if(!strcmp(argv[i], "-rnd")){
        rnd = true;
      } else if(!strcmp(argv[i], "-dk")){
        dmode = -1;
      } else if(!strcmp(argv[i], "-dc")){
        dmode = 1;
      } else if(!strcmp(argv[i], "-dai")){
        dmode = 10;
      } else if(!strcmp(argv[i], "-dad")){
        dmode = 11;
      } else {
        usage();
      }
    } else if(!rstr){
      rstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int rv = proctree(rnum, rd, tr, rnd, dmode);
  return rv;
}


/* parse arguments of mdb command */
static int runmdb(int argc, char **argv){
  char *rstr = NULL;
  char *bstr = NULL;
  bool rd = false;
  bool tr = false;
  bool rnd = false;
  int dmode = 0;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-rd")){
        rd = true;
      } else if(!strcmp(argv[i], "-tr")){
        tr = true;
      } else if(!strcmp(argv[i], "-rnd")){
        rnd = true;
      } else if(!strcmp(argv[i], "-dk")){
        dmode = -1;
      } else if(!strcmp(argv[i], "-dc")){
        dmode = 1;
      } else if(!strcmp(argv[i], "-dai")){
        dmode = 10;
      } else if(!strcmp(argv[i], "-dad")){
        dmode = 11;
      } else {
        usage();
      }
    } else if(!rstr){
      rstr = argv[i];
    } else if(!bstr){
      bstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int bnum = bstr ? tcatoi(bstr) : -1;
  int rv = procmdb(rnum, bnum, rd, tr, rnd, dmode);
  return rv;
}


/* parse arguments of ndb command */
static int runndb(int argc, char **argv){
  char *rstr = NULL;
  bool rd = false;
  bool tr = false;
  bool rnd = false;
  int dmode = 0;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-rd")){
        rd = true;
      } else if(!strcmp(argv[i], "-tr")){
        tr = true;
      } else if(!strcmp(argv[i], "-rnd")){
        rnd = true;
      } else if(!strcmp(argv[i], "-dk")){
        dmode = -1;
      } else if(!strcmp(argv[i], "-dc")){
        dmode = 1;
      } else if(!strcmp(argv[i], "-dai")){
        dmode = 10;
      } else if(!strcmp(argv[i], "-dad")){
        dmode = 11;
      } else {
        usage();
      }
    } else if(!rstr){
      rstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int rv = procndb(rnum, rd, tr, rnd, dmode);
  return rv;
}


/* parse arguments of misc command */
static int runmisc(int argc, char **argv){
  char *rstr = NULL;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      usage();
    } else if(!rstr){
      rstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int rv = procmisc(rnum);
  return rv;
}


/* parse arguments of wicked command */
static int runwicked(int argc, char **argv){
  char *rstr = NULL;
  for(int i = 2; i < argc; i++){
    if(!rstr && argv[i][0] == '-'){
      usage();
    } else if(!rstr){
      rstr = argv[i];
    } else {
      usage();
    }
  }
  if(!rstr) usage();
  int rnum = tcatoi(rstr);
  if(rnum < 1) usage();
  int rv = procwicked(rnum);
  return rv;
}


/* perform xstr command */
static int procxstr(int rnum){
  iprintf("<Extensible String Writing Test>\n  rnum=%d\n\n", rnum);
  double stime = tctime();
  TCXSTR *xstr = tcxstrnew();
  for(int i = 1; i <= rnum; i++){
    char buf[RECBUFSIZ];
    int len = sprintf(buf, "%08d", i);
    tcxstrcat(xstr, buf, len);
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("size: %u\n", tcxstrsize(xstr));
  tcxstrdel(xstr);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("ok\n\n");
  return 0;
}


/* perform list command */
static int proclist(int rnum, int anum, bool rd){
  iprintf("<List Writing Test>\n  rnum=%d  anum=%d  rd=%d\n\n", rnum, anum, rd);
  double stime = tctime();
  TCLIST *list = (anum > 0) ? tclistnew2(anum) : tclistnew();
  for(int i = 1; i <= rnum; i++){
    char buf[RECBUFSIZ];
    int len = sprintf(buf, "%08d", i);
    tclistpush(list, buf, len);
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  if(rd){
    double itime = tctime();
    iprintf("time: %.3f\n", itime - stime);
    stime = itime;
    for(int i = 1; i <= rnum; i++){
      int len;
      tclistval(list, i, &len);
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
  }
  iprintf("record number: %u\n", tclistnum(list));
  tclistdel(list);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("ok\n\n");
  return 0;
}


/* perform map command */
static int procmap(int rnum, int bnum, bool rd, bool tr, bool rnd, int dmode){
  iprintf("<Map Writing Test>\n  rnum=%d  bnum=%d  rd=%d  tr=%d  rnd=%d  dmode=%d\n\n",
          rnum, bnum, rd, tr, rnd, dmode);
  double stime = tctime();
  TCMAP *map = (bnum > 0) ? tcmapnew2(bnum) : tcmapnew();
  for(int i = 1; i <= rnum; i++){
    char buf[RECBUFSIZ];
    int len = sprintf(buf, "%08d", rnd ? myrand(rnum) + 1 : i);
    switch(dmode){
    case -1:
      tcmapputkeep(map, buf, len, buf, len);
      break;
    case 1:
      tcmapputcat(map, buf, len, buf, len);
      break;
    case 10:
      tcmapaddint(map, buf, len, myrand(3));
      break;
    case 11:
      tcmapadddouble(map, buf, len, myrand(3));
      break;
    default:
      tcmapput(map, buf, len, buf, len);
      break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  if(rd){
    double itime = tctime();
    iprintf("time: %.3f\n", itime - stime);
    stime = itime;
    for(int i = 1; i <= rnum; i++){
      char buf[RECBUFSIZ];
      int len = sprintf(buf, "%08d", rnd ? myrand(rnum) + 1 : i);
      tcmapget(map, buf, len, &len);
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
  }
  if(tr){
    double itime = tctime();
    iprintf("time: %.3f\n", itime - stime);
    stime = itime;
    tcmapiterinit(map);
    int ksiz;
    const char *kbuf;
    int inum = 1;
    while((kbuf = tcmapiternext(map, &ksiz)) != NULL){
      tcmapiterval2(kbuf);
      if(rnum > 250 && inum % (rnum / 250) == 0){
        iputchar('.');
        if(inum == rnum || inum % (rnum / 10) == 0) iprintf(" (%08d)\n", inum);
      }
      inum++;
    }
    if(rnd && rnum > 250) iprintf(" (%08d)\n", inum);
  }
  iprintf("record number: %llu\n", (unsigned long long)tcmaprnum(map));
  iprintf("size: %llu\n", (unsigned long long)tcmapmsiz(map));
  tcmapdel(map);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("ok\n\n");
  return 0;
}


/* perform tree command */
static int proctree(int rnum, bool rd, bool tr, bool rnd, int dmode){
  iprintf("<Tree Writing Test>\n  rnum=%d  rd=%d  tr=%d  rnd=%d  dmode=%d\n\n",
          rnum, rd, tr, rnd, dmode);
  double stime = tctime();
  TCTREE *tree = tctreenew();
  for(int i = 1; i <= rnum; i++){