Class: Event::Selector::EPoll

Inherits:

Object

• Object
• Event::Selector::EPoll

Defined in:

ext/event/selector/epoll.c

Instance Method Summary

• #close ⇒ Object
• #initialize(loop) ⇒ Object constructor
• #io_read(fiber, io, buffer, _length) ⇒ Object
• #io_wait(fiber, io, events) ⇒ Object
• #io_write(fiber, io, buffer, _length) ⇒ Object
• #process_wait(fiber, pid, flags) ⇒ Object
• #push(fiber) ⇒ Object
• #raise(*args) ⇒ Object
• #ready? ⇒ Boolean
• #select(duration) ⇒ Object
• #transfer(*args) ⇒ Object
• #yield ⇒ Object

Constructor Details

#initialize(loop) ⇒ Object

# File 'ext/event/selector/epoll.c', line 88

VALUE Event_Selector_EPoll_initialize(VALUE self, VALUE loop) {
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  Event_Selector_initialize(&data->backend, loop);
  int result = epoll_create1(EPOLL_CLOEXEC);
  
  if (result == -1) {
    rb_sys_fail("epoll_create");
  } else {
    data->descriptor = result;
    
    rb_update_max_fd(data->descriptor);
  }
  
  return self;
}

Instance Method Details

#close ⇒ Object

# File 'ext/event/selector/epoll.c', line 106

VALUE Event_Selector_EPoll_close(VALUE self) {
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  close_internal(data);
  
  return Qnil;
}

#io_read(fiber, io, buffer, _length) ⇒ Object

# File 'ext/event/selector/epoll.c', line 365

VALUE Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length) {
  int descriptor = Event_Selector_io_descriptor(io);
  
  size_t length = NUM2SIZET(_length);
  
  struct io_read_arguments io_read_arguments = {
    .self = self,
    .fiber = fiber,
    .io = io,
    
    .flags = Event_Selector_nonblock_set(descriptor),
    .descriptor = descriptor,
    .buffer = buffer,
    .length = length,
  };
  
  return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
}

#io_wait(fiber, io, events) ⇒ Object

# File 'ext/event/selector/epoll.c', line 269

VALUE Event_Selector_EPoll_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE events) {
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  struct epoll_event event = {0};
  
  int descriptor = Event_Selector_io_descriptor(io);
  int duplicate = -1;
  
  event.events = epoll_flags_from_events(NUM2INT(events));
  event.data.ptr = (void*)fiber;
  
  // fprintf(stderr, "<- fiber=%p descriptor=%d\n", (void*)fiber, descriptor);
  
  // A better approach is to batch all changes:
  int result = epoll_ctl(data->descriptor, EPOLL_CTL_ADD, descriptor, &event);
  
  if (result == -1 && errno == EEXIST) {
    // The file descriptor was already inserted into epoll.
    duplicate = descriptor = dup(descriptor);
    
    rb_update_max_fd(duplicate);
    
    if (descriptor == -1)
      rb_sys_fail("dup");
    
    result = epoll_ctl(data->descriptor, EPOLL_CTL_ADD, descriptor, &event);
  }
  
  if (result == -1) {
    rb_sys_fail("epoll_ctl");
  }
  
  struct io_wait_arguments io_wait_arguments = {
    .data = data,
    .descriptor = descriptor,
    .duplicate = duplicate
  };
  
  return rb_ensure(io_wait_transfer, (VALUE)&io_wait_arguments, io_wait_ensure, (VALUE)&io_wait_arguments);
}

#io_write(fiber, io, buffer, _length) ⇒ Object

# File 'ext/event/selector/epoll.c', line 437

VALUE Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length) {
  int descriptor = Event_Selector_io_descriptor(io);
  
  size_t length = NUM2SIZET(_length);
  
  struct io_write_arguments io_write_arguments = {
    .self = self,
    .fiber = fiber,
    .io = io,
    
    .flags = Event_Selector_nonblock_set(descriptor),
    .descriptor = descriptor,
    .buffer = buffer,
    .length = length,
  };
  
  return rb_ensure(io_write_loop, (VALUE)&io_write_arguments, io_write_ensure, (VALUE)&io_write_arguments);
}

