Merge pull request #97210 from AleksLitynski/object-snapshot-debugger

Add an ObjectDB Profiling Tool

Author: Repiteo

core/object/object.cpp

@@ -2374,12 +2374,12 @@ void postinitialize_handler(Object *p_object) {
 	p_object->_postinitialize();
 }
 
-void ObjectDB::debug_objects(DebugFunc p_func) {
+void ObjectDB::debug_objects(DebugFunc p_func, void *p_user_data) {
 	spin_lock.lock();
 
 	for (uint32_t i = 0, count = slot_count; i < slot_max && count != 0; i++) {
 		if (object_slots[i].validator) {
-			p_func(object_slots[i].object);
+			p_func(object_slots[i].object, p_user_data);
 			count--;
 		}
 	}
@@ -2547,6 +2547,9 @@ void ObjectDB::cleanup() {
 					if (obj->is_class("Resource")) {
 						extra_info = " - Resource path: " + String(resource_get_path->call(obj, nullptr, 0, call_error));
 					}
+					if (obj->is_class("RefCounted")) {
+						extra_info = " - Reference count: " + itos((static_cast<RefCounted *>(obj))->get_reference_count());
+					}
 
 					uint64_t id = uint64_t(i) | (uint64_t(object_slots[i].validator) << OBJECTDB_SLOT_MAX_COUNT_BITS) | (object_slots[i].is_ref_counted ? OBJECTDB_REFERENCE_BIT : 0);
 					DEV_ASSERT(id == (uint64_t)obj->get_instance_id()); // We could just use the id from the object, but this check may help catching memory corruption catastrophes.

core/object/object.h

@@ -1094,7 +1094,7 @@ class ObjectDB {
 	static void setup();
 
 public:
-	typedef void (*DebugFunc)(Object *p_obj);
+	typedef void (*DebugFunc)(Object *p_obj, void *p_user_data);
 
 	_ALWAYS_INLINE_ static Object *get_instance(ObjectID p_instance_id) {
 		uint64_t id = p_instance_id;
@@ -1126,6 +1126,6 @@ class ObjectDB {
 	template <typename T>
 	_ALWAYS_INLINE_ static Ref<T> get_ref(ObjectID p_instance_id); // Defined in ref_counted.h
 
-	static void debug_objects(DebugFunc p_func);
+	static void debug_objects(DebugFunc p_func, void *p_user_data);
 	static int get_object_count();
 };

doc/classes/Tree.xml

@@ -124,6 +124,13 @@
 				Returns column title language code.
 			</description>
 		</method>
+		<method name="get_column_title_tooltip_text" qualifiers="const">
+			<return type="String" />
+			<param index="0" name="column" type="int" />
+			<description>
+				Returns the column title's tooltip text.
+			</description>
+		</method>
 		<method name="get_column_width" qualifiers="const">
 			<return type="int" />
 			<param index="0" name="column" type="int" />
@@ -322,6 +329,14 @@
 				Sets language code of column title used for line-breaking and text shaping algorithms, if left empty current locale is used instead.
 			</description>
 		</method>
+		<method name="set_column_title_tooltip_text">
+			<return type="void" />
+			<param index="0" name="column" type="int" />
+			<param index="1" name="tooltip_text" type="String" />
+			<description>
+				Sets the column title's tooltip text.
+			</description>
+		</method>
 		<method name="set_selected">
 			<return type="void" />
 			<param index="0" name="item" type="TreeItem" />

modules/objectdb_profiler/SCsub

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+from misc.utility.scons_hints import *
+
+Import("env")
+Import("env_modules")
+
+env_objdb = env_modules.Clone()
+
+module_obj = []
+
+# Only include in editor and debug builds.
+if env_objdb.debug_features:
+    env_objdb.add_source_files(module_obj, "*.cpp")
+
+    # Only the editor needs these files, don't include them in the game.
+    if env.editor_build:
+        env_objdb.add_source_files(module_obj, "editor/*.cpp")
+        env_objdb.add_source_files(module_obj, "editor/data_viewers/*.cpp")
+
+env.modules_sources += module_obj

modules/objectdb_profiler/config.py

@@ -0,0 +1,6 @@
+def can_build(env, platform):
+    return env.debug_features
+
+
+def configure(env):
+    pass

modules/objectdb_profiler/editor/data_viewers/class_view.cpp

@@ -0,0 +1,282 @@
+/**************************************************************************/
+/*  class_view.cpp                                                        */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "class_view.h"
+
+#include "shared_controls.h"
+
+#include "editor/editor_node.h"
+#include "editor/themes/editor_scale.h"
+#include "scene/gui/split_container.h"
+
+int ClassData::instance_count(GameStateSnapshot *p_snapshot) {
+	int count = 0;
+	for (const SnapshotDataObject *instance : instances) {
+		if (!p_snapshot || instance->snapshot == p_snapshot) {
+			count += 1;
+		}
+	}
+	return count;
+}
+
+int ClassData::get_recursive_instance_count(HashMap<String, ClassData> &p_all_classes, GameStateSnapshot *p_snapshot) {
+	if (!recursive_instance_count_cache.has(p_snapshot)) {
+		recursive_instance_count_cache[p_snapshot] = instance_count(p_snapshot);
+		for (const String &child : child_classes) {
+			recursive_instance_count_cache[p_snapshot] += p_all_classes[child].get_recursive_instance_count(p_all_classes, p_snapshot);
+		}
+	}
+	return recursive_instance_count_cache[p_snapshot];
+}
+
+SnapshotClassView::SnapshotClassView() {
+	set_name(TTRC("Classes"));
+}
+
+void SnapshotClassView::show_snapshot(GameStateSnapshot *p_data, GameStateSnapshot *p_diff_data) {
+	SnapshotView::show_snapshot(p_data, p_diff_data);
+
+	set_v_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	set_h_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+
+	HSplitContainer *classes_view = memnew(HSplitContainer);
+	add_child(classes_view);
+	classes_view->set_anchors_preset(LayoutPreset::PRESET_FULL_RECT);
+	classes_view->set_v_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	classes_view->set_h_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	classes_view->set_split_offset(0);
+
+	VBoxContainer *class_list_column = memnew(VBoxContainer);
+	class_list_column->set_v_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	class_list_column->set_h_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	classes_view->add_child(class_list_column);
+
+	class_tree = memnew(Tree);
+
+	TreeSortAndFilterBar *filter_bar = memnew(TreeSortAndFilterBar(class_tree, TTRC("Filter Classes")));
+	filter_bar->add_sort_option(TTRC("Name"), TreeSortAndFilterBar::SortType::ALPHA_SORT, 0);
+
+	TreeSortAndFilterBar::SortOptionIndexes default_sort;
+	if (!diff_data) {
+		default_sort = filter_bar->add_sort_option(TTRC("Count"), TreeSortAndFilterBar::SortType::NUMERIC_SORT, 1);
+	} else {
+		filter_bar->add_sort_option(TTRC("A Count"), TreeSortAndFilterBar::SortType::NUMERIC_SORT, 1);
+		filter_bar->add_sort_option(TTRC("B Count"), TreeSortAndFilterBar::SortType::NUMERIC_SORT, 2);
+		default_sort = filter_bar->add_sort_option(TTRC("Delta"), TreeSortAndFilterBar::SortType::NUMERIC_SORT, 3);
+	}
+	class_list_column->add_child(filter_bar);
+
+	class_tree->set_select_mode(Tree::SelectMode::SELECT_ROW);
+	class_tree->set_custom_minimum_size(Size2(200 * EDSCALE, 0));
+	class_tree->set_hide_folding(false);
+	class_tree->set_hide_root(true);
+	class_tree->set_columns(diff_data ? 4 : 2);
+	class_tree->set_column_titles_visible(true);
+	class_tree->set_column_title(0, TTRC("Class"));
+	class_tree->set_column_expand(0, true);
+	class_tree->set_column_custom_minimum_width(0, 200 * EDSCALE);
+	class_tree->set_column_title(1, diff_data ? TTRC("A Count") : TTRC("Count"));
+	class_tree->set_column_expand(1, false);
+	if (diff_data) {
+		class_tree->set_column_title_tooltip_text(1, vformat(TTR("A: %s"), snapshot_data->name));
+		class_tree->set_column_title_tooltip_text(2, vformat(TTR("B: %s"), diff_data->name));
+		class_tree->set_column_title(2, TTRC("B Count"));
+		class_tree->set_column_expand(2, false);
+		class_tree->set_column_title(3, TTRC("Delta"));
+		class_tree->set_column_expand(3, false);
+	}
+	class_tree->connect(SceneStringName(item_selected), callable_mp(this, &SnapshotClassView::_class_selected));
+	class_tree->set_h_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	class_tree->set_v_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	class_tree->set_anchors_preset(LayoutPreset::PRESET_FULL_RECT);
+	class_list_column->add_child(class_tree);
+
+	VSplitContainer *object_lists = memnew(VSplitContainer);
+	classes_view->add_child(object_lists);
+	object_lists->set_custom_minimum_size(Size2(150 * EDSCALE, 0));
+	object_lists->set_h_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	object_lists->set_v_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	if (!diff_data) {
+		object_lists->add_child(object_list = _make_object_list_tree(TTRC("Objects")));
+	} else {
+		object_lists->add_child(object_list = _make_object_list_tree(TTRC("A Objects")));
+		object_lists->add_child(diff_object_list = _make_object_list_tree(TTRC("B Objects")));
+	}
+
+	HashMap<String, ClassData> grouped_by_class;
+	grouped_by_class["Object"] = ClassData("Object", "");
+	_add_objects_to_class_map(grouped_by_class, snapshot_data);
+	if (diff_data != nullptr) {
+		_add_objects_to_class_map(grouped_by_class, diff_data);
+	}
+
+	grouped_by_class[""].tree_node = class_tree->create_item();
+	List<String> classes_todo;
+	for (const String &c : grouped_by_class[""].child_classes) {
+		classes_todo.push_front(c);
+	}
+	while (classes_todo.size() > 0) {
+		String next_class_name = classes_todo.front()->get();
+		classes_todo.pop_front();
+		ClassData &next = grouped_by_class[next_class_name];
+		ClassData &nexts_parent = grouped_by_class[next.parent_class_name];
+		next.tree_node = class_tree->create_item(nexts_parent.tree_node);
+		next.tree_node->set_text(0, next_class_name + " (" + String::num_int64(next.instance_count(snapshot_data)) + ")");
+		next.tree_node->set_auto_translate_mode(0, AUTO_TRANSLATE_MODE_DISABLED);
+		int a_count = next.get_recursive_instance_count(grouped_by_class, snapshot_data);
+		next.tree_node->set_text(1, String::num_int64(a_count));
+		if (diff_data) {
+			int b_count = next.get_recursive_instance_count(grouped_by_class, diff_data);
+			next.tree_node->set_text(2, String::num_int64(b_count));
+			next.tree_node->set_text(3, String::num_int64(a_count - b_count));
+		}
+		next.tree_node->set_metadata(0, next_class_name);
+		for (const String &c : next.child_classes) {
+			classes_todo.push_front(c);
+		}
+	}
+
+	// Icons won't load until the frame after show_snapshot is called. Not sure why, but just defer the load.
+	callable_mp(this, &SnapshotClassView::_notification).call_deferred(NOTIFICATION_THEME_CHANGED);
+
+	// Default to sort by descending count. Putting the biggest groups at the top is generally pretty interesting.
+	filter_bar->select_sort(default_sort.descending);
+	filter_bar->apply();
+}
+
+Tree *SnapshotClassView::_make_object_list_tree(const String &p_column_name) {
+	Tree *list = memnew(Tree);
+	list->set_select_mode(Tree::SelectMode::SELECT_ROW);
+	list->set_hide_folding(true);
+	list->set_hide_root(true);
+	list->set_columns(1);
+	list->set_column_titles_visible(true);
+	list->set_column_title(0, p_column_name);
+	list->set_column_expand(0, true);
+	list->connect(SceneStringName(item_selected), callable_mp(this, &SnapshotClassView::_object_selected).bind(list));
+	list->set_h_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	list->set_v_size_flags(SizeFlags::SIZE_EXPAND_FILL);
+	return list;
+}
+
+void SnapshotClassView::_add_objects_to_class_map(HashMap<String, ClassData> &p_class_map, GameStateSnapshot *p_objects) {
+	for (const KeyValue<ObjectID, SnapshotDataObject *> &pair : p_objects->objects) {
+		StringName class_name = pair.value->type_name;
+		StringName parent_class_name = !class_name.is_empty() && ClassDB::class_exists(class_name) ? ClassDB::get_parent_class(class_name) : "";
+
+		p_class_map[class_name].instances.push_back(pair.value);
+
+		// Go up the tree and insert all parents/grandparents.
+		while (!class_name.is_empty()) {
+			if (!p_class_map.has(class_name)) {
+				p_class_map[class_name] = ClassData(class_name, parent_class_name);
+			}
+
+			if (!p_class_map.has(parent_class_name)) {
+				// Leave our grandparent blank for now. Next iteration of the while loop will fill it in.
+				p_class_map[parent_class_name] = ClassData(parent_class_name, "");
+			}
+			p_class_map[class_name].parent_class_name = parent_class_name;
+			p_class_map[parent_class_name].child_classes.insert(class_name);
+
+			class_name = parent_class_name;
+			parent_class_name = !class_name.is_empty() ? ClassDB::get_parent_class(class_name) : "";
+		}
+	}
+}
+
+void SnapshotClassView::_object_selected(Tree *p_tree) {
+	GameStateSnapshot *snapshot = snapshot_data;
+	if (diff_data) {
+		Tree *other = p_tree == diff_object_list ? object_list : diff_object_list;
+		TreeItem *selected = other->get_selected();
+		if (selected) {
+			selected->deselect(0);
+		}
+		if (p_tree == diff_object_list) {
+			snapshot = diff_data;
+		}
+	}
+	ObjectID object_id = p_tree->get_selected()->get_metadata(0);
+	EditorNode::get_singleton()->push_item(static_cast<Object *>(snapshot->objects[object_id]));
+}
+
+void SnapshotClassView::_class_selected() {
+	_update_lists();
+}
+
+void SnapshotClassView::_populate_object_list(GameStateSnapshot *p_snapshot, Tree *p_list, const String &p_name_base) {
+	p_list->clear();
+
+	TreeItem *selected_item = class_tree->get_selected();
+	if (selected_item == nullptr) {
+		p_list->set_column_title(0, vformat("%s (0)", TTR(p_name_base)));
+		return;
+	}
+
+	String class_name = selected_item->get_metadata(0);
+	TreeItem *root = p_list->create_item();
+	int object_count = 0;
+	for (const KeyValue<ObjectID, SnapshotDataObject *> &pair : p_snapshot->objects) {
+		if (pair.value->type_name == class_name) {
+			TreeItem *item = p_list->create_item(root);
+			item->set_auto_translate_mode(0, AUTO_TRANSLATE_MODE_DISABLED);
+			item->set_text(0, pair.value->get_name());
+			item->set_metadata(0, pair.value->remote_object_id);
+			item->set_text_overrun_behavior(0, TextServer::OverrunBehavior::OVERRUN_NO_TRIMMING);
+			object_count++;
+		}
+	}
+
+	p_list->set_column_title(0, vformat("%s (%d)", TTR(p_name_base), object_count));
+}
+
+void SnapshotClassView::_update_lists() {
+	if (snapshot_data == nullptr) {
+		return;
+	}
+
+	if (!diff_data) {
+		_populate_object_list(snapshot_data, object_list, TTRC("Objects"));
+	} else {
+		_populate_object_list(snapshot_data, object_list, TTRC("A Objects"));
+		_populate_object_list(diff_data, diff_object_list, TTRC("B Objects"));
+	}
+}
+
+void SnapshotClassView::_notification(int p_what) {
+	if (p_what == NOTIFICATION_THEME_CHANGED) {
+		for (TreeItem *item : _get_children_recursive(class_tree)) {
+			item->set_icon(0, EditorNode::get_singleton()->get_class_icon(item->get_metadata(0), ""));
+		}
+	} else if (p_what == NOTIFICATION_TRANSLATION_CHANGED) {
+		_update_lists();
+	}
+}