uringmachine 0.24.0 → 0.26.0

data/ext/um/um.h

@@ -73,20 +73,31 @@ enum um_op_kind {
   OP_READ_MULTISHOT,
   OP_RECV_MULTISHOT,
   OP_TIMEOUT_MULTISHOT,
-  OP_SLEEP_MULTISHOT
 };
 
-#define OP_F_COMPLETED        (1U <<  0) // op is completed (set on each CQE for multishot ops)
-#define OP_F_TRANSIENT        (1U <<  1) // op is heap allocated
-#define OP_F_ASYNC            (1U <<  2) // op belongs to an AsyncOp
-#define OP_F_CANCELED         (1U <<  3) // op is cancelled
-#define OP_F_IGNORE_CANCELED  (1U <<  4) // CQE with -ECANCEL should be ignored
-#define OP_F_MULTISHOT        (1U <<  5) // op is multishot
-#define OP_F_FREE_ON_COMPLETE (1U <<  6) // op should be freed on receiving CQE
-#define OP_F_RUNQUEUE_SKIP    (1U <<  7) // runqueue entry should be skipped
-#define OP_F_SELECT_POLLIN    (1U <<  8) // select POLLIN
-#define OP_F_SELECT_POLLOUT   (1U <<  9) // select POLLOUT
-#define OP_F_SELECT_POLLPRI   (1U << 10) // select POLLPRI
+
+#define OP_F_CQE_SEEN       (1U << 0) // CQE has been seen
+#define OP_F_CQE_DONE       (1U << 1) // CQE has been seen and operation is done
+#define OP_F_SCHEDULED      (1U << 2) // op is on runqueue
+#define OP_F_CANCELED       (1U << 3) // op is cancelled (disregard CQE results)
+#define OP_F_MULTISHOT      (1U << 4) // op is multishot
+#define OP_F_ASYNC          (1U << 5) // op is async (no fiber is scheduled to be resumed on completion)
+#define OP_F_TRANSIENT      (1U << 6) // op is on transient list (for GC purposes)
+#define OP_F_FREE_IOVECS    (1U << 7) // op->iovecs should be freed on release
+#define OP_F_SKIP           (1U << 8) // op should be skipped when pulled from runqueue
+
+#define OP_F_SELECT_POLLIN  (1U << 13) // select POLLIN
+#define OP_F_SELECT_POLLOUT (1U << 14) // select POLLOUT
+#define OP_F_SELECT_POLLPRI (1U << 15) // select POLLPRI
+
+#define OP_CQE_SEEN_P(op)   ((op)->flags & OP_F_CQE_SEEN)
+#define OP_CQE_DONE_P(op)   ((op)->flags & OP_F_CQE_DONE)
+#define OP_SCHEDULED_P(op)  ((op)->flags & OP_F_SCHEDULED)
+#define OP_CANCELED_P(op)   ((op)->flags & OP_F_CANCELED)
+#define OP_MULTISHOT_P(op)  ((op)->flags & OP_F_MULTISHOT)
+#define OP_ASYNC_P(op)      ((op)->flags & OP_F_ASYNC)
+#define OP_TRANSIENT_P(op)  ((op)->flags & OP_F_TRANSIENT)
+#define OP_SKIP_P(op)       ((op)->flags & OP_F_SKIP)
 
 struct um_op_result {
   __s32 res;
@@ -100,6 +111,7 @@ struct um_op {
 
   enum um_op_kind kind;
   uint flags;
+  uint ref_count;
 
   VALUE fiber;
   VALUE value;
@@ -109,7 +121,12 @@ struct um_op {
   struct um_op_result *multishot_result_tail;
   uint multishot_result_count;
 
-  struct __kernel_timespec ts; // used for timeout operation
+	union {
+    struct __kernel_timespec ts; // used for timeout operation
+    struct iovec *iovecs; // used for vectorized write/send
+    siginfo_t siginfo; // used for waitid
+    int int_value; // used for getsockopt
+  };
 };
 
 struct um_buffer {
@@ -170,7 +187,7 @@ struct um {
   struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
 
   struct um_op *transient_head; // list of pending transient ops
-  VALUE pending_fibers; // hash containing pending fibers
+  VALUE pending_fibers; // set containing pending fibers
 
   struct um_op *runqueue_head;
   struct um_op *runqueue_tail;
@@ -237,8 +254,12 @@ void um_teardown(struct um *machine);
 VALUE um_metrics(struct um *machine, struct um_metrics *metrics);
 
 const char * um_op_kind_name(enum um_op_kind kind);
-struct um_op *um_op_alloc(struct um *machine);
-void um_op_free(struct um *machine, struct um_op *op);
+
+struct um_op *um_op_acquire(struct um *machine);
+void um_op_release(struct um *machine, struct um_op *op);
+
+// 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);
@@ -264,11 +285,11 @@ VALUE um_raise_exception(VALUE v);
 
 #define RAISE_IF_EXCEPTION(v) if (unlikely(um_value_is_exception_p(v))) { um_raise_exception(v); }
 
-void um_prep_op(struct um *machine, struct um_op *op, enum um_op_kind kind, unsigned flags);
+void um_prep_op(struct um *machine, struct um_op *op, enum um_op_kind kind, uint ref_count, unsigned flags);
 void um_raise_on_error_result(int result);
-void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size);
+int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size, int raise_on_bad_buffer);
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
-void um_update_read_buffer(struct um *machine, VALUE buffer, ssize_t buffer_offset, __s32 result, __u32 flags);
+void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 result);
 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);
 void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
