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

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

MySQL数据库

开发平台：

Visual C++

perfTransporterTest.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 "TransporterRegistry.hpp"
  20. #include "TransporterDefinitions.hpp"
  21. #include "TransporterCallback.hpp"
  22. #include <RefConvert.hpp>
  24. #include <NdbTick.h>
  25. #include <NdbMain.h>
  26. #include <NdbOut.hpp>
  27. #include <NdbSleep.h>
  29. int basePortTCP = 17000;
  31. SCI_TransporterConfiguration sciTemplate = {
  32.   2000, 
  33.        // Packet size
  34.   2000000,      // Buffer size
  35.   2,           // number of adapters
  36.   1,           // remote node id SCI 
  37.   2,           // Remote node Id SCI
  38.   0,           // local ndb node id (server)
  39.   0,           // remote ndb node id (client)
  40.   0,              // byteOrder;
  41.   false,          // compression;
  42.   true,          // checksum;
  43.   true            // signalId;
  44. };
  47. SHM_TransporterConfiguration shmTemplate = {
  48.   0,      //remoteNodeId
  49.   0,      //localNodeId;
  50.   false,  //compression
  51.   true,   //checksum;
  52.   true,   //signalId;
  53.   0,      //byteOrder;
  54.   123,    //shmKey;
  55.   25000000 //shmSize;
  56. };
  59. TCP_TransporterConfiguration tcpTemplate = {
  60.   17000,          // port; 
  61.   "",             // remoteHostName;
  62.   "",             // localhostname
  63.   2,              // remoteNodeId;
  64.   1,              // localNodeId;
  65.   25000000,        // sendBufferSize - Size of SendBuffer of priority B 
  66.   5000000,         // maxReceiveSize - Maximum no of bytes to receive
  67.   0,              // byteOrder;
  68.   false,          // compression;
  69.   true,           // checksum;
  70.   true            // signalId;
  71. };
  73. OSE_TransporterConfiguration oseTemplate = {
  74.   "",    // remoteHostName;
  75.   "",    // localHostName;
  76.   0,     // remoteNodeId;
  77.   0,     // localNodeId;
  78.   false, // compression;
  79.   true,  // checksum;
  80.   true,  // signalId;
  81.   0,     // byteOrder;
  82.   
  83.   2000,  // prioASignalSize;
  84.   2000,  // prioBSignalSize;
  85.   10     // Recv buf size
  86. };
  88. TransporterRegistry *tReg = 0;
  90. #ifndef OSE_DELTA
  91. #include <signal.h>
  92. #endif
  94. extern "C"
  95. void
  96. signalHandler(int signo){
  97. #ifndef OSE_DELTA
  98.   ::signal(13, signalHandler);
  99. #endif
  100.   char buf[255];
  101.   sprintf(buf,"Signal: %dn", signo);
  102.   ndbout << buf << endl;
  103. }
  105. void 
  106. usage(const char * progName){
  107.   ndbout << "Usage: " << progName << " <type> localNodeId localHostName" 
  108.  << " remoteHostName"
  109.  << " [<loop count>] [<send buf size>] [<recv buf size>]" << endl;
  110.   ndbout << "  type = shm tcp ose sci" << endl;
  111.   ndbout << "  localNodeId - {1,2}" << endl;
  112. }
  114. typedef void (* CreateTransporterFunc)(void * conf, 
  115.        NodeId localNodeId,
  116.        NodeId remoteNodeId,
  117.        const char * localHostName,
  118.        const char * remoteHostName,
  119.        int sendBuf,
  120.        int recvBuf);
  122. void 
  123. createOSETransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
  124. void
  125. createTCPTransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
  126. void
  127. createSHMTransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
  128. void
  129. createSCITransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
  131. struct TestPhase {
  132.   int signalSize;
  133.   int noOfSignals;
  134.   int noOfSignalSent;
  135.   int noOfSignalReceived;
  136.   NDB_TICKS startTime;
  137.   NDB_TICKS stopTime;
  138.   NDB_TICKS accTime;
  139.   int loopCount;
  140.   Uint64 sendLenBytes, sendCount;
  141.   Uint64 recvLenBytes, recvCount;
  142. };
  144. TestPhase testSpec[] = {
  145.    {  1,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  146.   ,{  1,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  147.   ,{  1,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  148.   ,{  1, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  150.   ,{  8,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  151.   ,{  8,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  152.   ,{  8,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  153.   ,{  8, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  155.   ,{ 16,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  156.   ,{ 16,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  157.   ,{ 16,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  158.   ,{ 16, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  160.   ,{ 24,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  161.   ,{ 24,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  162.   ,{ 24,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  163.   ,{ 24, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  165.   ,{  0,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of random size
  166.   ,{  0,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of random size
  167.   ,{  0,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of random size
  168.   ,{  0, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of random size
  170.   ,{ 100,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals 
  171.   ,{ 100,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals 
  172.   ,{ 100,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals 
  173.   ,{ 100, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals 
  175.   ,{ 500,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals 
  176.   ,{ 500,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals 
  177.   ,{ 500,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals 
  178.   ,{ 500, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals 
  180.   ,{ 1000,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals 
  181.   ,{ 1000,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals 
  182.   ,{ 1000,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals 
  183.   ,{ 1000, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals 
  184. };
  186. const int noOfTests = sizeof(testSpec)/sizeof(TestPhase);
  188. Uint32 StaticBuffer[1000];
  190. SendStatus
  191. sendSignalTo(NodeId nodeId, int signalSize, Uint32 count){
  192.   if(signalSize == 0)
  193.     signalSize = (rand() % 25) + 1;
  195.   SignalHeader sh;
  196.   sh.theLength               = (signalSize > 25 ? 25 : signalSize);
  197.   sh.theVerId_signalNumber   = count;
  198.   sh.theReceiversBlockNumber = rand();   
  199.   sh.theSendersBlockRef      = rand(); 
  200.   sh.theSendersSignalId      = rand(); 
  201.   sh.theSignalId             = rand(); 
  202.   sh.theTrace                = rand(); 
  203.   
  204.   Uint32 theData[25];
  205.   for(int i = 0; i<25; i++)
  206.     theData[i] = (i+1) * (Uint32)(&theData[i]);
  207.   
  208.   theData[0] = count;
  209.   LinearSectionPtr ptr[3];
  210.   
  211.   if(signalSize <= 25){
  212.     sh.m_noOfSections = 0;
  213.   } else {
  214.     sh.m_noOfSections = 1;
  215.     ptr[0].sz = signalSize - 25;
  216.     ptr[0].p = &StaticBuffer[0];
  217.   }
  219.   return tReg->prepareSend(&sh, 1, theData, nodeId, ptr);
  220. }
  222. void
  223. reportHeader(){
  224.   ndbout << "#SigstSztTimetSig/sectBpstBps-tott"
  225.  << "s lentr len" << endl;
  226. }
  228. void
  229. print(char * dst, int i){
  230.   if(i > 1000000){
  231.     const int d = i / 1000000;
  232.     const int r = (i - (d * 1000000)) / 100000;
  233.     if(d < 100)
  234.       sprintf(dst, "%d.%dM", d, r);
  235.     else
  236.       sprintf(dst, "%dM", d);
  237.   } else if(i > 1000){
  238.     const int d = i / 1000;
  239.     const int r = (i - (d * 1000)) / 100;
  240.     if(d < 100)
  241.       sprintf(dst, "%d.%dk", d, r);
  242.     else
  243.       sprintf(dst, "%dk", d);
  244.   } else {
  245.     sprintf(dst, "%d", i);
  246.   }
  247. }
  249. void
  250. printReport(TestPhase & p){
  251.   if(p.accTime > 0) {
  252.     Uint32 secs = (p.accTime/p.loopCount)/1000;
  253.     Uint32 mill = (p.accTime/p.loopCount)%1000;
  254.     char st[255];
  255.     if(secs > 0){
  256.       sprintf(st, "%d.%.2ds", secs, (mill/10));
  257.     } else {
  258.       sprintf(st, "%dms", mill);
  259.     }
  260.   
  261.     Uint32 sps = (1000*p.noOfSignals*p.loopCount)/p.accTime;
  262.     Uint32 dps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*p.signalSize);
  263.     Uint32 bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(p.signalSize+3));
  264.     if(p.signalSize == 0){
  265.       dps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13));
  266.       bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13+3));
  267.     }
  268.     char ssps[255];
  269.     char sbps[255];
  270.     char sdps[255];
  272.     print(ssps, sps);
  273.     print(sbps, bps);
  274.     print(sdps, dps);
  275.     
  276.     
  277.     char buf[255];
  278.     if(p.signalSize != 0){
  279.       BaseString::snprintf(buf, 255,
  280.        "%dt%dt%st%st%st%st%dt%d",
  281.        p.noOfSignals,
  282.        4*p.signalSize,
  283.        st,
  284.        ssps,
  285.        sdps,
  286.        sbps,
  287.        (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)),
  288.        (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)));
  289.     } else {
  290.       BaseString::snprintf(buf, 255,
  291.        "%dtrandt%st%st%st%st%dt%d",
  292.        p.noOfSignals,
  293.        st,
  294.        ssps,
  295.        sdps,
  296.        sbps,
  297.        (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)),
  298.        (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)));
  299.       
  300.     }
  301.     ndbout << buf << endl;
  302.   }
  303. }
  305. int loopCount = 1;
  306. int sendBufSz = -1;
  307. int recvBufSz = -1;
  309. bool      isClient     = false;
  310. bool      isConnected  = false;
  311. bool      isStarted    = false;
  312. int       currentPhase = 0;
  313. TestPhase allPhases[noOfTests];
  314. Uint32    signalToEcho;
  315. Uint32    signalsEchoed;
  316. NDB_TICKS startTime, stopTime;
  318. void
  319. client(NodeId remoteNodeId){
  320.   isClient = true;
  322.   currentPhase = 0;
  323.   memcpy(allPhases, testSpec, sizeof(testSpec));
  325.   int counter = 0;
  326.   int sigCounter = 0;
  328.   while(true){
  329.     TestPhase * current = &allPhases[currentPhase];
  330.     if(current->noOfSignals == current->noOfSignalSent &&
  331.        current->noOfSignals == current->noOfSignalReceived){
  333.       /**
  334.        * Test phase done
  335.        */
  336.       current->stopTime  = NdbTick_CurrentMillisecond();
  337.       current->accTime  += (current->stopTime - current->startTime);
  339.       NdbSleep_MilliSleep(500 / loopCount);
  340.       
  341.       current->startTime = NdbTick_CurrentMillisecond();
  342.       
  343.       current->noOfSignalSent     = 0;
  344.       current->noOfSignalReceived = 0;
  346.       current->loopCount ++;
  347.       if(current->loopCount == loopCount){
  349. printReport(allPhases[currentPhase]);
  351. currentPhase ++;
  352. if(currentPhase == noOfTests){
  353.   /**
  354.    * Now we are done
  355.    */
  356.   break;
  357. }
  358. NdbSleep_MilliSleep(500);
  359. current = &allPhases[currentPhase];
  360. current->startTime = NdbTick_CurrentMillisecond();
  361.       }
  362.     } 
  363.     
  364.     int signalsLeft = current->noOfSignals - current->noOfSignalSent;
  365.     if(signalsLeft > 0){
  366.       for(; signalsLeft > 0; signalsLeft--){
  367. if(sendSignalTo(remoteNodeId,current->signalSize,sigCounter)== SEND_OK){
  368.   current->noOfSignalSent++;
  369.   sigCounter++;
  370. } else {
  371.   ndbout << "Failed to send: " << sigCounter << endl;
  372.   tReg->external_IO(10);
  373.   break;
  374. }
  375.       }
  376.     }
  377.     if(counter % 10 == 0)
  378.       tReg->checkConnections();
  379.     tReg->external_IO(0);
  380.     counter++;
  381.   }
  382. }
  384. void 
  385. server(){
  386.   isClient = false;
  387.   
  388.   signalToEcho = 0;
  389.   signalsEchoed = 0;
  390.   for(int i = 0; i<noOfTests; i++)
  391.     signalToEcho += testSpec[i].noOfSignals;
  392.   
  393.   signalToEcho *= loopCount;
  395.   while(signalToEcho > signalsEchoed){
  396.     tReg->checkConnections();
  397.     for(int i = 0; i<10; i++)
  398.       tReg->external_IO(10);
  399.   }
  400. }
  402. int
  403. main(int argc, const char **argv){
  404.   
  405.   const char * progName = argv[0];
  407.   loopCount = 100;
  408.   sendBufSz = -1;
  409.   recvBufSz = -1;
  410.   
  411.   isClient     = false;
  412.   isConnected  = false;
  413.   isStarted    = false;
  414.   currentPhase = 0;
  416.   signalHandler(0);
  417.   
  418.   if(argc < 5){
  419.     usage(progName);
  420.     return 0;
  421.   }
  422.   
  423.   const char * type = argv[1];
  424.   const NodeId localNodeId   = atoi(argv[2]);
  425.   const char * localHostName = argv[3];
  426.   const char * remoteHost1   = argv[4];
  427.   
  428.   if(argc >= 6)
  429.     loopCount = atoi(argv[5]);
  430.   if(argc >= 7)
  431.     sendBufSz = atoi(argv[6]);
  432.   if(argc >= 8)
  433.     recvBufSz = atoi(argv[7]);
  435.   if(localNodeId < 1 || localNodeId > 2){
  436.     ndbout << "localNodeId = " << localNodeId << endl << endl;
  437.     usage(progName);
  438.     return 0;
  439.   }
  440.   
  441.   if(localNodeId == 1)
  442.     ndbout << "-- ECHO CLIENT --" << endl;
  443.   else
  444.     ndbout << "-- ECHO SERVER --" << endl;
  446.   ndbout << "localNodeId:           " << localNodeId << endl;
  447.   ndbout << "localHostName:         " << localHostName << endl;
  448.   ndbout << "remoteHost1 (node " << (localNodeId == 1?2:1) << "): " 
  449.  << remoteHost1 << endl;
  450.   ndbout << "Loop count: " << loopCount << endl;
  451.   ndbout << "-----------------" << endl;
  452.   
  453.   void * confTemplate = 0;
  454.   CreateTransporterFunc func = 0;
  455.   if(strcasecmp(type, "tcp") == 0){
  456.     func = createTCPTransporter;
  457.     confTemplate = &tcpTemplate;
  458.   } else if(strcasecmp(type, "ose") == 0){
  459.     func = createOSETransporter;
  460.     confTemplate = &oseTemplate;
  461.   } else if(strcasecmp(type, "sci") == 0){
  462.     func = createSCITransporter;
  463.     confTemplate = &sciTemplate;
  464.   } else if(strcasecmp(type, "shm") == 0){
  465.     func = createSHMTransporter;
  466.     confTemplate = &shmTemplate;
  467.   } else {
  468.     ndbout << "Unsupported transporter type" << endl;
  469.     return 0;
  470.   }
  471.   
  472.   ndbout << "Creating transporter registry" << endl;
  473.   tReg = new TransporterRegistry;
  474.   tReg->init(localNodeId);
  475.   
  476.   switch(localNodeId){
  477.   case 1:
  478.     (* func)(confTemplate, 1, 2, localHostName, remoteHost1, 
  479.      sendBufSz, recvBufSz);
  480.     break;
  481.   case 2:
  482.     (* func)(confTemplate, 2, 1, localHostName, remoteHost1,
  483.      sendBufSz, recvBufSz);
  484.     break;
  485.   }
  486.   
  487.   ndbout << "Doing startSending/startReceiving" << endl;
  488.   tReg->startSending();
  489.   tReg->startReceiving();
  490.   
  491.   ndbout << "Connecting" << endl;
  492.   tReg->setPerformState(PerformConnect);
  493.   tReg->checkConnections();
  495.   if(localNodeId == 1)
  496.     client(2);
  497.   else
  498.     server();
  499.     
  500.   isStarted = false;
  501.   
  502.   ndbout << "Sleep 3 secs" << endl;
  503.   NdbSleep_SecSleep(3);
  505.   ndbout << "Doing setPerformState(Disconnect)" << endl;
  506.   tReg->setPerformState(PerformDisconnect);
  507.   
  508.   ndbout << "Doing checkConnections()" << endl;
  509.   tReg->checkConnections();
  510.     
  511.   ndbout << "Deleting transporter registry" << endl;
  512.   delete tReg; tReg = 0;
  513.   
  514.   return 0;
  515. }
  517. void
  518. execute(void* callbackObj, SignalHeader * const header, Uint8 prio, 
  519. Uint32 * const theData,
  520. LinearSectionPtr ptr[3]){
  521.   const NodeId nodeId = refToNode(header->theSendersBlockRef);
  522.  
  523.   if(isClient){
  524.     allPhases[currentPhase].noOfSignalReceived++;
  525.   } else {
  526.     int sleepTime = 10;
  527.     if(theData[0] != signalsEchoed){
  528.       ndbout << "Missing signal theData[0] = " << theData[0] 
  529.      << " signalsEchoed = " << signalsEchoed << endl;
  530.       ndbout << (* header) << endl;
  531.       abort();
  532.     }
  533.     while(tReg->prepareSend(header, prio, theData, nodeId, ptr) != SEND_OK){
  534.       ndbout << "Failed to echo " << theData[0] << endl;
  535.       NdbSleep_MilliSleep(sleepTime);
  536.       // sleepTime += 10;
  537.     }
  538.     signalsEchoed++;
  539.   }
  540. }
  542. void 
  543. copy(Uint32 * & insertPtr, 
  544.      class SectionSegmentPool & thePool, const SegmentedSectionPtr & _ptr){
  545.   abort();
  546. }
  548. void
  549. reportError(void* callbackObj, NodeId nodeId, TransporterError errorCode){
  550.   char buf[255];
  551.   sprintf(buf, "reportError (%d, %x) in perfTest", nodeId, errorCode);
  552.   ndbout << buf << endl;
  553.   if(errorCode & 0x8000 && errorCode != 0x8014){
  554.     abort(); //tReg->setPerformState(nodeId, PerformDisconnect);
  555.   }
  556. }
  558. /**
  559.  * Report average send theLength in bytes (4096 last sends)
  560.  */
  561. void
  562. reportSendLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){
  563.   allPhases[currentPhase].sendCount    += count;
  564.   allPhases[currentPhase].sendLenBytes += bytes;
  566.   if(!isClient){
  567.     ndbout << "reportSendLen(" << nodeId << ", " 
  568.    << (bytes/count) << ")" << endl;
  569.   }
  570. }
  572. /**
  573.  * Report average receive theLength in bytes (4096 last receives)
  574.  */
  575. void
  576. reportReceiveLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){
  577.   allPhases[currentPhase].recvCount    += count;
  578.   allPhases[currentPhase].recvLenBytes += bytes;
  580.   if(!isClient){
  581.     ndbout << "reportReceiveLen(" << nodeId << ", " 
  582.    << (bytes/count) << ")" << endl;
  583.   }
  584. }
  586. /**
  587.  * Report connection established
  588.  */
  589. void
  590. reportConnect(void* callbackObj, NodeId nodeId){
  591.   char buf[255];
  592.   sprintf(buf, "reportConnect(%d)", nodeId);
  593.   ndbout << buf << endl;
  594.   tReg->setPerformState(nodeId, PerformIO);
  595.   
  596.   if(!isStarted){
  597.     isStarted = true;
  598.     startTime = NdbTick_CurrentMillisecond();
  599.     if(isClient){
  600.       reportHeader();
  601.       allPhases[0].startTime = startTime;
  602.     }
  603.   }
  604.   else{
  605.     // Resend signals that were lost when connection failed
  606.     TestPhase * current = &allPhases[currentPhase];
  607.     current->noOfSignalSent = current->noOfSignalReceived;
  608.   }
  609. }
  611. /**
  612.  * Report connection broken
  613.  */
  614. void
  615. reportDisconnect(void* callbackObj, NodeId nodeId, Uint32 errNo){
  616.   char buf[255];
  617.   sprintf(buf, "reportDisconnect(%d)", nodeId);
  618.   ndbout << buf << endl;
  619.   
  620.   if(isStarted)
  621.     tReg->setPerformState(nodeId, PerformConnect);
  622. }
  625. int
  626. checkJobBuffer() {
  627.   /** 
  628.    * Check to see if jobbbuffers are starting to get full
  629.    * and if so call doJob
  630.    */
  631.   return 0;
  632. }
  634. void
  635. createOSETransporter(void * _conf,
  636.      NodeId localNodeId,
  637.      NodeId remoteNodeId,
  638.      const char * localHostName,
  639.      const char * remoteHostName,
  640.      int sendBuf,
  641.      int recvBuf){
  642.   
  643.   ndbout << "Creating OSE transporter from node " 
  644.  << localNodeId << "(" << localHostName << ") to "
  645.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  646.   
  647.   OSE_TransporterConfiguration * conf = (OSE_TransporterConfiguration*)_conf;
  648.   
  649.   if(sendBuf != -1){
  650.     conf->prioBSignalSize = sendBuf;
  651.   }
  652.   if(recvBuf != -1){
  653.     conf->receiveBufferSize = recvBuf;
  654.   }
  656.   ndbout << "tSendBufferSize:    " << conf->prioBSignalSize << endl;
  657.   ndbout << "tReceiveBufferSize: " << conf->receiveBufferSize << endl;
  659.   conf->localNodeId    = localNodeId;
  660.   conf->localHostName  = localHostName;
  661.   conf->remoteNodeId   = remoteNodeId;
  662.   conf->remoteHostName = remoteHostName;
  663.   bool res = tReg->createTransporter(conf);
  664.   if(res)
  665.     ndbout << "... -- Success " << endl;
  666.   else
  667.     ndbout << "... -- Failure " << endl;
  668. }
  671. void
  672. createSCITransporter(void * _conf,
  673.      NodeId localNodeId,
  674.      NodeId remoteNodeId,
  675.      const char * localHostName,
  676.      const char * remoteHostName,
  677.      int sendbuf,
  678.      int recvbuf) {
  681.   ndbout << "Creating SCI transporter from node " 
  682.  << localNodeId << "(" << localHostName << ") to "
  683.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  684.   
  685.   
  686.   SCI_TransporterConfiguration * conf = (SCI_TransporterConfiguration*)_conf;
  688.   conf->remoteSciNodeId0= (Uint16)atoi(localHostName);
  689.   conf->remoteSciNodeId1= (Uint16)atoi(remoteHostName);
  692.   conf->localNodeId    = localNodeId;
  693.   conf->remoteNodeId   = remoteNodeId;
  695.   bool res = tReg->createTransporter(conf);
  696.   if(res)
  697.     ndbout << "... -- Success " << endl;
  698.   else
  699.     ndbout << "... -- Failure " << endl;
  700. }
  702. void
  703. createSHMTransporter(void * _conf,
  704.      NodeId localNodeId,
  705.      NodeId remoteNodeId,
  706.      const char * localHostName,
  707.      const char * remoteHostName,
  708.      int sendbuf,
  709.      int recvbuf) {
  712.   ndbout << "Creating SHM transporter from node " 
  713.  << localNodeId << "(" << localHostName << ") to "
  714.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  715.   
  716.   
  717.   SHM_TransporterConfiguration * conf = (SHM_TransporterConfiguration*)_conf;
  720.   conf->localNodeId    = localNodeId;
  721.   conf->remoteNodeId   = remoteNodeId;
  723.   bool res = tReg->createTransporter(conf);
  724.   if(res)
  725.     ndbout << "... -- Success " << endl;
  726.   else
  727.     ndbout << "... -- Failure " << endl;
  728. }
  731. void
  732. createTCPTransporter(void * _conf,
  733.      NodeId localNodeId,
  734.      NodeId remoteNodeId,
  735.      const char * localHostName,
  736.      const char * remoteHostName,
  737.      int sendBuf,
  738.      int recvBuf){
  739.   ndbout << "Creating TCP transporter from node " 
  740.  << localNodeId << "(" << localHostName << ") to "
  741.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  742.   
  743.   TCP_TransporterConfiguration * conf = (TCP_TransporterConfiguration*)_conf;
  744.   
  745.   int port;
  746.   if(localNodeId == 1 && remoteNodeId == 2) port = basePortTCP + 0;
  747.   if(localNodeId == 1 && remoteNodeId == 3) port = basePortTCP + 1;
  748.   if(localNodeId == 2 && remoteNodeId == 1) port = basePortTCP + 0;
  749.   if(localNodeId == 2 && remoteNodeId == 3) port = basePortTCP + 2;
  750.   if(localNodeId == 3 && remoteNodeId == 1) port = basePortTCP + 1;
  751.   if(localNodeId == 3 && remoteNodeId == 2) port = basePortTCP + 2;
  753.   if(sendBuf != -1){
  754.     conf->sendBufferSize = sendBuf;
  755.   }
  756.   if(recvBuf != -1){
  757.     conf->maxReceiveSize = recvBuf;
  758.   }
  760.   ndbout << "tSendBufferSize:    " << conf->sendBufferSize << endl;
  761.   ndbout << "tReceiveBufferSize: " << conf->maxReceiveSize << endl;
  763.   conf->localNodeId    = localNodeId;
  764.   conf->localHostName  = localHostName;
  765.   conf->remoteNodeId   = remoteNodeId;
  766.   conf->remoteHostName = remoteHostName;
  767.   conf->port           = port;
  768.   bool res = tReg->createTransporter(conf);
  769.   if(res)
  770.     ndbout << "... -- Success " << endl;
  771.   else
  772.     ndbout << "... -- Failure " << endl;
  773. }