Add more properties

Author: xin-zhang2

velox/common/memory/AllocationPool.cpp

@@ -76,10 +76,13 @@ char* AllocationPool::allocateFixed(uint64_t bytes, int32_t alignment) {
   return result;
 }
 
-char* AllocationPool::allocateFixedWithPageSize(
+char* AllocationPool::allocateFixedTest(
     int64_t bytes,
     int32_t alignment,
-    uint64_t pageSize) {
+    uint64_t pageSize,
+    int32_t minPages,
+    int64_t hugePageThreshold,
+    int32_t hugePageNums) {
   VELOX_CHECK_GT(bytes, 0, "Cannot allocate zero bytes");
   if (freeAddressableBytes() >= bytes && alignment == 1) {
     auto* result = startOfRun_ + currentOffset_;
@@ -99,11 +102,13 @@ char* AllocationPool::allocateFixedWithPageSize(
   auto numPages = bits::roundUp(bytes + alignment - 1, pageSize) / pageSize;
 
   if (freeAddressableBytes() == 0) {
-    newRunImplWithPageSize(numPages, pageSize);
+    newRunImplWithPageSize(
+        numPages, pageSize, minPages, hugePageThreshold, hugePageNums);
   } else {
     auto alignedBytes = bytes + alignmentPadding(firstFreeInRun(), alignment);
     if (freeAddressableBytes() < alignedBytes) {
-      newRunImplWithPageSize(numPages, pageSize);
+      newRunImplWithPageSize(
+          numPages, pageSize, minPages, hugePageThreshold, hugePageNums);
     }
   }
   currentOffset_ += alignmentPadding(firstFreeInRun(), alignment);
@@ -180,8 +185,11 @@ void AllocationPool::newRunImpl(MachinePageCount numPages) {
 
 void AllocationPool::newRunImplWithPageSize(
     memory::MachinePageCount numPages,
-    uint64_t pageSize) {
-  if (usedBytes_ >= hugePageThreshold_ ||
+    const uint64_t pageSize,
+    int32_t minPages,
+    int64_t hugePageThreshold,
+    int32_t hugePageNum) {
+  if (usedBytes_ >= hugePageThreshold ||
       numPages > pool_->sizeClasses().back()) {
     // At least 16 huge pages, no more than kMaxMmapBytes. The next is
     // double the previous. Because the previous is a hair under the
@@ -190,7 +198,7 @@ void AllocationPool::newRunImplWithPageSize(
     int64_t nextSize = std::min(
         kMaxMmapBytes,
         std::max<int64_t>(
-            16 * AllocationTraits::kHugePageSize,
+            hugePageNum * AllocationTraits::kHugePageSize,
             bits::nextPowerOfTwo(
                 usedBytes_ + AllocationTraits::kHugePageSize)));
     // Round 'numPages' to no of pages in huge page. Allocating this plus an
@@ -220,9 +228,7 @@ void AllocationPool::newRunImplWithPageSize(
   }
 
   Allocation allocation;
-  const auto roundedBytes = std::max<uint64_t>(
-      kMinPages * AllocationTraits::kPageSize, numPages * pageSize);
-  const auto roundedPages = bits::roundUp(roundedBytes, pageSize) / pageSize;
+  const auto roundedPages = std::max<int32_t>(minPages, numPages);
   const auto standardPages =
       (roundedPages * pageSize) / AllocationTraits::kPageSize;
   pool_->allocateNonContiguous(standardPages, allocation, standardPages);

velox/common/memory/AllocationPool.h

@@ -40,10 +40,13 @@ class AllocationPool {
   // only be power of 2.
   char* allocateFixed(uint64_t bytes, int32_t alignment = 1);
 
-  char* allocateFixedWithPageSize(
+  char* allocateFixedTest(
       int64_t bytes,
       int32_t alignment,
-      uint64_t pageSize);
+      uint64_t pageSize,
+      int32_t minPages,
+      int64_t hugePageThreshold,
+      int32_t hugePageNums);
 
   // Starts a new run for variable length allocation. The actual size
   // is at least one machine page. Throws std::bad_alloc if no space.
@@ -144,7 +147,10 @@ class AllocationPool {
 
   void newRunImplWithPageSize(
       memory::MachinePageCount numPages,
-      uint64_t pageSize);
+      uint64_t pageSize,
+      int32_t minPages,
+      int64_t hugePageThreshold,
+      int32_t hugePageNum);
 
   memory::MemoryPool* pool_;
   std::vector<memory::Allocation> allocations_;

velox/core/QueryConfig.h

@@ -747,6 +747,14 @@ class QueryConfig {
   /// This is an experimental property for performance tuning.
   static constexpr const char* kHashTablePageSize = "hashtable_page_size";
 
+  static constexpr const char* kHashTableMinPages = "hashtable_min_pages";
+
+  static constexpr const char* kHashTableHugePageThreshold =
+      "hashtable_huge_page_threshold";
+
+  static constexpr const char* kHashTableHugePageNums =
+      "hashtable_huge_page_nums";
+
   enum class RowSizeTrackingMode {
     DISABLED = 0,
     EXCLUDE_DELTA_SPLITS = 1,
@@ -1339,6 +1347,20 @@ class QueryConfig {
         config::CapacityUnit::BYTE);
   }
 
+  int32_t hashTableMinPages() const {
+    return get<int32_t>(kHashTableMinPages, 16);
+  }
+
+  int32_t hashTableHugePageNums() const {
+    return get<int32_t>(kHashTableHugePageNums, 16);
+  }
+
+  int64_t hashTableHugePageThreshold() const {
+    return config::toCapacity(
+        get<std::string>(kHashTableHugePageThreshold, "256KB"),
+        config::CapacityUnit::BYTE);
+  }
+
   std::string source() const {
     return get<std::string>(kSource, "");
   }

velox/exec/HashBuild.cpp

@@ -402,9 +402,13 @@ void HashBuild::addInput(RowVectorPtr input) {
         input->childAt(spillProbedFlagChannel_)->asFlatVector<bool>();
   }
 
+  const auto& queryConfig = operatorCtx()->driverCtx()->queryConfig();
   activeRows_.applyToSelected([&](auto rowIndex) {
     char* newRow = rows->newRowTest(
-        operatorCtx()->driverCtx()->queryConfig().hashTablePageSize());
+        queryConfig.hashTablePageSize(),
+        queryConfig.hashTableMinPages(),
+        queryConfig.hashTableHugePageThreshold(),
+        queryConfig.hashTableHugePageNums());
     if (nextOffset) {
       *reinterpret_cast<char**>(newRow + nextOffset) = nullptr;
     }

velox/exec/HashTable.cpp

@@ -332,8 +332,12 @@ char* HashTable<ignoreNullKeys>::insertEntry(
     HashLookup& lookup,
     uint64_t index,
     vector_size_t row) {
+  const auto& queryConfig = driverThreadContext()->driverCtx()->queryConfig();
   char* group = rows_->newRowTest(
-      driverThreadContext()->driverCtx()->queryConfig().hashTablePageSize());
+      queryConfig.hashTablePageSize(),
+      queryConfig.hashTableMinPages(),
+      queryConfig.hashTableHugePageThreshold(),
+      queryConfig.hashTableHugePageNums());
   lookup.hits[row] = group; // NOLINT
   storeKeys(lookup, row);
   storeRowPointer(index, lookup.hashes[row], group);

velox/exec/RowContainer.cpp

@@ -283,7 +283,11 @@ char* RowContainer::newRow() {
   return initializeRow(row, false /* reuse */);
 }
 
-char* RowContainer::newRowTest(uint64_t pageSize) {
+char* RowContainer::newRowTest(
+    uint64_t pageSize,
+    int32_t minPages,
+    int64_t hugePageThreshold,
+    int32_t hugePageNums) {
   VELOX_DCHECK(mutable_, "Can't add row into an immutable row container");
   ++numRows_;
   char* row;
@@ -293,8 +297,13 @@ char* RowContainer::newRowTest(uint64_t pageSize) {
     firstFreeRow_ = nextFree(row);
     --numFreeRows_;
   } else {
-    row = rows_.allocateFixedWithPageSize(
-              fixedRowSize_ + normalizedKeySize_, alignment_, pageSize) +
+    row = rows_.allocateFixedTest(
+              fixedRowSize_ + normalizedKeySize_,
+              alignment_,
+              pageSize,
+              minPages,
+              hugePageThreshold,
+              hugePageNums) +
         normalizedKeySize_;
     if (normalizedKeySize_) {
       ++numRowsWithNormalizedKey_;

velox/exec/RowContainer.h

@@ -318,7 +318,11 @@ class RowContainer {
   /// Allocates a new row and initializes possible aggregates to null.
   char* newRow();
 
-  char* newRowTest(uint64_t pageSize);
+  char* newRowTest(
+      uint64_t pageSize,
+      int32_t minPages = 16,
+      int64_t hugePageThreshold = 256 * 1024,
+      int32_t hugePageNums = 16);
 
   uint32_t rowSize(const char* row) const {
     return fixedRowSize_ +