tcbtest.c

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

  }
  if(!tcbdbsetcache(bdb, lcnum, ncnum)){
    eprint(bdb, "tcbdbsetcache");
    err = true;
  }
  if(xmsiz >= 0 && !tcbdbsetxmsiz(bdb, xmsiz)){
    eprint(bdb, "tcbdbsetxmsiz");
    err = true;
  }
  if(!tcbdbopen(bdb, path, BDBOWRITER | omode)){
    eprint(bdb, "tcbdbopen");
    err = true;
  }
  int rnum = tcbdbrnum(bdb);
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz;
    if(cmp == tcbdbcmpdecimal){
      ksiz = sprintf(kbuf, "%d", rnd ? myrand(rnum) + 1 : i);
    } else if(cmp == tcbdbcmpint32){
      int32_t lnum = rnd ? myrand(rnum) + 1 : i;
      memcpy(kbuf, &lnum, sizeof(lnum));
      ksiz = sizeof(lnum);
    } else if(cmp == tcbdbcmpint64){
      int64_t llnum = rnd ? myrand(rnum) + 1 : i;
      memcpy(kbuf, &llnum, sizeof(llnum));
      ksiz = sizeof(llnum);
    } else {
      ksiz = sprintf(kbuf, "%08d", rnd ? myrand(rnum) + 1 : i);
    }
    if(!tcbdbout(bdb, kbuf, ksiz) && !(rnd && tcbdbecode(bdb) == TCENOREC)){
      eprint(bdb, "tcbdbout");
      err = true;
      break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("record number: %llu\n", (unsigned long long)tcbdbrnum(bdb));
  iprintf("size: %llu\n", (unsigned long long)tcbdbfsiz(bdb));
  mprint(bdb);
  if(!tcbdbclose(bdb)){
    eprint(bdb, "tcbdbclose");
    err = true;
  }
  tcbdbdel(bdb);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("%s\n\n", err ? "error" : "ok");
  return err ? 1 : 0;
}


