* Introduced a set of functions (thread_prepare_to_block(),

thread_block(), thread_unblock(),...) that allow a thread to wait for
  something without needing a semaphore or condition variable. It can
  simply block and another thread can unblock it. Supports timeouts and
  interrupting. Both semaphores and condition variables use this
  common mechanism, now.
* Semaphores:
  - Some simplifications due to the thread blocking mechanism.
  - Changed locking order to sem -> thread. It was the other way around
    before and when introducing the wait_for_objects() support I had
    also introduced a situation where the locking was reverse, which
    could potentially cause a dead lock on SMP systems.
  - Instead of queueing thread structures, a semaphore queues
    queued_thread entries now, which are created on the stack. The
    thread::sem structure could thus be removed.
  - Added sem_entry::net_count, which is sem_entry::count plus the
    acquisition count of all waiting threads. This number is needed in
    remove_thread_from_sem() and instead of computing it there we
    maintain it.
  - Fixed remove_thread_from_sem(). It would not unblock threads, if
    the sem count was <= 0.
  - Made sem::last_acquirer unconditional. It is actually needed for
    sem_info::latest_holder. Fixed fill_sem_info() accordingly.
  - Added some optional tracing output, though only via ktrace_printf().
* Condition variables:
  - Could be simplified significantly through the use of the thread
    blocking mechanism. Removed a good deal of unnecessary code.
  - Moved the ConditionVariableEntry "flags" parameter from Wait() to
    Add(), and adjusted all places where condition variables are used
    accordingly.
* snooze() uses thread_block_with_timeout() instead of a semaphore.
* Simplified thread interrupting in the signal and user debugger code.
  Instead of separate functions for threads waiting on a semaphore or
  condititon variable, we only have a single thread_interrupt(), now.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25099 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/kernel/condition_variable.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2007, Ingo Weinhold, [email protected].
+ * Copyright 2007-2008, Ingo Weinhold, [email protected].
  * Distributed under the terms of the MIT License.
  */
 #ifndef _KERNEL_CONDITION_VARIABLE_H
@@ -40,24 +40,16 @@ public:
 	inline	PrivateConditionVariable* Variable() const
 		{ return fVariable; }
 
-	class Private;
-
 protected:
-			bool				Add(const void* object);
-			status_t			Wait(uint32 flags);
+			bool				Add(const void* object, uint32 flags);
+			status_t			Wait();
 			status_t			Wait(const void* object, uint32 flags);
 
-private:
-			void				_Remove();
-
 protected:
 			PrivateConditionVariable* fVariable;
 			struct thread*		fThread;
-			uint32				fFlags;
-			status_t			fResult;
 
 			friend class PrivateConditionVariable;
-			friend class Private;
 };
 
 
@@ -103,8 +95,8 @@ public:
 template<typename Type = void>
 class ConditionVariableEntry : public PrivateConditionVariableEntry {
 public:
-	inline	bool				Add(const Type* object);
-	inline	status_t			Wait(uint32 flags = 0);
+	inline	bool				Add(const Type* object, uint32 flags = 0);
+	inline	status_t			Wait();
 	inline	status_t			Wait(const Type* object, uint32 flags = 0);
 };
 
@@ -143,17 +135,17 @@ ConditionVariable<Type>::NotifyAll(bool threadsLocked)
 
 template<typename Type>
 inline bool
-ConditionVariableEntry<Type>::Add(const Type* object)
+ConditionVariableEntry<Type>::Add(const Type* object, uint32 flags)
 {
-	return PrivateConditionVariableEntry::Add(object);
+	return PrivateConditionVariableEntry::Add(object, flags);
 }
 
 
 template<typename Type>
 inline status_t
-ConditionVariableEntry<Type>::Wait(uint32 flags)
+ConditionVariableEntry<Type>::Wait()
 {
-	return PrivateConditionVariableEntry::Wait(flags);
+	return PrivateConditionVariableEntry::Wait();
 }
 
 
@@ -170,8 +162,6 @@ extern "C" {
 
 struct thread;
 
-extern status_t condition_variable_interrupt_thread(struct thread* thread);
-
 extern void condition_variable_init();
 
 #ifdef __cplusplus