Skip to main content

Resource Pool

Initiation​

CLI Command: para init --template resource_pool

Deploy Node: para docker deploy node

Deploy Package: para docker deploy package

Why this project?​

This project demonstrates how an actor-based resource manager can handle dynamic allocation of limited resources to tasks, using a pooling mechanism for efficient delegation. It addresses common scenarios like warehouse operations where runners or robots fetch items for customers, ensuring exclusive assignment and automatic waiting when resources are saturated.

It models key patterns in resource-constrained systems, such as task delegation, pool saturation, and resource lifecycle management — essential for real-world applications like Warehouse Management Systems (WMS) or robotic fleet integrations.

What this kit showcases​

  • Actor-based resource management using a resource pool concept.
  • Dynamic allocation via "checkout" (assign a resource) and "checkin" (return a resource to the pool).
  • Handling of resource saturation: Tasks wait automatically if all resources are busy.
  • A demo actor that simulates a "test_flow" process with three independent jobs requiring robots from a pool of two.
  • Visualization of concurrent task execution: Two jobs start immediately, while the third waits for a resource to become available.
  • Easily extensible to real-world backends, such as physical runners, robots, or distributed systems.

Important takeaways​

  • Actor-based resource pooling provides a resilient and scalable way to manage limited assets in multi-task environments.
  • Automatic handling of saturation ensures tasks are deferred without manual intervention, improving system reliability.
  • The demo illustrates real-time behavior, making it ideal for testing allocation logic in constrained scenarios.
  • This architecture supports patterns for production-ready resource orchestration, like in logistics or automation systems.

Simulation behavior​

  • Resources (e.g., robots) are added to a pool (e.g., "robots" with two members).
  • When a new task arrives:
    • The resource manager "checks out" an available member for exclusive use.
    • If all members are busy, the task waits until a resource is "checked in" (returned after completion).
  • In the demo:
    • Three jobs are created.
    • Two robots are allocated immediately to the first two jobs.
    • The third job is deferred until one of the first jobs finishes, freeing a robot.

Tuning resource allocation​

  • The job duration in the demo is set for observability — long enough to see saturation and waiting.
  • To adjust it:
    • Edit: demo_actor/test_flow.py
    • Modify: Job execution times or pool size.

Shorter durations = quicker demos
Longer durations = better for testing saturation

Observing saturation behavior​

To see resource pooling in action:

  1. Start a "test_flow" with more jobs than available resources (e.g., three jobs with two robots).
  2. You'll observe:
    • Immediate allocation to available resources.
    • Deferred status for excess jobs.
    • Automatic reassignment as resources are checked back in.

Summary​

This project serves as a reference for:

  • Actor-based resource pooling and allocation
  • Handling limited resources with checkout/checkin
  • Deferred task management in saturated pools
  • Demo simulation for testing allocation dynamics