thrift之TTransport層的緩存?zhèn)鬏旑怲BufferedTransport和緩沖基類TBufferBase

　　class TBufferBase : public TVirtualTransport<TBufferBase> {
　　 public:
　　  uint32_t read(uint8_t* buf, uint32_t len) {//讀函數(shù)
　　    uint8_t* new_rBase = rBase_ + len;//得到需要讀到的緩存邊界
　　    if (TDB_LIKELY(new_rBase <= rBound_)) {//判斷緩存是否有足夠的數(shù)據(jù)可讀，采用了分支預(yù)測技術(shù)
　　      std::memcpy(buf, rBase_, len);//直接內(nèi)存拷貝
　　      rBase_ = new_rBase;//更新新的緩存讀基地址
　　      return len;//返回讀取的長度
　　    }
　　    return readSlow(buf, len);//如果緩存已經(jīng)不能夠滿足讀取長度需要就執(zhí)行慢讀
　　  }
　　  uint32_t readAll(uint8_t* buf, uint32_t len) {
　　    uint8_t* new_rBase = rBase_ + len;//同read函數(shù)
　　    if (TDB_LIKELY(new_rBase <= rBound_)) {
　　      std::memcpy(buf, rBase_, len);
　　      rBase_ = new_rBase;
　　      return len;
　　    }
　　    return apache::thrift::transport::readAll(*this, buf, len);//調(diào)用父類的
　　  }
　　  void write(const uint8_t* buf, uint32_t len) {//快速寫函數(shù)
　　    uint8_t* new_wBase = wBase_ + len;//寫入后的新緩存基地址
　　    if (TDB_LIKELY(new_wBase <= wBound_)) {//判斷緩存是否有足夠的空間可以寫入
　　      std::memcpy(wBase_, buf, len);//內(nèi)存拷貝
　　      wBase_ = new_wBase;//更新基地址
　　      return;
　　    }
　　    writeSlow(buf, len);//緩存空間不足就調(diào)用慢寫函數(shù)
　　  }
　　  const uint8_t* borrow(uint8_t* buf, uint32_t* len) {//快速路徑借
　　    if (TDB_LIKELY(static_cast<ptrdiff_t>(*len) <= rBound_ - rBase_)) {//判斷是否足夠借的長度
　　      *len = static_cast<uint32_t>(rBound_ - rBase_);
　　      return rBase_;//返回借的基地址
　　    }
　　    return borrowSlow(buf, len);//不足就采用慢路徑借
　　  }
　　  void consume(uint32_t len) {//消費函數(shù)
　　    if (TDB_LIKELY(static_cast<ptrdiff_t>(len) <= rBound_ - rBase_)) {//判斷緩存是否夠消費
　　      rBase_ += len;//更新已經(jīng)消耗的長度
　　    } else {
　　      throw TTransportException(TTransportException::BAD_ARGS,
　　                                "consume did not follow a borrow.");//不足拋異常
　　    }
　　  }
　　 protected:
　　  virtual uint32_t readSlow(uint8_t* buf, uint32_t len) = 0;//慢函數(shù)
　　  virtual void writeSlow(const uint8_t* buf, uint32_t len) = 0;
　　  virtual const uint8_t* borrowSlow(uint8_t* buf, uint32_t* len) = 0;
　　  TBufferBase()
　　    : rBase_(NULL)
　　    , rBound_(NULL)
　　    , wBase_(NULL)
　　    , wBound_(NULL)
　　  {}//構(gòu)造函數(shù)，把所有的緩存空間設(shè)置為NULL
　　  void setReadBuffer(uint8_t* buf, uint32_t len) {//設(shè)置讀緩存空間地址
　　    rBase_ = buf;//讀緩存開始地址
　　    rBound_ = buf+len;//讀緩存地址界限
　　  }
　　  void setWriteBuffer(uint8_t* buf, uint32_t len) {//設(shè)置寫緩存地址空間
　　    wBase_ = buf;//起
　　    wBound_ = buf+len;//邊界
　　  }
　　  virtual ~TBufferBase() {}
　　  uint8_t* rBase_;//讀從這兒開始
　　  uint8_t* rBound_;//讀界限
　　  uint8_t* wBase_;//寫開始地址
　　  uint8_t* wBound_;//寫界限
　　};

