gdharness 1.1.55 → 1.1.57

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -12,6 +12,7 @@ const PlayTools = preload("tools/play_tools.gd")
 const ClassTools = preload("tools/class_tools.gd")
 const SettingsTools = preload("tools/settings_tools.gd")
 const FilesystemTools = preload("tools/filesystem_tools.gd")
+const ProfileTools = preload("tools/profile_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -22,6 +23,7 @@ var _play_tools: PlayTools = null
 var _class_tools: ClassTools = null
 var _settings_tools: SettingsTools = null
 var _filesystem_tools: FilesystemTools = null
+var _profile_tools: ProfileTools = null
 
 var _tool_map: Dictionary = {}
 var _initialized: bool = false
@@ -36,6 +38,7 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_play_tools.set_editor_plugin(plugin)
 	_class_tools.set_editor_plugin(plugin)
 	_filesystem_tools.set_editor_plugin(plugin)
+	_profile_tools.set_editor_plugin(plugin)
 
 
 func _init_tools() -> void:
@@ -71,6 +74,10 @@ func _init_tools() -> void:
 	_filesystem_tools.name = "FilesystemTools"
 	add_child(_filesystem_tools)
 
+	_profile_tools = ProfileTools.new()
+	_profile_tools.name = "ProfileTools"
+	add_child(_profile_tools)
+
 	_tool_map = {
 		# Scene tools
 		"create_scene": [_scene_tools, "create_scene"],
@@ -108,6 +115,9 @@ func _init_tools() -> void:
 		"quit_editor": [_play_tools, "quit_editor"],
 		"stop_playing": [_play_tools, "stop_playing"],
 		"playing_status": [_play_tools, "playing_status"],
+		# The script profiler on a game the editor plays
+		"profile_start": [_profile_tools, "profile_start"],
+		"profile_read": [_profile_tools, "profile_read"],
 		"create_animation": [_animation_tools, "create_animation"],
 		"add_animation_track": [_animation_tools, "add_animation_track"],
 		"add_animation_state": [_animation_tools, "add_animation_state"],

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

@@ -0,0 +1,214 @@
+@tool
+extends Node
+
+## The engine's script profiler on a game the editor plays, summed here for the server.
+##
+## The editor is that game's debugger, so the profiler is switched on through the editor's own
+## session, and what the game sends back is read where the editor reads it. The editor's handlers
+## take the `servers:*` messages before any EditorDebuggerPlugin is asked (script_editor_debugger
+## .cpp at 4.7.2), so a plugin's capture never sees them. The one place they pass through is the
+## `debug_data` signal every ScriptEditorDebugger emits for every message, on a node Godot does not
+## expose to scripts: found by its class in the editor's tree and connected to by name.
+
+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
+const DEBUGGER_CLASS: String = "ScriptEditorDebugger"
+
+
+## The editor's debugger sessions, numbered as the editor numbers its debugger tabs.
+class Sessions:
+	extends EditorDebuggerPlugin
+
+	signal session_started(session_id: int)
+
+	func _setup_session(session_id: int) -> void:
+		var session: EditorDebuggerSession = get_session(session_id)
+		# int rather than Error: Signal.connect answers with a plain int.
+		var joined: int = session.started.connect(func() -> void: session_started.emit(session_id))
+		if joined != OK:
+			push_error("gdharness could not watch debugger session %d start: %d" % [session_id, joined])
+
+
+var _editor_plugin: EditorPlugin = null
+var _sessions: Sessions = null
+## The debugger tabs connected to, by instance id, so none is connected twice.
+var _hooked: Dictionary[int, bool] = {}
+
+## A play asked to be profiled before its session started.
+var _armed: bool = false
+var _session: int = -1
+var _started_msec: int = 0
+var _last_frame_msec: int = -1
+var _frames: int = 0
+var _complete: bool = false
+var _names: Dictionary[int, String] = {}
+## Per signature: calls, self seconds, total seconds.
+var _totals: Dictionary[String, PackedFloat64Array] = {}
+
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+	_sessions = Sessions.new()
+	var joined: int = _sessions.session_started.connect(_on_session_started)
+	if joined != OK:
+		push_error("gdharness could not watch debugger sessions start: %d" % joined)
+	plugin.add_debugger_plugin(_sessions)
+
+
+func _exit_tree() -> void:
+	if _editor_plugin != null and _sessions != null:
+		_editor_plugin.remove_debugger_plugin(_sessions)
+	_sessions = null
+
+
+## Switches the profiler on for the game being played, or with [code]arm[/code] for the next one
+## to start and never the one playing: a start ends the game before it, which can still be going.
+## Either way what was summed before is dropped.
+func profile_start(args: Dictionary) -> Dictionary:
+	if _hook() == 0:
+		return {
+			"ok": false,
+			"error":
+			(
+				(
+					"This editor's debugger has no %s node to read the profiler from, which is where Godot"
+					+ " 4.7 keeps it: a Godot that moved it has to be met by a gdharness that knows where."
+				)
+				% DEBUGGER_CLASS
+			),
+		}
+	_reset()
+	if Read.as_bool(args.get("arm", false)):
+		_armed = true
+		return {"ok": true, "started": false, "armed": true, "session": -1}
+	var active: int = _active_session()
+	if active < 0:
+		return {"ok": true, "started": false, "armed": false, "session": -1}
+	_switch_on(active)
+	return {"ok": true, "started": true, "armed": false, "session": active}
+
+
+## What has been summed, for the server to put into an answer.
+func profile_read(_args: Dictionary) -> Dictionary:
+	var functions: Dictionary = {}
+	for signature: String in _totals:
+		functions[signature] = Array(_totals[signature])
+	return {
+		"ok": true,
+		"profiled": _session >= 0,
+		"armed": _armed,
+		"session": _session,
+		"playing": EditorInterface.is_playing_scene(),
+		"frames": _frames,
+		"complete": _complete,
+		"coveredMs": _last_frame_msec - _started_msec if _last_frame_msec >= 0 else 0,
+		"functions": functions,
+	}
+
+
+func _reset() -> void:
+	_armed = false
+	_session = -1
+	_frames = 0
+	_complete = false
+	_last_frame_msec = -1
+	_names.clear()
+	_totals.clear()
+
+
+func _active_session() -> int:
+	if _sessions == null:
+		return -1
+	var all: Array[EditorDebuggerSession] = _sessions.get_sessions()
+	for index: int in all.size():
+		if all[index].is_active():
+			return index
+	return -1
+
+
+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])
+
+
+## A play that was asked to be profiled is switched on as it starts. Any other play drops what is
+## held: the editor plays the next game in the same session, and a profile kept past it was read as
+## the new game's.
+func _on_session_started(session_id: int) -> void:
+	if not _armed:
+		_reset()
+		return
+	_armed = false
+	if _hook() > 0:
+		_switch_on(session_id)
+
+
+## Connects to every debugger tab not connected yet, in tab order, which is session order.
+func _hook() -> int:
+	var found: Array[Node] = EditorInterface.get_base_control().find_children(
+		"*", DEBUGGER_CLASS, true, false
+	)
+	for index: int in found.size():
+		var tab: Node = found[index]
+		var id: int = tab.get_instance_id()
+		if not _hooked.has(id) and tab.has_signal("debug_data"):
+			var joined: Error = tab.connect("debug_data", _on_debug_data.bind(index))
+			if joined != OK:
+				push_error("gdharness could not read debugger tab %d: %d" % [index, joined])
+			_hooked[id] = true
+	return found.size()
+
+
+func _on_debug_data(message: String, data: Array, session_id: int) -> void:
+	if session_id != _session:
+		return
+	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):
+			_frames += 1
+			_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):
+			_totals = whole
+			_complete = true
+			_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:
+	var at: int = 6
+	if data.size() <= at:
+		return false
+	var servers: int = Read.as_int(data[at])
+	at += 1
+	for _server: int in servers:
+		if data.size() <= at + 1:
+			return false
+		at += 2 + Read.as_int(data[at + 1])
+	if data.size() <= at:
+		return false
+	var values: int = Read.as_int(data[at])
+	at += 1
+	if values % 5 != 0 or data.size() < at + values:
+		return false
+	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
+		var sum: PackedFloat64Array = (
+			into[signature] if into.has(signature) else PackedFloat64Array([0, 0, 0])
+		)
+		sum[0] += Read.as_float(data[index + 1])
+		sum[1] += Read.as_float(data[index + 2])
+		sum[2] += Read.as_float(data[index + 3])
+		into[signature] = sum
+	return true

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

