IDThreading.h

//========================================================================================
// 
// $File$
// 
// Owner: Florin Trofin
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// ADOBE CONFIDENTIAL
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================


#ifndef __IDTHREADING__
#define __IDTHREADING__

#include "IDThreadingPrimitives.h"
#include "OMTypes.h"
#include "K2Assert.h"

namespace IDThreading
{
 typedef uint32 ExecutionContextID;
 extern RUNTIME_DECL const ExecutionContextID kInvalidExecutionContextID;

 RUNTIME_DECL ExecutionContextID CurrentExecutionContextId ();

 RUNTIME_DECL void SetThreadName(ThreadID id, const char* name);

 //****************************************************************************************

 RUNTIME_DECL void BeginPublicThreadBottleneck ();

 RUNTIME_DECL void EndPublicThreadBottleneck ();

 typedef uint32 PublicThreadLocalStorageKey;
 typedef uint64 PublicThreadLocalStorageValue;

 RUNTIME_DECL PublicThreadLocalStorageKey PublicThreadLocalStorageAllocKey ();
 RUNTIME_DECL void PublicThreadLocalStorageRealeaseKey(PublicThreadLocalStorageKey key);
 RUNTIME_DECL void PublicThreadLocalStorageSet (PublicThreadLocalStorageKey key, PublicThreadLocalStorageValue value);
 RUNTIME_DECL PublicThreadLocalStorageValue PublicThreadLocalStorageGet (PublicThreadLocalStorageKey key, PublicThreadLocalStorageValue initialVal);

 typedef uint32 PublicThreadLocalSmartPointerKey;
 typedef boost::shared_ptr<void> PublicThreadLocalSmartPointerValue;


 RUNTIME_DECL PublicThreadLocalSmartPointerKey PublicThreadLocalSmartPointerAllocKey ();
 RUNTIME_DECL void PublicThreadLocalSmartPointerRealeaseKey(PublicThreadLocalSmartPointerKey key);
 RUNTIME_DECL void PublicThreadLocalSmartPointerSet (PublicThreadLocalSmartPointerKey key, PublicThreadLocalSmartPointerValue value);
 RUNTIME_DECL PublicThreadLocalSmartPointerValue PublicThreadLocalSmartPointerGet (PublicThreadLocalSmartPointerKey key);

 template<typename T>
 class ThreadLocal : boost::noncopyable
 {
 public:

 explicit ThreadLocal (const T & initialVal) : 
 fKey (PublicThreadLocalStorageAllocKey ()), 
 fInitialVal(PublicThreadLocalStorageValue(CONVERSION_TO_THREADLOCALSTORAGE<T>::CONVERT(initialVal)))
 {
 }
 
 ~ThreadLocal ()
 {
 PublicThreadLocalStorageRealeaseKey(fKey);
 }

 T Get () const
 {
 return T (PublicThreadLocalStorageGet (fKey, fInitialVal));
 }

 void Set (T x)
 {
 PublicThreadLocalStorageValue value =
 (PublicThreadLocalStorageValue) (CONVERSION_TO_THREADLOCALSTORAGE<T>::CONVERT(x));
 PublicThreadLocalStorageSet (fKey, value);
 }
 
 ThreadLocal<T>& operator=(T x)
 {
 Set(x);
 return *this;
 }

 ThreadLocal<T>& operator +=(T x)
 {
 Set(Get() + x);
 return *this;
 }
 ThreadLocal<T>& operator -=(T x)
 {
 Set(Get() - x);
 return *this;
 }
 ThreadLocal<T>& operator ++()
 {
 return operator+=(1);
 }
 ThreadLocal<T>& operator --()
 {
 return operator-=(1);
 }
 private:
 PublicThreadLocalStorageKey fKey;
 PublicThreadLocalStorageValue fInitialVal;
 };
 

 template<typename T>
 class ThreadLocalManagedObject : boost::noncopyable
 {
 public:
 ThreadLocalManagedObject():
 fKey (PublicThreadLocalSmartPointerAllocKey ()), 
 fInitialVal(nil)
 {
 }
 ThreadLocalManagedObject(const T& intVal):
 fKey (PublicThreadLocalSmartPointerAllocKey ()), 
 fInitialVal(new T(intVal))
 {
 }

 ~ThreadLocalManagedObject ()
 {
 delete fInitialVal;
 PublicThreadLocalSmartPointerRealeaseKey(fKey);
 }
 T *Get ()
 {
 return _get ();
 }

 const T *Get () const
 {
 return _get ();
 }

 const T& GetReference () const
 {
 return *_get ();
 }

 void Set (const T& val)
 {
 *_get () = val;
 }

 void Reset ()
 {
 *_get () = T();
 }
 private:
 
