//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
-// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
#include <simgear/compiler.h>
#include <pthread.h>
-#if defined ( SG_HAVE_STD_INCLUDES )
-# include <cassert>
-# include <cerrno>
-#else
-# include <assert.h>
-# include <sys/errno.h>
-#endif
+#include <cassert>
+#include <cerrno>
class SGThread;
/**
* Start the underlying thread of execution.
+ * @param cpu An optional parameter to specify on which CPU to run this
+ * thread (only supported on IRIX at this time).
* @return Pthread error code if execution fails, otherwise returns 0.
*/
- int start();
+ int start( unsigned cpu = 0 );
/**
* Sends a cancellation request to the underlying thread. The target
}
inline int
-SGThread::start()
+SGThread::start( unsigned cpu )
{
int status = pthread_create( &tid, 0, start_handler, this );
assert( status == 0 );
+ (void)status;
+#if defined( sgi )
+ if ( !status && !cpu )
+ pthread_setrunon_np( cpu );
+#endif
return status;
}
{
int status = pthread_join( tid, 0 );
assert( status == 0 );
+ (void)status;
}
inline void
{
int status = pthread_cancel( tid );
assert( status == 0 );
+ (void)status;
}
/**
*/
class SGMutex
{
- friend class SGCondition;
+ friend class SGPthreadCond;
public:
{
int status = pthread_mutex_init( &mutex, 0 );
assert( status == 0 );
+ (void)status;
}
inline SGMutex::~SGMutex()
{
int status = pthread_mutex_destroy( &mutex );
assert( status == 0 );
+ (void)status;
}
inline void SGMutex::lock()
{
int status = pthread_mutex_lock( &mutex );
assert( status == 0 );
+ (void)status;
}
inline void SGMutex::unlock()
{
int status = pthread_mutex_unlock( &mutex );
assert( status == 0 );
+ (void)status;
}
/**
* A condition variable is always associated with a mutex to avoid race
* conditions.
*/
-class SGCondition
+class SGPthreadCond
{
public:
/**
* Create a new condition variable.
*/
- SGCondition();
+ SGPthreadCond();
/**
* Destroy the condition object.
*/
- ~SGCondition();
+ ~SGPthreadCond();
/**
* Wait for this condition variable to be signaled.
private:
// Disable copying.
- SGCondition(const SGCondition& );
- SGCondition& operator=(const SGCondition& );
+ SGPthreadCond(const SGPthreadCond& );
+ SGPthreadCond& operator=(const SGPthreadCond& );
private:
pthread_cond_t cond;
};
-inline SGCondition::SGCondition()
+inline SGPthreadCond::SGPthreadCond()
{
int status = pthread_cond_init( &cond, 0 );
assert( status == 0 );
+ (void)status;
}
-inline SGCondition::~SGCondition()
+inline SGPthreadCond::~SGPthreadCond()
{
int status = pthread_cond_destroy( &cond );
assert( status == 0 );
+ (void)status;
}
-inline void SGCondition::signal()
+inline void SGPthreadCond::signal()
{
int status = pthread_cond_signal( &cond );
assert( status == 0 );
+ (void)status;
}
-inline void SGCondition::broadcast()
+inline void SGPthreadCond::broadcast()
{
int status = pthread_cond_broadcast( &cond );
assert( status == 0 );
+ (void)status;
}
-inline void SGCondition::wait( SGMutex& mutex )
+inline void SGPthreadCond::wait( SGMutex& mutex )
{
int status = pthread_cond_wait( &cond, &mutex.mutex );
assert( status == 0 );
+ (void)status;
}
#endif /* SGTHREAD_HXX_INCLUDED */