haiku.git

/*
 * Copyright 2008-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <locks.h>


enum {
	STATE_UNINITIALIZED	= -1,	// keep in sync with INIT_ONCE_UNINITIALIZED
	STATE_INITIALIZING	= -2,
	STATE_SPINNING		= -3,
	STATE_INITIALIZED	= -4	// keep in sync with INIT_ONCE_INITIALIZED
};


status_t
__init_once(int32* control, status_t (*initRoutine)(void*), void* data)
{
	// Algorithm:
	// The control variable goes through at most four states:
	// STATE_UNINITIALIZED: The initial uninitialized state.
	// STATE_INITIALIZING: Set by the first thread entering the function. It
	// will call initRoutine.
	// semaphore/STATE_SPINNING: Set by the second thread entering the function,
	// when the first thread is still executing initRoutine. The normal case is
	// that the thread manages to create a semaphore. This thread (and all
	// following threads) will block on the semaphore until the first thread is
	// done.
	// STATE_INITIALIZED: Set by the first thread when it returns from
	// initRoutine. All following threads will return right away.

	int32 value = atomic_test_and_set(control, STATE_INITIALIZING,
		STATE_UNINITIALIZED);

	if (value == STATE_INITIALIZED)
		return 0;

	if (value == STATE_UNINITIALIZED) {
		// we're the first -- perform the initialization
		initRoutine(data);

		value = atomic_get_and_set(control, STATE_INITIALIZED);

		// If someone else is waiting, we need to delete the semaphore.
		if (value >= 0)
			delete_sem(value);

		return 0;
	}

	if (value == STATE_INITIALIZING) {
		// someone is initializing -- we need to create a semaphore we can wait
		// on
		sem_id semaphore = create_sem(0, "pthread once");
		if (semaphore >= 0) {
			// successfully created -- set it
			value = atomic_test_and_set(control, semaphore, STATE_INITIALIZING);
			if (value == STATE_INITIALIZING)
				value = semaphore;
			else
				delete_sem(semaphore);
		} else {
			// Failed to create the semaphore. Can only happen when the system
			// runs out of semaphores, but we can still handle the situation
			// gracefully by spinning.
			value = atomic_test_and_set(control, STATE_SPINNING,
				STATE_INITIALIZING);
			if (value == STATE_INITIALIZING)
				value = STATE_SPINNING;
		}
	}

	if (value >= 0) {
		// wait on the semaphore
		while (acquire_sem(value) == B_INTERRUPTED);

		return 0;
	} else if (value == STATE_SPINNING) {
		// out of semaphores -- spin
		while (atomic_get(control) == STATE_SPINNING);
	}

	return 0;
}