Report core performance/efficiency

Code/EntryPoint.cpp

@@ -1,6 +1,7 @@
+#include <cstdint>
 #include <iostream>
 
-#include "GetProcessorInformation.hpp"
+#include "GetProcessorCoreInformation.hpp"
 #include "OverlappedIOFileRead.hpp"
 
 int main(int argc, const char * argv[]) {
@@ -10,19 +11,28 @@ int main(int argc, const char * argv[]) {
 		return -1;
 	}
 
-	auto processor_information = GetProcessorInformation();
-	if (!processor_information.has_value()) {
+	auto processor_core_information = GetProcessorCoreInformation();
+	if (!processor_core_information.has_value()) {
 		std::cerr << "Error: Could not find processor information." << std::endl;
 		return -1;
 	}
 
-	std::cout << "CPU cores: " << processor_information->actual_cores_;
-	if (processor_information->hyperthreading_cores_ != 0) {
-		std::cout << " (and " << processor_information->hyperthreading_cores_ << " hyperthreading cores)";
+	int16_t max_efficiency = -1;
+	uint16_t max_efficiency_core_count = 0;
+	for (auto& core_information : *processor_core_information) {
+		std::cout << "CPU cores: " << core_information.count_ << " @ performance class: " << core_information.efficiency_class_;
+		if (core_information.has_hyperthreading_ != 0) {
+			std::cout << " (with hyperthreading)";
+		}
+
+		if (core_information.efficiency_class_ > max_efficiency) {
+			max_efficiency = core_information.efficiency_class_;
+			max_efficiency_core_count = core_information.count_;
+		}
+		std::cout << std::endl;
 	}
-	std::cout << std::endl;
 
-	auto overlapped_io_file_read = PrepareToReadFile(argv[1], processor_information->actual_cores_);
+	auto overlapped_io_file_read = PrepareToReadFile(argv[1], max_efficiency_core_count);
 	if (!overlapped_io_file_read.has_value()) {
 		std::cerr << "Error";
 		return -1;

Code/GetProcessorCoreInformation.cpp

@@ -0,0 +1,64 @@
+// Copyright 2025, The FileReadSpeedTest Contributors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "GetProcessorCoreInformation.hpp"
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <Windows.h>
+
+#include <memory>
+#include <utility>
+
+ProcessorCoreInformation::ProcessorCoreInformation(uint16_t efficiency_class, uint16_t count, bool has_hyperthreading) noexcept
+	: efficiency_class_(std::move(efficiency_class))
+	, count_(std::move(count))
+	, has_hyperthreading_(std::move(has_hyperthreading))
+{}
+
+std::optional<std::vector<ProcessorCoreInformation>> GetProcessorCoreInformation() noexcept {
+	DWORD required_buffer_size = 0;
+	BOOL result = GetLogicalProcessorInformationEx(RelationProcessorCore, nullptr, &required_buffer_size);
+	if (result == FALSE) {
+		DWORD error_code = GetLastError();
+		if (error_code != ERROR_INSUFFICIENT_BUFFER) {
+			return std::nullopt;
+		}
+	}
+
+	const size_t element_size = sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX);
+	// char[] because chars enable aliasing
+	auto buffer = std::make_unique<char[]>(required_buffer_size);
+	auto buffer_end = buffer.get() + required_buffer_size;
+	auto* current_pointer = buffer.get();
+	auto* processor_information = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)current_pointer;
+	result = GetLogicalProcessorInformationEx(RelationProcessorCore, processor_information, &required_buffer_size);
+	if (result == FALSE) {
+		return std::nullopt;
+	}
+
+	std::vector<ProcessorCoreInformation> core_informations;
+	for (size_t i = 0; (char*)current_pointer < buffer_end; i++) {
+		uint32_t efficiency = processor_information->Processor.EfficiencyClass;
+		bool hyperthreading = processor_information->Processor.Flags == LTP_PC_SMT;
+
+		bool match_found = false;
+		for (auto& core_information : core_informations) {
+			if (core_information.efficiency_class_ == efficiency &&
+			    core_information.has_hyperthreading_ == hyperthreading) {
+				match_found = true;
+				core_information.count_++;
+			}
+		}
+		if (!match_found) {
+			core_informations.emplace_back(efficiency, 1, hyperthreading);
+		}
+
+		current_pointer += processor_information->Size;
+		processor_information = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)current_pointer;
+	}
+
+	return core_informations;
+}

Code/GetProcessorCoreInformation.hpp

@@ -0,0 +1,24 @@
+// Copyright 2025, The FileReadSpeedTest Contributors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GETPROCESSORCOREINFORMATION_HPP
+#define GETPROCESSORCOREINFORMATION_HPP
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+struct ProcessorCoreInformation {
+public:
+
+	explicit ProcessorCoreInformation(uint16_t efficiency_class, uint16_t count, bool has_hyperthreading) noexcept;
+
+	uint16_t efficiency_class_;
+	uint16_t count_;
+	bool has_hyperthreading_;
+};
+
+std::optional<std::vector<ProcessorCoreInformation>> GetProcessorCoreInformation() noexcept;
+
+#endif // #ifndef GETPROCESSORCOREINFORMATION_HPP

Projects/VisualStudio/FileReadSpeedTest.vcxproj

@@ -20,13 +20,13 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\Code\EntryPoint.cpp" />
-    <ClCompile Include="..\..\Code\GetProcessorInformation.cpp" />
+    <ClCompile Include="..\..\Code\GetProcessorCoreInformation.cpp" />
     <ClCompile Include="..\..\Code\OSAllocator.cpp" />
     <ClCompile Include="..\..\Code\OverlappedIOFileRead.cpp" />
     <ClCompile Include="..\..\Code\Win32Types.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\..\Code\GetProcessorInformation.hpp" />
+    <ClInclude Include="..\..\Code\GetProcessorCoreInformation.hpp" />
     <ClInclude Include="..\..\Code\OSAllocator.hpp" />
     <ClInclude Include="..\..\Code\OverlappedIOFileRead.hpp" />
     <ClInclude Include="..\..\Code\Win32Types.hpp" />