Return to tt3_checkpoint.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

sqlite3

    1: /*
    2: ** 2001 September 15
    3: **
    4: ** The author disclaims copyright to this source code.  In place of
    5: ** a legal notice, here is a blessing:
    6: **
    7: **    May you do good and not evil.
    8: **    May you find forgiveness for yourself and forgive others.
    9: **    May you share freely, never taking more than you give.
   10: **
   11: *************************************************************************
   12: ** This file is part of the test program "threadtest3". Despite being a C
   13: ** file it is not compiled separately, but included by threadtest3.c using
   14: ** the #include directive normally used with header files.
   15: **
   16: ** This file contains the implementation of test cases:
   17: **
   18: **     checkpoint_starvation_1
   19: **     checkpoint_starvation_2
   20: */
   21: 
   22: /*
   23: ** Both test cases involve 1 writer/checkpointer thread and N reader threads.
   24: ** 
   25: ** Each reader thread performs a series of read transactions, one after 
   26: ** another. Each read transaction lasts for 100 ms.
   27: **
   28: ** The writer writes transactions as fast as possible. It uses a callback
   29: ** registered with sqlite3_wal_hook() to try to keep the WAL-size limited to 
   30: ** around 50 pages.
   31: **
   32: ** In test case checkpoint_starvation_1, the auto-checkpoint uses 
   33: ** SQLITE_CHECKPOINT_PASSIVE. In checkpoint_starvation_2, it uses RESTART.
   34: ** The expectation is that in the first case the WAL file will grow very 
   35: ** large, and in the second will be limited to the 50 pages or thereabouts.
   36: ** However, the overall transaction throughput will be lower for 
   37: ** checkpoint_starvation_2, as every checkpoint will block for up to 200 ms
   38: ** waiting for readers to clear.
   39: */
   40: 
   41: /* Frame limit used by the WAL hook for these tests. */
   42: #define CHECKPOINT_STARVATION_FRAMELIMIT 50
   43: 
   44: /* Duration in ms of each read transaction */
   45: #define CHECKPOINT_STARVATION_READMS    100
   46: 
   47: struct CheckpointStarvationCtx {
   48:   int eMode;
   49:   int nMaxFrame;
   50: };
   51: typedef struct CheckpointStarvationCtx CheckpointStarvationCtx;
   52: 
   53: static int checkpoint_starvation_walhook(
   54:   void *pCtx, 
   55:   sqlite3 *db, 
   56:   const char *zDb, 
   57:   int nFrame
   58: ){
   59:   CheckpointStarvationCtx *p = (CheckpointStarvationCtx *)pCtx;
   60:   if( nFrame>p->nMaxFrame ){
   61:     p->nMaxFrame = nFrame;
   62:   }
   63:   if( nFrame>=CHECKPOINT_STARVATION_FRAMELIMIT ){
   64:     sqlite3_wal_checkpoint_v2(db, zDb, p->eMode, 0, 0);
   65:   }
   66:   return SQLITE_OK;
   67: }
   68: 
   69: static char *checkpoint_starvation_reader(int iTid, int iArg){
   70:   Error err = {0};
   71:   Sqlite db = {0};
   72: 
   73:   opendb(&err, &db, "test.db", 0);
   74:   while( !timetostop(&err) ){
   75:     i64 iCount1, iCount2;
   76:     sql_script(&err, &db, "BEGIN");
   77:     iCount1 = execsql_i64(&err, &db, "SELECT count(x) FROM t1");
   78:     usleep(CHECKPOINT_STARVATION_READMS*1000);
   79:     iCount2 = execsql_i64(&err, &db, "SELECT count(x) FROM t1");
   80:     sql_script(&err, &db, "COMMIT");
   81: 
   82:     if( iCount1!=iCount2 ){
   83:       test_error(&err, "Isolation failure - %lld %lld", iCount1, iCount2);
   84:     }
   85:   }
   86:   closedb(&err, &db);
   87: 
   88:   print_and_free_err(&err);
   89:   return 0;
   90: }
   91: 
   92: static void checkpoint_starvation_main(int nMs, CheckpointStarvationCtx *p){
   93:   Error err = {0};
   94:   Sqlite db = {0};
   95:   Threadset threads = {0};
   96:   int nInsert = 0;
   97:   int i;
   98: 
   99:   opendb(&err, &db, "test.db", 1);
  100:   sql_script(&err, &db, 
  101:       "PRAGMA page_size = 1024;"
  102:       "PRAGMA journal_mode = WAL;"
  103:       "CREATE TABLE t1(x);"
  104:   );
  105: 
  106:   setstoptime(&err, nMs);
  107: 
  108:   for(i=0; i<4; i++){
  109:     launch_thread(&err, &threads, checkpoint_starvation_reader, 0);
  110:     usleep(CHECKPOINT_STARVATION_READMS*1000/4);
  111:   }
  112: 
  113:   sqlite3_wal_hook(db.db, checkpoint_starvation_walhook, (void *)p);
  114:   while( !timetostop(&err) ){
  115:     sql_script(&err, &db, "INSERT INTO t1 VALUES(randomblob(1200))");
  116:     nInsert++;
  117:   }
  118: 
  119:   printf(" Checkpoint mode  : %s\n",
  120:       p->eMode==SQLITE_CHECKPOINT_PASSIVE ? "PASSIVE" : "RESTART"
  121:   );
  122:   printf(" Peak WAL         : %d frames\n", p->nMaxFrame);
  123:   printf(" Transaction count: %d transactions\n", nInsert);
  124: 
  125:   join_all_threads(&err, &threads);
  126:   closedb(&err, &db);
  127:   print_and_free_err(&err);
  128: }
  129: 
  130: static void checkpoint_starvation_1(int nMs){
  131:   Error err = {0};
  132:   CheckpointStarvationCtx ctx = { SQLITE_CHECKPOINT_PASSIVE, 0 };
  133:   checkpoint_starvation_main(nMs, &ctx);
  134:   if( ctx.nMaxFrame<(CHECKPOINT_STARVATION_FRAMELIMIT*10) ){
  135:     test_error(&err, "WAL failed to grow - %d frames", ctx.nMaxFrame);
  136:   }
  137:   print_and_free_err(&err);
  138: }
  139: 
  140: static void checkpoint_starvation_2(int nMs){
  141:   Error err = {0};
  142:   CheckpointStarvationCtx ctx = { SQLITE_CHECKPOINT_RESTART, 0 };
  143:   checkpoint_starvation_main(nMs, &ctx);
  144:   if( ctx.nMaxFrame>CHECKPOINT_STARVATION_FRAMELIMIT+10 ){
  145:     test_error(&err, "WAL grew too large - %d frames", ctx.nMaxFrame);
  146:   }
  147:   print_and_free_err(&err);
  148: }
  149: 
  150: