How to measure precise packet times?

xyz Well, there you go again... mystery solved.

ClientNode

# client_node.gd
class_name ClientNode
extends Node

var udp := PacketPeerUDP.new()

var timer = Timer.new()
var client_is_running = false
var thread :Thread
func _ready():
	add_child(timer)
	timer.wait_time=1
	timer.timeout.connect(_on_timeout)
	pass
	
func _process(_delta):
	pass

func _on_timeout():
		#var ut = Time.get_unix_time_from_system()
		var ms = str(Time.get_ticks_msec()) #str(int(ut * 1000))
		
		udp.put_packet(ms.to_utf8_buffer())
		
func start_ping(ip:String, port:int):
	
	var error = udp.connect_to_host(ip,port)

	if error != OK:
		print("ClientNode didnt connect")
	else:
		print("ClientNode connected")
		timer.start()
		print("Timer started!")
		client_is_running = true
		thread = Thread.new()
		thread.start(thread_get_packet, Thread.PRIORITY_HIGH)
	pass
	
func stop_ping():
	
	client_is_running = false
	timer.stop()
	udp.close()
	thread.wait_to_finish()
	print("ClientNode disconnected")
	
	pass

func thread_get_packet():
	
	while(client_is_running):
		if udp.get_available_packet_count() > 0:
			#var ut = Time.get_unix_time_from_system()
			var ms = Time.get_ticks_msec()
			var packet_ms = udp.get_packet().get_string_from_utf8().to_int()
			var latency = ms - packet_ms

			print("latency: %s ms" % latency)

ServerNode

# server_node.gd
class_name ServerNode
extends Node

var server := UDPServer.new()
var peers = []
var server_port = 4242
var server_is_running = false
var thread :Thread
func _ready():
	pass

func _process(_delta):
	pass

func start_server(port):
	var usable_port = server_port
	
	if port:
		usable_port = port
		
	var error = server.listen(usable_port)
	if error != OK:
		print("ServerNode didnt listten")
	else:
		print("ServerNode listenning")
		server_is_running = true
		thread = Thread.new()
		thread.start(thread_poll, Thread.PRIORITY_HIGH)
	pass
	
func stop_server():
	
	
	server_is_running= false
	server.stop()
	thread.wait_to_finish()
	print("ServerNode stopped")	

	pass
	
func thread_poll():
	
	while(server_is_running):
		server.poll() # Important!
		if server.is_connection_available():
			var peer: PacketPeerUDP = server.take_connection()
			var packet = peer.get_packet()

			peer.put_packet(packet)
			peers.append(peer)
			
		for i in range(0, peers.size()):
			if peers[i].get_available_packet_count() > 0:
				var packet = peers[i].get_packet()
				peers[i].put_packet(packet)
			pass # Do something with the connected peers.

MainScene

extends Control
@onready var udp_ping_server: ServerNode = $UdpPingServer
@onready var udp_ping_client: ClientNode = $UdpPingClient

@onready var line_edit_ip: LineEdit = $PanelContainer/MarginContainer/VBoxContainer/MarginContainer/HBoxContainer/LineEditIP
@onready var line_edit_port_client: LineEdit = $PanelContainer/MarginContainer/VBoxContainer/MarginContainer2/HBoxContainer/LineEditPortClient
@onready var button_start_client: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStartClient
@onready var button_stop_client: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStopClient
@onready var line_edit_port_server: LineEdit = $PanelContainer/MarginContainer/VBoxContainer/MarginContainer3/HBoxContainer/LineEditPortServer
@onready var button_start_server: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStartServer
@onready var button_stop_server: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStopServer


# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(_delta: float) -> void:
	pass

func _on_button_start_client_button_down() -> void:
	udp_ping_client.start_ping(line_edit_ip.text,line_edit_port_client.text.to_int())
	pass # Replace with function body.

func _on_button_stop_client_button_down() -> void:
	udp_ping_client.stop_ping()
	pass # Replace with function body.

func _on_button_start_server_button_down() -> void:
	udp_ping_server.start_server(line_edit_port_server.text.to_int())
	pass # Replace with function body.

func _on_button_stop_server_button_down() -> void:
	udp_ping_server.stop_server()
	pass # Replace with function body.

So i merged everything in one app, and with main scene i orchestrate what happens. Manually start/stop client/server.

Distributed this app across few local computers and now im getting better pings.

Did a test with swapped machines, same result, just didnt record the results.

So can we call it - problem solved? not sure how else to debug but to maybe host this over internet and try pinging machine somewhere in the world?

EDIT: Fixed the thread thing, and updated the codes above

xyz

xyz Then just execute ping via OS::execute()

First of all didnt know you could do that. Secondly this would assume that these programs exist on the device, and in real world situations is not reliable. I could pack the libs along with godot but idk.. it could be last resort. Im sure there is a way to do it reliably in godot. I just need to figure it out.

xyz Also note that ping typically uses plain IP protocol which is one layer below UDP socket protocol in the internet protocol suite. So it'll likely be faster. For the actual reference times try pinging with a tool that lets you specify the protocol.

I know, but relatively speaking i would understand that i would get higher times using higher protocols like UDP but here problem is consistency. One device receives faster than the other while doing the same work... if both devices would show the same times, dont matter how high they are, then i could start thinking about other protocols, and in godot i dont thik there is anything lower than TCP or UDP..

xyz Also, you can benchmark time between two consecutive iterations in the polling loop and see if the values corelates with the communication delay.

What am i measuring here? For example now im measuring from put_packet until i get_packet. This is done on the client, server just get_packet and puts_packet back at the client. And this action is triggered by times once every second.

Measuring for fast polling happens?

poll
latency = current_time - last_poll_time?
last_poll_time = current_time

And then read out that latency variable? But the pollin would happen super fast as it runs like 100000/s or something..