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

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

MySQL数据库

开发平台：

Visual C++

failoverSCI.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 "sisci_types.h"
  20. #include "sisci_api.h"
  21. #include "sisci_error.h"
  22. //#include "sisci_demolib.h"
  23. #include <NdbTick.h>
  24. #include <NdbSleep.h>
  25. #define NO_CALLBACK         NULL
  26. #define NO_FLAGS            0
  27. #define DATA_TRANSFER_READY 8
  29. sci_error_t             error;
  30. sci_desc_t              sdOne;
  31. sci_desc_t              sdTwo;
  32. sci_local_segment_t     localSegmentOne;
  33. sci_local_segment_t     localSegmentTwo;
  34. sci_remote_segment_t    remoteSegmentOne;
  35. sci_remote_segment_t    remoteSegmentTwo;
  36. sci_map_t               localMapOne;
  37. sci_map_t               localMapTwo;
  38. sci_map_t               remoteMapOne;
  39. sci_map_t               remoteMapTwo;
  40. unsigned int            localAdapterNo = 0;
  41. unsigned int            standbyAdapterNo = 1;
  42. unsigned int            localNodeId1;
  43. unsigned int            localNodeId2;
  44. unsigned int            remoteNodeId1 = 0;
  45. unsigned int            remoteNodeId2 = 0;
  46. unsigned int            localSegmentId;
  47. unsigned int            remoteSegmentId1;
  48. unsigned int            remoteSegmentId2;
  49. unsigned int            segmentSize = 8192;
  50. unsigned int            offset = 0;
  51. unsigned int            client = 0;
  52. unsigned int            server = 0;
  53. unsigned int            *localbufferPtr;
  54. static int data;
  55. static int interruptConnected=0;
  57. /*********************************************************************************/
  58. /*                                U S A G E                                      */
  59. /*                                                                               */
  60. /*********************************************************************************/
  62. void Usage()
  63. {
  64.     printf("Usage of shmemn");
  65.     printf("shmem -rn <remote node-id> -client/server [ -adapterno <adapter no> -size <segment size> ] nn");
  66.     printf(" -rn               : Remote node-idn");
  67.     printf(" -client           : The local node is clientn");
  68.     printf(" -server           : The local node is servern");
  69.     printf(" -adapterno        : Local adapter number (default %d)n", localAdapterNo);
  70.     printf(" -size             : Segment block size   (default %d)n", segmentSize);
  71.     printf(" -help             : This helpscreenn");
  73.     printf("n");
  74. }
  77. /*********************************************************************************/
  78. /*                   P R I N T   P A R A M E T E R S                             */
  79. /*                                                                               */
  80. /*********************************************************************************/
  81. void PrintParameters(void)
  82. {
  84.     printf("Test parameters for %s n",(client) ?  "client" : "server" );
  85.     printf("----------------------------nn");
  86.     printf("Local node-id1      : %dn",localNodeId1);
  87.     printf("Local node-id2      : %dn",localNodeId2);
  88.     //    printf("Remote node-id     : %dn",remoteNodeId);
  89.     printf("Local adapter no.  : %dn",localAdapterNo);
  90.     printf("Segment size       : %dn",segmentSize);
  91.     printf("----------------------------nn");
  93. }
  96. /*********************************************************************************/
  97. /*                F I L L   S E G M E N T   W I T H   D A T A                    */
  98. /*                                                                               */
  99. /*********************************************************************************/
  101. sci_error_t GetLocalNodeId(Uint32 localAdapterNo, Uint32* localNodeId)
  102. {
  103.   sci_query_adapter_t queryAdapter;
  104.   sci_error_t  error;
  105.   unsigned int _localNodeId;
  106.   
  107.   queryAdapter.subcommand = SCI_Q_ADAPTER_NODEID;
  108.   queryAdapter.localAdapterNo = localAdapterNo;
  109.   queryAdapter.data = &_localNodeId;
  111.   SCIQuery(SCI_Q_ADAPTER,&queryAdapter,NO_FLAGS,&error);
  112.   
  113.   *localNodeId=_localNodeId;
  114.   
  115.   return error;
  116. }
  123. sci_error_t SendInterrupt(sci_desc_t   sd,
  124.       Uint32 localAdapterNo, 
  125.       Uint32 localSciNodeId, 
  126.       Uint32 remoteSciNodeId,
  127.       Uint32 interruptNo){
  128.   
  129.   sci_error_t             error;
  130.   sci_remote_interrupt_t  remoteInterrupt;
  131.   Uint32 timeOut = SCI_INFINITE_TIMEOUT;
  133.     // Now connect to the other sides interrupt flag 
  134.     do {
  135.       SCIConnectInterrupt(sd, &remoteInterrupt, remoteSciNodeId, localAdapterNo,
  136.   interruptNo, timeOut, NO_FLAGS, &error);
  137.     } while (error != SCI_ERR_OK);
  138.     
  139.     if (error != SCI_ERR_OK) {
  140.       fprintf(stderr, "SCIConnectInterrupt failed - Error code 0x%xn", error);
  141.       return error;
  142.     } 
  144.   // Trigger interrupt
  145.   printf("nNode %u sent interrupt (0x%x) to node %dn",localSciNodeId, interruptNo, remoteSciNodeId);
  146.   SCITriggerInterrupt(remoteInterrupt, NO_FLAGS, &error);
  147.   if (error != SCI_ERR_OK) {
  148.     fprintf(stderr, "SCITriggerInterrupt failed - Error code 0x%xn", error);
  149.     return error;
  150.   } 
  151.    
  153.     // Disconnect and remove interrupts 
  154.     SCIDisconnectInterrupt(remoteInterrupt, NO_FLAGS, &error);
  155.     if (error != SCI_ERR_OK) {
  156.       fprintf(stderr, "SCIDisconnectInterrupt failed - Error code 0x%xn", error);
  157.       return error; 
  158.     }    
  160.   return error;
  161. }
  164. sci_error_t ReceiveInterrupt(sci_desc_t sd,
  165.  Uint32 localAdapterNo,
  166.  Uint32 localSciNodeId, 
  167.  Uint32 interruptNo,
  168.  Uint32 timeout) {
  169.   
  170.   sci_error_t             error;
  171.   sci_local_interrupt_t   localInterrupt;
  172.   Uint32 timeOut = SCI_INFINITE_TIMEOUT;
  174.   // Create an interrupt 
  175.   SCICreateInterrupt(sd, &localInterrupt, localAdapterNo,
  176.        &interruptNo, 0, NULL, SCI_FLAG_FIXED_INTNO, &error);
  177.   if (error != SCI_ERR_OK) {
  178.     fprintf(stderr, "SCICreateInterrupt failed - Error code 0x%xn", error);
  179.     return error; 
  180.   }  
  181.   
  182.   
  183.   // Wait for an interrupt 
  184.   SCIWaitForInterrupt(localInterrupt, timeOut, NO_FLAGS, &error);
  186.   printf("nNode %u received interrupt (0x%x)n", localSciNodeId, interruptNo); 
  187.  
  188.   // Remove interrupt 
  189.   
  190.   SCIRemoveInterrupt(localInterrupt, NO_FLAGS, &error);
  191.   if (error != SCI_ERR_OK) {
  192.     fprintf(stderr, "SCIRemoveInterrupt failed - Error code 0x%xn", error);
  193.     return error; 
  194.   }
  195.   return error;
  196. }
  199. sci_error_t FillSegmentWithData(unsigned int segmentSize, int reverse)
  200. {
  201.     unsigned int i;
  202.     unsigned int nostores;
  204.     
  205.     nostores = (segmentSize) / sizeof(unsigned int);
  206.     
  207.     /* Allocate buffer */
  208.     
  209.     localbufferPtr = (unsigned int*)malloc( segmentSize );
  210.     if ( localbufferPtr == NULL ) {
  211.         /*
  212.          * Unable to create local buffer - Insufficient memory available
  213.          */
  214.         return SCI_ERR_NOSPC;
  215.     }
  216.     if(reverse) {
  217.       /* Fill in the data into a local buffer */
  218.       printf("Filling forward order n");
  219.       for (i=0;i<nostores;i++) {
  220. localbufferPtr[i] = i;
  221.       }
  222.     }
  223.     else {
  224.       int temp=nostores;
  225.       printf("Filling reverse order n");
  226.       for (i=0;i<nostores;i++) {
  227. localbufferPtr[i] = temp-- ;
  229.       }
  230.      
  231.     }
  232.     
  233.     return SCI_ERR_OK;
  234. }
  239. /*********************************************************************************/
  240. /*                    P R I N T   C L I E N T   D A T A                          */
  241. /*                                                                               */
  242. /*********************************************************************************/
  244. void PrintClientData(void)
  245. {
  246.     unsigned int i;
  248.     printf("nClient data: ");
  249.     /* Print the first 20 entries in the segment */
  250.     for (i=0;i<20;i++) {
  251.         printf("%d ",localbufferPtr[i]);
  252.     }
  254.     printf("n");
  255. }
  258. /*********************************************************************************/
  259. /*                    P R I N T   S E R V E R   D A T A                          */
  260. /*                                                                               */
  261. /*********************************************************************************/
  263. void PrintServerData(volatile unsigned int *localMapAddr)
  264. {
  265.  
  266.     unsigned int *buffer; 
  267.     int i;
  269.     //    printf("nServer data: ");
  270.     buffer = (unsigned int *)localMapAddr;
  272.     /* Print the first 20 entries in the segment */
  273.     for (i=0; i< 20; i++) {
  274.         
  275.         printf("%d ",buffer[i]);
  276.     }
  277.     printf("n");
  279. }
  283. /*********************************************************************************/
  284. /*                       T R A N S F E R   D A T A                               */
  285. /*                                                                               */
  286. /*********************************************************************************/
  288. unsigned int TransferData(sci_map_t             remoteMap,
  289.                           volatile unsigned int *remoteSegmentAddr1, 
  290.   volatile unsigned int *remoteSegmentAddr2, 
  291.                           unsigned int          segmentSize)
  293. {
  294.   
  295.   volatile unsigned int   *remoteBuffer1;
  296.   volatile unsigned int   *remoteBuffer;
  297.   volatile unsigned int   *remoteBuffer2;
  298.   static int times = 0;
  299.     sci_sequence_t          sequence;
  300.     sci_error_t             error;
  301.     unsigned int            nostores;
  302.     unsigned int            j;
  303.     sci_sequence_status_t   sequenceStatus;
  306.     remoteBuffer1 = (volatile unsigned int *)remoteSegmentAddr1;
  307.     remoteBuffer2 = (volatile unsigned int *)remoteSegmentAddr2;
  308.     remoteBuffer=remoteBuffer1;
  310. /* 4-byte test only */ 
  311. nostores = (segmentSize) / sizeof(unsigned int);
  313.     /* Create a sequence for data error checking */    
  314.     SCICreateMapSequence(remoteMapOne,&sequence,NO_FLAGS,&error);
  315.     if (error != SCI_ERR_OK) {
  316.         fprintf(stderr,"SCICreateMapSequence failed - Error code 0x%xn",error);
  317.         return error;
  318.     }
  322.     /* Fill in the data into a local buffer */
  323.     error = SendInterrupt(sdOne,localAdapterNo,localNodeId1,remoteNodeId1, DATA_TRANSFER_READY);
  325.     error = FillSegmentWithData(segmentSize, 0);
  327.  tryagain:
  328.     PrintServerData(localbufferPtr);
  329.     fprintf(stderr,"After recover n");
  330.     while(1){
  333.       //data=0;
  334.     
  335.       if (error != SCI_ERR_OK) {
  336.         /*
  337.          * Unable to create local buffer - Insufficient memory available
  338.          */
  339.         printf( "Unable to create local buffer - Insufficient memory availablen" );
  341.         return error;
  342.       }
  344.       do {
  345.         /* Start data error checking */
  346.         sequenceStatus = SCIStartSequence(sequence,NO_FLAGS,&error);
  347.       } while (sequenceStatus != SCI_SEQ_OK) ;
  348.       
  349.             
  350.     /* Transfer data to remote node */
  351.       for (j=0;j<nostores;j++) {
  352. remoteBuffer[j] = localbufferPtr[j];
  353.       }
  354.       
  355.       /* Check for error after data transfer */
  356.       sequenceStatus = SCICheckSequence(sequence,NO_FLAGS,&error);
  357.       if (sequenceStatus != SCI_SEQ_OK) {
  358.         fprintf(stderr,"Data transfer failedn");
  359. if(times==0) {
  360.   error = FillSegmentWithData(segmentSize, 1);
  361.   
  362.   SCICreateMapSequence(remoteMapTwo,&sequence,NO_FLAGS,&error);
  363.   if (error != SCI_ERR_OK) {
  364.     fprintf(stderr,"SCICreateMapSequence failed - Error code 0x%xn",error);
  365.     return error;
  366.     return SCI_ERR_TRANSFER_FAILED;
  367.   }
  368. }
  369. else 
  370.   {
  371.     error = FillSegmentWithData(segmentSize, 0);
  372.     /* Create a sequence for data error checking */    
  373.     SCICreateMapSequence(remoteMapOne,&sequence,NO_FLAGS,&error);
  374.     if (error != SCI_ERR_OK) {
  375.       fprintf(stderr,"SCICreateMapSequence failed - Error code 0x%xn",error);
  376.       return error;
  377.       return SCI_ERR_TRANSFER_FAILED;
  378. }
  379.     
  380.   }
  381. fprintf(stderr,"Recovery n");
  382. if(times==0)
  383.   remoteBuffer=remoteBuffer2;
  384. else
  385.   remoteBuffer=remoteBuffer1;
  386. times++;
  387. printf("remotebuffer %p   times %dn", remoteBuffer, times);
  388. goto tryagain;
  390.       }    
  391.       int timeout=0;
  392.       //      error = SendInterrupt(sdOne,localAdapterNo,localNodeId1,remoteNodeId1, DATA_TRANSFER_READY);
  393.       //      NdbSleep_MilliSleep(100);
  394.       //error = ReceiveInterrupt(sdOne,localAdapterNo,localNodeId1,DATA_TRANSFER_READY, timeout);
  396.     }
  397.     /* Remove the Sequence */
  398.     SCIRemoveSequence(sequence,NO_FLAGS, &error);
  399.     if (error != SCI_ERR_OK) {
  400.       fprintf(stderr,"SCIRemoveSequence failed - Error code 0x%xn",error);
  401.       return error;
  402.     }
  403.     
  404.     return SCI_ERR_OK;
  405. }
  408. /*********************************************************************************/
  409. /*                    S H M E M   C L I E N T   N O D E                          */
  410. /*                                                                               */
  411. /*********************************************************************************/
  413. unsigned int ShmemClientNode(void)
  414. {
  416.     volatile unsigned int *remoteMapAddr1;
  417.     volatile unsigned int *remoteMapAddr2;
  418.     printf("here?n");
  420.     
  421.     /* Create a segmentId */
  422.     remoteSegmentId1 = 1;//(remoteNodeId1 << 16) | localNodeId1;
  424.     /* Connect to remote segment */
  426.     printf("Connect to remote segment ....  n");
  427.     printf("segid = %d  node %d n",remoteSegmentId1, remoteNodeId1 );
  429.      do { 
  430.       SCIConnectSegment(sdOne,
  431. &remoteSegmentOne,
  432. remoteNodeId1,
  433. remoteSegmentId1,
  434. localAdapterNo,
  435. NO_CALLBACK,
  436. NULL,
  437. SCI_INFINITE_TIMEOUT,
  438. NO_FLAGS,
  439. &error);
  440.       
  441.         } while (error != SCI_ERR_OK);
  444.     printf("connectedn");
  445.     
  446.     // remoteSegmentId2 = (remoteNodeId2 << 16) | localNodeId2;
  447.     //  printf("segid = %dn",remoteSegmentId2 );
  448.     printf("segid = %d  node %d n",remoteSegmentId1, remoteNodeId1 );
  449.     do { 
  450.       SCIConnectSegment(sdTwo,
  451. &remoteSegmentTwo,
  452. remoteNodeId2,
  453. remoteSegmentId1,
  454. standbyAdapterNo,
  455. NO_CALLBACK,
  456. NULL,
  457. SCI_INFINITE_TIMEOUT,
  458. NO_FLAGS,
  459. &error);
  460.       
  461.     } while (error != SCI_ERR_OK);
  462.     
  463.    
  465.     printf("connected 3n");
  466.     printf("Remote segment (id=0x%x) is connected.n", remoteSegmentId2);
  469. /* Map remote segment to user space */
  470.     remoteMapAddr1 = (unsigned int*)SCIMapRemoteSegment(remoteSegmentOne,&remoteMapOne,offset,segmentSize,NULL,NO_FLAGS,&error);
  471.     if (error == SCI_ERR_OK) {
  472.         printf("Remote segment (id=0x%x) is mapped to user space @ 0x%x. n", remoteSegmentId1, remoteMapAddr1);         
  473.     } else {
  474.         fprintf(stderr,"SCIMapRemoteSegment failed - Error code 0x%xn",error);
  475.         return 0;
  476.     } 
  478.     remoteMapAddr2 = (unsigned int *)SCIMapRemoteSegment(remoteSegmentTwo,&remoteMapTwo,offset,segmentSize,NULL,NO_FLAGS,&error);
  479.     if (error == SCI_ERR_OK) {
  480.       printf("Remote segment (id=0x%x) is mapped to user space @ 0x%x. n", remoteSegmentId2, remoteMapAddr2);         
  481.     } else {
  482.         fprintf(stderr,"SCIMapRemoteSegment failed - Error code 0x%xn",error);
  483.         return 0;
  484.     } 
  486.         
  487.     /* Start data transfer and error checking */
  488.     error = (sci_error_t)TransferData(remoteMapOne,remoteMapAddr1, remoteMapAddr2,segmentSize);
  489.     if (error == SCI_ERR_OK) {
  490.         printf("Data transfer done!nn");
  491.     } else {
  492.         fprintf(stderr,"Data transfer failed - Error code 0x%xnn",error);
  493.         return 0;
  494.     }
  496.     /* Send an interrupt to remote node telling that the data transfer is ready */
  497.     error = SendInterrupt(sdOne,localAdapterNo,localNodeId1,remoteNodeId1, DATA_TRANSFER_READY);
  498.     if (error == SCI_ERR_OK) {
  499.         printf("nInterrupt message sent to remote noden");
  500.     } else {
  501.         printf("nInterrupt synchronization failedn");
  502.         return 0;
  503.     }
  504.     
  505.     PrintClientData();
  507.     /* Unmap remote segment */
  508.     SCIUnmapSegment(remoteMapOne,NO_FLAGS,&error);
  509.     if (error == SCI_ERR_OK) {
  510.         printf("The remote segment is unmappedn"); 
  511.     } else {
  512.         fprintf(stderr,"SCIUnmapSegment failed - Error code 0x%xn",error);
  513.         return 0;
  514.     }
  515.     
  516.     SCIUnmapSegment(remoteMapTwo,NO_FLAGS,&error);
  517.     if (error == SCI_ERR_OK) {
  518.       printf("The remote segment is unmappedn"); 
  519.     } else {
  520.       fprintf(stderr,"SCIUnmapSegment failed - Error code 0x%xn",error);
  521.       return 0;
  522.     }
  523.     /* Disconnect segment */
  524.     SCIDisconnectSegment(remoteSegmentOne,NO_FLAGS,&error);
  525.     if (error == SCI_ERR_OK) {
  526.         printf("The segment is disconnectedn"); 
  527.     } else {
  528.         fprintf(stderr,"SCIDisconnectSegment failed - Error code 0x%xn",error);
  529.         return 0;
  530.     } 
  531.     
  532.     SCIDisconnectSegment(remoteSegmentTwo,NO_FLAGS,&error);
  533.     if (error == SCI_ERR_OK) {
  534.         printf("The segment is disconnectedn"); 
  535.     } else {
  536.         fprintf(stderr,"SCIDisconnectSegment failed - Error code 0x%xn",error);
  537.         return 0;
  538.     } 
  541.     return 1;
  542. }
  545. /*********************************************************************************/
  546. /*                    S H M E M   S E R V E R   N O D E                          */
  547. /*                                                                               */
  548. /*********************************************************************************/
  550. unsigned int ShmemServerNode(void)
  551. {
  553.   unsigned int *localMapAddr;
  554.     
  555.     /* Create a segmentId */
  556.   localSegmentId  =1;// (localNodeId1 << 16)  | remoteNodeId1;
  558.     /* Create local segment */    
  559.         SCICreateSegment(sdOne,&localSegmentOne,localSegmentId, segmentSize, NO_CALLBACK, NULL, NO_FLAGS,&error);
  560.     if (error == SCI_ERR_OK) {
  561.         printf("Local segment (id=%d, size=%d) is created. n", localSegmentId, segmentSize);  
  562.     } else {
  563.         fprintf(stderr,"SCICreateSegment failed - Error code 0x%xn",error);
  564.         return 0;
  565.     }
  567.     //localSegmentId  = (localNodeId2 << 16)  | remoteNodeId2;
  568.     /*
  569.     SCICreateSegment(sdTwo,&localSegmentTwo,localSegmentId+1, segmentSize, NO_CALLBACK, NULL, NO_FLAGS,&error);
  570.     if (error == SCI_ERR_OK) {
  571.       printf("Local segment (id=%d, size=%d) is created (2). n", localSegmentId, segmentSize);  
  572.     } else {
  573.       fprintf(stderr,"SCICreateSegment failed - Error code 0x%xn",error);
  574.       return 0;
  575.     }
  576.     
  577.     printf("segment one %p segment 2 %pn", localSegmentOne, localSegmentTwo);
  578.     */
  579.     /* Prepare the segment */
  580.     SCIPrepareSegment(localSegmentOne,localAdapterNo,NO_FLAGS,&error);
  581.     if (error == SCI_ERR_OK) {
  582.         printf("Local segment (id=%d, size=%d) is prepared. n", localSegmentId, segmentSize);  
  583.     } else {
  584.         fprintf(stderr,"SCIPrepareSegment failed - Error code 0x%xn",error);
  585.         return 0;
  586.     }
  587.     
  588.     
  589.     /* Prepare the segment */
  590.    
  591.     SCIPrepareSegment(localSegmentOne,standbyAdapterNo,NO_FLAGS,&error);
  592.     if (error == SCI_ERR_OK) {
  593.         printf("Local segment (id=%d, size=%d) is created. n", localSegmentId, segmentSize);  
  594.     } else {
  595.         fprintf(stderr,"SCIPrepareSegment failed - Error code 0x%xn",error);
  596.         return 0;
  597.     }
  598.    
  600.     /* Map local segment to user space */
  601.     localMapAddr = (unsigned int *)SCIMapLocalSegment(localSegmentOne,&localMapOne, offset,segmentSize, NULL,NO_FLAGS,&error);
  602.     if (error == SCI_ERR_OK) {
  603.         printf("Local segment (id=0x%x) is mapped to user space @ 0x%x.n", localSegmentId, localMapAddr); 
  604.     } else {
  605.         fprintf(stderr,"SCIMapLocalSegment failed - Error code 0x%xn",error);
  606.         return 0;
  607.     } 
  608.     
  610.     /* Map local segment to user space */
  611.     /*
  612.     localMapAddr = (unsigned int *)SCIMapLocalSegment(localSegmentTwo,&localMapTwo, offset,segmentSize, NULL,NO_FLAGS,&error);
  613.     if (error == SCI_ERR_OK) {
  614.       printf("Local segment (id=0x%x) is mapped to user space @ 0x%x.n", localSegmentId, localMapAddr); 
  615.       printf("Local segment (id=%d) is mapped to user space.n", localSegmentId); 
  616.     } else {
  617.       fprintf(stderr,"SCIMapLocalSegment failed - Error code 0x%xn",error);
  618.       return 0;
  619.     } 
  620.     */
  622.     /* Set the segment available */
  623.     SCISetSegmentAvailable(localSegmentOne, localAdapterNo, NO_FLAGS, &error);
  624.     if (error == SCI_ERR_OK) {
  625.         printf("Local segment (id=0x%x) is available for remote connections. n", localSegmentId); 
  626.     } else {
  627.         fprintf(stderr,"SCISetSegmentAvailable failed - Error code 0x%xn",error);
  628.         return 0;
  629.     } 
  631.     
  632.     SCISetSegmentAvailable(localSegmentOne, standbyAdapterNo, NO_FLAGS, &error);
  633.     if (error == SCI_ERR_OK) {
  634.         printf("Local segment (id=0x%x) is available for remote connections. n", localSegmentId); 
  635.     } else {
  636.         fprintf(stderr,"SCISetSegmentAvailable failed - Error code 0x%xn",error);
  637.         return 0;
  638.     } 
  639.     int timeout=0;
  640.     error = ReceiveInterrupt(sdOne,localAdapterNo,localNodeId1,DATA_TRANSFER_READY, timeout);    
  642.     if (error == SCI_ERR_OK) {
  643.       printf("nThe data transfer is readyn");
  644.     } else {
  645.       printf("nInterrupt synchronization failedn");
  646.       return 0;
  647.     }
  648.     
  650.  again:
  652.     //    printf("Wait for the shared memory data transfer .....");
  653.     /* Wait for interrupt signal telling that block transfer is ready */
  655.     //printf("nData transfer done!n");
  656.     //PrintClientData()
  657.     PrintServerData(localMapAddr);
  658.     /*Uint32 micros;
  659.     Uint32 micros2;
  660.     NDB_TICKS secs;
  661.     NdbTick_CurrentMicrosecond(&secs, &micros);
  662.     error = SendInterrupt(sdOne,localAdapterNo,localNodeId1,remoteNodeId1, DATA_TRANSFER_READY);
  663.     NdbTick_CurrentMicrosecond(&secs, &micros2);
  664.     printf("TIME ELAPSED %d n", micros2-micros);
  665. //    NdbSleep_MilliSleep(100);
  666.     */
  667.     goto again;
  669.     /* Unmap local segment */
  670.     SCIUnmapSegment(localMapTwo,NO_FLAGS,&error);
  671.     if (error == SCI_ERR_OK) {
  672.       printf("The local segment is unmappedn"); 
  673.     } else {
  674.       fprintf(stderr,"SCIUnmapSegment failed - Error code 0x%xn",error);
  675.       return 0;
  676.     }
  677.     
  678.     /* Unmap local segment */
  679.     SCIUnmapSegment(localMapOne,NO_FLAGS,&error);
  680.     if (error == SCI_ERR_OK) {
  681.       printf("The local segment is unmappedn"); 
  682.     } else {
  683.       fprintf(stderr,"SCIUnmapSegment failed - Error code 0x%xn",error);
  684.         return 0;
  685.     }
  686.     /* Remove local segment */
  687.     SCIRemoveSegment(localSegmentOne,NO_FLAGS,&error);
  688.     if (error == SCI_ERR_OK) {
  689.         printf("The local segment is removedn"); 
  690.     } else {
  691.         fprintf(stderr,"SCIRemoveSegment failed - Error code 0x%xn",error);
  692.         return 0;
  693.     }  
  695.     /* Remove local segment */
  696.     SCIRemoveSegment(localSegmentTwo,NO_FLAGS,&error);
  697.     if (error == SCI_ERR_OK) {
  698.         printf("The local segment is removedn"); 
  699.     } else {
  700.         fprintf(stderr,"SCIRemoveSegment failed - Error code 0x%xn",error);
  701.         return 0;
  702.     } 
  707.     return 1;
  708. }
  712. /*********************************************************************************/
  713. /*                                M A I N                                        */
  714. /*                                                                               */
  715. /*********************************************************************************/
  717. int main(int argc,char *argv[])
  718. {
  720.     int counter; 
  722.     printf("n %s compiled %s : %snn",argv[0],__DATE__,__TIME__);
  723.     
  724.     if (argc<3) {
  725.         Usage();
  726.         exit(-1);
  727.     }
  730.     /* Get the parameters */
  731.     for (counter=1; counter<argc; counter++) {
  733.         if (!strcmp("-rn",argv[counter])) {
  734.   //            remoteNodeId = strtol(argv[counter+1],(char **) NULL,10);
  735.             continue;
  736.         } 
  738.         if (!strcmp("-size",argv[counter])) {
  739.             segmentSize = strtol(argv[counter+1],(char **) NULL,10);
  740.             continue;
  741.         } 
  743.         if (!strcmp("-adapterno",argv[counter])) {
  744.             localAdapterNo = strtol(argv[counter+1],(char **) NULL,10);
  745.             continue;
  746.         }
  748.         if (!strcmp("-client",argv[counter])) {
  749.             client = 1;
  750.             continue;
  751.         }
  753.         if (!strcmp("-server",argv[counter])) {
  754.             server = 1;
  755.             continue;
  756.         }
  758.         if (!strcmp("-help",argv[counter])) {
  759.             Usage();
  760.             exit(0);
  761.         }
  762.     }
  764.     //    if (remoteNodeId == 0) {
  765.     //   fprintf(stderr,"Remote node-id is not specified. Use -rn <remote node-id>n");
  766.     //  exit(-1);
  767.     //}
  769.     if (server == 0 && client == 0) {
  770.         fprintf(stderr,"You must specify a client node or a server noden");
  771.         exit(-1);
  772.     }
  774.     if (server == 1 && client == 1) {
  775.         fprintf(stderr,"Both server node and client node is selected.n"); 
  776.         fprintf(stderr,"You must specify either a client or a server noden");
  777.         exit(-1);
  778.     }
  781.     /* Initialize the SISCI library */
  782.     SCIInitialize(NO_FLAGS, &error);
  783.     if (error != SCI_ERR_OK) {
  784.         fprintf(stderr,"SCIInitialize failed - Error code: 0x%xn",error);
  785.         exit(error);
  786.     }
  789.     /* Open a file descriptor */
  790.     SCIOpen(&sdOne,NO_FLAGS,&error);
  791.     if (error != SCI_ERR_OK) {
  792.         if (error == SCI_ERR_INCONSISTENT_VERSIONS) {
  793.             fprintf(stderr,"Version mismatch between SISCI user library and SISCI drivern");
  794.         }
  795.         fprintf(stderr,"SCIOpen failed - Error code 0x%xn",error);
  796.         exit(error); 
  797.     }
  799.     /* Open a file descriptor */
  800.     SCIOpen(&sdTwo,NO_FLAGS,&error);
  801.     if (error != SCI_ERR_OK) {
  802.         if (error == SCI_ERR_INCONSISTENT_VERSIONS) {
  803.             fprintf(stderr,"Version mismatch between SISCI user library and SISCI drivern");
  804.         }
  805.         fprintf(stderr,"SCIOpen failed - Error code 0x%xn",error);
  806.         exit(error); 
  807.     }
  810.     /* Get local node-id */
  811.     error = GetLocalNodeId(localAdapterNo, &localNodeId1);
  812.     error = GetLocalNodeId(standbyAdapterNo, &localNodeId2);
  813.     if (error != SCI_ERR_OK) {
  814.       fprintf(stderr,"Could not find the local adapter %dn", localAdapterNo);
  815.       SCIClose(sdOne,NO_FLAGS,&error);
  816.       SCIClose(sdTwo,NO_FLAGS,&error);
  817.       exit(-1);
  818.     }
  819.     
  821.     /* Print parameters */
  822.     PrintParameters();
  824.     if (client) {
  825.       remoteNodeId1=324;
  826.       remoteNodeId2=328;
  827.         ShmemClientNode();
  828.     } else {
  829.          remoteNodeId1=452;
  830.  remoteNodeId2=456;
  831.         ShmemServerNode();
  832.     }
  834.     /* Close the file descriptor */
  835.     SCIClose(sdOne,NO_FLAGS,&error);
  836.     SCIClose(sdTwo,NO_FLAGS,&error);
  837.     if (error != SCI_ERR_OK) {
  838.         fprintf(stderr,"SCIClose failed - Error code: 0x%xn",error);
  839.     }
  842.     /* Free allocated resources */
  843.     SCITerminate();
  845.     return SCI_ERR_OK;
  846. }