//// spectral toolkit // copyright (c) 2005 university corporation for atmospheric research// licensed under the gnu general public license//#include "group.h"namespace spectral{  /// Constructor for group object.  Creates a group of size 0.  group::group()  {    block=0;    count=0;    threads=0;    pthread_mutex_init(&mutex,NULL);    pthread_mutex_init(&mutex_lock,NULL);    pthread_cond_init(&cond,NULL);  }  /// Constructor for group object.  Creates a group of size nt.  /// \param nt size of group  group::group(int nt)  {    block=0;    count=0;    threads=nt;    pthread_mutex_init(&mutex,NULL);    pthread_mutex_init(&mutex_lock,NULL);    pthread_cond_init(&cond,NULL);  }  /// Destructor for group object.  Cleans up mutex and condition variables.  group::~group()  {    pthread_mutex_destroy(&mutex);    pthread_mutex_destroy(&mutex_lock);    pthread_cond_destroy(&cond);  }  /// Dynamic increment operator for group object.  Increases the size of a group by one.  /// \sa size  void group::operator++(int)  {    pthread_mutex_lock(&mutex_lock);    threads++;    pthread_mutex_unlock(&mutex_lock);  }  /// Dynamic decrement operator for group object.  Descreases the size of a group by one.  /// \sa size  void group::operator--(int)  {    pthread_mutex_lock(&mutex_lock);    threads--;    pthread_mutex_unlock(&mutex_lock);  }  /// Group sync function.    /// Blocks all threads calling the sync until all of the group members call the sync.  /// The number of calling threads must equal the size of the group or a deadlock may occur.  /// \param g pointer to a group object  /// \sa group size  int sync(group *g)  {    int local;    if(g)      {	pthread_mutex_lock(&(g->mutex));	local=g->count;	g->block++;	if(g->block==g->threads)	  {	    g->block=0;	    g->count++;	    pthread_cond_broadcast(&(g->cond));	  }	while(local==g->count)	  pthread_cond_wait(&(g->cond),&(g->mutex));	pthread_mutex_unlock(&(g->mutex));      }    return(0);  }  /// Group lock function.  Performs a mutex lock on group object.  /// \param g pointer to a group object  /// \sa group unlock  int lock(group *g)  {    if(g)      return(pthread_mutex_lock(&(g->mutex_lock)));    else      return(0);  }  /// Group unlock function.  Performs a mutex unlock on group object.  /// \param g pointer to a group object  /// \sa group lock  int unlock(group *g)  {    if(g)      return(pthread_mutex_unlock(&(g->mutex_lock)));    else      return(0);  }  /// Group size function.  Returns current size of group.  /// \param g pointer to a group object  /// \sa group  int size(group *g)  {    if(g)      return(g->threads);    else      return(0);  }  /// Group sync function.    /// Blocks all threads calling the sync until all of the group members call the sync.  /// The number of calling threads must equal the size of the group or a deadlock may occur.  /// \param g reference to a group object  /// \sa group size  int sync(group& g) { return(sync(&g)); }  /// Group lock function.  Performs a mutex lock on group object.  /// \param g reference to a group object  /// \sa group unlock  int lock(group& g) { return(lock(&g)); }  /// Group unlock function.  Performs a mutex unlock on group object.  /// \param g reference to a group object  /// \sa group lock  int unlock(group& g) { return(unlock(&g)); }  /// Group size function.  Returns current size of group.  /// \param g reference to a group object  /// \sa group  int size(group& g) { return(size(&g)); }}