Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

PsnMultiThreadedBenchmarkingScheduler Class Reference

class PsnMultiThreadedScheduler : uses threads to schedule the different simulation objects, and bench the simulation times More...

#include <PsnMultiThreadedBenchmarkingScheduler.h>

Inheritance diagram for PsnMultiThreadedBenchmarkingScheduler:

Inheritance graph
[legend]
Collaboration diagram for PsnMultiThreadedBenchmarkingScheduler:

Collaboration graph
[legend]
List of all members.

Public Methods

 PsnMultiThreadedBenchmarkingScheduler (unsigned int numberOfSteps, unsigned int numberOfThreads, bool createThreadAndLocalSchedulers, const int &indiceEchantillon, unsigned int _numberOfSamples, ostream &outputFile)
 constructor

virtual ~PsnMultiThreadedBenchmarkingScheduler ()
 destructor

virtual void addToScheduable (PsnReferenceObjectHandle *ref, unsigned int when)
 redefine so that simulated objects are assigned to threads in a cyclic manner

virtual void addToScheduable (PsnReferenceObjectHandle *ref, unsigned int when, unsigned int whichThread)
 add a simulated object to a specific thread

virtual void removeFromScheduable (PsnReferenceObjectHandle *ref)
 redefine to remove the simulated object from schedulers local to a thread

virtual void schedule (PsnReferenceObjectHandle *ref)
 mark a scheduable object as active

virtual void unschedule (PsnReferenceObjectHandle *ref)
 mark a scheduable object as inactive

virtual void runStep (unsigned int which)
 run a simulation step

