dyld-44.4.tar.gz

[apple/dyld.git] / src / dyldLock.cpp

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2004-2005 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <pthread.h>

#include "dyldLock.h"

// until the reader/writer locks are fully tested, we just use a simple recursive mutex
#define REAL_READER_WRITER_LOCK 0



//
// This class implements a recursive reader/writer lock.
// Recursive means a thread that has already aquired the lock can re-acquire it.
// The lock allows either:
//      a) one "writer" thread to hold lock
//              b) multiple "reader" threads to hold
//
// A thread with the writer can acquire a reader lock.
// A thread with a reader lock can acquire a writer lock iff it is the only thread with a reader lock
//
class RecursiveReaderWriterLock 
{
public:
                        RecursiveReaderWriterLock() __attribute__((visibility("hidden")));
        void    initIfNeeded();
        
        
        void    lockForSingleWritingThread() __attribute__((visibility("hidden")));
        void    unlockForSingleWritingThread() __attribute__((visibility("hidden")));
        
        void    lockForMultipleReadingThreads() __attribute__((visibility("hidden")));
        void    unlockForMultipleReadingThreads() __attribute__((visibility("hidden")));

private:
#if REAL_READER_WRITER_LOCK
        struct ThreadRecursionCount {
                pthread_t       fThread;
                uint32_t        fCount;
        };
        bool    writerThreadIsAnyThreadBut(pthread_t thread);
        void    writerThreadRetain(pthread_t thread);
        bool    writerThreadRelease(pthread_t thread);

        enum { kMaxReaderThreads = 4 };
        bool    readerThreadSetRetain(pthread_t thread);
        bool    readerThreadSetRelease(pthread_t thread);
        bool    readerThreadSetContainsAnotherThread(pthread_t thread);

        ThreadRecursionCount    fWriterThread;
        ThreadRecursionCount    fReaderThreads[kMaxReaderThreads];
        pthread_cond_t                  fLockFree;
        pthread_mutex_t                 fMutex;
#else
        pthread_mutex_t                 fMutex;
#endif
        bool                                    fInitialized;   // assumes this is statically initialized to false because sLock is static
};


//
// initIfNeeded() is a hack so that when libSystem_debug.dylb is useable.
// The problem is that Objective-C +load methods are called before C++ initialziers are run
// If +load method makes a call into dyld, sLock is not initialized.  
//
// The long term solution is for objc and dyld to work more closely together so that instead
// of running all +load methods before all initializers, we run each image's +load then its
// initializers all in bottom up order.
//
// This lazy initialization is not thread safe, but as long as someone does not create a 
// new thread in a +load method, the C++ constructor for sLock will be called before main()
// so there will only be one thead.
//
void RecursiveReaderWriterLock::initIfNeeded()
{
        if ( ! fInitialized ) {
                pthread_mutexattr_t recursiveMutexAttr;
                pthread_mutexattr_init(&recursiveMutexAttr);
                pthread_mutexattr_settype(&recursiveMutexAttr, PTHREAD_MUTEX_RECURSIVE);
                pthread_mutex_init(&fMutex, &recursiveMutexAttr);
        #if REAL_READER_WRITER_LOCK
                pthread_cond_init(&fLockFree, NULL);
                fWriterThread.fThread = NULL;
                fWriterThread.fCount = 0;
                for (int i=0; i < kMaxReaderThreads; ++i) {
                        fReaderThreads[i].fThread = NULL;
                        fReaderThreads[i].fCount = 0;
                }
        #endif
                fInitialized = true;
        }
}

RecursiveReaderWriterLock::RecursiveReaderWriterLock()
{
        initIfNeeded();
}

void RecursiveReaderWriterLock::lockForSingleWritingThread()
{
        this->initIfNeeded();
#if REAL_READER_WRITER_LOCK
        pthread_mutex_lock(&fMutex);
        pthread_t thisThread = pthread_self();
        // wait as long as there is another writer or any readers on a different thread
        while ( writerThreadIsAnyThreadBut(thisThread) || readerThreadSetContainsAnotherThread(thisThread) ) {
                pthread_cond_wait(&fLockFree, &fMutex);
        }
        writerThreadRetain(thisThread);
        pthread_mutex_unlock(&fMutex);
#else
        pthread_mutex_lock(&fMutex);
#endif
}