@@ -283,10 +304,9 @@ VALUE um_yield(struct um *machine);
 VALUE um_switch(struct um *machine);
 VALUE um_wakeup(struct um *machine);
 void um_cancel_op(struct um *machine, struct um_op *op);
-void um_cancel_and_wait(struct um *machine, struct um_op *op);
-int um_check_completion(struct um *machine, struct um_op *op);
-
-#define um_op_completed_p(op) ((op)->flags & OP_F_COMPLETED)
+void um_cancel_op_and_discard_cqe(struct um *machine, struct um_op *op);
+void um_cancel_op_and_await_cqe(struct um *machine, struct um_op *op);
+int um_verify_op_completion(struct um *machine, struct um_op *op, int await_cancelled);
 
 void um_schedule(struct um *machine, VALUE fiber, VALUE value);
 VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
@@ -297,6 +317,7 @@ VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t b
 size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
 VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
+size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t maxlen);
 VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv);
 VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 VALUE um_close(struct um *machine, int fd);
@@ -368,4 +389,8 @@ void um_sidecar_teardown(struct um *machine);
 void um_sidecar_signal_wait(struct um *machine);
 void um_sidecar_signal_wake(struct um *machine);
 
+void um_ssl_set_bio(struct um *machine, VALUE ssl_obj);
+int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, int maxlen);
+int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, int len);
+
 #endif // UM_H

data/ext/um/um_async_op.c

@@ -5,11 +5,11 @@ VALUE um_prep_timeout(struct um *machine, double interval) {
   static ID ID_new = 0;
   if (!ID_new) ID_new = rb_intern("new");
 
-  struct um_op *op = malloc(sizeof(struct um_op));
-  um_prep_op(machine, op, OP_TIMEOUT, OP_F_TRANSIENT | OP_F_ASYNC);
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_TIMEOUT, 2, OP_F_ASYNC | OP_F_TRANSIENT);
   op->ts = um_double_to_timespec(interval);
 
-  VALUE obj = rb_funcall(cAsyncOp, rb_intern_const("new"), 0);
+  VALUE obj = rb_funcall(cAsyncOp, ID_new, 0);
   um_async_op_set(obj, machine, op);
 
   RB_OBJ_WRITE(machine->self, &op->async_op, obj);