　　  bool peek() {
　　    if (rBase_ == rBound_) {//判斷讀的基地址與讀邊界是否重合了，也就是已經(jīng)讀取完畢
　　      setReadBuffer(rBuf_.get(), transport_->read(rBuf_.get(), rBufSize_));//是：重新讀取底層來的數(shù)據(jù)
　　    }
　　    return (rBound_ > rBase_);//邊界大于基地址就是有未決狀態(tài)數(shù)據(jù)
　　  }

　　uint32_t TBufferedTransport::readSlow(uint8_t* buf, uint32_t len) {
　　  uint32_t have = rBound_ - rBase_;//計算還有多少數(shù)據(jù)在緩存中
　　
　　  // 如果讀取緩存中已經(jīng)存在的數(shù)據(jù)不能滿足我們，
　　  // 我們（也僅僅在這種情況下）應(yīng)該才從慢路徑讀數(shù)據(jù)。
　　  assert(have < len);
　　
　　  // 如果我們有一些數(shù)據(jù)在緩存，拷貝出來并返回它
　　  // 我們不得不返回它而去嘗試讀更多的數(shù)據(jù)，因為我們不能保證
　　  // 下層傳輸實際有更多的數(shù)據(jù)， 因此嘗試阻塞式讀取它。
　　  if (have > 0) {
　　    memcpy(buf, rBase_, have);//拷貝數(shù)據(jù)
　　    setReadBuffer(rBuf_.get(), 0);//設(shè)置讀緩存，基類實現(xiàn)該函數(shù)
　　    return have;//返回緩存中已經(jīng)存在的不完整數(shù)據(jù)
　　  }
　　
　　  // 在我們的緩存中沒有更多的數(shù)據(jù)可用。從下層傳輸?shù)玫礁嘁赃_(dá)到buffer的大小。
　　  // 注意如果len小于rBufSize_可能會產(chǎn)生多種場景否則幾乎是沒有意義的。
　　  setReadBuffer(rBuf_.get(), transport_->read(rBuf_.get(), rBufSize_));//讀取數(shù)據(jù)并設(shè)置讀緩存
　　
　　  // 處理我們已有的數(shù)據(jù)
　　  uint32_t give = std::min(len, static_cast<uint32_t>(rBound_ - rBase_));
　　  memcpy(buf, rBase_, give);
　　  rBase_ += give;
　　
　　  return give;
　　}

　　void TBufferedTransport::writeSlow(const uint8_t* buf, uint32_t len) {
　　  uint32_t have_bytes = wBase_ - wBuf_.get();//計算寫緩存區(qū)中已有的字節(jié)數(shù)
　　  uint32_t space = wBound_ - wBase_;//計算剩余寫緩存空間
　　  // 如果在緩存區(qū)的空閑空間不能容納我們的數(shù)據(jù)，我們采用慢路徑寫（僅僅）
　　  assert(wBound_ - wBase_ < static_cast<ptrdiff_t>(len));
　　
       //已有數(shù)據(jù)加上需要寫入的數(shù)據(jù)是否大于2倍寫緩存區(qū)或者緩存區(qū)為空
　　  if ((have_bytes + len >= 2*wBufSize_) || (have_bytes == 0)) {
　　    if (have_bytes > 0) {//緩存大于0且加上需要再寫入數(shù)據(jù)的長度大于2倍緩存區(qū)
　　      transport_->write(wBuf_.get(), have_bytes);//先將已有數(shù)據(jù)寫入下層傳輸
　　    }
　　    transport_->write(buf, len);//寫入這次的len長度的數(shù)據(jù)
　　    wBase_ = wBuf_.get();//重新得到寫緩存的基地址
　　    return;
　　  }
　　
　　  memcpy(wBase_, buf, space);//填充我們的內(nèi)部緩存區(qū)為了寫
　　  buf += space;
　　  len -= space;
　　  transport_->write(wBuf_.get(), wBufSize_);//寫入下層傳輸
　　
　　  assert(len < wBufSize_);
　　  memcpy(wBuf_.get(), buf, len);//拷貝剩余的數(shù)據(jù)到我們的緩存
　　  wBase_ = wBuf_.get() + len;//重新得到寫緩存基地址
　　  return;
　　}

　　const uint8_t* TBufferedTransport::borrowSlow(uint8_t* buf, uint32_t* len) {
　　  (void) buf;
　　  (void) len;
　　  return NULL;//默認(rèn)返回空
　　}