Another interesting issue ....

[Vladimir Jojic]

I would like to suggest another topic for discussion:

Turning Swarm into a Distributed System ...

(paralelizing swarm is to simple to be of any interest :)

I will describe a simple distributed Swarm system, just to start the
discussion about this.

Description:
------------

Let's consider a system of ~1000 autonomous agents. For example. user has
11 PCs on a local net with i586 in each of those PCs (all machines are
equal in the terms of the processing power). 

We could create a system with:
- one coordinator machine (used for storage of the space information, and
message passing)
- ten slave machines, simulating their own portion of the agents (~100)

This could give us (if everything is working perfectly) 10 * performance
of the slowest machine on the net. We could of course, do the
load-balance, and assign each machine as much agents as it can take, and
yet not drastically influencing the performance of the whole system. 


Problems:  
---------

- Objc message passing ... 

I took a look at the objc lib source last night, it seems feasible to
arange message passinge to direct all messages to the coordinator (through
a socket), and the coordinator could then send message to the machine were
the specific agent is running.  (of course, libobjc would have to listen
to a port on every `slave' machine expecting messages)

- your agents could be based on a heavy communication with space and other
agents, and could easily bring down the resources of any net. 

There are couple of solutions to this:

1. Grouping agents (manually, or by intelligent load-balancer) that tend
to communicate between them selves a lot (`friends') on the same machine.
2. Creating a map of agents on the other machines (based on information
from coordinator from previous interation), so that the coordinator would
in time become more-or-less idle.


Conclusion:
-----------

Ideally, distributed Swarm, would be useful for the simulation of the
large number of the complicated agents (for example based on neural nets),
where more resources are spent on the calculating the next move, than
talking to other agents and actually making the move (`thinkers' as
opposed to the `talkers'). 

Questions:
----------

1. Will I really get 10* performance? 

Probably not, 5 times better is more likely (but this is still a lot
better, hey even 2 times is better!). But in some special cases, you might
... 

2. Could this work slower that one machine simulation?

There is a level of saturation, for every system, and it is a question
which concept (single machine vs. distributed system) would suit your
needs better, but ... we could do a simple experiment:

I) Let the swarm do couple of the standard simulations (of all types:
`thinkers' and `talkers'), and run profiler (gprof). 

II) Alter the objc lib to support message passing to other machines on the
local net, and profile that too (this could be tricky, but can be done)
...

III) (beauty part) Create a swarm application, with 3-20 agents (PCs) and
use gathered data to see what happens. (hint 1.: channels of communication
could be represented by delegate object, with the limited data-flow, that 
way simulating local net, with all of its limitations; hint 2.: We
could test our intelligent balance-loader in this system)

This experiment, would give us, a better perspective of what can be done
better in a distributed system, and what on the single machine system.

This is my project (among others) for the summer `97, and all
ideas/suggestions will be gladly accepted ...
 
Send your opinions, please (especially people from swarm team).

Thanks,
Vladimir 

   

                  ==================================
   Swarm-Support is for discussion of the technical details of the day
   to day usage of Swarm.  For list administration needs (esp.
   [un]subscribing), please send a message to <address@hidden>
   with "help" in the body of the message.
                  ==================================