pthread_cond_timedwait
pthread_rwlock_timedrdlock
sem_timedwait
mq_timedreceive

?
Bzw. anders rum, habt ihr schonmal (z.B. unter Windows) geflucht weil es keine absoluten Timeouts gibt, und ihr drumrum stricken musstet?

Wenn ja bitte mit Beispiel, also wozu und warum das absolute Timeout verwendet wurde. Es geht einfach darum dass ich an einer Library arbeite, und dort Timeouts brauche. Und ich sehe keinen vernünftigen Grund absolute Timeouts zu implementieren ... deswegen frage ich ob ihr vielleicht einen seht. Sozusagen.

Die Sache mit dem Neuberechnen von relativen Timeouts (in Funktionen die z.B. Schleifen benötigen) ist - innerhalb und ausserhalb der Library - kein Problem, also bitte keine Beispiele ala "absolutes Timeout ist gut weil man das nicht neu berechnen muss"

EDIT: freue mich auch allgemein über Kommentare zu dem Thema.

Wäre aber cool wenns das auch mit dem monotonischen Zeitgeber gäbe. (POSIX Realtime Extensions, Linux hats, OS X nicht, Windows hat etwas ähnliches)

Mein Design sieht derzeit folgende Klasse für Timeouts vor:

namespace xyz
{

typedef uint64_t timeout_t;

#define XYZ_NO_THROW throw()

class XYZ_EXPORT abstract_timeout_clock
{
public:
	static timeout_t const max_wait_duration = timeout_t(1) << 30;

	virtual timeout_t get_remaining_msec() const = 0;
	virtual timeout_t get_wait_duration_msec(timeout_t limit = max_wait_duration) const = 0;
};

//---------------------------------------------------------------------
// a monotonic microsecond clock, used for relative timeouts

class XYZ_EXPORT timeout_clock : public abstract_timeout_clock // final
{
public:
	explicit timeout_clock(timeout_t msec) XYZ_NO_THROW;

	void update() const XYZ_NO_THROW;
	void reset(timeout_t msec) XYZ_NO_THROW;

	virtual timeout_t get_remaining_msec() const XYZ_NO_THROW;
	virtual timeout_t get_wait_duration_msec(timeout_t limit = max_wait_duration) const XYZ_NO_THROW;

	void wait() const XYZ_NO_THROW;

private:
	// ...
};

//---------------------------------------------------------------------
// an "infinite timeout" clock

class XYZ_EXPORT infinite_timeout : public abstract_timeout_clock // final
{
    // ...
};

} // namespace xyz

Diverse Funktionen, wie z.B. scoped_lock::timed_lock oder mutex::timed_lock nehmen als Parameter dann ein "abstract_timeout_clock const&".

Die Verwendung sieht für den Client dann ca. so aus:

void foo::bar()
{
    xyz::scoped_lock<xyz::mutex> lock(m_mutex, false); // don't lock now
    if (lock.timed_lock(xyz::timeout_clock(1000)))
    {
        // ...
    }
}

bzw.

void foo::bar()
{
    xyz::scoped_lock<xyz::mutex> lock(m_mutex, xyz::timeout_clock(1000)); 
    if (lock.is_locked())
    {
        // ...
    }
}

----

Unter Windows verwende ich für die timeout_clock ::GetTickCount(), unter *NIX werde ich wohl clock_gettime(CLOCK_MONOTONIC, &timespec_) verwenden. Auf jeden Fall einen "monotonischen Zeitgeber" wie du das nennst.

Die Frage ist nur ob es notwändig ist/sinnvoll wäre zusätzlich absolute Timeouts zu unterstützen (die dann auf der nicht-sehr-monotonischen System-Time basieren). Ich sehe dafür wie gesagt keine Verwendung. Also ich wüsste nicht warum ich jemals ein timed_lock/timed_wait/timed_xxx irgendwo brauchen würde mit einem absoluten "Timeout Datum".

Und "einfach beides unterstützen" ist auch leider nicht einfach genug als dass ich mir die Arbeit antun würde wenns nicht wirklich Sinn macht.

clock_gettime(CLOCK_MONOTONIC, &timespec_) ist toll, funktioniert aber unter OS X nicht.

Im nächsten Schritt kommt dann Linux, und später wahrscheinlich BSD & Solaris -- ggf. noch andere, mal sehen.

BTW: wenn du ne gute Seite weisst mit ner API Reference für OS X wäre ich auch dankbar

p.S.: gibt's die Funktion in OS X: http://felinemenace.org/~nemo/mach/manpages/clock_get_time.html ?
Die müsste reichen...

Linux ist eh viel wichtiger.