noe/tl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

perf: hand a joiner the room instead of asking everyone to answer

Browse source 
A joining peer learnt the roster by announcing itself and having every member
reply with their state. That's one broadcast per member — O(N^2) messages for
a room of N — and the in-memory channel layer caps each connection's queue at
100 and drops the overflow silently. Measured with 100 synthetic peers: every
peer ended up seeing only 58-96 of the other 100, permanently. Not cosmetic —
joinable? and mirrors? both read the roster, so you couldn't join someone you
couldn't see, and a mate whose state was dropped wouldn't move you.

The consumer now keeps the roster it is already relaying and hands a newcomer
a snapshot in one message, so a join costs two broadcasts instead of N. Same
100 peers: roster complete and identical for everyone, 2310 messages sent down
to 349, 72.6k deliveries down to 38.6k, server 30% -> 21% of one core, nav
latency unchanged at ~14ms p50.

This is a cache of relayed gossip, not a source of truth: parties are still
worked out entirely in the browsers, and the server still decides nothing
about them. It is process-local, like the in-memory channel layer it sits
next to — if that ever moves to Redis for multiple workers, this moves too.

Measured ceiling for the pathological case (everyone in ONE party, all
mirroring each other): 100 peers ~14ms p50 at 21% of a core, 150 still ~14ms
at 27%, 250 degrades to ~450ms p50 with the roster incomplete again.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Your Name 2026-09-17 17:01:33 -04:00
parent 1ae4251a34
commit 48e154d53c
4 changed files with 84 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

52
scenes/tests.py
View file

@ -109,31 +109,61 @@ class AccessTests(SceneApiTestCase):
class PresenceRelayTests(TransactionTestCase):
"""The socket hands out connection ids and stamps identity; the party itself
is worked out in the browsers, so there is nothing here to store or trust."""
"""The socket hands out connection ids, stamps identity, and hands a joiner
the room in one message. The party itself is worked out in the browsers, so
there is nothing here to decide or trust."""
def setUp(self):
self.alice = User.objects.create_user("alice", password="pw")
self.project = Project.objects.create(owner=self.alice, name="p")
async def open(self, user=None):
"""Connect and drain the handshake, returning (comm, welcome, roster)."""
comm = WebsocketCommunicator(application, f"/ws/projects/{self.project.pk}/")
comm.scope["user"] = user or AnonymousUser()
connected, _ = await comm.connect()
self.assertTrue(connected)
return comm, await comm.receive_json_from()
welcome = await comm.receive_json_from()
roster = await comm.receive_json_from()
await comm.receive_json_from() # our own join, echoed back
return comm, welcome, roster
async def test_welcome_carries_an_id_and_the_signed_in_name(self):
comm, welcome = await self.open(self.alice)
comm, welcome, _ = await self.open(self.alice)
self.assertEqual(welcome["kind"], "welcome")
self.assertEqual(welcome["user"], "alice")
self.assertTrue(welcome["cid"])
await comm.disconnect()
async def test_a_joiner_is_handed_the_whole_room_in_one_message(self):
# the alternative — everyone answering a join — costs a broadcast per
# member, and a room of a hundred loses most of its roster to it
a, a_hello, a_roster = await self.open(self.alice)
self.assertEqual(a_roster["peers"], []) # first one in
await a.send_json_to({"kind": "state", "party": "P", "joinable": False})
await a.receive_json_from()
b, _, b_roster = await self.open()
self.assertEqual([p["cid"] for p in b_roster["peers"]], [a_hello["cid"]])
seen = b_roster["peers"][0]
self.assertEqual((seen["user"], seen["party"], seen["joinable"]),
("alice", "P", False)) # including what they last said
self.assertTrue(await b.receive_nothing(timeout=0.2)) # and nobody answers
await a.disconnect(); await b.disconnect()
async def test_a_departure_is_forgotten_not_handed_to_the_next_joiner(self):
a, _, _ = await self.open(self.alice)
b, b_hello, _ = await self.open()
await a.receive_json_from() # b's join
await b.disconnect()
await a.receive_json_from() # b's leave
c, _, c_roster = await self.open()
self.assertNotIn(b_hello["cid"], [p["cid"] for p in c_roster["peers"]])
await a.disconnect(); await c.disconnect()
async def test_presence_is_stamped_with_the_server_side_identity(self):
a, a_hello = await self.open(self.alice)
await a.receive_json_from() # our own join, echoed back
b, _ = await self.open()
a, a_hello, _ = await self.open(self.alice)
b, _, _ = await self.open()
self.assertEqual((await a.receive_json_from())["kind"], "join")
await b.send_json_to({"kind": "state", "party": a_hello["cid"],
@ -146,16 +176,14 @@ class PresenceRelayTests(TransactionTestCase):
await a.disconnect(); await b.disconnect()
async def test_scene_edits_are_not_accepted_over_the_socket(self):
a, _ = await self.open(self.alice)
await a.receive_json_from() # join
a, _, _ = await self.open(self.alice)
await a.send_json_to({"kind": "scene", "changed": {"a1": ann("x")}})
self.assertTrue(await a.receive_nothing(timeout=0.2))
await a.disconnect()
async def test_leaving_tells_the_room(self):
a, _ = await self.open(self.alice)
await a.receive_json_from() # join
b, b_hello = await self.open()
a, _, _ = await self.open(self.alice)
b, b_hello, _ = await self.open()
await a.receive_json_from() # b's join
await b.disconnect()
bye = await a.receive_json_from()