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

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. #ifndef SHM_BUFFER_HPP
  14. #define SHM_BUFFER_HPP
  15. #include <ndb_global.h>
  16. #include <NdbSleep.h>
  17. /**
  18.  * These classes implement a circular buffer
  19.  *
  20.  * One reader and one writer
  21.  */
  22. /**
  23.  * SHM_Reader
  24.  *
  25.  * Use as follows:
  26.  *  getReadPtr(ptr, sz);
  27.  *  for(int i = 0; i<sz; i++)
  28.  *    printf("%cn", ptr[i]);
  29.  *  updateReadPtr(sz);
  30.  */
  31. class SHM_Reader {
  32. public:
  33.   SHM_Reader(char * const _startOfBuffer,
  34.      Uint32 _sizeOfBuffer,
  35.      Uint32 _slack,
  36.      Uint32 * _readIndex,
  37.      Uint32 * _writeIndex) :
  38.     m_startOfBuffer(_startOfBuffer),
  39.     m_totalBufferSize(_sizeOfBuffer),
  40.     m_bufferSize(_sizeOfBuffer - _slack),
  41.     m_sharedReadIndex(_readIndex),
  42.     m_sharedWriteIndex(_writeIndex)
  43.   {
  44.   }
  45.   
  46.   void clear() {
  47.     m_readIndex = 0;
  48.   }
  49.   
  50.   /**
  51.    * 
  52.    */
  53.   inline bool empty() const;
  54.   
  55.   /**
  56.    * Get read pointer
  57.    *
  58.    *  returns ptr - where to start reading
  59.    *           sz - how much can I read
  60.    */
  61.   inline void getReadPtr(Uint32 * & ptr, Uint32 * & eod);
  62.   /**
  63.    * Update read ptr
  64.    */
  65.   inline void updateReadPtr(Uint32 *ptr);
  66.   
  67. private:
  68.   char * const m_startOfBuffer;
  69.   Uint32 m_totalBufferSize;
  70.   Uint32 m_bufferSize;
  71.   Uint32 m_readIndex;
  72.   Uint32 * m_sharedReadIndex;
  73.   Uint32 * m_sharedWriteIndex;
  74. };
  75. inline 
  76. bool
  77. SHM_Reader::empty() const{
  78.   bool ret = (m_readIndex == * m_sharedWriteIndex);
  79.   return ret;
  80. }
  81. /**
  82.  * Get read pointer
  83.  *
  84.  *  returns ptr - where to start reading
  85.  *           sz - how much can I read
  86.  */
  87. inline 
  88. void
  89. SHM_Reader::getReadPtr(Uint32 * & ptr, Uint32 * & eod)
  90. {
  91.   Uint32 tReadIndex  = m_readIndex;
  92.   Uint32 tWriteIndex = * m_sharedWriteIndex;
  93.   
  94.   ptr = (Uint32*)&m_startOfBuffer[tReadIndex];
  95.   
  96.   if(tReadIndex <= tWriteIndex){
  97.     eod = (Uint32*)&m_startOfBuffer[tWriteIndex];
  98.   } else {
  99.     eod = (Uint32*)&m_startOfBuffer[m_bufferSize];
  100.   }
  101. }
  102. /**
  103.  * Update read ptr
  104.  */
  105. inline
  106. void 
  107. SHM_Reader::updateReadPtr(Uint32 *ptr)
  108. {
  109.   Uint32 tReadIndex = ((char*)ptr) - m_startOfBuffer;
  110.   assert(tReadIndex < m_totalBufferSize);
  111.   if(tReadIndex >= m_bufferSize){
  112.     tReadIndex = 0;
  113.   }
  114.   m_readIndex = tReadIndex;
  115.   * m_sharedReadIndex = tReadIndex;
  116. }
  117. #define WRITER_SLACK 4
  118. class SHM_Writer {
  119. public:
  120.   SHM_Writer(char * const _startOfBuffer,
  121.      Uint32 _sizeOfBuffer,
  122.      Uint32 _slack,
  123.      Uint32 * _readIndex,
  124.      Uint32 * _writeIndex) :
  125.     m_startOfBuffer(_startOfBuffer),
  126.     m_totalBufferSize(_sizeOfBuffer),
  127.     m_bufferSize(_sizeOfBuffer - _slack),
  128.     m_sharedReadIndex(_readIndex),
  129.     m_sharedWriteIndex(_writeIndex)
  130.   {
  131.   }
  132.   
  133.   void clear() {
  134.     m_writeIndex = 0;
  135.   }
  136.     
  137.   inline char * getWritePtr(Uint32 sz);
  138.   inline void updateWritePtr(Uint32 sz);
  139.   inline Uint32 getWriteIndex() const { return m_writeIndex;}
  140.   inline Uint32 getBufferSize() const { return m_bufferSize;}
  141.   inline Uint32 get_free_buffer() const;
  142.   
  143.   inline void copyIndexes(SHM_Writer * standbyWriter);
  144. private:
  145.   char * const m_startOfBuffer;
  146.   Uint32 m_totalBufferSize;
  147.   Uint32 m_bufferSize;
  148.   
  149.   Uint32 m_writeIndex;
  150.   
  151.   Uint32 * m_sharedReadIndex;
  152.   Uint32 * m_sharedWriteIndex;
  153. };
  154. inline
  155. char *
  156. SHM_Writer::getWritePtr(Uint32 sz){
  157.   Uint32 tReadIndex  = * m_sharedReadIndex;
  158.   Uint32 tWriteIndex = m_writeIndex;
  159.   
  160.   char * ptr = &m_startOfBuffer[tWriteIndex];
  161.   Uint32 free;
  162.   if(tReadIndex <= tWriteIndex){
  163.     free = m_bufferSize + tReadIndex - tWriteIndex;
  164.   } else {
  165.     free = tReadIndex - tWriteIndex;
  166.   }
  167.   
  168.   sz += 4;
  169.   if(sz < free){
  170.     return ptr;
  171.   }
  172.   
  173.   return 0;
  174. }
  175. inline
  176. void 
  177. SHM_Writer::updateWritePtr(Uint32 sz){
  178.   assert(m_writeIndex == * m_sharedWriteIndex);
  179.   Uint32 tWriteIndex = m_writeIndex;
  180.   tWriteIndex += sz;
  181.   
  182.   assert(tWriteIndex < m_totalBufferSize);
  183.   if(tWriteIndex >= m_bufferSize){
  184.     tWriteIndex = 0;
  185.   }
  186.   m_writeIndex = tWriteIndex;
  187.   * m_sharedWriteIndex = tWriteIndex;
  188. }
  189. inline
  190. Uint32
  191. SHM_Writer::get_free_buffer() const
  192. {
  193.   Uint32 tReadIndex  = * m_sharedReadIndex;
  194.   Uint32 tWriteIndex = m_writeIndex;
  195.   
  196.   Uint32 free;
  197.   if(tReadIndex <= tWriteIndex){
  198.     free = m_bufferSize + tReadIndex - tWriteIndex;
  199.   } else {
  200.     free = tReadIndex - tWriteIndex;
  201.   }
  202.   return free;
  203. }
  204.  
  205. #endif