libs-base/Source/NSLock.m

/** Control of executable units within a shared virtual memory space
   Copyright (C) 1996-2000 Free Software Foundation, Inc.

   Original Author:  David Chisnall <csdavec@swan.ac.uk>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02111 USA.

   <title>NSLock class reference</title>
*/



// This file uses some SUS'98 extensions, so we need to tell glibc not to hide
// them.  Other platforms have more sensible libcs, which just default to being
// standards-compliant.
#define _XOPEN_SOURCE 500
#include <pthread.h>
#import "GNUstepBase/GSConfig.h"
#define	gs_cond_t	pthread_cond_t
#define	gs_mutex_t	pthread_mutex_t
#import "Foundation/NSLock.h"
#include <math.h>
#include <errno.h>
#import "Foundation/NSException.h"

/**
 * Methods shared between NSLock, NSRecursiveLock, and NSCondition
 *
 * Note: These methods currently throw exceptions when locks are incorrectly
 * acquired.  This is compatible with earlier GNUstep behaviour.  In OS X 10.5
 * and later, these will just NSLog a warning instead.  Throwing an exception
 * is probably better behaviour, because it encourages developer to fix their
 * code.  
 */
#define NSLOCKING_METHODS \
- (void) lock\
{\
  int err = pthread_mutex_lock(&_mutex);\
  if (EINVAL == err)\
    {\
      [NSException raise: NSLockException\
	    format: @"failed to lock mutex"];\
    }\
  if (EDEADLK == err)\
    {\
	_NSLockError(self, _cmd);\
    }\
}\
- (void) unlock\
{\
  if (0 != pthread_mutex_unlock(&_mutex))\
    {\
      [NSException raise: NSLockException\
	    format: @"failed to unlock mutex"];\
    }\
}\
- (NSString*) description\
{\
  if (_name == nil)\
    {\
      return [super description];\
    }\
  return [NSString stringWithFormat: @"%@ '%@'",\
    [super description], _name];\
}\
- (BOOL) tryLock\
{\
  int err = pthread_mutex_trylock(&_mutex);\
  if (EDEADLK == err)\
    {\
      _NSLockError(self, _cmd);\
      return YES;\
    }\
  return (0 == err);\
}\
- (BOOL) lockBeforeDate: (NSDate*)limit\
{\
  do\
    {\
      int err = pthread_mutex_trylock(&_mutex);\
      if (EDEADLK == err)\
	{\
	  _NSLockError(self, _cmd);\
	  return YES;\
	}\
      if (0 == err)\
	{\
	  return YES;\
	}\
      sched_yield();\
    } while([limit timeIntervalSinceNow] < 0);\
  return NO;\
}\
NAME_METHODS

#define NAME_METHODS \
- (void) setName: (NSString*)newName\
{\
  ASSIGNCOPY(_name, newName);\
}\
- (NSString*) name\
{\
  return _name;\
}

/**
 * OS X 10.5 compatibility function to allow debugging deadlock conditions.
 *
 * On OS X, this really deadlocks.  For now, we just continue, while logging
 * the 'you are a numpty' warning.
 */
void _NSLockError(id obj, SEL _cmd)
{
  NSLog(@"*** -[%@ %@]: deadlock (%@)", [obj class],
      NSStringFromSelector(_cmd), obj);
  NSLog(@"*** Break on _NSLockError() to debug.");
}

/**
 * Init method for an NSLock / NSRecursive lock.  Creates a mutex of the
 * specified type.  Also adds the corresponding -finalize and -dealloc methods.
 */
#define INIT_LOCK_WITH_TYPE(lock_type) \
- (id) init\
{\
  pthread_mutexattr_t attr;\
  if (nil == (self = [super init]))\
    {\
      return nil;\
    }\
  pthread_mutexattr_init(&attr);\
  pthread_mutexattr_settype(&attr, lock_type);\
  if (0 != pthread_mutex_init(&_mutex, &attr))\
    {\
      [self release];\
      return nil;\
    }\
  return self;\
}\
- (void) finalize\
{\
  pthread_mutex_destroy(&_mutex);\
}\
- (void) dealloc\
{\
  [self finalize];\
  [_name release];\
  [super dealloc];\
}

