uringmachine 0.3 → 0.5

data/ext/um/um.h

@@ -20,38 +20,64 @@
 #define likely(cond)	__builtin_expect(!!(cond), 1)
 #endif
 
-enum op_state {
-  OP_initial,     // initial state
-  OP_submitted,   // op has been submitted (SQE prepared)
-  OP_completed,   // op has been completed (CQE processed)
-  OP_cancelled,   // op is cancelled (after CQE is processed)
-  OP_abandonned,  // op is abandonned by fiber (before CQE is processed)
-  OP_schedule,    // the corresponding fiber is scheduled
+enum op_kind {
+  OP_TIMEOUT,
+  OP_SCHEDULE,
+
+  OP_SLEEP,
+  OP_READ,
+  OP_WRITE,
+  OP_CLOSE,
+  OP_ACCEPT,
+  OP_RECV,
+  OP_SEND,
+  OP_SOCKET,
+  OP_CONNECT,
+  OP_BIND,
+  OP_LISTEN,
+  OP_GETSOCKOPT,
+  OP_SETSOCKOPT,
+
+  OP_FUTEX_WAIT,
+  OP_FUTEX_WAKE,
+
+  OP_ACCEPT_MULTISHOT,
+  OP_READ_MULTISHOT,
+  OP_RECV_MULTISHOT
 };
 
-struct um_result_entry {
-  struct um_result_entry *next;
+#define OP_F_COMPLETED        (1U << 0)
+#define OP_F_TRANSIENT        (1U << 1)
+#define OP_F_IGNORE_CANCELED  (1U << 2)
+#define OP_F_MULTISHOT        (1U << 3)
 
-  int result;
-  int flags;
+struct um_op_result {
+  __s32 res;
+  __u32 flags;
+  struct um_op_result *next;
 };
 
 struct um_op {
-  enum op_state state;
   struct um_op *prev;
   struct um_op *next;
 
-  // linked list for multishot results
-  struct um_result_entry *results_head;
-  struct um_result_entry *results_tail;
-  
+  enum op_kind kind;
+  unsigned flags;
+
   VALUE fiber;
-  VALUE resume_value;
-  int is_multishot;
-  struct __kernel_timespec ts;
-  
-  int cqe_result;
-  int cqe_flags;
+  VALUE value;
+
+  struct um_op_result result;
+  struct um_op_result *multishot_result_tail;
+  unsigned multishot_result_count;
+
+  struct __kernel_timespec ts; // used for timeout operation
+};
+
+struct um_buffer {
+  struct um_buffer *next;
+  void *ptr;
+  long len;
 };
 
 struct buf_ring_descriptor {
@@ -59,17 +85,17 @@ struct buf_ring_descriptor {
   size_t br_size;
   unsigned buf_count;
   unsigned buf_size;
-	char *buf_base;
+  unsigned buf_mask;
+	void *buf_base;
 };
 
 #define BUFFER_RING_MAX_COUNT 10
 
 struct um {
-  struct um_op *op_freelist;
-  struct um_result_entry *result_freelist;
+  VALUE self;
+  VALUE poll_fiber;
 
-  struct um_op *runqueue_head;
-  struct um_op *runqueue_tail;
+  struct um_buffer *buffer_freelist;
 
   struct io_uring ring;
 
@@ -79,47 +105,123 @@ struct um {
 
   struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
   unsigned int buffer_ring_count;
+
+  struct um_op *transient_head;
+  struct um_op *runqueue_head;
+  struct um_op *runqueue_tail;
+
+  struct um_op *op_freelist;
+  struct um_op_result *result_freelist;
+};
+
+struct um_mutex {
+  VALUE self;
+  uint32_t state;
+};
+
+struct um_queue_entry {
+  struct um_queue_entry *prev;
+  struct um_queue_entry *next;
+  VALUE value;
+};
+
+struct um_queue {
+  VALUE self;
+
+  struct um_queue_entry *head;
+  struct um_queue_entry *tail;
+  struct um_queue_entry *free_head;
+  
+  uint32_t num_waiters;
+  uint32_t state;
+  uint32_t count;
 };
 
 extern VALUE cUM;
+extern VALUE cMutex;
+extern VALUE cQueue;
 
-void um_setup(struct um *machine);
+void um_setup(VALUE self, struct um *machine);
 void um_teardown(struct um *machine);
-void um_free_op_linked_list(struct um *machine, struct um_op *op);
-void um_free_result_linked_list(struct um *machine, struct um_result_entry *entry);
+
+struct um_op *um_op_alloc(struct um *machine);
+void um_op_free(struct um *machine, struct um_op *op);
+void um_op_clear(struct um *machine, struct um_op *op);
+void um_op_transient_add(struct um *machine, struct um_op *op);
+void um_op_transient_remove(struct um *machine, struct um_op *op);
+void um_op_list_mark(struct um *machine, struct um_op *head);
+void um_op_list_compact(struct um *machine, struct um_op *head);
+
+void um_op_multishot_results_push(struct um *machine, struct um_op *op, __s32 res, __u32 flags);
+void um_op_multishot_results_clear(struct um *machine, struct um_op *op);
+
+void um_runqueue_push(struct um *machine, struct um_op *op);
+struct um_op *um_runqueue_shift(struct um *machine);
+
+struct um_buffer *um_buffer_checkout(struct um *machine, int len);
+void um_buffer_checkin(struct um *machine, struct um_buffer *buffer);
+void um_free_buffer_linked_list(struct um *machine);
 
 struct __kernel_timespec um_double_to_timespec(double value);
 int um_value_is_exception_p(VALUE v);
 VALUE um_raise_exception(VALUE v);
-void um_raise_on_system_error(int result);
 
+#define raise_if_exception(v) (um_value_is_exception_p(v) ? um_raise_exception(v) : v)
+
+void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind);
+void um_raise_on_error_result(int result);
 void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs);
-void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, int result, int flags);
-VALUE get_string_from_buffer_ring(struct um *machine, int bgid, int result, int flags);
+void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags);
+int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
+VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags);
+
+struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
+void um_cancel_and_wait(struct um *machine, struct um_op *op);
+int um_check_completion(struct um *machine, struct um_op *op);
 
