[refactor](inverted_index) replace custom memory pool with doris built-in arena (apache#52334)

### What problem does this PR solve?

Replace the custom memory pool implementation with Doris built-in arena 
to improve memory management consistency and reduce code maintenance
overhead.

Author: Ryan19929

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/AnalyzeContext.cpp

@@ -19,15 +19,15 @@
 
 namespace doris::segment_v2 {
 
-AnalyzeContext::AnalyzeContext(IKMemoryPool<Cell>& pool, std::shared_ptr<Configuration> config)
+AnalyzeContext::AnalyzeContext(vectorized::Arena& arena, std::shared_ptr<Configuration> config)
         : segment_buff_(),
           typed_runes_(),
           buffer_offset_(0),
           cursor_(0),
           available_(0),
           last_useless_char_num_(0),
           buffer_locker_(0),
-          org_lexemes_(pool),
+          org_lexemes_(arena),
           path_map_(),
           results_(),
           config_(config) {

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/AnalyzeContext.h

@@ -34,6 +34,8 @@
 #include "common/logging.h"
 #include "olap/rowset/segment_v2/inverted_index/analyzer/ik/cfg/Configuration.h"
 #include "olap/rowset/segment_v2/inverted_index/analyzer/ik/dic/Dictionary.h"
+#include "vec/common/arena.h"
+
 namespace doris::segment_v2 {
 
 class AnalyzeContext {
@@ -80,7 +82,7 @@ class AnalyzeContext {
         SURROGATE_PAIR_SEGMENTER
     };
     const CharacterUtil::TypedRuneArray& getTypedRuneArray() const { return typed_runes_; }
-    explicit AnalyzeContext(IKMemoryPool<Cell>& pool, std::shared_ptr<Configuration> config);
+    explicit AnalyzeContext(vectorized::Arena& arena, std::shared_ptr<Configuration> config);
     virtual ~AnalyzeContext();
 
     void reset();

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/IKArbitrator.cpp

@@ -22,7 +22,7 @@ namespace doris::segment_v2 {
 void IKArbitrator::process(AnalyzeContext& context, bool use_smart) {
     auto org_lexemes = context.getOrgLexemes();
     auto org_lexeme = org_lexemes->pollFirst();
-    LexemePath* cross_path = new LexemePath(pool_);
+    LexemePath* cross_path = new LexemePath(arena_);
 
     auto process_path = [&](LexemePath* path) {
         if (path->size() == 1 || !use_smart) {
@@ -43,7 +43,7 @@ void IKArbitrator::process(AnalyzeContext& context, bool use_smart) {
             // Find the next crossPath that does not intersect with crossPath.
             process_path(cross_path);
             // Add orgLexeme to the new crossPath
-            cross_path = new LexemePath(pool_);
+            cross_path = new LexemePath(arena_);
             cross_path->addCrossLexeme(*org_lexeme);
         }
         org_lexeme = org_lexemes->pollFirst();
@@ -56,12 +56,12 @@ void IKArbitrator::process(AnalyzeContext& context, bool use_smart) {
 // Performs ambiguity resolution on a given lexeme path.
 LexemePath* IKArbitrator::judge(Cell* lexeme_cell, size_t full_text_length) {
     // Candidate result path
-    LexemePath* path_option = new LexemePath(pool_);
+    LexemePath* path_option = new LexemePath(arena_);
 
     // Traverse crossPath once and return the stack of conflicting Lexemes
     std::stack<Cell*, std::vector<Cell*>> lexemeStack;
     forwardPath(lexeme_cell, path_option, lexemeStack);
-    LexemePath* best_path = new LexemePath(*path_option, pool_);
+    LexemePath* best_path = new LexemePath(*path_option, arena_);
 
     // Process ambiguous words if they exist
     while (!lexemeStack.empty()) {
@@ -71,7 +71,7 @@ LexemePath* IKArbitrator::judge(Cell* lexeme_cell, size_t full_text_length) {
         forwardPath(c, path_option);
         if (*path_option < *best_path) {
             delete best_path;
-            best_path = new LexemePath(*path_option, pool_);
+            best_path = new LexemePath(*path_option, arena_);
         }
     }
     delete path_option;

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/IKArbitrator.h

@@ -29,12 +29,12 @@ namespace doris::segment_v2 {
 
 class IKArbitrator {
 public:
-    IKArbitrator(IKMemoryPool<Cell>& pool) : pool_(pool) {}
+    IKArbitrator(vectorized::Arena& arena) : arena_(arena) {}
     // Ambiguity handling
     void process(AnalyzeContext& context, bool use_smart);
 
 private:
-    IKMemoryPool<Cell>& pool_;
+    vectorized::Arena& arena_;
     // Ambiguity identification
     LexemePath* judge(Cell* lexeme_cell, size_t full_text_length);
 

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/IKSegmenter.cpp

@@ -19,14 +19,12 @@
 
 namespace doris::segment_v2 {
 
-constexpr size_t DEFAULT_MEMORY_POOL_SIZE = 512;
-
 IKSegmenter::IKSegmenter(std::shared_ptr<Configuration> config)
-        : pool_(DEFAULT_MEMORY_POOL_SIZE),
+        : arena_(),
           config_(config),
-          context_(std::make_unique<AnalyzeContext>(pool_, config_)),
+          context_(std::make_unique<AnalyzeContext>(arena_, config_)),
           segmenters_(loadSegmenters()),
-          arbitrator_(IKArbitrator(pool_)) {}
+          arbitrator_(IKArbitrator(arena_)) {}
 
 std::vector<std::unique_ptr<ISegmenter>> IKSegmenter::loadSegmenters() {
     std::vector<std::unique_ptr<ISegmenter>> segmenters;
@@ -62,6 +60,7 @@ bool IKSegmenter::next(Lexeme& lexeme) {
         arbitrator_.process(*context_, config_->isUseSmart());
         context_->outputToResult();
         context_->markBufferOffset();
+        arena_.clear();
     }
     return true;
 }

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/IKSegmenter.h

@@ -29,6 +29,7 @@
 #include "LetterSegmenter.h"
 #include "SurrogatePairSegmenter.h"
 #include "olap/rowset/segment_v2/inverted_index/analyzer/ik/cfg/Configuration.h"
+#include "vec/common/arena.h"
 namespace doris::segment_v2 {
 
 class IKSegmenter {
@@ -40,7 +41,7 @@ class IKSegmenter {
 
 private:
     std::vector<std::unique_ptr<ISegmenter>> loadSegmenters();
-    IKMemoryPool<Cell> pool_;
+    vectorized::Arena arena_;
     lucene::util::Reader* input_;
     std::shared_ptr<Configuration> config_;
     std::unique_ptr<AnalyzeContext> context_;

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/LexemePath.cpp

@@ -19,11 +19,11 @@
 
 namespace doris::segment_v2 {
 
-LexemePath::LexemePath(IKMemoryPool<Cell>& pool)
-        : QuickSortSet(pool), path_begin_(-1), path_end_(-1), payload_length_(0) {}
+LexemePath::LexemePath(vectorized::Arena& arena)
+        : QuickSortSet(arena), path_begin_(-1), path_end_(-1), payload_length_(0) {}
 
-LexemePath::LexemePath(LexemePath& other, IKMemoryPool<Cell>& pool)
-        : QuickSortSet(pool),
+LexemePath::LexemePath(LexemePath& other, vectorized::Arena& arena)
+        : QuickSortSet(arena),
           path_begin_(other.path_begin_),
           path_end_(other.path_end_),
           payload_length_(other.payload_length_) {
@@ -34,8 +34,8 @@ LexemePath::LexemePath(LexemePath& other, IKMemoryPool<Cell>& pool)
     }
 }
 
-LexemePath::LexemePath(LexemePath&& other, IKMemoryPool<Cell>& pool) noexcept
-        : QuickSortSet(pool),
+LexemePath::LexemePath(LexemePath&& other, vectorized::Arena& arena) noexcept
+        : QuickSortSet(arena),
           path_begin_(other.path_begin_),
           path_end_(other.path_end_),
           payload_length_(other.payload_length_) {

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/LexemePath.h

@@ -31,9 +31,9 @@ namespace doris::segment_v2 {
 
 class LexemePath : public QuickSortSet {
 public:
-    LexemePath(IKMemoryPool<Cell>& pool);
-    LexemePath(LexemePath& other, IKMemoryPool<Cell>& pool);
-    LexemePath(LexemePath&& other, IKMemoryPool<Cell>& pool) noexcept;
+    LexemePath(vectorized::Arena& arena);
+    LexemePath(LexemePath& other, vectorized::Arena& arena);
+    LexemePath(LexemePath&& other, vectorized::Arena& arena) noexcept;
     bool addCrossLexeme(Lexeme& lexeme);
     bool addNotCrossLexeme(Lexeme& lexeme);
     std::optional<Lexeme> removeTail();

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/QuickSortSet.cpp

@@ -25,7 +25,13 @@ QuickSortSet::~QuickSortSet() {
 
 void QuickSortSet::clear() {
     if (head_) {
-        pool_.mergeFreeList(head_, tail_, cell_size_);
+        Cell* current = head_;
+        while (current) {
+            Cell* next = current->next_;
+            current->~Cell();
+            current = next;
+        }
+
         head_ = nullptr;
         tail_ = nullptr;
         cell_size_ = 0;
@@ -129,14 +135,13 @@ size_t QuickSortSet::getPathEnd() const {
 }
 
 Cell* QuickSortSet::allocateCell(Lexeme&& lexeme) {
-    void* memory = pool_.allocate();
-    return new (memory) Cell(std::move(lexeme));
+    Cell* cell = arena_.alloc<Cell>();
+    return new (cell) Cell(std::move(lexeme));
 }
 
 void QuickSortSet::deallocateCell(Cell* cell) {
     if (cell) {
         cell->~Cell();
-        pool_.deallocate(cell);
     }
 }
 

be/src/olap/rowset/segment_v2/inverted_index/analyzer/ik/core/QuickSortSet.h

@@ -23,8 +23,7 @@
 #include "CLucene/_ApiHeader.h"
 #include "CLucene/util/Misc.h"
 #include "Lexeme.h"
-#include "olap/rowset/segment_v2/inverted_index/analyzer/ik/util/IKMemoryPool.h"
-
+#include "vec/common/arena.h"
 namespace doris::segment_v2 {
 
 class Cell {
@@ -42,8 +41,6 @@ class Cell {
     Lexeme& getLexeme() { return lexeme_; }
 
 private:
-    // Do not change the position of the declarations of next_ and prev_, as this is related to the
-    // mergeFreeList in IKMemoryPool.
     Cell* next_ = nullptr;
     Cell* prev_ = nullptr;
     Lexeme lexeme_;
@@ -61,9 +58,9 @@ class QuickSortSet {
     size_t cell_size_ = 0;
 
 public:
-    IKMemoryPool<Cell>& pool_;
+    vectorized::Arena& arena_;
 
-    QuickSortSet(IKMemoryPool<Cell>& pool) : pool_(pool) {}
+    QuickSortSet(vectorized::Arena& arena) : arena_(arena) {}
     virtual ~QuickSortSet();
 
     QuickSortSet(const QuickSortSet&) = delete;