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

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

MySQL数据库

开发平台：

Visual C++

prioTransporterTest.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 "prioTransporterTest.hpp"
  26. #include <NdbTick.h>
  27. #include <NdbMain.h>
  28. #include <NdbOut.hpp>
  29. #include <NdbSleep.h>
  31. int basePortTCP = 17000;
  33. SCI_TransporterConfiguration sciTemplate = {
  34.   2000, 
  35.        // Packet size
  36.   2000000,      // Buffer size
  37.   2,           // number of adapters
  38.   1,           // remote node id SCI 
  39.   2,           // Remote node Id SCI
  40.   0,           // local ndb node id (server)
  41.   0,           // remote ndb node id (client)
  42.   0,              // byteOrder;
  43.   false,          // compression;
  44.   true,          // checksum;
  45.   true            // signalId;
  46. };
  49. SHM_TransporterConfiguration shmTemplate = {
  50.   100000, // shmSize
  51.   0,      // shmKey
  52.   1,           // local ndb node id (server)
  53.   2,           // remote ndb node id (client)
  54.   0,              // byteOrder;
  55.   false,          // compression;
  56.   true,           // checksum;
  57.   true            // signalId;
  58. };
  60. TCP_TransporterConfiguration tcpTemplate = {
  61.   17000,          // port; 
  62.   "",             // remoteHostName;
  63.   "",             // localhostname
  64.   2,              // remoteNodeId;
  65.   1,              // localNodeId;
  66.   2000000,          // sendBufferSize - Size of SendBuffer of priority B 
  67.   2000,           // maxReceiveSize - Maximum no of bytes to receive
  68.   0,              // byteOrder;
  69.   false,          // compression;
  70.   true,           // checksum;
  71.   true            // signalId;
  72. };
  74. OSE_TransporterConfiguration oseTemplate = {
  75.   "",    // remoteHostName;
  76.   "",    // localHostName;
  77.   0,     // remoteNodeId;
  78.   0,     // localNodeId;
  79.   false, // compression;
  80.   true,  // checksum;
  81.   true,  // signalId;
  82.   0,     // byteOrder;
  83.   
  84.   2000,  // prioASignalSize;
  85.   2000,  // prioBSignalSize;
  86.   10     // Recv buf size
  87. };
  89. TransporterRegistry *tReg = 0;
  91. #ifndef OSE_DELTA
  92. #include <signal.h>
  93. #endif
  95. extern "C"
  96. void
  97. signalHandler(int signo){
  98. #ifndef OSE_DELTA
  99.   ::signal(13, signalHandler);
  100. #endif
  101.   char buf[255];
  102.   sprintf(buf,"Signal: %dn", signo);
  103.   ndbout << buf << endl;
  104. }
  106. void 
  107. usage(const char * progName){
  108.   ndbout << "Usage: " << progName << " localNodeId localHostName" 
  109.  << " remoteHostName"
  110.  << " [<loop count>] [<send buf size>] [<recv buf size>]" << 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 * _conf,
  124.      NodeId localNodeId,
  125.      NodeId remoteNodeId,
  126.      const char * localHostName,
  127.      const char * remoteHostName,
  128.      int sendBuf,
  129.      int recvBuf){
  130.   
  131.   ndbout << "Creating OSE transporter from node " 
  132.  << localNodeId << "(" << localHostName << ") to "
  133.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  134.   
  135.   OSE_TransporterConfiguration * conf = (OSE_TransporterConfiguration*)_conf;
  136.   
  137.   if(sendBuf != -1){
  138.     conf->prioBSignalSize = sendBuf;
  139.   }
  140.   if(recvBuf != -1){
  141.     conf->receiveBufferSize = recvBuf;
  142.   }
  144.   ndbout << "tSendBufferSize:    " << conf->prioBSignalSize << endl;
  145.   ndbout << "tReceiveBufferSize: " << conf->receiveBufferSize << endl;
  147.   conf->localNodeId    = localNodeId;
  148.   conf->localHostName  = localHostName;
  149.   conf->remoteNodeId   = remoteNodeId;
  150.   conf->remoteHostName = remoteHostName;
  151.   bool res = tReg->createTransporter(conf);
  152.   if(res)
  153.     ndbout << "... -- Success " << endl;
  154.   else
  155.     ndbout << "... -- Failure " << endl;
  156. }
  159. void
  160. createSCITransporter(void * _conf,
  161.      NodeId localNodeId,
  162.      NodeId remoteNodeId,
  163.      const char * localHostName,
  164.      const char * remoteHostName,
  165.      int sendbuf,
  166.      int recvbuf) {
  169.   ndbout << "Creating SCI transporter from node " 
  170.  << localNodeId << "(" << localHostName << ") to "
  171.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  172.   
  173.   
  174.   SCI_TransporterConfiguration * conf = (SCI_TransporterConfiguration*)_conf;
  176.   conf->remoteSciNodeId0= (Uint16)atoi(localHostName);
  177.   conf->remoteSciNodeId1= (Uint16)atoi(remoteHostName);
  180.   conf->localNodeId    = localNodeId;
  181.   conf->remoteNodeId   = remoteNodeId;
  183.   bool res = tReg->createTransporter(conf);
  184.   if(res)
  185.     ndbout << "... -- Success " << endl;
  186.   else
  187.     ndbout << "... -- Failure " << endl;
  188. }
  190. void
  191. createSHMTransporter(void * _conf,
  192.      NodeId localNodeId,
  193.      NodeId remoteNodeId,
  194.      const char * localHostName,
  195.      const char * remoteHostName,
  196.      int sendbuf,
  197.      int recvbuf) {
  200.   ndbout << "Creating SHM transporter from node " 
  201.  << localNodeId << "(" << localHostName << ") to "
  202.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  203.   
  204.   
  205.   SHM_TransporterConfiguration * conf = (SHM_TransporterConfiguration*)_conf;
  208.   conf->localNodeId    = localNodeId;
  209.   conf->remoteNodeId   = remoteNodeId;
  211.   bool res = tReg->createTransporter(conf);
  212.   if(res)
  213.     ndbout << "... -- Success " << endl;
  214.   else
  215.     ndbout << "... -- Failure " << endl;
  216. }
  219. void
  220. createTCPTransporter(void * _conf,
  221.      NodeId localNodeId,
  222.      NodeId remoteNodeId,
  223.      const char * localHostName,
  224.      const char * remoteHostName,
  225.      int sendBuf,
  226.      int recvBuf){
  227.   ndbout << "Creating TCP transporter from node " 
  228.  << localNodeId << "(" << localHostName << ") to "
  229.  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
  230.   
  231.   TCP_TransporterConfiguration * conf = (TCP_TransporterConfiguration*)_conf;
  232.   
  233.   int port;
  234.   if(localNodeId == 1 && remoteNodeId == 2) port = basePortTCP + 0;
  235.   if(localNodeId == 1 && remoteNodeId == 3) port = basePortTCP + 1;
  236.   if(localNodeId == 2 && remoteNodeId == 1) port = basePortTCP + 0;
  237.   if(localNodeId == 2 && remoteNodeId == 3) port = basePortTCP + 2;
  238.   if(localNodeId == 3 && remoteNodeId == 1) port = basePortTCP + 1;
  239.   if(localNodeId == 3 && remoteNodeId == 2) port = basePortTCP + 2;
  241.   if(sendBuf != -1){
  242.     conf->sendBufferSize = sendBuf;
  243.   }
  244.   if(recvBuf != -1){
  245.     conf->maxReceiveSize = recvBuf;
  246.   }
  248.   ndbout << "tSendBufferSize:    " << conf->sendBufferSize << endl;
  249.   ndbout << "tReceiveBufferSize: " << conf->maxReceiveSize << endl;
  251.   conf->localNodeId    = localNodeId;
  252.   conf->localHostName  = localHostName;
  253.   conf->remoteNodeId   = remoteNodeId;
  254.   conf->remoteHostName = remoteHostName;
  255.   conf->port           = port;
  256.   bool res = tReg->createTransporter(conf);
  257.   if(res)
  258.     ndbout << "... -- Success " << endl;
  259.   else
  260.     ndbout << "... -- Failure " << endl;
  261. }
  263. struct TestPhase {
  264.   int signalSize;
  265.   int noOfSignals;
  266.   int noOfSignalSent;
  267.   int noOfSignalReceived;
  268.   NDB_TICKS startTime;
  269.   NDB_TICKS stopTime;
  271.   NDB_TICKS startTimePrioA;
  272.   NDB_TICKS stopTimePrioA;
  273.   NDB_TICKS totTimePrioA;
  274.   int bytesSentBeforePrioA;
  275.   NDB_TICKS accTime;
  276.   int loopCount;
  277.   Uint64 sendLenBytes, sendCount;
  278.   Uint64 recvLenBytes, recvCount;
  279. };
  281. TestPhase testSpec[] = {
  282.    {  1,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  283.   ,{  1,   10000, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  284.   ,{  1,  10000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  285.   ,{  1, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  287.   ,{  8,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  288.   ,{  8,   10000, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  289.   ,{  8,  10000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  290.   ,{  8, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  292.   ,{ 16,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  293.   ,{ 16,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  294.   ,{ 16,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  295.   ,{ 16, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  297.   ,{ 24,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of size 1  word
  298.   ,{ 24,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of size 1  word
  299.   ,{ 24,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of size 1  word
  300.   ,{ 24, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1  word
  302.   ,{  0,    10, 0,0, 0,0,0,0,0,0,0 } //    10 signals of random size
  303.   ,{  0,   100, 0,0, 0,0,0,0,0,0,0 } //   100 signals of random size
  304.   ,{  0,  1000, 0,0, 0,0,0,0,0,0,0 } //  1000 signals of random size
  305.   ,{  0, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of random size
  306. };
  308. const int noOfTests = sizeof(testSpec)/sizeof(TestPhase);
  310. SendStatus
  311. sendSignalTo(NodeId nodeId, int signalSize, int prio){
  312.   if(signalSize == 0)
  313.     signalSize = (rand() % 25) + 1;
  315.   SignalHeader sh;
  316.   sh.theLength               = signalSize;
  317.   sh.theVerId_signalNumber   = rand();
  318.   sh.theReceiversBlockNumber = rand();   
  319.   sh.theSendersBlockRef      = rand(); 
  320.   sh.theSendersSignalId      = rand(); 
  321.   sh.theSignalId             = rand(); 
  322.   sh.theTrace                = rand(); 
  323.   
  324.   Uint32 theData[25];
  325.   for(int i = 0; i<signalSize; i++)
  326.     theData[i] = (i+1) * (Uint32)(&theData[i]);
  327.   
  328.   return tReg->prepareSend(&sh, prio, theData, nodeId);
  329. }
  331. void
  332. reportHeader(){
  333.   ndbout << "#SigstSztPayloadtTimetSig/sectBpst"
  334.  << "s lentr lentprioAtimetbytesb4pA" << endl;
  335. }
  337. void
  338. printReport(TestPhase & p){
  339.   if(p.accTime > 0) {
  340.     Uint32 secs = (p.accTime/p.loopCount)/1000;
  341.     Uint32 mill = (p.accTime/p.loopCount)%1000;
  342.     char st[255];
  343.     if(secs > 0){
  344.       sprintf(st, "%d.%.2ds", secs, (mill/10));
  345.     } else {
  346.       sprintf(st, "%dms", mill);
  347.     }
  348.   
  349.     Uint32 sps = (1000*p.noOfSignals*p.loopCount)/p.accTime;
  350.     Uint32 bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(p.signalSize+3));
  351.     if(p.signalSize == 0)
  352.       ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13+3));
  353.     
  354.     char ssps[255];
  355.     if(sps > 1000000){
  356.       sps /= 1000000;
  357.       sprintf(ssps, "%dM", (int)sps);
  358.     } else if(sps > 1000){
  359.     sps /= 1000;
  360.     sprintf(ssps, "%dk", (int)sps);
  361.     } else {
  362.       sprintf(ssps, "%d", (int)sps);
  363.     }
  364.     
  365.     char sbps[255];
  366.     if(bps > 1000000){
  367.       bps /= 1000000;
  368.       sprintf(sbps, "%dM", bps);
  369.     } else if(bps>1000){
  370.       bps /= 1000;
  371.       sprintf(sbps, "%dk", bps);
  372.     } else {
  373.       sprintf(sbps, "%d", bps);
  374.   }
  375.     
  376.     char buf[255];
  377.     if(p.signalSize != 0){
  378.       BaseString::snprintf(buf, 255,
  379.        "%dt%dt%dt%st%st%st%dt%dt%dt%d",
  380.        p.noOfSignals,
  381.        p.signalSize,
  382.        (4*p.signalSize),
  383.        st,
  384.        ssps,
  385.        sbps,
  386.        (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)),
  387.        (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)),
  388.        (int)(p.totTimePrioA / p.loopCount),
  389.        (int)(p.bytesSentBeforePrioA));
  390.     } else {
  391.       BaseString::snprintf(buf, 255,
  392.        "%dtrandt4*randt%st%st%st%dt%dt%dt%d",
  393.        p.noOfSignals,
  394.        st,
  395.        ssps,
  396.        sbps,
  397.        (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)),
  398.        (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)),
  399.        (int)(p.totTimePrioA / p.loopCount),
  400.        (int)(p.bytesSentBeforePrioA));
  401.       
  402.     }
  403.     ndbout << buf << endl;
  404.   }
  405. }
  407. int loopCount = 1;
  408. int sendBufSz = -1;
  409. int recvBufSz = -1;
  411. NDB_TICKS startSec=0;
  412. NDB_TICKS stopSec=0;
  413. Uint32 startMicro=0;
  414. Uint32 stopMicro=0;
  415. int timerStarted;
  416. int timerStopped;
  418. bool      isClient     = false;
  419. bool      isConnected  = false;
  420. bool      isStarted    = false;
  421. int       currentPhase = 0;
  422. TestPhase allPhases[noOfTests];
  423. Uint32    signalToEcho;
  424. NDB_TICKS startTime, stopTime;
  426. void
  427. client(NodeId remoteNodeId){
  428.   isClient = true;
  430.   currentPhase = 0;
  431.   memcpy(allPhases, testSpec, sizeof(testSpec));
  433.   int counter = 0;
  435.   while(true){
  436.     TestPhase * current = &allPhases[currentPhase];
  437.     if(current->noOfSignals == current->noOfSignalSent &&
  438.        current->noOfSignals == current->noOfSignalReceived){
  440.       /**
  441.        * Test phase done
  442.        */
  443.       current->stopTime  = NdbTick_CurrentMillisecond();
  444.       current->accTime  += (current->stopTime - current->startTime);
  446.       NdbSleep_MilliSleep(500 / loopCount);
  447.       
  448.       current->startTime = NdbTick_CurrentMillisecond();
  449.       
  450.       current->noOfSignalSent     = 0;
  451.       current->noOfSignalReceived = 0;
  453.       current->loopCount ++;
  454.       if(current->loopCount == loopCount){
  456. printReport(allPhases[currentPhase]);
  458. currentPhase ++;
  459. if(currentPhase == noOfTests){
  460.   /**
  461.    * Now we are done
  462.    */
  463.   break;
  464. }
  465. NdbSleep_MilliSleep(500);
  466. current = &allPhases[currentPhase];
  467. current->startTime = NdbTick_CurrentMillisecond();
  468.       }
  469.     } 
  470.     int signalsLeft = current->noOfSignals - current->noOfSignalSent;
  471.     if(signalsLeft > 0){
  472.       for(; signalsLeft > 1; signalsLeft--){
  473. if(sendSignalTo(remoteNodeId, current->signalSize, 1) == SEND_OK) {
  474.   current->noOfSignalSent++;
  475.   //   ndbout << "sent prio b" << endl;
  476.   current->bytesSentBeforePrioA += (current->signalSize << 2);
  477. }
  478. else {
  479.   tReg->external_IO(10);
  480.   break;
  481. }
  482.       }
  483.       //prio A
  484.       if(signalsLeft==1) {
  485. NDB_TICKS sec = 0;
  486. Uint32 micro=0;
  487. int ret = NdbTick_CurrentMicrosecond(&sec,&micro);
  488. if(ret==0)
  489.   current->startTimePrioA  = micro + sec*1000000;
  490. if(sendSignalTo(remoteNodeId, current->signalSize, 0) == SEND_OK) {
  491.   current->noOfSignalSent++;
  492.   signalsLeft--;
  493. }
  494. else {
  495.   tReg->external_IO(10);
  496.   break;
  497. }
  498.       }
  499.     }
  500.     
  501.     if(counter % 10 == 0)
  502.       tReg->checkConnections();
  503.     tReg->external_IO(0);
  504.     counter++;
  505.   }
  506. }
  508. void 
  509. server(){
  510.   isClient = false;
  511.   
  512.   signalToEcho = 0;
  513.   for(int i = 0; i<noOfTests; i++)
  514.     signalToEcho += testSpec[i].noOfSignals;
  515.   
  516.   signalToEcho *= loopCount;
  517.   
  518.   while(signalToEcho > 0){
  519.     tReg->checkConnections();
  520.     for(int i = 0; i<10; i++)
  521.       tReg->external_IO(10);
  522.   }
  523. }
  525. int
  526. prioTransporterTest(TestType tt, const char * progName, 
  527.     int argc, const char **argv){
  528.   
  529.   loopCount = 100;
  530.   sendBufSz = -1;
  531.   recvBufSz = -1;
  532.   
  533.   isClient     = false;
  534.   isConnected  = false;
  535.   isStarted    = false;
  536.   currentPhase = 0;
  538.   signalHandler(0);
  539.   
  540.   if(argc < 4){
  541.     usage(progName);
  542.     return 0;
  543.   }
  544.   
  545.   const NodeId localNodeId   = atoi(argv[1]);
  546.   const char * localHostName = argv[2];
  547.   const char * remoteHost1   = argv[3];
  548.   
  549.   if(argc >= 5)
  550.     loopCount = atoi(argv[4]);
  551.   if(argc >= 6)
  552.     sendBufSz = atoi(argv[5]);
  553.   if(argc >= 7)
  554.     recvBufSz = atoi(argv[6]);
  556.   if(localNodeId < 1 || localNodeId > 2){
  557.     ndbout << "localNodeId = " << localNodeId << endl << endl;
  558.     usage(progName);
  559.     return 0;
  560.   }
  561.   
  562.   if(localNodeId == 1)
  563.     ndbout << "-- ECHO CLIENT --" << endl;
  564.   else
  565.     ndbout << "-- ECHO SERVER --" << endl;
  567.   ndbout << "localNodeId:           " << localNodeId << endl;
  568.   ndbout << "localHostName:         " << localHostName << endl;
  569.   ndbout << "remoteHost1 (node " << (localNodeId == 1?2:1) << "): " 
  570.  << remoteHost1 << endl;
  571.   ndbout << "Loop count: " << loopCount << endl;
  572.   ndbout << "-----------------" << endl;
  573.   
  574.   void * confTemplate = 0;
  575.   CreateTransporterFunc func = 0;
  576.   switch(tt){
  577.   case TestTCP:
  578.     func = createTCPTransporter;
  579.     confTemplate = &tcpTemplate;
  580.     break;
  581.   case TestOSE:
  582.     func = createOSETransporter;
  583.     confTemplate = &oseTemplate;
  584.     break;
  585.   case TestSCI:
  586.     func = createSCITransporter;
  587.     confTemplate = &sciTemplate;
  588.     break;
  589.   case TestSHM:
  590.     func = createSHMTransporter;
  591.     confTemplate = &shmTemplate;
  592.     break;
  593.   default:
  594.     ndbout << "Unsupported transporter type" << endl;
  595.     return 0;
  596.   }
  597.   
  598.   ndbout << "Creating transporter registry" << endl;
  599.   tReg = new TransporterRegistry;
  600.   tReg->init(localNodeId);
  601.   
  602.   switch(localNodeId){
  603.   case 1:
  604.     (* func)(confTemplate, 1, 2, localHostName, remoteHost1, 
  605.      sendBufSz, recvBufSz);
  606.     break;
  607.   case 2:
  608.     (* func)(confTemplate, 2, 1, localHostName, remoteHost1,
  609.      sendBufSz, recvBufSz);
  610.     break;
  611.   }
  612.   
  613.   ndbout << "Doing startSending/startReceiving" << endl;
  614.   tReg->startSending();
  615.   tReg->startReceiving();
  616.   
  617.   ndbout << "Connecting" << endl;
  618.   tReg->setPerformState(PerformConnect);
  619.   tReg->checkConnections();
  621.   if(localNodeId == 1)
  622.     client(2);
  623.   else
  624.     server();
  625.     
  626.   isStarted = false;
  627.   
  628.   ndbout << "Sleep 3 secs" << endl;
  629.   NdbSleep_SecSleep(3);
  631.   ndbout << "Doing setPerformState(Disconnect)" << endl;
  632.   tReg->setPerformState(PerformDisconnect);
  633.   
  634.   ndbout << "Doing checkConnections()" << endl;
  635.   tReg->checkConnections();
  636.     
  637.   ndbout << "Deleting transporter registry" << endl;
  638.   delete tReg; tReg = 0;
  639.   
  640.   return 0;
  641. }
  643. NdbOut & operator <<(NdbOut & out, SignalHeader & sh){
  644.   out << "-- Signal Header --" << endl;
  645.   out << "theLength:    " << sh.theLength << endl;
  646.   out << "gsn:          " << sh.theVerId_signalNumber << endl;
  647.   out << "recBlockNo:   " << sh.theReceiversBlockNumber << endl;
  648.   out << "sendBlockRef: " << sh.theSendersBlockRef << endl;
  649.   out << "sendersSig:   " << sh.theSendersSignalId << endl;
  650.   out << "theSignalId:  " << sh.theSignalId << endl;
  651.   out << "trace:        " << (int)sh.theTrace << endl;
  652.   return out;
  653. } 
  655. void
  656. execute(SignalHeader * const header, Uint8 prio, Uint32 * const theData){
  657.   const NodeId nodeId = refToNode(header->theSendersBlockRef);
  658.   NDB_TICKS sec = 0;
  659.   Uint32 micro=0;
  660.   int ret = NdbTick_CurrentMicrosecond(&sec,&micro);
  661.   if(prio == 0 && isClient && ret == 0) {
  662.     allPhases[currentPhase].stopTimePrioA  = micro + sec*1000000;
  663.     allPhases[currentPhase].totTimePrioA += 
  664.       allPhases[currentPhase].stopTimePrioA -  
  665.       allPhases[currentPhase].startTimePrioA;
  666.   }
  667.   if(ret!=0)
  668.     allPhases[currentPhase].totTimePrioA = -1;
  670.   if(isClient){
  671.     allPhases[currentPhase].noOfSignalReceived++;
  672.   } else {
  673.     int sleepTime = 10;
  674.     while(tReg->prepareSend(header, prio, theData, nodeId) != SEND_OK){
  675.       ndbout << "Failed to echo" << sleepTime << endl;
  676.       NdbSleep_MilliSleep(sleepTime);
  677.       // sleepTime += 10;
  678.     }
  679.     
  680.     signalToEcho--;
  681.   }
  682. }
  684. void
  685. reportError(NodeId nodeId, TransporterError errorCode){
  686.   char buf[255];
  687.   sprintf(buf, "reportError (%d, %x) in perfTest", nodeId, errorCode);
  688.   ndbout << buf << endl;
  689.   if(errorCode & 0x8000){
  690.     tReg->setPerformState(nodeId, PerformDisconnect);
  691.   }
  692. }
  694. /**
  695.  * Report average send theLength in bytes (4096 last sends)
  696.  */
  697. void
  698. reportSendLen(NodeId nodeId, Uint32 count, Uint64 bytes){
  699.   allPhases[currentPhase].sendCount    += count;
  700.   allPhases[currentPhase].sendLenBytes += bytes;
  702.   if(!isClient){
  703.     ndbout << "reportSendLen(" << nodeId << ", " 
  704.    << (bytes/count) << ")" << endl;
  705.   }
  706. }
  708. /**
  709.  * Report average receive theLength in bytes (4096 last receives)
  710.  */
  711. void
  712. reportReceiveLen(NodeId nodeId, Uint32 count, Uint64 bytes){
  713.   allPhases[currentPhase].recvCount    += count;
  714.   allPhases[currentPhase].recvLenBytes += bytes;
  716.   if(!isClient){
  717.     ndbout << "reportReceiveLen(" << nodeId << ", " 
  718.    << (bytes/count) << ")" << endl;
  719.   }
  720. }
  722. /**
  723.  * Report connection established
  724.  */
  725. void
  726. reportConnect(NodeId nodeId){
  727.   char buf[255];
  728.   sprintf(buf, "reportConnect(%d)", nodeId);
  729.   ndbout << buf << endl;
  730.   tReg->setPerformState(nodeId, PerformIO);
  731.   
  732.   if(!isStarted){
  733.     isStarted = true;
  734.     startTime = NdbTick_CurrentMillisecond();
  735.     if(isClient){
  736.       reportHeader();
  737.       allPhases[0].startTime = startTime;
  738.     }
  739.   }
  740.   else{
  741.     // Resend signals that were lost when connection failed
  742.     TestPhase * current = &allPhases[currentPhase];
  743.     current->noOfSignalSent = current->noOfSignalReceived;
  744.   }
  745. }
  747. /**
  748.  * Report connection broken
  749.  */
  750. void
  751. reportDisconnect(NodeId nodeId, Uint32 errNo){
  752.   char buf[255];
  753.   sprintf(buf, "reportDisconnect(%d)", nodeId);
  754.   ndbout << buf << endl;
  755.   
  756.   if(isStarted)
  757.     tReg->setPerformState(nodeId, PerformConnect);
  758. }
  761. int
  762. checkJobBuffer() {
  763.   /** 
  764.    * Check to see if jobbbuffers are starting to get full
  765.    * and if so call doJob
  766.    */
  767.   return 0;
  768. }