 T *_get () const
 {
 PublicThreadLocalSmartPointerValue value = 
 PublicThreadLocalSmartPointerGet (fKey);
 T *p = (T*) (value.get());

 if ( p == 0)
 {
 p = fInitialVal? new T(*fInitialVal) : new T;

 value =
 (PublicThreadLocalSmartPointerValue) (p);
 PublicThreadLocalSmartPointerSet (fKey, value);
 }
 return p;
 }

 PublicThreadLocalSmartPointerKey fKey;
 T* fInitialVal;

 };

 template<typename T>
 class ThreadLocalManagedArray : boost::noncopyable
 {
 public:
 ThreadLocalManagedArray(size_t __size):
 fKey (PublicThreadLocalSmartPointerAllocKey ()), 
 fSize(__size)
 {
 }

 ~ThreadLocalManagedArray()
 {
 PublicThreadLocalSmartPointerRealeaseKey(fKey);
 }

 T *Get ()
 {
 return _get ();
 }

 const T *Get () const
 {
 return _get ();
 }


 T *begin ()
 {
 return _get ();
 }

 const T *begin () const
 {
 return _get ();
 }

 T *end ()
 {
 return _get () + fSize;
 }

 const T *end () const
 {
 return _get () + fSize;
 }

 size_t size () const
 {
 return fSize;
 }

 private:
 T *_get () const
 {
 PublicThreadLocalSmartPointerValue value = 
 PublicThreadLocalSmartPointerGet (fKey);
 std::vector<T> *p = (std::vector<T> *) (value.get());
 
 if (p == 0)
 {
 p = new std::vector<T>(fSize);
 value =
 (PublicThreadLocalSmartPointerValue) (p);
 PublicThreadLocalSmartPointerSet (fKey, value);
 }
 
 return &(*p)[0];
 }
 
 const size_t fSize;
 PublicThreadLocalSmartPointerKey fKey;
 
 };

 // private testing use only
 RUNTIME_DECL void TestHook ();

 template<typename T>
 inline bool operator<(ThreadLocal<T> const& left, ThreadLocal<T> const& right)
 {
 return left.Get() < right.Get();
 }

 template<typename T>
 inline bool operator==(ThreadLocal<T> const& left, ThreadLocal<T> const& right)
 {
 return left.Get() == right.Get();
 }

 template<typename T>
 inline bool operator<(ThreadLocal<T> const& left, T right)
 {
 return left.Get() < right;
 }

 template<typename T>
 inline bool operator<(T left, ThreadLocal<T> const& right)
 {
 return left < right.Get();
 }

 template<typename T>
 inline bool operator==(ThreadLocal<T> const& left, T right)
 {
 return left.Get() == right;
 }

 template<typename T>
 inline bool operator==(T left, ThreadLocal<T> const& right)
 {
 return left == right.Get();
 }

 template<typename T>
 inline bool operator!=(ThreadLocal<T> const& left, T right)
 {
 return left.Get() != right;
 }

 template<typename T>
 inline bool operator!=(T left, ThreadLocal<T> const& right)
 {
 return left != right.Get();
 }

 RUNTIME_DECL void Sleep( uint32 milliseconds );
 
 
 struct adopt_lock_t {};
 extern const adopt_lock_t adopt_lock;

 template <class Mutex>
 class lock_guard
 {
 public:
 explicit lock_guard(Mutex& mx)
 : fMutex(mx), fLocked(false)
 {
 lock();
 }

 lock_guard(Mutex& mx, adopt_lock_t)
 : fMutex(mx), fLocked(true)
 {
 }
 
 ~lock_guard()
 {
 if (fLocked)
 unlock();
 }

 private:

 // This class is not copyable
 lock_guard(const lock_guard&);
 lock_guard& operator=(const lock_guard&);
 
 void lock()
 {
 ASSERT_MSG (!fLocked, "lock_guard::lock called on an already owned mutex!");
 fMutex.lock();
 fLocked = true;
 }

 void unlock()
 {
 ASSERT_MSG (fLocked, "lock_guard::unlock called on a mutex we don't own!");
 fMutex.unlock();
 fLocked = false;
 }
 
 bool is_locked() const { return fLocked; }

 Mutex& fMutex;
 bool fLocked;
 };

 class spin_mutex_impl;
 class RUNTIME_DECL spin_mutex
 {
 public:
 spin_mutex();

 ~spin_mutex();

 void lock();
 
 bool try_lock();
 
 void unlock();
 
 private:
 // This class is not copyable
 spin_mutex(const spin_mutex&);
 spin_mutex& operator=(const spin_mutex&);
 
 spin_mutex_impl* fIsLocked;
 };
 
} //IDThreading
#endif // __IDTHREADING__