Log system information on startup

libobs/obs-cocoa.c

@@ -21,6 +21,8 @@
 #include "obs-internal.h"
 
 #include <unistd.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
 
 // support both foo.so and libfoo.so for now
 static const char *plugin_patterns[] = {
@@ -61,3 +63,89 @@ char *obs_find_plugin_file(const char *file)
 	dstr_cat(&path, file);
 	return path.array;
 }
+
+static void log_processor_name(void)
+{
+	char   *name = NULL;
+	size_t size;
+	int    ret;
+
+	ret = sysctlbyname("machdep.cpu.brand_string", NULL, &size, NULL, 0);
+	if (ret != 0)
+		return;
+
+	name = malloc(size);
+
+	ret = sysctlbyname("machdep.cpu.brand_string", name, &size, NULL, 0);
+	if (ret == 0)
+		blog(LOG_INFO, "CPU Name: %s", name);
+
+	free(name);
+}
+
+static void log_processor_speed(void)
+{
+	size_t    size;
+	long long freq;
+	int       ret;
+
+	size = sizeof(freq);
+	ret = sysctlbyname("hw.cpufrequency", &freq, &size, NULL, 0);
+	if (ret == 0)
+		blog(LOG_INFO, "CPU Speed: %lldMHz", freq / 1000000);
+}
+
+static void log_processor_cores(void)
+{
+	size_t size;
+	int    physical_cores = 0, logical_cores = 0;
+	int    ret;
+
+	size = sizeof(physical_cores);
+	ret = sysctlbyname("machdep.cpu.cores_per_package", &physical_cores,
+			&size, NULL, 0);
+	if (ret != 0)
+		return;
+
+	ret = sysctlbyname("machdep.cpu.logical_per_package", &logical_cores,
+			&size, NULL, 0);
+	if (ret != 0)
+		return;
+
+	blog(LOG_INFO, "Physical Cores: %d, Logical Cores: %d",
+			physical_cores, logical_cores);
+}
+
+static void log_available_memory(void)
+{
+	size_t    size;
+	long long memory_available;
+	int       ret;
+
+	size = sizeof(memory_available);
+	ret = sysctlbyname("hw.memsize", &memory_available, &size, NULL, 0);
+	if (ret == 0)
+		blog(LOG_INFO, "Physical Memory: %lldMB Total",
+				memory_available / 1024 / 1024);
+}
+
+static void log_kernel_version(void)
+{
+	char   kernel_version[1024];
+	size_t size = sizeof(kernel_version);
+	int    ret;
+
+	ret = sysctlbyname("kern.osrelease", kernel_version, &size,
+			NULL, 0);
+	if (ret == 0)
+		blog(LOG_INFO, "Kernel Version: %s", kernel_version);
+}
+
+void log_system_info(void)
+{
+	log_processor_name();
+	log_processor_speed();
+	log_processor_cores();
+	log_available_memory();
+	log_kernel_version();
+}

libobs/obs-nix.c

@@ -120,3 +120,15 @@ char *obs_find_plugin_file(const char *file)
 	dstr_free(&output);
 	return NULL;
 }
+
+void log_system_info(void)
+{
+	/* TODO */
+#if 0
+	log_processor_name();
+	log_processor_speed();
+	log_processor_cores();
+	log_available_memory();
+	log_distribution();
+#endif
+}

libobs/obs-windows.c

@@ -20,6 +20,8 @@
 #include "obs.h"
 #include "obs-internal.h"
 
+#include <windows.h>
+
 static inline bool check_path(const char* data, const char *path,
 		struct dstr * output)
 {
@@ -101,3 +103,130 @@ char *obs_find_plugin_file(const char *file)
 	dstr_free(&path);
 	return NULL;
 }
