group.cpp

The Spectral Toolkit is a C++ spectral transform library written by Rodney James and Chuck Panaccion

//
// 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)); }

}