sharememory.cpp

Mysql的处理

		    printf("open %s failed!\n",gsLogFileName);
		    exit(-1);	
		  }          
		  fprintf(fp,"C_ShareMemory{ ucInitialFalg = %d }\n",ucInitialFlag);
		  fprintf(fp,"m_iShmID = %d share memory start address:0x%0x\n",m_iShmID,m_pBlockStartAddress);
		  fclose(fp);
		#endif

        // initialize config information of whole share memory block
        InitConfig(ucInitialFlag);
        
		/*// initialize share memory config information of this program
        GetProgramConfig();*/
        
        // initialize config information of the specified business area
        if(m_uiProgramFlag != 0 || ( (m_uiProgramFlag == 0) && (m_uiOperateAreaFlag != 0) ) )
            GetOperateAreaConfig();

        if(m_pConfigFileName != NULL)
        {
            delete [] m_pConfigFileName;
            m_pConfigFileName = NULL;	
        } 
		ShmLog("C_ShareMemory end");       
    }
    catch (C_SHMException)
    {
        // write log
        printf("Initialize share memory failed!\n");
    
        // exit program
        exit(-1);
    }
    
    // read data item to buffer from the specified business data area
    long C_ShareMemory::ReadData(void *pBuffer,unsigned long ulSize, \
                                   unsigned int uiNextFlag)
    {
        // verify value of input parameter
        if(NULL == pBuffer)
            return -1;
        // verify value of business area flag for this program to read    	
        unsigned char ucExistFlag = 0;
		/*        int i=0;
		        for(;i < m_uiReadAreaNumber;i++)
		        {
		printf("flag%darea%dID%d\n",uiAreaFlag,i,(m_pReadAreaInfo + i)->uiAreaID);            
		            if(uiAreaFlag == (m_pReadAreaInfo + i)->uiAreaID)
		            {
		                ucExistFlag = 1;
		                break;
		            }
		        }
		        if(0 == ucExistFlag)
		            return -2; // the specified read business area is not exist */
		        // verify value of next business program flag
		/*        ucExistFlag = 0;*/
        int j=0;
        for(;j < m_pOperateAreaInfo->uiQueueNumber;j++)
        {
            if(uiNextFlag == (m_pOperateAreaInfo->pQueueInfo + j)->uiQueueID)
            {    
                ucExistFlag = 1;
                break;
            }
        }
        if(0 == ucExistFlag)
            return -2; // the next business program queue is not exist
        
        // locate this program maintenance queue 
        ucExistFlag = 0;
        int k=0;
        for(;k < m_pOperateAreaInfo->uiQueueNumber;k++)
        {
            if(m_uiProgramFlag == (m_pOperateAreaInfo->pQueueInfo + k)->uiQueueID)
            {    
                ucExistFlag = 1;
                break;
            }
        }
        if(0 == ucExistFlag)
            return -3; // this program maintenance queue is not exist 
                       //   in the specified business area

		#ifdef DEBUG_SHM
		{      
		  	if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
		  	{
		  	  printf("open %s failed!\n",gsLogFileName);
		  	  exit(-1);	
		  	}
		  	fprintf(fp,"read data program[%d] area[%d] next[%d] ulSize[%d]\n",m_uiProgramFlag,m_uiOperateAreaFlag,uiNextFlag, ulSize);
		  	fprintf(fp,"share memory key[%ld] [0x%0x] ID[%d]\n",m_pBlockInfo->ulShmKey,m_pBlockInfo->ulShmKey,m_iShmID);
		  	fclose(fp);
		}
		#endif
                
        // semaphore mechanism, 
        //   check front concurrent flag of this program maintenance queue
        if( 1 == (m_pOperateAreaInfo->pQueueInfo + k)->ucFrontConcurrent )
        {
            // lock front pointer of this program maintenance queue
            OperateSem((m_pOperateAreaInfo->pQueueInfo + k)->uiFrontSemNumber,1);
        }
                 
        unsigned long ulIndexArraySubfix; // subfix of index array
        // this program maintenance queue
        C_LoopQueue ProgramQueue( *( (m_pOperateAreaInfo->pQueueInfo + k)->pQueue ) );
        // empty flag of queue, 1 denote queue is empty
        unsigned char ucEmptyFlag = 1;
		#ifdef DEBUG_SHM
		{      
		  	if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
		  	{
		  	  printf("open %s failed!\n",gsLogFileName);
		  	  exit(-1);	
		  	}
		  	fprintf(fp,"get queueID[%d] front[%ld] rear[%ld] queue[0x%0x]\n",(m_pOperateAreaInfo->pQueueInfo + k)->uiQueueID, \
		  	        *((m_pOperateAreaInfo->pQueueInfo + k)->pQueue->pFront), \
		  	        *((m_pOperateAreaInfo->pQueueInfo + k)->pQueue->pRear),(m_pOperateAreaInfo->pQueueInfo + k)->pQueue->pQueue); 
		  	fclose(fp);
		}
		#endif         
        // get element from this program maintenance queue
        if( ProgramQueue.DeleteElement(ulIndexArraySubfix) )
        {
            ucEmptyFlag = 0; // set empty flag = 0, denote have got element 
            // save change of queue 
            ProgramQueue.SaveChange( *( (m_pOperateAreaInfo->pQueueInfo + k)->pQueue ) );
			#ifdef DEBUG_SHM
			{      
			  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			  {
			    printf("open %s failed!\n",gsLogFileName);
			    exit(-1);	
			  }
			  fprintf(fp,"save queueID[%d] front[%ld] rear[%ld] queue[%0x]\n",(m_pOperateAreaInfo->pQueueInfo + k)->uiQueueID, \
			          *((m_pOperateAreaInfo->pQueueInfo + k)->pQueue->pFront),\
			          *((m_pOperateAreaInfo->pQueueInfo + k)->pQueue->pRear),(m_pOperateAreaInfo->pQueueInfo + k)->pQueue->pQueue); 
			  fclose(fp);
			}
			#endif      
        }
                              
        // semaphore mechanism, 
        //   check front concurrent flag of this program maintenance queue
        if(1 == (m_pOperateAreaInfo->pQueueInfo + k)->ucFrontConcurrent)
        {
            // unlock front pointer of this program maintenance queue
            OperateSem((m_pOperateAreaInfo->pQueueInfo + k)->uiFrontSemNumber,-1);
        } 
        
        // empty flag is 0, denote have got element
        if(0 == ucEmptyFlag)
        {

			#ifdef DEBUG_SHM
			{      
			  	if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			  	{
			  	  printf("open %s failed!\n",gsLogFileName);
			  	  exit(-1);	
			  	}
			  	fprintf(fp,"subfix[%ld] address[0x%0x] itemsize[%ld]\n",ulIndexArraySubfix, \
			  	           (void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix),m_pOperateAreaInfo->ulItemSize);
			  	fclose(fp);
			}
			#endif       

            // length flag of copy data, 
            //   1 denote copy data length = size of input parameter value
            unsigned char ucLengthFlag = 1;        
            if(ulSize <= m_pOperateAreaInfo->ulItemSize)
            {
            	// locate index and read data item to buffer
                memcpy(pBuffer,(void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix),ulSize);
				#ifdef DEBUG_SHM
				{      
				  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
				  {
				    printf("open %s failed!\n",gsLogFileName);
				    exit(-1);	
				  }
				  fprintf(fp,"read size[%ld] content[",ulSize);
				  fwrite((void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix),ulSize,1,fp); 
				  fprintf(fp,"]\n");
				  fclose(fp);
				}
				#endif      
            }
            else
            {
                // set length flag = 0, 0 denote copy data length = item size
                ucLengthFlag = 0; 
                // locate index and read data item to buffer
                memcpy(pBuffer,(void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix), \
                           m_pOperateAreaInfo->ulItemSize); 
				#ifdef DEBUG_SHM
				{      
				  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
				  {
				    printf("open %s failed!\n",gsLogFileName);
				    exit(-1);	
				  }
				  fprintf(fp,"read itemsize[%ld] content[",m_pOperateAreaInfo->ulItemSize);
				  fwrite((void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix),m_pOperateAreaInfo->ulItemSize,1,fp); 
				  fprintf(fp,"]\n");
				  fclose(fp);
				}
				#endif                 	
            }
            
            // semaphore mechanism, 
            //   check rear concurrent flag 
            //     of the next business program maintenance queue
            if(1 == (m_pOperateAreaInfo->pQueueInfo + j)->ucRearConcurrent)
            {
                // lock rear pointer of the next program maintenance queue
                OperateSem((m_pOperateAreaInfo->pQueueInfo + j)->uiRearSemNumber,1);
            }
            
            // next business program maintenance queue
            C_LoopQueue NextQueue( *( (m_pOperateAreaInfo->pQueueInfo + j)->pQueue ) );
			#ifdef DEBUG_SHM
			{      
			  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			  {
			    printf("open %s failed!\n",gsLogFileName);
			    exit(-1);	
			  }
			  fprintf(fp,"next get queueID[%d] front[%ld] rear[%ld] queue[0x%0x]\n", \
			          (m_pOperateAreaInfo->pQueueInfo + j)->uiQueueID,*((m_pOperateAreaInfo->pQueueInfo + j)->pQueue->pFront),\
			          *((m_pOperateAreaInfo->pQueueInfo + j)->pQueue->pRear),(m_pOperateAreaInfo->pQueueInfo + j)->pQueue->pQueue); 
			  fclose(fp);
			}
			#endif                  
            // add element to the next business program maintenance queue
            NextQueue.AddElement(ulIndexArraySubfix);
            // save change of queue
            NextQueue.SaveChange( *( (m_pOperateAreaInfo->pQueueInfo + j)->pQueue ) );
			#ifdef DEBUG_SHM
			{      
			  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			  {
			    printf("open %s failed!\n",gsLogFileName);
			    exit(-1);	
			  }
			  fprintf(fp,"next save queueID[%d] front[%ld] rear[%ld] queue[0x%0x]\n", \
			          (m_pOperateAreaInfo->pQueueInfo + j)->uiQueueID,*((m_pOperateAreaInfo->pQueueInfo + j)->pQueue->pFront), \
			          *((m_pOperateAreaInfo->pQueueInfo + j)->pQueue->pRear),(m_pOperateAreaInfo->pQueueInfo + j)->pQueue->pQueue); 
			  fclose(fp);
			}
			#endif      
                  
            // clear reclaimed data item content, set 0
            if(0 == uiNextFlag)
            {

			#ifdef DEBUG_SHM
			{      
			  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			  {
			    printf("open %s failed!\n",gsLogFileName);
			    exit(-1);	
			  }
			  fprintf(fp,"clear memory: subfix[%ld] address[0x%0x] itemsize[%ld]\n",ulIndexArraySubfix, \
			             (void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix),m_pOperateAreaInfo->ulItemSize);
			  fclose(fp);
			}
			#endif     

                memset((void *) *(m_pOperateAreaInfo->pIndex + ulIndexArraySubfix),0,m_pOperateAreaInfo->ulItemSize);	
            }
                               
            // semaphore mechanism, 
            //   check rear concurrent flag 
            //     of the next business program maintenance queue
            if(1 == (m_pOperateAreaInfo->pQueueInfo + j)->ucRearConcurrent)
            {
                // unlock rear pointer
                //   of the next business program maintenance queue
                OperateSem((m_pOperateAreaInfo->pQueueInfo + j)->uiRearSemNumber,-1);
            } 
                    
            // length flag is 1, 
            //   denote copy data length = size of input parameter value
            if(1 == ucLengthFlag)
                return ulSize;               
            // length flag is 0, 
            //   denote copy data length = item size
            else 
                return 	m_pOperateAreaInfo->ulItemSize;                    
        }
        else 
        {
			#ifdef DEBUG_SHM
			{      
			  if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			  {
			    printf("open %s failed!\n",gsLogFileName);
			    exit(-1);	
			  }
			  fprintf(fp,"queue is empty, no data item to read\n"); 
			  fclose(fp);
			}
			#endif         
            return 0; // queue is empty, no data item to read     
        } 
    }
    
    // read data item, not specify next program 
    long C_ShareMemory::ReadDataUpdate( void *pBuffer,unsigned long ulSize,unsigned long &ulUpdateFlag)
    {
        // verify value of input parameter
        if(NULL == pBuffer)
            return -1;
        // verify value of business area flag for this program to read    	
        unsigned char ucExistFlag = 0;
        int i=0;
		/*for(;i < m_pOperateAreaInfo->uiUpdateArrayNumber;i++)
        {   
            if(m_uiProgramFlag == (m_pOperateAreaInfo->pUpdateArrayInfo + i)->uiUpdateArrayID)
            {
                ucExistFlag = 1;
                break;