Op: Make the functions in DataBuffer inline

`DataBuffer` is the basic buffer manager of pax.

Make frequently called methods to inline can reduce some instruction calls.

Author: jiaqizho

contrib/pax_storage/src/cpp/storage/pax_buffer.cc

@@ -25,16 +25,6 @@ void BlockBufferBase::Set(char *ptr, size_t size) {
   block_pos_ = ptr;
 }
 
-void BlockBufferBase::Write(char *ptr, size_t size) {
-  Assert(block_pos_ + size <= block_buffer_.End());
-  memcpy(block_pos_, ptr, size);
-}
-
-void BlockBufferBase::WriteZero(size_t size) {
-  Assert(block_pos_ + size <= block_buffer_.End());
-  memset(block_pos_, 0, size);
-}
-
 void BlockBufferBase::Combine(const BlockBufferBase &buffer) {
   Assert(Available() > buffer.Used());
   Write(buffer.block_buffer_.Start(), buffer.Used());
@@ -62,16 +52,6 @@ template <typename T>  // NOLINT: redirect constructor
 DataBuffer<T>::DataBuffer(size_t size)
     : DataBuffer(nullptr, size, false, true) {}
 
-template <typename T>
-T &DataBuffer<T>::operator[](size_t i) {
-  return data_buffer_[i];
-}
-
-template <typename T>
-size_t DataBuffer<T>::GetSize() {
-  return Used() / sizeof(T);
-}
-
 template <typename T>
 DataBuffer<T>::~DataBuffer() {
   if (mem_take_over_ && data_buffer_) {
@@ -100,46 +80,6 @@ void DataBuffer<T>::Reset() {
   data_buffer_ = nullptr;
 }
 
-template <typename T>
-void DataBuffer<T>::Write(T value) {
-  Assert(block_pos_ + sizeof(T) <= block_buffer_.End());
-  *(reinterpret_cast<T *>(block_pos_)) = value;
-}
-
-template <typename T>
-void DataBuffer<T>::Write(T *ptr, size_t size) {
-  Assert(size % sizeof(T) == 0 && (block_pos_ + size) <= block_buffer_.End());
-  memcpy(block_pos_, reinterpret_cast<const char *>(ptr), size);
-}
-
-template <typename T>
-void DataBuffer<T>::Write(const T *ptr, size_t size) {
-  Assert(size % sizeof(T) == 0 && (block_pos_ + size) <= block_buffer_.End());
-  memcpy(block_pos_, reinterpret_cast<const char *>(ptr), size);
-}
-
-template <typename T>
-void DataBuffer<T>::Read(T *dst) {
-  Assert(Used() > sizeof(T) && Used() <= Capacity());
-  memcpy(dst, block_pos_, sizeof(T));
-}
-
-template <typename T>
-void DataBuffer<T>::Read(void *dst, size_t n) {
-  Assert(Used() > n && Used() <= Capacity());
-  memcpy(dst, block_pos_, n);
-}
-
-template <typename T>
-T *DataBuffer<T>::GetBuffer() const {
-  return data_buffer_;
-}
-
-template <typename T>
-T *DataBuffer<T>::GetAvailableBuffer() const {
-  return data_buffer_ + Used();
-}
-
 template <typename T>
 void DataBuffer<T>::ReSize(size_t size, double mul_ratio) {
   Assert(mul_ratio > 1);
@@ -175,24 +115,6 @@ void DataBuffer<T>::ReSize(size_t size) {
   BlockBufferBase::Set(reinterpret_cast<char *>(data_buffer_), size, used);
 }
 
-template <typename T>
-bool DataBuffer<T>::IsMemTakeOver() const {
-  return mem_take_over_;
-}
-
-template <typename T>
-void DataBuffer<T>::SetMemTakeOver(bool take_over) {
-  mem_take_over_ = take_over;
-}
-
-template <typename T>
-void DataBuffer<T>::Clear() {
-  if (mem_take_over_ && data_buffer_) {
-    cbdb::Pfree(data_buffer_);
-  }
-  data_buffer_ = nullptr;
-}
-
 template class DataBuffer<char>;
 template class DataBuffer<int8>;
 template class DataBuffer<int16>;

contrib/pax_storage/src/cpp/storage/pax_buffer.h

@@ -77,9 +77,16 @@ class BlockBufferBase {
 
   virtual void Set(char *ptr, size_t size);
 
-  void Write(char *ptr, size_t size);
+  inline void Write(char *ptr, size_t size) {
+    Assert(block_pos_ + size <= block_buffer_.End());
+    memcpy(block_pos_, ptr, size);
+  }
+
+  inline void WriteZero(size_t size) {
+    Assert(block_pos_ + size <= block_buffer_.End());
+    memset(block_pos_, 0, size);
+  }
 
-  void WriteZero(size_t size);
 
   void Combine(const BlockBufferBase &buffer);
 
@@ -139,12 +146,16 @@ class DataBuffer : public BlockBufferBase {
         data_buffer_(reinterpret_cast<T *>(data_buffer.data_buffer_)) {}
 
   // Direct access elements of internal buffer
-  T &operator[](size_t i);
+  inline T &operator[](size_t i) {
+    return data_buffer_[i];
+  }
 
-  T *StartT() const { return data_buffer_; }
+  inline T *StartT() const { return data_buffer_; }
 
   // Get size of elements of internal buffer
-  size_t GetSize();
+  inline size_t GetSize() {
+    return Used() / sizeof(T);
+  }
 
   ~DataBuffer() override;
 
@@ -160,22 +171,41 @@ class DataBuffer : public BlockBufferBase {
 
   // Direct write a element into available buffer
   // Should call `Brush` after write
-  virtual void Write(T value);
+  inline void Write(T value) {
+    Assert(block_pos_ + sizeof(T) <= block_buffer_.End());
+    *(reinterpret_cast<T *>(block_pos_)) = value;
+  }
 
-  virtual void Write(T *ptr, size_t size);
+  inline void Write(T *ptr, size_t size) {
+    Assert(size % sizeof(T) == 0 && (block_pos_ + size) <= block_buffer_.End());
+    memcpy(block_pos_, reinterpret_cast<const char *>(ptr), size);
+  }
 
-  virtual void Write(const T *ptr, size_t size);
+  inline void Write(const T *ptr, size_t size) {
+    Assert(size % sizeof(T) == 0 && (block_pos_ + size) <= block_buffer_.End());
+    memcpy(block_pos_, reinterpret_cast<const char *>(ptr), size);
+  }
 
   // Read all to dst pointer
-  virtual void Read(T *dst);
+  inline void Read(T *dst) {
+    Assert(Used() > sizeof(T) && Used() <= Capacity());
+    memcpy(dst, block_pos_, sizeof(T));
+  }
 
-  virtual void Read(void *dst, size_t n);
+  inline void Read(void *dst, size_t n) {
+    Assert(Used() > n && Used() <= Capacity());
+    memcpy(dst, block_pos_, n);
+  }
 
   // Get the internal buffer pointer
-  T *GetBuffer() const;
+  inline T *GetBuffer() const {
+    return data_buffer_;
+  }
 
   // Get the available buffer pointer
-  T *GetAvailableBuffer() const;
+  inline T *GetAvailableBuffer() const {
+    return data_buffer_ + Used();
+  }
 
   // Resize the internal buffer, size should bigger than capacity of internal
   // buffer `mem_take_over` should be true
@@ -188,13 +218,22 @@ class DataBuffer : public BlockBufferBase {
   virtual void ReSize(size_t size);
 
   // Is current internal buffer take over by DataBuffer
-  bool IsMemTakeOver() const;
+  inline bool IsMemTakeOver() const {
+    return mem_take_over_;
+  }
 
-  void SetMemTakeOver(bool take_over);
+  inline void SetMemTakeOver(bool take_over) {
+    mem_take_over_ = take_over;
+  }
 
   // Clear up the DataBuffer
   // Caller should call `Set` to reuse current `DataBuffer` after call `Clear`
-  virtual void Clear();
+  inline void Clear() {
+    if (mem_take_over_ && data_buffer_) {
+      cbdb::Pfree(data_buffer_);
+    }
+    data_buffer_ = nullptr;
+  }
 
  protected:
   bool mem_take_over_;