开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
dbGenerator.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：15k
源码类别：

MySQL数据库

开发平台：

Visual C++

dbGenerator.c：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /***************************************************************
  18. * I N C L U D E D   F I L E S                                  *
  19. ***************************************************************/
  21. #include <ndb_global.h>
  22. #include "dbGenerator.h"
  24. /***************************************************************
  25. * L O C A L   C O N S T A N T S                                *
  26. ***************************************************************/
  28. /***************************************************************
  29. * L O C A L   D A T A   S T R U C T U R E S                    *
  30. ***************************************************************/
  32. /***************************************************************
  33. * L O C A L   F U N C T I O N S                                *
  34. ***************************************************************/
  36. static void getRandomSubscriberNumber(SubscriberNumber number);
  37. static void getRandomServerId(ServerId *serverId);
  38. static void getRandomChangedBy(ChangedBy changedBy);
  39. static void getRandomChangedTime(ChangedTime changedTime);
  41. static void clearTransaction(TransactionDefinition *trans);
  42. static void initGeneratorStatistics(GeneratorStatistics *gen);
  44. static void doOneTransaction(UserHandle *uh, GeneratorStatistics *gen);
  45. static void doTransaction_T1(UserHandle *uh, GeneratorStatistics *gen);
  46. static void doTransaction_T2(UserHandle *uh, GeneratorStatistics *gen);
  47. static void doTransaction_T3(UserHandle *uh, GeneratorStatistics *gen);
  48. static void doTransaction_T4(UserHandle *uh, GeneratorStatistics *gen);
  49. static void doTransaction_T5(UserHandle *uh, GeneratorStatistics *gen);
  51. /***************************************************************
  52. * L O C A L   D A T A                                          *
  53. ***************************************************************/
  55. static SequenceValues transactionDefinition[] = {
  56.    {25, 1},
  57.    {25, 2},
  58.    {20, 3},
  59.    {15, 4},
  60.    {15, 5},
  61.    {0,  0}
  62. };
  64. static SequenceValues rollbackDefinition[] = {
  65.    {98, 0},
  66.    {2 , 1},
  67.    {0,  0}
  68. };
  70. static int maxsize = 0;
  72. /***************************************************************
  73. * P U B L I C   D A T A                                        *
  74. ***************************************************************/
  76. /***************************************************************
  77. ****************************************************************
  78. * L O C A L   F U N C T I O N S   C O D E   S E C T I O N      *
  79. ****************************************************************
  80. ***************************************************************/
  82. static void getRandomSubscriberNumber(SubscriberNumber number)
  83. {
  84.    uint32 tmp;
  85.    char sbuf[SUBSCRIBER_NUMBER_LENGTH + 1];
  86.    tmp = myRandom48(NO_OF_SUBSCRIBERS);
  87.    sprintf(sbuf, "%.*d", SUBSCRIBER_NUMBER_LENGTH, tmp);
  88.    memcpy(number, sbuf, SUBSCRIBER_NUMBER_LENGTH);
  89. }
  91. static void getRandomServerId(ServerId *serverId)
  92. {
  93.    *serverId = myRandom48(NO_OF_SERVERS);
  94. }
  96. static void getRandomChangedBy(ChangedBy changedBy)
  97. {
  98.    memset(changedBy, myRandom48(26)+'A', CHANGED_BY_LENGTH);
  99.    changedBy[CHANGED_BY_LENGTH] = 0;
  100. }
  102. static void getRandomChangedTime(ChangedTime changedTime)
  103. {
  104.    memset(changedTime, myRandom48(26)+'A', CHANGED_TIME_LENGTH);
  105.    changedTime[CHANGED_TIME_LENGTH] = 0;
  106. }
  108. static void clearTransaction(TransactionDefinition *trans)
  109. {
  110.    trans->benchTime        = 0.0;
  111.    trans->count            = 0;
  112.    trans->branchExecuted   = 0;
  113.    trans->rollbackExecuted = 0;
  114. }
  116. static int listFull(SessionList *list)
  117. {
  118.    return(list->numberInList == SESSION_LIST_LENGTH);
  119. }
  121. static int listEmpty(SessionList *list)
  122. {
  123.    return(list->numberInList == 0);
  124. }
  126. static void insertSession(SessionList     *list, 
  127.                           SubscriberNumber number,
  128.                           ServerId         serverId)
  129. {
  130.    SessionElement *e;
  131.    if( listFull(list) ) return;
  133.    e = &list->list[list->writeIndex];
  135.    strcpy(e->subscriberNumber, number);
  136.    e->serverId = serverId;
  138.    list->writeIndex = (list->writeIndex + 1) % SESSION_LIST_LENGTH;
  139.    list->numberInList++;
  141. if( list->numberInList > maxsize )
  142. maxsize = list->numberInList;
  143. }
  145. static SessionElement *getNextSession(SessionList *list)
  146. {
  147.    if( listEmpty(list) ) return(0);
  149.    return(&list->list[list->readIndex]);
  150. }
  152. static void deleteSession(SessionList *list)
  153. {
  154.    if( listEmpty(list) ) return;
  156.    list->readIndex = (list->readIndex + 1) % SESSION_LIST_LENGTH;
  157.    list->numberInList--;
  158. }
  160. static void initGeneratorStatistics(GeneratorStatistics *gen)
  161. {
  162.    int i;
  164.    if( initSequence(&gen->transactionSequence,
  165.                     transactionDefinition) != 0 ) {
  166.       printf("could not set the transaction typesn");
  167.       exit(0);
  168.    }
  170.    if( initSequence(&gen->rollbackSequenceT4,
  171.                     rollbackDefinition) != 0 ) {
  172.       printf("could not set the rollback sequencen");
  173.       exit(0);
  174.    }
  176.    if( initSequence(&gen->rollbackSequenceT5,
  177.                     rollbackDefinition) != 0 ) {
  178.       printf("could not set the rollback sequencen");
  179.       exit(0);
  180.    }
  182.    for(i = 0; i < NUM_TRANSACTION_TYPES; i++ )
  183.       clearTransaction(&gen->transactions[i]);
  185.    gen->totalTransactions = 0;
  187.    gen->activeSessions.numberInList = 0;
  188.    gen->activeSessions.readIndex    = 0;
  189.    gen->activeSessions.writeIndex   = 0;
  190. }
  193. static void doOneTransaction(UserHandle *uh, GeneratorStatistics *gen)
  194. {
  195.    unsigned int transactionType;
  197.    transactionType = getNextRandom(&gen->transactionSequence);
  199.    switch(transactionType) {
  200.       case 1:
  201.          doTransaction_T1(uh, gen);
  202.          break;
  203.       case 2:
  204.          doTransaction_T2(uh, gen);
  205.          break;
  206.       case 3:
  207.          doTransaction_T3(uh, gen);
  208.          break;
  209.       case 4:
  210.          doTransaction_T4(uh, gen);
  211.          break;
  212.       case 5:
  213.          doTransaction_T5(uh, gen);
  214.          break;
  215.       default:
  216.          printf("Unknown transaction type: %dn", transactionType);
  217.    }
  219.    gen->totalTransactions++;
  220. }
  222. static void doTransaction_T1(UserHandle *uh, GeneratorStatistics *gen)
  223. {
  224.    SubscriberNumber number;
  225.    Location         new_location;
  226.    ChangedBy        changed_by; 
  227.    ChangedTime      changed_time;
  229.    double start_time;
  230.    double end_time;
  231.    double transaction_time;
  233.    unsigned int tid = 0;
  235.    /*----------------*/
  236.    /* Init arguments */
  237.    /*----------------*/
  238.    getRandomSubscriberNumber(number);
  239.    getRandomChangedBy(changed_by);
  240.    getRandomChangedTime(changed_time);
  241.    new_location = changed_by[0];
  243.    /*-----------------*/
  244.    /* Run transaction */
  245.    /*-----------------*/
  246.    start_time = userGetTimeSync();
  247.    userTransaction_T1(uh,
  248.                       number,
  249.                       new_location,
  250.                       changed_by,
  251.                       changed_time);
  252.    end_time = userGetTimeSync();
  254.    /*-------------------*/
  255.    /* Update Statistics */
  256.    /*-------------------*/
  257.    transaction_time = end_time - start_time;
  258.    gen->transactions[tid].benchTime += transaction_time;
  259.    gen->transactions[tid].count++;
  260. }
  262. static void doTransaction_T2(UserHandle *uh, GeneratorStatistics *gen)
  263. {
  264.    SubscriberNumber number;
  265.    Location         new_location;
  266.    ChangedBy        changed_by; 
  267.    ChangedTime      changed_time;
  268.    SubscriberName   subscriberName;
  270.    double start_time;
  271.    double end_time;
  272.    double transaction_time;
  274.    unsigned int tid = 1;
  276.    /*----------------*/
  277.    /* Init arguments */
  278.    /*----------------*/
  279.    getRandomSubscriberNumber(number);
  281.    /*-----------------*/
  282.    /* Run transaction */
  283.    /*-----------------*/
  284.    start_time = userGetTimeSync();
  285.    userTransaction_T2(uh,
  286.                       number,
  287.                      &new_location,
  288.                       changed_by,
  289.                       changed_time,
  290.                       subscriberName);
  291.    end_time = userGetTimeSync();
  293.    /*-------------------*/
  294.    /* Update Statistics */
  295.    /*-------------------*/
  296.    transaction_time = end_time - start_time;
  297.    gen->transactions[tid].benchTime += transaction_time;
  298.    gen->transactions[tid].count++;
  299. }
  301. static void doTransaction_T3(UserHandle *uh, GeneratorStatistics *gen)
  302. {
  303.    SubscriberNumber number;
  304.    ServerId         serverId;
  305.    ServerBit        serverBit;
  306.    SessionDetails   sessionDetails;
  307.    unsigned int     branchExecuted;
  308.    SessionElement  *se;
  310.    double start_time;
  311.    double end_time;
  312.    double transaction_time;
  314.    unsigned int tid = 2;
  316.    /*----------------*/
  317.    /* Init arguments */
  318.    /*----------------*/
  319.    se = getNextSession(&gen->activeSessions);
  320.    if( se ) {
  321.       strcpy(number, se->subscriberNumber);
  322.       serverId = se->serverId;
  323.    }
  324.    else {
  325.       getRandomSubscriberNumber(number);
  326.       getRandomServerId(&serverId);
  327.    }
  329.    serverBit = 1 << serverId;
  331.    /*-----------------*/
  332.    /* Run transaction */
  333.    /*-----------------*/
  334.    start_time = userGetTimeSync();
  335.    userTransaction_T3(uh,
  336.                       number,
  337.                       serverId,
  338.                       serverBit,
  339.                       sessionDetails,
  340.                       &branchExecuted);
  341.    end_time = userGetTimeSync();
  343.    /*-------------------*/
  344.    /* Update Statistics */
  345.    /*-------------------*/
  346.    transaction_time = end_time - start_time;
  347.    gen->transactions[tid].benchTime += transaction_time;
  348.    gen->transactions[tid].count++;
  350.    if(branchExecuted)
  351.       gen->transactions[tid].branchExecuted++;
  352. }
  354. static void doTransaction_T4(UserHandle *uh, GeneratorStatistics *gen)
  355. {
  356.    SubscriberNumber number;
  357.    ServerId         serverId;
  358.    ServerBit        serverBit;
  359.    SessionDetails   sessionDetails;
  360.    unsigned int     branchExecuted;
  361.    unsigned int     rollback;
  363.    double start_time;
  364.    double end_time;
  365.    double transaction_time;
  367.    unsigned int tid = 3;
  369.    /*----------------*/
  370.    /* Init arguments */
  371.    /*----------------*/
  372.    getRandomSubscriberNumber(number);
  373.    getRandomServerId(&serverId);
  375.    serverBit = 1 << serverId;
  376.    rollback  = getNextRandom(&gen->rollbackSequenceT4);
  378.    memset(sessionDetails, myRandom48(26)+'A', SESSION_DETAILS_LENGTH);
  379.    sessionDetails[SESSION_DETAILS_LENGTH] = 0;
  381.    /*-----------------*/
  382.    /* Run transaction */
  383.    /*-----------------*/
  384.    start_time = userGetTimeSync();
  385.    userTransaction_T4(uh,
  386.                       number,
  387.                       serverId,
  388.                       serverBit,
  389.                       sessionDetails,
  390.                       rollback,
  391.                       &branchExecuted);
  392.    end_time = userGetTimeSync();
  394.    /*-------------------*/
  395.    /* Update Statistics */
  396.    /*-------------------*/
  397.    transaction_time = end_time - start_time;
  398.    gen->transactions[tid].benchTime += transaction_time;
  399.    gen->transactions[tid].count++;
  401.    if(branchExecuted)
  402.       gen->transactions[tid].branchExecuted++;
  403.    if(rollback)
  404.       gen->transactions[tid].rollbackExecuted++;
  406.    if( branchExecuted && !rollback ) {
  407.       insertSession(&gen->activeSessions, number, serverId);
  408.    }
  409. }
  411. static void doTransaction_T5(UserHandle *uh, GeneratorStatistics *gen)
  412. {
  413.    SubscriberNumber number;
  414.    ServerId         serverId;
  415.    ServerBit        serverBit;
  416.    unsigned int     branchExecuted;
  417.    unsigned int     rollback;
  418.    SessionElement  *se;
  420.    double start_time;
  421.    double end_time;
  422.    double transaction_time;
  424.    unsigned int tid = 4;
  426.    /*----------------*/
  427.    /* Init arguments */
  428.    /*----------------*/
  429.    se = getNextSession(&gen->activeSessions);
  430.    if( se ) {
  431.       strcpy(number, se->subscriberNumber);
  432.       serverId = se->serverId;
  433.    }
  434.    else {
  435.       getRandomSubscriberNumber(number);
  436.       getRandomServerId(&serverId);
  437.    }
  439.    serverBit = 1 << serverId;
  440.    rollback  = getNextRandom(&gen->rollbackSequenceT5);
  442.    /*-----------------*/
  443.    /* Run transaction */
  444.    /*-----------------*/
  445.    start_time = userGetTimeSync();
  446.    userTransaction_T5(uh,
  447.                       number,
  448.                       serverId,
  449.                       serverBit,
  450.                       rollback,
  451.                       &branchExecuted);
  452.    end_time = userGetTimeSync();
  454.    /*-------------------*/
  455.    /* Update Statistics */
  456.    /*-------------------*/
  457.    transaction_time = end_time - start_time;
  458.    gen->transactions[tid].benchTime += transaction_time;
  459.    gen->transactions[tid].count++;
  461.    if(branchExecuted)
  462.       gen->transactions[tid].branchExecuted++;
  463.    if(rollback)
  464.       gen->transactions[tid].rollbackExecuted++;
  466.    if( se && !rollback) {
  467.       deleteSession(&gen->activeSessions);
  468.    }
  469. }
  471. /***************************************************************
  472. ****************************************************************
  473. * P U B L I C   F U N C T I O N S   C O D E   S E C T I O N    *
  474. ****************************************************************
  475. ***************************************************************/
  478. void dbGenerator(UserHandle *uh, ThreadData *data)
  479. {
  480.    GeneratorStatistics rg_warmUp;
  481.    GeneratorStatistics rg_coolDown;
  482.    GeneratorStatistics *st;
  483.    double periodStop;
  484.    double benchTimeStart;
  485.    double benchTimeEnd;
  486.    int i;
  488.    myRandom48Init(data->randomSeed);
  490.    initGeneratorStatistics(&rg_warmUp);
  491.    initGeneratorStatistics(&data->generator);
  492.    initGeneratorStatistics(&rg_coolDown);
  494.    /*----------------*/
  495.    /* warm up period */
  496.    /*----------------*/
  497.    periodStop = userGetTimeSync() + (double)data->warmUpSeconds;
  498.    while(userGetTimeSync() < periodStop){
  499.      doOneTransaction(uh, &rg_warmUp);
  500.    }
  502.    /*-------------------------*/
  503.    /* normal benchmark period */
  504.    /*-------------------------*/
  505.    benchTimeStart = userGetTimeSync();
  507.    if( data->numTransactions > 0 ) {
  508.       for(i = 0; i < data->numTransactions; i++)
  509.          doOneTransaction(uh, &data->generator);
  510.    }
  511.    else {
  512.       periodStop = benchTimeStart + (double)data->testSeconds;
  513.       while(userGetTimeSync() < periodStop)
  514.          doOneTransaction(uh, &data->generator);
  515.    }
  517.    benchTimeEnd = userGetTimeSync();
  519.    /*------------------*/
  520.    /* cool down period */
  521.    /*------------------*/
  522.    periodStop = benchTimeEnd + data->coolDownSeconds;
  523.    while(userGetTimeSync() < periodStop){
  524.      doOneTransaction(uh, &rg_coolDown);
  525.    }
  527.    /*---------------------------------------------------------*/
  528.    /* add the times for all transaction for inner loop timing */
  529.    /*---------------------------------------------------------*/
  530.    st = &data->generator;
  531.    st->innerLoopTime = 0.0;
  532.    for(i = 0 ; i < NUM_TRANSACTION_TYPES; i++) {
  533.       st->innerLoopTime += st->transactions[i].benchTime;
  534.       st->transactions[i].tps = getTps(st->transactions[i].count,
  535.                                        st->transactions[i].benchTime);
  536.    }
  538.    st->outerLoopTime = benchTimeEnd - benchTimeStart;
  539.    st->outerTps      = getTps(st->totalTransactions, st->outerLoopTime);
  540.    st->innerTps      = getTps(st->totalTransactions, st->innerLoopTime);
  542.    /* printf("maxsize = %dn",maxsize); */
  543. }