gdharness 1.1.57 → 1.1.59

package/build/godot/addons/gdharness_editor/tools/profile_tools.gd

@@ -12,9 +12,10 @@ extends Node
 
 const Read = preload("../reading.gd")
 
-## The engine sends only the top so many functions a frame and clamps nothing on the game's side.
-## Its own buffer's default, so no frame is cut short of what was called.
-const FRAME_FUNCTIONS: int = 16384
+## The most functions a frame may carry when the server does not say. The engine names a function
+## once, as it first appears, and the game's debugger queue drops those messages past its size, so
+## the server keeps this below the queue the project sets; this is that for the engine's default.
+const FRAME_FUNCTIONS: int = 1536
 const DEBUGGER_CLASS: String = "ScriptEditorDebugger"
 
 
@@ -44,6 +45,10 @@ var _started_msec: int = 0
 var _last_frame_msec: int = -1
 var _frames: int = 0
 var _complete: bool = false
+var _frame_functions: int = FRAME_FUNCTIONS
+## Frames that carried as many functions as were asked for, and whether the totals did.
+var _capped_frames: int = 0
+var _total_capped: bool = false
 var _names: Dictionary[int, String] = {}
 ## Per signature: calls, self seconds, total seconds.
 var _totals: Dictionary[String, PackedFloat64Array] = {}
@@ -81,6 +86,8 @@ func profile_start(args: Dictionary) -> Dictionary:
 			),
 		}
 	_reset()
+	var asked: int = Read.as_int(args.get("frameFunctions", FRAME_FUNCTIONS))
+	_frame_functions = asked if asked > 0 else FRAME_FUNCTIONS
 	if Read.as_bool(args.get("arm", false)):
 		_armed = true
 		return {"ok": true, "started": false, "armed": true, "session": -1}
@@ -104,6 +111,9 @@ func profile_read(_args: Dictionary) -> Dictionary:
 		"playing": EditorInterface.is_playing_scene(),
 		"frames": _frames,
 		"complete": _complete,
+		"frameFunctions": _frame_functions,
+		"cappedFrames": _capped_frames,
+		"totalCapped": _total_capped,
 		"coveredMs": _last_frame_msec - _started_msec if _last_frame_msec >= 0 else 0,
 		"functions": functions,
 	}
@@ -114,6 +124,8 @@ func _reset() -> void:
 	_session = -1
 	_frames = 0
 	_complete = false
+	_capped_frames = 0
+	_total_capped = false
 	_last_frame_msec = -1
 	_names.clear()
 	_totals.clear()
@@ -133,7 +145,7 @@ func _switch_on(session_id: int) -> void:
 	_session = session_id
 	_started_msec = Time.get_ticks_msec()
 	var session: EditorDebuggerSession = _sessions.get_session(session_id)
-	session.toggle_profiler("servers", true, [FRAME_FUNCTIONS, false])
+	session.toggle_profiler("servers", true, [_frame_functions, false])
 
 
 ## A play that was asked to be profiled is switched on as it starts. Any other play drops what is
@@ -170,37 +182,42 @@ func _on_debug_data(message: String, data: Array, session_id: int) -> void:
 	if message == "servers:function_signature" and data.size() >= 2:
 		_names[Read.as_int(data[1])] = str(data[0])
 	elif message == "servers:profile_frame":
-		if _add(data, _totals):
+		var carried: int = _add(data, _totals)
+		if carried >= 0:
 			_frames += 1
+			_capped_frames += 1 if carried >= _frame_functions else 0
 			_last_frame_msec = Time.get_ticks_msec()
 	elif message == "servers:profile_total":
 		# The engine's own count since the profiler started, so it replaces the frames' sum.
 		var whole: Dictionary[String, PackedFloat64Array] = {}
-		if _add(data, whole):
+		var carried: int = _add(data, whole)
+		if carried >= 0:
 			_totals = whole
 			_complete = true
+			_total_capped = carried >= _frame_functions
 			_last_frame_msec = Time.get_ticks_msec()
 
 
 ## Adds one frame's functions into [param into], reading past the servers' section to reach them:
 ## six frame times, the server count, each server's name and field count and fields, then five
-## numbers per function.
-func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> bool:
+## numbers per function. Answers how many functions it carried, or -1 for a frame it cannot read.
+func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> int:
 	var at: int = 6
 	if data.size() <= at:
-		return false
+		return -1
 	var servers: int = Read.as_int(data[at])
 	at += 1
 	for _server: int in servers:
 		if data.size() <= at + 1:
-			return false
+			return -1
 		at += 2 + Read.as_int(data[at + 1])
 	if data.size() <= at:
