Set max_threads according to the number of physical cpu cores (#6481) (…

…#6489)

close #6480

dbms/src/Common/getNumberOfCPUCores.cpp

@@ -0,0 +1,63 @@
+// Copyright 2022 PingCAP, Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <Common/getNumberOfCPUCores.h>
+#include <common/types.h>
+
+namespace CPUCores
+{
+UInt16 number_of_logical_cpu_cores = std::thread::hardware_concurrency();
+UInt16 number_of_physical_cpu_cores = std::thread::hardware_concurrency() / 2;
+} // namespace CPUCores
+
+
+UInt16 getNumberOfLogicalCPUCores()
+{
+    return CPUCores::number_of_logical_cpu_cores;
+}
+
+UInt16 getNumberOfPhysicalCPUCores()
+{
+    return CPUCores::number_of_physical_cpu_cores;
+}
+
+// We should call this function before Context has been created,
+// which will call `getNumberOfLogicalCPUCores`, or we can not
+// set cpu cores any more.
+void setNumberOfLogicalCPUCores(UInt16 number_of_logical_cpu_cores_)
+{
+    CPUCores::number_of_logical_cpu_cores = number_of_logical_cpu_cores_;
+}
+
+void computeAndSetNumberOfPhysicalCPUCores(UInt16 number_of_logical_cpu_cores_, UInt16 number_of_hardware_physical_cores)
+{
+    // First of all, we need to take consideration of two situation:
+    //   1. tiflash on physical machine.
+    //      In old codes, tiflash needs to set max_threads which is equal to
+    //      physical cpu cores, so we need to ensure this behavior is not broken.
+    //   2. tiflash on virtual environment.
+    //      In virtual environment, when setting max_threads, we can't directly
+    //      get physical cpu cores to set this variable because only host machine's
+    //      physical cpu core can be reached. So, number of physical cpus cores can
+    //      only be assigned by calculated with logical cpu cores.
+    //
+    // - `number_of_logical_cpu_cores_` which represents how many logical cpu cores a tiflash could use(no matter in physical or virtual environment) is assigned from ServerInfo.
+    // - `hardware_logical_cpu_cores` represents how many logical cpu cores the host physical machine has.
+    // - `number_of_hardware_physical_cores` represents how many physical cpu cores the host physical machine has.
+    // - `(hardware_logical_cpu_cores / number_of_hardware_physical_cores)` means how many logical cpu core a physical cpu core has.
+    // - `number_of_logical_cpu_cores_ / (hardware_logical_cpu_cores / number_of_hardware_physical_cores)` means how many physical cpu cores the tiflash process could use. (Actually, it's needless to get physical cpu cores in virtual environment, but we must ensure the behavior `1` is not broken)
+    auto hardware_logical_cpu_cores = std::thread::hardware_concurrency();
+    UInt16 physical_cores = number_of_logical_cpu_cores_ / (hardware_logical_cpu_cores / number_of_hardware_physical_cores);
+    CPUCores::number_of_physical_cpu_cores = physical_cores > 0 ? physical_cores : 1;
+}

dbms/src/Common/getNumberOfLogicalCPUCores.h → dbms/src/Common/getNumberOfCPUCores.h

@@ -19,8 +19,11 @@
 #include <thread>
 
 UInt16 getNumberOfLogicalCPUCores();
+UInt16 getNumberOfPhysicalCPUCores();
 
 // We should call this function before Context has been created,
 // which will call `getNumberOfLogicalCPUCores`, or we can not
 // set cpu cores any more.
-void setNumberOfLogicalCPUCores(UInt16 max_logical_cpu_cores);
+void setNumberOfLogicalCPUCores(UInt16 number_of_logical_cpu_cores_);
+
+void computeAndSetNumberOfPhysicalCPUCores(UInt16 number_of_logical_cpu_cores, UInt16 number_of_hardware_physical_cores);

dbms/src/Flash/FlashService.cpp

@@ -17,7 +17,7 @@
 #include <Common/ThreadMetricUtil.h>
 #include <Common/TiFlashMetrics.h>
 #include <Common/VariantOp.h>
-#include <Common/getNumberOfLogicalCPUCores.h>
+#include <Common/getNumberOfCPUCores.h>
 #include <Common/setThreadName.h>
 #include <Flash/BatchCoprocessorHandler.h>
 #include <Flash/EstablishCall.h>

dbms/src/Flash/Mpp/MinTSOScheduler.cpp

@@ -14,7 +14,7 @@
 
 #include <Common/FailPoint.h>
 #include <Common/TiFlashMetrics.h>
-#include <Common/getNumberOfLogicalCPUCores.h>
+#include <Common/getNumberOfCPUCores.h>
 #include <Flash/Mpp/MPPTaskManager.h>
 #include <Flash/Mpp/MinTSOScheduler.h>
 

dbms/src/Functions/FunctionsRegexp.h

@@ -1015,7 +1015,8 @@ class FunctionStringRegexp : public FunctionStringRegexpBase
         // Initialize result column
         auto col_res = ColumnVector<ResultType>::create();
         typename ColumnVector<ResultType>::Container & vec_res = col_res->getData();
-        vec_res.resize(col_size, 0);
+        ResultType default_val = 0;
+        vec_res.assign(col_size, default_val);
 
         constexpr bool has_nullable_col = ExprT::isNullableCol() || PatT::isNullableCol() || MatchTypeT::isNullableCol();
 
@@ -1030,7 +1031,8 @@ class FunctionStringRegexp : public FunctionStringRegexpBase
                 {
                     auto nullmap_col = ColumnUInt8::create();
                     typename ColumnUInt8::Container & nullmap = nullmap_col->getData();
-                    nullmap.resize(col_size, 1);
+                    UInt8 default_val = 1;
+                    nullmap.assign(col_size, default_val);
                     res_arg.column = ColumnNullable::create(std::move(col_res), std::move(nullmap_col));
                     return;
                 }
@@ -1317,7 +1319,8 @@ class FunctionStringRegexpInstr : public FunctionStringRegexpBase
         // Initialize result column
         auto col_res = ColumnVector<ResultType>::create();
         typename ColumnVector<ResultType>::Container & vec_res = col_res->getData();
-        vec_res.resize(col_size, 0);
+        ResultType default_val = 0;
+        vec_res.assign(col_size, default_val);
 
         constexpr bool has_nullable_col = ExprT::isNullableCol() || PatT::isNullableCol() || PosT::isNullableCol() || OccurT::isNullableCol() || RetOpT::isNullableCol() || MatchTypeT::isNullableCol();
 
@@ -1366,7 +1369,8 @@ class FunctionStringRegexpInstr : public FunctionStringRegexpBase
                 {
                     auto nullmap_col = ColumnUInt8::create();
                     typename ColumnUInt8::Container & nullmap = nullmap_col->getData();
-                    nullmap.resize(col_size, 1);
+                    UInt8 default_val = 1;
+                    nullmap.assign(col_size, default_val);
                     res_arg.column = ColumnNullable::create(std::move(col_res), std::move(nullmap_col));
                     return;
                 }
@@ -1698,7 +1702,8 @@ class FunctionStringRegexpSubstr : public FunctionStringRegexpBase
 
         auto null_map_col = ColumnUInt8::create();
         typename ColumnUInt8::Container & null_map = null_map_col->getData();
-        null_map.resize(col_size, 1);
+        UInt8 default_val = 1;
+        null_map.assign(col_size, default_val);
 
         // Start to execute substr
         if (canMemorize<PatT, MatchTypeT>())

dbms/src/Interpreters/SettingsCommon.h

@@ -16,7 +16,7 @@
 
 #include <Common/Checksum.h>
 #include <Common/FieldVisitors.h>
-#include <Common/getNumberOfLogicalCPUCores.h>
+#include <Common/getNumberOfCPUCores.h>
 #include <Core/Field.h>
 #include <DataStreams/SizeLimits.h>
 #include <IO/CompressedStream.h>
@@ -167,7 +167,7 @@ struct SettingMaxThreads
 
     static UInt64 getAutoValue()
     {
-        static auto res = getNumberOfLogicalCPUCores();
+        static auto res = getNumberOfPhysicalCPUCores();
         return res;
     }
 

dbms/src/Server/Server.cpp

@@ -32,7 +32,7 @@
 #include <Common/formatReadable.h>
 #include <Common/getFQDNOrHostName.h>
 #include <Common/getMultipleKeysFromConfig.h>
-#include <Common/getNumberOfLogicalCPUCores.h>
+#include <Common/getNumberOfCPUCores.h>
 #include <Common/setThreadName.h>
 #include <Encryption/DataKeyManager.h>
 #include <Encryption/FileProvider.h>
@@ -883,11 +883,13 @@ int Server::main(const std::vector<std::string> & /*args*/)
         helper->fn_server_info(helper->proxy_ptr, strIntoView(&req), &response);
         server_info.parseSysInfo(response);
         setNumberOfLogicalCPUCores(server_info.cpu_info.logical_cores);
+        computeAndSetNumberOfPhysicalCPUCores(server_info.cpu_info.logical_cores, server_info.cpu_info.physical_cores);
         LOG_INFO(log, "ServerInfo: {}", server_info.debugString());
     }
     else
     {
         setNumberOfLogicalCPUCores(std::thread::hardware_concurrency());
+        computeAndSetNumberOfPhysicalCPUCores(std::thread::hardware_concurrency(), std::thread::hardware_concurrency() / 2);
         LOG_INFO(log, "TiFlashRaftProxyHelper is null, failed to get server info");
     }