virtual void run (unsigned int whichFrameScheduler)
 run one of the local frame schedulers ( called by the thread container function


Static Protected Methods

void * _threadContainer (void *)
 used to start threads


Protected Attributes

unsigned int _currentStep
 the shared simulation step number

unsigned int _numberOfThreads
 the number of threads

vector< PsnScheduler * > * _localSchedulers
 for each thread, a local frame scheduler is created

PsnScheduler * _duplicatedObjectScheduler
 a specific scheduler is created for duplicated objects

PsnBarrier * _barrier
 the synchronisation barrier between al lthe threads

unsigned int _nextThreadForScheduling
 cycles through all threads, for cyclic alloaction of simulated objects to threads

map< PsnReferenceObjectHandle *,
unsigned int > 		_whichThread
 remember to wich thread a simulated object was assigned

pthread_t * _threadIds
 store the thread ids

vector< pair< PsnScheduler *,
unsigned int > * > * 		_threadData
 store for each created thread, a pointer to the scheduler and thread specific data

long ** _localWaitingTimes
 used to bench waiting times

int _numberOfSamples
 used to bench waiting times

map< PsnReferenceObjectHandle *,
long * > 		_tabVitesse
const int & _sampleIndex
ostream & _outputFile

Detailed Description

class PsnMultiThreadedScheduler : uses threads to schedule the different simulation objects, and bench the simulation times

Author:
David Margery
Version:
:

Definition at line 33 of file PsnMultiThreadedBenchmarkingScheduler.h.

Constructor & Destructor Documentation

PsnMultiThreadedBenchmarkingScheduler::PsnMultiThreadedBenchmarkingScheduler (  unsigned int    numberOfSteps,
unsigned int    numberOfThreads,
bool    createThreadAndLocalSchedulers,
const int &    indiceEchantillon,
unsigned int    _numberOfSamples,
ostream &    outputFile
) 
 

constructor

Parameters:
numberOfSteps number of simulation steps in a simualtion cycle
numberOfThreads number of threads to create to simulata each step
createThreadAndLocalSchedulers if false, no threads are created (enables redefintion)

Definition at line 33 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _barrier, _duplicatedObjectScheduler, _localSchedulers, _localWaitingTimes, _numberOfSamples, _numberOfThreads, _outputFile, _sampleIndex, _threadContainer(), _threadData, _threadIds, and PsController::error(). 

00038                                                                                                      :
00039    PsnScheduler(numberOfSteps),
00040    _numberOfThreads(numberOfThreads),
00041    _currentStep ( 0 ),
00042    _nextThreadForScheduling ( 0 ),
00043    _sampleIndex ( sampleIndex ),
00044    _numberOfSamples( numberOfSamples ),
00045    _outputFile ( outputFile )
00046 
00047 {
00048    assert ( _outputFile.good() ) ;
00049 
00050    _barrier = new PsnBarrier ( _numberOfThreads + 1) ;
00051 
00052    _threadIds = new pthread_t [ _numberOfThreads ] ;
00053 
00054    _threadData = new vector <pair<PsnScheduler *, unsigned int> * > ( _numberOfThreads ) ;
00055 
00056    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00057       {
00058          (*_threadData)[i] = new pair<PsnScheduler *, unsigned int> (this, i) ;
00059       }
00060 
00061    _localSchedulers = new vector <PsnScheduler *> ( _numberOfThreads ) ;
00062 
00063    int ret;
00064 
00065 #ifdef _SGI
00066    //for better use of the cpus available
00067    pthread_setconcurrency(_numberOfThreads) ;
00068 #endif
00069 
00070    if ( createThreadAndLocalSchedulers )
00071       {
00072          
00073          _duplicatedObjectScheduler = new PsnBenchScheduler( numberOfSteps, 
00074                                                              _sampleIndex, 
00075                                                              _numberOfSamples, 
00076                                                              _outputFile ) ;
00077          
00078          for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00079             {
00080                (*_localSchedulers)[i] = new PsnBenchScheduler( numberOfSteps, 
00081                                                              _sampleIndex, 
00082                                                              _numberOfSamples, 
00083                                                              _outputFile ) ;
00084             }
00085             
00086          for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00087             {
00088                ret = pthread_create( & (_threadIds [i]), 
00089                                      0,
00090                                      (void *(*)(void *))_threadContainer,
00091                                      (*_threadData)[i]);
00092                if (ret) 
00093                   {
00094                      PsController::error("Thread creation impossible") ;
00095                   }
00096                
00097             }
00098       }
00099 
00100    // create the data structures needed for benchmarking the waiting times
00101    _localWaitingTimes = new long * [ _numberOfThreads ] ;
00102 
00103    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00104       {
00105          _localWaitingTimes [ i ] = new long [ _numberOfSamples ] ;
00106       }
00107    
00108 }

PsnMultiThreadedBenchmarkingScheduler::~PsnMultiThreadedBenchmarkingScheduler (    )  [virtual]
 

destructor

Definition at line 111 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _barrier, _duplicatedObjectScheduler, _localSchedulers, _localWaitingTimes, _numberOfSamples, _numberOfThreads, _outputFile, _threadData, and _threadIds. 

00112 {
00113    //first, print the scheduling data.
00114    long totalTime = 0 ;
00115    
00116    assert (_outputFile.good() ) ;
00117    
00118    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00119       {
00120          totalTime = 0 ;
00121          _outputFile <<"thread "<<i<<endl;
00122          for ( int j =0 ; j < _numberOfSamples ; j ++ ) 
00123             {
00124                totalTime += _localWaitingTimes [i] [j] ;
00125                _outputFile <<_localWaitingTimes [i] [j] <<" , ";
00126             }
00127          _outputFile << "average " <<totalTime/_numberOfSamples<<endl;
00128          
00129          delete _localWaitingTimes [ i ] ;
00130          
00131       }  
00132    
00133    delete [] _localWaitingTimes ;
00134    
00135 
00136    // then take care of the multi-threading data
00137    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00138       {
00139          // this will print the benchmarking data for each local scheduler
00140          delete (*_localSchedulers)[i] ;
00141          
00142          delete (*_threadData)[i] ;
00143 
00144    }
00145 
00146    delete _localSchedulers ;
00147 
00148    delete _barrier ;
00149 
00150    delete [] _threadIds ;
00151 
00152    delete _threadData ;
00153 
00154    delete _duplicatedObjectScheduler ;
00155 }

Member Function Documentation

void * PsnMultiThreadedBenchmarkingScheduler::_threadContainer (  void *    )  [static, protected]
 

used to start threads

Definition at line 285 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References PsnMemoryManager::allocateSizeRemembered(), HeapStackTop::getSystemMemoryManager(), and PsnMemoryManager::init().

Referenced by PsnMultiThreadedBenchmarkingScheduler(). 

00286 {
00287    // install the memory managers
00288    HeapStackTop systemMemoryManager ( HeapStackTop::getSystemMemoryManager() ) ;
00289   
00290    PsnMemoryManager * currentMemoryManager = HeapStackTop::getSystemMemoryManager() ;
00291 
00292    assert ( currentMemoryManager != 0 ) ;
00293 
00294    size_t initialAllocatatedMemory = 1024 * 1024 ;
00295 
00296    void * startMemory = currentMemoryManager->allocateSizeRemembered ( initialAllocatatedMemory ) ;
00297 
00298    PsnDescriptorMemoryManager * descriptorMemoryManager = new PsnDescriptorMemoryManager ( *currentMemoryManager ) ;
00299 
00300    descriptorMemoryManager->init() ;
00301    
00302    PsnThreadMemoryManager * memoryManagerForThisThread ;
00303    
00304    memoryManagerForThisThread = new PsnThreadMemoryManager ( startMemory, 
00305                                                              initialAllocatatedMemory,
00306                                                              *currentMemoryManager,
00307                                                              *descriptorMemoryManager ) ;
00308    memoryManagerForThisThread -> init() ;
00309 
00310    HeapStackTop allocationContextForThisThread ( memoryManagerForThisThread ) ;
00311    
00312    pair<PsnMultiThreadedBenchmarkingScheduler *, unsigned int> * threadData = ( pair<PsnMultiThreadedBenchmarkingScheduler *, unsigned int> * ) myThreadData ;
00313 
00314    ( * threadData ).first->run( ( * threadData ).second ) ;
00315 
00316    return threadData ;
00317 }

void PsnMultiThreadedBenchmarkingScheduler::addToScheduable (  PsnReferenceObjectHandle *    ref,
unsigned int    when,
unsigned int    whichThread
)  [virtual]
 

add a simulated object to a specific thread

Definition at line 185 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _duplicatedObjectScheduler, addToScheduable(), and PsnScheduler::addToScheduable(). 

00188 {
00189    if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
00190       {
00191          _duplicatedObjectScheduler->addToScheduable ( ref , when ) ;
00192       }
00193    else 
00194       {
00195          (*_localSchedulers)[ whichThread ] -> addToScheduable( ref , when ) ;
00196       }
00197 }

void PsnMultiThreadedBenchmarkingScheduler::addToScheduable (  PsnReferenceObjectHandle *    ref,
unsigned int    when
)  [virtual]
 

redefine so that simulated objects are assigned to threads in a cyclic manner

Implements PsnScheduler.

Definition at line 201 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _duplicatedObjectScheduler, _nextThreadForScheduling, _numberOfThreads, _whichThread, PsnScheduler::addToScheduable(), map< PsnReferenceObjectHandle *, unsigned int >::end(), map< PsnReferenceObjectHandle *, unsigned int >::find(), PsSimulatedObject::getFather(), PsObjectDescriptor::getName(), PsSimulatedObject::getObjectDescriptor(), PsSimulatedObject::getObjectHandle(), and PsnObjectHandle::getSimulatedObject().

Referenced by addToScheduable(). 

00203 {
00204 
00205    if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
00206       {
00207          _duplicatedObjectScheduler->addToScheduable ( ref , when ) ;
00208       }
00209    else 
00210       {
00211          assert ( ref != NULL ) ;
00212          assert ( ref->getSimulatedObject().getFather () != NULL );
00213          
00214          //try and schedule an object on the same thread as it's father.
00215          map<PsnReferenceObjectHandle *, unsigned int>::iterator i = _whichThread.find((PsnReferenceObjectHandle *)ref->getSimulatedObject().getFather()->getObjectHandle() ) ;
00216          if ( i == _whichThread.end() )
00217             {
00218             
00219                (*_localSchedulers)[ _nextThreadForScheduling ] -> addToScheduable( ref , when ) ;
00220 #ifdef _DEBUGSCHEDULER
00221                cerr<<ref->getSimulatedObject().getObjectDescriptor().getName()<< " goes to thread "<<_nextThreadForScheduling<<endl;
00222 #endif
00223                _whichThread [ ref ] = _nextThreadForScheduling ;
00224                
00225                _nextThreadForScheduling = ( _nextThreadForScheduling + 1 ) % _numberOfThreads ;
00226                
00227             }
00228          else {//schedule on the same thread as ref's father
00229             
00230             (*_localSchedulers)[ (*i).second ] -> addToScheduable( ref , when ) ;
00231 #ifdef _DEBUGSCHEDULER
00232             cerr<<ref->getSimulatedObject().getObjectDescriptor().getName()<< " goes to thread "<<(*i).second<<endl;
00233 #endif
00234             
00235             _whichThread [ ref ] = (*i).second ;
00236             
00237       }
00238    }
00239 }

void PsnMultiThreadedBenchmarkingScheduler::removeFromScheduable (  PsnReferenceObjectHandle *    ref )  [virtual]
 

redefine to remove the simulated object from schedulers local to a thread

Implements PsnScheduler.

Definition at line 243 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _duplicatedObjectScheduler, _whichThread, and PsnScheduler::removeFromScheduable(). 

00243                                                                                                 {
00244 
00245    if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
00246       {
00247          _duplicatedObjectScheduler->removeFromScheduable ( ref ) ;
00248       }
00249    else 
00250       {
00251          (*_localSchedulers) [ _whichThread [ ref ] ] ->removeFromScheduable (ref ) ;
00252       }
00253 }

void PsnMultiThreadedBenchmarkingScheduler::run (  unsigned int    whichFrameScheduler )  [virtual]
 

run one of the local frame schedulers ( called by the thread container function

Definition at line 320 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _barrier, _currentStep, _localWaitingTimes, _numberOfSamples, and PsnBarrier::Sync(). 

00321 {
00322 #ifdef _SGI
00323   timespec dateBeforeSync, dateAfterSync ;
00324   int counter = 0 ;
00325   while ( true ) 
00326      {
00327          
00328          //wait for the controller to be ready
00329          _barrier->Sync() ;
00330          
00331          (*_localSchedulers)[ whichFrameScheduler ]->runStep ( _currentStep ) ;
00332          
00333          clock_gettime (CLOCK_SGI_CYCLE, &dateBeforeSync);
00334 
00335          //wait for other local schdulers to be ready
00336          _barrier->Sync() ;
00337 
00338          clock_gettime (CLOCK_SGI_CYCLE, &dateAfterSync);
00339 
00340          if (dateAfterSync.tv_nsec >= dateBeforeSync.tv_nsec ) 
00341             {
00342                _localWaitingTimes [whichFrameScheduler] [ counter ] =  ( dateAfterSync.tv_nsec - dateBeforeSync.tv_nsec ) / 1000 ;
00343             }
00344          
00345          counter = ( counter + 1 ) % _numberOfSamples ;
00346    }
00347 
00348 #else
00349    timeval dateBeforeSync ;
00350    timeval dateAfterSync ;
00351    int counter = 0 ;
00352    while ( true ) 
00353       {
00354          
00355          //wait for the controller to be ready
00356          _barrier->Sync() ;
00357          
00358          (*_localSchedulers)[ whichFrameScheduler ]->runStep ( _currentStep ) ;
00359          
00360          gettimeofday(&dateBeforeSync, NULL);
00361 
00362          //wait for other local schdulers to be ready
00363          _barrier->Sync() ;
00364 
00365          gettimeofday(&dateAfterSync, NULL);
00366 
00367          if (dateAfterSync.tv_usec >= dateBeforeSync.tv_usec ) 
00368             {
00369             _localWaitingTimes [whichFrameScheduler] [ counter ] =  dateAfterSync.tv_usec - dateBeforeSync.tv_usec ;
00370             }
00371 
00372          counter = ( counter + 1 ) % _numberOfSamples ;
00373    }
00374 #endif
00375 }

void PsnMultiThreadedBenchmarkingScheduler::runStep (  unsigned int    which )  [virtual]
 

run a simulation step

Implements PsnScheduler.

Definition at line 159 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _barrier, _currentStep, _duplicatedObjectScheduler, _numberOfThreads, PsnThreadMemoryManager::freeLeakedMemoryBlocks(), PsnScheduler::runStep(), and PsnBarrier::Sync(). 

00160 {
00161 
00162    _currentStep = which ;
00163 
00164    _duplicatedObjectScheduler->runStep (which) ;
00165 
00166 #if defined (_DEBUGSCHEDULER)   
00167    cerr<<"PsnMultiThreadedScheduler::runStep : Execution by block for debug "<<endl;
00168    for ( int i = 0 ; i < _numberOfThreads ; i++ ) {
00169       cerr<<"Block "<<i<<" ***********************************"<<endl;
00170       (*_localSchedulers)[ i ]->runStep (which) ;
00171    }
00172 #else
00173    _barrier->Sync() ;
00174 
00175    _barrier->Sync() ;
00176    //let the controller do it's work
00177 
00178    //purge the memory manager from memory that couldn't be freed efficiently
00179    PsnThreadMemoryManager::freeLeakedMemoryBlocks() ;
00180 #endif
00181 }

void PsnMultiThreadedBenchmarkingScheduler::schedule (  PsnReferenceObjectHandle *    ref )  [virtual]
 

mark a scheduable object as active

Implements PsnScheduler.

Definition at line 257 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _duplicatedObjectScheduler, _whichThread, and PsnScheduler::schedule(). 

00258 {
00259    if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
00260       {
00261          _duplicatedObjectScheduler->schedule ( ref ) ;
00262       }
00263    else 
00264       {
00265          (*_localSchedulers) [ _whichThread [ ref ] ] -> schedule (ref) ;
00266       }
00267 }

void PsnMultiThreadedBenchmarkingScheduler::unschedule (  PsnReferenceObjectHandle *    ref )  [virtual]
 

mark a scheduable object as inactive

Implements PsnScheduler.

Definition at line 271 of file PsnMultiThreadedBenchmarkingScheduler.cxx.

References _duplicatedObjectScheduler, _whichThread, and PsnScheduler::unschedule(). 

00272 {
00273    if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
00274       {
00275          _duplicatedObjectScheduler->unschedule ( ref ) ;
00276       }
00277    else 
00278       {
00279          (*_localSchedulers) [ _whichThread [ ref ] ] -> unschedule (ref) ;
00280       }
00281 }

Member Data Documentation

PsnBarrier* PsnMultiThreadedBenchmarkingScheduler::_barrier [protected]
 

the synchronisation barrier between al lthe threads

Definition at line 90 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), run(), runStep(), and ~PsnMultiThreadedBenchmarkingScheduler().

unsigned int PsnMultiThreadedBenchmarkingScheduler::_currentStep [protected]
 

the shared simulation step number

Definition at line 78 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by run(), and runStep().

PsnScheduler* PsnMultiThreadedBenchmarkingScheduler::_duplicatedObjectScheduler [protected]
 

a specific scheduler is created for duplicated objects

Definition at line 87 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by addToScheduable(), PsnMultiThreadedBenchmarkingScheduler(), removeFromScheduable(), runStep(), schedule(), unschedule(), and ~PsnMultiThreadedBenchmarkingScheduler().

vector<PsnScheduler * >* PsnMultiThreadedBenchmarkingScheduler::_localSchedulers [protected]
 

for each thread, a local frame scheduler is created

Definition at line 84 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), and ~PsnMultiThreadedBenchmarkingScheduler().