-		return false
+		return -1
 	var values: int = Read.as_int(data[at])
 	at += 1
 	if values % 5 != 0 or data.size() < at + values:
-		return false
+		return -1
+	var carried: int = 0
 	for index: int in range(at, at + values, 5):
 		var id: int = Read.as_int(data[index])
 		var signature: String = _names[id] if _names.has(id) else "#%d" % id
@@ -211,4 +228,5 @@ func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> bool:
 		sum[1] += Read.as_float(data[index + 2])
 		sum[2] += Read.as_float(data[index + 3])
 		into[signature] = sum
-	return true
+		carried += 1
+	return carried

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -172,6 +172,7 @@ func _report_errors() -> void:
 func _process(_delta: float) -> void:
 	if not _enabled or _server == null:
 		return
+	_queries.note_frame(Time.get_ticks_usec())
 
 	if _server.is_connection_available():
 		var client: StreamPeerTCP = _server.take_connection()

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -28,8 +28,14 @@ const READ_LIMIT: int = 500
 ## and said nothing, and a caller told to raise a number that stays put concludes the screen moved.
 const LIMIT_CEILING: int = 5000
 
+## How many frames the frame time is the mean of: two seconds at sixty frames a second.
+const FRAMES_TIMED: int = 120
+
 var _host: Node
 var _values: Values
+## How long each of the last frames took, oldest first, in microseconds, as the game timed them.
+var _frame_usec: PackedInt64Array = PackedInt64Array()
+var _last_frame_usec: int = 0
 
 
 ## The host is the autoload, which is how the tree is reached: it is not in one when the
@@ -649,12 +655,60 @@ func get_property(params: Dictionary) -> Dictionary:
 	}
 
 
+## Called by the autoload once a frame, whatever else it does that frame, with the time it was called.
+##
+## The engine's own monitors do not follow the frame: TIME_PROCESS and the frame rate are set once a
+## second, the first to the slowest process step of that second, so a game whose frames took 16.7ms
+## read 45ms for a second at a time, and a change to the game showed only on the next second's
+## worst frame. The time between two of these calls is the frame as it passed, physics and the wait
+## for the display included.
+func note_frame(now_usec: int) -> void:
+	if _last_frame_usec > 0:
+		var _grew: bool = _frame_usec.push_back(now_usec - _last_frame_usec)
+		if _frame_usec.size() > FRAMES_TIMED:
+			_frame_usec.remove_at(0)
+	_last_frame_usec = now_usec
+
+
+## Whether the frame waits for the display, which sets its floor: a game with vsync on cannot
+## finish a frame sooner than the display refreshes, however little it does.
+static func _vsync() -> String:
+	if DisplayServer.get_name() == "headless":
+		return "none, headless"
+	match DisplayServer.window_get_vsync_mode():
+		DisplayServer.VSYNC_DISABLED:
+			return "disabled"
+		DisplayServer.VSYNC_ADAPTIVE:
+			return "adaptive"
+		DisplayServer.VSYNC_MAILBOX:
+			return "mailbox"
+		_:
+			return "enabled"
+
+
 func get_metrics(params: Dictionary) -> Dictionary:
 	var metrics: Array = params.get("metrics", [])
+	var timed: int = _frame_usec.size()
+	var total_usec: int = 0
+	var slowest_usec: int = 0
+	for one: int in _frame_usec:
+		total_usec += one
+		slowest_usec = maxi(slowest_usec, one)
+	# Null rather than zero before a frame has been timed: no frame took no time.
+	var frame_time: Variant = null
+	var frame_time_max: Variant = null
+	if timed > 0:
+		frame_time = float(total_usec) / timed / 1000000.0
+		frame_time_max = slowest_usec / 1000000.0
 	var all: Dictionary = {
 		"fps": Engine.get_frames_per_second(),
-		"frame_time": Performance.get_monitor(Performance.TIME_PROCESS),
+		"frame_time": frame_time,
+		"frame_time_max": frame_time_max,
+		"frames_timed": timed,
+		"process_time_max": Performance.get_monitor(Performance.TIME_PROCESS),
 		"physics_time": Performance.get_monitor(Performance.TIME_PHYSICS_PROCESS),
+		"vsync": _vsync(),
+		"max_fps": Engine.max_fps,
 		"memory_static": Performance.get_monitor(Performance.MEMORY_STATIC),
 		"memory_static_max": Performance.get_monitor(Performance.MEMORY_STATIC_MAX),
 		"object_count": Performance.get_monitor(Performance.OBJECT_COUNT),