-void um_op_checkin(struct um *machine, struct um_op *op);
-struct um_op* um_op_checkout(struct um *machine);
-void um_op_result_push(struct um *machine, struct um_op *op, int result, int flags);
-int um_op_result_shift(struct um *machine, struct um_op *op, int *result, int *flags);
-
-struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber);
-void um_runqueue_push(struct um *machine, struct um_op *op);
-struct um_op *um_runqueue_shift(struct um *machine);
-void um_runqueue_unshift(struct um *machine, struct um_op *op);
+#define um_op_completed_p(op) ((op)->flags & OP_F_COMPLETED)
 
 void um_schedule(struct um *machine, VALUE fiber, VALUE value);
-void um_interrupt(struct um *machine, VALUE fiber, VALUE value);
 VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
 
 VALUE um_sleep(struct um *machine, double duration);
 VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
-VALUE um_write(struct um *machine, int fd, VALUE buffer, int len);
+VALUE um_write(struct um *machine, int fd, VALUE str, int len);
+VALUE um_close(struct um *machine, int fd);
+VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode);
+VALUE um_waitpid(struct um *machine, int pid, int options);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
+VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags);
+VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen);
+VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags);
+VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags);
+VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags);
+VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen);
+VALUE um_listen(struct um *machine, int fd, int backlog);
+VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);
+VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value);
+
+struct um_mutex *Mutex_data(VALUE self);
+struct um_queue *Queue_data(VALUE self);
+
+void um_mutex_init(struct um_mutex *mutex);
+VALUE um_mutex_synchronize(struct um *machine, uint32_t *state);
+
+void um_queue_init(struct um_queue *queue);
+void um_queue_free(struct um_queue *queue);
+void um_queue_mark(struct um_queue *queue);
+void um_queue_compact(struct um_queue *queue);
+VALUE um_queue_push(struct um *machine, struct um_queue *queue, VALUE value);
+VALUE um_queue_pop(struct um *machine, struct um_queue *queue);
+VALUE um_queue_unshift(struct um *machine, struct um_queue *queue, VALUE value);
+VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
+
+void um_define_net_constants(VALUE mod);
 
 #endif // UM_H

data/ext/um/um_buffer.c

@@ -0,0 +1,49 @@
+#include "um.h"
+
+inline long buffer_size(long len) {
+  len--;
+  len |= len >> 1;
+  len |= len >> 2;
+  len |= len >> 4;
+  len |= len >> 8;
+  len |= len >> 16;
+  len++;
+  return (len > 4096) ? len : 4096;
+}
+
+inline struct um_buffer *um_buffer_checkout(struct um *machine, int len) {
+  struct um_buffer *buffer = machine->buffer_freelist;
+  if (buffer)
+    machine->buffer_freelist = buffer->next;
+  else {
+    buffer = malloc(sizeof(struct um_buffer));
+    memset(buffer, 0, sizeof(struct um_buffer));
+  }
+
+  if (buffer->len < len) {
+    if (buffer->ptr) {
+      free(buffer->ptr);
+      buffer->ptr = NULL;
+    }
+
+    buffer->len = buffer_size(len);
+    if (posix_memalign(&buffer->ptr, 4096, buffer->len))
+      rb_raise(rb_eRuntimeError, "Failed to allocate buffer");
+  }
+  return buffer;
+}
+
+inline void um_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
+  buffer->next = machine->buffer_freelist;
+  machine->buffer_freelist = buffer;
+}
+
+inline void um_free_buffer_linked_list(struct um *machine) {
+  struct um_buffer *buffer = machine->buffer_freelist;
+  while (buffer) {
+    struct um_buffer *next = buffer->next;
+    if (buffer->ptr) free(buffer->ptr);
+    free(buffer);
+    buffer = next;
+  }
+}