In this strategy, each client uses its servent's manager to send allocation requests. The local manager does not wait for messages from other clients - it acts immediately upon the client's request. The manager attempts to allocate as much network RAM as possible for its client. When the client receives network RAM, it begins execution immediately. It does not wait for the other threads in the parallel job. The local manager does not share memory load information with other servents.
This strategy allows clients to allocate network RAM quickly and eliminates all synchronization overhead. It is scalable, since each client is responsible only for itself. It is also simple to implement, since there is no need for a manager at all.
However, this solution has major drawbacks. First, memory load information is not shared. Each client must discover memory load information for itself and this may lead to a large amount of ineffective network RAM allocation requests.
Second, and more serious, the clients do not coordinate memory allocation with each other. Some clients may receive large amounts of network RAM if they get their messages to the servers first while other clients get very little network RAM. This will not improve the performance of parallel jobs as a whole, since each job will only execute at the speed of its slowest thread.
In fact, this scheme may worsen overall performance, since much of the network RAM allocated is can be wasted. Thus, no benefit is gained from network RAM and higher memory loads on the servers may induce disk paging, the very problem we are trying to avoid!