Re: Synchronous scheduling

[Marcus G. Daniels]

>>>>> "HJY" == Ho Jung Yoo <address@hidden> writes:

HJY> Yes, the model will eventually have stage structure and spatial
HJY> structure, such that individuals advance through 3 stages with
HJY> one dispersal event in the interim, before reproducing and dying
HJY> (if they live that long).  So, ultimately, I will probably need
HJY> to keep track of individuals as agents. 

MGD> I would suggest you have a `nextGenerationMothList' list that you
MGD> build, and assign to the `mothList' variable when it is time for
MGD> the next generation to start.

HJY> Can you give an example of how to tell mothList when the next
HJY> generation should start? 

I was thinking of something like this... 

#import <simtools.h>
#import <objectbase/SwarmObject.h>
#import <objectbase/Swarm.h>
#import <collections.h>

id <RandomBitDist> randomBitDist;

#define COUNT 20

@interface Bug: SwarmObject
{
  unsigned sn;
}
+ create: aZone setSn: (unsigned)sn;
@end

@implementation Bug
+ create: aZone setSn: (unsigned)theSn
{
  Bug *obj = [self create: aZone];

  obj->sn = theSn;
  return obj;
}

- (void)live: (id <List>)nextGenerationList
{
  if ([randomBitDist getCoinToss])
    {
      printf (" %02u", sn); fflush (stdout);
      [nextGenerationList addLast: self];
    }
}

@end

@interface ModelSwarm: Swarm
{
  id <List> populationList;
  id <List> nextGenerationList;

  id <Schedule> reproduceSchedule;
  id <Schedule> generationSchedule;

}
- buildObjects;
- buildActions;
- (void)reproduce;
- (void)nextGeneration;
@end

@implementation ModelSwarm
- buildObjects
{
  [super buildObjects];

  populationList = [List create: self];

  {
    unsigned i;

    for (i = 0; i < COUNT; i++)
      [populationList addLast: [Bug create: self setSn: i]];
  }

  nextGenerationList = [List create: self];

  return self;
}

- (void)reproduce
{
  id <Index> index = [populationList beginPermuted: scratchZone];
  id bug;

  printf ("Survivors: ");

  for (bug = [index next]; [index getLoc] == Member; bug = [index next])
    [bug live: nextGenerationList];
    
  [index drop];
  printf ("\n");
}

- (void)nextGeneration
{
  id <List> temp;
  unsigned count = [nextGenerationList getCount];

  printf ("Swapping nextGenerationList and populationList, count: %u\n",
          count);
  [populationList removeAll];
  temp = nextGenerationList;
  nextGenerationList = populationList;
  populationList = temp;

  if (count == 0)
    [getCurrentSwarmActivity () terminate];
}

- buildActions
{
  [super buildActions];

  reproduceSchedule = [Schedule create: self setRepeatInterval: 1];
  generationSchedule = [Schedule create: self setRepeatInterval: 1];

  [reproduceSchedule at: 0
                     createActionTo: self
                     message: M(reproduce)];

  [generationSchedule at: 0
                      createActionTo: self
                      message: M(nextGeneration)];

  return self;
}

- (id <Activity>)activateIn: (id <Swarm>)swarm
{
  [super activateIn: swarm];
  
  [reproduceSchedule activateIn: self];
  [generationSchedule activateIn: self];

  return [self getActivity];
}

@end

int
main (int argc, const char **argv)
{
  initSwarmBatch (argc, argv);

  randomBitDist = [RandomBitDist create: globalZone
                                 setGenerator: randomGenerator];
  {
    id <Swarm> modelSwarm = [ModelSwarm create: globalZone];

    [modelSwarm buildObjects];
    [modelSwarm buildActions];
    
    [[modelSwarm activateIn: nil] run];
  }

  return 0;
}

/*
Local Variables:
compile-command: "$SWARMHOME/bin/libtool-swarm --mode=link gcc -D_GNU_SOURCE -o 
GenerationSwap -O2 -g -Wno-import -I$SWARMHOME/include/swarm 
-L$SWARMHOME/lib/swarm GenerationSwap.m -lswarm -lobjc -ldl -lc"
End:
*/

                  ==================================
   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.