@@ -0,0 +1 @@
+uid://bxqtu4010skdi

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

@@ -27,6 +27,10 @@ const BIND_ADDRESS_SETTING: String = "gdharness/runtime/bind_address"
 ## expects. A fixed port is for a client that cannot read the announcement.
 const PORT_SETTING: String = "gdharness/runtime/port"
 
+## How long a profiled game waits as it leaves for its profile to be sent: the debugger's thread
+## sends every 6.9 ms, so this is many of its turns.
+const PROFILE_SEND_MS: int = 100
+
 ## How the engine is told to run a script instead of the game: `godot -s thing.gd`.
 const SCRIPT_FLAGS: PackedStringArray = ["-s", "--script"]
 
@@ -126,6 +130,7 @@ func _ready() -> void:
 
 
 func _exit_tree() -> void:
+	_send_the_profile()
 	if _errors != null:
 		OS.remove_logger(_errors)
 		_errors.close()
@@ -133,6 +138,18 @@ func _exit_tree() -> void:
 	_cleanup()
 
 
+## A profiled run's totals, sent as the game leaves the tree.
+##
+## The engine sends its script profiler's totals only when the profiler is switched off, and at
+## exit it is torn down without being switched off, so a scene that did its work in _ready and
+## quit took its whole profile with it, last frame included. The wait is for the debugger's own
+## thread, which sends what is queued every few milliseconds and stops without emptying the queue.
+func _send_the_profile() -> void:
+	if EngineDebugger.is_active() and EngineDebugger.is_profiling("servers"):
+		EngineDebugger.profiler_enable("servers", false)
+		OS.delay_msec(PROFILE_SEND_MS)
+
+
 ## The engine's error reports, written to a file for the server, for a game the editor plays, and
 ## its prints as well from the line announcing the runtime on.
 ##

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

