---

thread.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _JOT_STD_THREAD_H
#define _JOT_STD_THREAD_H

#include "std/dllimpexp.H"
#include "std/config.H"
#include "std/error.H"
#include "std/thread_mutex.H"

// This file should contain generalized thread support, but for now
// it's just a pthread implmentation of a thread syncronization primitive.

#ifdef USE_PTHREAD
#if defined(sun) && !defined(_REENTRANT)
// Would like to use #error, but that just gives a warning
Need to compile thread stuff with -mt under Solaris
#endif
#include <pthread.h>

class Thread {
   public:
      Thread()          { _running = false; }
      virtual ~Thread() { if (_running) pthread_cancel(_thread); }  

      void start()  { 
     pthread_attr_t attr;
         int retval;
     if ((retval = pthread_attr_init(&attr)) != 0) {
            err_sys("Thread:start - pthread_attr_init returned %d", retval);
         }
     if ((retval=pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) != 0) {
            // On the SGI errno is cleared, so we have to use strerror
            err_quit("Thread:start - pthread_attr_setscope: %s", 
                     strerror(retval));
         }
     _running = !pthread_create(&_thread, &attr, kickstart, (void *)this);
     pthread_attr_destroy(&attr);
      }
   protected:
      virtual void threadProc() = 0;

   private:
      bool      _running;
      pthread_t _thread;
      static void *kickstart(void *me) { ((Thread *)me)->threadProc(); 
                                         return 0; }
};


class ThreadSync {
private:
  pthread_mutex_t mut_;
  pthread_cond_t queue_;
  int count_;
  const int number_;
  int generation_;

public:
  ThreadSync(int number): number_(number) {
    pthread_mutex_init(&mut_, 0);
    pthread_cond_init(&queue_, 0);
    count_ = 0;
    generation_ = 0;
  }
  
  ~ThreadSync() {
    pthread_mutex_destroy(&mut_);
    pthread_cond_destroy(&queue_);
  }

#ifndef sgi 
  void wait() {
    pthread_mutex_lock(&mut_);
    if (++count_ < number_) {
      int my_generation = generation_;
      while(my_generation == generation_)
    pthread_cond_wait(&queue_, &mut_);
    } else {
      count_ = 0;
      generation_++;
      pthread_cond_broadcast(&queue_);
    }
    pthread_mutex_unlock(&mut_);
  }
#else
  void wait() {
    pthread_mutex_lock(&mut_);
    if (++count_ < number_) {
      assert((count_ < number_) && (count_ > 0));
      int my_generation = generation_;
      pthread_mutex_unlock(&mut_);
      while(my_generation == generation_)
        ;
    } else {
      count_ = 0;
      generation_++;
      pthread_mutex_unlock(&mut_);
    }
  }
#endif
};

class ThreadData {
   public:
      ThreadData()  : _key(0) { }
      // Call this only once after all threads are created
      void create() {
         if (pthread_key_create(&_key, 0)) {
            cerr << "ThreadData::create - Could not create key" << endl;
         }
      }
      // Call from threads
      void  set(void *val) { pthread_setspecific(_key, val);}
      void *get()          { return pthread_getspecific(_key);}
   protected:
      pthread_key_t _key;
};
#endif

#endif

---