MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
perfTransporterTest.cpp
1 /*
2  Copyright (C) 2003-2006 MySQL AB
3  All rights reserved. Use is subject to license terms.
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; version 2 of the License.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 
19 #include <ndb_global.h>
20 
21 #include "TransporterRegistry.hpp"
22 #include "TransporterDefinitions.hpp"
23 #include "TransporterCallback.hpp"
24 #include <RefConvert.hpp>
25 
26 #include <NdbTick.h>
27 #include <NdbMain.h>
28 #include <NdbOut.hpp>
29 #include <NdbSleep.h>
30 
31 int basePortTCP = 17000;
32 
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 };
47 
48 
49 SHM_TransporterConfiguration shmTemplate = {
50  0, //remoteNodeId
51  0, //localNodeId;
52  false, //compression
53  true, //checksum;
54  true, //signalId;
55  0, //byteOrder;
56  123, //shmKey;
57  25000000 //shmSize;
58 };
59 
60 
61 TCP_TransporterConfiguration tcpTemplate = {
62  17000, // port;
63  "", // remoteHostName;
64  "", // localhostname
65  2, // remoteNodeId;
66  1, // localNodeId;
67  25000000, // sendBufferSize - Size of SendBuffer of priority B
68  5000000, // maxReceiveSize - Maximum no of bytes to receive
69  0, // byteOrder;
70  false, // compression;
71  true, // checksum;
72  true // signalId;
73 };
74 
75 TransporterRegistry *tReg = 0;
76 
77 #include <signal.h>
78 
79 extern "C"
80 void
81 signalHandler(int signo){
82  ::signal(13, signalHandler);
83  char buf[255];
84  sprintf(buf,"Signal: %d\n", signo);
85  ndbout << buf << endl;
86 }
87 
88 void
89 usage(const char * progName){
90  ndbout << "Usage: " << progName << " <type> localNodeId localHostName"
91  << " remoteHostName"
92  << " [<loop count>] [<send buf size>] [<recv buf size>]" << endl;
93  ndbout << " type = shm tcp ose sci" << endl;
94  ndbout << " localNodeId - {1,2}" << endl;
95 }
96 
97 typedef void (* CreateTransporterFunc)(void * conf,
98  NodeId localNodeId,
99  NodeId remoteNodeId,
100  const char * localHostName,
101  const char * remoteHostName,
102  int sendBuf,
103  int recvBuf);
104 
105 void
106 createTCPTransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
107 void
108 createSHMTransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
109 void
110 createSCITransporter(void*, NodeId, NodeId, const char*, const char*, int, int);
111 
112 struct TestPhase {
113  int signalSize;
114  int noOfSignals;
115  int noOfSignalSent;
116  int noOfSignalReceived;
117  NDB_TICKS startTime;
118  NDB_TICKS stopTime;
119  NDB_TICKS accTime;
120  int loopCount;
121  Uint64 sendLenBytes, sendCount;
122  Uint64 recvLenBytes, recvCount;
123 };
124 
125 TestPhase testSpec[] = {
126  { 1, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word
127  ,{ 1, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word
128  ,{ 1, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word
129  ,{ 1, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word
130 
131  ,{ 8, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word
132  ,{ 8, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word
133  ,{ 8, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word
134  ,{ 8, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word
135 
136  ,{ 16, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word
137  ,{ 16, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word
138  ,{ 16, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word
139  ,{ 16, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word
140 
141  ,{ 24, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word
142  ,{ 24, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word
143  ,{ 24, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word
144  ,{ 24, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word
145 
146  ,{ 0, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of random size
147  ,{ 0, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of random size
148  ,{ 0, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of random size
149  ,{ 0, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of random size
150 
151  ,{ 100, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals
152  ,{ 100, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals
153  ,{ 100, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals
154  ,{ 100, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals
155 
156  ,{ 500, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals
157  ,{ 500, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals
158  ,{ 500, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals
159  ,{ 500, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals
160 
161  ,{ 1000, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals
162  ,{ 1000, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals
163  ,{ 1000, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals
164  ,{ 1000, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals
165 };
166 
167 const int noOfTests = sizeof(testSpec)/sizeof(TestPhase);
168 
169 Uint32 StaticBuffer[1000];
170 
171 SendStatus
172 sendSignalTo(NodeId nodeId, int signalSize, Uint32 count){
173  if(signalSize == 0)
174  signalSize = (rand() % 25) + 1;
175 
176  SignalHeader sh;
177  sh.theLength = (signalSize > 25 ? 25 : signalSize);
178  sh.theVerId_signalNumber = count;
179  sh.theReceiversBlockNumber = rand();
180  sh.theSendersBlockRef = rand();
181  sh.theSendersSignalId = rand();
182  sh.theSignalId = rand();
183  sh.theTrace = rand();
184 
185  Uint32 theData[25];
186  for(int i = 0; i<25; i++)
187  theData[i] = (i+1) * (Uint32)(&theData[i]);
188 
189  theData[0] = count;
190  LinearSectionPtr ptr[3];
191 
192  if(signalSize <= 25){
193  sh.m_noOfSections = 0;
194  } else {
195  sh.m_noOfSections = 1;
196  ptr[0].sz = signalSize - 25;
197  ptr[0].p = &StaticBuffer[0];
198  }
199 
200  return tReg->prepareSend(&sh, 1, theData, nodeId, ptr);
201 }
202 
203 void
204 reportHeader(){
205  ndbout << "#Sigs\tSz\tTime\tSig/sec\tBps\tBps-tot\t"
206  << "s len\tr len" << endl;
207 }
208 
209 void
210 print(char * dst, int i){
211  if(i > 1000000){
212  const int d = i / 1000000;
213  const int r = (i - (d * 1000000)) / 100000;
214  if(d < 100)
215  sprintf(dst, "%d.%dM", d, r);
216  else
217  sprintf(dst, "%dM", d);
218  } else if(i > 1000){
219  const int d = i / 1000;
220  const int r = (i - (d * 1000)) / 100;
221  if(d < 100)
222  sprintf(dst, "%d.%dk", d, r);
223  else
224  sprintf(dst, "%dk", d);
225  } else {
226  sprintf(dst, "%d", i);
227  }
228 }
229 
230 void
231 printReport(TestPhase & p){
232  if(p.accTime > 0) {
233  Uint32 secs = (p.accTime/p.loopCount)/1000;
234  Uint32 mill = (p.accTime/p.loopCount)%1000;
235  char st[255];
236  if(secs > 0){
237  sprintf(st, "%d.%.2ds", secs, (mill/10));
238  } else {
239  sprintf(st, "%dms", mill);
240  }
241 
242  Uint32 sps = (1000*p.noOfSignals*p.loopCount)/p.accTime;
243  Uint32 dps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*p.signalSize);
244  Uint32 bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(p.signalSize+3));
245  if(p.signalSize == 0){
246  dps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13));
247  bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13+3));
248  }
249  char ssps[255];
250  char sbps[255];
251  char sdps[255];
252 
253  print(ssps, sps);
254  print(sbps, bps);
255  print(sdps, dps);
256 
257 
258  char buf[255];
259  if(p.signalSize != 0){
260  BaseString::snprintf(buf, 255,
261  "%d\t%d\t%s\t%s\t%s\t%s\t%d\t%d",
262  p.noOfSignals,
263  4*p.signalSize,
264  st,
265  ssps,
266  sdps,
267  sbps,
268  (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)),
269  (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)));
270  } else {
271  BaseString::snprintf(buf, 255,
272  "%d\trand\t%s\t%s\t%s\t%s\t%d\t%d",
273  p.noOfSignals,
274  st,
275  ssps,
276  sdps,
277  sbps,
278  (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)),
279  (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)));
280 
281  }
282  ndbout << buf << endl;
283  }
284 }
285 
286 int loopCount = 1;
287 int sendBufSz = -1;
288 int recvBufSz = -1;
289 
290 bool isClient = false;
291 bool isConnected = false;
292 bool isStarted = false;
293 int currentPhase = 0;
294 TestPhase allPhases[noOfTests];
295 Uint32 signalToEcho;
296 Uint32 signalsEchoed;
297 NDB_TICKS startTime, stopTime;
298 
299 void
300 client(NodeId remoteNodeId){
301  isClient = true;
302 
303  currentPhase = 0;
304  memcpy(allPhases, testSpec, sizeof(testSpec));
305 
306  int counter = 0;
307  int sigCounter = 0;
308 
309  while(true){
310  TestPhase * current = &allPhases[currentPhase];
311  if(current->noOfSignals == current->noOfSignalSent &&
312  current->noOfSignals == current->noOfSignalReceived){
313 
317  current->stopTime = NdbTick_CurrentMillisecond();
318  current->accTime += (current->stopTime - current->startTime);
319 
320  NdbSleep_MilliSleep(500 / loopCount);
321 
322  current->startTime = NdbTick_CurrentMillisecond();
323 
324  current->noOfSignalSent = 0;
325  current->noOfSignalReceived = 0;
326 
327  current->loopCount ++;
328  if(current->loopCount == loopCount){
329 
330  printReport(allPhases[currentPhase]);
331 
332  currentPhase ++;
333  if(currentPhase == noOfTests){
337  break;
338  }
339  NdbSleep_MilliSleep(500);
340  current = &allPhases[currentPhase];
341  current->startTime = NdbTick_CurrentMillisecond();
342  }
343  }
344 
345  int signalsLeft = current->noOfSignals - current->noOfSignalSent;
346  if(signalsLeft > 0){
347  for(; signalsLeft > 0; signalsLeft--){
348  if(sendSignalTo(remoteNodeId,current->signalSize,sigCounter)== SEND_OK){
349  current->noOfSignalSent++;
350  sigCounter++;
351  } else {
352  ndbout << "Failed to send: " << sigCounter << endl;
353  tReg->external_IO(10);
354  break;
355  }
356  }
357  }
358  if(counter % 10 == 0)
359  tReg->checkConnections();
360  tReg->external_IO(0);
361  counter++;
362  }
363 }
364 
365 void
366 server(){
367  isClient = false;
368 
369  signalToEcho = 0;
370  signalsEchoed = 0;
371  for(int i = 0; i<noOfTests; i++)
372  signalToEcho += testSpec[i].noOfSignals;
373 
374  signalToEcho *= loopCount;
375 
376  while(signalToEcho > signalsEchoed){
377  tReg->checkConnections();
378  for(int i = 0; i<10; i++)
379  tReg->external_IO(10);
380  }
381 }
382 
383 int
384 main(int argc, const char **argv){
385 
386  const char * progName = argv[0];
387 
388  loopCount = 100;
389  sendBufSz = -1;
390  recvBufSz = -1;
391 
392  isClient = false;
393  isConnected = false;
394  isStarted = false;
395  currentPhase = 0;
396 
397  signalHandler(0);
398 
399  if(argc < 5){
400  usage(progName);
401  return 0;
402  }
403 
404  const char * type = argv[1];
405  const NodeId localNodeId = atoi(argv[2]);
406  const char * localHostName = argv[3];
407  const char * remoteHost1 = argv[4];
408 
409  if(argc >= 6)
410  loopCount = atoi(argv[5]);
411  if(argc >= 7)
412  sendBufSz = atoi(argv[6]);
413  if(argc >= 8)
414  recvBufSz = atoi(argv[7]);
415 
416  if(localNodeId < 1 || localNodeId > 2){
417  ndbout << "localNodeId = " << localNodeId << endl << endl;
418  usage(progName);
419  return 0;
420  }
421 
422  if(localNodeId == 1)
423  ndbout << "-- ECHO CLIENT --" << endl;
424  else
425  ndbout << "-- ECHO SERVER --" << endl;
426 
427  ndbout << "localNodeId: " << localNodeId << endl;
428  ndbout << "localHostName: " << localHostName << endl;
429  ndbout << "remoteHost1 (node " << (localNodeId == 1?2:1) << "): "
430  << remoteHost1 << endl;
431  ndbout << "Loop count: " << loopCount << endl;
432  ndbout << "-----------------" << endl;
433 
434  void * confTemplate = 0;
435  CreateTransporterFunc func = 0;
436  if(strcasecmp(type, "tcp") == 0){
437  func = createTCPTransporter;
438  confTemplate = &tcpTemplate;
439  } else if(strcasecmp(type, "sci") == 0){
440  func = createSCITransporter;
441  confTemplate = &sciTemplate;
442  } else if(strcasecmp(type, "shm") == 0){
443  func = createSHMTransporter;
444  confTemplate = &shmTemplate;
445  } else {
446  ndbout << "Unsupported transporter type" << endl;
447  return 0;
448  }
449 
450  ndbout << "Creating transporter registry" << endl;
451  tReg = new TransporterRegistry;
452  tReg->init(localNodeId);
453 
454  switch(localNodeId){
455  case 1:
456  (* func)(confTemplate, 1, 2, localHostName, remoteHost1,
457  sendBufSz, recvBufSz);
458  break;
459  case 2:
460  (* func)(confTemplate, 2, 1, localHostName, remoteHost1,
461  sendBufSz, recvBufSz);
462  break;
463  }
464 
465  ndbout << "Doing startSending/startReceiving" << endl;
466  tReg->startSending();
467  tReg->startReceiving();
468 
469  ndbout << "Connecting" << endl;
470  tReg->setPerformState(PerformConnect);
471  tReg->checkConnections();
472 
473  if(localNodeId == 1)
474  client(2);
475  else
476  server();
477 
478  isStarted = false;
479 
480  ndbout << "Sleep 3 secs" << endl;
481  NdbSleep_SecSleep(3);
482 
483  ndbout << "Doing setPerformState(Disconnect)" << endl;
484  tReg->setPerformState(PerformDisconnect);
485 
486  ndbout << "Doing checkConnections()" << endl;
487  tReg->checkConnections();
488 
489  ndbout << "Deleting transporter registry" << endl;
490  delete tReg; tReg = 0;
491 
492  return 0;
493 }
494 
495 void
496 execute(void* callbackObj, SignalHeader * const header, Uint8 prio,
497  Uint32 * const theData,
498  LinearSectionPtr ptr[3]){
499  const NodeId nodeId = refToNode(header->theSendersBlockRef);
500 
501  if(isClient){
502  allPhases[currentPhase].noOfSignalReceived++;
503  } else {
504  int sleepTime = 10;
505  if(theData[0] != signalsEchoed){
506  ndbout << "Missing signal theData[0] = " << theData[0]
507  << " signalsEchoed = " << signalsEchoed << endl;
508  ndbout << (* header) << endl;
509  abort();
510  }
511  while(tReg->prepareSend(header, prio, theData, nodeId, ptr) != SEND_OK){
512  ndbout << "Failed to echo " << theData[0] << endl;
513  NdbSleep_MilliSleep(sleepTime);
514  // sleepTime += 10;
515  }
516  signalsEchoed++;
517  }
518 }
519 
520 void
521 copy(Uint32 * & insertPtr,
522  class SectionSegmentPool & thePool, const SegmentedSectionPtr & _ptr){
523  abort();
524 }
525 
526 void
527 reportError(void* callbackObj, NodeId nodeId, TransporterError errorCode){
528  char buf[255];
529  sprintf(buf, "reportError (%d, %x) in perfTest", nodeId, errorCode);
530  ndbout << buf << endl;
531  if(errorCode & 0x8000 && errorCode != 0x8014){
532  abort(); //tReg->setPerformState(nodeId, PerformDisconnect);
533  }
534 }
535 
539 void
540 reportSendLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){
541  allPhases[currentPhase].sendCount += count;
542  allPhases[currentPhase].sendLenBytes += bytes;
543 
544  if(!isClient){
545  ndbout << "reportSendLen(" << nodeId << ", "
546  << (bytes/count) << ")" << endl;
547  }
548 }
549 
553 void
554 reportReceiveLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){
555  allPhases[currentPhase].recvCount += count;
556  allPhases[currentPhase].recvLenBytes += bytes;
557 
558  if(!isClient){
559  ndbout << "reportReceiveLen(" << nodeId << ", "
560  << (bytes/count) << ")" << endl;
561  }
562 }
563 
567 void
568 reportConnect(void* callbackObj, NodeId nodeId){
569  char buf[255];
570  sprintf(buf, "reportConnect(%d)", nodeId);
571  ndbout << buf << endl;
572  tReg->setPerformState(nodeId, PerformIO);
573 
574  if(!isStarted){
575  isStarted = true;
576  startTime = NdbTick_CurrentMillisecond();
577  if(isClient){
578  reportHeader();
579  allPhases[0].startTime = startTime;
580  }
581  }
582  else{
583  // Resend signals that were lost when connection failed
584  TestPhase * current = &allPhases[currentPhase];
585  current->noOfSignalSent = current->noOfSignalReceived;
586  }
587 }
588 
592 void
593 reportDisconnect(void* callbackObj, NodeId nodeId, Uint32 errNo){
594  char buf[255];
595  sprintf(buf, "reportDisconnect(%d)", nodeId);
596  ndbout << buf << endl;
597 
598  if(isStarted)
599  tReg->setPerformState(nodeId, PerformConnect);
600 }
601 
602 
603 int
604 checkJobBuffer() {
609  return 0;
610 }
611 
612 void
613 createSCITransporter(void * _conf,
614  NodeId localNodeId,
615  NodeId remoteNodeId,
616  const char * localHostName,
617  const char * remoteHostName,
618  int sendbuf,
619  int recvbuf) {
620 
621 
622  ndbout << "Creating SCI transporter from node "
623  << localNodeId << "(" << localHostName << ") to "
624  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
625 
626 
627  SCI_TransporterConfiguration * conf = (SCI_TransporterConfiguration*)_conf;
628 
629  conf->remoteSciNodeId0= (Uint16)atoi(localHostName);
630  conf->remoteSciNodeId1= (Uint16)atoi(remoteHostName);
631 
632 
633  conf->localNodeId = localNodeId;
634  conf->remoteNodeId = remoteNodeId;
635 
636  bool res = tReg->createTransporter(conf);
637  if(res)
638  ndbout << "... -- Success " << endl;
639  else
640  ndbout << "... -- Failure " << endl;
641 }
642 
643 void
644 createSHMTransporter(void * _conf,
645  NodeId localNodeId,
646  NodeId remoteNodeId,
647  const char * localHostName,
648  const char * remoteHostName,
649  int sendbuf,
650  int recvbuf) {
651 
652 
653  ndbout << "Creating SHM transporter from node "
654  << localNodeId << "(" << localHostName << ") to "
655  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
656 
657 
658  SHM_TransporterConfiguration * conf = (SHM_TransporterConfiguration*)_conf;
659 
660 
661  conf->localNodeId = localNodeId;
662  conf->remoteNodeId = remoteNodeId;
663 
664  bool res = tReg->createTransporter(conf);
665  if(res)
666  ndbout << "... -- Success " << endl;
667  else
668  ndbout << "... -- Failure " << endl;
669 }
670 
671 
672 void
673 createTCPTransporter(void * _conf,
674  NodeId localNodeId,
675  NodeId remoteNodeId,
676  const char * localHostName,
677  const char * remoteHostName,
678  int sendBuf,
679  int recvBuf){
680  ndbout << "Creating TCP transporter from node "
681  << localNodeId << "(" << localHostName << ") to "
682  << remoteNodeId << "(" << remoteHostName << ")..." << endl;;
683 
684  TCP_TransporterConfiguration * conf = (TCP_TransporterConfiguration*)_conf;
685 
686  int port;
687  if(localNodeId == 1 && remoteNodeId == 2) port = basePortTCP + 0;
688  if(localNodeId == 1 && remoteNodeId == 3) port = basePortTCP + 1;
689  if(localNodeId == 2 && remoteNodeId == 1) port = basePortTCP + 0;
690  if(localNodeId == 2 && remoteNodeId == 3) port = basePortTCP + 2;
691  if(localNodeId == 3 && remoteNodeId == 1) port = basePortTCP + 1;
692  if(localNodeId == 3 && remoteNodeId == 2) port = basePortTCP + 2;
693 
694  if(sendBuf != -1){
695  conf->sendBufferSize = sendBuf;
696  }
697  if(recvBuf != -1){
698  conf->maxReceiveSize = recvBuf;
699  }
700 
701  ndbout << "\tSendBufferSize: " << conf->sendBufferSize << endl;
702  ndbout << "\tReceiveBufferSize: " << conf->maxReceiveSize << endl;
703 
704  conf->localNodeId = localNodeId;
705  conf->localHostName = localHostName;
706  conf->remoteNodeId = remoteNodeId;
707  conf->remoteHostName = remoteHostName;
708  conf->port = port;
709  bool res = tReg->createTransporter(conf);
710  if(res)
711  ndbout << "... -- Success " << endl;
712  else
713  ndbout << "... -- Failure " << endl;
714 }