void RecursiveReaderWriterLock::unlockForSingleWritingThread()
{
        this->initIfNeeded();
#if REAL_READER_WRITER_LOCK
        pthread_mutex_lock(&fMutex);
        if ( writerThreadRelease(pthread_self()) ) {
                pthread_cond_broadcast(&fLockFree);
        }
        pthread_mutex_unlock(&fMutex);
#else
        pthread_mutex_unlock(&fMutex);
#endif
}


void RecursiveReaderWriterLock::lockForMultipleReadingThreads()
{
        this->initIfNeeded();
#if REAL_READER_WRITER_LOCK
        pthread_mutex_lock(&fMutex);
        pthread_t thisThread = pthread_self();
        // wait as long as there is a writer on another thread or too many readers already
        while ( writerThreadIsAnyThreadBut(thisThread) || !readerThreadSetRetain(thisThread) ) {
                pthread_cond_wait(&fLockFree, &fMutex);
        }
        pthread_mutex_unlock(&fMutex);
#else
        pthread_mutex_lock(&fMutex);
#endif
}


void RecursiveReaderWriterLock::unlockForMultipleReadingThreads()
{
        this->initIfNeeded();
#if REAL_READER_WRITER_LOCK
        pthread_mutex_lock(&fMutex);
        if ( readerThreadSetRelease(pthread_self()) ) {
                pthread_cond_broadcast(&fLockFree);
        }
        pthread_mutex_unlock(&fMutex);
#else
        pthread_mutex_unlock(&fMutex);
#endif
}

#if REAL_READER_WRITER_LOCK
bool RecursiveReaderWriterLock::writerThreadIsAnyThreadBut(pthread_t thread)
{
        return ( (fWriterThread.fThread != NULL) && (fWriterThread.fThread != thread) );
}

void RecursiveReaderWriterLock::writerThreadRetain(pthread_t thread)
{
        ++fWriterThread.fCount;
}

bool RecursiveReaderWriterLock::writerThreadRelease(pthread_t thread)
{
        return ( --fWriterThread.fCount == 0 );
}


bool RecursiveReaderWriterLock::readerThreadSetRetain(pthread_t thread)
{
        // if thread is already in set, bump its count
        for (int i=0; i < kMaxReaderThreads; ++i) {
                if ( fReaderThreads[i].fThread == thread ) {
                        ++fReaderThreads[i].fCount;
                        return true;
                }
        }
        // find empty slot in set
        for (int i=0; i < kMaxReaderThreads; ++i) {
                if ( fReaderThreads[i].fThread == NULL ) {
                        fReaderThreads[i].fThread = thread;
                        fReaderThreads[i].fCount = 1;
                        return true;
                }
        }

        // all reader slots full
        return false;
}

bool RecursiveReaderWriterLock::readerThreadSetRelease(pthread_t thread)
{
        for (int i=0; i < kMaxReaderThreads; ++i) {
                if ( fReaderThreads[i].fThread == thread ) {
                        if ( --fReaderThreads[i].fCount == 0 ) {
                                fReaderThreads[i].fThread = NULL;
                                return true;
                        }
                        return false;
                }
        }
        // should never get here
        return false;
}

bool RecursiveReaderWriterLock::readerThreadSetContainsAnotherThread(pthread_t thread)
{
        for (int i=0; i < kMaxReaderThreads; ++i) {
                if ( (fReaderThreads[i].fThread != NULL) && (fReaderThreads[i].fThread != thread) ) 
                        return true;
        }
        return false;
}
#endif


// dyld's global reader/writer lock
static RecursiveReaderWriterLock        sLock;


LockReaderHelper::LockReaderHelper() 
{ 
        sLock.lockForMultipleReadingThreads();
}

LockReaderHelper::~LockReaderHelper() 
{ 
        sLock.unlockForMultipleReadingThreads();
}


LockWriterHelper::LockWriterHelper() 
{ 
        sLock.lockForSingleWritingThread();
}

LockWriterHelper::~LockWriterHelper() 
{ 
        sLock.unlockForSingleWritingThread();
}


// needed by lazy binding
void lockForLazyBinding() 
{
        sLock.lockForMultipleReadingThreads();
}

void unlockForLazyBinding() 
{
        sLock.unlockForMultipleReadingThreads();
}