37eda488be
Before this commit, *all* ConditionVariable operations (yes, all; even Wait, Notify, etc.) went through a single spinlock, that also protected the sConditionVariableHash. This obviously does not scale so well with core count, to say the least! With this commit, we add spinlocks to each Variable and Entry. This makes locking somewhat more complicated (and nuanced; see inline comment), but the trade-off seems completely worth it: (compile HaikuDepot in VMware, 2 cores) before real 1m20.219s user 1m5.619s sys 0m40.724s after real 1m12.667s user 0m57.684s sys 0m37.251s The more cores there are, the more of an optimization this will likely prove to be. But 10%-across-the-board is not bad to say the least. Change-Id: I1e40a997fff58a79e987d7cdcafa8f7358e1115a
147 lines
3.1 KiB
C++
147 lines
3.1 KiB
C++
/*
|
|
* Copyright 2007-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
|
|
* Copyright 2019, Haiku, Inc. All rights reserved.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef _KERNEL_CONDITION_VARIABLE_H
|
|
#define _KERNEL_CONDITION_VARIABLE_H
|
|
|
|
|
|
#include <OS.h>
|
|
|
|
#include <debug.h>
|
|
|
|
#ifdef __cplusplus
|
|
|
|
#include <util/DoublyLinkedList.h>
|
|
#include <util/OpenHashTable.h>
|
|
|
|
|
|
struct ConditionVariable;
|
|
|
|
|
|
struct ConditionVariableEntry
|
|
: DoublyLinkedListLinkImpl<ConditionVariableEntry> {
|
|
public:
|
|
#if KDEBUG
|
|
inline ConditionVariableEntry();
|
|
inline ~ConditionVariableEntry();
|
|
#endif
|
|
|
|
bool Add(const void* object);
|
|
status_t Wait(uint32 flags = 0, bigtime_t timeout = 0);
|
|
status_t Wait(const void* object, uint32 flags = 0,
|
|
bigtime_t timeout = 0);
|
|
|
|
inline status_t WaitStatus() const { return fWaitStatus; }
|
|
|
|
inline ConditionVariable* Variable() const { return fVariable; }
|
|
|
|
private:
|
|
inline void AddToLockedVariable(ConditionVariable* variable);
|
|
|
|
private:
|
|
spinlock fLock;
|
|
ConditionVariable* fVariable;
|
|
Thread* fThread;
|
|
status_t fWaitStatus;
|
|
|
|
friend struct ConditionVariable;
|
|
};
|
|
|
|
|
|
struct ConditionVariable {
|
|
public:
|
|
void Init(const void* object,
|
|
const char* objectType);
|
|
// for anonymous (unpublished) cvars
|
|
|
|
void Publish(const void* object,
|
|
const char* objectType);
|
|
void Unpublish();
|
|
|
|
inline void NotifyOne(status_t result = B_OK);
|
|
inline void NotifyAll(status_t result = B_OK);
|
|
|
|
static void NotifyOne(const void* object, status_t result);
|
|
static void NotifyAll(const void* object, status_t result);
|
|
// (both methods) caller must ensure that
|
|
// the variable is not unpublished
|
|
// concurrently
|
|
|
|
void Add(ConditionVariableEntry* entry);
|
|
|
|
status_t Wait(uint32 flags = 0, bigtime_t timeout = 0);
|
|
// all-in one, i.e. doesn't need a
|
|
// ConditionVariableEntry
|
|
|
|
const void* Object() const { return fObject; }
|
|
const char* ObjectType() const { return fObjectType; }
|
|
|
|
static void ListAll();
|
|
void Dump() const;
|
|
|
|
private:
|
|
void _Notify(bool all, status_t result);
|
|
void _NotifyLocked(bool all, status_t result);
|
|
|
|
protected:
|
|
typedef DoublyLinkedList<ConditionVariableEntry> EntryList;
|
|
|
|
const void* fObject;
|
|
const char* fObjectType;
|
|
|
|
spinlock fLock;
|
|
EntryList fEntries;
|
|
ConditionVariable* fNext;
|
|
|
|
friend struct ConditionVariableEntry;
|
|
friend struct ConditionVariableHashDefinition;
|
|
};
|
|
|
|
|
|
#if KDEBUG
|
|
|
|
inline
|
|
ConditionVariableEntry::ConditionVariableEntry()
|
|
: fVariable(NULL)
|
|
{
|
|
}
|
|
|
|
inline
|
|
ConditionVariableEntry::~ConditionVariableEntry()
|
|
{
|
|
if (fVariable != NULL) {
|
|
panic("Destroying condition variable entry %p, but it's still "
|
|
"attached to variable %p\n", this, fVariable);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
inline void
|
|
ConditionVariable::NotifyOne(status_t result)
|
|
{
|
|
_Notify(false, result);
|
|
}
|
|
|
|
|
|
inline void
|
|
ConditionVariable::NotifyAll(status_t result)
|
|
{
|
|
_Notify(true, result);
|
|
}
|
|
|
|
|
|
extern "C" {
|
|
#endif // __cplusplus
|
|
|
|
extern void condition_variable_init();
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif /* _KERNEL_CONDITION_VARIABLE_H */
|