long* * PsnMultiThreadedBenchmarkingScheduler::_localWaitingTimes [protected]
 

used to bench waiting times

Definition at line 105 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), run(), and ~PsnMultiThreadedBenchmarkingScheduler().

unsigned int PsnMultiThreadedBenchmarkingScheduler::_nextThreadForScheduling [protected]
 

cycles through all threads, for cyclic alloaction of simulated objects to threads

Definition at line 93 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by addToScheduable().

int PsnMultiThreadedBenchmarkingScheduler::_numberOfSamples [protected]
 

used to bench waiting times

Definition at line 108 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), run(), and ~PsnMultiThreadedBenchmarkingScheduler().

unsigned int PsnMultiThreadedBenchmarkingScheduler::_numberOfThreads [protected]
 

the number of threads

Definition at line 81 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by addToScheduable(), PsnMultiThreadedBenchmarkingScheduler(), runStep(), and ~PsnMultiThreadedBenchmarkingScheduler().

ostream& PsnMultiThreadedBenchmarkingScheduler::_outputFile [protected]
 

Definition at line 114 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), and ~PsnMultiThreadedBenchmarkingScheduler().

const int& PsnMultiThreadedBenchmarkingScheduler::_sampleIndex [protected]
 

Definition at line 112 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler().

map<PsnReferenceObjectHandle *, long*> PsnMultiThreadedBenchmarkingScheduler::_tabVitesse [protected]
 

Definition at line 110 of file PsnMultiThreadedBenchmarkingScheduler.h.

vector<pair<PsnScheduler *, unsigned int> * >* PsnMultiThreadedBenchmarkingScheduler::_threadData [protected]
 

store for each created thread, a pointer to the scheduler and thread specific data

Definition at line 102 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), and ~PsnMultiThreadedBenchmarkingScheduler().

pthread_t* PsnMultiThreadedBenchmarkingScheduler::_threadIds [protected]
 

store the thread ids

Definition at line 99 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by PsnMultiThreadedBenchmarkingScheduler(), and ~PsnMultiThreadedBenchmarkingScheduler().

map<PsnReferenceObjectHandle *, unsigned int> PsnMultiThreadedBenchmarkingScheduler::_whichThread [protected]
 

remember to wich thread a simulated object was assigned

Definition at line 96 of file PsnMultiThreadedBenchmarkingScheduler.h.

Referenced by addToScheduable(), removeFromScheduable(), schedule(), and unschedule().

The documentation for this class was generated from the following files:
logo OpenMask

Documentation generated on Mon Nov 25 15:26:13 2002

Generated with doxygen 1.2.12 by Dimitri van Heesch ,   1997-2001