runtime/objc-sync.m

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24  */
  25 //
  26 //  objc_sync.m
  27 //
  28 //  Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
  29 //
  30
  31 #include <stdbool.h>
  32 #include <stdlib.h>
  33 #include <sys/time.h>
  34 #include <pthread.h>
  35 #include <AssertMacros.h>
  36
  37 #include "objc-sync.h"
  38
  39 //
  40 // Code by Nick Kledzik
  41 //
  42
  43 // revised comments by Blaine
  44
  45 //
  46 // Allocate a lock only when needed.  Since few locks are needed at any point
  47 // in time, keep them on a single list.
  48 //
  49
  50 static pthread_mutexattr_t      sRecursiveLockAttr;
  51 static bool                     sRecursiveLockAttrIntialized = false;
  52
  53 static pthread_mutexattr_t* recursiveAttributes()
  54 {
  55     if ( !sRecursiveLockAttrIntialized ) {
  56         int err = pthread_mutexattr_init(&sRecursiveLockAttr);
  57         require_noerr_string(err, done, "pthread_mutexattr_init failed");
  58
  59         err = pthread_mutexattr_settype(&sRecursiveLockAttr, PTHREAD_MUTEX_RECURSIVE);
  60         require_noerr_string(err, done, "pthread_mutexattr_settype failed");
  61
  62         sRecursiveLockAttrIntialized = true;
  63    }
  64
  65 done:
  66     return &sRecursiveLockAttr;
  67 }
  68
  69
  70 struct SyncData
  71 {
  72         struct SyncData*        nextData;       // only accessed while holding sTableLock
  73         id                      object;         // only accessed while holding sTableLock
  74         unsigned int            lockCount;      // only accessed while holding sTableLock
  75         pthread_mutex_t         mutex;
  76         pthread_cond_t          conditionVariable;
  77 };
  78 typedef struct SyncData SyncData;
  79
  80
  81 static pthread_mutex_t          sTableLock = PTHREAD_MUTEX_INITIALIZER;
  82 static SyncData*                sDataList = NULL;
  83
  84 enum usage { ACQUIRE, RELEASE, CHECK };
  85
  86 static SyncData* id2data(id object, enum usage why)
  87 {
  88     SyncData* result = NULL;
  89     int err;
  90
  91     pthread_mutex_lock(&sTableLock);
  92
  93     // Walk in-use list looking for matching object
  94     // sTableLock keeps other threads from winning an allocation race
  95     // for the same new object.
  96     // We could keep the nodes in some hash table if we find that there are
  97     // more than 20 or so distinct locks active, but we don't do that now.
  98
  99     SyncData* firstUnused = NULL;
 100     SyncData* p;
 101     for (p = sDataList; p != NULL; p = p->nextData) {
 102         if ( p->object == object ) {
 103             result = p;
 104             goto done;
 105         }
 106         if ( (firstUnused == NULL) && (p->object == NULL) )
 107             firstUnused = p;
 108     }
 109
 110     // no SyncData currently associated with object
 111     if ( (why == RELEASE) || (why == CHECK) )
 112         goto done;
 113
 114     // an unused one was found, use it
 115     if ( firstUnused != NULL ) {
 116         result = firstUnused;
 117         result->object = object;
 118         result->lockCount = 0;  // sanity
 119         goto done;
 120     }
 121
 122     // malloc a new SyncData and add to list.
 123     // XXX calling malloc with a global lock held is bad practice,
 124     // might be worth releasing the lock, mallocing, and searching again.
 125     // But since we never free these guys we won't be stuck in malloc very often.
 126     result = (SyncData*)malloc(sizeof(SyncData));
 127     result->object = object;
 128     result->lockCount = 0;
 129     err = pthread_mutex_init(&result->mutex, recursiveAttributes());
 130     require_noerr_string(err, done, "pthread_mutex_init failed");
 131     err = pthread_cond_init(&result->conditionVariable, NULL);
 132     require_noerr_string(err, done, "pthread_cond_init failed");
 133     result->nextData = sDataList;
 134     sDataList = result;
 135
 136 done:
 137     if ( result != NULL ) {
 138         switch ( why ) {
 139             case ACQUIRE:
 140                 result->lockCount++;
 141                 break;
 142             case RELEASE:
 143                 result->lockCount--;
 144                 if ( result->lockCount == 0 )
 145                     result->object = NULL;  // now recycled
 146                 break;
 147             case CHECK:
 148                 // do nothing
 149                 break;
 150         }
 151     }
 152     pthread_mutex_unlock(&sTableLock);
 153     return result;
 154 }
 155
 156
 157
 158 // Begin synchronizing on 'obj'.
 159 // Allocates recursive pthread_mutex associated with 'obj' if needed.
 160 // Returns OBJC_SYNC_SUCCESS once lock is acquired.
 161 int objc_sync_enter(id obj)
 162 {
 163     int result = OBJC_SYNC_SUCCESS;
 164
 165     SyncData* data = id2data(obj, ACQUIRE);
 166     require_action_string(data != NULL, done, result = OBJC_SYNC_NOT_INITIALIZED, "id2data failed");
 167
 168     result = pthread_mutex_lock(&data->mutex);
 169     require_noerr_string(result, done, "pthread_mutex_lock failed");
 170
 171 done:
 172     return result;
 173 }
 174
 175
 176 // End synchronizing on 'obj'.
 177 // Returns OBJC_SYNC_SUCCESS or OBJC_SYNC_NOT_OWNING_THREAD_ERROR
 178 int objc_sync_exit(id obj)
 179 {
 180     int result = OBJC_SYNC_SUCCESS;
 181
 182     SyncData* data = id2data(obj, RELEASE);
 183     require_action_string(data != NULL, done, result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR, "id2data failed");
 184
 185     result = pthread_mutex_unlock(&data->mutex);
 186     require_noerr_string(result, done, "pthread_mutex_unlock failed");
 187
 188 done:
 189     if ( result == EPERM )
 190         result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
 191
 192     return result;
 193 }
 194
 195
 196 // Temporarily release lock on 'obj' and wait for another thread to notify on 'obj'
 197 // Return OBJC_SYNC_SUCCESS, OBJC_SYNC_NOT_OWNING_THREAD_ERROR, OBJC_SYNC_TIMED_OUT, OBJC_SYNC_INTERRUPTED
 198 int objc_sync_wait(id obj, long long milliSecondsMaxWait)
 199 {
 200     int result = OBJC_SYNC_SUCCESS;
 201
 202     SyncData* data = id2data(obj, CHECK);
 203     require_action_string(data != NULL, done, result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR, "id2data failed");
 204
 205
 206     // XXX need to retry cond_wait under out-of-our-control failures
 207     if ( milliSecondsMaxWait == 0 ) {
 208         result = pthread_cond_wait(&data->conditionVariable, &data->mutex);
 209         require_noerr_string(result, done, "pthread_cond_wait failed");
 210     }
 211     else {
 212         struct timespec maxWait;
 213         maxWait.tv_sec  = milliSecondsMaxWait / 1000;
 214         maxWait.tv_nsec = (milliSecondsMaxWait - (maxWait.tv_sec * 1000)) * 1000000;
 215         result = pthread_cond_timedwait_relative_np(&data->conditionVariable, &data->mutex, &maxWait);
 216         require_noerr_string(result, done, "pthread_cond_timedwait_relative_np failed");
 217     }
 218     // no-op to keep compiler from complaining about branch to next instruction
 219     data = NULL;
 220
 221 done:
 222     if ( result == EPERM )
 223         result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
 224     else if ( result == ETIMEDOUT )
 225         result = OBJC_SYNC_TIMED_OUT;
 226
 227     return result;
 228 }
 229
 230
 231 // Wake up another thread waiting on 'obj'
 232 // Return OBJC_SYNC_SUCCESS, OBJC_SYNC_NOT_OWNING_THREAD_ERROR
 233 int objc_sync_notify(id obj)
 234 {
 235     int result = OBJC_SYNC_SUCCESS;
 236
 237     SyncData* data = id2data(obj, CHECK);
 238     require_action_string(data != NULL, done, result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR, "id2data failed");
 239
 240     result = pthread_cond_signal(&data->conditionVariable);
 241     require_noerr_string(result, done, "pthread_cond_signal failed");
 242
 243 done:
 244     if ( result == EPERM )
 245         result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
 246
 247     return result;
 248 }
 249
 250
 251 // Wake up all threads waiting on 'obj'
 252 // Return OBJC_SYNC_SUCCESS, OBJC_SYNC_NOT_OWNING_THREAD_ERROR
 253 int objc_sync_notifyAll(id obj)
 254 {
 255     int result = OBJC_SYNC_SUCCESS;
 256
 257     SyncData* data = id2data(obj, CHECK);
 258     require_action_string(data != NULL, done, result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR, "id2data failed");
 259
 260     result = pthread_cond_broadcast(&data->conditionVariable);
 261     require_noerr_string(result, done, "pthread_cond_broadcast failed");
 262
 263 done:
 264     if ( result == EPERM )
 265         result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
 266
 267     return result;
 268 }
 269
 270
 271
 272
 273
 274