+
+static void log_processor_info(void)
+{
+	HKEY    key;
+	wchar_t data[1024];
+	char    *str = NULL;
+	DWORD   size, speed;
+	LSTATUS status;
+
+	memset(data, 0, 1024);
+
+	status = RegOpenKeyW(HKEY_LOCAL_MACHINE,
+			L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
+			&key);
+	if (status != ERROR_SUCCESS)
+		return;
+
+	size = 1024;
+	status = RegQueryValueExW(key, L"ProcessorNameString", NULL, NULL,
+			(LPBYTE)data, &size);
+	if (status == ERROR_SUCCESS) {
+		os_wcs_to_utf8_ptr(data, 0, &str);
+		blog(LOG_INFO, "CPU Name: %s", str);
+		bfree(str);
+	}
+
+	size = sizeof(speed);
+	status = RegQueryValueExW(key, L"~MHz", NULL, NULL, (LPBYTE)&speed,
+			&size);
+	if (status == ERROR_SUCCESS)
+		blog(LOG_INFO, "CPU Speed: %dMHz", speed);
+
+	RegCloseKey(key);
+}
+
+static DWORD num_logical_cores(ULONG_PTR mask)
+{
+	DWORD     left_shift    = sizeof(ULONG_PTR) * 8 - 1;
+	DWORD     bit_set_count = 0;
+	ULONG_PTR bit_test      = (ULONG_PTR)1 << left_shift;
+
+	for (DWORD i = 0; i <= left_shift; ++i) {
+		bit_set_count += ((mask & bit_test) ? 1 : 0);
+		bit_test      /= 2;
+	}
+
+	return bit_set_count;
+}
+
+static void log_processor_cores(void)
+{
+	PSYSTEM_LOGICAL_PROCESSOR_INFORMATION info = NULL, temp = NULL;
+	DWORD len = 0;
+
+	GetLogicalProcessorInformation(info, &len);
+	if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+		return;
+
+	info = malloc(len);
+
+	if (GetLogicalProcessorInformation(info, &len)) {
+		DWORD num            = len / sizeof(*info);
+		int   physical_cores = 0;
+		int   logical_cores  = 0;
+
+		temp = info;
+
+		for (DWORD i = 0; i < num; i++) {
+			if (temp->Relationship == RelationProcessorCore) {
+				ULONG_PTR mask = temp->ProcessorMask;
+
+				physical_cores++;
+				logical_cores += num_logical_cores(mask);
+			}
+
+			temp++;
+		}
+
+		blog(LOG_INFO, "Physical Cores: %d, Logical Cores: %d",
+				physical_cores, logical_cores);
+	}
+
+	free(info);
+}
+
+static void log_available_memory(void)
+{
+	MEMORYSTATUS ms;
+	GlobalMemoryStatus(&ms);
+
+#ifdef _WIN64
+	const char *note = "";
+#else
+	const char *note = " (NOTE: 4 gigs max is normal for 32bit programs)";
+#endif
+
+	blog(LOG_INFO, "Physical Memory: %ldMB Total, %ldMB Free%s",
+			ms.dwTotalPhys / 1048576,
+			ms.dwAvailPhys / 1048576,
+			note);
+}
+
+static void log_windows_version(void)
+{
+	OSVERSIONINFOW osvi;
+	char           *build = NULL;
+
+	osvi.dwOSVersionInfoSize = sizeof(osvi);
+	GetVersionExW(&osvi);
+
+	os_wcs_to_utf8_ptr(osvi.szCSDVersion, 0, &build);
+	blog(LOG_INFO, "Windows Version: %u.%u Build %u %s",
+			osvi.dwMajorVersion,
+			osvi.dwMinorVersion,
+			osvi.dwBuildNumber,
+			build);
+
+	bfree(build);
+}
+
+void log_system_info(void)
+{
+	log_processor_info();
+	log_processor_cores();
+	log_available_memory();
+	log_windows_version();
+}

libobs/obs.c

@@ -504,10 +504,14 @@ static inline bool obs_init_handlers(void)
 
 extern const struct obs_source_info scene_info;
 
+extern void log_system_info(void);
+
 static bool obs_init(const char *locale)
 {
 	obs = bzalloc(sizeof(struct obs_core));
 
+	log_system_info();
+
 	if (!obs_init_data())
 		return false;
 	if (!obs_init_handlers())