inline void broadcast () const
{
if (ref_count > 0) {
int ret = gu_cond_broadcast (&cond);
if (gu_unlikely(ret != 0))
throw Exception("gu_cond_broadcast() failed", ret);
}
}
void gcs_fifo_lite_close (gcs_fifo_lite_t* fifo)
{
GCS_FIFO_LITE_LOCK;
if (fifo->closed) {
gu_error ("Trying to close a closed FIFO");
assert(0);
}
else {
fifo->closed = true;
// wake whoever is waiting
fifo->put_wait = 0;
gu_cond_broadcast (&fifo->put_cond);
fifo->get_wait = 0;
gu_cond_broadcast (&fifo->get_cond);
}
gu_mutex_unlock (&fifo->lock);
}
long gcs_fifo_lite_destroy (gcs_fifo_lite_t* f)
{
if (f) {
if (gu_mutex_lock (&f->lock)) { abort(); }
if (f->destroyed) {
gu_mutex_unlock (&f->lock);
return -EALREADY;
}
f->closed = true;
f->destroyed = true;
/* get rid of "put" threads waiting for lock or signal */
while (pthread_cond_destroy (&f->put_cond)) {
if (f->put_wait <= 0) {
gu_fatal ("Can't destroy condition while nobody's waiting");
abort();
}
f->put_wait = 0;
gu_cond_broadcast (&f->put_cond);
}
while (f->used) {
/* there are some items in FIFO - and that means
* no gcs_fifo_lite_safe_get() is waiting on condition */
gu_mutex_unlock (&f->lock);
/* let them get remaining items from FIFO,
* we don't know how to deallocate them ourselves.
* unfortunately this may take some time */
usleep (10000); /* sleep a bit to avoid busy loop */
gu_mutex_lock (&f->lock);
}
f->length = 0;
/* now all we have - "get" threads waiting for lock or signal */
while (pthread_cond_destroy (&f->get_cond)) {
if (f->get_wait <= 0) {
gu_fatal ("Can't destroy condition while nobody's waiting");
abort();
}
f->get_wait = 0;
gu_cond_broadcast (&f->get_cond);
}
/* at this point there are only functions waiting for lock */
gu_mutex_unlock (&f->lock);
while (gu_mutex_destroy (&f->lock)) {
/* this should be fast provided safe get and safe put are
* wtitten correctly. They should immediately freak out. */
gu_mutex_lock (&f->lock);
gu_mutex_unlock (&f->lock);
}
/* now nobody's waiting for anything */
gu_free (f->queue);
gu_free (f);
return 0;
}
return -EINVAL;
}
