/* Non-blocking operation. Returns {0, 0} if queue is empty */
struct packet_buffer queue_pop(struct queue *q) {
int success = uv_sem_trywait(&q->fill_count);
if (success != 0) {
return (struct packet_buffer){.payload_len = 0, .payload = NULL};
}
struct packet_buffer result = q->buf[q->head];
q->head = (q->head + 1) % QUEUE_CAP;
uv_sem_post(&q->empty_count);
return result;
}
/* Non-blocking operation. Returns -1 if queue is full */
int queue_push(struct queue *q, struct packet_buffer b) {
int success = uv_sem_trywait(&q->empty_count);
if (success != 0) {
return -1;
}
q->buf[q->tail] = b;
q->tail = (q->tail + 1) % QUEUE_CAP;
uv_sem_post(&q->fill_count);
return 0;
}
void uv__stream_osx_select(void* arg) {
uv_stream_t* stream;
uv__stream_select_t* s;
fd_set read;
fd_set write;
fd_set error;
struct timeval timeout;
int events;
int fd;
int r;
stream = arg;
s = stream->select;
fd = stream->fd;
while (1) {
/* Terminate on semaphore */
if (uv_sem_trywait(&s->sem) == 0) break;
/* Watch fd using select(2) */
FD_ZERO(&read);
FD_ZERO(&write);
FD_ZERO(&error);
FD_SET(fd, &read);
FD_SET(fd, &write);
FD_SET(fd, &error);
timeout.tv_sec = 0;
timeout.tv_usec = 250000; /* 250 ms timeout */
r = select(fd + 1, &read, &write, &error, &timeout);
if (r == -1) {
if (errno == EINTR) continue;
/* XXX: Possible?! */
abort();
}
/* Ignore timeouts */
if (r == 0) continue;
/* Handle events */
events = 0;
if (FD_ISSET(fd, &read)) events |= UV__IO_READ;
if (FD_ISSET(fd, &write)) events |= UV__IO_WRITE;
if (FD_ISSET(fd, &error)) events |= UV__IO_ERROR;
uv_mutex_lock(&s->mutex);
s->events |= events;
uv_mutex_unlock(&s->mutex);
if (events != 0) uv_async_send(&s->async);
}
}
static PyObject *
Semaphore_func_trywait(Semaphore *self)
{
int r;
RAISE_IF_NOT_INITIALIZED(self, NULL);
Py_BEGIN_ALLOW_THREADS
r = uv_sem_trywait(&self->uv_semaphore);
Py_END_ALLOW_THREADS
return PyBool_FromLong((long)(r == 0));
}
static mrb_value
mrb_uv_sem_trywait(mrb_state *mrb, mrb_value self)
{
int err;
uv_sem_t *sem = (uv_sem_t*)mrb_uv_get_ptr(mrb, self, &sem_type);
err = uv_sem_trywait(sem);
if(err == UV_EAGAIN) {
return mrb_false_value();
}
if(err < 0) {
mrb_uv_check_error(mrb, err);
}
return mrb_true_value();
}
static void fib(uv_work_t *req) {
struct threadpool_data_t *data = req->data;
data->func(data->reason, data->userdata);
int x = 0;
if(data->ref != NULL) {
x = uv_sem_trywait(data->ref);
}
if((data->ref == NULL) || (x == UV__EAGAIN)) {
if(data->done != NULL && data->reason != REASON_END) {
data->done(data->userdata);
}
if(data->ref != NULL) {
FREE(data->ref);
}
}
// FREE(req->data);
}
static void uv__stream_osx_select(void* arg) {
uv_stream_t* stream;
uv__stream_select_t* s;
char buf[1024];
int events;
int fd;
int r;
int max_fd;
stream = arg;
s = stream->select;
fd = s->fd;
if (fd > s->int_fd)
max_fd = fd;
else
max_fd = s->int_fd;
while (1) {
/* Terminate on semaphore */
if (uv_sem_trywait(&s->close_sem) == 0)
break;
/* Watch fd using select(2) */
memset(s->sread, 0, s->sread_sz);
memset(s->swrite, 0, s->swrite_sz);
if (uv__io_active(&stream->io_watcher, POLLIN))
FD_SET(fd, s->sread);
if (uv__io_active(&stream->io_watcher, POLLOUT))
FD_SET(fd, s->swrite);
FD_SET(s->int_fd, s->sread);
/* Wait indefinitely for fd events */
r = select(max_fd + 1, s->sread, s->swrite, NULL, NULL);
if (r == -1) {
if (errno == EINTR)
continue;
/* XXX: Possible?! */
abort();
}
/* Ignore timeouts */
if (r == 0)
continue;
/* Empty socketpair's buffer in case of interruption */
if (FD_ISSET(s->int_fd, s->sread))
while (1) {
r = read(s->int_fd, buf, sizeof(buf));
if (r == sizeof(buf))
continue;
if (r != -1)
break;
if (errno == EAGAIN || errno == EWOULDBLOCK)
break;
if (errno == EINTR)
continue;
abort();
}
/* Handle events */
events = 0;
if (FD_ISSET(fd, s->sread))
events |= POLLIN;
if (FD_ISSET(fd, s->swrite))
events |= POLLOUT;
assert(events != 0 || FD_ISSET(s->int_fd, s->sread));
if (events != 0) {
ACCESS_ONCE(int, s->events) = events;
uv_async_send(&s->async);
uv_sem_wait(&s->async_sem);
/* Should be processed at this stage */
assert((s->events == 0) || (stream->flags & UV_CLOSING));
}
}
bool Semaphore::trywait()
{
int r = uv_sem_trywait(&sem);
return r == 0;
}
void uv__stream_osx_select(void* arg) {
uv_stream_t* stream;
uv__stream_select_t* s;
char buf[1024];
fd_set sread;
fd_set swrite;
fd_set serror;
int events;
int fd;
int r;
int max_fd;
stream = arg;
s = stream->select;
fd = stream->io_watcher.fd;
if (fd > s->int_fd)
max_fd = fd;
else
max_fd = s->int_fd;
while (1) {
/* Terminate on semaphore */
if (uv_sem_trywait(&s->sem) == 0)
break;
/* Watch fd using select(2) */
FD_ZERO(&sread);
FD_ZERO(&swrite);
FD_ZERO(&serror);
if (uv_is_readable(stream))
FD_SET(fd, &sread);
if (uv_is_writable(stream))
FD_SET(fd, &swrite);
FD_SET(fd, &serror);
FD_SET(s->int_fd, &sread);
/* Wait indefinitely for fd events */
r = select(max_fd + 1, &sread, &swrite, &serror, NULL);
if (r == -1) {
if (errno == EINTR)
continue;
/* XXX: Possible?! */
abort();
}
/* Ignore timeouts */
if (r == 0)
continue;
/* Empty socketpair's buffer in case of interruption */
if (FD_ISSET(s->int_fd, &sread))
while (1) {
r = read(s->int_fd, buf, sizeof(buf));
if (r == sizeof(buf))
continue;
if (r != -1)
break;
if (errno == EAGAIN || errno == EWOULDBLOCK)
break;
if (errno == EINTR)
continue;
abort();
}
/* Handle events */
events = 0;
if (FD_ISSET(fd, &sread))
events |= UV__POLLIN;
if (FD_ISSET(fd, &swrite))
events |= UV__POLLOUT;
if (FD_ISSET(fd, &serror))
events |= UV__POLLERR;
uv_mutex_lock(&s->mutex);
s->events |= events;
uv_mutex_unlock(&s->mutex);
if (events != 0)
uv_async_send(&s->async);
}
}
