polyphony 0.71 → 0.74

data/ext/polyphony/backend_io_uring_context.c

@@ -17,6 +17,7 @@ const char *op_type_to_str(enum op_type type) {
   case OP_ACCEPT: return "ACCEPT";
   case OP_CONNECT: return "CONNECT";
   case OP_CHAIN: return "CHAIN";
+  case OP_CLOSE: return "CLOSE";
   default: return "";
   };
 }
@@ -64,7 +65,7 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
   // printf("release %p %d (%s, ref_count: %d)\n", ctx, ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
 
   assert(ctx->ref_count);
-  
+
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 

data/ext/polyphony/backend_io_uring_context.h

@@ -15,14 +15,15 @@ enum op_type {
   OP_POLL,
   OP_ACCEPT,
   OP_CONNECT,
-  OP_CHAIN
+  OP_CHAIN,
+  OP_CLOSE
 };
 
 typedef struct op_context {
   struct op_context *prev;
   struct op_context *next;
   enum op_type      type: 16;
-  unsigned int      ref_count : 16;       
+  unsigned int      ref_count : 16;
   int               id;
   int               result;
   VALUE             fiber;

data/ext/polyphony/backend_libev.c

@@ -118,7 +118,7 @@ inline struct ev_loop *libev_new_loop() {
 
 static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
-  
+
   GetBackend(self, backend);
 
   backend_base_initialize(&backend->base);
@@ -188,7 +188,7 @@ inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  runqueue_delete(&backend->base.runqueue, fiber);  
+  runqueue_delete(&backend->base.runqueue, fiber);
 }
 
 inline VALUE Backend_switch_fiber(VALUE self) {
@@ -287,7 +287,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
-  OBJ_TAINT(str);
 
   while (1) {
     backend->base.op_count++;
@@ -698,10 +697,13 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
-  struct sockaddr_in addr;
-  char *host_buf = StringValueCStr(host);
+  struct sockaddr *ai_addr;
+  int ai_addrlen;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
+
+  ai_addrlen = backend_getaddrinfo(host, port, &ai_addr);
+
   if (underlying_sock != Qnil) sock = underlying_sock;
 
   GetBackend(self, backend);
@@ -709,12 +711,8 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   io_verify_blocking_mode(fptr, sock, Qfalse);
   watcher.fiber = Qnil;
 
-  addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = inet_addr(host_buf);
-  addr.sin_port = htons(NUM2INT(port));
-
   backend->base.op_count++;
-  int result = connect(fptr->fd, (struct sockaddr *)&addr, sizeof(addr));
+  int result = connect(fptr->fd, ai_addr, ai_addrlen);
   if (result < 0) {
     int e = errno;
     if (e != EINPROGRESS) rb_syserr_fail(e, strerror(e));
@@ -971,7 +969,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
   watcher.fiber = Qnil;
-  
+
   while (1) {
     backend->base.op_count++;
     ssize_t n = read(src_fptr->fd, buf, len);
@@ -1047,7 +1045,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   watcher.fiber = Qnil;
 
-  while (1) { 
+  while (1) {
     char *ptr = buf;
     while (1) {
       backend->base.op_count++;
@@ -1147,33 +1145,39 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
 noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   Backend_t *backend;
   struct libev_timer watcher;
-  double interval_d = NUM2DBL(interval);
-
-  GetBackend(self, backend);
   watcher.fiber = rb_fiber_current();
+  uint64_t interval_ns = NUM2DBL(interval) * 1e9;
+  uint64_t next_time_ns = 0;
+  VALUE resume_value = Qnil;
 
-  double next_time = 0.;
+  GetBackend(self, backend);
 
   while (1) {
-    double now = current_time();
-    if (next_time == 0.) next_time = current_time() + interval_d;
-    double sleep_duration = next_time - now;
-    if (sleep_duration < 0) sleep_duration = 0;
-    
-    VALUE switchpoint_result = Qnil;    
-    ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
-    ev_timer_start(backend->ev_loop, &watcher.timer);
-    backend->base.op_count++;
-    switchpoint_result = backend_await((struct Backend_base *)backend);
-    ev_timer_stop(backend->ev_loop, &watcher.timer);
-    RAISE_IF_EXCEPTION(switchpoint_result);
-    RB_GC_GUARD(switchpoint_result);
+    uint64_t now_ns = current_time_ns();
+    if (next_time_ns == 0) next_time_ns = now_ns + interval_ns;
+
+    if (next_time_ns > now_ns) {
+      double sleep_duration = ((double)(next_time_ns - now_ns))/1e9;
+      ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
+      ev_timer_start(backend->ev_loop, &watcher.timer);
+      backend->base.op_count++;
+      resume_value = backend_await((struct Backend_base *)backend);
+      ev_timer_stop(backend->ev_loop, &watcher.timer);
+      RAISE_IF_EXCEPTION(resume_value);
+    }
+    else {
+      resume_value = backend_snooze();
+      RAISE_IF_EXCEPTION(resume_value);
+    }
 
     rb_yield(Qnil);
-    do {
-      next_time += interval_d;
-    } while (next_time <= now);
+
+    while (1) {
+      next_time_ns += interval_ns;
+      if (next_time_ns > now_ns) break;
+    }
   }
+  RB_GC_GUARD(resume_value);
 }
 
 struct libev_timeout {
@@ -1219,7 +1223,7 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
 
   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));
@@ -1337,7 +1341,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     else
       rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
   }
-  
+
   RB_GC_GUARD(result);
   return result;
 }
@@ -1364,7 +1368,7 @@ inline VALUE Backend_run_idle_tasks(VALUE self) {
   return self;
 }
 
-inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct libev_rw_io *watcher, VALUE *result) {
+static inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct libev_rw_io *watcher, VALUE *result) {
   char *buf = RSTRING_PTR(str);
   int len = RSTRING_LEN(str);
   int left = len;
@@ -1386,14 +1390,14 @@ inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct lib
   return 0;
 }
 
-static inline int splice_chunks_splice(Backend_t *backend, int src_fd, int dest_fd, int maxlen, 
+static inline int splice_chunks_splice(Backend_t *backend, int src_fd, int dest_fd, int maxlen,
   struct libev_rw_io *watcher, VALUE *result, int *chunk_len) {
 #ifdef POLYPHONY_LINUX
   backend->base.op_count++;
   while (1) {
     *chunk_len = splice(src_fd, 0, dest_fd, 0, maxlen, 0);
     if (*chunk_len >= 0) return 0;
-    
+
     int err = errno;
     if (err != EWOULDBLOCK && err != EAGAIN) return err;
 
@@ -1489,7 +1493,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     err = splice_chunks_splice(backend, src_fptr->fd, pipefd[1], maxlen, &watcher, &result, &chunk_len);
     if (err == -1) goto error; else if (err) goto syscallerror;
     if (chunk_len == 0) break;
-    
+
     total += chunk_len;
     chunk_len_value = INT2NUM(chunk_len);
 

data/ext/polyphony/event.c

@@ -59,14 +59,17 @@ VALUE Event_signal(int argc, VALUE *argv, VALUE self) {
 
 VALUE Event_await(VALUE self) {
   Event_t *event;
+  VALUE switchpoint_result;
+  VALUE backend;
+
   GetEvent(self, event);
 
   if (event->waiting_fiber != Qnil)
     rb_raise(rb_eRuntimeError, "Event is already awaited by another fiber");
 
-  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
   event->waiting_fiber = rb_fiber_current();
-  VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
+  switchpoint_result = Backend_wait_event(backend, Qnil);
   event->waiting_fiber = Qnil;
 
   RAISE_IF_EXCEPTION(switchpoint_result);

data/ext/polyphony/extconf.rb

@@ -3,32 +3,43 @@
 require 'rubygems'
 require 'mkmf'
 
-use_liburing = false
-use_pidfd_open = false
-force_use_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
-linux = RUBY_PLATFORM =~ /linux/
-
-if linux && `uname -sr` =~ /Linux 5\.(\d+)/
-  kernel_minor_version = $1.to_i
-  use_liburing = !force_use_libev && kernel_minor_version >= 6
-  use_pidfd_open = kernel_minor_version >= 3
+
+KERNEL_INFO_RE = /Linux (\d)\.(\d+)\.(?:\d+)\-(?:\d+\-)?(\w+)/
+def get_config
+  config = { linux: !!(RUBY_PLATFORM =~ /linux/) }
+  return config if !config[:linux]
+
+  kernel_info = `uname -sr`
+  m = kernel_info.match(KERNEL_INFO_RE)
+  raise "Could not parse Linux kernel information (#{kernel_info.inspect})" if !m
+
+  version, major_revision, distribution = m[1].to_i, m[2].to_i, m[3]
+  config[:pidfd_open] = (version == 5) && (major_revision >= 3)
+
+  force_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+  config[:io_uring] = !force_libev &&
+    (version == 5) && (major_revision >= 6) && (distribution != 'linuxkit')
+  config
 end
 
-$defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if use_pidfd_open
-if use_liburing
+config = get_config
+puts "Building Polyphony... (#{config.inspect})"
+
+$defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if config[:pidfd_open]
+if config[:io_uring]
   $defs << "-DPOLYPHONY_BACKEND_LIBURING"
   $defs << "-DPOLYPHONY_UNSET_NONBLOCK" if RUBY_VERSION =~ /^3/
   $CFLAGS << " -Wno-pointer-arith"
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
-  $defs << "-DPOLYPHONY_LINUX" if linux
+  $defs << "-DPOLYPHONY_LINUX" if config[:linux]
   $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
   $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
   $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
   $defs << '-DEV_USE_EPOLL'        if have_header('sys/epoll.h')
   $defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
   $defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
-  $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')  
+  $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')
 
   $CFLAGS << " -Wno-comment"
   $CFLAGS << " -Wno-unused-result"
@@ -40,6 +51,7 @@ $defs << '-DPOLYPHONY_PLAYGROUND' if ENV['POLYPHONY_PLAYGROUND']
 
 CONFIG['optflags'] << ' -fno-strict-aliasing' unless RUBY_PLATFORM =~ /mswin/
 
+have_func('rb_fiber_transfer', 'ruby.h')
 
 dir_config 'polyphony_ext'
 create_makefile 'polyphony_ext'

data/ext/polyphony/polyphony.c

@@ -9,16 +9,18 @@ ID ID_clear;
 ID ID_each;
 ID ID_inspect;
 ID ID_invoke;
-ID ID_new;
 ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
 ID ID_ivar_parked;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
 ID ID_ivar_thread;
+ID ID_new;
+ID ID_raise;
 ID ID_size;
 ID ID_signal;
 ID ID_switch_fiber;
+ID ID_to_s;
 ID ID_transfer;
 ID ID_R;
 ID ID_W;
@@ -123,6 +125,10 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
   return Backend_write_m(argc, argv, BACKEND());
 }
 
+VALUE Polyphony_backend_close(VALUE self, VALUE io) {
+  return Backend_close(BACKEND(), io);
+}
+
 void Init_Polyphony() {
   mPolyphony = rb_define_module("Polyphony");
 
@@ -147,6 +153,7 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "backend_wait_io", Polyphony_backend_wait_io, 2);
   rb_define_singleton_method(mPolyphony, "backend_waitpid", Polyphony_backend_waitpid, 1);
   rb_define_singleton_method(mPolyphony, "backend_write", Polyphony_backend_write, -1);
+  rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
 
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
@@ -166,8 +173,10 @@ void Init_Polyphony() {
   ID_ivar_running       = rb_intern("@running");
   ID_ivar_thread        = rb_intern("@thread");
   ID_new                = rb_intern("new");
+  ID_raise              = rb_intern("raise");
   ID_signal             = rb_intern("signal");
   ID_size               = rb_intern("size");
   ID_switch_fiber       = rb_intern("switch_fiber");
+  ID_to_s               = rb_intern("to_s");
   ID_transfer           = rb_intern("transfer");
 }

data/ext/polyphony/polyphony.h

@@ -26,7 +26,11 @@
 #define RAISE_IF_NOT_NIL(ret) if (ret != Qnil) { RAISE_EXCEPTION(ret); }
 
 // Fiber#transfer
-#define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
+#if HAVE_RB_FIBER_TRANSFER
+  #define FIBER_TRANSFER(fiber, value) rb_fiber_transfer(fiber, 1, &value)
+#else
+  #define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
+#endif
 
 #define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
 
@@ -53,6 +57,7 @@ extern ID ID_raise;
 extern ID ID_signal;
 extern ID ID_size;
 extern ID ID_switch_fiber;
+extern ID ID_to_s;
 extern ID ID_transfer;
 
 extern VALUE SYM_fiber_create;
@@ -108,6 +113,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise);
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write);
 VALUE Backend_waitpid(VALUE self, VALUE pid);
 VALUE Backend_write_m(int argc, VALUE *argv, VALUE self);
+VALUE Backend_close(VALUE self, VALUE io);
 
 VALUE Backend_poll(VALUE self, VALUE blocking);
 VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);

data/ext/polyphony/queue.c

@@ -121,24 +121,27 @@ VALUE Queue_unshift(VALUE self, VALUE value) {
 
 VALUE Queue_shift(VALUE self) {
   Queue_t *queue;
-  GetQueue(self, queue);
-
   VALUE fiber = rb_fiber_current();
   VALUE thread = rb_thread_current();
   VALUE backend = rb_ivar_get(thread, ID_ivar_backend);
+  VALUE value;
+
+  GetQueue(self, queue);
 
   while (1) {
+    VALUE switchpoint_result;
+
     if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
     ring_buffer_push(&queue->shift_queue, fiber);
-    VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
+    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) break;
   }
-  VALUE value = ring_buffer_shift(&queue->values);
+  value = ring_buffer_shift(&queue->values);
   if ((queue->capacity) && (queue->capacity > queue->values.count))
     queue_schedule_first_blocked_fiber(&queue->push_queue);
   RB_GC_GUARD(value);
@@ -162,12 +165,12 @@ VALUE Queue_cap(VALUE self, VALUE cap) {
   Queue_t *queue;
   GetQueue(self, queue);
   queue->capacity = new_capacity;
-  
+
   if (queue->capacity)
     queue_schedule_blocked_fibers_to_capacity(queue);
   else
     queue_schedule_all_blocked_fibers(&queue->push_queue);
-  
+
   return self;
 }
 
@@ -206,9 +209,11 @@ VALUE Queue_shift_each(VALUE self) {
 
 VALUE Queue_shift_all(VALUE self) {
   Queue_t *queue;
+  VALUE result;
+
   GetQueue(self, queue);
 
-  VALUE result = ring_buffer_shift_all(&queue->values);
+  result = ring_buffer_shift_all(&queue->values);
   if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return result;
 }

data/ext/polyphony/runqueue_ring_buffer.c

@@ -24,9 +24,11 @@ inline void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
 static runqueue_entry nil_runqueue_entry = {(Qnil), (Qnil)};
 
 inline runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
+  runqueue_entry value;
+
   if (buffer->count == 0) return nil_runqueue_entry;
 
-  runqueue_entry value = buffer->entries[buffer->head];
+  value = buffer->entries[buffer->head];
   buffer->head = (buffer->head + 1) % buffer->size;
   buffer->count--;
   return value;
@@ -61,8 +63,9 @@ inline void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber,
 
 inline void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer) {
   for (unsigned int i = 0; i < buffer->count; i++) {
-    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].fiber);
-    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].value);
+    runqueue_entry entry = buffer->entries[(buffer->head + i) % buffer->size];
+    rb_gc_mark(entry.fiber);
+    rb_gc_mark(entry.value);
   }
 }
 

data/ext/polyphony/socket_extensions.c

@@ -17,10 +17,13 @@ VALUE Socket_double_chevron(VALUE self, VALUE msg) {
 }
 
 void Init_SocketExtensions() {
+  VALUE cSocket;
+  VALUE cTCPSocket;
+
   rb_require("socket");
 
-  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
-  VALUE cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+  cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
+  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
 
   rb_define_method(cSocket, "send", Socket_send, 2);
   rb_define_method(cTCPSocket, "send", Socket_send, 2);

data/ext/polyphony/thread.c

@@ -40,7 +40,7 @@ VALUE Thread_fiber_schedule_and_wakeup(VALUE self, VALUE fiber, VALUE resume_obj
   }
 
   if (Backend_wakeup(rb_ivar_get(self, ID_ivar_backend)) == Qnil) {
-    // we're not inside the ev_loop, so we just do a switchpoint
+    // we're not inside Backend_poll, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
 

data/lib/polyphony/adapters/irb.rb

@@ -3,26 +3,36 @@
 require 'polyphony'
 
 if Object.constants.include?(:Reline)
+  puts "reline"
   class Reline::ANSI
     def self.select(read_ios = [], write_ios = [], error_ios = [], timeout = nil)
-      p [:select, read_ios]
+      # p [:select, read_ios, timeout]
+      # puts caller.join("\n")
       raise if read_ios.size > 1
       raise if write_ios.size > 0
       raise if error_ios.size > 0
 
+      # p 1
       fiber = Fiber.current
       timer = spin do
         sleep timeout
         fiber.cancel
       end
+      # p 2
       read_ios.each do |io|
+        # p wait: io
         Polyphony.backend_wait_io(io, false)
+        # p :done_wait
         return [io]
       end
+      # p 3
     rescue Polyphony::Cancel
+      # p :cancel
       return nil
     ensure
+      # p :ensure
       timer.stop
+      # p :ensure_done      
     end
   end
 else

data/lib/polyphony/core/global_api.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../extensions/core'
-require_relative '../extensions/fiber'
-require_relative './exceptions'
 require_relative './throttler'
 
 module Polyphony
@@ -73,7 +70,7 @@ module Polyphony
 
     def spin_scope
       raise unless block_given?
-    
+
       spin do
         result = yield
         Fiber.current.await_all_children
@@ -122,8 +119,8 @@ module Polyphony
       Fiber.current.receive_all_pending
     end
 
-    def supervise(*args, &block)
-      Fiber.current.supervise(*args, &block)
+    def supervise(*args, **opts, &block)
+      Fiber.current.supervise(*args, **opts, &block)
     end
 
     def sleep(duration = nil)

data/lib/polyphony/core/timer.rb

@@ -44,7 +44,7 @@ module Polyphony
     ensure
       @timeouts.delete(fiber)
     end
-  
+
     def cancel_after(interval, with_exception: Polyphony::Cancel)
       fiber = Fiber.current
       @timeouts[fiber] = {
@@ -74,7 +74,7 @@ module Polyphony
     def reset
       record = @timeouts[Fiber.current]
       return unless record
-  
+
       record[:target_stamp] = now + record[:interval]
     end
 

data/lib/polyphony/debugger.rb

@@ -9,11 +9,11 @@ module Polyphony
     :return,
     :b_call,
     :b_return
-  ]    
+  ]
 
   def self.start_debug_server(socket_path)
     server = DebugServer.new(socket_path)
-    controller = DebugController.new(server)      
+    controller = DebugController.new(server)
     trace = TracePoint.new(*TP_EVENTS) { |tp| controller.handle_tp(trace, tp) }
     trace.enable
 
@@ -124,7 +124,7 @@ module Polyphony
         h
       end
     end
-    
+
     def cmd_step(cmd)
       tp = nil
       fiber = nil

data/lib/polyphony/extensions/exception.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Exeption overrides
+class ::Exception
+  class << self
+    attr_accessor :__disable_sanitized_backtrace__
+  end
+
+  attr_accessor :source_fiber, :raising_fiber
+
+  alias_method :orig_initialize, :initialize
+  def initialize(*args)
+    @raising_fiber = Fiber.current
+    orig_initialize(*args)
+  end
+
+  alias_method :orig_backtrace, :backtrace
+  def backtrace
+    unless @backtrace_called
+      @backtrace_called = true
+      return orig_backtrace
+    end
+
+    sanitized_backtrace
+  end
+
+  def sanitized_backtrace
+    return sanitize(orig_backtrace) unless @raising_fiber
+
+    backtrace = orig_backtrace || []
+    sanitize(backtrace + @raising_fiber.caller)
+  end
+
+  POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
+
+  def sanitize(backtrace)
+    return backtrace if ::Exception.__disable_sanitized_backtrace__
+
+    backtrace.reject { |l| l[POLYPHONY_DIR] }
+  end
+
+  def invoke
+    Kernel.raise(self)
+  end
+end