iodine 0.1.21 → 0.2.0

data/ext/iodine/libasync.h

@@ -0,0 +1,117 @@
+/*
+copyright: Boaz segev, 2016
+license: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef LIB_ASYNC
+#define LIB_ASYNC "0.4.0"
+#define LIB_ASYNC_VERSION_MAJOR 0
+#define LIB_ASYNC_VERSION_MINOR 4
+#define LIB_ASYNC_VERSION_PATCH 0
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef DEBUG
+// prints out testing and benchmarking data
+void async_test_library_speed(void);
+#endif
+
+/** \file
+This is an easy to use **global** thread pool library. Once the thread pool was
+initiated it makes running tasks very simple. i.e.:
+
+    async_start(4); // 4 worker threads
+    async_run(task, arg);
+    async_finish(); // waits for tasks and releases threads.
+
+Please note, this library isn't fork-friendly - fork **before** you create the
+thread pool. In general, mixing `fork` with multi-threading isn't safe nor
+trivial - always fork before multi-threading.
+*/
+
+/**
+Starts running the global thread pool. Use:
+
+  async_start(8, 0);
+
+The `use_sentinal` variable protects threads from crashing and produces error
+reports. It isn't effective against all errors, but it should protect against
+some.
+
+*/
+ssize_t async_start(size_t threads);
+
+/**
+Use `async_join` instead.
+
+Performs tasks until the task queue is empty. An empty task queue does NOT mean
+all the tasks have completed, since some other threads might be running tasks
+that have yet to complete (and these tasks might schedule new tasks as well).
+
+Use:
+
+  async_perform();
+
+*/
+void async_perform();
+
+/**
+Waits for all the present tasks to complete and threads to exist.
+
+The function won't return unless `async_signal` is called to signal the threads
+to stop waiting for new tasks.
+
+After this function returns, the thread pool will remain active, waiting for new
+tasts.
+
+Unline finish (that uses `join`) this is an **active** wait where the waiting
+thread acts as a working thread and performs any pending tasks and then
+spinlocks until the active thread count drops to 0.
+
+Use:
+
+  async_join();
+
+*/
+void async_join();
+
+/**
+Signals all the threads to finish up and stop waiting for new tasks.
+
+Use:
+
+  async_join();
+
+*/
+void async_signal();
+
+/**
+Schedules a task to be performed by the thread pool.
+
+The Task should be a function such as `void task(void *arg)`.
+
+Use:
+
+  void task(void * arg) { printf("%s", arg); }
+
+  char arg[] = "Demo Task";
+
+  async_run(task, arg);
+
+*/
+int async_run(void (*task)(void*), void* arg);
+
+/**
+Same as:
+
+`async_signal(); async_wait();`
+*/
+#define async_finish() \
+  {                    \
+    async_signal();    \
+    async_join();      \
+  }
+
+#endif /* LIB_ASYNC */

data/ext/iodine/libreact.c