@@ -322,12 +322,14 @@ static func _declared_type(holder: Variant, named: String) -> int:
 ## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
 ## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
 ## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
-## The answer says how many frames the wait spanned and how many looks it took, which is how a
-## caller sees what it cost.
+## The answer says how many frames the wait spanned, how many looks it took and how long they took
+## between them, which is how a caller sees what it cost and whether the game lost its speed to the
+## looks or to something else.
 func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_hidden: bool) -> Dictionary:
 	var started: int = Time.get_ticks_msec()
 	var frames: int = 0
 	var looks: int = 0
+	var looked_usec: int = 0
 	var next_look: int = 0
 	var found: bool = false
 	while true:
@@ -335,7 +337,9 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 			var looking: int = Time.get_ticks_usec()
 			found = _anything_says(node_path, said, include_hidden)
 			looks += 1
-			next_look = Time.get_ticks_usec() + (Time.get_ticks_usec() - looking) * LOOKS_APART
+			var took: int = Time.get_ticks_usec() - looking
+			looked_usec += took
+			next_look = Time.get_ticks_usec() + took * LOOKS_APART
 		if found or Time.get_ticks_msec() - started >= timeout_ms:
 			break
 		await _host.get_tree().process_frame
@@ -343,8 +347,10 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 	# One more look at the end, so words that arrived between two paced looks are not answered as
 	# never having come.
 	if not found:
+		var last: int = Time.get_ticks_usec()
 		found = _anything_says(node_path, said, include_hidden)
 		looks += 1
+		looked_usec += Time.get_ticks_usec() - last
 
 	return {
 		"type": "condition",
@@ -355,6 +361,7 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 		"elapsed_ms": Time.get_ticks_msec() - started,
 		"frames": frames,
 		"looks": looks,
+		"looking_ms": looked_usec / 1000.0,
 	}