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

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

MySQL数据库

开发平台：

Visual C++

msa.cpp：源码内容
  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. #include <ndb_global.h>
  19. #include <NdbApi.hpp>
  20. #include <NdbSchemaCon.hpp>
  21. #include <NdbCondition.h>
  22. #include <NdbMutex.h>
  23. #include <NdbSleep.h>
  24. #include <NdbThread.h>
  25. #include <NdbTick.h>
  27. const char* const c_szDatabaseName = "TEST_DB";
  29. const char* const c_szTableNameStored = "CCStored";
  30. const char* const c_szTableNameTemp = "CCTemp";
  32. const char* const c_szContextId = "ContextId";
  33. const char* const c_szVersion = "Version";
  34. const char* const c_szLockFlag = "LockFlag";
  35. const char* const c_szLockTime = "LockTime";
  36. const char* const c_szLockTimeUSec = "LockTimeUSec";
  37. const char* const c_szContextData = "ContextData";
  39. const char* g_szTableName = c_szTableNameStored;
  42. #ifdef NDB_WIN32
  43. HANDLE hShutdownEvent = 0;
  44. #else
  45. #include <signal.h>
  46. bool bShutdownEvent = false;
  47. #endif
  48. long g_nMaxContextIdPerThread = 5000;
  49. long g_nNumThreads = 0;
  50. long g_nMaxCallsPerSecond = 0;
  51. long g_nMaxRetry = 50;
  52. bool g_bWriteTuple = false;
  53. bool g_bInsertInitial = false;
  54. bool g_bVerifyInitial = false;
  56. NdbMutex* g_pNdbMutexPrintf = 0;
  57. NdbMutex* g_pNdbMutexIncrement = 0;
  58. long g_nNumCallsProcessed = 0;
  59. NDB_TICKS g_tStartTime = 0;
  60. NDB_TICKS g_tEndTime = 0;
  62. long g_nNumberOfInitialInsert = 0;
  63. long g_nNumberOfInitialVerify = 0;
  65. const long c_nMaxMillisecForAllCall = 5000;
  66. long* g_plCountMillisecForCall = 0;
  67. const long c_nMaxMillisecForAllTrans = 5000;
  68. long* g_plCountMillisecForTrans = 0;
  69. bool g_bReport = false;
  70. bool g_bReportPlus = false;
  73. // data for CALL_CONTEXT and GROUP_RESOURCE
  74. static char STATUS_DATA[]= 
  75. "000102030405060708090A0B0C0D0E0F000102030405060708090A0B0C0D0E0F"
  76. "101112131415161718191A1B1C1D1E1F000102030405060708090A0B0C0D0E0F"
  77. "202122232425262728292A2B2C2D2E2F000102030405060708090A0B0C0D0E0F"
  78. "303132333435363738393A3B3C3D3E3F000102030405060708090A0B0C0D0E0F"
  79. "404142434445464748494A4B4C4D4E4F000102030405060708090A0B0C0D0E0F"
  80. "505152535455565758595A5B5C5D5E5F000102030405060708090A0B0C0D0E0F"
  81. "606162636465666768696A6B6C6D6E6F000102030405060708090A0B0C0D0E0F"
  82. "707172737475767778797A7B7C7D7E7F000102030405060708090A0B0C0D0E0F"
  83. "808182838485868788898A8B8C8D8E8F000102030405060708090A0B0C0D0E0F"
  84. "909192939495969798999A9B9C9D9E9F000102030405060708090A0B0C0D0E0F"
  85. "10010110210310410510610710810910A000102030405060708090A0B0C0D0EF"
  86. "10B10C10D10E10F110111112113114115000102030405060708090A0B0C0D0EF"
  87. "11611711811911A11B11C11D11E11F120000102030405060708090A0B0C0D0EF"
  88. "12112212312412512612712812912A12B000102030405060708090A0B0C0D0EF"
  89. "12C12D12E12F130131132134135136137000102030405060708090A0B0C0D0EF"
  90. "13813913A13B13C13D13E13F140141142000102030405060708090A0B0C0D0EF"
  91. "14314414514614714814914A14B14C14D000102030405060708090A0B0C0D0EF"
  92. "14E14F150151152153154155156157158000102030405060708090A0B0C0D0EF"
  93. "15915A15B15C15D15E15F160161162163000102030405060708090A0B0C0D0EF"
  94. "16416516616716816916A16B16C16D16E000102030405060708090A0B0C0D0EF"
  95. "16F170171172173174175176177178179000102030405060708090A0B0C0D0EF"
  96. "17A17B17C17D17E17F180181182183184000102030405060708090A0B0C0D0EF"
  97. "18518618718818918A18B18C18D18E18F000102030405060708090A0B0C0D0EF"
  98. "19019119219319419519619719819919A000102030405060708090A0B0C0D0EF"
  99. "19B19C19D19E19F200201202203204205000102030405060708090A0B0C0D0EF"
  100. "20620720820920A20B20C20D20F210211000102030405060708090A0B0C0D0EF"
  101. "21221321421521621721821921A21B21C000102030405060708090A0B0C0D0EF"
  102. "21D21E21F220221222223224225226227000102030405060708090A0B0C0D0EF"
  103. "22822922A22B22C22D22E22F230231232000102030405060708090A0B0C0D0EF"
  104. "23323423523623723823923A23B23C23D000102030405060708090A0B0C0D0EF"
  105. "23E23F240241242243244245246247248000102030405060708090A0B0C0D0EF"
  106. "24924A24B24C24D24E24F250251252253000102030405060708090A0B0C0D0EF"
  107. "101112131415161718191A1B1C1D1E1F000102030405060708090A0B0C0D0E0F"
  108. "202122232425262728292A2B2C2D2E2F000102030405060708090A0B0C0D0E0F"
  109. "303132333435363738393A3B3C3D3E3F000102030405060708090A0B0C0D0E0F"
  110. "404142434445464748494A4B4C4D4E4F000102030405060708090A0B0C0D0E0F"
  111. "505152535455565758595A5B5C5D5E5F000102030405060708090A0B0C0D0E0F"
  112. "606162636465666768696A6B6C6D6E6F000102030405060708090A0B0C0D0E0F"
  113. "707172737475767778797A7B7C7D7E7F000102030405060708090A0B0C0D0E0F"
  114. "808182838485868788898A8B8C8D8E8F000102030405060708090A0B0C0D0E0F"
  115. "909192939495969798999A9B9C9D9E9F000102030405060708090A0B0C0D0E0F"
  116. "10010110210310410510610710810910A000102030405060708090A0B0C0D0EF"
  117. "10B10C10D10E10F110111112113114115000102030405060708090A0B0C0D0EF"
  118. "11611711811911A11B11C11D11E11F120000102030405060708090A0B0C0D0EF"
  119. "12112212312412512612712812912A12B000102030405060708090A0B0C0D0EF"
  120. "12C12D12E12F130131132134135136137000102030405060708090A0B0C0D0EF"
  121. "13813913A13B13C13D13E13F140141142000102030405060708090A0B0C0D0EF"
  122. "14314414514614714814914A14B14C14D000102030405060708090A0B0C0D0EF"
  123. "14E14F150151152153154155156157158000102030405060708090A0B0C0D0EF"
  124. "15915A15B15C15D15E15F160161162163000102030405060708090A0B0C0D0EF"
  125. "16416516616716816916A16B16C16D16E000102030405060708090A0B0C0D0EF"
  126. "16F170171172173174175176177178179000102030405060708090A0B0C0D0EF"
  127. "17A17B17C17D17E17F180181182183184000102030405060708090A0B0C0D0EF"
  128. "18518618718818918A18B18C18D18E18F000102030405060708090A0B0C0D0EF"
  129. "19019119219319419519619719819919A000102030405060708090A0B0C0D0EF"
  130. "19B19C19D19E19F200201202203204205000102030405060708090A0B0C0D0EF"
  131. "20620720820920A20B20C20D20F210211000102030405060708090A0B0C0D0EF"
  132. "21221321421521621721821921A21B21C000102030405060708090A0B0C0D0EF"
  133. "21D21E21F220221222223224225226227000102030405060708090A0B0C0D0EF"
  134. "22822922A22B22C22D22E22F230231232000102030405060708090A0B0C0D0EF"
  135. "23323423523623723823923A23B23C23D000102030405060708090A0B0C0D0EF"
  136. "2366890FE1438751097E7F6325DC0E6326F"
  137. "25425525625725825925A25B25C25D25E25F000102030405060708090A0B0C0F";     
  139. long g_nStatusDataSize = sizeof(STATUS_DATA);
  142. // Thread function for Call Context Inserts
  145. #ifdef NDB_WIN32
  147. BOOL WINAPI ConsoleCtrlHandler(DWORD dwCtrlType)
  148. {
  149.     if(CTRL_C_EVENT == dwCtrlType)
  150.     {
  151.         SetEvent(hShutdownEvent);
  152.         return TRUE;
  153.     }
  154.     return FALSE;
  155. }
  157. #else
  159. void CtrlCHandler(int)
  160. {
  161.     bShutdownEvent = true;
  162. }
  164. #endif
  168. void ReportNdbError(const char* szMsg, const NdbError& err)
  169. {
  170.     NdbMutex_Lock(g_pNdbMutexPrintf);
  171.     printf("%s: %d: %sn", szMsg, err.code, (err.message ? err.message : ""));
  172.     NdbMutex_Unlock(g_pNdbMutexPrintf);
  173. }
  176. void
  177. ReportCallsPerSecond(long nNumCallsProcessed, 
  178.                      NDB_TICKS tStartTime, 
  179.                      NDB_TICKS tEndTime)
  180. {
  181.     NDB_TICKS tElapsed = tEndTime - tStartTime;
  182.     long lCallsPerSec;
  183.     if(tElapsed>0)
  184.         lCallsPerSec = (long)((1000*nNumCallsProcessed)/tElapsed);
  185.     else
  186.         lCallsPerSec = 0;
  188.     NdbMutex_Lock(g_pNdbMutexPrintf);
  189.     printf("Time Taken for %ld Calls is %ld msec (= %ld calls/sec)n",
  190.         nNumCallsProcessed, (long)tElapsed, lCallsPerSec);
  191.     NdbMutex_Unlock(g_pNdbMutexPrintf);
  192. }
  195. #ifndef NDB_WIN32
  196. void InterlockedIncrement(long* lp)             // expensive
  197. {
  198.     NdbMutex_Lock(g_pNdbMutexIncrement);
  199.     (*lp)++;
  200.     NdbMutex_Unlock(g_pNdbMutexIncrement);
  201. }
  202. #endif
  205. void InterlockedIncrementAndReport(void)
  206. {
  207.     NdbMutex_Lock(g_pNdbMutexIncrement);
  208.     ++g_nNumCallsProcessed;
  209.     if((g_nNumCallsProcessed%1000)==0) 
  210.     {
  211.         g_tEndTime = NdbTick_CurrentMillisecond();
  212.         if(g_tStartTime) 
  213.             ReportCallsPerSecond(1000, g_tStartTime, g_tEndTime);
  215.         g_tStartTime = g_tEndTime;
  216.     }
  217.     NdbMutex_Unlock(g_pNdbMutexIncrement);
  218. }
  221. void SleepOneCall(void)
  222. {
  223.     int iMillisecToSleep;
  224.     if(g_nMaxCallsPerSecond>0)
  225.         iMillisecToSleep = (1000*g_nNumThreads)/g_nMaxCallsPerSecond;
  226.     else
  227.         iMillisecToSleep = 50;
  229.     if(iMillisecToSleep>0)
  230.         NdbSleep_MilliSleep(iMillisecToSleep);
  232. }
  236. int QueryTransaction(Ndb* pNdb, 
  237.                      long iContextId,                       
  238.                      long* piVersion, 
  239.                      long* piLockFlag, 
  240.                      long* piLockTime, 
  241.                      long* piLockTimeUSec, 
  242.                      char* pchContextData, 
  243.                      NdbError& err)
  244. {
  245.     int iRes = -1;
  246.     NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextId, 4);
  247.     if(pNdbConnection)
  248.     {
  249.         NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName);
  250.         if(pNdbOperation)
  251.         {
  252.             NdbRecAttr* pNdbRecAttrVersion;
  253.             NdbRecAttr* pNdbRecAttrLockFlag;
  254.             NdbRecAttr* pNdbRecAttrLockTime;
  255.             NdbRecAttr* pNdbRecAttrLockTimeUSec;
  256.             NdbRecAttr* pNdbRecAttrContextData;
  257.             if(!pNdbOperation->readTuple()
  258.             && !pNdbOperation->equal(c_szContextId, (Int32)iContextId)
  259.             && (pNdbRecAttrVersion=pNdbOperation->getValue(c_szVersion, (char*)piVersion))
  260.             && (pNdbRecAttrLockFlag=pNdbOperation->getValue(c_szLockFlag, (char*)piLockFlag))
  261.             && (pNdbRecAttrLockTime=pNdbOperation->getValue(c_szLockTime, (char*)piLockTime))
  262.             && (pNdbRecAttrLockTimeUSec=pNdbOperation->getValue(c_szLockTimeUSec, (char*)piLockTimeUSec))
  263.             && (pNdbRecAttrContextData=pNdbOperation->getValue(c_szContextData, pchContextData)))
  264.             {
  265.                 if(!pNdbConnection->execute(Commit))
  266.                     iRes = 0;
  267.                 else 
  268.                     err = pNdbConnection->getNdbError();
  269.             } 
  270.             else 
  271.                 err = pNdbOperation->getNdbError();
  272.         } 
  273.         else 
  274.             err = pNdbConnection->getNdbError();
  276.         pNdb->closeTransaction(pNdbConnection);
  277.     } 
  278.     else 
  279.         err = pNdb->getNdbError();
  280.     
  281.     return iRes;
  282. }
  285. int RetryQueryTransaction(Ndb* pNdb, 
  286.                           long iContextId, 
  287.                           long* piVersion, 
  288.                           long* piLockFlag, 
  289.                           long* piLockTime, 
  290.                           long* piLockTimeUSec, 
  291.                           char* pchContextData, 
  292.                           NdbError& err, 
  293.                           int& nRetry)
  294. {
  295.     int iRes = -1;
  296.     nRetry = 0;
  297.     bool bRetry = true;
  298.     while(bRetry && nRetry<g_nMaxRetry)
  299.     {
  300.         if(!QueryTransaction(pNdb, iContextId, piVersion, piLockFlag, 
  301.             piLockTime, piLockTimeUSec, pchContextData, err))
  302.         {
  303.             iRes = 0;
  304.             bRetry = false;
  305.         }
  306.         else
  307.         {
  308.             switch(err.status)
  309.             {
  310.             case NdbError::TemporaryError:
  311.             case NdbError::UnknownResult:
  312.                 SleepOneCall();
  313.                 ++nRetry;
  314.                 break;
  315.             
  316.             case NdbError::PermanentError:
  317.             default:
  318.                 bRetry = false;
  319.                 break;
  320.             }
  321.         }
  322.     }
  323.     return iRes;
  324. }
  327. int DeleteTransaction(Ndb* pNdb, long iContextId, NdbError& err)
  328. {
  329.     int iRes = -1;
  330.     NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextId, 4);
  331.     if(pNdbConnection)
  332.     {
  333.         NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName);
  334.         if(pNdbOperation)
  335.         {
  336.             if(!pNdbOperation->deleteTuple()
  337.             && !pNdbOperation->equal(c_szContextId, (Int32)iContextId)) 
  338.             {
  339.                 if(pNdbConnection->execute(Commit) == 0) 
  340.                     iRes = 0;
  341.                 else 
  342.                     err = pNdbConnection->getNdbError();
  343.             } 
  344.             else 
  345.                 err = pNdbOperation->getNdbError();
  346.         } 
  347.         else 
  348.             err = pNdbConnection->getNdbError();
  350.         pNdb->closeTransaction(pNdbConnection);
  351.     } 
  352.     else 
  353.         err = pNdb->getNdbError();
  355.     return iRes;
  356. }
  360. int RetryDeleteTransaction(Ndb* pNdb, long iContextId, NdbError& err, int& nRetry)
  361. {
  362.     int iRes = -1;
  363.     nRetry = 0;
  364.     bool bRetry = true;
  365.     bool bUnknown = false;
  366.     while(bRetry && nRetry<g_nMaxRetry)
  367.     {
  368.         if(!DeleteTransaction(pNdb, iContextId, err))
  369.         {
  370.             iRes = 0;
  371.             bRetry = false;
  372.         }
  373.         else
  374.         {
  375.             switch(err.status)
  376.             {
  377.             case NdbError::UnknownResult:
  378.                 bUnknown = true;
  379.                 ++nRetry;
  380.                 break;
  382.             case NdbError::TemporaryError:
  383.                 bUnknown = false;
  384.                 SleepOneCall();
  385.                 ++nRetry;
  386.                 break;
  387.             
  388.             case NdbError::PermanentError:
  389.                 if(err.code==626 && bUnknown)
  390.                     iRes = 0;
  391.                 bRetry = false;
  392.                 break;
  394.             default:
  395.                 bRetry = false;
  396.                 break;
  397.             }
  398.         }
  399.     }
  400.     return iRes;
  401. }
  405. int InsertTransaction(Ndb* pNdb, 
  406.                       long iContextID, 
  407.                       long iVersion, 
  408.                       long iLockFlag, 
  409.                       long iLockTime, 
  410.                       long iLockTimeUSec, 
  411.                       const char* pchContextData, 
  412.                       NdbError& err)
  413. {
  414.     int iRes = -1;
  415.     NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextID, 4);
  416.     if(pNdbConnection)
  417.     {
  418.         NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName);
  419.         if(pNdbOperation) 
  420.         {
  421.             if(!(g_bWriteTuple ? pNdbOperation->writeTuple() : pNdbOperation->insertTuple())
  422.                 && !pNdbOperation->equal(c_szContextId, (Int32)iContextID)
  423.                 && !pNdbOperation->setValue(c_szVersion, (Int32)iVersion)
  424.                 && !pNdbOperation->setValue(c_szLockFlag, (Int32)iLockFlag)
  425.                 && !pNdbOperation->setValue(c_szLockTime, (Int32)iLockTime)
  426.                 && !pNdbOperation->setValue(c_szLockTimeUSec, (Int32)iLockTimeUSec)
  427.                 && !pNdbOperation->setValue(c_szContextData, pchContextData, g_nStatusDataSize))  
  428.             {
  429.                 if(!pNdbConnection->execute(Commit))
  430.                     iRes = 0;
  431.                 else 
  432.                     err = pNdbConnection->getNdbError();
  433.             }
  434.             else 
  435.                 err = pNdbOperation->getNdbError();
  436.         } 
  437.         else 
  438.             err = pNdbConnection->getNdbError();
  440.         pNdb->closeTransaction(pNdbConnection);
  441.     } 
  442.     else 
  443.         err = pNdb->getNdbError();
  445.     return iRes;
  446. }
  450. int RetryInsertTransaction(Ndb* pNdb, 
  451.                            long iContextId, 
  452.                            long iVersion, 
  453.                            long iLockFlag, 
  454.                            long iLockTime, 
  455.                            long iLockTimeUSec, 
  456.                            const char* pchContextData, 
  457.                            NdbError& err, int& nRetry)
  458. {
  459.     int iRes = -1;
  460.     nRetry = 0;
  461.     bool bRetry = true;
  462.     bool bUnknown = false;
  463.     while(bRetry && nRetry<g_nMaxRetry)
  464.     {
  465.         if(!InsertTransaction(pNdb, iContextId, iVersion, iLockFlag, 
  466.             iLockTime, iLockTimeUSec, pchContextData, err))
  467.         {
  468.             iRes = 0;
  469.             bRetry = false;
  470.         }
  471.         else
  472.         {
  473.             switch(err.status)
  474.             {
  475.             case NdbError::UnknownResult:
  476.                 bUnknown = true;
  477.                 ++nRetry;
  478.                 break;
  480.             case NdbError::TemporaryError:
  481.                 bUnknown = false;
  482.                 SleepOneCall();
  483.                 ++nRetry;
  484.                 break;
  485.             
  486.             case NdbError::PermanentError:
  487.                 if(err.code==630 && bUnknown)
  488.                     iRes = 0;
  489.                 bRetry = false;
  490.                 break;
  492.             default:
  493.                 bRetry = false;
  494.                 break;
  495.             }
  496.         }
  497.     }
  498.     return iRes;
  499. }
  502. int UpdateTransaction(Ndb* pNdb, long iContextId, NdbError& err)
  503. {
  504.     int iRes = -1;
  505.     NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextId, 4);
  506.     if(pNdbConnection)
  507.     {
  508.         NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName);
  509.         if(pNdbOperation)
  510.         {
  511.             if(!pNdbOperation->updateTuple()
  512.             && !pNdbOperation->equal(c_szContextId, (Int32)iContextId)
  513.             && !pNdbOperation->setValue(c_szContextData, STATUS_DATA, g_nStatusDataSize))
  514.             {
  515.                 if(!pNdbConnection->execute(Commit))
  516.                     iRes = 0;
  517.                 else 
  518.                     err = pNdbConnection->getNdbError();
  519.             }
  520.             else 
  521.                 err = pNdbOperation->getNdbError();
  522.         } 
  523.         else 
  524.             err = pNdbConnection->getNdbError();
  526.         pNdb->closeTransaction(pNdbConnection);
  527.     } 
  528.     else 
  529.         err = pNdb->getNdbError();
  531.     return iRes;
  532. }
  535. int RetryUpdateTransaction(Ndb* pNdb, long iContextId, NdbError& err, int& nRetry)
  536. {
  537.     int iRes = -1;
  538.     nRetry = 0;
  539.     bool bRetry = true;
  540.     while(bRetry && nRetry<g_nMaxRetry)
  541.     {
  542.         if(!UpdateTransaction(pNdb, iContextId, err))
  543.         {
  544.             iRes = 0;
  545.             bRetry = false;
  546.         }
  547.         else
  548.         {
  549.             switch(err.status)
  550.             {
  551.             case NdbError::TemporaryError:
  552.             case NdbError::UnknownResult:
  553.                 SleepOneCall();
  554.                 ++nRetry;
  555.                 break;
  556.             
  557.             case NdbError::PermanentError:
  558.             default:
  559.                 bRetry = false;
  560.                 break;
  561.             }
  562.         }
  563.     }
  564.     return iRes;
  565. }
  569. int InsertInitialRecords(Ndb* pNdb, long nInsert, long nSeed)
  570. {
  571.     int iRes = -1;
  572.     char szMsg[100];
  573.     for(long i=0; i<nInsert; ++i) 
  574.     {
  575.         int iContextID = i+nSeed;
  576.         int nRetry = 0;
  577.         NdbError err;
  578.         memset(&err, 0, sizeof(err));
  579.         NDB_TICKS tStartTrans = NdbTick_CurrentMillisecond();
  580.         iRes = RetryInsertTransaction(pNdb, iContextID, nSeed, iContextID,
  581.             (long)(tStartTrans/1000), (long)((tStartTrans%1000)*1000), 
  582.             STATUS_DATA, err, nRetry);
  583.         NDB_TICKS tEndTrans = NdbTick_CurrentMillisecond();
  584.         long lMillisecForThisTrans = (long)(tEndTrans-tStartTrans);
  585.         if(nRetry>0)
  586.         {
  587.             sprintf(szMsg, "insert retried %d times, time %ld msec.", 
  588.                 nRetry, lMillisecForThisTrans);
  589.             ReportNdbError(szMsg, err);
  590.         }
  591.         if(iRes)
  592.         {
  593.             ReportNdbError("Insert initial record failed", err);
  594.             return iRes;
  595.         }
  596.         InterlockedIncrement(&g_nNumberOfInitialInsert);
  597.     }
  598.     return iRes;
  599. }
  603. int VerifyInitialRecords(Ndb* pNdb, long nVerify, long nSeed)
  604. {
  605.     int iRes = -1;
  606.     char* pchContextData = new char[g_nStatusDataSize];
  607.     char szMsg[100];
  608.     long iPrevLockTime = -1;
  609.     long iPrevLockTimeUSec = -1;
  610.     for(long i=0; i<nVerify; ++i) 
  611.     {
  612.         int iContextID = i+nSeed;
  613.         long iVersion = 0;
  614.         long iLockFlag = 0;
  615.         long iLockTime = 0;
  616.         long iLockTimeUSec = 0;
  617.         int nRetry = 0;
  618.         NdbError err;
  619.         memset(&err, 0, sizeof(err));
  620.         NDB_TICKS tStartTrans = NdbTick_CurrentMillisecond();
  621.         iRes = RetryQueryTransaction(pNdb, iContextID, &iVersion, &iLockFlag, 
  622.                     &iLockTime, &iLockTimeUSec, pchContextData, err, nRetry);
  623.         NDB_TICKS tEndTrans = NdbTick_CurrentMillisecond();
  624.         long lMillisecForThisTrans = (long)(tEndTrans-tStartTrans);
  625.         if(nRetry>0)
  626.         {
  627.             sprintf(szMsg, "verify retried %d times, time %ld msec.", 
  628.                 nRetry, lMillisecForThisTrans);
  629.             ReportNdbError(szMsg, err);
  630.         }
  631.         if(iRes)
  632.         {
  633.             ReportNdbError("Read initial record failed", err);
  634.             delete[] pchContextData;
  635.             return iRes;
  636.         }
  637.         if(memcmp(pchContextData, STATUS_DATA, g_nStatusDataSize))
  638.         {
  639.             sprintf(szMsg, "wrong context data in tuple %d", iContextID);
  640.             ReportNdbError(szMsg, err);
  641.             delete[] pchContextData;
  642.             return -1;
  643.         }
  644.         if(iVersion!=nSeed 
  645.             || iLockFlag!=iContextID 
  646.             || iLockTime<iPrevLockTime 
  647.             || (iLockTime==iPrevLockTime && iLockTimeUSec<iPrevLockTimeUSec))
  648.         {
  649.             sprintf(szMsg, "wrong call data in tuple %d", iContextID);
  650.             ReportNdbError(szMsg, err);
  651.             delete[] pchContextData;
  652.             return -1;
  653.         }
  654.         iPrevLockTime = iLockTime;
  655.         iPrevLockTimeUSec = iLockTimeUSec;
  656.         InterlockedIncrement(&g_nNumberOfInitialVerify);
  657.     }
  658.     delete[] pchContextData;
  659.     return iRes;
  660. }
  666. void* RuntimeCallContext(void* lpParam)
  667. {
  668.     long nNumCallsProcessed = 0;
  669.     int nStartingRecordID = *(int*)lpParam;
  670.     
  671.     Ndb* pNdb;
  672.     char* pchContextData = new char[g_nStatusDataSize];
  673.     char szMsg[100];
  674.     
  675.     int iRes;
  676.     const char* szOp;
  677.     long iVersion;
  678.     long iLockFlag;
  679.     long iLockTime;
  680.     long iLockTimeUSec;
  681.     
  682.     pNdb = new Ndb("TEST_DB");
  683.     if(!pNdb)
  684.     {
  685.         NdbMutex_Lock(g_pNdbMutexPrintf);
  686.         printf("new Ndb failedn");
  687.         NdbMutex_Unlock(g_pNdbMutexPrintf);
  688.         delete[] pchContextData;
  689.         return 0;
  690.     }
  691.     
  692.     if(pNdb->init(1) || pNdb->waitUntilReady())
  693.     {
  694.         ReportNdbError("init of Ndb failed", pNdb->getNdbError());
  695.         delete pNdb;
  696.         delete[] pchContextData;
  697.         return 0;
  698.     }
  700.     if(g_bInsertInitial)
  701.     {
  702.         if(InsertInitialRecords(pNdb, g_nMaxContextIdPerThread, -nStartingRecordID-g_nMaxContextIdPerThread))
  703.         {
  704.             delete pNdb;
  705.             delete[] pchContextData;
  706.             return 0;
  707.         }
  708.     }
  710.     if(g_bVerifyInitial)
  711.     {
  712.         NdbError err;
  713.         memset(&err, 0, sizeof(err));
  714.         if(VerifyInitialRecords(pNdb, g_nMaxContextIdPerThread, -nStartingRecordID-g_nMaxContextIdPerThread))
  715.         {
  716.             delete pNdb;
  717.             delete[] pchContextData;
  718.             return 0;
  719.         }
  720.     }
  721.     if(g_bInsertInitial || g_bVerifyInitial)
  722.     {
  723.         delete[] pchContextData;
  724.         return 0;
  725.     }
  727.     long nContextID = nStartingRecordID;
  728. #ifdef NDB_WIN32
  729.     while(WaitForSingleObject(hShutdownEvent,0) != WAIT_OBJECT_0)
  730. #else
  731.     while(!bShutdownEvent)
  732. #endif
  733.     {
  734.         ++nContextID;
  735.         nContextID %= g_nMaxContextIdPerThread;
  736.         nContextID += nStartingRecordID;
  738.         bool bTimeLatency = (nContextID==100);
  739.         
  740.         NDB_TICKS tStartCall = NdbTick_CurrentMillisecond();
  741.         for (int i=0; i < 20; i++)
  742.         {
  743.             int nRetry = 0;
  744.             NdbError err;
  745.             memset(&err, 0, sizeof(err));
  746.             NDB_TICKS tStartTrans = NdbTick_CurrentMillisecond();
  747.             switch(i)
  748.             {
  749.             case 3:
  750.             case 6:
  751.             case 9: 
  752.             case 11: 
  753.             case 12: 
  754.             case 15: 
  755.             case 18:   // Query Record
  756.                 szOp = "Read";
  757.                 iRes = RetryQueryTransaction(pNdb, nContextID, &iVersion, &iLockFlag, 
  758.                     &iLockTime, &iLockTimeUSec, pchContextData, err, nRetry);
  759.                 break;
  760.                 
  761.             case 19:    // Delete Record
  762.                 szOp = "Delete";
  763.                 iRes = RetryDeleteTransaction(pNdb, nContextID, err, nRetry);
  764.                 break;
  765.                 
  766.             case 0: // Insert Record
  767.                 szOp = "Insert";
  768.                 iRes = RetryInsertTransaction(pNdb, nContextID, 1, 1, 1, 1, STATUS_DATA, err, nRetry);
  769.                 break;
  770.                 
  771.             default:    // Update Record
  772.                 szOp = "Update";
  773.                 iRes = RetryUpdateTransaction(pNdb, nContextID, err, nRetry);
  774.                 break;
  775.             }
  776.             NDB_TICKS tEndTrans = NdbTick_CurrentMillisecond();
  777.             long lMillisecForThisTrans = (long)(tEndTrans-tStartTrans);
  779.             if(g_bReport)
  780.             {
  781.               assert(lMillisecForThisTrans>=0 && lMillisecForThisTrans<c_nMaxMillisecForAllTrans);
  782.               InterlockedIncrement(g_plCountMillisecForTrans+lMillisecForThisTrans);
  783.             }
  785.             if(nRetry>0)
  786.             {
  787.                 sprintf(szMsg, "%s retried %d times, time %ld msec.", 
  788.                     szOp, nRetry, lMillisecForThisTrans);
  789.                 ReportNdbError(szMsg, err);
  790.             }
  791.             else if(bTimeLatency)
  792.             {
  793.                 NdbMutex_Lock(g_pNdbMutexPrintf);
  794.                 printf("%s = %ld msec.n", szOp, lMillisecForThisTrans);
  795.                 NdbMutex_Unlock(g_pNdbMutexPrintf);
  796.             }
  798.             if(iRes)
  799.             {
  800.                 sprintf(szMsg, "%s failed after %ld calls, terminating thread", 
  801.                     szOp, nNumCallsProcessed);
  802.                 ReportNdbError(szMsg, err);
  803.                 delete pNdb;
  804.                 delete[] pchContextData;
  805.                 return 0;
  806.             }
  807.         }
  808.         NDB_TICKS tEndCall = NdbTick_CurrentMillisecond();
  809.         long lMillisecForThisCall = (long)(tEndCall-tStartCall);
  811.         if(g_bReport)
  812.         {
  813.           assert(lMillisecForThisCall>=0 && lMillisecForThisCall<c_nMaxMillisecForAllCall);
  814.           InterlockedIncrement(g_plCountMillisecForCall+lMillisecForThisCall);
  815.         }
  817.         if(bTimeLatency)
  818.         {
  819.             NdbMutex_Lock(g_pNdbMutexPrintf);
  820.             printf("Total time for call is %ld msec.n", (long)lMillisecForThisCall);
  821.             NdbMutex_Unlock(g_pNdbMutexPrintf);
  822.         }
  823.         
  824.         nNumCallsProcessed++;
  825.         InterlockedIncrementAndReport();
  826.         if(g_nMaxCallsPerSecond>0)
  827.         {
  828.             int iMillisecToSleep = (1000*g_nNumThreads)/g_nMaxCallsPerSecond;
  829.             iMillisecToSleep -= lMillisecForThisCall;
  830.             if(iMillisecToSleep>0)
  831.             {
  832.                 NdbSleep_MilliSleep(iMillisecToSleep);
  833.             }
  834.         }
  835.     }
  837.     NdbMutex_Lock(g_pNdbMutexPrintf);
  838.     printf("Terminating thread after %ld callsn", nNumCallsProcessed);
  839.     NdbMutex_Unlock(g_pNdbMutexPrintf);
  840.     
  841.     delete pNdb;
  842.     delete[] pchContextData;
  843.     return 0;
  844. }
  847. int CreateCallContextTable(Ndb* pNdb, const char* szTableName, bool bStored)
  848. {
  849.     int iRes = -1;
  850.     NdbError err;
  851.     memset(&err, 0, sizeof(err));
  853.     NdbSchemaCon* pNdbSchemaCon = NdbSchemaCon::startSchemaTrans(pNdb);
  854.     if(pNdbSchemaCon)
  855.     {
  856.         NdbSchemaOp* pNdbSchemaOp = pNdbSchemaCon->getNdbSchemaOp();
  857.         if(pNdbSchemaOp)
  858.         {
  859.             if(!pNdbSchemaOp->createTable(szTableName, 8, TupleKey, 2, 
  860.                 All, 6, 78, 80, 1, bStored)
  861.                 && !pNdbSchemaOp->createAttribute(c_szContextId, TupleKey, 32, 1, Signed)
  862.                 && !pNdbSchemaOp->createAttribute(c_szVersion, NoKey, 32, 1, Signed)
  863.                 && !pNdbSchemaOp->createAttribute(c_szLockFlag, NoKey, 32, 1, Signed)
  864.                 && !pNdbSchemaOp->createAttribute(c_szLockTime, NoKey, 32, 1, Signed)
  865.                 && !pNdbSchemaOp->createAttribute(c_szLockTimeUSec, NoKey, 32, 1, Signed)
  866.                 && !pNdbSchemaOp->createAttribute(c_szContextData, NoKey, 8, g_nStatusDataSize, String)) 
  867.             {
  868.                 if(!pNdbSchemaCon->execute()) 
  869.                     iRes = 0;
  870.                 else 
  871.                     err = pNdbSchemaCon->getNdbError();
  872.             } 
  873.             else 
  874.                 err = pNdbSchemaOp->getNdbError();
  875.         } 
  876.         else 
  877.             err = pNdbSchemaCon->getNdbError();
  879.         NdbSchemaCon::closeSchemaTrans(pNdbSchemaCon);
  880.     }
  881.     else 
  882.         err = pNdb->getNdbError();
  884.     if(iRes)
  885.     {
  886.         ReportNdbError("create call context table failed", err);
  887.     }
  888.     return iRes;
  889. }
  893. void ReportResponseTimeStatistics(const char* szStat, long* plCount, const long lSize)
  894. {
  895.   long lCount = 0;
  896.   Int64 llSum = 0;
  897.   Int64 llSum2 = 0;
  898.   long lMin = -1;
  899.   long lMax = -1;
  901.   for(long l=0; l<lSize; ++l)
  902.   {
  903.     if(plCount[l]>0)
  904.     {
  905.       lCount += plCount[l];
  906.       llSum += (Int64)l*(Int64)plCount[l];
  907.       llSum2 += (Int64)l*(Int64)l*(Int64)plCount[l];
  908.       if(lMin==-1 || l<lMin)
  909.       {
  910.         lMin = l;
  911.       }
  912.       if(lMax==-1 || l>lMax)
  913.       {
  914.         lMax = l;
  915.       }
  916.     }
  917.   }
  919.   long lAvg = long(llSum/lCount);
  920.   double dblVar = ((double)lCount*(double)llSum2 - (double)llSum*(double)llSum)/((double)lCount*(double)(lCount-1));
  921.   long lStd = long(sqrt(dblVar));
  923.   long lMed = -1;
  924.   long l95 = -1;
  925.   long lSel = -1;
  926.   for(long l=lMin; l<=lMax; ++l)
  927.   {
  928.     if(plCount[l]>0)
  929.     {
  930.       lSel += plCount[l];
  931.       if(lMed==-1 && lSel>=(lCount/2))
  932.       {
  933.         lMed = l;
  934.       }
  935.       if(l95==-1 && lSel>=((lCount*95)/100))
  936.       {
  937.         l95 = l;
  938.       }
  939.       if(g_bReportPlus)
  940.       {
  941.         printf("%ldt%ldn", l, plCount[l]);
  942.       }
  943.     }
  944.   }
  946.   printf("%s: Count=%ld, Min=%ld, Max=%ld, Avg=%ld, Std=%ld, Med=%ld, 95%%=%ldn",
  947.     szStat, lCount, lMin, lMax, lAvg, lStd, lMed, l95);
  948. }
  952. void ShowHelp(const char* szCmd)
  953. {
  954.     printf("%s -t<threads> [-s<seed>] [-b<batch>] [-c<maxcps>] [-m<size>] [-d] [-i] [-v] [-f] [-w] [-r[+]]n", szCmd);
  955.     printf("%s -?n", szCmd);
  956.     puts("-dttcreate the table");
  957.     puts("-ittinsert initial records");
  958.     puts("-vttverify initial records");
  959.     puts("-t<threads>tnumber of threads making calls");
  960.     puts("-s<seed>toffset for primary key");
  961.     puts("-b<batch>tbatch size per thread");
  962.     puts("-c<maxcps>tmax number of calls per second for this process");
  963.     puts("-m<size>tsize of context data");
  964.     puts("-fttno checkpointing and no logging");
  965.     puts("-wttuse writeTuple instead of insertTuple");
  966.     puts("-rttreport response time statistics");
  967.     puts("-r+ttreport response time distribution");
  968.     puts("-?tthelp");
  969. }
  972. int main(int argc, char* argv[])
  973. {
  974.     ndb_init();
  975.     int iRes = -1;
  976.     g_nNumThreads = 0;
  977.     g_nMaxCallsPerSecond = 0;
  978.     long nSeed = 0;
  979.     bool bStoredTable = true;
  980.     bool bCreateTable = false;
  981.     g_bWriteTuple = false;
  982.     g_bReport = false;
  983.     g_bReportPlus = false;
  984.     
  985.     for(int i=1; i<argc; ++i)
  986.     {
  987.         if(argv[i][0]=='-' || argv[i][0]=='/')
  988.         {
  989.             switch(argv[i][1])
  990.             {
  991.             case 't': 
  992.                 g_nNumThreads = atol(argv[i]+2); 
  993.                 break;
  994.             case 's': 
  995.                 nSeed = atol(argv[i]+2); 
  996.                 break;
  997.             case 'b': 
  998.                 g_nMaxContextIdPerThread = atol(argv[i]+2); 
  999.                 break;
  1000.             case 'm': 
  1001.                 g_nStatusDataSize = atol(argv[i]+2); 
  1002.                 if(g_nStatusDataSize>sizeof(STATUS_DATA))
  1003.                 {
  1004.                     g_nStatusDataSize = sizeof(STATUS_DATA);
  1005.                 }
  1006.                 break;
  1007.             case 'i': 
  1008.                 g_bInsertInitial = true;
  1009.                 break;
  1010.             case 'v': 
  1011.                 g_bVerifyInitial = true;
  1012.                 break;
  1013.             case 'd':
  1014.                 bCreateTable = true;
  1015.                 break;
  1016.             case 'f': 
  1017.                 bStoredTable = false;
  1018.                 break;
  1019.             case 'w': 
  1020.                 g_bWriteTuple = true;
  1021.                 break;
  1022.             case 'r': 
  1023.                 g_bReport = true;
  1024.                 if(argv[i][2]=='+')
  1025.                 {
  1026.                   g_bReportPlus = true;
  1027.                 }
  1028.                 break;
  1029.             case 'c':
  1030.                 g_nMaxCallsPerSecond = atol(argv[i]+2);
  1031.                 break;
  1032.             case '?':
  1033.             default:
  1034.                 ShowHelp(argv[0]);
  1035.                 return -1;
  1036.             }
  1037.         }
  1038.         else
  1039.         {
  1040.             ShowHelp(argv[0]);
  1041.             return -1;
  1042.         }
  1043.     }
  1044.     if(bCreateTable)
  1045.         puts("-dtcreate the table");
  1046.     if(g_bInsertInitial)
  1047.         printf("-itinsert initial recordsn");
  1048.     if(g_bVerifyInitial)
  1049.         printf("-vtverify initial recordsn");
  1050.     if(g_nNumThreads>0)
  1051.         printf("-t%ldtnumber of threads making callsn", g_nNumThreads);
  1052.     if(g_nNumThreads>0)
  1053.     {
  1054.         printf("-s%ldtoffset for primary keyn", nSeed);
  1055.         printf("-b%ldtbatch size per threadn", g_nMaxContextIdPerThread);
  1056.     }
  1057.     if(g_nMaxCallsPerSecond>0)
  1058.         printf("-c%ldtmax number of calls per second for this processn", g_nMaxCallsPerSecond);
  1059.     if(!bStoredTable)
  1060.         puts("-ftno checkpointing and no logging to disk");
  1061.     if(g_bWriteTuple)
  1062.         puts("-wtuse writeTuple instead of insertTuple");
  1063.     if(g_bReport)
  1064.         puts("-rtreport response time statistics");
  1065.     if(g_bReportPlus)
  1066.         puts("-r+treport response time distribution");
  1068.     if(!bCreateTable && g_nNumThreads<=0)
  1069.     {
  1070.         ShowHelp(argv[0]);
  1071.         return -1;
  1072.     }
  1073.     printf("-m%ldtsize of context datan", g_nStatusDataSize);
  1075.     g_szTableName = (bStoredTable ? c_szTableNameStored : c_szTableNameTemp);
  1076.     
  1077. #ifdef NDB_WIN32
  1078.     SetConsoleCtrlHandler(ConsoleCtrlHandler, true); 
  1079. #else
  1080.     signal(SIGINT, CtrlCHandler);
  1081. #endif
  1083.     if(g_bReport)
  1084.     {
  1085.       g_plCountMillisecForCall = new long[c_nMaxMillisecForAllCall];
  1086.       memset(g_plCountMillisecForCall, 0, c_nMaxMillisecForAllCall*sizeof(long));
  1087.       g_plCountMillisecForTrans = new long[c_nMaxMillisecForAllTrans];
  1088.       memset(g_plCountMillisecForTrans, 0, c_nMaxMillisecForAllTrans*sizeof(long));
  1089.     }
  1090.     
  1091.     g_pNdbMutexIncrement = NdbMutex_Create();
  1092.     g_pNdbMutexPrintf = NdbMutex_Create();
  1093. #ifdef NDB_WIN32
  1094.     hShutdownEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  1095. #endif
  1096.     
  1097.     Ndb* pNdb = new Ndb(c_szDatabaseName);
  1098.     if(!pNdb)
  1099.     {
  1100.         printf("could not construct ndbn");
  1101.         return 1;
  1102.     }
  1103.     
  1104.     if(pNdb->init(1) || pNdb->waitUntilReady())
  1105.     {
  1106.         ReportNdbError("could not initialize ndbn", pNdb->getNdbError());
  1107.         delete pNdb;
  1108.         return 2;
  1109.     }
  1111.     if(bCreateTable)
  1112.     {
  1113.         printf("Create CallContext tablen");
  1114. if (bStoredTable)
  1115. {
  1116.   if (CreateCallContextTable(pNdb, c_szTableNameStored, true))
  1117.   {
  1118.             printf("Create table failedn");
  1119.             delete pNdb;
  1120.             return 3;     
  1121.   }
  1122. }
  1123. else
  1124. {
  1125.   if (CreateCallContextTable(pNdb, c_szTableNameTemp, false))
  1126.   {
  1127.             printf("Create table failedn");
  1128.             delete pNdb;
  1129.             return 3;
  1130.   }
  1131. }
  1132.     }
  1133.     
  1134.     if(g_nNumThreads>0) 
  1135.     {
  1136.         printf("creating %d threadsn", (int)g_nNumThreads);
  1137.         if(g_bInsertInitial)
  1138.         {
  1139.             printf("each thread will insert %ld initial records, total %ld insertsn", 
  1140.                 g_nMaxContextIdPerThread, g_nNumThreads*g_nMaxContextIdPerThread);
  1141.         }
  1142.         if(g_bVerifyInitial)
  1143.         {
  1144.             printf("each thread will verify %ld initial records, total %ld readsn", 
  1145.                 g_nMaxContextIdPerThread, g_nNumThreads*g_nMaxContextIdPerThread);
  1146.         }
  1148.         g_nNumberOfInitialInsert = 0;
  1149.         g_nNumberOfInitialVerify = 0;
  1151.         NDB_TICKS tStartTime = NdbTick_CurrentMillisecond();
  1152.         NdbThread* pThreads[256];
  1153.         int pnStartingRecordNum[256];
  1154.         int ij;
  1155.         for(ij=0;ij<g_nNumThreads;ij++) 
  1156.         {
  1157.             pnStartingRecordNum[ij] = (ij*g_nMaxContextIdPerThread) + nSeed;
  1158.         }
  1159.         
  1160.         for(ij=0;ij<g_nNumThreads;ij++) 
  1161.         {
  1162.             pThreads[ij] = NdbThread_Create(RuntimeCallContext, 
  1163.                 (void**)(pnStartingRecordNum+ij), 
  1164.                 0, "RuntimeCallContext", NDB_THREAD_PRIO_LOW);
  1165.         }
  1166.         
  1167.         //Wait for the threads to finish
  1168.         for(ij=0;ij<g_nNumThreads;ij++) 
  1169.         {
  1170.             void* status;
  1171.             NdbThread_WaitFor(pThreads[ij], &status);
  1172.         }
  1173.         NDB_TICKS tEndTime = NdbTick_CurrentMillisecond();
  1174.         
  1175.         //Print time taken
  1176.         printf("Time Taken for %ld Calls is %ld msec (= %ld calls/sec)n",
  1177.             g_nNumCallsProcessed, 
  1178.             (long)(tEndTime-tStartTime), 
  1179.             (long)((1000*g_nNumCallsProcessed)/(tEndTime-tStartTime)));
  1181.         if(g_bInsertInitial)
  1182.             printf("successfully inserted %ld tuplesn", g_nNumberOfInitialInsert);
  1183.         if(g_bVerifyInitial)
  1184.             printf("successfully verified %ld tuplesn", g_nNumberOfInitialVerify);
  1185.     }
  1186.     
  1187.     delete pNdb;
  1189. #ifdef NDB_WIN32
  1190.     CloseHandle(hShutdownEvent);
  1191. #endif
  1192.     NdbMutex_Destroy(g_pNdbMutexIncrement);
  1193.     NdbMutex_Destroy(g_pNdbMutexPrintf);
  1195.     if(g_bReport)
  1196.     {
  1197.       ReportResponseTimeStatistics("Calls", g_plCountMillisecForCall, c_nMaxMillisecForAllCall);
  1198.       ReportResponseTimeStatistics("Transactions", g_plCountMillisecForTrans, c_nMaxMillisecForAllTrans);
  1200.       delete[] g_plCountMillisecForCall;
  1201.       delete[] g_plCountMillisecForTrans;
  1202.     }
  1204.     return 0;
  1205. }