mirror of
https://github.com/godotengine/godot
synced 2024-09-05 13:38:29 +00:00
[MP] Initial replication profiler.
Part of the current network profiler stack. Tracks synchronizers, incoming/outgoing state sizes, and their bandwidth usage.
This commit is contained in:
Fabio Alessandrelli
parent
895428c805
commit
f38e116026
|
|
@ -36,13 +36,19 @@
|
|||
|
||||
void EditorNetworkProfiler::_bind_methods() {
|
||||
ADD_SIGNAL(MethodInfo("enable_profiling", PropertyInfo(Variant::BOOL, "enable")));
|
||||
ADD_SIGNAL(MethodInfo("open_request", PropertyInfo(Variant::STRING, "path")));
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::_notification(int p_what) {
|
||||
switch (p_what) {
|
||||
case NOTIFICATION_ENTER_TREE:
|
||||
case NOTIFICATION_THEME_CHANGED: {
|
||||
activate->set_icon(get_theme_icon(SNAME("Play"), SNAME("EditorIcons")));
|
||||
node_icon = get_theme_icon(SNAME("Node"), SNAME("EditorIcons"));
|
||||
if (activate->is_pressed()) {
|
||||
activate->set_icon(get_theme_icon(SNAME("Stop"), SNAME("EditorIcons")));
|
||||
} else {
|
||||
activate->set_icon(get_theme_icon(SNAME("Play"), SNAME("EditorIcons")));
|
||||
}
|
||||
clear_button->set_icon(get_theme_icon(SNAME("Clear"), SNAME("EditorIcons")));
|
||||
incoming_bandwidth_text->set_right_icon(get_theme_icon(SNAME("ArrowDown"), SNAME("EditorIcons")));
|
||||
outgoing_bandwidth_text->set_right_icon(get_theme_icon(SNAME("ArrowUp"), SNAME("EditorIcons")));
|
||||
|
|
@ -54,15 +60,25 @@ void EditorNetworkProfiler::_notification(int p_what) {
|
|||
}
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::_update_frame() {
|
||||
void EditorNetworkProfiler::_refresh() {
|
||||
if (!dirty) {
|
||||
return;
|
||||
}
|
||||
dirty = false;
|
||||
refresh_rpc_data();
|
||||
refresh_replication_data();
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::refresh_rpc_data() {
|
||||
counters_display->clear();
|
||||
|
||||
TreeItem *root = counters_display->create_item();
|
||||
int cols = counters_display->get_columns();
|
||||
|
||||
for (const KeyValue<ObjectID, RPCNodeInfo> &E : nodes_data) {
|
||||
for (const KeyValue<ObjectID, RPCNodeInfo> &E : rpc_data) {
|
||||
TreeItem *node = counters_display->create_item(root);
|
||||
|
||||
for (int j = 0; j < counters_display->get_columns(); ++j) {
|
||||
for (int j = 0; j < cols; ++j) {
|
||||
node->set_text_alignment(j, j > 0 ? HORIZONTAL_ALIGNMENT_RIGHT : HORIZONTAL_ALIGNMENT_LEFT);
|
||||
}
|
||||
|
||||
|
|
@ -72,11 +88,76 @@ void EditorNetworkProfiler::_update_frame() {
|
|||
}
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::refresh_replication_data() {
|
||||
replication_display->clear();
|
||||
|
||||
TreeItem *root = replication_display->create_item();
|
||||
|
||||
for (const KeyValue<ObjectID, SyncInfo> &E : sync_data) {
|
||||
// Ensure the nodes have at least a temporary cache.
|
||||
ObjectID ids[3] = { E.value.synchronizer, E.value.config, E.value.root_node };
|
||||
for (uint32_t i = 0; i < 3; i++) {
|
||||
const ObjectID &id = ids[i];
|
||||
if (!node_data.has(id)) {
|
||||
missing_node_data.insert(id);
|
||||
node_data[id] = NodeInfo(id);
|
||||
}
|
||||
}
|
||||
|
||||
TreeItem *node = replication_display->create_item(root);
|
||||
|
||||
const NodeInfo &root_info = node_data[E.value.root_node];
|
||||
const NodeInfo &sync_info = node_data[E.value.synchronizer];
|
||||
const NodeInfo &cfg_info = node_data[E.value.config];
|
||||
|
||||
node->set_text(0, root_info.path.get_file());
|
||||
node->set_icon(0, has_theme_icon(root_info.type, SNAME("EditorIcons")) ? get_theme_icon(root_info.type, SNAME("EditorIcons")) : node_icon);
|
||||
node->set_tooltip_text(0, root_info.path);
|
||||
|
||||
node->set_text(1, sync_info.path.get_file());
|
||||
node->set_icon(1, get_theme_icon("MultiplayerSynchronizer", SNAME("EditorIcons")));
|
||||
node->set_tooltip_text(1, sync_info.path);
|
||||
|
||||
int cfg_idx = cfg_info.path.find("::");
|
||||
if (cfg_info.path.begins_with("res://") && ResourceLoader::exists(cfg_info.path) && cfg_idx > 0) {
|
||||
String res_idstr = cfg_info.path.substr(cfg_idx + 2).replace("SceneReplicationConfig_", "");
|
||||
String scene_path = cfg_info.path.substr(0, cfg_idx);
|
||||
node->set_text(2, vformat("%s (%s)", res_idstr, scene_path.get_file()));
|
||||
node->add_button(2, get_theme_icon(SNAME("InstanceOptions"), SNAME("EditorIcons")));
|
||||
node->set_tooltip_text(2, cfg_info.path);
|
||||
node->set_metadata(2, scene_path);
|
||||
} else {
|
||||
node->set_text(2, cfg_info.path);
|
||||
node->set_metadata(2, "");
|
||||
}
|
||||
|
||||
node->set_text(3, vformat("%d - %d", E.value.incoming_syncs, E.value.outgoing_syncs));
|
||||
node->set_text(4, vformat("%d - %d", E.value.incoming_size, E.value.outgoing_size));
|
||||
}
|
||||
}
|
||||
|
||||
Array EditorNetworkProfiler::pop_missing_node_data() {
|
||||
Array out;
|
||||
for (const ObjectID &id : missing_node_data) {
|
||||
out.push_back(id);
|
||||
}
|
||||
missing_node_data.clear();
|
||||
return out;
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::add_node_data(const NodeInfo &p_info) {
|
||||
ERR_FAIL_COND(!node_data.has(p_info.id));
|
||||
node_data[p_info.id] = p_info;
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::_activate_pressed() {
|
||||
if (activate->is_pressed()) {
|
||||
refresh_timer->start();
|
||||
activate->set_icon(get_theme_icon(SNAME("Stop"), SNAME("EditorIcons")));
|
||||
activate->set_text(TTR("Stop"));
|
||||
} else {
|
||||
refresh_timer->stop();
|
||||
activate->set_icon(get_theme_icon(SNAME("Play"), SNAME("EditorIcons")));
|
||||
activate->set_text(TTR("Start"));
|
||||
}
|
||||
|
|
@ -84,31 +165,55 @@ void EditorNetworkProfiler::_activate_pressed() {
|
|||
}
|
||||
|
||||
void EditorNetworkProfiler::_clear_pressed() {
|
||||
nodes_data.clear();
|
||||
rpc_data.clear();
|
||||
sync_data.clear();
|
||||
node_data.clear();
|
||||
missing_node_data.clear();
|
||||
set_bandwidth(0, 0);
|
||||
if (frame_delay->is_stopped()) {
|
||||
frame_delay->set_wait_time(0.1);
|
||||
frame_delay->start();
|
||||
refresh_rpc_data();
|
||||
refresh_replication_data();
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::_replication_button_clicked(TreeItem *p_item, int p_column, int p_idx, MouseButton p_button) {
|
||||
if (!p_item) {
|
||||
return;
|
||||
}
|
||||
String meta = p_item->get_metadata(p_column);
|
||||
if (meta.size() && ResourceLoader::exists(meta)) {
|
||||
emit_signal("open_request", meta);
|
||||
}
|
||||
}
|
||||
|
||||
void EditorNetworkProfiler::add_node_frame_data(const RPCNodeInfo p_frame) {
|
||||
if (!nodes_data.has(p_frame.node)) {
|
||||
nodes_data.insert(p_frame.node, p_frame);
|
||||
void EditorNetworkProfiler::add_rpc_frame_data(const RPCNodeInfo &p_frame) {
|
||||
dirty = true;
|
||||
if (!rpc_data.has(p_frame.node)) {
|
||||
rpc_data.insert(p_frame.node, p_frame);
|
||||
} else {
|
||||
nodes_data[p_frame.node].incoming_rpc += p_frame.incoming_rpc;
|
||||
nodes_data[p_frame.node].outgoing_rpc += p_frame.outgoing_rpc;
|
||||
rpc_data[p_frame.node].incoming_rpc += p_frame.incoming_rpc;
|
||||
rpc_data[p_frame.node].outgoing_rpc += p_frame.outgoing_rpc;
|
||||
}
|
||||
if (p_frame.incoming_rpc) {
|
||||
nodes_data[p_frame.node].incoming_size = p_frame.incoming_size / p_frame.incoming_rpc;
|
||||
rpc_data[p_frame.node].incoming_size = p_frame.incoming_size / p_frame.incoming_rpc;
|
||||
}
|
||||
if (p_frame.outgoing_rpc) {
|
||||
nodes_data[p_frame.node].outgoing_size = p_frame.outgoing_size / p_frame.outgoing_rpc;
|
||||
rpc_data[p_frame.node].outgoing_size = p_frame.outgoing_size / p_frame.outgoing_rpc;
|
||||
}
|
||||
}
|
||||
|
||||
if (frame_delay->is_stopped()) {
|
||||
frame_delay->set_wait_time(0.1);
|
||||
frame_delay->start();
|
||||
void EditorNetworkProfiler::add_sync_frame_data(const SyncInfo &p_frame) {
|
||||
dirty = true;
|
||||
if (!sync_data.has(p_frame.synchronizer)) {
|
||||
sync_data[p_frame.synchronizer] = p_frame;
|
||||
} else {
|
||||
sync_data[p_frame.synchronizer].incoming_syncs += p_frame.incoming_syncs;
|
||||
sync_data[p_frame.synchronizer].outgoing_syncs += p_frame.outgoing_syncs;
|
||||
}
|
||||
SyncInfo &info = sync_data[p_frame.synchronizer];
|
||||
if (info.incoming_syncs) {
|
||||
info.incoming_size = p_frame.incoming_size / p_frame.incoming_syncs;
|
||||
}
|
||||
if (info.outgoing_syncs) {
|
||||
info.outgoing_size = p_frame.outgoing_size / p_frame.outgoing_syncs;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -174,9 +279,17 @@ EditorNetworkProfiler::EditorNetworkProfiler() {
|
|||
// Set initial texts in the incoming/outgoing bandwidth labels
|
||||
set_bandwidth(0, 0);
|
||||
|
||||
HSplitContainer *sc = memnew(HSplitContainer);
|
||||
add_child(sc);
|
||||
sc->set_v_size_flags(SIZE_EXPAND_FILL);
|
||||
sc->set_h_size_flags(SIZE_EXPAND_FILL);
|
||||
sc->set_split_offset(100 * EDSCALE);
|
||||
|
||||
// RPC
|
||||
counters_display = memnew(Tree);
|
||||
counters_display->set_custom_minimum_size(Size2(300, 0) * EDSCALE);
|
||||
counters_display->set_custom_minimum_size(Size2(320, 0) * EDSCALE);
|
||||
counters_display->set_v_size_flags(SIZE_EXPAND_FILL);
|
||||
counters_display->set_h_size_flags(SIZE_EXPAND_FILL);
|
||||
counters_display->set_hide_folding(true);
|
||||
counters_display->set_hide_root(true);
|
||||
counters_display->set_columns(3);
|
||||
|
|
@ -193,11 +306,42 @@ EditorNetworkProfiler::EditorNetworkProfiler() {
|
|||
counters_display->set_column_expand(2, false);
|
||||
counters_display->set_column_clip_content(2, true);
|
||||
counters_display->set_column_custom_minimum_width(2, 120 * EDSCALE);
|
||||
add_child(counters_display);
|
||||
sc->add_child(counters_display);
|
||||
|
||||
frame_delay = memnew(Timer);
|
||||
frame_delay->set_wait_time(0.1);
|
||||
frame_delay->set_one_shot(true);
|
||||
add_child(frame_delay);
|
||||
frame_delay->connect("timeout", callable_mp(this, &EditorNetworkProfiler::_update_frame));
|
||||
// Replication
|
||||
replication_display = memnew(Tree);
|
||||
replication_display->set_custom_minimum_size(Size2(320, 0) * EDSCALE);
|
||||
replication_display->set_v_size_flags(SIZE_EXPAND_FILL);
|
||||
replication_display->set_h_size_flags(SIZE_EXPAND_FILL);
|
||||
replication_display->set_hide_folding(true);
|
||||
replication_display->set_hide_root(true);
|
||||
replication_display->set_columns(5);
|
||||
replication_display->set_column_titles_visible(true);
|
||||
replication_display->set_column_title(0, TTR("Root"));
|
||||
replication_display->set_column_expand(0, true);
|
||||
replication_display->set_column_clip_content(0, true);
|
||||
replication_display->set_column_custom_minimum_width(0, 80 * EDSCALE);
|
||||
replication_display->set_column_title(1, TTR("Synchronizer"));
|
||||
replication_display->set_column_expand(1, true);
|
||||
replication_display->set_column_clip_content(1, true);
|
||||
replication_display->set_column_custom_minimum_width(1, 80 * EDSCALE);
|
||||
replication_display->set_column_title(2, TTR("Config"));
|
||||
replication_display->set_column_expand(2, true);
|
||||
replication_display->set_column_clip_content(2, true);
|
||||
replication_display->set_column_custom_minimum_width(2, 80 * EDSCALE);
|
||||
replication_display->set_column_title(3, TTR("Count"));
|
||||
replication_display->set_column_expand(3, false);
|
||||
replication_display->set_column_clip_content(3, true);
|
||||
replication_display->set_column_custom_minimum_width(3, 80 * EDSCALE);
|
||||
replication_display->set_column_title(4, TTR("Size"));
|
||||
replication_display->set_column_expand(4, false);
|
||||
replication_display->set_column_clip_content(4, true);
|
||||
replication_display->set_column_custom_minimum_width(4, 80 * EDSCALE);
|
||||
replication_display->connect("button_clicked", callable_mp(this, &EditorNetworkProfiler::_replication_button_clicked));
|
||||
sc->add_child(replication_display);
|
||||
|
||||
refresh_timer = memnew(Timer);
|
||||
refresh_timer->set_wait_time(0.5);
|
||||
refresh_timer->connect("timeout", callable_mp(this, &EditorNetworkProfiler::_refresh));
|
||||
add_child(refresh_timer);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,30 +43,55 @@
|
|||
class EditorNetworkProfiler : public VBoxContainer {
|
||||
GDCLASS(EditorNetworkProfiler, VBoxContainer)
|
||||
|
||||
public:
|
||||
struct NodeInfo {
|
||||
ObjectID id;
|
||||
String type;
|
||||
String path;
|
||||
|
||||
NodeInfo() {}
|
||||
NodeInfo(const ObjectID &p_id) {
|
||||
id = p_id;
|
||||
path = String::num_int64(p_id);
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
using RPCNodeInfo = MultiplayerDebugger::RPCNodeInfo;
|
||||
using SyncInfo = MultiplayerDebugger::SyncInfo;
|
||||
|
||||
bool dirty = false;
|
||||
Timer *refresh_timer = nullptr;
|
||||
Button *activate = nullptr;
|
||||
Button *clear_button = nullptr;
|
||||
Tree *counters_display = nullptr;
|
||||
LineEdit *incoming_bandwidth_text = nullptr;
|
||||
LineEdit *outgoing_bandwidth_text = nullptr;
|
||||
Tree *replication_display = nullptr;
|
||||
|
||||
Timer *frame_delay = nullptr;
|
||||
|
||||
HashMap<ObjectID, RPCNodeInfo> nodes_data;
|
||||
|
||||
void _update_frame();
|
||||
HashMap<ObjectID, RPCNodeInfo> rpc_data;
|
||||
HashMap<ObjectID, SyncInfo> sync_data;
|
||||
HashMap<ObjectID, NodeInfo> node_data;
|
||||
HashSet<ObjectID> missing_node_data;
|
||||
Ref<Texture2D> node_icon;
|
||||
|
||||
void _activate_pressed();
|
||||
void _clear_pressed();
|
||||
void _refresh();
|
||||
void _replication_button_clicked(TreeItem *p_item, int p_column, int p_idx, MouseButton p_button);
|
||||
|
||||
protected:
|
||||
void _notification(int p_what);
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void add_node_frame_data(RPCNodeInfo p_frame);
|
||||
void refresh_rpc_data();
|
||||
void refresh_replication_data();
|
||||
|
||||
Array pop_missing_node_data();
|
||||
void add_node_data(const NodeInfo &p_info);
|
||||
void add_rpc_frame_data(const RPCNodeInfo &p_frame);
|
||||
void add_sync_frame_data(const SyncInfo &p_frame);
|
||||
void set_bandwidth(int p_incoming, int p_outgoing);
|
||||
bool is_profiling();
|
||||
|
||||
|
|
|
|||
|
|
@ -36,10 +36,18 @@
|
|||
|
||||
#include "editor/editor_node.h"
|
||||
|
||||
void MultiplayerEditorDebugger::_bind_methods() {
|
||||
ADD_SIGNAL(MethodInfo("open_request", PropertyInfo(Variant::STRING, "path")));
|
||||
}
|
||||
|
||||
bool MultiplayerEditorDebugger::has_capture(const String &p_capture) const {
|
||||
return p_capture == "multiplayer";
|
||||
}
|
||||
|
||||
void MultiplayerEditorDebugger::_open_request(const String &p_path) {
|
||||
emit_signal("open_request", p_path);
|
||||
}
|
||||
|
||||
bool MultiplayerEditorDebugger::capture(const String &p_message, const Array &p_data, int p_session) {
|
||||
ERR_FAIL_COND_V(!profilers.has(p_session), false);
|
||||
EditorNetworkProfiler *profiler = profilers[p_session];
|
||||
|
|
@ -47,10 +55,31 @@ bool MultiplayerEditorDebugger::capture(const String &p_message, const Array &p_
|
|||
MultiplayerDebugger::RPCFrame frame;
|
||||
frame.deserialize(p_data);
|
||||
for (int i = 0; i < frame.infos.size(); i++) {
|
||||
profiler->add_node_frame_data(frame.infos[i]);
|
||||
profiler->add_rpc_frame_data(frame.infos[i]);
|
||||
}
|
||||
return true;
|
||||
} else if (p_message == "multiplayer:syncs") {
|
||||
MultiplayerDebugger::ReplicationFrame frame;
|
||||
frame.deserialize(p_data);
|
||||
for (const KeyValue<ObjectID, MultiplayerDebugger::SyncInfo> &E : frame.infos) {
|
||||
profiler->add_sync_frame_data(E.value);
|
||||
}
|
||||
Array missing = profiler->pop_missing_node_data();
|
||||
if (missing.size()) {
|
||||
// Asks for the object information.
|
||||
get_session(p_session)->send_message("multiplayer:cache", missing);
|
||||
}
|
||||
return true;
|
||||
} else if (p_message == "multiplayer:cache") {
|
||||
ERR_FAIL_COND_V(p_data.size() % 3, false);
|
||||
for (int i = 0; i < p_data.size(); i += 3) {
|
||||
EditorNetworkProfiler::NodeInfo info;
|
||||
info.id = p_data[i].operator ObjectID();
|
||||
info.type = p_data[i + 1].operator String();
|
||||
info.path = p_data[i + 2].operator String();
|
||||
profiler->add_node_data(info);
|
||||
}
|
||||
return true;
|
||||
|
||||
} else if (p_message == "multiplayer:bandwidth") {
|
||||
ERR_FAIL_COND_V(p_data.size() < 2, false);
|
||||
profiler->set_bandwidth(p_data[0], p_data[1]);
|
||||
|
|
@ -62,8 +91,9 @@ bool MultiplayerEditorDebugger::capture(const String &p_message, const Array &p_
|
|||
void MultiplayerEditorDebugger::_profiler_activate(bool p_enable, int p_session_id) {
|
||||
Ref<EditorDebuggerSession> session = get_session(p_session_id);
|
||||
ERR_FAIL_COND(session.is_null());
|
||||
session->toggle_profiler("multiplayer", p_enable);
|
||||
session->toggle_profiler("rpc", p_enable);
|
||||
session->toggle_profiler("multiplayer:bandwidth", p_enable);
|
||||
session->toggle_profiler("multiplayer:rpc", p_enable);
|
||||
session->toggle_profiler("multiplayer:replication", p_enable);
|
||||
}
|
||||
|
||||
void MultiplayerEditorDebugger::setup_session(int p_session_id) {
|
||||
|
|
@ -71,20 +101,25 @@ void MultiplayerEditorDebugger::setup_session(int p_session_id) {
|
|||
ERR_FAIL_COND(session.is_null());
|
||||
EditorNetworkProfiler *profiler = memnew(EditorNetworkProfiler);
|
||||
profiler->connect("enable_profiling", callable_mp(this, &MultiplayerEditorDebugger::_profiler_activate).bind(p_session_id));
|
||||
profiler->connect("open_request", callable_mp(this, &MultiplayerEditorDebugger::_open_request));
|
||||
profiler->set_name(TTR("Network Profiler"));
|
||||
session->add_session_tab(profiler);
|
||||
profilers[p_session_id] = profiler;
|
||||
}
|
||||
|
||||
/// MultiplayerEditorPlugin
|
||||
|
||||
MultiplayerEditorPlugin::MultiplayerEditorPlugin() {
|
||||
repl_editor = memnew(ReplicationEditor);
|
||||
button = EditorNode::get_singleton()->add_bottom_panel_item(TTR("Replication"), repl_editor);
|
||||
button->hide();
|
||||
repl_editor->get_pin()->connect("pressed", callable_mp(this, &MultiplayerEditorPlugin::_pinned));
|
||||
debugger.instantiate();
|
||||
debugger->connect("open_request", callable_mp(this, &MultiplayerEditorPlugin::_open_request));
|
||||
}
|
||||
|
||||
MultiplayerEditorPlugin::~MultiplayerEditorPlugin() {
|
||||
void MultiplayerEditorPlugin::_open_request(const String &p_path) {
|
||||
get_editor_interface()->open_scene_from_path(p_path);
|
||||
}
|
||||
|
||||
void MultiplayerEditorPlugin::_notification(int p_what) {
|
||||
|
|
|
|||
|
|
@ -42,8 +42,12 @@ class MultiplayerEditorDebugger : public EditorDebuggerPlugin {
|
|||
private:
|
||||
HashMap<int, EditorNetworkProfiler *> profilers;
|
||||
|
||||
void _open_request(const String &p_path);
|
||||
void _profiler_activate(bool p_enable, int p_session_id);
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
virtual bool has_capture(const String &p_capture) const override;
|
||||
virtual bool capture(const String &p_message, const Array &p_data, int p_index) override;
|
||||
|
|
@ -62,6 +66,7 @@ private:
|
|||
ReplicationEditor *repl_editor = nullptr;
|
||||
Ref<MultiplayerEditorDebugger> debugger;
|
||||
|
||||
void _open_request(const String &p_path);
|
||||
void _node_removed(Node *p_node);
|
||||
|
||||
void _pinned();
|
||||
|
|
@ -75,7 +80,6 @@ public:
|
|||
virtual void make_visible(bool p_visible) override;
|
||||
|
||||
MultiplayerEditorPlugin();
|
||||
~MultiplayerEditorPlugin();
|
||||
};
|
||||
|
||||
#endif // MULTIPLAYER_EDITOR_PLUGIN_H
|
||||
|
|
|
|||
|
|
@ -30,6 +30,9 @@
|
|||
|
||||
#include "multiplayer_debugger.h"
|
||||
|
||||
#include "multiplayer_synchronizer.h"
|
||||
#include "scene_replication_config.h"
|
||||
|
||||
#include "core/debugger/engine_debugger.h"
|
||||
#include "scene/main/node.h"
|
||||
|
||||
|
|
@ -38,19 +41,51 @@ List<Ref<EngineProfiler>> multiplayer_profilers;
|
|||
void MultiplayerDebugger::initialize() {
|
||||
Ref<BandwidthProfiler> bandwidth;
|
||||
bandwidth.instantiate();
|
||||
bandwidth->bind("multiplayer");
|
||||
bandwidth->bind("multiplayer:bandwidth");
|
||||
multiplayer_profilers.push_back(bandwidth);
|
||||
|
||||
Ref<RPCProfiler> rpc_profiler;
|
||||
rpc_profiler.instantiate();
|
||||
rpc_profiler->bind("rpc");
|
||||
rpc_profiler->bind("multiplayer:rpc");
|
||||
multiplayer_profilers.push_back(rpc_profiler);
|
||||
|
||||
Ref<ReplicationProfiler> replication_profiler;
|
||||
replication_profiler.instantiate();
|
||||
replication_profiler->bind("multiplayer:replication");
|
||||
multiplayer_profilers.push_back(replication_profiler);
|
||||
|
||||
EngineDebugger::register_message_capture("multiplayer", EngineDebugger::Capture(nullptr, &_capture));
|
||||
}
|
||||
|
||||
void MultiplayerDebugger::deinitialize() {
|
||||
multiplayer_profilers.clear();
|
||||
}
|
||||
|
||||
Error MultiplayerDebugger::_capture(void *p_user, const String &p_msg, const Array &p_args, bool &r_captured) {
|
||||
if (p_msg == "cache") {
|
||||
Array out;
|
||||
for (int i = 0; i < p_args.size(); i++) {
|
||||
ObjectID id = p_args[i].operator ObjectID();
|
||||
Object *obj = ObjectDB::get_instance(id);
|
||||
ERR_CONTINUE(!obj);
|
||||
if (Object::cast_to<SceneReplicationConfig>(obj)) {
|
||||
out.push_back(id);
|
||||
out.push_back(obj->get_class());
|
||||
out.push_back(((SceneReplicationConfig *)obj)->get_path());
|
||||
} else if (Object::cast_to<Node>(obj)) {
|
||||
out.push_back(id);
|
||||
out.push_back(obj->get_class());
|
||||
out.push_back(String(((Node *)obj)->get_path()));
|
||||
} else {
|
||||
ERR_FAIL_V(FAILED);
|
||||
}
|
||||
}
|
||||
EngineDebugger::get_singleton()->send_message("multiplayer:cache", out);
|
||||
return OK;
|
||||
}
|
||||
ERR_FAIL_V(FAILED);
|
||||
}
|
||||
|
||||
// BandwidthProfiler
|
||||
|
||||
int MultiplayerDebugger::BandwidthProfiler::bandwidth_usage(const Vector<BandwidthFrame> &p_buffer, int p_pointer) {
|
||||
|
|
@ -198,3 +233,101 @@ void MultiplayerDebugger::RPCProfiler::tick(double p_frame_time, double p_proces
|
|||
EngineDebugger::get_singleton()->send_message("multiplayer:rpc", frame.serialize());
|
||||
}
|
||||
}
|
||||
|
||||
// ReplicationProfiler
|
||||
|
||||
MultiplayerDebugger::SyncInfo::SyncInfo(MultiplayerSynchronizer *p_sync) {
|
||||
ERR_FAIL_COND(!p_sync);
|
||||
synchronizer = p_sync->get_instance_id();
|
||||
if (p_sync->get_replication_config().is_valid()) {
|
||||
config = p_sync->get_replication_config()->get_instance_id();
|
||||
}
|
||||
if (p_sync->get_root_node()) {
|
||||
root_node = p_sync->get_root_node()->get_instance_id();
|
||||
}
|
||||
}
|
||||
|
||||
void MultiplayerDebugger::SyncInfo::write_to_array(Array &r_arr) const {
|
||||
r_arr.push_back(synchronizer);
|
||||
r_arr.push_back(config);
|
||||
r_arr.push_back(root_node);
|
||||
r_arr.push_back(incoming_syncs);
|
||||
r_arr.push_back(incoming_size);
|
||||
r_arr.push_back(outgoing_syncs);
|
||||
r_arr.push_back(outgoing_size);
|
||||
}
|
||||
|
||||
bool MultiplayerDebugger::SyncInfo::read_from_array(const Array &p_arr, int p_offset) {
|
||||
ERR_FAIL_COND_V(p_arr.size() - p_offset < 7, false);
|
||||
synchronizer = int64_t(p_arr[p_offset]);
|
||||
config = int64_t(p_arr[p_offset + 1]);
|
||||
root_node = int64_t(p_arr[p_offset + 2]);
|
||||
incoming_syncs = p_arr[p_offset + 3];
|
||||
incoming_size = p_arr[p_offset + 4];
|
||||
outgoing_syncs = p_arr[p_offset + 5];
|
||||
outgoing_size = p_arr[p_offset + 6];
|
||||
return true;
|
||||
}
|
||||
|
||||
Array MultiplayerDebugger::ReplicationFrame::serialize() {
|
||||
Array arr;
|
||||
arr.push_back(infos.size() * 7);
|
||||
for (const KeyValue<ObjectID, SyncInfo> &E : infos) {
|
||||
E.value.write_to_array(arr);
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
bool MultiplayerDebugger::ReplicationFrame::deserialize(const Array &p_arr) {
|
||||
ERR_FAIL_COND_V(p_arr.size() < 1, false);
|
||||
uint32_t size = p_arr[0];
|
||||
ERR_FAIL_COND_V(size % 7, false);
|
||||
ERR_FAIL_COND_V((uint32_t)p_arr.size() != size + 1, false);
|
||||
int idx = 1;
|
||||
for (uint32_t i = 0; i < size / 7; i++) {
|
||||
SyncInfo info;
|
||||
if (!info.read_from_array(p_arr, idx)) {
|
||||
return false;
|
||||
}
|
||||
infos[info.synchronizer] = info;
|
||||
idx += 7;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void MultiplayerDebugger::ReplicationProfiler::toggle(bool p_enable, const Array &p_opts) {
|
||||
sync_data.clear();
|
||||
}
|
||||
|
||||
void MultiplayerDebugger::ReplicationProfiler::add(const Array &p_data) {
|
||||
ERR_FAIL_COND(p_data.size() != 3);
|
||||
const String what = p_data[0];
|
||||
const ObjectID id = p_data[1];
|
||||
const uint64_t size = p_data[2];
|
||||
MultiplayerSynchronizer *sync = Object::cast_to<MultiplayerSynchronizer>(ObjectDB::get_instance(id));
|
||||
ERR_FAIL_COND(!sync);
|
||||
if (!sync_data.has(id)) {
|
||||
sync_data[id] = SyncInfo(sync);
|
||||
}
|
||||
SyncInfo &info = sync_data[id];
|
||||
if (what == "sync_in") {
|
||||
info.incoming_syncs++;
|
||||
info.incoming_size += size;
|
||||
} else if (what == "sync_out") {
|
||||
info.outgoing_syncs++;
|
||||
info.outgoing_size += size;
|
||||
}
|
||||
}
|
||||
|
||||
void MultiplayerDebugger::ReplicationProfiler::tick(double p_frame_time, double p_process_time, double p_physics_time, double p_physics_frame_time) {
|
||||
uint64_t pt = OS::get_singleton()->get_ticks_msec();
|
||||
if (pt - last_profile_time > 100) {
|
||||
last_profile_time = pt;
|
||||
ReplicationFrame frame;
|
||||
for (const KeyValue<ObjectID, SyncInfo> &E : sync_data) {
|
||||
frame.infos[E.key] = E.value;
|
||||
}
|
||||
sync_data.clear();
|
||||
EngineDebugger::get_singleton()->send_message("multiplayer:syncs", frame.serialize());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,8 @@
|
|||
|
||||
#include "core/os/os.h"
|
||||
|
||||
class MultiplayerSynchronizer;
|
||||
|
||||
class MultiplayerDebugger {
|
||||
public:
|
||||
struct RPCNodeInfo {
|
||||
|
|
@ -53,6 +55,29 @@ public:
|
|||
bool deserialize(const Array &p_arr);
|
||||
};
|
||||
|
||||
struct SyncInfo {
|
||||
ObjectID synchronizer;
|
||||
ObjectID config;
|
||||
ObjectID root_node;
|
||||
int incoming_syncs = 0;
|
||||
int incoming_size = 0;
|
||||
int outgoing_syncs = 0;
|
||||
int outgoing_size = 0;
|
||||
|
||||
void write_to_array(Array &r_arr) const;
|
||||
bool read_from_array(const Array &p_arr, int p_offset);
|
||||
|
||||
SyncInfo() {}
|
||||
SyncInfo(MultiplayerSynchronizer *p_sync);
|
||||
};
|
||||
|
||||
struct ReplicationFrame {
|
||||
HashMap<ObjectID, SyncInfo> infos;
|
||||
|
||||
Array serialize();
|
||||
bool deserialize(const Array &p_arr);
|
||||
};
|
||||
|
||||
private:
|
||||
class BandwidthProfiler : public EngineProfiler {
|
||||
protected:
|
||||
|
|
@ -76,7 +101,6 @@ private:
|
|||
};
|
||||
|
||||
class RPCProfiler : public EngineProfiler {
|
||||
public:
|
||||
private:
|
||||
HashMap<ObjectID, RPCNodeInfo> rpc_node_data;
|
||||
uint64_t last_profile_time = 0;
|
||||
|
|
@ -89,6 +113,19 @@ private:
|
|||
void tick(double p_frame_time, double p_process_time, double p_physics_time, double p_physics_frame_time);
|
||||
};
|
||||
|
||||
class ReplicationProfiler : public EngineProfiler {
|
||||
private:
|
||||
HashMap<ObjectID, SyncInfo> sync_data;
|
||||
uint64_t last_profile_time = 0;
|
||||
|
||||
public:
|
||||
void toggle(bool p_enable, const Array &p_opts);
|
||||
void add(const Array &p_data);
|
||||
void tick(double p_frame_time, double p_process_time, double p_physics_time, double p_physics_frame_time);
|
||||
};
|
||||
|
||||
static Error _capture(void *p_user, const String &p_msg, const Array &p_args, bool &r_captured);
|
||||
|
||||
public:
|
||||
static void initialize();
|
||||
static void deinitialize();
|
||||
|
|
|
|||
|
|
@ -41,12 +41,12 @@
|
|||
|
||||
#ifdef DEBUG_ENABLED
|
||||
_FORCE_INLINE_ void SceneMultiplayer::_profile_bandwidth(const String &p_what, int p_value) {
|
||||
if (EngineDebugger::is_profiling("multiplayer")) {
|
||||
if (EngineDebugger::is_profiling("multiplayer:bandwidth")) {
|
||||
Array values;
|
||||
values.push_back(p_what);
|
||||
values.push_back(OS::get_singleton()->get_ticks_msec());
|
||||
values.push_back(p_value);
|
||||
EngineDebugger::profiler_add_frame_data("multiplayer", values);
|
||||
EngineDebugger::profiler_add_frame_data("multiplayer:bandwidth", values);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
|
||||
#include "scene_multiplayer.h"
|
||||
|
||||
#include "core/debugger/engine_debugger.h"
|
||||
#include "core/io/marshalls.h"
|
||||
#include "scene/main/node.h"
|
||||
#include "scene/scene_string_names.h"
|
||||
|
|
@ -40,6 +41,18 @@
|
|||
if (packet_cache.size() < m_amount) \
|
||||
packet_cache.resize(m_amount);
|
||||
|
||||
#ifdef DEBUG_ENABLED
|
||||
_FORCE_INLINE_ void SceneReplicationInterface::_profile_node_data(const String &p_what, ObjectID p_id, int p_size) {
|
||||
if (EngineDebugger::is_profiling("multiplayer:replication")) {
|
||||
Array values;
|
||||
values.push_back(p_what);
|
||||
values.push_back(p_id);
|
||||
values.push_back(p_size);
|
||||
EngineDebugger::profiler_add_frame_data("multiplayer:replication", values);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
SceneReplicationInterface::TrackedNode &SceneReplicationInterface::_track(const ObjectID &p_id) {
|
||||
if (!tracked_nodes.has(p_id)) {
|
||||
tracked_nodes[p_id] = TrackedNode(p_id);
|
||||
|
|
@ -635,6 +648,9 @@ void SceneReplicationInterface::_send_sync(int p_peer, const HashSet<ObjectID> p
|
|||
MultiplayerAPI::encode_and_compress_variants(varp.ptrw(), varp.size(), &ptr[ofs], size);
|
||||
ofs += size;
|
||||
}
|
||||
#ifdef DEBUG_ENABLED
|
||||
_profile_node_data("sync_out", oid, size);
|
||||
#endif
|
||||
}
|
||||
if (ofs > 3) {
|
||||
// Got some left over to send.
|
||||
|
|
@ -682,6 +698,9 @@ Error SceneReplicationInterface::on_sync_receive(int p_from, const uint8_t *p_bu
|
|||
err = MultiplayerSynchronizer::set_state(props, node, vars);
|
||||
ERR_FAIL_COND_V(err, err);
|
||||
ofs += size;
|
||||
#ifdef DEBUG_ENABLED
|
||||
_profile_node_data("sync_in", sync->get_instance_id(), size);
|
||||
#endif
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -105,6 +105,10 @@ private:
|
|||
return p_id.is_valid() ? Object::cast_to<T>(ObjectDB::get_instance(p_id)) : nullptr;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_ENABLED
|
||||
_FORCE_INLINE_ void _profile_node_data(const String &p_what, ObjectID p_id, int p_size);
|
||||
#endif
|
||||
|
||||
public:
|
||||
static void make_default();
|
||||
|
||||
|
|
|
|||
|
|
@ -53,12 +53,12 @@
|
|||
|
||||
#ifdef DEBUG_ENABLED
|
||||
_FORCE_INLINE_ void SceneRPCInterface::_profile_node_data(const String &p_what, ObjectID p_id, int p_size) {
|
||||
if (EngineDebugger::is_profiling("rpc")) {
|
||||
if (EngineDebugger::is_profiling("multiplayer:rpc")) {
|
||||
Array values;
|
||||
values.push_back(p_what);
|
||||
values.push_back(p_id);
|
||||
values.push_back(p_size);
|
||||
EngineDebugger::profiler_add_frame_data("rpc", values);
|
||||
EngineDebugger::profiler_add_frame_data("multiplayer:rpc", values);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Reference in a new issue