Set max_threads according to the number of physical cpu cores

dbms/src/Common/getNumberOfCPUCores.cpp

@@ -0,0 +1,62 @@
+// 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 computeAndSetNumberOfPhysicalCPUCores()
+{
+    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();
+    CPUCores::number_of_physical_cpu_cores = number_of_logical_cpu_cores_ / (hardware_logical_cpu_cores / number_of_hardware_physical_cores);
+}

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/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 <Core/TiFlashDisaggregatedMode.h>
 #include <Encryption/DataKeyManager.h>
@@ -886,11 +886,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");
     }