/* perform rcat command */
static int procrcat(const char *path, int rnum,
                    int lmemb, int nmemb, int bnum, int apow, int fpow,
                    bool mt, BDBCMP cmp, int opts, int lcnum, int ncnum, int xmsiz,
                    int lsmax, int capnum, int omode, int pnum, bool dai, bool dad, bool rl){
  iprintf("<Random Concatenating Test>\n"
          "  path=%s  rnum=%d  lmemb=%d  nmemb=%d  bnum=%d  apow=%d  fpow=%d"
          "  mt=%d  cmp=%p  opts=%d  lcnum=%d  ncnum=%d  xmsiz=%d  lsmax=%d  capnum=%d"
          "  omode=%d  pnum=%d  dai=%d  dad=%d  rl=%d\n\n",
          path, rnum, lmemb, nmemb, bnum, apow, fpow, mt, (void *)(intptr_t)cmp,
          opts, lcnum, ncnum, xmsiz, lsmax, capnum, omode, pnum, dai, dad, rl);
  if(pnum < 1) pnum = rnum;
  bool err = false;
  double stime = tctime();
  TCBDB *bdb = tcbdbnew();
  if(g_dbgfd >= 0) tcbdbsetdbgfd(bdb, g_dbgfd);
  if(mt && !tcbdbsetmutex(bdb)){
    eprint(bdb, "tcbdbsetmutex");
    err = true;
  }
  if(cmp && !tcbdbsetcmpfunc(bdb, cmp, NULL)){
    eprint(bdb, "tcbdbsetcmpfunc");
    err = true;
  }
  if(!tcbdbsetcodecfunc(bdb, _tc_recencode, NULL, _tc_recdecode, NULL)){
    eprint(bdb, "tcbdbsetcodecfunc");
    err = true;
  }
  if(!tcbdbtune(bdb, lmemb, nmemb, bnum, apow, fpow, opts)){
    eprint(bdb, "tcbdbtune");
    err = true;
  }
  if(!tcbdbsetcache(bdb, lcnum, ncnum)){
    eprint(bdb, "tcbdbsetcache");
    err = true;
  }
  if(xmsiz >= 0 && !tcbdbsetxmsiz(bdb, xmsiz)){
    eprint(bdb, "tcbdbsetxmsiz");
    err = true;
  }
  if(!tcbdbsetlsmax(bdb, lsmax)){
    eprint(bdb, "tcbdbsetlsmax");
    err = true;
  }
  if(!tcbdbsetcapnum(bdb, capnum)){
    eprint(bdb, "tcbdbsetcapnum");
    err = true;
  }
  if(!tcbdbopen(bdb, path, BDBOWRITER | BDBOCREAT | BDBOTRUNC | omode)){
    eprint(bdb, "tcbdbopen");
    err = true;
  }
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz;
    if(cmp == tcbdbcmpdecimal){
      ksiz = sprintf(kbuf, "%d", myrand(pnum));
    } else if(cmp == tcbdbcmpint32){
      int32_t lnum = myrand(pnum);
      memcpy(kbuf, &lnum, sizeof(lnum));
      ksiz = sizeof(lnum);
    } else if(cmp == tcbdbcmpint64){
      int64_t llnum = myrand(pnum);
      memcpy(kbuf, &llnum, sizeof(llnum));
      ksiz = sizeof(llnum);
    } else {
      ksiz = sprintf(kbuf, "%d", myrand(pnum));
    }
    if(dai){
      if(tcbdbaddint(bdb, kbuf, ksiz, myrand(3)) == INT_MIN){
        eprint(bdb, "tcbdbaddint");
        err = true;
        break;
      }
    } else if(dad){
      if(isnan(tcbdbadddouble(bdb, kbuf, ksiz, myrand(3)))){
        eprint(bdb, "tcbdbadddouble");
        err = true;
        break;
      }
    } else if(rl){
      char vbuf[PATH_MAX];
      int vsiz = myrand(PATH_MAX);
      for(int j = 0; j < vsiz; j++){
        vbuf[j] = myrand(0x100);
      }
      if(!tcbdbputcat(bdb, kbuf, ksiz, vbuf, vsiz)){
        eprint(bdb, "tcbdbputcat");
        err = true;
        break;
      }
    } else {
      if(!tcbdbputcat(bdb, kbuf, ksiz, kbuf, ksiz)){
        eprint(bdb, "tcbdbputcat");
        err = true;
        break;
      }
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("record number: %llu\n", (unsigned long long)tcbdbrnum(bdb));
  iprintf("size: %llu\n", (unsigned long long)tcbdbfsiz(bdb));
  mprint(bdb);
  if(!tcbdbclose(bdb)){
    eprint(bdb, "tcbdbclose");
    err = true;
  }
  tcbdbdel(bdb);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("%s\n\n", err ? "error" : "ok");
  return err ? 1 : 0;
}


/* perform queue command */
static int procqueue(const char *path, int rnum, int lmemb, int nmemb, int bnum,
                     int apow, int fpow, bool mt, BDBCMP cmp, int opts,
                     int lcnum, int ncnum, int xmsiz, int lsmax, int capnum, int omode){
  iprintf("<Queueing Test>\n  path=%s  rnum=%d  lmemb=%d  nmemb=%d  bnum=%d  apow=%d  fpow=%d"
          "  mt=%d  cmp=%p  opts=%d  lcnum=%d  ncnum=%d  xmsiz=%d  lsmax=%d  capnum=%d"
          "  omode=%d\n\n", path, rnum, lmemb, nmemb, bnum, apow, fpow, mt, (void *)(intptr_t)cmp,
          opts, lcnum, ncnum, xmsiz, lsmax, capnum, omode);
  bool err = false;
  double stime = tctime();
  TCBDB *bdb = tcbdbnew();
  if(g_dbgfd >= 0) tcbdbsetdbgfd(bdb, g_dbgfd);
  if(mt && !tcbdbsetmutex(bdb)){
    eprint(bdb, "tcbdbsetmutex");
    err = true;
  }
  if(cmp && !tcbdbsetcmpfunc(bdb, cmp, NULL)){
    eprint(bdb, "tcbdbsetcmpfunc");
    err = true;
  }
  if(!tcbdbsetcodecfunc(bdb, _tc_recencode, NULL, _tc_recdecode, NULL)){
    eprint(bdb, "tcbdbsetcodecfunc");
    err = true;
  }
  if(!tcbdbtune(bdb, lmemb, nmemb, bnum, apow, fpow, opts)){
    eprint(bdb, "tcbdbtune");
    err = true;
  }
  if(!tcbdbsetcache(bdb, lcnum, ncnum)){
    eprint(bdb, "tcbdbsetcache");
    err = true;
  }
  if(xmsiz >= 0 && !tcbdbsetxmsiz(bdb, xmsiz)){
    eprint(bdb, "tcbdbsetxmsiz");
    err = true;
  }
  if(!tcbdbsetlsmax(bdb, lsmax)){
    eprint(bdb, "tcbdbsetlsmax");
    err = true;
  }
  if(!tcbdbsetcapnum(bdb, capnum)){
    eprint(bdb, "tcbdbsetcapnum");
    err = true;
  }
  if(!tcbdbopen(bdb, path, BDBOWRITER | BDBOCREAT | BDBOTRUNC)){
    eprint(bdb, "tcbdbopen");
    err = true;
  }
  int deqfreq = (lmemb > 0) ? lmemb * 2 : 256;
  BDBCUR *cur = tcbdbcurnew(bdb);
  for(int i = 1; i <= rnum; i++){
    char buf[RECBUFSIZ];
    int len;
    if(cmp == tcbdbcmpdecimal){
      len = sprintf(buf, "%d", i);
    } else if(cmp == tcbdbcmpint32){
      int32_t lnum = i;
      memcpy(buf, &lnum, sizeof(lnum));
      len = sizeof(lnum);
    } else if(cmp == tcbdbcmpint64){
      int64_t llnum = i;
      memcpy(buf, &llnum, sizeof(llnum));
      len = sizeof(llnum);
    } else {
      len = sprintf(buf, "%08d", i);
    }
    if(!tcbdbput(bdb, buf, len, buf, len)){
      eprint(bdb, "tcbdbput");
      err = true;
      break;
    }
    if(myrand(deqfreq) == 0){
      if(!tcbdbcurfirst(cur) && tcbdbecode(bdb) != TCENOREC){
        eprint(bdb, "tcbdbcurfirst");
        err = true;
        break;
      }
      int num = myrand(deqfreq * 2 + 1);
      while(num >= 0){
        if(tcbdbcurout(cur)){
          num--;
        } else {
          if(tcbdbecode(bdb) != TCENOREC){
            eprint(bdb, "tcbdbcurout");
            err = true;
          }
          break;
        }
      }
      if(err) break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  if(!tcbdbcurfirst(cur) && tcbdbecode(bdb) != TCENOREC){
    eprint(bdb, "tcbdbcurfirst");
    err = true;
  }
  while(true){
    if(tcbdbcurout(cur)) continue;
    if(tcbdbecode(bdb) != TCENOREC){
      eprint(bdb, "tcbdbcurout");
      err = true;
    }
    break;
  }
  tcbdbcurdel(cur);
  iprintf("record number: %llu\n", (unsigned long long)tcbdbrnum(bdb));
  iprintf("size: %llu\n", (unsigned long long)tcbdbfsiz(bdb));
  mprint(bdb);
  if(!tcbdbclose(bdb)){
    eprint(bdb, "tcbdbclose");
    err = true;
  }
  tcbdbdel(bdb);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("%s\n\n", err ? "error" : "ok");
  return err ? 1 : 0;
}


/* perform misc command */
static int procmisc(const char *path, int rnum, bool mt, int opts, int omode){
  iprintf("<Miscellaneous Test>\n  path=%s  rnum=%d  mt=%d  opts=%d  omode=%d\n\n",
          path, rnum, mt, opts, omode);
  bool err = false;
  double stime = tctime();
  TCBDB *bdb = tcbdbnew();
  if(g_dbgfd >= 0) tcbdbsetdbgfd(bdb, g_dbgfd);
  if(mt && !tcbdbsetmutex(bdb)){
    eprint(bdb, "tcbdbsetmutex");
    err = true;
  }
  if(!tcbdbsetcodecfunc(bdb, _tc_recencode, NULL, _tc_recdecode, NULL)){
    eprint(bdb, "tcbdbsetcodecfunc");
    err = true;
  }
  if(!tcbdbtune(bdb, 10, 10, rnum / 50, 100, -1, opts)){
    eprint(bdb, "tcbdbtune");
    err = true;
  }
  if(!tcbdbsetcache(bdb, 128, 256)){
    eprint(bdb, "tcbdbsetcache");
    err = true;
  }
  if(!tcbdbsetxmsiz(bdb, rnum)){
    eprint(bdb, "tcbdbsetxmsiz");
    err = true;
  }
  if(!tcbdbopen(bdb, path, BDBOWRITER | BDBOCREAT | BDBOTRUNC | omode)){
    eprint(bdb, "tcbdbopen");
    err = true;
  }
  iprintf("writing:\n");
  for(int i = 1; i <= rnum; i++){
    char buf[RECBUFSIZ];
    int len = sprintf(buf, "%08d", i);
    if(!tcbdbputkeep(bdb, buf, len, buf, len)){
      eprint(bdb, "tcbdbputkeep");
      err = true;
      break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("reading:\n");
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%08d", i);
    int vsiz;
    char *vbuf = tcbdbget(bdb, kbuf, ksiz, &vsiz);
    if(!vbuf){
      eprint(bdb, "tcbdbget");
      err = true;
      break;
    } else if(vsiz != ksiz || memcmp(vbuf, kbuf, vsiz)){
      eprint(bdb, "(validation)");
      err = true;
      tcfree(vbuf);
      break;
    }
    tcfree(vbuf);
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  if(tcbdbrnum(bdb) != rnum){
    eprint(bdb, "(validation)");
    err = true;
  }
  iprintf("random writing:\n");
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", myrand(rnum));
    char vbuf[RECBUFSIZ];
    int vsiz = myrand(RECBUFSIZ);
    memset(vbuf, '*', vsiz);
    if(!tcbdbput(bdb, kbuf, ksiz, vbuf, vsiz)){
      eprint(bdb, "tcbdbput");
      err = true;
      break;
    }
    int rsiz;
    char *rbuf = tcbdbget(bdb, kbuf, ksiz, &rsiz);
    if(!rbuf){
      eprint(bdb, "tcbdbget");
      err = true;
      break;
    }
    if(rsiz != vsiz || memcmp(rbuf, vbuf, rsiz)){
      eprint(bdb, "(validation)");
      err = true;
      tcfree(rbuf);
      break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
    tcfree(rbuf);
  }
  iprintf("word writing:\n");
  const char *words[] = {
    "a", "A", "bb", "BB", "ccc", "CCC", "dddd", "DDDD", "eeeee", "EEEEEE",
    "mikio", "hirabayashi", "tokyo", "cabinet", "hyper", "estraier", "19780211", "birth day",
    "one", "first", "two", "second", "three", "third", "four", "fourth", "five", "fifth",
    "_[1]_", "uno", "_[2]_", "dos", "_[3]_", "tres", "_[4]_", "cuatro", "_[5]_", "cinco",
    "[\xe5\xb9\xb3\xe6\x9e\x97\xe5\xb9\xb9\xe9\x9b\x84]", "[\xe9\xa6\xac\xe9\xb9\xbf]", NULL
  };
  for(int i = 0; words[i] != NULL; i += 2){
    const char *kbuf = words[i];
    int ksiz = strlen(kbuf);
    const char *vbuf = words[i+1];
    int vsiz = strlen(vbuf);
    if(!tcbdbputkeep(bdb, kbuf, ksiz, vbuf, vsiz)){
      eprint(bdb, "tcbdbputkeep");
      err = true;
      break;
    }
    if(rnum > 250) iputchar('.');
  }
  if(rnum > 250) iprintf(" (%08d)\n", sizeof(words) / sizeof(*words));
  iprintf("random erasing:\n");
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", myrand(rnum));
    if(!tcbdbout(bdb, kbuf, ksiz) && tcbdbecode(bdb) != TCENOREC){
      eprint(bdb, "tcbdbout");
      err = true;
      break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }