haiku/src/servers/app/MultiLocker.cpp

/*
 * Copyright 2005-2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT license.
 *
 * Copyright 1999, Be Incorporated.   All Rights Reserved.
 * This file may be used under the terms of the Be Sample Code License.
 */


#include "MultiLocker.h"

#include <Debug.h>
#include <Errors.h>
#include <OS.h>


#define TIMING	MULTI_LOCKER_TIMING
#ifndef DEBUG
#	define DEBUG	MULTI_LOCKER_DEBUG
#endif


const int32 LARGE_NUMBER = 100000;


MultiLocker::MultiLocker(const char* baseName)
	:
#if DEBUG
	fDebugArray(NULL),
	fMaxThreads(0),
	fWriterNest(0),
	fWriterThread(-1),
#endif
	fInit(B_NO_INIT)
{
#if !DEBUG
	rw_lock_init_etc(&fLock, baseName != NULL ? baseName : "some MultiLocker",
		baseName != NULL ? RW_LOCK_FLAG_CLONE_NAME : 0);
	fInit = B_OK;
#else
	// we are in debug mode!
	fLock = create_sem(LARGE_NUMBER, baseName != NULL ? baseName : "MultiLocker");
	if (fLock >= 0)
		fInit = B_OK;

	// create the reader tracking list
	// the array needs to be large enough to hold all possible threads
	system_info sys;
	get_system_info(&sys);
	fMaxThreads = sys.max_threads;
	fDebugArray = (int32 *) malloc(fMaxThreads * sizeof(int32));
	for (int32 i = 0; i < fMaxThreads; i++) {
		fDebugArray[i] = 0;
	}
#endif
#if TIMING
	//initialize the counter variables
	rl_count = ru_count = wl_count = wu_count = islock_count = 0;
	rl_time = ru_time = wl_time = wu_time = islock_time = 0;
	#if DEBUG
		reg_count = unreg_count = 0;
		reg_time = unreg_time = 0;
	#endif
#endif
}


MultiLocker::~MultiLocker()
{
	// become the writer
	if (!IsWriteLocked())
		WriteLock();

	// set locker to be uninitialized
	fInit = B_NO_INIT;

#if !DEBUG
	rw_lock_destroy(&fLock);
#else
	delete_sem(fLock);
	free(fDebugArray);
#endif
#if TIMING
	// let's produce some performance numbers
	printf("MultiLocker Statistics:\n"
		"Avg ReadLock: %lld\n"
		"Avg ReadUnlock: %lld\n"
		"Avg WriteLock: %lld\n"
		"Avg WriteUnlock: %lld\n"
		"Avg IsWriteLocked: %lld\n",
		rl_count > 0 ? rl_time / rl_count : 0,
		ru_count > 0 ? ru_time / ru_count : 0,
		wl_count > 0 ? wl_time / wl_count : 0,
		wu_count > 0 ? wu_time / wu_count : 0,
		islock_count > 0 ? islock_time / islock_count : 0);
#endif
}


status_t
MultiLocker::InitCheck()
{
	return fInit;
}


#if !DEBUG
//	#pragma mark - Standard versions


bool
MultiLocker::IsWriteLocked() const
{
#if TIMING
	bigtime_t start = system_time();
#endif

	bool writeLockHolder = false;

	if (fInit == B_OK)
		writeLockHolder = (find_thread(NULL) == fLock.holder);

#if TIMING
	bigtime_t end = system_time();
	islock_time += (end - start);
	islock_count++;
#endif

	return writeLockHolder;
}


bool
MultiLocker::ReadLock()
{
#if TIMING
	bigtime_t start = system_time();
#endif

	bool locked = (rw_lock_read_lock(&fLock) == B_OK);

#if TIMING
	bigtime_t end = system_time();
	rl_time += (end - start);
	rl_count++;
#endif

	return locked;
}


bool
MultiLocker::WriteLock()
{
#if TIMING
	bigtime_t start = system_time();
#endif

	bool locked = (rw_lock_write_lock(&fLock) == B_OK);

#if TIMING
	bigtime_t end = system_time();
	wl_time += (end - start);
	wl_count++;
#endif

	return locked;
}


bool
MultiLocker::ReadUnlock()
{
#if TIMING
	bigtime_t start = system_time();
#endif

	bool unlocked = (rw_lock_read_unlock(&fLock) == B_OK);

#if TIMING
	bigtime_t end = system_time();
	ru_time += (end - start);
	ru_count++;
#endif

	return unlocked;
}


bool
MultiLocker::WriteUnlock()
{
#if TIMING
	bigtime_t start = system_time();
#endif

	bool unlocked = (rw_lock_write_unlock(&fLock) == B_OK);

#if TIMING
	bigtime_t end = system_time();
	wu_time += (end - start);
	wu_count++;
#endif

	return unlocked;
}