// Exceptions

NSString *NSLockException = @"NSLockException";


@implementation NSLock
// Use an error-checking lock.  This is marginally slower, but lets us throw
// exceptions when incorrect locking occurs.
INIT_LOCK_WITH_TYPE(PTHREAD_MUTEX_ERRORCHECK)
NSLOCKING_METHODS
@end

@implementation NSRecursiveLock
INIT_LOCK_WITH_TYPE(PTHREAD_MUTEX_RECURSIVE);
NSLOCKING_METHODS
@end

@implementation NSCondition
- (id)init
{
  pthread_mutexattr_t attr;

  if (nil == (self = [super init]))
    {
      return nil;
    }
  if (0 != pthread_cond_init(&_condition, NULL))
    {
      [self release];
      return nil;
    }
  pthread_mutexattr_init(&attr);
  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
  if (0 != pthread_mutex_init(&_mutex, &attr))
    {
      pthread_cond_destroy(&_condition);
      [self release];
      return nil;
    }
  return self;
}

- (void) finalize
{
  pthread_cond_destroy(&_condition);
  pthread_mutex_destroy(&_mutex);
}

- (void) dealloc
{
  [self finalize];
  [_name release];
  [super dealloc];
}

- (void) wait
{
  pthread_cond_wait(&_condition, &_mutex);
}

- (BOOL) waitUntilDate: (NSDate*)limit
{
  NSTimeInterval t = [limit timeIntervalSinceReferenceDate];
  double secs, subsecs;
  struct timespec timeout;

  // Split the float into seconds and fractions of a second
  subsecs = modf(t, &secs);
  timeout.tv_sec = secs;
  // Convert fractions of a second to nanoseconds
  timeout.tv_nsec = subsecs * 1e9;
  return (0 == pthread_cond_timedwait(&_condition, &_mutex, &timeout));
}

- (void) signal
{
  pthread_cond_signal(&_condition);
}

- (void) broadcast
{
  pthread_cond_broadcast(&_condition);
}

NSLOCKING_METHODS
@end

@implementation NSConditionLock
- (id) init
{
  return [self initWithCondition: 0];
}

- (id) initWithCondition: (NSInteger)value
{
  if (nil == (self = [super init]))
    {
      return nil;
    }
  if (nil == (_condition = [NSCondition new]))
    {
      [self release];
      return nil;
    }
  _condition_value = value;
  return self;
}

- (void) dealloc
{
  [_name release];
  [_condition release];
  [super dealloc];
}

- (NSInteger) condition
{
  return _condition_value;
}

- (void) lockWhenCondition: (NSInteger)value
{
  [_condition lock];
  while (value != _condition_value)
    {
      [_condition wait];
    }
}

- (void) unlockWithCondition: (NSInteger)value
{
  _condition_value = value;
  [_condition broadcast];
  [_condition unlock];
}

- (BOOL) tryLockWhenCondition: (NSInteger)value
{
  return [self lockWhenCondition: value
		      beforeDate: [NSDate date]];
}

- (BOOL) lockBeforeDate: (NSDate*)limit
{
  return [_condition lockBeforeDate: limit];
}

- (BOOL) lockWhenCondition: (NSInteger)condition_to_meet
                beforeDate: (NSDate*)limitDate
{
  [_condition lock];
  if (condition_to_meet == _condition_value)
    {
      return YES;
    }
  if ([_condition waitUntilDate: limitDate]
    && (condition_to_meet == _condition_value))
    {
      return YES;
    }
  return NO;
}

// NSLocking methods.  These aren't instantiated with the macro as they are
// delegated to the NSCondition.
- (void) lock
{
  [_condition lock];
}

- (void) unlock
{
  [_condition unlock];
}

- (BOOL) tryLock
{
  return [_condition tryLock];
}

NAME_METHODS
@end