polyphony 0.46.1 → 0.47.4

data/ext/polyphony/backend_io_uring.c

@@ -27,7 +27,6 @@ static int pidfd_open(pid_t pid, unsigned int flags) {
   return syscall(__NR_pidfd_open, pid, flags);
 }
 
-VALUE cTCPSocket;
 VALUE SYM_io_uring;
 
 typedef struct Backend_t {
@@ -171,7 +170,7 @@ void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *bac
     // otherwise, we mark it as completed, schedule the fiber and let it deal
     // with releasing the context
     ctx->completed = 1;
-    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, Qnil);
+    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, ctx->resume_value);
   }
 }
 
@@ -669,15 +668,16 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str) {
   return INT2NUM(len);
 }
 
-VALUE io_uring_backend_accept(Backend_t *backend, VALUE sock, int loop) {
+VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, int loop) {
   rb_io_t *fptr;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
   VALUE socket = Qnil;
-  if (underlying_sock != Qnil) sock = underlying_sock;
+  VALUE socket_class = ConnectionSocketClass(server_socket);
+  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
+  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
-  GetOpenFile(sock, fptr);
+  GetOpenFile(server_socket, fptr);
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_ACCEPT);
@@ -695,7 +695,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE sock, int loop) {
     else {
       rb_io_t *fp;
 
-      socket = rb_obj_alloc(cTCPSocket);
+      socket = rb_obj_alloc(socket_class);
       MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
@@ -774,15 +774,23 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   return self;
 }
 
-// returns true if completed, 0 otherwise
-int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
+inline struct __kernel_timespec double_to_timespec(double duration) {
   double duration_integral;
   double duration_fraction = modf(duration, &duration_integral);
   struct __kernel_timespec ts;
-
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   ts.tv_sec = duration_integral;
 	ts.tv_nsec = floor(duration_fraction * 1000000000);
+  return ts;
+}
+
+inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
+  return double_to_timespec(NUM2DBL(duration));
+}
+
+// returns true if completed, 0 otherwise
+int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
+  struct __kernel_timespec ts = double_to_timespec(duration);
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
   op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -830,6 +838,73 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   }
 }
 
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}
+
+struct Backend_timeout_ctx {
+  Backend_t *backend;
+  op_context_t *ctx;
+};
+
+VALUE Backend_timeout_ensure(VALUE arg) {
+    struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
+    if (!timeout_ctx->ctx->completed) {
+    timeout_ctx->ctx->result = -ECANCELED;
+
+    // op was not completed, so we need to cancel it
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&timeout_ctx->backend->ring);
+    io_uring_prep_cancel(sqe, timeout_ctx->ctx, 0);
+    timeout_ctx->backend->pending_sqes = 0;
+    io_uring_submit(&timeout_ctx->backend->ring);
+  }
+  OP_CONTEXT_RELEASE(&timeout_ctx->backend->store, timeout_ctx->ctx);
+  return Qnil;
+}
+
+VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
+  VALUE duration;
+  VALUE exception;
+  VALUE move_on_value = Qnil;
+  rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
+  
+  struct __kernel_timespec ts = duration_to_timespec(duration);
+  Backend_t *backend;
+  GetBackend(self, backend);
+  VALUE result = Qnil;
+  VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  
+  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  ctx->resume_value = timeout;
+  io_uring_prep_timeout(sqe, &ts, 0, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  io_uring_backend_defer_submit(backend);
+
+  struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
+  result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
+
+  if (result == timeout) {
+    if (exception == Qnil) return move_on_value;
+    RAISE_EXCEPTION(backend_timeout_exception(exception));
+  }
+
+  RAISE_IF_EXCEPTION(result);
+  RB_GC_GUARD(result);
+  RB_GC_GUARD(timeout);
+  return result;
+}
+
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
   Backend_t *backend;
   int pid_int = NUM2INT(pid);
