testLongSig.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:9k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include <ndb_global.h>
  14. #include <editline/editline.h>
  15. #include <SignalSender.hpp>
  16. void
  17. print_help(){
  18.   ndbout << "The test menu" << endl;
  19.   ndbout << "1 - Sending of long signals w/ segmented sections" << endl;
  20.   ndbout << "2 - As 1 but using receiver group" << endl;
  21.   ndbout << "3 - Sending of long signals w/ linear sections" << endl;
  22.   ndbout << "4 - As 3 but using receiver group" << endl;
  23.   ndbout << "5 - Sending of manually fragmented signals w/ segmented sections" 
  24.  << endl;
  25.   ndbout << "6 - As 5 but using receiver group" << endl;
  26.   ndbout << "7 - Sending of manually fragmented signals w/ linear sections" 
  27.  << endl;
  28.   ndbout << "8 - As but using receiver group" << endl;
  29.   
  30.   ndbout << "9 - Sending of CONTINUEB fragmented signals w/ segmented sections" 
  31.  << endl;
  32.   ndbout << "10 - As 9 but using receiver group" << endl;
  33.   ndbout << "11 - Sending of CONTINUEB fragmented signals w/ linear sections" 
  34.  << endl;
  35.   ndbout << "12 - As but using receiver group" << endl;
  36.   ndbout << "13 - Send 100 * 1000 25 len signals wo/ sections" << endl;
  37.   ndbout << "r - Recive signal from anyone" << endl;
  38.   ndbout << "a - Run tests 1 - 12 with variable sizes - 10 loops" << endl;
  39.   ndbout << "b - Run tests 1 - 12 with variable sizes - 100 loops" << endl;
  40.   ndbout << "c - Run tests 1 - 12 with variable sizes - 1000k loops" << endl;
  41. }
  42. void runTest(SignalSender &, Uint32 i, bool verbose);
  43. static
  44. int
  45. randRange(Uint32 min, Uint32 max){
  46.   float r = rand();
  47.   float f = (max - min + 1);
  48.   float d = (float)RAND_MAX + 1.0;
  49.   return min + (int)(f * r / d);
  50. }
  51. static
  52. int
  53. randRange(const Uint32 odds[], Uint32 count){
  54.   Uint32 val = randRange((Uint32)0, 100);
  55.   
  56.   Uint32 i = 0;
  57.   Uint32 sum = 0;
  58.   while(sum <= val && i < count){
  59.     sum += odds[i];
  60.     i++;
  61.   }
  62.   return i - 1;
  63. }
  64. int
  65. main(void){
  66.   srand(NdbTick_CurrentMillisecond());
  67. #if 0
  68.   for(int i = 0; i<100; i++)
  69.     ndbout_c("randRange(0, 3) = %d", randRange(0, 3));
  70.   return 0;
  71. #endif
  72.   SignalSender ss;
  73.   
  74.   ndbout << "Connecting...";
  75.   if(!ss.connect(30)){
  76.     ndbout << "failed" << endl << "Exiting" << endl;
  77.     return 0;
  78.   }
  79.   ndbout << "done" << endl;
  80.   ndbout_c("Connected as block=%d node=%d",
  81.    refToBlock(ss.getOwnRef()), refToNode(ss.getOwnRef()));
  82.   
  83.   Uint32 data[25];
  84.   Uint32 sec0[70];
  85.   Uint32 sec1[123];
  86.   Uint32 sec2[10];
  87.   
  88.   data[0] = ss.getOwnRef();
  89.   data[1] = 1;
  90.   data[2] = 76; 
  91.   data[3] = 1;
  92.   data[4] = 1;
  93.   data[5] = 70;
  94.   data[6] = 123;
  95.   data[7] = 10;
  96.   const Uint32 theDataLen = 18;
  97.   for(Uint32 i = 0; i<70; i++)
  98.     sec0[i] = i;
  99.   
  100.   for(Uint32 i = 0; i<123; i++)
  101.     sec1[i] = 70+i;
  102.   for(Uint32 i = 0; i<10; i++)
  103.     sec2[i] = (i + 1)*(i + 1);
  104.   
  105.   SimpleSignal signal1;
  106.   signal1.set(ss, 0, CMVMI, GSN_TESTSIG, theDataLen + 2);  
  107.   signal1.header.m_noOfSections = 1;
  108.   signal1.header.m_fragmentInfo = 1;
  109.   memcpy(&signal1.theData[0], data, 4 * theDataLen );
  110.   signal1.theData[theDataLen + 0] = 0;
  111.   signal1.theData[theDataLen + 1] = 7; // FragmentId
  112.   
  113.   signal1.ptr[0].sz = 60;
  114.   signal1.ptr[0].p = &sec0[0];
  115.   
  116.   SimpleSignal signal2;
  117.   
  118.   Uint32 idx = 0;
  119.   memcpy(&signal2.theData[0], data, 4 * theDataLen );
  120.   signal2.theData[theDataLen + idx] = 0; idx++;
  121.   signal2.theData[theDataLen + idx] = 1; idx++;
  122.   //signal2.theData[theDataLen + idx] = 2; idx++;
  123.   signal2.theData[theDataLen + idx] = 7; idx++; // FragmentId
  124.   signal2.set(ss, 0, CMVMI, GSN_TESTSIG, theDataLen + idx);
  125.   signal2.header.m_fragmentInfo = 3;
  126.   signal2.header.m_noOfSections = idx - 1;
  127.   
  128.   signal2.ptr[0].sz = 10;
  129.   signal2.ptr[0].p = &sec0[60];
  130.   
  131.   signal2.ptr[1].sz = 123;
  132.   signal2.ptr[1].p = &sec1[0];
  133.   
  134.   signal2.ptr[2].sz = 10;
  135.   signal2.ptr[2].p = &sec2[0];
  136.   
  137.   char * buf;
  138.   while((buf = readline("Enter command: "))){
  139.     add_history(buf);
  140.     data[1] = atoi(buf);
  141.     if(strcmp(buf, "r") == 0){
  142.       SimpleSignal * ret1 = ss.waitFor();
  143.       (* ret1).print();
  144.       delete ret1;
  145.       continue;
  146.     }
  147.     if(strcmp(buf, "a") == 0){
  148.       runTest(ss, 10, true);
  149.       print_help();
  150.       continue;
  151.     }
  152.     if(strcmp(buf, "b") == 0){
  153.       runTest(ss, 100, false);
  154.       print_help();
  155.       continue;
  156.     }
  157.     if(strcmp(buf, "c") == 0){
  158.       runTest(ss, 1000000, false);
  159.       print_help();
  160.       continue;
  161.     }
  162.     
  163.     if(data[1] >= 1 && data[1] <= 12){
  164.       Uint32 nodeId = ss.getAliveNode();
  165.       ndbout_c("Sending 2 fragmented to node %d", nodeId);
  166.       ss.sendSignal(nodeId, &signal1);
  167.       ss.sendSignal(nodeId, &signal2);
  168.       if(data[1] >= 5){
  169. continue;
  170.       }
  171.       ndbout_c("Waiting for signal from %d", nodeId);
  172.       
  173.       SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
  174.       (* ret1).print();
  175.       Uint32 count = ret1->theData[4] - 1;
  176.       delete ret1;
  177.       while(count > 0){
  178. ndbout << "Waiting for " << count << " signals... ";
  179. SimpleSignal * ret1 = ss.waitFor();
  180. ndbout_c("received from node %d", 
  181.  refToNode(ret1->header.theSendersBlockRef));
  182. (* ret1).print();
  183. delete ret1;
  184. count--;
  185.       }
  186.     } else if (data[1] == 13) {
  187.       const Uint32 count = 3500;
  188.       const Uint32 loop = 1000;
  189.       signal1.set(ss, 0, CMVMI, GSN_TESTSIG, 25);
  190.       signal1.header.m_fragmentInfo = 0;
  191.       signal1.header.m_noOfSections = 0;
  192.       signal1.theData[1] = 14; 
  193.       signal1.theData[3] = 0;   // Print
  194.       signal1.theData[8] = count;
  195.       signal1.theData[9] = loop;
  196.       Uint32 nodeId = ss.getAliveNode();
  197.       ndbout_c("Sending 25 len signal to node %d", nodeId);
  198.       ss.sendSignal(nodeId, &signal1);
  199.       Uint32 total;
  200.       {
  201. SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
  202. ndbout_c("received from node %d", 
  203.  refToNode(ret1->header.theSendersBlockRef));
  204. total = ret1->theData[10] - 1;
  205. delete ret1;
  206.       }
  207.       do {
  208. ndbout << "Waiting for " << total << " signals... " << flush;
  209. SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
  210. ndbout_c("received from node %d", 
  211.  refToNode(ret1->header.theSendersBlockRef));
  212. delete ret1;
  213. total --;
  214.       } while(total > 0);
  215.     } else {
  216.       print_help();
  217.     }
  218.   }
  219.   ndbout << "Exiting" << endl;
  220. };
  221. void
  222. runTest(SignalSender & ss, Uint32 count, bool verbose){
  223.   
  224.   SimpleSignal sig;
  225.   Uint32 sec0[256];
  226.   Uint32 sec1[256];
  227.   Uint32 sec2[256];
  228.   for(Uint32 i = 0; i<256; i++){
  229.     sec0[i] = i;
  230.     sec1[i] = i + i;
  231.     sec2[i] = i * i;
  232.   }
  233.   sig.theData[0] = ss.getOwnRef();
  234.   sig.theData[1] = 1;   // TestType
  235.   sig.theData[2] = 128; // FragSize
  236.   sig.theData[3] = 0;   // Print
  237.   sig.theData[4] = 1;   // RetCount
  238.   
  239.   sig.ptr[0].p = &sec0[0];
  240.   sig.ptr[1].p = &sec1[0];
  241.   sig.ptr[2].p = &sec2[0];
  242.   for(unsigned loop = 0; loop < count; loop++){
  243.     const Uint32 odds[] =  { 5, 40, 30, 25 };
  244.     const Uint32 secs = randRange(odds, 4);
  245.     sig.ptr[0].sz = randRange(1, 256);
  246.     sig.ptr[1].sz = randRange(1, 256);
  247.     sig.ptr[2].sz = randRange(1, 256);
  248.     sig.header.m_noOfSections = secs;
  249.     const Uint32 len = 5 + (secs > 0 ? 1 : 0) * (25 - 5 - 7);
  250.     sig.set(ss, 0, CMVMI, GSN_TESTSIG, len);
  251.     ndbout << "Loop " << loop << " #secs = " << secs << " sizes = [ ";
  252.     unsigned min = 256;
  253.     unsigned max = 0;
  254.     unsigned sum = 0;
  255.     for(unsigned i = 0; i<secs; i++){
  256.       const Uint32 sz = sig.ptr[i].sz;
  257.       ndbout << sz << " ";
  258.       min = (min < sz ? min : sz);
  259.       max = (max > sz ? max : sz);
  260.       sum += sz;
  261.       sig.theData[5+i] = sz;
  262.     }
  263.     ndbout_c("] len = %d", len);
  264.     for(int test = 1; test <= 12; test++){
  265.       sig.theData[1] = test;
  266.       Uint32 nodeId = ss.getAliveNode();
  267.       if(verbose){
  268. ndbout << "  Test " << test << " node " << nodeId << "...";
  269. fflush(stdout);
  270.       }
  271.       SendStatus r = ss.sendSignal(nodeId, &sig);
  272.       assert(r == SEND_OK);
  273.       if(test < 5){
  274. SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
  275. Uint32 count = ret1->theData[4] - 1;
  276. delete ret1;
  277. while(count > 0){
  278.   SimpleSignal * ret1 = ss.waitFor();
  279.   delete ret1;
  280.   count--;
  281. }
  282. if(verbose)
  283.   ndbout << "done" << endl;
  284.       } else {
  285. Uint32 nodes = ss.getNoOfConnectedNodes();
  286. Uint32 sum2 = 0;
  287. if((test & 1) == 1) 
  288.   nodes = 1;
  289. while(nodes > 0){
  290.   SimpleSignal * ret = ss.waitFor();
  291.   if(ret->header.m_fragmentInfo == 0){
  292.     for(Uint32 i = 0; i<ret->header.m_noOfSections; i++)
  293.       sum2 += ret->ptr[i].sz;
  294.   } else {
  295.     for(Uint32 i = 0; i<ret->header.m_noOfSections; i++)
  296.       if(ret->theData[i] != 3)
  297. sum2 += ret->ptr[i].sz;
  298.   }
  299.   if(ret->header.m_fragmentInfo == 0 ||
  300.      ret->header.m_fragmentInfo == 3){
  301.     nodes--;
  302.   }
  303.   delete ret;
  304. }
  305. if(verbose)
  306.   ndbout_c("done sum=%d sum2=%d", sum, sum2);
  307.       }
  308.     }
  309.   }
  310. }