ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

push accessing the DiagnosticContext down one layer

Browse source 
accessing the DiagnosticContext now inline when
providing the paramters for calling the C-functions.
No change in functionality, but saves us a lot of
syntactic noise.
This commit is contained in:
Fischlurch 2010-02-13 05:33:08 +01:00
parent 3466793976
commit b41bd20de4
1 changed files with 436 additions and 409 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

171
src/lib/sync.hpp
View file

@ -87,144 +87,179 @@ using boost::noncopyable;
namespace lib {
/** Helpers and building blocks for Monitor based synchronisation */
namespace sync {
namespace { // implementation shortcuts...
inline DiagnosticContext&
_accessContext()
{
return DiagnosticContext::access();
}
}
/* ========== adaptation layer for accessing the backend code ============== */
struct Wrapped_LumieraExcMutex
{
lumiera_mutex self;
lumiera_mutex self_;
protected:
Wrapped_LumieraExcMutex(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{ lumiera_mutex_init (&self, "Obj.Monitor ExclMutex", &NOBUG_FLAG(sync), ctx); }
Wrapped_LumieraExcMutex()
{ //TODO: currently passing no lineno/function info, put planning to use the DiagnosticContext to provide something in place of that later...
lumiera_mutex_init (&self_, "Obj.Monitor ExclMutex", &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
~Wrapped_LumieraExcMutex()
{ lumiera_mutex_destroy (&self, &NOBUG_FLAG(sync), NOBUG_CONTEXT); }
bool lock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{
return !!lumiera_mutex_lock (&self, &NOBUG_FLAG(sync), handle, ctx);
lumiera_mutex_destroy (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT);
}
void unlock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
lock()
{
lumiera_mutex_unlock (&self, &NOBUG_FLAG(sync), handle, ctx);
return !!lumiera_mutex_lock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
LumieraReccondition myreccond () {throw "bullshit"; return NULL;} // placeholder, brainstorm
void
unlock()
{
lumiera_mutex_unlock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
};
struct Wrapped_LumieraRecMutex
{
lumiera_recmutex self;
lumiera_recmutex self_;
protected:
Wrapped_LumieraRecMutex(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{ lumiera_recmutex_init (&self, "Obj.Monitor RecMutex", &NOBUG_FLAG(sync), ctx); }
Wrapped_LumieraRecMutex()
{
lumiera_recmutex_init (&self_, "Obj.Monitor RecMutex", &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
~Wrapped_LumieraRecMutex()
{ lumiera_recmutex_destroy (&self, &NOBUG_FLAG(sync), NOBUG_CONTEXT); }
bool lock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{
return !!lumiera_recmutex_lock (&self, &NOBUG_FLAG(sync), handle, ctx);
lumiera_recmutex_destroy (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT);
}
void unlock (struct nobug_resource_user** handle,
const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
lock()
{
lumiera_recmutex_unlock (&self, &NOBUG_FLAG(sync), handle, ctx);
return !!lumiera_recmutex_lock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
LumieraReccondition myreccond () {throw "bullshit"; return NULL;} // placeholder, brainstorm
void
unlock()
{
lumiera_recmutex_unlock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
};
struct Wrapped_LumieraExcCond
{
lumiera_condition self;
lumiera_condition self_;
protected:
Wrapped_LumieraExcCond(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{ lumiera_condition_init (&self, "Obj.Monitor ExclCondition", &NOBUG_FLAG(sync), ctx); }
Wrapped_LumieraExcCond()
{
lumiera_condition_init (&self_, "Obj.Monitor ExclCondition", &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
~Wrapped_LumieraExcCond()
{ lumiera_condition_destroy (&self, &NOBUG_FLAG(sync), NOBUG_CONTEXT); }
bool lock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{
return !!lumiera_condition_lock (&self, &NOBUG_FLAG(sync), handle, ctx);
lumiera_condition_destroy (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT);
}
bool wait (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
lock()
{
return !!lumiera_condition_wait (&self, &NOBUG_FLAG(sync), handle, ctx);
return !!lumiera_condition_lock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
bool timedwait (const struct timespec* timeout,
struct nobug_resource_user** handle,
const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
void
unlock()
{
return !!lumiera_condition_timedwait (&self, timeout, &NOBUG_FLAG(sync), handle, ctx);
lumiera_condition_unlock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
void signal(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
wait()
{
lumiera_condition_signal (&self, &NOBUG_FLAG(sync), ctx);
return !!lumiera_condition_wait (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
void broadcast(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
timedwait (const struct timespec* timeout)
{
lumiera_condition_broadcast (&self, &NOBUG_FLAG(sync), ctx);
return !!lumiera_condition_timedwait (&self_, timeout, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
void unlock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
void
signal()
{
lumiera_condition_unlock (&self, &NOBUG_FLAG(sync), handle, ctx);
lumiera_condition_signal (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
void
broadcast()
{
lumiera_condition_broadcast (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
};
struct Wrapped_LumieraRecCond
{
lumiera_reccondition self;
lumiera_reccondition self_;
protected:
Wrapped_LumieraRecCond(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{ lumiera_reccondition_init (&self, "Obj.Monitor RecCondition", &NOBUG_FLAG(sync), ctx); }
Wrapped_LumieraRecCond()
{
lumiera_reccondition_init (&self_, "Obj.Monitor RecCondition", &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
~Wrapped_LumieraRecCond()
{ lumiera_reccondition_destroy (&self, &NOBUG_FLAG(sync), NOBUG_CONTEXT); }
bool lock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
{
return !!lumiera_reccondition_lock (&self, &NOBUG_FLAG(sync), handle, ctx);
lumiera_reccondition_destroy (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT);
}
bool wait (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
lock()
{
return !!lumiera_reccondition_wait (&self, &NOBUG_FLAG(sync), handle, ctx);
return !!lumiera_reccondition_lock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
bool timedwait (const struct timespec* timeout,
struct nobug_resource_user** handle,
const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
void
unlock ()
{
return !!lumiera_reccondition_timedwait (&self, timeout, &NOBUG_FLAG(sync), handle, ctx);
lumiera_reccondition_unlock (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
void signal(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
wait()
{
lumiera_reccondition_signal (&self, &NOBUG_FLAG(sync), ctx);
return !!lumiera_reccondition_wait (&self_, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
void broadcast(const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
bool
timedwait (const struct timespec* timeout)
{
lumiera_reccondition_broadcast (&self, &NOBUG_FLAG(sync), ctx);
return !!lumiera_reccondition_timedwait (&self_, timeout, &NOBUG_FLAG(sync), _accessContext(), NOBUG_CONTEXT_NOFUNC);
}
void unlock (struct nobug_resource_user** handle, const struct nobug_context ctx = NOBUG_CONTEXT_NOFUNC)
void
signal()
{
lumiera_reccondition_unlock (&self, &NOBUG_FLAG(sync), handle, ctx);
lumiera_reccondition_signal (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
void
broadcast()
{
lumiera_reccondition_broadcast (&self_, &NOBUG_FLAG(sync), NOBUG_CONTEXT_NOFUNC);
}
};
@ -238,12 +273,6 @@ namespace lib {
: protected MTX
{
protected:
DiagnosticContext&
_usage()
{
return DiagnosticContext::access();
}
~Mutex () { }
Mutex () { }
Mutex (const Mutex&); ///< noncopyable...
@ -253,13 +282,13 @@ namespace lib {
void
acquire()
{
MTX::lock (_usage());
MTX::lock ();
}
void
release()
{
MTX::unlock (_usage());
MTX::unlock ();
}
};
@ -291,9 +320,9 @@ namespace lib {
bool ok = true;
while (ok && !predicate())
if (waitEndTime)
ok = CDX::timedwait (&waitEndTime, this->_usage());
ok = CDX::timedwait (&waitEndTime);
else
ok = CDX::wait (this->_usage());
ok = CDX::wait ();
if (!ok && lumiera_error_expect(LUMIERA_ERROR_LOCK_TIMEOUT)) return false;
lumiera::throwOnError(); // any other error thows
@ -508,8 +537,6 @@ namespace lib {
Monitor&
accessMonitor() { return mon_; }
};
};