#process_wait(fiber, pid, flags) ⇒ Object

# File 'ext/event/selector/epoll.c', line 187

VALUE Event_Selector_EPoll_process_wait(VALUE self, VALUE fiber, VALUE pid, VALUE flags) {
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  struct process_wait_arguments process_wait_arguments = {
    .data = data,
    .pid = NUM2PIDT(pid),
    .flags = NUM2INT(flags),
  };
  
  process_wait_arguments.descriptor = pidfd_open(process_wait_arguments.pid, 0);
  rb_update_max_fd(process_wait_arguments.descriptor);
  
  struct epoll_event event = {
    .events = EPOLLIN|EPOLLRDHUP|EPOLLONESHOT,
    .data = {.ptr = (void*)fiber},
  };
  
  int result = epoll_ctl(data->descriptor, EPOLL_CTL_ADD, process_wait_arguments.descriptor, &event);
  
  if (result == -1) {
    rb_sys_fail("epoll_ctl(process_wait)");
  }
  
  return rb_ensure(process_wait_transfer, (VALUE)&process_wait_arguments, process_wait_ensure, (VALUE)&process_wait_arguments);
}

#push(fiber) ⇒ Object

# File 'ext/event/selector/epoll.c', line 135

VALUE Event_Selector_EPoll_push(VALUE self, VALUE fiber)
{
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  Event_Selector_queue_push(&data->backend, fiber);
  
  return Qnil;
}

#raise(*args) ⇒ Object

# File 'ext/event/selector/epoll.c', line 145

VALUE Event_Selector_EPoll_raise(int argc, VALUE *argv, VALUE self)
{
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  return Event_Selector_wait_and_raise(&data->backend, argc, argv);
}

#ready? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/event/selector/epoll.c', line 153

VALUE Event_Selector_EPoll_ready_p(VALUE self) {
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  return data->backend.ready ? Qtrue : Qfalse;
}

#select(duration) ⇒ Object

# File 'ext/event/selector/epoll.c', line 513

VALUE Event_Selector_EPoll_select(VALUE self, VALUE duration) {
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  int ready = Event_Selector_queue_flush(&data->backend);
  
  struct select_arguments arguments = {
    .data = data,
    .timeout = 0
  };
  
  select_internal_with_gvl(&arguments);

  // If the ready list was empty and no events were processed: 
  if (!ready && arguments.count == 0) {
    arguments.timeout = make_timeout(duration);
    
    if (arguments.timeout != 0) {
      select_internal_without_gvl(&arguments);
    }
  }
  
  for (int i = 0; i < arguments.count; i += 1) {
    VALUE fiber = (VALUE)arguments.events[i].data.ptr;
    VALUE result = INT2NUM(arguments.events[i].events);
    
    // fprintf(stderr, "-> fiber=%p descriptor=%d\n", (void*)fiber, events[i].data.fd);
    
    Event_Selector_fiber_transfer(fiber, 1, &result);
  }
  
  return INT2NUM(arguments.count);
}

#transfer(*args) ⇒ Object

# File 'ext/event/selector/epoll.c', line 115

VALUE Event_Selector_EPoll_transfer(int argc, VALUE *argv, VALUE self)
{
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  Event_Selector_wait_and_transfer(&data->backend, argc, argv);
  
  return Qnil;
}

#yield ⇒ Object

# File 'ext/event/selector/epoll.c', line 125

VALUE Event_Selector_EPoll_yield(VALUE self)
{
  struct Event_Selector_EPoll *data = NULL;
  TypedData_Get_Struct(self, struct Event_Selector_EPoll, &Event_Selector_EPoll_Type, data);
  
  Event_Selector_yield(&data->backend);
  
  return Qnil;
}