#else	// DEBUG
//	#pragma mark - Debug versions


bool
MultiLocker::IsWriteLocked() const
{
#if TIMING
	bigtime_t start = system_time();
#endif

	bool writeLockHolder = false;

	if (fInit == B_OK)
		writeLockHolder = (find_thread(NULL) == fWriterThread);

#if TIMING
	bigtime_t end = system_time();
	islock_time += (end - start);
	islock_count++;
#endif

	return writeLockHolder;
}


bool
MultiLocker::ReadLock()
{
	bool locked = false;

	if (fInit != B_OK)
		debugger("lock not initialized");

	if (IsWriteLocked()) {
		if (fWriterNest < 0)
			debugger("ReadLock() - negative writer nest count");

		fWriterNest++;
		locked = true;
	} else {
		status_t status;
		do {
			status = acquire_sem(fLock);
		} while (status == B_INTERRUPTED);

		locked = status == B_OK;

		if (locked)
			_RegisterThread();
	}

	return locked;
}


bool
MultiLocker::WriteLock()
{
	bool locked = false;

	if (fInit != B_OK)
		debugger("lock not initialized");

	if (IsWriteLocked()) {
		if (fWriterNest < 0)
			debugger("WriteLock() - negative writer nest count");

		fWriterNest++;
		locked = true;
	} else {
		// new writer acquiring the lock
		if (IsReadLocked())
			debugger("Reader wants to become writer!");

		status_t status;
		do {
			status = acquire_sem_etc(fLock, LARGE_NUMBER, 0, 0);
		} while (status == B_INTERRUPTED);

		locked = status == B_OK;
		if (locked) {
			// record thread information
			fWriterThread = find_thread(NULL);
		}
	}

	return locked;
}


bool
MultiLocker::ReadUnlock()
{
	bool unlocked = false;

	if (IsWriteLocked()) {
		// writers simply decrement the nesting count
		fWriterNest--;
		if (fWriterNest < 0)
			debugger("ReadUnlock() - negative writer nest count");

		unlocked = true;
	} else {
		// decrement and retrieve the read counter
		unlocked = release_sem_etc(fLock, 1, B_DO_NOT_RESCHEDULE) == B_OK;
		if (unlocked)
			_UnregisterThread();
	}

	return unlocked;
}


bool
MultiLocker::WriteUnlock()
{
	bool unlocked = false;

	if (IsWriteLocked()) {
		// if this is a nested lock simply decrement the nest count
		if (fWriterNest > 0) {
			fWriterNest--;
			unlocked = true;
		} else {
			// clear the information while still holding the lock
			fWriterThread = -1;
			unlocked = release_sem_etc(fLock, LARGE_NUMBER,
				B_DO_NOT_RESCHEDULE) == B_OK;
		}
	} else {
		char message[256];
		snprintf(message, sizeof(message), "Non-writer attempting to "
			"WriteUnlock() - write holder: %" B_PRId32, fWriterThread);
		debugger(message);
	}

	return unlocked;
}


bool
MultiLocker::IsReadLocked() const
{
	if (fInit == B_NO_INIT)
		return false;

	// determine if the lock is actually held
	thread_id thread = find_thread(NULL);
	return fDebugArray[thread % fMaxThreads] > 0;
}


/* these two functions manage the debug array for readers */
/* an array is created in the constructor large enough to hold */
/* an int32 for each of the maximum number of threads the system */
/* can have at one time. */
/* this array does not need to be locked because each running thread */
/* can be uniquely mapped to a slot in the array by performing: */
/* 		thread_id % max_threads */
/* each time ReadLock is called while in debug mode the thread_id	*/
/* is retrived in register_thread() and the count is adjusted in the */
/* array.  If register thread is ever called and the count is not 0 then */
/* an illegal, potentially deadlocking nested ReadLock occured */
/* unregister_thread clears the appropriate slot in the array */

/* this system could be expanded or retracted to include multiple arrays of information */
/* in all fairness for it's current use, fDebugArray could be an array of bools */

/* The disadvantage of this system for maintaining state is that it sucks up a ton of */
/* memory.  The other method (which would be slower), would involve an additional lock and */
/* traversing a list of cached information.  As this is only for a debug mode, the extra memory */
/* was not deemed to be a problem */

void
MultiLocker::_RegisterThread()
{
	thread_id thread = find_thread(NULL);

	if (fDebugArray[thread % fMaxThreads] != 0)
		debugger("Nested ReadLock!");

	fDebugArray[thread % fMaxThreads]++;
}


void
MultiLocker::_UnregisterThread()
{
	thread_id thread = find_thread(NULL);

	ASSERT(fDebugArray[thread % fMaxThreads] == 1);
	fDebugArray[thread % fMaxThreads]--;
}

#endif	// DEBUG