Add Core and hyperthreading + core type info, use e-cores for EventQueue

Author: VReaperV

src/engine/Base/Base.cmake

@@ -58,6 +58,8 @@ set( sysList
 )
 
 set( threadList
+    ${engineBase}/Thread/Core.cpp
+    ${engineBase}/Thread/Core.h
     ${engineBase}/Thread/EventQueue.cpp
     ${engineBase}/Thread/EventQueue.h
     ${engineBase}/Thread/GlobalMemory.cpp

src/engine/Base/BaseDecls.h

@@ -42,4 +42,6 @@ struct Array;
 template<typename T>
 class DynamicArray;
 
+struct Core;
+
 #endif // BASE_DECLS_H

src/engine/Base/Sys/OSThread.cpp

@@ -29,6 +29,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #ifdef _MSC_VER
+	#include <intrin.h>
+
 	#include "Windows.h"
 
 	#include <powerbase.h>
@@ -44,10 +46,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	#include <pthread.h>
 #endif
 
+#include "Thread/Core.h"
 #include "Thread/ThreadCommon.h"
+#include "SysAllocator.h"
 #include "Bit.h"
 #include "DynamicArray.h"
 #include "Timer.h"
+#include "Parser.h"
 
 #include "CPUInfo.h"
 
@@ -82,6 +87,9 @@ void OSThread::SetAffinity( const uint32 newCore ) {
 
 		if ( !ret ) {
 			Log::Warn( "SetThreadGroupAffinity error: %i", GetLastError() );
+			baseMaxFrequency = 1.0;
+
+			return;
 		}
 
 		// PROCESSOR_POWER_INFORMATION, which is missing from windows headers
@@ -127,7 +135,7 @@ void OSThread::SetAffinity( const uint32 newCore ) {
 		int ret = pthread_setaffinity_np( thread, sizeof( cpu ), &cpu );
 
 		if ( ret != 0 ) {
-			Log::Warn( "sched_setaffinity error: %s", strerror( errno ) );
+			Log::Warn( "pthread_setaffinity_np error: %s", strerror( errno ) );
 		}
 	#endif
 }
@@ -185,4 +193,173 @@ double OSThread::GetMaxFrequencyScale() {
 	#else // Can't set thread affinity on apple, so no point in scaling by max frequency
 		return 1.0;
 	#endif
+}
+
+struct File {
+	FILE*    file;
+	uint32_t size;
+
+	File( const std::string& path, const char* mode ) {
+		file = fopen( path.c_str(), mode );
+
+		if ( !file ) {
+			printf( "Failed to open file: %s, mode: %s\n", path.c_str(), mode );
+			printf( strerror( errno ) );
+			exit( 1 );
+		}
+
+		fseek( file, 0, SEEK_END );
+		size = ftell( file );
+
+		fseek( file, 0, 0 );
+	}
+
+	File( const std::string& path, const std::string& path2, const char* mode ) {
+		file = fopen( path.c_str(), mode );
+
+		if ( !file ) {
+			file = fopen( path2.c_str(), mode );
+
+			if( !file ) {
+				Log::Warn( "Failed to open file: %s, mode: %s\n", path.c_str(), mode );
+				Log::Warn( strerror( errno ) );
+			}
+		}
+
+		fseek( file, 0, SEEK_END );
+		size = ftell( file );
+
+		fseek( file, 0, 0 );
+	}
+
+	~File() {
+		fclose( file );
+	}
+
+	std::string ReadAll() {
+		std::string data;
+		data.resize( size );
+		size = fread( data.data(), sizeof( char ), size, file );
+
+		data.resize( size );
+		data.shrink_to_fit();
+
+		return data;
+	}
+};
+
+Core OSThread::GetCoreInfo() {
+	#ifdef _MSC_VER
+		DWORD size = 0;
+
+		GetLogicalProcessorInformationEx( RelationProcessorCore, nullptr, &size );
+		SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* buf = ( SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* ) sysAllocator.Alloc( size, 64 );
+		bool                                     ret = GetLogicalProcessorInformationEx( RelationProcessorCore, buf, &size );
+
+		if ( !ret ) {
+			Log::Warn( "GetLogicalProcessorInformationEx error: %i", GetLastError() );
+
+			return {
+				.type              = CORE_UNKNOWN,
+				.hyperthreading    = false,
+				.maxFrequencyScale = GetMaxFrequencyScale()
+			};
+		}
+
+		SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* coreInfo = ( SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* ) ( ( ( byte* ) buf ) + core * buf->Size );
+
+		return {
+			.type              = coreInfo->Processor.EfficiencyClass ? CORE_PERFORMANCE : CORE_EFFICIENCY,
+			.hyperthreading    = coreInfo->Processor.Flags == LTP_PC_SMT,
+			.maxFrequencyScale = GetMaxFrequencyScale()
+		};
+	#elifndef __APPLE__
+		return {
+			.type              = CORE_UNKNOWN,
+			.hyperthreading    = false,
+			.maxFrequencyScale = GetMaxFrequencyScale()
+		};
+	#else
+		return {
+			.type              = CORE_PERFORMANCE,
+			.hyperthreading    = false,
+			.maxFrequencyScale = GetMaxFrequencyScale()
+		};
+	#endif
+}
+
+#ifdef __linux__
+	bool IsHyperthreadingEnabled() {
+		File        cpuInfoFile { "/proc/cpuinfo", "r" };
+		std::string cpuInfo   = cpuInfoFile.ReadAll();
+
+		StringView  v { cpuInfo.c_str(), cpuInfo.size() };
+
+		int         physicalCores = 0;
+		int         logicalCores  = 0;
+	
+		do {
+			StringView o = Parse( v );
+
+			if ( o == "cpu" ) {
+				if ( Parse( v ) == "cores" ) {
+					Parse( v ); // :
+					Str::ParseInt( physicalCores, std::string( o.memory, o.size ) );
+				}
+			} else if ( o == "siblings" ) {
+				Parse( v ); // :
+				Str::ParseInt( logicalCores, std::string( o.memory, o.size ) );
+			}
+		} while ( v.size && !( physicalCores && logicalCores ) );
+
+		return physicalCores == logicalCores;
+	}
+#elif __APPLE__
+	bool IsHyperthreadingEnabled() {
+		return false;
+	}
+#endif
+
+std::string GetCPUModel() {
+	#ifdef _MSC_VER
+		int         info[4] {};
+		std::string model;
+
+		static constexpr uint32 infoSize = 4 * sizeof( int );
+
+		model.resize( 65 );
+
+		__cpuid( info, 0x80000002 );
+		memcpy( model.data(),                info, infoSize );
+
+		__cpuid( info, 0x80000003 );
+		memcpy( model.data() +     infoSize, info, infoSize );
+
+		__cpuid( info, 0x80000004 );
+		memcpy( model.data() + 2 * infoSize, info, infoSize );
+
+		model.resize( strlen( model.c_str() ) ); // Avoid the ugly NUL characters in logger
+
+		return model;
+	#elifdef __linux__
+		File        cpuInfoFile { "/proc/cpuinfo", "r" };
+		std::string cpuInfo   = cpuInfoFile.ReadAll();
+
+		StringView  v { cpuInfo.c_str(), cpuInfo.size() };
+	
+		do {
+			StringView o = Parse( v );
+
+			if ( o == "model" ) {
+				if ( Parse( v ) == "name" ) {
+					Parse( v ); // :
+					return Parse( v );
+				}
+			}
+		} while ( v.size );
+
+		return "Unknown";
+	#else
+		return "Unknown";
+	#endif
 }

src/engine/Base/Sys/OSThread.h

@@ -36,6 +36,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include "Int.h"
+#include "BaseDecls.h"
 
 struct OSThread {
 	#ifdef _MSC_VER
@@ -52,6 +53,13 @@ struct OSThread {
 	void   Init();
 	void   SetAffinity( const uint32 core );
 	double GetMaxFrequencyScale();
+	Core   GetCoreInfo();
 };
 
+#if defined( __linux__ ) || defined( __APPLE__ )
+	bool IsHyperthreadingEnabled();
+#endif
+
+std::string GetCPUModel();
+
 #endif // OS_THREAD_H

src/engine/Base/Thread/Core.cpp

@@ -0,0 +1,48 @@
+/*
+=============================================================================
+Daemon-Vulkan BSD Source Code
+Copyright (c) 2025-2026 Reaper
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Reaper nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL REAPER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+=============================================================================
+*/
+
+#include "common/Common.h"
+
+#include "Sys/CPUInfo.h"
+
+#include "Core.h"
+
+std::string CPU::FormatCoreInfo() {
+	std::string out = model + "\n";
+
+	for ( Core* core = cores; core < cores + CPU_CORES; core++ ) {
+		out += Str::Format( "\nCore %2u: max freq: %f, hyperthreading: %s",
+		                    core - cores, core->maxFrequencyScale, core->hyperthreading );
+	}
+
+	return out;
+}
+
+CPU cpu;

src/engine/Base/Thread/Core.h

@@ -0,0 +1,66 @@
+/*
+=============================================================================
+Daemon-Vulkan BSD Source Code
+Copyright (c) 2025-2026 Reaper
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Reaper nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL REAPER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+=============================================================================
+*/
+
+#ifndef CORE_H
+#define CORE_H
+
+#include <string>
+
+#include "Int.h"
+
+#include "ThreadCommon.h"
+
+enum CoreType : uint8 {
+	CORE_UNKNOWN,
+	CORE_PERFORMANCE,
+	CORE_EFFICIENCY
+};
+
+struct Core {
+	CoreType type;
+	bool     hyperthreading;
+	double   maxFrequencyScale;
+	uint16   coreLatencies[MAX_THREADS];
+};
+
+struct CPU {
+	Core        cores[MAX_THREADS];
+
+	uint64      performanceCores = 0;
+	uint64      efficiencyCores  = 0;
+
+	std::string model;
+
+	std::string FormatCoreInfo();
+};
+
+extern CPU cpu;
+
+#endif // CORE_H