Merge pull request #7 from Ryan-000/add_tracy_module

wip

Author: Ryan-000

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "modules/godot_tracy"]
+	path = modules/godot_tracy
+	url = https://github.com/AndreaCatania/godot_tracy.git

core/object/message_queue.cpp

@@ -226,6 +226,40 @@ void CallQueue::_call_function(const Callable &p_callable, const Variant *p_args
 Error CallQueue::flush() {
 	LOCK_MUTEX;
 
+#ifdef MODULE_GODOT_TRACY_ENABLED
+	ZoneScoped; // Trace the entire push operation
+
+	// Start constructing the identifier
+	String identifier = "Callable::";
+	Object *obj = p_callable.get_object(); // Get the object associated with the callable
+
+	if (obj) {
+		// Check if it's a standard method (not from a script)
+		if (p_callable.is_standard()) {
+			// Append the standard method name and class name
+			identifier += obj->get_class() + "::" + p_callable.get_method();
+		} else {
+			// It's a script callable, so get the script instance
+			ScriptInstance *script = obj->get_script_instance();
+			if (script) {
+				// Get the script path and append it to the identifier along with the method name
+				identifier = "Script::" + script->get_script()->get_path() + "::" + p_callable.get_method();
+			} else {
+				// Fallback to using just the class name and method if no script instance is found
+				identifier += "Custom::" + obj->get_class() + "::" + p_callable.get_method();
+			}
+		}
+	} else {
+		// No object, use just the method name
+		identifier += p_callable.get_method();
+	}
+
+	// Convert the identifier to a char array for Tracy
+	CharString c = identifier.utf8();
+	ZoneName(c.get_data(), c.length());  // Set the zone name with the constructed identifier
+#endif
+
+
 	if (pages.size() == 0) {
 		// Never allocated
 		UNLOCK_MUTEX;

core/object/object.cpp

@@ -42,6 +42,12 @@
 #include "core/templates/local_vector.h"
 #include "core/variant/typed_array.h"
 
+#include "modules/modules_enabled.gen.h"
+
+#ifdef MODULE_GODOT_TRACY_ENABLED
+#include "modules/godot_tracy/profiler.h"
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 #ifdef DEBUG_ENABLED
 
 struct _ObjectDebugLock {
@@ -751,6 +757,12 @@ Variant Object::callv(const StringName &p_method, const Array &p_args) {
 }
 
 Variant Object::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+#ifdef MODULE_GODOT_TRACY_ENABLED
+	ZoneScoped;
+	CharString c = Profiler::stringify_method(p_method, p_args, p_argcount);
+	ZoneName(c.ptr(), c.size());
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 	r_error.error = Callable::CallError::CALL_OK;
 
 	if (p_method == CoreStringName(free_)) {
@@ -814,6 +826,12 @@ Variant Object::callp(const StringName &p_method, const Variant **p_args, int p_
 }
 
 Variant Object::call_const(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+#ifdef MODULE_GODOT_TRACY_ENABLED
+	ZoneScoped;
+	CharString c = Profiler::stringify_method(p_method, p_args, p_argcount);
+	ZoneName(c.ptr(), c.size());
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 	r_error.error = Callable::CallError::CALL_OK;
 
 	if (p_method == CoreStringName(free_)) {
@@ -862,6 +880,24 @@ Variant Object::call_const(const StringName &p_method, const Variant **p_args, i
 }
 
 void Object::notification(int p_notification, bool p_reversed) {
+#ifdef MODULE_GODOT_TRACY_ENABLED
+	ZoneScoped;  // Start a Tracy zone to track the entire notification process
+	String identifier = "Notification::" + String::num(p_notification);  // Start building the identifier
+
+	if (script_instance) {
+		// If it's a script-based notification, include the script path and notification number
+		identifier = "Script::" + script_instance->get_script()->get_path() + "::Notification::" + String::num(p_notification);
+	} else {
+		// For standard objects, include the class name
+		identifier = "Class::" + String(get_class()) + "::Notification::" + String::num(p_notification);
+	}
+
+	// Set the identifier for the Tracy zone
+	CharString c = identifier.utf8();
+	ZoneName(c.get_data(), c.length());
+#endif
+
+
 	if (p_reversed) {
 		if (script_instance) {
 			script_instance->notification(p_notification, p_reversed);

core/os/memory.cpp

@@ -36,6 +36,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
 void *operator new(size_t p_size, const char *p_description) {
 	return Memory::alloc_static(p_size, false);
 }
@@ -73,6 +74,9 @@ void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) {
 #endif
 
 	void *mem = malloc(p_bytes + (prepad ? DATA_OFFSET : 0));
+#if MODULE_GODOT_TRACY_ENABLED
+	TracyAlloc(mem, p_bytes);
+#endif
 
 	ERR_FAIL_NULL_V(mem, nullptr);
 
@@ -121,9 +125,16 @@ void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
 #endif
 
 		if (p_bytes == 0) {
+#if MODULE_GODOT_TRACY_ENABLED
+			TracyFree(mem);
+#endif
 			free(mem);
 			return nullptr;
 		} else {
+#if MODULE_GODOT_TRACY_ENABLED
+			TracyFree(mem + DATA_OFFSET);  // Free old memory
+#endif
+
 			*s = p_bytes;
 
 			mem = (uint8_t *)realloc(mem, p_bytes + DATA_OFFSET);
@@ -133,13 +144,25 @@ void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
 
 			*s = p_bytes;
 
+#if MODULE_GODOT_TRACY_ENABLED
+			TracyAlloc(mem + DATA_OFFSET, p_bytes);  // Allocate new memory
+#endif
+
 			return mem + DATA_OFFSET;
 		}
 	} else {
+#if MODULE_GODOT_TRACY_ENABLED
+		TracyFree(mem);  // Free old memory
+#endif
+
 		mem = (uint8_t *)realloc(mem, p_bytes);
 
 		ERR_FAIL_COND_V(mem == nullptr && p_bytes > 0, nullptr);
 
+#if MODULE_GODOT_TRACY_ENABLED
+		TracyAlloc(mem, p_bytes);  // Allocate new memory
+#endif
+
 		return mem;
 	}
 }
@@ -165,8 +188,16 @@ void Memory::free_static(void *p_ptr, bool p_pad_align) {
 		mem_usage.sub(*s);
 #endif
 
+#if MODULE_GODOT_TRACY_ENABLED
+		TracyFree(mem);
+#endif
 		free(mem);
 	} else {
+
+#if MODULE_GODOT_TRACY_ENABLED
+		TracyFree(mem);
+#endif
+
 		free(mem);
 	}
 }

core/variant/variant_call.cpp

@@ -39,6 +39,12 @@
 #include "core/templates/local_vector.h"
 #include "core/templates/oa_hash_map.h"
 
+#include "modules/modules_enabled.gen.h"
+
+#ifdef MODULE_GODOT_TRACY_ENABLED
+#include "modules/godot_tracy/profiler.h"
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
 typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
 
@@ -1194,6 +1200,12 @@ static void register_builtin_method(const Vector<String> &p_argnames, const Vect
 }
 
 void Variant::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
+#ifdef MODULE_GODOT_TRACY_ENABLED
+	ZoneScoped;
+	CharString c = Profiler::stringify_method(p_method, p_args, p_argcount);
+	ZoneName(c.ptr(), c.size());
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 	if (type == Variant::OBJECT) {
 		//call object
 		Object *obj = _get_obj().obj;

main/main.cpp

@@ -131,6 +131,14 @@
 #endif // TOOLS_ENABLED && !GDSCRIPT_NO_LSP
 #endif // MODULE_GDSCRIPT_ENABLED
 
+#ifdef MODULE_GODOT_TRACY_ENABLED
+#include "modules/godot_tracy/profiler.h"
+#else
+// Dummy defines to allow compiling without tracy.
+#define ZoneScoped
+#define ZoneScopedN(a)
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 /* Static members */
 
 // Singletons
@@ -3999,6 +4007,7 @@ static uint64_t navigation_process_max = 0;
 // will terminate the program. In case of failure, the OS exit code needs
 // to be set explicitly here (defaults to EXIT_SUCCESS).
 bool Main::iteration() {
+	ZoneScoped;
 	iterating++;
 
 	const uint64_t ticks = OS::get_singleton()->get_ticks_usec();
@@ -4044,6 +4053,8 @@ bool Main::iteration() {
 	NavigationServer2D::get_singleton()->sync();
 	NavigationServer3D::get_singleton()->sync();
 
+	{
+	ZoneScopedN("PHYSICS LOOP");
 	for (int iters = 0; iters < advance.physics_steps; ++iters) {
 		if (Input::get_singleton()->is_agile_input_event_flushing()) {
 			Input::get_singleton()->flush_buffered_events();
@@ -4055,17 +4066,26 @@ bool Main::iteration() {
 		uint64_t physics_begin = OS::get_singleton()->get_ticks_usec();
 
 #ifndef _3D_DISABLED
+		{
+			ZoneScopedN("Godot physics 3D - sync");
 		PhysicsServer3D::get_singleton()->sync();
 		PhysicsServer3D::get_singleton()->flush_queries();
+		}
 #endif // _3D_DISABLED
 
 		// Prepare the fixed timestep interpolated nodes BEFORE they are updated
 		// by the physics server, otherwise the current and previous transforms
 		// may be the same, and no interpolation takes place.
 		OS::get_singleton()->get_main_loop()->iteration_prepare();
 
+		{
+			ZoneScopedN("Godot physics 2D - sync");
 		PhysicsServer2D::get_singleton()->sync();
 		PhysicsServer2D::get_singleton()->flush_queries();
+		}
+
+		{
+			ZoneScopedN("physics_process");
 
 		if (OS::get_singleton()->get_main_loop()->physics_process(physics_step * time_scale)) {
 #ifndef _3D_DISABLED
@@ -4076,23 +4096,33 @@ bool Main::iteration() {
 			exit = true;
 			break;
 		}
+		}
 
 		uint64_t navigation_begin = OS::get_singleton()->get_ticks_usec();
 
+		{
+			ZoneScopedN("Navigation process");
 		NavigationServer3D::get_singleton()->process(physics_step * time_scale);
+		}
 
 		navigation_process_ticks = MAX(navigation_process_ticks, OS::get_singleton()->get_ticks_usec() - navigation_begin); // keep the largest one for reference
 		navigation_process_max = MAX(OS::get_singleton()->get_ticks_usec() - navigation_begin, navigation_process_max);
 
 		message_queue->flush();
 
 #ifndef _3D_DISABLED
+		{
+			ZoneScopedN("Godot physics 3D - step");
 		PhysicsServer3D::get_singleton()->end_sync();
 		PhysicsServer3D::get_singleton()->step(physics_step * time_scale);
+		}
 #endif // _3D_DISABLED
 
+		{
+			ZoneScopedN("Godot physics 2D - step");
 		PhysicsServer2D::get_singleton()->end_sync();
 		PhysicsServer2D::get_singleton()->step(physics_step * time_scale);
+		}
 
 		message_queue->flush();
 
@@ -4101,18 +4131,24 @@ bool Main::iteration() {
 
 		Engine::get_singleton()->_in_physics = false;
 	}
+	}
 
 	if (Input::get_singleton()->is_agile_input_event_flushing()) {
 		Input::get_singleton()->flush_buffered_events();
 	}
 
 	uint64_t process_begin = OS::get_singleton()->get_ticks_usec();
 
+	{
+		ZoneScopedN("Main process");
 	if (OS::get_singleton()->get_main_loop()->process(process_step * time_scale)) {
 		exit = true;
 	}
+	}
 	message_queue->flush();
 
+	{
+		ZoneScopedN("Main::iteration - Draw");
 	RenderingServer::get_singleton()->sync(); //sync if still drawing from previous frames.
 
 	if ((DisplayServer::get_singleton()->can_any_window_draw() || DisplayServer::get_singleton()->has_additional_outputs()) &&
@@ -4128,16 +4164,23 @@ bool Main::iteration() {
 			force_redraw_requested = false;
 		}
 	}
+	}
 
 	process_ticks = OS::get_singleton()->get_ticks_usec() - process_begin;
 	process_max = MAX(process_ticks, process_max);
 	uint64_t frame_time = OS::get_singleton()->get_ticks_usec() - ticks;
 
+	{
+		ZoneScopedN("Languages update");
 	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
 		ScriptServer::get_language(i)->frame();
 	}
+	}
 
+	{
+		ZoneScopedN("Audio update");
 	AudioServer::get_singleton()->update();
+	}
 
 	if (EngineDebugger::is_active()) {
 		EngineDebugger::get_singleton()->iteration(frame_time, process_ticks, physics_process_ticks, physics_step);
@@ -4198,7 +4241,10 @@ bool Main::iteration() {
 		return exit;
 	}
 
+	{
+		ZoneScopedN("Frame delay");
 	OS::get_singleton()->add_frame_delay(DisplayServer::get_singleton()->window_can_draw());
+	}
 
 #ifdef TOOLS_ENABLED
 	if (auto_build_solutions) {

modules/gdscript/gdscript.cpp

@@ -61,6 +61,12 @@
 
 #include <stdint.h>
 
+#include "modules/modules_enabled.gen.h"
+
+#ifdef MODULE_GODOT_TRACY_ENABLED
+#include "modules/godot_tracy/profiler.h"
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 ///////////////////////////
 
 GDScriptNativeClass::GDScriptNativeClass(const StringName &p_name) {
@@ -2020,6 +2026,19 @@ void GDScriptInstance::_call_implicit_ready_recursively(GDScript *p_script) {
 }
 
 Variant GDScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+#ifdef MODULE_GODOT_TRACY_ENABLED
+	ZoneScoped;
+
+	// get the script path.
+	String identifier = script->path;
+	// get the file name.
+//	identifier = identifier.get_file().get_basename();
+	identifier += "::" + p_method;
+
+	CharString c = Profiler::stringify_method(identifier, p_args, p_argcount);
+	ZoneName(c.ptr(), c.size());
+#endif // MODULE_GODOT_TRACY_ENABLED
+
 	GDScript *sptr = script.ptr();
 	if (unlikely(p_method == SceneStringName(_ready))) {
 		// Call implicit ready first, including for the super classes recursively.