get ram and cpu measures for autoconfig

Author: summeroff

js/module.d.ts

@@ -977,6 +977,29 @@ export interface IAudioTrackFactory {
     importLegacySettings(): void;
     saveLegacySettings(): void;
 }
+export interface IAutoConfigResourcePercentile {
+    p50: number;
+    p95: number;
+}
+export interface IAutoConfigResourceGpu {
+    available: boolean;
+    vramUsedMB?: IAutoConfigResourcePercentile;
+    vramBudgetMB?: number;
+}
+export type AutoConfigResourcePhase = 'bandwidth' | 'stream_encoder' | 'recording_encoder';
+export interface IAutoConfigResourceUsage {
+    phase: AutoConfigResourcePhase;
+    sampleCount: number;
+    durationMs: number;
+    cpuPct: IAutoConfigResourcePercentile;
+    procRamMB: IAutoConfigResourcePercentile;
+    gpu: IAutoConfigResourceGpu;
+}
+export interface IAutoConfigSummary {
+    complete: boolean;
+    resourceUsage: IAutoConfigResourceUsage[];
+    [key: string]: unknown;
+}
 export declare const enum VCamOutputType {
     Invalid = 0,
     SceneOutput = 1,

js/module.ts

@@ -1925,6 +1925,48 @@ export interface IAudioTrackFactory {
     saveLegacySettings(): void;
 }
 
+// ---- Autoconfig resource-usage telemetry ----
+//
+// Shapes for the JSON payload of the autoconfig 'resource_usage' event, and
+// the matching `resourceUsage` array inside GetAutoConfigSummary()'s JSON.
+//
+// p50 is the typical value during the phase; p95 is the sustained ceiling
+// after dropping single-sample spikes from unrelated OS noise. min / max / avg
+// are deliberately not exposed — max overweights one-off background activity
+// and avg is hard to act on.
+
+export interface IAutoConfigResourcePercentile {
+    p50: number;
+    p95: number;
+}
+
+export interface IAutoConfigResourceGpu {
+    available: boolean;
+    vramUsedMB?: IAutoConfigResourcePercentile;
+    vramBudgetMB?: number;
+}
+
+export type AutoConfigResourcePhase = 'bandwidth' | 'stream_encoder' | 'recording_encoder';
+
+export interface IAutoConfigResourceUsage {
+    phase: AutoConfigResourcePhase;
+    sampleCount: number;
+    durationMs: number;
+    cpuPct: IAutoConfigResourcePercentile;
+    procRamMB: IAutoConfigResourcePercentile;
+    gpu: IAutoConfigResourceGpu;
+}
+
+// Parsed shape of NodeObs.GetAutoConfigSummary(). Only the fields the
+// resource-usage feature consumes are typed; other historical fields
+// (encoderDetection, videoDecision, bandwidthTest, selection) are present in
+// the JSON but intentionally left as `unknown` — type them when you need them.
+export interface IAutoConfigSummary {
+    complete: boolean;
+    resourceUsage: IAutoConfigResourceUsage[];
+    [key: string]: unknown;
+}
+
 export const enum VCamOutputType {
 	Invalid,
 	SceneOutput,

js/tsconfig.json

@@ -10,7 +10,6 @@
     "noImplicitAny": true,
     "noImplicitThis": true,
     "removeComments": true,
-    "suppressImplicitAnyIndexErrors": true,
     "allowSyntheticDefaultImports": true,
     "strictNullChecks": false,
     "emitDecoratorMetadata": true

obs-studio-server/CMakeLists.txt

@@ -368,6 +368,8 @@ SET(osn-server_SOURCES
     "${PROJECT_SOURCE_DIR}/source/nodeobs_audio_encoders.h"
     "${PROJECT_SOURCE_DIR}/source/nodeobs_autoconfig.cpp"
     "${PROJECT_SOURCE_DIR}/source/nodeobs_autoconfig.h"
+    "${PROJECT_SOURCE_DIR}/source/nodeobs_autoconfig_resource_sampler.cpp"
+    "${PROJECT_SOURCE_DIR}/source/nodeobs_autoconfig_resource_sampler.h"
     "${PROJECT_SOURCE_DIR}/source/nodeobs_configManager.cpp"
     "${PROJECT_SOURCE_DIR}/source/nodeobs_configManager.hpp"
     "${PROJECT_SOURCE_DIR}/source/nodeobs_display.cpp"

obs-studio-server/source/nodeobs_autoconfig.cpp

@@ -17,6 +17,7 @@
 ******************************************************************************/
 
 #include "nodeobs_autoconfig.h"
+#include "nodeobs_autoconfig_resource_sampler.h"
 #include <algorithm>
 #include <array>
 #include <future>
@@ -158,6 +159,12 @@ struct AutoconfigRun {
 	};
 	std::vector<SelectionDetail> selectionDetails;
 
+	// Per-phase resource samples (CPU%, process RAM, optionally GPU VRAM).
+	// Captured by ResourceSampler around the bandwidth and encoder test phases;
+	// surfaced via the resource_usage event + summary IPC. Pure telemetry — no
+	// influence on the selection heuristics in this version.
+	std::vector<autoConfig::ResourceWindow> resourceWindows;
+
 	// Per-canvas video-context decision. Captured in applyResults.
 	struct VideoDecision {
 		void *contextPtr = nullptr;
@@ -234,6 +241,65 @@ void autoConfig::WaitPendingTests(double timeout)
 	}
 }
 
+// Serialize a ResourceWindow to JSON and emit a resource_usage event. The window
+// is also pushed onto runContext.resourceWindows so GetAutoConfigSummary can
+// re-emit it later. Frontends can consume either the event stream or the summary.
+static std::string resourceWindowToJson(const autoConfig::ResourceWindow &w)
+{
+	obs_data_t *root = obs_data_create();
+	obs_data_set_string(root, "phase", w.phase.c_str());
+	obs_data_set_int(root, "sampleCount", w.sampleCount);
+	obs_data_set_int(root, "durationMs", w.durationMs);
+
+	// p50 is the typical value during the window; p95 is the sustained ceiling
+	// after dropping single-sample outliers (a background process briefly using
+	// CPU shouldn't dominate the report).
+	auto putPct = [&](const char *key, double p50, double p95) {
+		obs_data_t *o = obs_data_create();
+		obs_data_set_double(o, "p50", p50);
+		obs_data_set_double(o, "p95", p95);
+		obs_data_set_obj(root, key, o);
+		obs_data_release(o);
+	};
+	auto putPctInt = [&](obs_data_t *parent, const char *key, uint64_t p50, uint64_t p95) {
+		obs_data_t *o = obs_data_create();
+		obs_data_set_int(o, "p50", (long long)p50);
+		obs_data_set_int(o, "p95", (long long)p95);
+		obs_data_set_obj(parent, key, o);
+		obs_data_release(o);
+	};
+
+	putPct("cpuPct", w.p50Sample.cpuPct, w.p95Sample.cpuPct);
+	putPct("procRamMB", w.p50Sample.procRamMB, w.p95Sample.procRamMB);
+
+	obs_data_t *gpu = obs_data_create();
+	obs_data_set_bool(gpu, "available", w.gpuAvailable);
+	if (w.gpuAvailable) {
+		putPctInt(gpu, "vramUsedMB", w.p50Sample.gpuVramUsedMB, w.p95Sample.gpuVramUsedMB);
+		// Budget is platform-driven and effectively constant across a window —
+		// surface a single number rather than a percentile pair.
+		obs_data_set_int(gpu, "vramBudgetMB", (long long)w.p95Sample.gpuVramBudgetMB);
+	}
+	obs_data_set_obj(root, "gpu", gpu);
+	obs_data_release(gpu);
+
+	std::string json = obs_data_get_json(root);
+	obs_data_release(root);
+	return json;
+}
+
+static void recordResourceWindow(const autoConfig::ResourceWindow &w)
+{
+	if (w.sampleCount <= 0)
+		return;
+
+	runContext.resourceWindows.push_back(w);
+
+	std::string payload = resourceWindowToJson(w);
+	std::lock_guard<std::mutex> lock(eventsMutex);
+	events.push(AutoConfigInfo("resource_usage", w.phase, 100, payload));
+}
+
 void autoConfig::TestHardwareEncoding(void)
 {
 	size_t idx = 0;
@@ -518,6 +584,23 @@ void autoConfig::GetAutoConfigSummary(void *data, const int64_t id, const std::v
 		obs_data_release(sel);
 	}
 
+	// resourceUsage — per-phase CPU/RAM (and Windows-only GPU VRAM) samples
+	// captured during the bandwidth and encoder test phases. Same JSON shape
+	// as the resource_usage event payload.
+	{
+		obs_data_array_t *windows = obs_data_array_create();
+		for (auto &w : runContext.resourceWindows) {
+			std::string s = resourceWindowToJson(w);
+			obs_data_t *item = obs_data_create_from_json(s.c_str());
+			if (item) {
+				obs_data_array_push_back(windows, item);
+				obs_data_release(item);
+			}
+		}
+		obs_data_set_array(root, "resourceUsage", windows);
+		obs_data_array_release(windows);
+	}
+
 	std::string json = obs_data_get_json_pretty(root);
 	obs_data_release(root);
 
@@ -538,6 +621,15 @@ void autoConfig::InitializeAutoConfig(void *data, const int64_t id, const std::v
 	runContext = AutoconfigRun{};
 	cancel = false;
 
+	// Drain leftover events from a prior run. Otherwise a stopping_step queued
+	// by an aborted bandwidth thread (e.g. after TerminateAutoConfig) leaks into
+	// the next session's first drainUntil() and confuses callers.
+	{
+		std::lock_guard<std::mutex> lock(eventsMutex);
+		while (!events.empty())
+			events.pop();
+	}
+
 	if (!args.empty()) {
 		const std::vector<char> &bin = args[0].value_bin;
 		size_t n = bin.size() / sizeof(uint64_t);
@@ -846,9 +938,11 @@ void autoConfig::TestBandwidthThreadV2(void)
 			// the loop above exits as soon as signals are drained (often
 			// < 100 ms after the RTMP connection opens) and totalBytes is 0.
 			int dataWaitMs = 0;
+			autoConfig::ResourceSampler sampler;
 			if (!gotError && allConnected) {
 				const int targetWaitMs = 5000;
 				auto dataStart = std::chrono::steady_clock::now();
+				sampler.start("bandwidth");
 				while (std::chrono::steady_clock::now() - dataStart < std::chrono::milliseconds(targetWaitMs)) {
 					std::unique_lock<std::mutex> ul(m);
 					if (cancel) {
@@ -857,8 +951,10 @@ void autoConfig::TestBandwidthThreadV2(void)
 					}
 					ul.unlock();
 					std::this_thread::sleep_for(std::chrono::milliseconds(250));
+					sampler.sample();
 				}
 				dataWaitMs = (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - dataStart).count();
+				recordResourceWindow(sampler.stop());
 			}
 
 			if (!gotError) {
@@ -1693,6 +1789,9 @@ void autoConfig::TestStreamEncoderThread()
 	events.push(AutoConfigInfo("starting_step", "runContext.streamingEncoder_test", 0));
 	eventsMutex.unlock();
 
+	autoConfig::ResourceSampler sampler;
+	sampler.start("stream_encoder", std::chrono::milliseconds(250));
+
 	TestHardwareEncoding();
 
 	if (!runContext.softwareTested) {
@@ -1738,6 +1837,8 @@ void autoConfig::TestStreamEncoderThread()
 		events.push(AutoConfigInfo("encoder_detection", "summary", 100, payload));
 	}
 
+	recordResourceWindow(sampler.stop());
+
 	eventsMutex.lock();
 	events.push(AutoConfigInfo("stopping_step", "runContext.streamingEncoder_test", 100));
 	eventsMutex.unlock();
@@ -1749,6 +1850,9 @@ void autoConfig::TestRecordingEncoderThread()
 	events.push(AutoConfigInfo("starting_step", "runContext.recordingEncoder_test", 0));
 	eventsMutex.unlock();
 
+	autoConfig::ResourceSampler sampler;
+	sampler.start("recording_encoder", std::chrono::milliseconds(250));
+
 	TestHardwareEncoding();
 
 	if (!runContext.hardwareEncodingAvailable && !runContext.softwareTested) {
@@ -1785,6 +1889,8 @@ void autoConfig::TestRecordingEncoderThread()
 		}
 	}
 
+	recordResourceWindow(sampler.stop());
+
 	eventsMutex.lock();
 	events.push(AutoConfigInfo("stopping_step", "runContext.recordingEncoder_test", 100));
 	eventsMutex.unlock();