Re: [Caml-list] Linux epoll bindings

[Goswin von Brederlow <goswin-v-b@web.de>]

On Wed, May 08, 2013 at 11:06:48AM -0400, Markus Mottl wrote:
> Hi,
> 
> the Jane Street Core library has epoll in its Linux extensions module
> (Core.Std.Linux_ext.Epoll).
> 
> Regards,
> Markus
> 
> On Wed, May 8, 2013 at 10:50 AM, Goswin von Brederlow <goswin-v-b@web.de> wrote:
> > Hi,
> >
> > does anyone have or know of bindings for linux epoll for ocaml?
> >
> > MfG
> >         Goswin
> 
> -- 
> Markus Mottl        http://www.ocaml.info        markus.mottl@gmail.com

I think the best feature of Linux epoll is that the struct epoll_event
contains a epoll_data_t where one can store a pointer, int, uint32_t
or uint64_t. Core.Std.Linux_ext.Epoll (and the other epoll bindings)
seem to always store the Unix.file_descr there.

In my case, and probably most cases, I have different FDs in the mix
that need to do different things when their event is triggered. For
example the server socket needs to call accpet() on POLLIN while
client sockets need to (continue to) parse requests. So every FD has a
bit of state associated with it that tells what to do with it. And I
need a Hashtbl.t to lookup the state for each FD that gets an event.


Now wouldn't it be much better to store a 'a in the epoll_data_t
instead of the FD? That would allow storing a Unix.file_descr just
like now, a closure or any other data structure one wishes to
associate with the event being waited for. Something like (loosely
based on janestreets core):

module Epoll: sig
  type op = ADD | MOD | DEL

  type flags (* EPOLLIN | EPOLLOUT | .... *)

  type 'a event = {
    flags : flags;
    data : 'a
  }

  type 'a t

  val create : 'a. (int -> 'a t)
  (** create max_events  creates an epoll object able to process up
      to max_events per wait call. *)

  val ctl : 'a t -> op -> Unix.file_descr -> 'a event -> unit
  (** ctl t op fd event  adds, modifies, deletes the association between
      the fd and the event. *)

  val wait : 'a t -> [ `After of float | `Immediately | `Never ]
                  -> [ `Ok | `Timeout ]
  (** wait t timeout  blocks until at least one file descriptor in t
      is ready for one of the events it is being watched for, or timeout
      passes. *)

  val iter : 'a t -> (flags -> 'a -> unit) -> unit
  val fold : 'a t -> 'b -> ('b -> flags -> 'a -> 'b) -> 'b
  (** iterate or fold over pending events *)
end


Anyone know of epoll bindings like that? I only found the FD kind with
google.

MfG
	Goswin