tcbtest.c

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

          eprint(bdb, "tcbdbcurout");
          err = true;
        }
      }
      tcfree(kbuf);
      if(myrand(30) == 0 && !tcbdbcurfirst(cur)){
        eprint(bdb, "tcbdbcurfirst");
        err = true;
      }
    }
  }
  if(!tcbdbvanish(bdb)){
    eprint(bdb, "tcbdbvanish");
    err = true;
  }
  if(!tcbdbtranbegin(bdb)){
    eprint(bdb, "tcbdbtranbegin");
    err = true;
  }
  if(!tcbdbput2(bdb, "mikio", "hirabayashi")){
    eprint(bdb, "tcbdbput2");
    err = true;
  }
  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 wicked command */
static int procwicked(const char *path, int rnum, bool mt, int opts, int omode){
  iprintf("<Wicked Writing 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;
  }
  BDBCUR *cur = tcbdbcurnew(bdb);
  if(!tcbdbcurfirst(cur) && tcbdbecode(bdb) != TCENOREC){
    eprint(bdb, "tcbdbcurfirst");
    err = true;
  }
  TCMAP *map = tcmapnew2(rnum / 5);
  for(int i = 1; i <= rnum && !err; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", myrand(rnum));
    char vbuf[RECBUFSIZ];
    int vsiz = myrand(RECBUFSIZ);
    memset(vbuf, '*', vsiz);
    vbuf[vsiz] = '\0';
    char *rbuf;
    switch(myrand(16)){
    case 0:
      iputchar('0');
      if(!tcbdbput(bdb, kbuf, ksiz, vbuf, vsiz)){
        eprint(bdb, "tcbdbput");
        err = true;
      }
      tcmapput(map, kbuf, ksiz, vbuf, vsiz);
      break;
    case 1:
      iputchar('1');
      if(!tcbdbput2(bdb, kbuf, vbuf)){
        eprint(bdb, "tcbdbput2");
        err = true;
      }
      tcmapput2(map, kbuf, vbuf);
      break;
    case 2:
      iputchar('2');
      if(!tcbdbputkeep(bdb, kbuf, ksiz, vbuf, vsiz) && tcbdbecode(bdb) != TCEKEEP){
        eprint(bdb, "tcbdbputkeep");
        err = true;
      }
      tcmapputkeep(map, kbuf, ksiz, vbuf, vsiz);
      break;
    case 3:
      iputchar('3');
      if(!tcbdbputkeep2(bdb, kbuf, vbuf) && tcbdbecode(bdb) != TCEKEEP){
        eprint(bdb, "tcbdbputkeep2");
        err = true;
      }
      tcmapputkeep2(map, kbuf, vbuf);
      break;
    case 4:
      iputchar('4');
      if(!tcbdbputcat(bdb, kbuf, ksiz, vbuf, vsiz)){
        eprint(bdb, "tcbdbputcat");
        err = true;
      }
      tcmapputcat(map, kbuf, ksiz, vbuf, vsiz);
      break;
    case 5:
      iputchar('5');
      if(!tcbdbputcat2(bdb, kbuf, vbuf)){
        eprint(bdb, "tcbdbputcat2");
        err = true;
      }
      tcmapputcat2(map, kbuf, vbuf);
      break;
    case 6:
      iputchar('6');
      if(myrand(10) == 0){
        if(!tcbdbout(bdb, kbuf, ksiz) && tcbdbecode(bdb) != TCENOREC){
          eprint(bdb, "tcbdbout");
          err = true;
        }
        tcmapout(map, kbuf, ksiz);
      }
      break;
    case 7:
      iputchar('7');
      if(myrand(10) == 0){
        if(!tcbdbout2(bdb, kbuf) && tcbdbecode(bdb) != TCENOREC){
          eprint(bdb, "tcbdbout2");
          err = true;
        }
        tcmapout2(map, kbuf);
      }
      break;
    case 8:
      iputchar('8');
      if(!(rbuf = tcbdbget(bdb, kbuf, ksiz, &vsiz))){
        if(tcbdbecode(bdb) != TCENOREC){
          eprint(bdb, "tcbdbget");
          err = true;
        }
        rbuf = tcsprintf("[%d]", myrand(i + 1));
        vsiz = strlen(rbuf);
      }
      vsiz += myrand(vsiz);
      if(myrand(3) == 0) vsiz += PATH_MAX;
      rbuf = tcrealloc(rbuf, vsiz + 1);
      for(int j = 0; j < vsiz; j++){
        rbuf[j] = myrand(0x100);
      }
      if(!tcbdbput(bdb, kbuf, ksiz, rbuf, vsiz)){
        eprint(bdb, "tcbdbput");
        err = true;
      }
      tcmapput(map, kbuf, ksiz, rbuf, vsiz);
      tcfree(rbuf);
      break;
    case 9:
      iputchar('9');
      if(!(rbuf = tcbdbget(bdb, kbuf, ksiz, &vsiz)) && tcbdbecode(bdb) != TCENOREC){
        eprint(bdb, "tcbdbget");
        err = true;
      }
      tcfree(rbuf);
      break;
    case 10:
      iputchar('A');
      if(!(rbuf = tcbdbget2(bdb, kbuf)) && tcbdbecode(bdb) != TCENOREC){
        eprint(bdb, "tcbdbget2");
        err = true;
      }
      tcfree(rbuf);
      break;
    case 11:
      iputchar('B');
      if(myrand(1) == 0) vsiz = 1;
      if(!tcbdbget3(bdb, kbuf, ksiz, &vsiz) && tcbdbecode(bdb) != TCENOREC){
        eprint(bdb, "tcbdbget3");
        err = true;
      }
      break;
    case 12:
      iputchar('C');
      if(myrand(rnum / 50) == 0){
        if(!tcbdbcurfirst(cur) && tcbdbecode(bdb) != TCENOREC){
          eprint(bdb, "tcbdbcurfirst");
          err = true;
        }
      }
      TCXSTR *ikey = tcxstrnew();
      TCXSTR *ival = tcxstrnew();
      for(int j = myrand(rnum) / 1000 + 1; j >= 0; j--){
        if(j % 3 == 0){
          if(tcbdbcurrec(cur, ikey, ival)){
            if(tcbdbvnum(bdb, tcxstrptr(ikey), tcxstrsize(ikey)) != 1){
              eprint(bdb, "(validation)");
              err = true;
            }
            if(tcxstrsize(ival) != tcbdbvsiz(bdb, tcxstrptr(ikey), tcxstrsize(ikey))){
              eprint(bdb, "(validation)");
              err = true;
            }
          } else {
            int ecode = tcbdbecode(bdb);
            if(ecode != TCEINVALID && ecode != TCENOREC){
              eprint(bdb, "tcbdbcurrec");
              err = true;
            }
          }
        } else {
          int iksiz;
          char *ikbuf = tcbdbcurkey(cur, &iksiz);
          if(ikbuf){
            tcfree(ikbuf);
          } else {
            int ecode = tcbdbecode(bdb);
            if(ecode != TCEINVALID && ecode != TCENOREC){
              eprint(bdb, "tcbdbcurkey");
              err = true;
            }
          }
        }
        tcbdbcurnext(cur);
      }
      tcxstrdel(ival);
      tcxstrdel(ikey);
      break;
    default:
      iputchar('@');
      if(myrand(10000) == 0) srand((unsigned int)(tctime() * 1000) % UINT_MAX);
      if(myrand(rnum / 32 + 1) == 0){
        if(!tcbdbcurfirst(cur) && tcbdbecode(bdb) != TCENOREC){
          eprint(bdb, "tcbdbcurfirst");
          err = true;
        }
        int cnt = myrand(30);
        for(int j = 0; j < rnum && !err; j++){
          ksiz = sprintf(kbuf, "%d", i + j);
          if(myrand(4) == 0){
            if(tcbdbout3(bdb, kbuf, ksiz)){
              cnt--;
            } else if(tcbdbecode(bdb) != TCENOREC){
              eprint(bdb, "tcbdbout3");
              err = true;
            }
            tcmapout(map, kbuf, ksiz);
          } else if(myrand(30) == 0){
            int tksiz;
            char *tkbuf = tcbdbcurkey(cur, &tksiz);
            if(tkbuf){
              if(tcbdbcurout(cur)){
                cnt--;
              } else {
                eprint(bdb, "tcbdbcurout");
                err = true;
              }
              tcmapout(map, tkbuf, tksiz);
              tcfree(tkbuf);
            } else if(tcbdbecode(bdb) != TCENOREC){
              eprint(bdb, "tcbdbcurfirst");
              err = true;
            }
          } else {
            if(tcbdbout(bdb, kbuf, ksiz)){
              cnt--;
            } else if(tcbdbecode(bdb) != TCENOREC){
              eprint(bdb, "tcbdbout");
              err = true;
            }
            tcmapout(map, kbuf, ksiz);
          }
          if(cnt < 0) break;
        }
      }
      break;
    }
    if(i % 50 == 0) iprintf(" (%08d)\n", i);
    if(i == rnum / 2){
      if(!tcbdbclose(bdb)){
        eprint(bdb, "tcbdbclose");
        err = true;
      }
      if(!tcbdbopen(bdb, path, BDBOWRITER | omode)){
        eprint(bdb, "tcbdbopen");
        err = true;
      }
    } else if(i == rnum / 4){
      char *npath = tcsprintf("%s-tmp", path);
      if(!tcbdbcopy(bdb, npath)){
        eprint(bdb, "tcbdbcopy");
        err = true;
      }
      TCBDB *nbdb = tcbdbnew();
      if(!tcbdbsetcodecfunc(nbdb, _tc_recencode, NULL, _tc_recdecode, NULL)){
        eprint(nbdb, "tcbdbsetcodecfunc");
        err = true;
      }
      if(!tcbdbopen(nbdb, npath, BDBOREADER | omode)){
        eprint(nbdb, "tcbdbopen");
        err = true;
      }
      tcbdbdel(nbdb);
      unlink(npath);
      tcfree(npath);
      if(!tcbdboptimize(bdb, -1, -1, -1, -1, -1, -1)){
        eprint(bdb, "tcbdboptimize");
        err = true;
      }
      if(!tcbdbcurfirst(cur) && tcbdbecode(bdb) != TCENOREC){
        eprint(bdb, "tcbdbcurfirst");
        err = true;
      }
    } else if(i == rnum / 8){
      if(!tcbdbtranbegin(bdb)){
        eprint(bdb, "tcbdbtranbegin");
        err = true;
      }
    } else if(i == rnum / 8 + rnum / 16){
      if(!tcbdbtrancommit(bdb)){
        eprint(bdb, "tcbdbtrancommit");
        err = true;
      }
    }
  }
  if(rnum % 50 > 0) iprintf(" (%08d)\n", rnum);
  if(!tcbdbsync(bdb)){
    eprint(bdb, "tcbdbsync");
    err = true;
  }
  if(tcbdbrnum(bdb) != tcmaprnum(map)){
    eprint(bdb, "(validation)");
    err = true;
  }
  for(int i = 1; i <= rnum && !err; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", i - 1);
    int vsiz;
    const char *vbuf = tcmapget(map, kbuf, ksiz, &vsiz);
    int rsiz;
    char *rbuf = tcbdbget(bdb, kbuf, ksiz, &rsiz);
    if(vbuf){
      iputchar('.');
      if(!rbuf){
        eprint(bdb, "tcbdbget");
        err = true;
      } else if(rsiz != vsiz || memcmp(rbuf, vbuf, rsiz)){
        eprint(bdb, "(validation)");
        err = true;
      }
    } else {
      iputchar('*');
      if(rbuf || tcbdbecode(bdb) != TCENOREC){
        eprint(bdb, "(validation)");
        err = true;
      }
    }
    tcfree(rbuf);
    if(i % 50 == 0) iprintf(" (%08d)\n", i);
  }
  if(rnum % 50 > 0) iprintf(" (%08d)\n", rnum);
  tcmapiterinit(map);
  int ksiz;
  const char *kbuf;
  for(int i = 1; (kbuf = tcmapiternext(map, &ksiz)) != NULL; i++){
    iputchar('+');
    int vsiz;
    const char *vbuf = tcmapiterval(kbuf, &vsiz);
    int rsiz;
    char *rbuf = tcbdbget(bdb, kbuf, ksiz, &rsiz);
    if(!rbuf){
      eprint(bdb, "tcbdbget");
      err = true;
    } else if(rsiz != vsiz || memcmp(rbuf, vbuf, rsiz)){
      eprint(bdb, "(validation)");
      err = true;
    }
    tcfree(rbuf);
    if(!tcbdbout(bdb, kbuf, ksiz)){
      eprint(bdb, "tcbdbout");
      err = true;
    }
    if(i % 50 == 0) iprintf(" (%08d)\n", i);
  }
  int mrnum = tcmaprnum(map);
  if(mrnum % 50 > 0) iprintf(" (%08d)\n", mrnum);
  if(tcbdbrnum(bdb) != 0){
    eprint(bdb, "(validation)");
    err = true;
  }
  tcbdbcurdel(cur);
  iprintf("record number: %llu\n", (unsigned long long)tcbdbrnum(bdb));
  iprintf("size: %llu\n", (unsigned long long)tcbdbfsiz(bdb));
  mprint(bdb);
  tcmapdel(map);
  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;
}



// END OF FILE