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

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

MySQL数据库

开发平台：

Visual C++

InsertRecs.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. // InsertRecs.cpp : Defines the entry point for the console application.
  18. //
  21. #include <NdbApi.hpp>
  22. #include <windows.h>
  23. #include <tchar.h>
  26. // data for CALL_CONTEXT and GROUP_RESOURCE
  27. static TCHAR STATUS_DATA[]=_T("000102030405060708090A0B0C0D0E0F000102030405060708090A0B0C0D0E0F")
  28.    _T("101112131415161718191A1B1C1D1E1F000102030405060708090A0B0C0D0E0F")
  29.    _T("202122232425262728292A2B2C2D2E2F000102030405060708090A0B0C0D0E0F")
  30.    _T("303132333435363738393A3B3C3D3E3F000102030405060708090A0B0C0D0E0F")
  31.    _T("404142434445464748494A4B4C4D4E4F000102030405060708090A0B0C0D0E0F")
  32.    _T("505152535455565758595A5B5C5D5E5F000102030405060708090A0B0C0D0E0F")
  33.    _T("606162636465666768696A6B6C6D6E6F000102030405060708090A0B0C0D0E0F")
  34.    _T("707172737475767778797A7B7C7D7E7F000102030405060708090A0B0C0D0E0F")
  35.    _T("808182838485868788898A8B8C8D8E8F000102030405060708090A0B0C0D0E0F")
  36.    _T("909192939495969798999A9B9C9D9E9F000102030405060708090A0B0C0D0E0F")
  37.    _T("10010110210310410510610710810910A000102030405060708090A0B0C0D0EF")
  38.    _T("10B10C10D10E10F110111112113114115000102030405060708090A0B0C0D0EF")
  39.    _T("11611711811911A11B11C11D11E11F120000102030405060708090A0B0C0D0EF")
  40.    _T("12112212312412512612712812912A12B000102030405060708090A0B0C0D0EF")
  41.    _T("12C12D12E12F130131132134135136137000102030405060708090A0B0C0D0EF")
  42.    _T("13813913A13B13C13D13E13F140141142000102030405060708090A0B0C0D0EF")
  43.    _T("14314414514614714814914A14B14C14D000102030405060708090A0B0C0D0EF")
  44.    _T("14E14F150151152153154155156157158000102030405060708090A0B0C0D0EF")
  45.    _T("15915A15B15C15D15E15F160161162163000102030405060708090A0B0C0D0EF")
  46.    _T("16416516616716816916A16B16C16D16E000102030405060708090A0B0C0D0EF")
  47.    _T("16F170171172173174175176177178179000102030405060708090A0B0C0D0EF")
  48.    _T("17A17B17C17D17E17F180181182183184000102030405060708090A0B0C0D0EF")
  49.    _T("18518618718818918A18B18C18D18E18F000102030405060708090A0B0C0D0EF")
  50.    _T("19019119219319419519619719819919A000102030405060708090A0B0C0D0EF")
  51.    _T("19B19C19D19E19F200201202203204205000102030405060708090A0B0C0D0EF")
  52.    _T("20620720820920A20B20C20D20F210211000102030405060708090A0B0C0D0EF")
  53.    _T("21221321421521621721821921A21B21C000102030405060708090A0B0C0D0EF")
  54.    _T("21D21E21F220221222223224225226227000102030405060708090A0B0C0D0EF")
  55.    _T("22822922A22B22C22D22E22F230231232000102030405060708090A0B0C0D0EF")
  56.    _T("23323423523623723823923A23B23C23D000102030405060708090A0B0C0D0EF")
  57.    _T("23E23F240241242243244245246247248000102030405060708090A0B0C0D0EF")
  58.    _T("24924A24B24C24D24E24F250251252253000102030405060708090A0B0C0D0EF")
  59.    _T("101112131415161718191A1B1C1D1E1F000102030405060708090A0B0C0D0E0F")
  60.    _T("202122232425262728292A2B2C2D2E2F000102030405060708090A0B0C0D0E0F")
  61.    _T("303132333435363738393A3B3C3D3E3F000102030405060708090A0B0C0D0E0F")
  62.    _T("404142434445464748494A4B4C4D4E4F000102030405060708090A0B0C0D0E0F")
  63.    _T("505152535455565758595A5B5C5D5E5F000102030405060708090A0B0C0D0E0F")
  64.    _T("606162636465666768696A6B6C6D6E6F000102030405060708090A0B0C0D0E0F")
  65.    _T("707172737475767778797A7B7C7D7E7F000102030405060708090A0B0C0D0E0F")
  66.    _T("808182838485868788898A8B8C8D8E8F000102030405060708090A0B0C0D0E0F")
  67.    _T("909192939495969798999A9B9C9D9E9F000102030405060708090A0B0C0D0E0F")
  68.    _T("10010110210310410510610710810910A000102030405060708090A0B0C0D0EF")
  69.    _T("10B10C10D10E10F110111112113114115000102030405060708090A0B0C0D0EF")
  70.    _T("11611711811911A11B11C11D11E11F120000102030405060708090A0B0C0D0EF")
  71.    _T("12112212312412512612712812912A12B000102030405060708090A0B0C0D0EF")
  72.    _T("12C12D12E12F130131132134135136137000102030405060708090A0B0C0D0EF")
  73.    _T("13813913A13B13C13D13E13F140141142000102030405060708090A0B0C0D0EF")
  74.    _T("14314414514614714814914A14B14C14D000102030405060708090A0B0C0D0EF")
  75.    _T("14E14F150151152153154155156157158000102030405060708090A0B0C0D0EF")
  76.    _T("15915A15B15C15D15E15F160161162163000102030405060708090A0B0C0D0EF")
  77.    _T("16416516616716816916A16B16C16D16E000102030405060708090A0B0C0D0EF")
  78.    _T("16F170171172173174175176177178179000102030405060708090A0B0C0D0EF")
  79.    _T("17A17B17C17D17E17F180181182183184000102030405060708090A0B0C0D0EF")
  80.    _T("18518618718818918A18B18C18D18E18F000102030405060708090A0B0C0D0EF")
  81.    _T("19019119219319419519619719819919A000102030405060708090A0B0C0D0EF")
  82.    _T("19B19C19D19E19F200201202203204205000102030405060708090A0B0C0D0EF")
  83.    _T("20620720820920A20B20C20D20F210211000102030405060708090A0B0C0D0EF")
  84.    _T("21221321421521621721821921A21B21C000102030405060708090A0B0C0D0EF")
  85.    _T("21D21E21F220221222223224225226227000102030405060708090A0B0C0D0EF")
  86.    _T("22822922A22B22C22D22E22F230231232000102030405060708090A0B0C0D0EF")
  87.    _T("23323423523623723823923A23B23C23D000102030405060708090A0B0C0D0EF")
  88.    _T("2366890FE1438751097E7F6325DC0E6326F")
  89.    _T("25425525625725825925A25B25C25D25E25F000102030405060708090A0B0C0F");
  90. // Thread function for Call Context Inserts
  92. struct _ParamStruct
  93. {
  94. HANDLE hShutdownEvent;
  95. int nStartingRecordNum;
  96. long* pnNumCallsProcessed;
  97. };
  99. HANDLE hShutdownEvent = 0;
  101. BOOL WINAPI ConsoleCtrlHandler(DWORD dwCtrlType)
  102. {
  103. if(CTRL_C_EVENT == dwCtrlType)
  104. {
  105. SetEvent(hShutdownEvent);
  106. return TRUE;
  107. }
  108. return FALSE;
  109. }
  114. DWORD WINAPI RuntimeCallContext(LPVOID lpParam)
  115. {
  116.     long nNumCallsProcessed = 0;
  118. struct _ParamStruct* pData = (struct _ParamStruct*)lpParam;
  119.     int nStartingRecordID = pData->nStartingRecordNum;
  121.     Ndb* pNdb;
  122.     NdbConnection* pNdbConnection;
  123.     NdbOperation* pNdbOperation;
  124.     NdbRecAttr* pNdbRecAttrContextData;
  126.     char pchContextData[4008];
  128. LARGE_INTEGER freq;
  129. LARGE_INTEGER liStartTime, liEndTime;
  131.     pNdb = new Ndb("TEST_DB");
  132.     if(!pNdb)
  133.     {
  134.         printf("new Ndb failedn");
  135.         return 0;
  136.     }
  138.     try
  139.     {
  140.         if(pNdb->init(1)
  141.             || pNdb->waitUntilReady())
  142.         {
  143.             throw pNdb;
  144.         }
  146.         while(WaitForSingleObject(pData->hShutdownEvent,0) != WAIT_OBJECT_0)
  147.         {
  148.             nStartingRecordID++;
  150. bool bTimeLatency = (nStartingRecordID == 100) ? TRUE : FALSE;
  152. if (bTimeLatency)
  153. {
  154. BOOL bSuccess = QueryPerformanceFrequency(&freq);
  155. if (!bSuccess)
  156. printf("Error retrieving frequency: %dn", GetLastError());
  158. }
  160.             for (int i=0; i < 20; i++)
  161.             {
  162.                 switch(i)
  163.                 {
  164.                     case 3:
  165.                     case 6:
  166.                     case 9: 
  167.                     case 11: 
  168.                     case 12: 
  169.                     case 15: 
  170.                     case 18:   // Query Record
  171. if (bTimeLatency)
  172.    QueryPerformanceCounter(&liStartTime);
  174.                         pNdbConnection = pNdb->startTransaction((Uint32)0, (const char*)&nStartingRecordID, (Uint32)4);
  175.                         if(!pNdbConnection)
  176.                         {
  177.                             throw pNdb;
  178.                         }
  179.                         pNdbOperation = pNdbConnection->getNdbOperation(_T("CallContext"));
  180.                         if(!pNdbOperation)
  181.                         {
  182.                             throw pNdbConnection;
  183.                         }
  184.                         if(pNdbOperation->readTuple()
  185.                             || pNdbOperation->equal(_T("ContextId"), nStartingRecordID))
  186.                         {
  187.                             throw pNdbOperation;
  188.                         }
  189.                         pNdbRecAttrContextData = pNdbOperation->getValue(_T("ContextData"), pchContextData);
  190.                         if(!pNdbRecAttrContextData)
  191.                         {
  192.                             throw pNdbOperation;
  193.                         }
  194.                         if(pNdbConnection->execute(Commit))
  195.                         {
  196.                             throw pNdbConnection;
  197.                         }
  198.                         pNdb->closeTransaction(pNdbConnection);
  200. if (bTimeLatency)
  201. {
  202. QueryPerformanceCounter(&liEndTime);
  203. printf("Read = %d msec.n", (liEndTime.QuadPart - liStartTime.QuadPart) / (freq.QuadPart/1000));
  204. }
  205.                         break;
  207.                     case 19:    // Delete Record
  208.                         if (bTimeLatency)
  209.                             QueryPerformanceCounter(&liStartTime);
  210.                         
  211.                         pNdbConnection = pNdb->startTransaction((Uint32)0, (const char*)&nStartingRecordID, (Uint32)4);
  212.                         if(!pNdbConnection)
  213.                         {
  214.                             throw pNdb;
  215.                         }
  216.                         pNdbOperation = pNdbConnection->getNdbOperation(_T("CallContext"));
  217.                         if(!pNdbOperation)
  218.                         {
  219.                             throw pNdbConnection;
  220.                         }
  221.                         if(pNdbOperation->deleteTuple()
  222.                             || pNdbOperation->equal(_T("ContextId"), nStartingRecordID))
  223.                         {
  224.                             throw pNdbOperation;
  225.                         }
  226.                         if(pNdbConnection->execute(Commit))
  227.                         {
  228.                             throw pNdbConnection;
  229.                         }
  230.                         pNdb->closeTransaction(pNdbConnection);
  231.                         
  232. if (bTimeLatency)
  233. {
  234. QueryPerformanceCounter(&liEndTime);
  235. printf("Delete = %d msec.n", (liEndTime.QuadPart - liStartTime.QuadPart) / (freq.QuadPart/1000));
  236. }
  237.                         break;
  239.                     case 0: // Insert Record
  240. if (bTimeLatency)
  241.    QueryPerformanceCounter(&liStartTime);
  243.                         pNdbConnection = pNdb->startTransaction((Uint32)0, (const char*)&nStartingRecordID, (Uint32)4);
  244.                         if(!pNdbConnection)
  245.                         {
  246.                             throw pNdb;
  247.                         }
  248.                         pNdbOperation = pNdbConnection->getNdbOperation(_T("CallContext"));
  249.                         if(!pNdbOperation)
  250.                         {
  251.                             throw pNdbConnection;
  252.                         }
  253.                         if(pNdbOperation->insertTuple()
  254.                             || pNdbOperation->equal(_T("ContextId"), nStartingRecordID)
  255.                         || pNdbOperation->setValue(_T("Version"), Int32(1))
  256.                         || pNdbOperation->setValue(_T("LockFlag"), Int32(1))
  257.                         || pNdbOperation->setValue(_T("LockTime"), Int32(1))
  258.                         || pNdbOperation->setValue(_T("LockTimeUSec"), Int32(1))
  259.                         || pNdbOperation->setValue(_T("ContextData"), STATUS_DATA, sizeof(STATUS_DATA)))
  260.                         {
  261.                             throw pNdbOperation;
  262.                         }
  263.                         if(pNdbConnection->execute(Commit))
  264.                         {
  265.                             throw pNdbConnection;
  266.                         }
  267.                         pNdb->closeTransaction(pNdbConnection);
  268.                         
  269. if (bTimeLatency)
  270. {
  271. QueryPerformanceCounter(&liEndTime);
  272. printf("Insert = %d msec.n", (liEndTime.QuadPart - liStartTime.QuadPart) / (freq.QuadPart/1000));
  273. }
  274.                         break;
  276.                     default:    // Update Record
  277. if (bTimeLatency)
  278.    QueryPerformanceCounter(&liStartTime);
  280.                         pNdbConnection = pNdb->startTransaction((Uint32)0, (const char*)&nStartingRecordID, (Uint32)4);
  281.                         if(!pNdbConnection)
  282.                         {
  283.                             throw pNdb;
  284.                         }
  285.                         pNdbOperation = pNdbConnection->getNdbOperation(_T("CallContext"));
  286.                         if(!pNdbOperation)
  287.                         {
  288.                             throw pNdbConnection;
  289.                         }
  290.                         if(pNdbOperation->updateTuple())
  291.                         {
  292.                             throw pNdbOperation;
  293.                         }
  294.                         if(pNdbOperation->equal(_T("ContextId"), nStartingRecordID)
  295.                             || pNdbOperation->setValue(_T("ContextData"), STATUS_DATA, sizeof(STATUS_DATA)))
  296.                         {
  297.                             throw pNdbOperation;
  298.                         }
  299.                         if(pNdbConnection->execute(Commit))
  300.                         {
  301.                             throw pNdbConnection;
  302.                         }
  303.                         pNdb->closeTransaction(pNdbConnection);
  305. if (bTimeLatency)
  306. {
  307. QueryPerformanceCounter(&liEndTime);
  308. printf("Update = %d msec.n", (liEndTime.QuadPart - liStartTime.QuadPart) / (freq.QuadPart/1000));
  309. }
  310.                         
  311. break;
  312.                 }
  313.             }
  315. nNumCallsProcessed++;
  317.             InterlockedIncrement(pData->pnNumCallsProcessed);
  318.         }
  320.         delete pNdb;
  321.     }
  322.     catch(Ndb* pNdb)
  323.     {
  324.         printf("%d: nt%snt%sn",
  325.             pNdb->getNdbError(), 
  326.             pNdb->getNdbErrorString(), 
  327.             "Ndb");
  328.         delete pNdb;
  329.     }
  330.     catch(NdbConnection* pNdbConnection)
  331.     {
  332.         printf("%d: nt%snt%sn",
  333.             pNdbConnection->getNdbError(), 
  334.             pNdbConnection->getNdbErrorString(), 
  335.             "NdbConnection");
  336.         pNdb->closeTransaction(pNdbConnection);
  337.         delete pNdb;
  338.     }
  339.     catch(NdbOperation* pNdbOperation)
  340.     {
  341.         printf("%d: nt%snt%sn",
  342.             pNdbOperation->getNdbError(), 
  343.             pNdbOperation->getNdbErrorString(), 
  344.             "NdbOperation");
  345.         pNdb->closeTransaction(pNdbConnection);
  346.         delete pNdb;
  347.     }
  349.     return 0;
  350. }
  353. void Initialize(Ndb* pNdb, long nInsert, bool bStoredTable)
  354. {
  355.     NdbSchemaCon* pNdbSchemaCon;
  356.     NdbSchemaOp* pNdbSchemaOp;
  357.     NdbConnection* pNdbConnection;
  358.     NdbOperation* pNdbOperation;
  360.     try
  361.     {
  362.         _tprintf(_T("Create CallContext tablen"));
  364.         pNdbSchemaCon = pNdb->startSchemaTransaction();
  365.         if(!pNdbSchemaCon)
  366.         {
  367.             throw pNdb;
  368.         }
  369.         pNdbSchemaOp = pNdbSchemaCon->getNdbSchemaOp();
  370.         if(!pNdbSchemaOp)
  371.         {
  372.             throw pNdbSchemaCon;
  373.         }
  374.         if(pNdbSchemaOp->createTable(_T("CallContext"), 8, TupleKey, 2, All, 6, 78, 80, 1, bStoredTable)
  375.             || pNdbSchemaOp->createAttribute(_T("ContextId"), TupleKey, 32, 1, Signed)
  376.             || pNdbSchemaOp->createAttribute(_T("Version"), NoKey, 32, 1, Signed)
  377.             || pNdbSchemaOp->createAttribute(_T("LockFlag"), NoKey, 32, 1, Signed)
  378.             || pNdbSchemaOp->createAttribute(_T("LockTime"), NoKey, 32, 1, Signed)
  379.             || pNdbSchemaOp->createAttribute(_T("LockTimeUSec"), NoKey, 32, 1, Signed)
  380.             || pNdbSchemaOp->createAttribute(_T("ContextData"), NoKey, 8, 4004, String))
  381.         {
  382.             throw pNdbSchemaOp;
  383.         }
  384.         if(pNdbSchemaCon->execute())
  385.         {
  386.             throw pNdbSchemaCon;
  387.         }
  388.         pNdb->closeSchemaTransaction(pNdbSchemaCon);
  389.         
  390.         _tprintf(_T("Insert %d tuples in the CallContext tablen"), nInsert);
  391.         for(long i=0; i<nInsert; ++i)
  392.         {
  393.             long iContextId = -i;
  394.             pNdbConnection = pNdb->startTransaction((Uint32)0, (const char*)&iContextId, (Uint32)4);
  395.             if(!pNdbConnection)
  396.             {
  397.                 throw pNdb;
  398.             }
  399.             pNdbOperation = pNdbConnection->getNdbOperation(_T("CallContext"));
  400.             if(!pNdbOperation)
  401.             {
  402.                 throw pNdbConnection;
  403.             }
  404.             if(pNdbOperation->insertTuple()
  405.                 || pNdbOperation->equal(_T("ContextId"), iContextId)
  406.                 || pNdbOperation->setValue(_T("Version"), Int32(1))
  407.                 || pNdbOperation->setValue(_T("LockFlag"), Int32(1))
  408.                 || pNdbOperation->setValue(_T("LockTime"), Int32(1))
  409.                 || pNdbOperation->setValue(_T("LockTimeUSec"), Int32(1))
  410.                 || pNdbOperation->setValue(_T("ContextData"), STATUS_DATA, sizeof(STATUS_DATA)))
  411.             {
  412.                 throw pNdbOperation;
  413.             }
  414.             if(pNdbConnection->execute(Commit))
  415.             {
  416.                 throw pNdbConnection;
  417.             }
  418.             pNdb->closeTransaction(pNdbConnection);
  419.         }
  420.         _tprintf(_T("initialisation donen"));
  421.     }
  422.     catch(Ndb* pNdb)
  423.     {
  424.         printf("%d: nt%snt%sn",
  425.             pNdb->getNdbError(), 
  426.             pNdb->getNdbErrorString(), 
  427.             "Ndb");
  428.         delete pNdb;
  429.     }
  430.     catch(NdbConnection* pNdbConnection)
  431.     {
  432.         printf("%d: nt%snt%sn",
  433.             pNdbConnection->getNdbError(), 
  434.             pNdbConnection->getNdbErrorString(), 
  435.             "NdbConnection");
  436.         pNdb->closeTransaction(pNdbConnection);
  437.         delete pNdb;
  438.     }
  439.     catch(NdbOperation* pNdbOperation)
  440.     {
  441.         printf("%d: nt%snt%sn",
  442.             pNdbOperation->getNdbError(), 
  443.             pNdbOperation->getNdbErrorString(), 
  444.             "NdbOperation");
  445.         pNdb->closeTransaction(pNdbConnection);
  446.         delete pNdb;
  447.     }
  448.     catch(NdbSchemaCon* pNdbSchemaCon)
  449.     {
  450.         printf("%d: nt%snt%sn",
  451.             pNdbSchemaCon->getNdbError(), 
  452.             pNdbSchemaCon->getNdbErrorString(), 
  453.             "pNdbSchemaCon");
  454.         pNdb->closeSchemaTransaction(pNdbSchemaCon);
  455.         delete pNdb;
  456.     }
  457.     catch(NdbSchemaOp* pNdbSchemaOp)
  458.     {
  459.         printf("%d: nt%snt%sn",
  460.             pNdbSchemaOp->getNdbError(), 
  461.             pNdbSchemaOp->getNdbErrorString(), 
  462.             "pNdbSchemaOp");
  463.         pNdb->closeTransaction(pNdbConnection);
  464.         delete pNdb;
  465.     }
  466. }
  469. int _tmain(int argc, _TCHAR* argv[])
  470. {
  471. long nNumThreads=4;
  472. long nSeed = 0;
  473.     long nInsert = 0;
  474.     bool bStoredTable = true;
  475. if(lstrcmp(argv[1],_T("/?")) == 0)
  476. {
  477. _tprintf(_T("InsertRecs [No.Of Threads] [Record Seed No.] [Init no. of rec.] [Stored?]n"));
  478. return 0;
  479. }
  481. if(argc > 1) 
  482.      nNumThreads = _ttol(argv[1]);
  483. else
  484. nNumThreads = 4;
  485. if (argc > 2)
  486. nSeed = _ttol(argv[2]);
  487. _tprintf(_T("Num of Threads = %d, Seed = %d"), nNumThreads, nSeed);
  489.     if(argc>3)
  490.         nInsert = _ttol(argv[3]);
  491.     if(argc>4)
  492.         bStoredTable = (_ttol(argv[4])!=0);
  494. long nNumCallsProcessed = 0;
  496.     SetConsoleCtrlHandler(ConsoleCtrlHandler,true); 
  497. hShutdownEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  498.    
  499.     // initiate windows sockets
  500.     WORD wVersionRequested;
  501.     WSADATA wsaData;
  502.     int err;
  503.     wVersionRequested = MAKEWORD( 2, 2 );
  504.     err = WSAStartup( wVersionRequested, &wsaData );
  505.     if ( err != 0 ) {
  506.         _tprintf(_T("could not find a usable WinSock DLLn"));
  507.         return 0;
  508.     }
  509.     if ( LOBYTE( wsaData.wVersion ) != 2 
  510.         || HIBYTE( wsaData.wVersion ) != 2 ) 
  511.     {
  512.         _tprintf(_T("could not find a usable WinSock DLLn"));
  513.         WSACleanup();
  514.         return 0;
  515.     }
  517.     Ndb* pNdb = new Ndb("TEST_DB");
  518.     if(!pNdb)
  519.     {
  520.         _tprintf(_T("could not construct ndbn"));
  521.         return 0;
  522.     }
  523.     if(pNdb->init(1)
  524.         || pNdb->waitUntilReady())
  525.     {
  526.         _tprintf(_T("could not initialize ndbn"));
  527.         return 0;
  528.     }
  529.     
  530.     if(nInsert>0)
  531.     {
  532.         Initialize(pNdb, nInsert, bStoredTable);
  533.     }
  534.     
  535.     if(nNumThreads>0)
  536.     {
  537.         _tprintf(_T("creating %d threadsn"), nNumThreads);
  538.         DWORD dwStartTime  = GetTickCount();
  539.         
  540.         DWORD dwThreadID = 0;
  541.         HANDLE hThreads[50];
  542.         
  543.         struct _ParamStruct params[50];
  544.         
  545.         for(int ij=0;ij<nNumThreads;ij++) {
  546.             params[ij].hShutdownEvent = hShutdownEvent;
  547.             params[ij].nStartingRecordNum = (ij*5000) + nSeed;
  548.             params[ij].pnNumCallsProcessed = &nNumCallsProcessed;
  549.         }
  550.         
  551.         for(ij=0;ij<nNumThreads;ij++) {
  552.             hThreads[ij] = CreateThread(NULL,NULL,RuntimeCallContext,&params[ij],0,&dwThreadID);
  553.         }
  554.         
  555.         //Wait for the threads to finish
  556.         WaitForMultipleObjects(nNumThreads,hThreads,TRUE,INFINITE);
  557.         DWORD dwEndTime  = GetTickCount();
  558.         
  559.         //Print time taken
  560.         _tprintf(_T("Time Taken for %d Calls is %ld msec (= %ld calls/secn"),
  561.             nNumCallsProcessed,dwEndTime-dwStartTime, (1000*nNumCallsProcessed/(dwEndTime-dwStartTime)));
  562.     }
  564.     delete pNdb;
  565.     WSACleanup();
  566. CloseHandle(hShutdownEvent);
  568.     return 0;
  569. }