Backpressure in ActorPools

[johnpyp]

For single-actors I think the unbounded channels work fine, because implicitly they're sequential, conceptually (of course you can do more complex things).

However for actor pools, I want the ability to fill up all the actors in a given pool, and not keep spamming messages until they're ready to accept some more. I can't use .send().await like I would in a normal actor, because that's effectively just making the pool meaningless. I can't send_async unless it's trivially small data, because it's not going to have any backpressure, and will effectively memory leak.

In this case, I think it's fine to have a model of something like...

pool.send_async()
pool.wait_until_available().await

This does of course have an implicit race condition, which probably doesn't matter for a lot of use cases, but it could be baked into another send method like...

pool.send_when_available().await

For users who want more backpressure than the pool actor count provides, they can easily add a buffered channel on top of this (or another actor itself that buffers).

[johnpyp]

I see there's a similar issue #3, though that seems more generic than just for pools. I'd be ok with either - making it more generic for actors and pools, or being a specific pool implementation detail.

[tqwewe]

Hi @johnpyp

I can't use .send().await like I would in a normal actor, because that's effectively just making the pool meaningless.

Could you clarify this a little? Do you mean calling .send().await on the pool itself? If so that should provide essentially the same as back pressure since the places that send the message would be awaited until its been processed.

Would the pool.send_when_available().await method await the response of the message, or is this more like send_async(), but waiting first until a worker is available?

[johnpyp]

Right, the latter, i.e "send_async_when_available().await"

The first option of just using .send doesn't work because it only fills up a one actor at a time, so I'd have to set up a parallel feeder anyways, kind of defeating the purpose.

[tqwewe]

I see, I think this could be easily achieved using a Semaphore, where permits are sent along with each message, and dropped when the worker handles it. This would provide backpressure and only await if all permits are in use.

I wonder if this should simply be the behaviour of .send_async().await on the pool, or if it should be a separate method.

Though, is this issue specific to the actor pool? Or is this the same thing with regular actors too I wonder.

[tqwewe]

On second thought, I think changing regular actors to use bounded channels would likely be beneficial in that unbounded channels are definitely a potential for a memory leak, and using bounded channels would also close this issue.

[tqwewe]

Closed in #29