October 2006


Options: Use Monospaced Font
Show Text Part by Default
Show All Mail Headers

Message: [<< First] [< Prev] [Next >] [Last >>]
Topic: [<< First] [< Prev] [Next >] [Last >>]
Author: [<< First] [< Prev] [Next >] [Last >>]

Print Reply
Sean Luke <[log in to unmask]>
Reply To:
MASON Multiagent Simulation Toolkit <[log in to unmask]>
Tue, 10 Oct 2006 16:23:36 -0400
text/plain (90 lines)
In response to the questions below.

1. Yes, it's doable -- but you have to lock *somewhere*.  If you  
don't do a global lock with MASON, you're going to have to do some  
fine-grained lock on some subelement of MASON to make certain that  
MASON Steppables aren't scribbling at the same time that the repaint  
method is reading.  Otherwise you're going to have a race condition.

2. It won't violate any MASON design principle.  But there are two  
things to keep in consideration:
	A. You need to gather the repaint thread at some point, when the  
simulation is stopped.  AsynchronousSteppable would do this; else  
you'll need to roll your own approach.
	B. Fine-grained locking means a lot more synchronized{ } calls,  
which can be expensive.  Having a global lock on MASON to paint, then  
to do the model, allows MASON to largely run unsynchronized (except  
for the schedule, sigh).

3. Essentially no modification.  I think the easiest way to do this  
is to copy the network first, and then you don't have to do any  
locking!  You can do the copy in a Steppable stored in the GUIState's  
minischedule, and then fire off something to do drawing on the *copy*  
of the network in the background.  Though you need to check to see  
that your GUI can accept a new copy -- it's done drawing its old copy  
-- before you shove a new one at it!


On Oct 10, 2006, at 12:48 PM, Maciej M. Latek wrote:

> OK, now I see a clouded path to follow: use Asynchronous Steppable  
> just for
> a certain time-consuming display and leave the rest GUI unchanged.
> Maciek
> -----Original Message-----
> From: Maciej M. Latek [mailto:[log in to unmask]]
> Sent: Tuesday, October 10, 2006 12:31 PM
> To: 'MASON Multiagent Simulation Toolkit'
> Subject: Make things more parallel
> Hi all,
> I've got a question concerning parallelization of visualization  
> inspired by
> parallel version of Heatbugs (which works very nicely on a Core Duo  
> by the
> way, one can really see the difference) and Mr. Ong's problem.
> My understanding is that, as the GUI thread repaints displays, the  
> SimState
> thread is put on hold. When we consider really computationally  
> expensive GUI
> tasks as laying out a graphs, this seems to be suboptimal solution.  
> I was
> wondering if it would be possible to put the two thread on separate
> processors, have the GUI thread probe the other one for information  
> and
> afterwards to detach and free the SimState thread to go ahead while  
> GUI is
> doing its job. After GUI is done, the process would repeat.
> I realize that in general I would loose synchronization, but if I'm  
> laying
> something out let's say each 50 time-steps and still have to wait  
> few second
> for the simulation to resume, this path would provide me with much  
> smoother
> and faster performance.
> The questions are:
> 1) Is it doable?
> 2) Would it violate some important MASON design principle?
> 3) How much modification to MASON core would one have to introduce  
> to arrive
> at such a solution?
> Regards
> Maciek Latek