@@ -870,8 +945,7 @@ VALUE Backend_kind(VALUE self) {
 }
 
 void Init_Backend() {
-  rb_require("socket");
-  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+  Init_SocketClasses();
 
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -899,6 +973,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
+  rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
 

data/ext/polyphony/backend_io_uring_context.c

@@ -42,6 +42,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
 
   ctx->type = type;
   ctx->fiber = rb_fiber_current();
+  ctx->resume_value = Qnil;
   ctx->completed = 0;
   ctx->result = 0;
 

data/ext/polyphony/backend_io_uring_context.h

@@ -24,6 +24,7 @@ typedef struct op_context {
   int               id;
   int               result;
   VALUE             fiber;
+  VALUE             resume_value;
 } op_context_t;
 
 typedef struct op_context_store {

data/ext/polyphony/backend_libev.c

@@ -13,7 +13,6 @@
 #include "../libev/ev.h"
 #include "ruby/io.h"
 
-VALUE cTCPSocket;
 VALUE SYM_libev;
 
 ID ID_ivar_is_nonblocking;
@@ -494,7 +493,7 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
     Backend_writev(self, argv[0], argc - 1, argv + 1);
 }
 
-VALUE Backend_accept(VALUE self, VALUE sock) {
+VALUE Backend_accept(VALUE self, VALUE server_socket) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
@@ -502,12 +501,13 @@ VALUE Backend_accept(VALUE self, VALUE sock) {
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
-  if (underlying_sock != Qnil) sock = underlying_sock;
+  VALUE socket_class = ConnectionSocketClass(server_socket);
+  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
+  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetBackend(self, backend);
-  GetOpenFile(sock, fptr);
-  io_set_nonblock(fptr, sock);
+  GetOpenFile(server_socket, fptr);
+  io_set_nonblock(fptr, server_socket);
   watcher.fiber = Qnil;
   while (1) {
     fd = accept(fptr->fd, &addr, &len);
@@ -529,7 +529,7 @@ VALUE Backend_accept(VALUE self, VALUE sock) {
         goto error;
       }
 
-      socket = rb_obj_alloc(cTCPSocket);
+      socket = rb_obj_alloc(socket_class);
       MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
@@ -550,7 +550,7 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE Backend_accept_loop(VALUE self, VALUE sock) {
+VALUE Backend_accept_loop(VALUE self, VALUE server_socket) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
@@ -559,12 +559,13 @@ VALUE Backend_accept_loop(VALUE self, VALUE sock) {
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
   VALUE socket = Qnil;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
-  if (underlying_sock != Qnil) sock = underlying_sock;
+  VALUE socket_class = ConnectionSocketClass(server_socket);
+  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
+  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetBackend(self, backend);
-  GetOpenFile(sock, fptr);
-  io_set_nonblock(fptr, sock);
+  GetOpenFile(server_socket, fptr);
+  io_set_nonblock(fptr, server_socket);
   watcher.fiber = Qnil;
 
   while (1) {
@@ -586,7 +587,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE sock) {
         goto error;
       }
 
-      socket = rb_obj_alloc(cTCPSocket);
+      socket = rb_obj_alloc(socket_class);
       MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
@@ -722,6 +723,72 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   }
 }
 
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}
+
+struct libev_timeout {
+  struct ev_timer timer;
+  VALUE fiber;
+  VALUE resume_value;
+};
+
+struct Backend_timeout_ctx {
+  Backend_t *backend;
+  struct libev_timeout *watcher;
+};
+
+VALUE Backend_timeout_ensure(VALUE arg) {
+  struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
+  ev_timer_stop(timeout_ctx->backend->ev_loop, &(timeout_ctx->watcher->timer));
+  return Qnil;
+}
+
+void Backend_timeout_callback(EV_P_ ev_timer *w, int revents)
+{
+  struct libev_timeout *watcher = (struct libev_timeout *)w;
+  Fiber_make_runnable(watcher->fiber, watcher->resume_value);
+}
+
+VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
+  VALUE duration;
+  VALUE exception;
+  VALUE move_on_value = Qnil;
+  rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
+
+  Backend_t *backend;
+  struct libev_timeout watcher;
+  VALUE result = Qnil;
+  VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
+
+  GetBackend(self, backend);
+  watcher.fiber = rb_fiber_current();
+  watcher.resume_value = timeout;
+  ev_timer_init(&watcher.timer, Backend_timeout_callback, NUM2DBL(duration), 0.);
+  ev_timer_start(backend->ev_loop, &watcher.timer);
+
+  struct Backend_timeout_ctx timeout_ctx = {backend, &watcher};
+  result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
+  
+  if (result == timeout) {
+    if (exception == Qnil) return move_on_value;
+    RAISE_EXCEPTION(backend_timeout_exception(exception));
+  }
+
+  RAISE_IF_EXCEPTION(result);
+  RB_GC_GUARD(result);
+  RB_GC_GUARD(timeout);
+  return result;
+}
+
 struct libev_child {
   struct ev_child child;
   VALUE fiber;
@@ -783,8 +850,7 @@ VALUE Backend_kind(VALUE self) {
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
-  rb_require("socket");
-  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+  Init_SocketClasses();
 
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -812,6 +878,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
+  rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
 

data/ext/polyphony/fiber.c

@@ -128,6 +128,15 @@ VALUE Fiber_receive(VALUE self) {
   return Queue_shift(mailbox);  
 }
 
+VALUE Fiber_mailbox(VALUE self) {
+  VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
+  if (mailbox == Qnil) {
+    mailbox = rb_funcall(cQueue, ID_new, 0);
+    rb_ivar_set(self, ID_ivar_mailbox, mailbox);
+  }
+  return mailbox;
+}
+
 VALUE Fiber_receive_all_pending(VALUE self) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   return (mailbox == Qnil) ? rb_ary_new() : Queue_shift_all(mailbox);
@@ -146,9 +155,9 @@ void Init_Fiber() {
 
   rb_define_method(cFiber, "<<", Fiber_send, 1);
   rb_define_method(cFiber, "send", Fiber_send, 1);
-
   rb_define_method(cFiber, "receive", Fiber_receive, 0);
   rb_define_method(cFiber, "receive_all_pending", Fiber_receive_all_pending, 0);
+  rb_define_method(cFiber, "mailbox", Fiber_mailbox, 0);
 
   SYM_dead = ID2SYM(rb_intern("dead"));
   SYM_running = ID2SYM(rb_intern("running"));

data/ext/polyphony/polyphony.c

@@ -1,6 +1,7 @@
 #include "polyphony.h"
 
 VALUE mPolyphony;
+VALUE cTimeoutException;
 
 ID ID_call;
 ID ID_caller;
@@ -55,6 +56,8 @@ void Init_Polyphony() {
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
 
+  cTimeoutException = rb_define_class_under(mPolyphony, "TimeoutException", rb_eException);
+
   ID_call           = rb_intern("call");
   ID_caller         = rb_intern("caller");
   ID_clear          = rb_intern("clear");

data/ext/polyphony/polyphony.h

@@ -39,6 +39,7 @@ extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
 extern VALUE cRunqueue;
+extern VALUE cTimeoutException;
 
 extern ID ID_call;
 extern ID ID_caller;
@@ -82,12 +83,6 @@ VALUE Queue_push(VALUE self, VALUE value);
 VALUE Queue_unshift(VALUE self, VALUE value);
 VALUE Queue_shift(VALUE self);
 VALUE Queue_shift_all(VALUE self);
-VALUE Queue_shift_no_wait(VALUE self);
-VALUE Queue_clear(VALUE self);
-VALUE Queue_delete(VALUE self, VALUE value);
-long Queue_len(VALUE self);
-void Queue_trace(VALUE self);
-
 
 void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule);
 void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule);
@@ -101,4 +96,6 @@ VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
 
+VALUE Polyphony_snooze(VALUE self);
+
 #endif /* POLYPHONY_H */

data/ext/polyphony/queue.c

@@ -4,6 +4,8 @@
 typedef struct queue {
   ring_buffer values;
   ring_buffer shift_queue;
+  ring_buffer push_queue;
+  unsigned int capacity;
 } Queue_t;
 
 VALUE cQueue = Qnil;
@@ -12,12 +14,14 @@ static void Queue_mark(void *ptr) {
   Queue_t *queue = ptr;
   ring_buffer_mark(&queue->values);
   ring_buffer_mark(&queue->shift_queue);
+  ring_buffer_mark(&queue->push_queue);
 }
 
 static void Queue_free(void *ptr) {
   Queue_t *queue = ptr;
   ring_buffer_free(&queue->values);
   ring_buffer_free(&queue->shift_queue);
+  ring_buffer_free(&queue->push_queue);
   xfree(ptr);
 }
 
@@ -41,36 +45,77 @@ static VALUE Queue_allocate(VALUE klass) {
 #define GetQueue(obj, queue) \
   TypedData_Get_Struct((obj), Queue_t, &Queue_type, (queue))
 
-static VALUE Queue_initialize(VALUE self) {
+static VALUE Queue_initialize(int argc, VALUE *argv, VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
   ring_buffer_init(&queue->values);
   ring_buffer_init(&queue->shift_queue);
+  ring_buffer_init(&queue->push_queue);
+  queue->capacity = (argc == 1) ?  NUM2UINT(argv[0]) : 0;
 
   return self;
 }
 
+inline void queue_resume_first_blocked_fiber(ring_buffer *queue) {
+  if (queue->count) {
+    VALUE fiber = ring_buffer_shift(queue);
+    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
+  }
+}
+
+inline void queue_resume_all_blocked_fibers(ring_buffer *queue) {
+  while (queue->count) {
+    VALUE fiber = ring_buffer_shift(queue);
+    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
+  }
+}
+
+inline void queue_resume_blocked_fibers_to_capacity(Queue_t *queue) {
+  for (unsigned int i = queue->values.count; (i < queue->capacity) && queue->push_queue.count; i++) {
+    VALUE fiber = ring_buffer_shift(&queue->push_queue);
+    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
+  }
+}
+
+inline void capped_queue_block_push(Queue_t *queue) {
+  VALUE fiber = rb_fiber_current();
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  VALUE switchpoint_result;
+  while (1) {
+    if (queue->capacity > queue->values.count) Fiber_make_runnable(fiber, Qnil);
+
+    ring_buffer_push(&queue->push_queue, fiber);
+    switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    ring_buffer_delete(&queue->push_queue, fiber);
+
+    RAISE_IF_EXCEPTION(switchpoint_result);
+    RB_GC_GUARD(switchpoint_result);
+    if (queue->capacity > queue->values.count) break;
+  }
+}
+
 VALUE Queue_push(VALUE self, VALUE value) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  if (queue->shift_queue.count > 0) {
-    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
-    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
-  }
+  if (queue->capacity) capped_queue_block_push(queue);
+
+  queue_resume_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_push(&queue->values, value);
+
   return self;
 }
 
 VALUE Queue_unshift(VALUE self, VALUE value) {
   Queue_t *queue;
   GetQueue(self, queue);
-  if (queue->shift_queue.count > 0) {
-    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
-    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
-  }
+
+  if (queue->capacity) capped_queue_block_push(queue);
+
+  queue_resume_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_unshift(&queue->values, value);
+
   return self;
 }
 
@@ -83,42 +128,63 @@ VALUE Queue_shift(VALUE self) {
   VALUE backend = rb_ivar_get(thread, ID_ivar_backend);
 
   while (1) {
-    ring_buffer_push(&queue->shift_queue, fiber);
-    if (queue->values.count > 0) Fiber_make_runnable(fiber, Qnil);
+    if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
+    ring_buffer_push(&queue->shift_queue, fiber);
     VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
     RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
-
-    if (queue->values.count > 0)
-      return ring_buffer_shift(&queue->values);
+    if (queue->values.count) break;
   }
-
-  return Qnil;
+  VALUE value = ring_buffer_shift(&queue->values);
+  if ((queue->capacity) && (queue->capacity > queue->values.count))
+    queue_resume_first_blocked_fiber(&queue->push_queue);
+  RB_GC_GUARD(value);
+  return value;
 }
 
-VALUE Queue_shift_no_wait(VALUE self) {
-    Queue_t *queue;
+VALUE Queue_delete(VALUE self, VALUE value) {
+  Queue_t *queue;
   GetQueue(self, queue);
 
-  return ring_buffer_shift(&queue->values);
+  ring_buffer_delete(&queue->values, value);
+
+  if (queue->capacity && (queue->capacity > queue->values.count))
+    queue_resume_first_blocked_fiber(&queue->push_queue);
+
+  return self;
 }
 
-VALUE Queue_delete(VALUE self, VALUE value) {
+VALUE Queue_cap(VALUE self, VALUE cap) {
+  unsigned int new_capacity = NUM2UINT(cap);
   Queue_t *queue;
   GetQueue(self, queue);
-
-  ring_buffer_delete(&queue->values, value);
+  queue->capacity = new_capacity;
+  
+  if (queue->capacity)
+    queue_resume_blocked_fibers_to_capacity(queue);
+  else
+    queue_resume_all_blocked_fibers(&queue->push_queue);
+  
   return self;
 }
 
+VALUE Queue_capped_p(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->capacity ? UINT2NUM(queue->capacity) : Qnil;
+}
+
 VALUE Queue_clear(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
   ring_buffer_clear(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+
   return self;
 }
 
@@ -134,6 +200,7 @@ VALUE Queue_shift_each(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_shift_each(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
   return self;
 }
 
@@ -141,7 +208,9 @@ VALUE Queue_shift_all(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return ring_buffer_shift_all(&queue->values);
+  VALUE result = ring_buffer_shift_all(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  return result;
 }
 
 VALUE Queue_flush_waiters(VALUE self, VALUE value) {
@@ -160,14 +229,14 @@ VALUE Queue_empty_p(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return (queue->values.count == 0) ? Qtrue : Qfalse;
+  return (!queue->values.count) ? Qtrue : Qfalse;
 }
 
 VALUE Queue_pending_p(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return (queue->shift_queue.count > 0) ? Qtrue : Qfalse;
+  return (queue->shift_queue.count) ? Qtrue : Qfalse;
 }
 
 VALUE Queue_size_m(VALUE self) {
@@ -177,26 +246,22 @@ VALUE Queue_size_m(VALUE self) {
   return INT2NUM(queue->values.count);
 }
 
-void Queue_trace(VALUE self) {
-  Queue_t *queue;
-  GetQueue(self, queue);
-
-  printf("run queue size: %d count: %d\n", queue->values.size, queue->values.count);
-}
-
 void Init_Queue() {
   cQueue = rb_define_class_under(mPolyphony, "Queue", rb_cData);
   rb_define_alloc_func(cQueue, Queue_allocate);
 
-  rb_define_method(cQueue, "initialize", Queue_initialize, 0);
+  rb_define_method(cQueue, "initialize", Queue_initialize, -1);
   rb_define_method(cQueue, "push", Queue_push, 1);
   rb_define_method(cQueue, "<<", Queue_push, 1);
   rb_define_method(cQueue, "unshift", Queue_unshift, 1);
 
   rb_define_method(cQueue, "shift", Queue_shift, 0);
   rb_define_method(cQueue, "pop", Queue_shift, 0);
-  rb_define_method(cQueue, "shift_no_wait", Queue_shift_no_wait, 0);
   rb_define_method(cQueue, "delete", Queue_delete, 1);
+  rb_define_method(cQueue, "clear", Queue_clear, 0);
+
+  rb_define_method(cQueue, "cap", Queue_cap, 1);
+  rb_define_method(cQueue, "capped?", Queue_capped_p, 0);
 
   rb_define_method(cQueue, "shift_each", Queue_shift_each, 0);
   rb_define_method(cQueue, "shift_all", Queue_shift_all, 0);