@@ -0,0 +1,347 @@
+/*
+copyright: Boaz segev, 2016
+license: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#include "libreact.h"
+
+#if !defined(__linux__) && !defined(__CYGWIN__)
+#include <sys/event.h>
+#else
+#include <sys/timerfd.h>
+#include <sys/epoll.h>
+#endif
+#include <time.h>
+#include <assert.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+/* The (sadly, global) reactor fd */
+static int reactor_fd = -1;
+
+/* an inner helper function that removes and adds events */
+
+/* *****************************************************************************
+Callbacks
+*/
+
+#pragma weak reactor_on_close
+void reactor_on_close(intptr_t uuid) {}
+
+#pragma weak reactor_on_data
+void reactor_on_data(intptr_t uuid) {
+  char data[1024];
+  while (read(sock_uuid2fd(uuid), data, 1024) > 0)
+    ;
+}
+
+#pragma weak reactor_on_ready
+void reactor_on_ready(intptr_t uuid) {}
+
+/* *****************************************************************************
+Integrate the `libsock` library if exists.
+*/
+
+#pragma weak sock_flush
+ssize_t sock_flush(intptr_t uuid) { return 0; }
+
+#pragma weak sock_close
+void sock_close(intptr_t uuid) {
+  shutdown(sock_uuid2fd(uuid), SHUT_RDWR);
+  close(sock_uuid2fd(uuid));
+  /* this is automatic on epoll... what about kqueue? */
+  reactor_remove(uuid);
+  /* call callback */
+  reactor_on_close(uuid);
+}
+
+/* *****************************************************************************
+The main libreact API.
+*/
+
+/**
+Closes a file descriptor, calling it's callback if it was registered with the
+reactor.
+*/
+void reactor_close(intptr_t uuid) {
+  sock_close(uuid);
+  return;
+}
+
+/* *****************************************************************************
+KQueue implementation.
+*/
+#ifdef EV_SET
+
+int reactor_add(intptr_t uuid) {
+  struct kevent chevent[2];
+  EV_SET(chevent, sock_uuid2fd(uuid), EVFILT_READ,
+         EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, (void *)uuid);
+  EV_SET(chevent + 1, sock_uuid2fd(uuid), EVFILT_WRITE,
+         EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, (void *)uuid);
+  return kevent(reactor_fd, chevent, 2, NULL, 0, NULL);
+}
+int reactor_add_timer(intptr_t uuid, long milliseconds) {
+  struct kevent chevent;
+  EV_SET(&chevent, sock_uuid2fd(uuid), EVFILT_TIMER, EV_ADD | EV_ENABLE, 0,
+         milliseconds, (void *)uuid);
+  return kevent(reactor_fd, &chevent, 1, NULL, 0, NULL);
+}
+
+int reactor_remove(intptr_t uuid) {
+  struct kevent chevent[2];
+  EV_SET(chevent, sock_uuid2fd(uuid), EVFILT_READ, EV_DELETE, 0, 0,
+         (void *)uuid);
+  EV_SET(chevent + 1, sock_uuid2fd(uuid), EVFILT_WRITE, EV_DELETE, 0, 0,
+         (void *)uuid);
+  return kevent(reactor_fd, chevent, 2, NULL, 0, NULL);
+}
+int reactor_remove_timer(intptr_t uuid) {
+  struct kevent chevent;
+  EV_SET(&chevent, sock_uuid2fd(uuid), EVFILT_TIMER, EV_DELETE, 0, 0,
+         (void *)uuid);
+  return kevent(reactor_fd, &chevent, 1, NULL, 0, NULL);
+}
+
+/**
+epoll requires the timer to be "reset" before repeating. Kqueue requires no such
+thing.
+
+This method promises that the timer will be repeated when running on epoll. This
+method is redundent on kqueue.
+*/
+void reactor_reset_timer(intptr_t uuid) {} /* EPoll only */
+
+/**
+Creates a timer file descriptor, system dependent.
+
+Opens a new file decriptor for creating timer events. On BSD this will revert to
+an `fileno(tmpfile())` (with error handling) and on Linux it will call
+`timerfd_create(CLOCK_MONOTONIC, ...)`.
+
+Returns -1 on error, otherwise returns the file descriptor.
+*/
+intptr_t reactor_make_timer() {
+#ifdef P_tmpdir
+  char template[] = P_tmpdir "libreact_timer_XXXXXX";
+#else
+  char template[] = "/tmp/libreact_timer_XXXXXX";
+#endif
+  return mkstemp(template);
+}
+
+/* *****************************************************************************
+EPoll implementation.
+*/
+#elif defined(EPOLLIN)
+
+int reactor_add(intptr_t uuid) {
+  struct epoll_event chevent = {0};
+  chevent.data.ptr = (void *)uuid;
+  chevent.events =
+      EPOLLOUT | EPOLLIN | EPOLLET | EPOLLERR | EPOLLRDHUP | EPOLLHUP;
+  return epoll_ctl(reactor_fd, EPOLL_CTL_ADD, sock_uuid2fd(uuid), &chevent);
+}
+int reactor_add_timer(intptr_t uuid, long milliseconds) {
+  struct epoll_event chevent;
+  chevent.data.ptr = (void *)uuid;
+  chevent.events =
+      EPOLLOUT | EPOLLIN | EPOLLET | EPOLLERR | EPOLLRDHUP | EPOLLHUP;
+  struct itimerspec new_t_data;
+  new_t_data.it_value.tv_sec = new_t_data.it_interval.tv_sec =
+      milliseconds / 1000;
+  new_t_data.it_value.tv_nsec = new_t_data.it_interval.tv_nsec =
+      (milliseconds % 1000) * 1000000;
+  timerfd_settime(sock_uuid2fd(uuid), 0, &new_t_data, NULL);
+  return epoll_ctl(reactor_fd, EPOLL_CTL_ADD, sock_uuid2fd(uuid), &chevent);
+}
+
+int reactor_remove(intptr_t uuid) {
+  struct epoll_event chevent = {0};
+  // chevent.data.ptr = (void *)uuid;
+  // chevent.events =
+  //     EPOLLOUT | EPOLLIN | EPOLLET | EPOLLERR | EPOLLRDHUP | EPOLLHUP;
+  return epoll_ctl(reactor_fd, EPOLL_CTL_DEL, sock_uuid2fd(uuid), &chevent);
+}
+int reactor_remove_timer(intptr_t uuid) {
+  struct epoll_event chevent = {0};
+  // chevent.data.ptr = (void *)uuid;
+  // chevent.events =
+  //     EPOLLOUT | EPOLLIN | EPOLLET | EPOLLERR | EPOLLRDHUP | EPOLLHUP;
+  return epoll_ctl(reactor_fd, EPOLL_CTL_DEL, sock_uuid2fd(uuid), &chevent);
+}
+
+/**
+epoll requires the timer to be "reset" before repeating. Kqueue requires no such
+thing.
+
+This method promises that the timer will be repeated when running on epoll. This
+method is redundent on kqueue.
+*/
+void reactor_reset_timer(intptr_t uuid) {
+  char data[8]; // void * is 8 byte long
+  if (read(sock_uuid2fd(uuid), &data, 8) < 0)
+    data[0] = 0;
+}
+/**
+Creates a timer file descriptor, system dependent.
+
+Opens a new file decriptor for creating timer events. On BSD this will revert to
+an `fileno(tmpfile())` (with error handling) and on Linux it will call
+`timerfd_create(CLOCK_MONOTONIC, ...)`.
+
+Returns -1 on error, otherwise returns the file descriptor.
+*/
+intptr_t reactor_make_timer() {
+  return timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
+  ;
+}
+
+/* *****************************************************************************
+This library requires either kqueue or epoll to be available.
+Please help us be implementing support for your OS.
+*/
+#else
+int reactor_add(intptr_t uuid) { return -1; }
+int reactor_add_timer(intptr_t uuid, long milliseconds) { return -1; }
+
+int reactor_remove(intptr_t uuid) { return -1; }
+int reactor_remove_timer(intptr_t uuid) { return -1; }
+#error(This library requires either kqueue or epoll to be available. Please help us be implementing support for your OS.)
+#endif
+
+/* *****************************************************************************
+The Reactor loop.
+*/
+
+/*
+define some macros to help us write a cleaner main function.
+*/
+
+/* KQueue */
+#ifdef EV_SET
+/* global timout value for the reactors */
+static struct timespec _reactor_timeout = {
+    .tv_sec = (REACTOR_TICK / 1000),
+    .tv_nsec = ((REACTOR_TICK % 1000) * 1000000)};
+#define _CRAETE_QUEUE_ kqueue()
+#define _EVENT_TYPE_ struct kevent
+// #define _EVENTS_ ((_EVENT_TYPE_*)(reactor->internal_data.events))
+#define _WAIT_FOR_EVENTS_(events)                                              \
+  kevent(reactor_fd, NULL, 0, (events), REACTOR_MAX_EVENTS, &_reactor_timeout);
+#define _GET_FDUUID_(events, _ev_) ((intptr_t)((events)[(_ev_)].udata))
+#define _EVENTERROR_(events, _ev_) (events)[(_ev_)].flags &(EV_EOF | EV_ERROR)
+#define _EVENTREADY_(events, _ev_) (events)[(_ev_)].filter == EVFILT_WRITE
+#define _EVENTDATA_(events, _ev_)                                              \
+  (events)[(_ev_)].filter == EVFILT_READ ||                                    \
+      (events)[(_ev_)].filter == EVFILT_TIMER
+
+/* EPoll */
+#elif defined(EPOLLIN)
+static int const _reactor_timeout = REACTOR_TICK;
+#define _CRAETE_QUEUE_ epoll_create1(0)
+#define _EVENT_TYPE_ struct epoll_event
+// #define _EVENTS_ ((_EVENT_TYPE_*)reactor->internal_data.events)
+#define _QUEUE_READY_FLAG_ EPOLLOUT
+#define _WAIT_FOR_EVENTS_(events)                                              \
+  epoll_wait(reactor_fd, (events), REACTOR_MAX_EVENTS, _reactor_timeout)
+#define _GET_FDUUID_(events, _ev_) ((intptr_t)((events)[(_ev_)].data.ptr))
+#define _EVENTERROR_(events, _ev_)                                             \
+  ((events)[(_ev_)].events & (~(EPOLLIN | EPOLLOUT)))
+#define _EVENTREADY_(_events, _ev_) (_events)[(_ev_)].events &EPOLLOUT
+#define _EVENTDATA_(_events, _ev_) (_events)[(_ev_)].events &EPOLLIN
+
+#else /* no epoll, no kqueue - this is where support ends */
+#error(This library requires either kqueue or epoll to be available. Please help us be implementing support for your OS.)
+#endif
+
+/**
+Initializes the reactor, making the reactor "live".
+
+Returns -1 on error, otherwise returns 0.
+*/
+ssize_t reactor_init() {
+  if (reactor_fd > 0)
+    return -1;
+  reactor_fd = _CRAETE_QUEUE_;
+  return 0;
+}
+
+/**
+Closes the reactor, releasing it's resources (except the actual struct Reactor,
+which might have been allocated on the stack and should be handled by the
+caller).
+*/
+void reactor_stop() {
+  close(reactor_fd);
+  reactor_fd = -1;
+}
+
+/* *****************************************************************************
+The main Reactor Review function
+*/
+
+/**
+Reviews any pending events (up to REACTOR_MAX_EVENTS)
+
+Returns -1 on error, otherwise returns 0.
+*/
+int reactor_review() {
+  if (reactor_fd < 0)
+    return -1;
+  _EVENT_TYPE_ events[REACTOR_MAX_EVENTS];
+
+  /* wait for events and handle them */
+  int active_count = _WAIT_FOR_EVENTS_(events);
+  if (active_count > 0) {
+    for (int i = 0; i < active_count; i++) {
+      if (_EVENTERROR_(events, i)) {
+        // errors are hendled as disconnections (on_close)
+        // printf("on_close for %lu\n", _GET_FDUUID_(events, i));
+        sock_close(_GET_FDUUID_(events, i));
+      } else {
+        // no error, then it's an active event(s)
+        if (_EVENTREADY_(events, i)) {
+          // printf("on_ready for %lu\n", _GET_FDUUID_(events, i));
+          if (sock_flush(_GET_FDUUID_(events, i)) < 0) {
+            sock_close(_GET_FDUUID_(events, i));
+          } else {
+            // printf("on_ready callback for %lu fd(%d)\n",
+            //        _GET_FDUUID_(events, i),
+            //        sock_uuid2fd(_GET_FDUUID_(events, i)));
+            reactor_on_ready(_GET_FDUUID_(events, i));
+          }
+        }
+        if (_EVENTDATA_(events, i)) {
+          // printf("on_data callback for %lu fd(%d)\n",
+          //        _GET_FDUUID_(events, i),
+          //        sock_uuid2fd(_GET_FDUUID_(events, i)));
+          reactor_on_data(_GET_FDUUID_(events, i));
+        }
+      }
+    } // end for loop
+  } else if (active_count < 0) {
+    // perror("Please close the reactor, it's dying...");
+    return -1;
+  }
+  return active_count;
+}
+
+// we're done with these
+#undef _CRAETE_QUEUE_
+#undef _EVENT_TYPE_
+#undef _EVENTS
+#undef _INIT_TIMEOUT_
+#undef _WAIT_FOR_EVENTS_
+#undef _GET_FDUUID_
+#undef _EVENTERROR_
+#undef _EVENTREADY_
+#undef _EVENTDATA_