pegasus/src/Pegasus/Common/SpinLock.cpp - diff

Return to SpinLock.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/SpinLock.cpp between version 1.3 and 1.10

version 1.3, 2005/11/03 02:36:59

version 1.10, 2006/06/26 23:30:26

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

Line 8

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 29

Line 31

// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)

// Modified By: David Dillard, Symantec Corp. (david_dillard@symantec.com)

//%/////////////////////////////////////////////////////////////////////////////

#include "Network.h"

#if defined(PEGASUS_OS_SOLARIS)

# include <sys/types.h>

# include <unistd.h>

#endif

#include "SpinLock.h"

#if !defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

#if !defined(PEGASUS_OS_VMS) && !defined(PEGASUS_OS_TYPE_WINDOWS)

# define PEGASUS_SPINLOCK_USE_PTHREADS

#endif

Line 45

Line 56

PEGASUS_NAMESPACE_BEGIN

SpinLock sharedSpinLocks[PEGASUS_NUM_SHARED_SPIN_LOCKS];

SpinLock spinLockPool[PEGASUS_NUM_SHARED_SPIN_LOCKS];

int spinLockPoolInitialized;

#ifdef PEGASUS_SPINLOCK_USE_PTHREADS

pthread_mutex_t _spinLockInitMutex = PTHREAD_MUTEX_INITIALIZER;

Line 53

Line 65

static Mutex _spinLockInitMutex;

#endif

void SpinLockConditionalCreate(SpinLock& lock)

void SpinLockCreatePool()

{

// Use double-checked locking pattern to avoid mutex lock when possible.

// There's no need to check spinLockPoolInitialized before locking the

// mutex, because the caller can check the flag before calling this

// function.

if (lock.initialized == 0)

{

#ifdef PEGASUS_SPINLOCK_USE_PTHREADS

pthread_mutex_lock(&_spinLockInitMutex);

#else

_spinLockInitMutex.lock(pegasus_thread_self());

#endif

if (lock.initialized == 0)

if (spinLockPoolInitialized == 0)

SpinLockCreate(lock);

{

for (size_t i = 0; i < PEGASUS_NUM_SHARED_SPIN_LOCKS; i++)

SpinLockCreate(spinLockPool[i]);

spinLockPoolInitialized = 1;

}

#ifdef PEGASUS_SPINLOCK_USE_PTHREADS

pthread_mutex_unlock(&_spinLockInitMutex);

Line 74

Line 91

_spinLockInitMutex.unlock();

#endif

}

#if defined(PEGASUS_SPINLOCK_USE_PTHREADS)

// This function is called prior to forking. We must obtain a lock

// on every mutex that the child will inherit. These will remain locked

// until they are unlocked (by _unlockSpinLockPool()). This prevents a

// child process from waiting indefinitely on a mutex that was locked by

// another thread in the parent process during the fork.

extern "C" void _lockSpinLockPool()

{

// Initialize the spinlock pool if not already done.

if (spinLockPoolInitialized == 0)

SpinLockCreatePool();

pthread_mutex_lock(&_spinLockInitMutex);

for (size_t i = 0; i < PEGASUS_NUM_SHARED_SPIN_LOCKS; i++)

SpinLockLock(spinLockPool[i]);

}

// This function is called after forking. It unlocks the mutexes that

// were locked by _lockSpinLockPool() before the fork.

extern "C" void _unlockSpinLockPool()

{

pthread_mutex_unlock(&_spinLockInitMutex);

for (size_t i = 0; i < PEGASUS_NUM_SHARED_SPIN_LOCKS; i++)

SpinLockUnlock(spinLockPool[i]);

}

class SpinLockInitializer

{

public:

SpinLockInitializer()

{

// ATTN: Temporary workaround for Bug 4559

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_SOLARIS)

pthread_atfork(

_lockSpinLockPool,

_unlockSpinLockPool,

_unlockSpinLockPool);

#endif

}

};

static SpinLockInitializer spinLockInitializer;

#endif /* PEGASUS_SPINLOCK_USE_PTHREADS */

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.3
changed lines
	Added in v.1.10

No CVS admin address has been configured