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

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

MySQL数据库

开发平台：

Visual C++

DataBuffer.hpp：源码内容
  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. #ifndef DATA_BUFFER_HPP
  18. #define DATA_BUFFER_HPP
  20. #include "ArrayPool.hpp"
  22. /**
  23.  * @class  DataBuffer
  24.  * @brief  Buffer of data words
  25.  * 
  26.  * @note   The buffer is divided into segments (of size sz)
  27.  */
  28. template <Uint32 sz>
  29. class DataBuffer {
  30. public:
  31.   struct Segment {
  32.     Uint32 nextPool;
  33.     Uint32 data[sz];
  34.     NdbOut& print(NdbOut& out){
  35.       out << "[DataBuffer<" << sz << ">::Segment this=" 
  36.   << this << dec << " nextPool= "
  37.   << nextPool << " ]";
  38.       return out;
  39.     }
  40.   };
  41. public:
  42.   typedef ArrayPool<Segment> DataBufferPool;
  44.   /**
  45.    * Head/anchor for data buffer
  46.    */
  47.   struct Head {
  48.     Head() ;
  50.     Uint32 used;       // Words used
  51.     Uint32 firstItem;  // First segment (or RNIL)
  52.     Uint32 lastItem;   // Last segment (or RNIL)
  54.     /** 
  55.      * Get size of databuffer, in words
  56.      */
  57.     Uint32 getSize() const { return used;}
  58.     
  59.     /** 
  60.      * Get segment size in words (template argument) 
  61.      */
  62.     static Uint32 getSegmentSize() { return sz;}
  63.   };
  65.   /** Constructor */
  66.   DataBuffer(DataBufferPool &);
  68.   /** Seize <b>n</b> words, Release */
  69.   bool seize(Uint32 n);
  70.   void release();
  72.   /** 
  73.    * Get size of databuffer, in words
  74.    */
  75.   Uint32 getSize() const;
  76.   
  77.   /** 
  78.    * Check if buffer is empty
  79.    */
  80.   bool isEmpty() const;
  81.   
  82.   /**
  83.    * Get segment size in words (template argument) 
  84.    */
  85.   static Uint32 getSegmentSize();
  86.   
  87.   void print(FILE*) const;
  89.   /* ----------------------------------------------------------------------- */
  91.   struct DataBufferIterator {
  92.     Ptr<Segment>       curr;  // Ptr to current segment
  93.     Uint32*            data;  // Pointer to current data (word)
  94.     Uint32             ind;   // Word index within a segment
  95.     Uint32             pos;   // Absolute word position within DataBuffer
  97.     void print(FILE* out) {
  98.       fprintf(out, "[DataBufferIterator curr.i=%d, data=%p, ind=%d, pos=%d]n",
  99.       curr.i, (void*) data, ind, pos);
  100.     };
  102.     inline bool isNull() const { return curr.isNull();}
  103.     inline void setNull() { curr.setNull(); data = 0; ind = pos = RNIL;}
  104.   };
  105.   
  106.   struct ConstDataBufferIterator {
  107.     ConstPtr<Segment>  curr;
  108.     const Uint32 *     data;
  109.     Uint32             ind;
  110.     Uint32             pos;
  112.     inline bool isNull() const { return curr.isNull();}
  113.     inline void setNull() { curr.setNull(); data = 0; ind = pos = RNIL;}
  114.   };
  116.   /** 
  117.    * Iterator 
  118.    * @parameter hops  Number of words to jump forward
  119.    * @note DataBuffer::next returns false if applied to last word.
  120.    */
  121.   bool first(DataBufferIterator &);
  122.   bool next(DataBufferIterator &);
  123.   bool next(DataBufferIterator &, Uint32 hops);
  124.   bool nextPool(DataBufferIterator &);
  126.   /**
  127.    * Set iterator to position
  128.    */
  129.   bool position(DataBufferIterator& it, Uint32 pos);
  131.   /** Iterator */
  132.   bool first(ConstDataBufferIterator &) const;
  133.   bool next(ConstDataBufferIterator &) const;
  134.   bool next(ConstDataBufferIterator &, Uint32 hops) const;
  135.   bool nextPool(ConstDataBufferIterator &) const;
  137.   /** 
  138.    * Returns true if it is possible to store <em>len</em> 
  139.    * no of words at position given in iterator.
  140.    */
  141.   bool importable(const DataBufferIterator, Uint32 len);
  143.   /**
  144.    * Stores <em>len</em> no of words starting at location <em>src</em> in
  145.    * databuffer at position given in iterator.
  146.    * 
  147.    * @return true if success, false otherwise.
  148.    * @note Iterator is not advanced.
  149.    */
  150.   bool import(const DataBufferIterator &, const Uint32* src, Uint32 len);
  152.   /**
  153.    * Increases size with appends <em>len</em> words
  154.    * @return true if success, false otherwise.
  155.    */
  156.   bool append(const Uint32* src, Uint32 len);
  158. protected:
  159.   Head head;
  160.   DataBufferPool &  thePool;
  162. private:
  163.   /**
  164.    * This is NOT a public method, since the intension is that the import
  165.    * method using iterators will be more effective in the future 
  166.    */
  167.   bool import(Uint32 pos, const Uint32* src, Uint32 len);
  168. };
  170. template<Uint32 sz>
  171. class LocalDataBuffer : public DataBuffer<sz> {
  172. public:
  173.   LocalDataBuffer(typename DataBuffer<sz>::DataBufferPool & thePool, 
  174.   typename DataBuffer<sz>::Head & _src)
  175.     : DataBuffer<sz>(thePool), src(_src)
  176.   {
  177.     this->head = src;
  178.   }
  179.   
  180.   ~LocalDataBuffer(){
  181.     src = this->head;
  182.   }
  183. private:
  184.   typename DataBuffer<sz>::Head & src;
  185. };
  187. template<Uint32 sz>
  188. inline
  189. DataBuffer<sz>::Head::Head(){
  190.   used = 0;
  191.   firstItem = RNIL;
  192.   lastItem = RNIL;
  193. }
  195. template<Uint32 sz>
  196. inline
  197. bool DataBuffer<sz>::importable(const DataBufferIterator it, Uint32 len){
  198.   return (it.pos + len < head.used);
  199. }
  201. template<Uint32 sz>
  202. inline
  203. bool DataBuffer<sz>::position(DataBufferIterator& it, Uint32 p){
  205.   // TODO: The current implementation is not the most effective one.
  206.   //       A more effective implementation would start at the current 
  207.   //       position of the iterator.
  209.   if(!first(it)){
  210.     return false;
  211.   }
  212.   return next(it, p);
  213. }
  214.   
  215. template<Uint32 sz>
  216. inline
  217. bool 
  218. DataBuffer<sz>::import(const DataBufferIterator & it, 
  219.        const Uint32* src, Uint32 len){
  221. #if 0
  222.   DataBufferIterator it;
  223.   position(it, _it.pos);
  224.   
  225.   for(; len > 0; len--){
  226.     Uint32 s = * src;
  227.     * it.data = s;
  228.     next(it);
  229.     src++;
  230.   }
  231.   return true;
  232. #else
  233.   Uint32 ind = (it.pos % sz);
  234.   Uint32 left = sz  - ind;
  235.   Segment * p = it.curr.p;
  237.   while(len > left){
  238.     memcpy(&p->data[ind], src, 4 * left);
  239.     src += left;
  240.     len -= left;
  241.     ind = 0;
  242.     left = sz;
  243.     p = thePool.getPtr(p->nextPool);
  244.   }
  245.   
  246.   memcpy(&p->data[ind], src, 4 * len);      
  247.   return true;
  248. #endif
  249. }
  251. template<Uint32 sz>
  252. inline
  253. bool 
  254. DataBuffer<sz>::append(const Uint32* src, Uint32 len){
  255.   if(len == 0)
  256.     return true;
  257.   
  258.   Uint32 pos = head.used;
  259.   if(!seize(len)){
  260.     return false;
  261.   }
  262.   DataBufferIterator it;
  263.   
  264.   if(position(it, pos) && import(it, src, len)){
  265.     return true;
  266.   }
  267.   abort();
  268.   return false;
  269. }
  271. template<Uint32 sz>
  272. inline
  273. void DataBuffer<sz>::print(FILE* out) const {
  274.   fprintf(out, "[DataBuffer used=%d words, segmentsize=%d words",
  275.   head.used, sz);
  277.   if (head.firstItem == RNIL) {
  278.     fprintf(out, ": No segments seized.]n");
  279.     return;
  280.   } else {
  281.     fprintf(out, "n");
  282.   }
  284.   Ptr<Segment> ptr;
  285.   ptr.i = head.firstItem;
  286.   
  287.   Uint32 acc = 0;
  288.   for(; ptr.i != RNIL; ){
  289.     thePool.getPtr(ptr);
  290.     const Uint32 * rest = ptr.p->data;
  291.     for(Uint32 i = 0; i<sz; i++){
  292.       fprintf(out, " H'%.8x", rest[i]);
  293.       if(acc++ == 6){
  294. acc = 0;
  295. fprintf(out, "n");
  296.       }
  297.     }
  298.     ptr.i = ptr.p->nextPool;
  299.   }
  300.   fprintf(out, " ]n");
  301. }
  303. template<Uint32 sz>
  304. inline
  305. DataBuffer<sz>::DataBuffer(DataBufferPool & p) : thePool(p){
  306. }
  308. template<Uint32 sz>
  309. inline
  310. bool
  311. DataBuffer<sz>::seize(Uint32 n){
  312.   Uint32 rest; // Free space in last segment (currently)
  313.   Segment* prevPtr;
  315.   if(head.firstItem == RNIL){
  316.     rest = 0;
  317.     prevPtr = (Segment*)&head.firstItem;
  318.   } else {
  319.     rest = (sz - (head.used % sz)) % sz;
  320.     prevPtr = thePool.getPtr(head.lastItem);
  321.   }
  322.   
  323.   /**
  324.    * Check for space
  325.    */
  326.   Uint32 free = thePool.getNoOfFree() * sz + rest;
  327.   if(n > free){
  328.     release();
  329.     return false;
  330.   }
  331.     
  332.   Uint32 used = head.used + n;
  333.   Ptr<Segment> currPtr; 
  334.   currPtr.i = head.lastItem;
  335.   
  336.   while(n >= sz){
  337.     if(0)
  338.       ndbout_c("n(%d) %c sz(%d)", n, (n>sz?'>':(n<sz?'<':'=')), sz);    
  340.     thePool.seize(currPtr); assert(currPtr.i != RNIL);
  341.     prevPtr->nextPool = currPtr.i;
  342.      
  343.     prevPtr = currPtr.p;
  344.     prevPtr->nextPool = RNIL;
  345.     n -= sz;
  346.   }
  347.   
  348.   if(0){
  349.     Uint32 pos = rest + n;
  350.     ndbout_c("rest(%d), n(%d) pos=%d %c sz(%d)", 
  351.      rest, n, pos, (pos>sz?'>':(pos<sz?'<':'=')), sz);
  352.   }
  353.   
  354.   if(n > rest){
  355.     thePool.seize(currPtr);
  356.     assert(currPtr.i != RNIL);
  357.     prevPtr->nextPool = currPtr.i;
  358.     currPtr.p->nextPool = RNIL;
  359.   }
  360.   
  361.   head.used = used;
  362.   head.lastItem = currPtr.i;
  363.   
  364. #if 0
  365.   {
  366.     ndbout_c("Before validate - %d", head.used);
  367.     if(head.used == 0){
  368.       assert(head.firstItem == RNIL);
  369.       assert(head.lastItem == RNIL);
  370.     } else {
  371.       Ptr<Segment> tmp;
  372.       tmp.i = head.firstItem;
  373.       for(Uint32 i = head.used; i > sz; i -= sz){
  374. ndbout << tmp.i << " ";
  375. tmp.p = thePool.getPtr(tmp.i);
  376. tmp.i = tmp.p->nextPool;
  377.       }
  378.       ndbout_c("%d", tmp.i);
  379.       assert(head.lastItem == tmp.i);
  380.     }
  381.     ndbout_c("After validate");
  382.   }
  383. #endif
  384.   return true;
  385. }
  387. template<Uint32 sz>
  388. inline
  389. void
  390. DataBuffer<sz>::release(){
  391.   Uint32 used = head.used + sz - 1;
  392.   if(head.firstItem != RNIL){
  393.     thePool.releaseList(used / sz, head.firstItem, head.lastItem);
  394.     head.used = 0;
  395.     head.firstItem = RNIL;
  396.     head.lastItem = RNIL;
  397.   }
  398. }
  400. template<Uint32 sz>
  401. inline
  402. Uint32
  403. DataBuffer<sz>::getSegmentSize(){
  404.   return sz;
  405. }
  407. template<Uint32 sz>
  408. inline
  409. bool
  410. DataBuffer<sz>::first(DataBufferIterator & it){
  411.   return first((ConstDataBufferIterator&)it);
  412. }
  414. template<Uint32 sz>
  415. inline
  416. bool
  417. DataBuffer<sz>::next(DataBufferIterator & it){
  418.   return next((ConstDataBufferIterator&)it);
  419. }
  421. template<Uint32 sz>
  422. inline
  423. bool
  424. DataBuffer<sz>::next(DataBufferIterator & it, Uint32 hops){
  425.   return next((ConstDataBufferIterator&)it, hops);
  426. }
  428. template<Uint32 sz>
  429. inline
  430. bool
  431. DataBuffer<sz>::first(ConstDataBufferIterator & it) const {
  432.   it.curr.i = head.firstItem;
  433.   if(it.curr.i == RNIL){
  434.     it.setNull();
  435.     return false;
  436.   }
  437.   thePool.getPtr(it.curr);
  438.   it.data = &it.curr.p->data[0];
  439.   it.ind = 0;
  440.   it.pos = 0;
  441.   return true;
  442. }
  444. template<Uint32 sz>
  445. inline
  446. bool
  447. DataBuffer<sz>::next(ConstDataBufferIterator & it) const {
  448.   it.ind ++;
  449.   it.data ++;
  450.   it.pos ++;
  451.   if(it.ind < sz && it.pos < head.used){
  452.     return true;
  453.   }
  455.   if(it.pos < head.used){
  456.     it.curr.i = it.curr.p->nextPool;
  457. #ifdef ARRAY_GUARD    
  458.     if(it.curr.i == RNIL){
  459.       /**
  460.        * This is actually "internal error"
  461.        * pos can't be less than head.used and at the same time we can't 
  462.        * find next segment
  463.        * 
  464.        * Note this must not "really" be checked since thePool.getPtr will
  465.        *  abort when trying to get RNIL. That's why the check is within
  466.        *  ARRAY_GUARD
  467.        */
  468.       ErrorReporter::handleAssert("DataBuffer<sz>::next", __FILE__, __LINE__);
  469.     }
  470. #endif
  471.     thePool.getPtr(it.curr);
  472.     it.data = &it.curr.p->data[0];
  473.     it.ind = 0;
  474.     return true;
  475.   }
  476.   it.setNull();
  477.   return false;
  478. }
  480. template<Uint32 sz>
  481. inline
  482. bool
  483. DataBuffer<sz>::next(ConstDataBufferIterator & it, Uint32 hops) const {
  484. #if 0
  485.   for (Uint32 i=0; i<hops; i++) {
  486.     if (!this->next(it))
  487.       return false;
  488.   }
  489.   return true;
  490. #else
  491.   if(it.pos + hops < head.used){
  492.     while(hops >= sz){
  493.       it.curr.i = it.curr.p->nextPool;
  494.       thePool.getPtr(it.curr);
  495.       hops -= sz;
  496.       it.pos += sz;
  497.     }
  499.     it.ind += hops;
  500.     it.pos += hops;
  501.     if(it.ind < sz){
  502.       it.data = &it.curr.p->data[it.ind];
  503.       return true;
  504.     }
  505.     
  506.     it.curr.i = it.curr.p->nextPool;
  507.     thePool.getPtr(it.curr);
  508.     it.ind -= sz;
  509.     it.data = &it.curr.p->data[it.ind];
  510.     return true;
  511.   }
  512.   it.setNull();
  513.   return false;
  514. #endif
  515. }
  517. template<Uint32 sz>
  518. inline
  519. Uint32
  520. DataBuffer<sz>::getSize() const {
  521.   return head.used;
  522. }
  524. template<Uint32 sz>
  525. inline
  526. bool
  527. DataBuffer<sz>::isEmpty() const {
  528.   return (head.used == 0);
  529. }
  531. #endif