@@ -17,18 +17,19 @@ VALUE um_prep_timeout(struct um *machine, double interval) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_timeout(sqe, &op->ts, 0, 0);
 
-  um_op_transient_add(machine, op);
-
   return obj;
 }
 
 VALUE um_async_op_await(struct um_async_op *async_op) {
+  if (OP_CQE_DONE_P(async_op->op)) return async_op->op->value;
+
   RB_OBJ_WRITE(async_op->machine->self, &async_op->op->fiber, rb_fiber_current());
-  async_op->op->flags &= ~OP_F_ASYNC;
+  um_op_transient_remove(async_op->machine, async_op->op);
+  async_op->op->flags &= ~(OP_F_ASYNC | OP_F_TRANSIENT);
 
   VALUE ret = um_switch(async_op->machine);
-  if (!um_op_completed_p(async_op->op))
-    um_cancel_and_wait(async_op->machine, async_op->op);
+
+  um_verify_op_completion(async_op->machine, async_op->op, true);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);

data/ext/um/um_async_op_class.c

@@ -1,6 +1,13 @@
 #include "um.h"
 #include <stdlib.h>
 
+/*
+ * Document-class: UringMachine::AsyncOp
+ *
+ * Encapsulates an asynchronous operation. Currently the only asynchronous
+ * operation supported is a timeout operation.
+ */
+
 VALUE cAsyncOp;
 
 VALUE SYM_timeout;
@@ -12,8 +19,8 @@ static void AsyncOp_mark(void *ptr) {
 
 static void AsyncOp_free(void *ptr) {
   struct um_async_op *async_op = ptr;
-  if (async_op->op)
-    um_op_free(async_op->machine, async_op->op);
+  if (likely(async_op->op))
+    um_op_release(async_op->machine, async_op->op);
 }
 
 static const rb_data_type_t AsyncOp_type = {
@@ -56,9 +63,13 @@ inline void raise_on_missing_op(struct um_async_op *async_op) {
 }
 
 inline int async_op_is_done(struct um_async_op *async_op) {
-  return (async_op->op->flags & OP_F_COMPLETED);
+  return OP_CQE_DONE_P(async_op->op);
 }
 
+/* Returns the kind of asynchronous operation.
+ *
+ * @return [Symbol] operation kind
+ */
 VALUE AsyncOp_kind(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -71,6 +82,10 @@ VALUE AsyncOp_kind(VALUE self) {
   }
 }
 
+/* Returns true if the operation has completed.
+ *
+ * @return [bool] is the operation done
+ */
 VALUE AsyncOp_done_p(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -78,6 +93,10 @@ VALUE AsyncOp_done_p(VALUE self) {
   return async_op_is_done(async_op) ? Qtrue : Qfalse;
 }
 
+/* Returns the operation result. If the operation is not completed, returns nil.
+ *
+ * @return [Integer, nil] operation result
+ */
 VALUE AsyncOp_result(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -85,6 +104,10 @@ VALUE AsyncOp_result(VALUE self) {
   return async_op_is_done(async_op) ? INT2NUM(async_op->op->result.res) : Qnil;
 }
 
+/* Returns true if the operation has been cancelled.
+ *
+ * @return [bool] is the operation cancelled
+ */
 VALUE AsyncOp_cancelled_p(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -94,6 +117,10 @@ VALUE AsyncOp_cancelled_p(VALUE self) {
   return (async_op->op->result.res == -ECANCELED) ? Qtrue : Qfalse;
 }
 
+/* Waits for the operation to complete.
+ *
+ * @return [Integer] operation result
+ */
 VALUE AsyncOp_await(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -104,6 +131,10 @@ VALUE AsyncOp_await(VALUE self) {
   return um_async_op_await(async_op);
 }
 
+/* Cancels the operation.
+ *
+ * @return [UringMachine::AsyncOp] self
+ */
 VALUE AsyncOp_cancel(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);