To stress test network interest management by creating a large busy train station

[fire]

This art for this demo would consist of a large train station model and some models of trains. It would consists on trains coming in and out of the station, and a huge amount (thousands) of agents (AI) entering and leaving trains all the time. This demo would allow to stress the following

Godot existing features:

• 3D Rendering a complex, realistic train station
• Controlling thousands of agents pathfinding and AI
• Testing local obstacle avoidance
• Improving Navigation classes so they support threading
• Rendering several thousand agents
• Animating several thousand agents via compute shader with compressed animations
• Using particle system collisions to deal with smoke inside the train station.

Game features:

• network interest management
• spatially dividing simulation over multiple servers

Fales comments

We can approximate the size of the state based on the size of the variants synchronized, and apply an average compression ratio
the profiler also shows you that bandwidth, but it's not smart, so it does not include things like protocol compression.

If you have a 1000 objects, each represented by 4 bytes ID + payload, you already have a 4K state, at 60Hz that's 240K/s and this is without payload (but also without compression).

ID Software's Quake 3 was 20 hertz tick rate (1998).

As a good actionable, we should test a few popular games bandwidth usage.

Start the client, measure the min/max/avg/deviation bandwidth in a real match scenario.

For example:

• Rocket League?
• COD?
• Battlefield?
• Fortnite?
• Dota 2?

Fire's comments

What's a good estimate on a baseline channel rate on upload and download? 1. of a player 2. of a server

References

• https://booth.pm/en/items/2878564
• Reduz's list of demo proposals on Google Drive

[fire]

Archived and moved to Godot Engine Proposals https://github.com/godotengine/godot-proposals/discussions/4233.

[fire]

let me find the problem statement

here's the design as I think it works

you have a lot of 8_000 player servers all these take is input

you have a lot of a 10_000 player world servers

1 b each player server see all the other players as ghosts and do not interact
2 b each world server needs to iterate through all the other players and calculate state
2 c each world server sends the entire frame to each client as a blob
2 d when it iterates through each state it basically is ticking the frame on a dag. I chose relaying, but you can do a game here. where each frame you write some code to calculate the next state.

max, jamie-pate, Godot Engine — Today at 17:51
so no collision .. that makes it easier ;d

# Copyright (c) 2018-present. This file is part of V-Sekai https://v-sekai.org/.
# K. S. Ernest (Fire) Lee & Contributors
# state_lcrs_tree_converter.exs
# SPDX-License-Identifier: MIT

defmodule StateNode do
  defstruct [:first_child, :next_sibling, :state]
end

defmodule StateLCRSTreeFilter do
  use Membrane.Filter

  alias StateNode

  def handle_init(_opts) do
    {:ok, %{}}
  end

  @impl true
  def handle_demand(:output, size, :buffers, _ctx, state) do
    {{:ok, demand: {:input, size}}, state}
  end

  def handle_process(:input, buffer, _ctx, state) do
    states = buffer.payload
    tree = convert_states_to_tree(states)

    buffer = %{buffer | payload: tree}
    {{:ok, buffer: {:output, buffer}}, state}
  end

  defp convert_states_to_tree([state | _] = states) do
    %StateNode{
      state: elem(state, 0),
      first_child: convert_children(elem(state, 1)),
      next_sibling: convert_siblings(tl(states))
    }
  end

  defp convert_siblings([]), do: nil
  defp convert_siblings([head | tail]) do
    %StateNode{
      state: elem(head, 0),
      first_child: convert_children(elem(head, 1)),
      next_sibling: convert_siblings(tail)
    }
  end

  defp convert_children([]), do: nil
  defp convert_children([head | tail]) do
    %StateNode{
      state: elem(head, 0),
      first_child: convert_children(elem(head, 1)),
      next_sibling: convert_children(tail)
    }
  end
end

convert_states_to_tree is my function do that
benchee says I can call convert_states_to_tree 19k times a second on 10_000 states
in elixir
elixir and erlang is known to be a slow language unless I use nx - gpu

max, jamie-pate, Godot Engine — Today at 17:54
ya
iFire — Today at 17:54
nx has a xla adapter
so I can treat this as a ml problem

max, jamie-pate, Godot Engine — Today at 17:54
hm, running game state on the gpu feels like a win
if nothing is interacting

https://github.com/elixir-nx/nx
so this code is normally used for machine learning think like chatgpt stuff
but it'll work for my problem case too
some old benchmarks from 3 years ago from github

we're 3 ips in pure elixir. We can go to 15_308 gpu xla f32 ips on this chart
even simd 168 ips isn't too shabby compared to 3 ips