iodine 0.2.17 → 0.3.0

data/ext/iodine/defer.h

@@ -0,0 +1,105 @@
+/*
+Copyright: Boaz Segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_DEFER_H
+/**
+A library for deferring execution of code.
+
+Deferred execution can be multi-threaded, although threads aren't managed by the
+library.
+
+All deferred execution is shared among the same process and inherited by any
+forked process.
+*/
+#define H_DEFER_H
+#define LIB_DEFER_VERSION_MAJOR 0
+#define LIB_DEFER_VERSION_MINOR 1
+#define LIB_DEFER_VERSION_PATCH 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* *****************************************************************************
+Core API
+***************************************************************************** */
+
+/** Defer an execution of a function for later. Returns -1 on error.*/
+int defer(void (*func)(void *, void *), void *arg1, void *arg2);
+
+/** Performs all deferred functions until the queue had been depleted. */
+void defer_perform(void);
+
+/** returns true if there are deferred functions waiting for execution. */
+int defer_has_queue(void);
+
+/* *****************************************************************************
+Thread Pool support
+***************************************************************************** */
+
+/** an opaque thread pool type */
+typedef struct defer_pool *pool_pt;
+
+/** Starts a thread pool that will run deferred tasks in the background. */
+pool_pt defer_pool_start(unsigned int thread_count);
+/** Signals a running thread pool to stop. Returns immediately. */
+void defer_pool_stop(pool_pt pool);
+/** Waits for a running thread pool, joining threads and finishing all tasks. */
+void defer_pool_wait(pool_pt pool);
+/** Returns TRUE (1) if the pool is hadn't been signaled to finish up. */
+int defer_pool_is_active(pool_pt pool);
+
+/**
+OVERRIDE THIS to replace the default pthread implementation.
+
+Accepts a pointer to a function and a single argument that should be executed
+within a new thread.
+
+The function should allocate memory for the thread object and return a pointer
+to the allocated memory that identifies the thread.
+
+On error NULL should be returned.
+*/
+void *defer_new_thread(void *(*thread_func)(void *), pool_pt pool);
+
+/**
+OVERRIDE THIS to replace the default pthread implementation.
+
+Accepts a pointer returned from `defer_new_thread` (should also free any
+allocated memory) and joins the associated thread.
+
+Return value is ignored.
+*/
+int defer_join_thread(void *p_thr);
+
+/* *****************************************************************************
+Child Process support (`fork`)
+***************************************************************************** */
+
+/**
+ * Forks the process, starts up a thread pool and waits for all tasks to run.
+ * All existing tasks will run in all processes (multiple times).
+ *
+ * It's possible to synchronize workload across processes by using a pipe (or
+ * pipes) and a self-scheduling event that reads instructions from the pipe.
+ *
+ * This function will use SIGINT or SIGTERM to signal all the children processes
+ * to finish up and exit. It will also setup a child process reaper (which will
+ * remain active for the application's lifetime).
+ *
+ * Returns 0 on success, -1 on error and a positive number if this is a child
+ * process that was forked.
+ */
+int defer_perform_in_fork(unsigned int process_count,
+                          unsigned int thread_count);
+/** Returns TRUE (1) if the forked thread pool hadn't been signaled to finish
+ * up. */
+int defer_fork_is_active(void);
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif
+
+#endif

data/ext/iodine/evio.c

@@ -0,0 +1,263 @@
+/*
+Copyright: Boaz Segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "evio.h"
+
+#if !defined(__unix__) && !defined(__linux__) && !defined(__APPLE__) &&        \
+    !defined(__CYGWIN__)
+#error This library currently supports only Unix based systems (i.e. Linux and BSD)
+#endif
+
+#if !defined(__linux__) && !defined(__CYGWIN__)
+#include <sys/event.h>
+#else
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#endif
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+/*
+#define EVIO_MAX_EVENTS 64
+#define EVIO_TICK 256
+*/
+
+#if (EVIO_MAX_EVENTS & 1) || EVIO_MAX_EVENTS < 3
+#error EVIO_MAX_EVENTS must be an even number higher than 4
+#endif
+
+/* *****************************************************************************
+Callbacks - weak versions to be overridden.
+***************************************************************************** */
+#pragma weak evio_on_data
+void __attribute__((weak)) evio_on_data(void *arg) { (void)arg; }
+#pragma weak evio_on_ready
+void __attribute__((weak)) evio_on_ready(void *arg) { (void)arg; }
+#pragma weak evio_on_error
+void __attribute__((weak)) evio_on_error(void *arg) { (void)arg; }
+#pragma weak evio_on_close
+void __attribute__((weak)) evio_on_close(void *arg) { (void)arg; }
+
+/* *****************************************************************************
+Global data and system independant code
+***************************************************************************** */
+
+static int evio_fd = -1;
+
+/** Closes the `epoll` / `kqueue` object, releasing it's resources. */
+void evio_close() {
+  if (evio_fd != -1)
+    close(evio_fd);
+}
+
+/**
+returns true if the evio is available for adding or removing file descriptors.
+*/
+int evio_isactive(void) { return evio_fd >= 0; }
+
+/* *****************************************************************************
+Linux `epoll` implementation
+***************************************************************************** */
+#if defined(__linux__) || defined(__CYGWIN__)
+/**
+Creates the `epoll` or `kqueue` object.
+*/
+intptr_t evio_create() { return evio_fd = epoll_create1(EPOLL_CLOEXEC); }
+
+/**
+Removes a file descriptor from the polling object.
+*/
+int evio_remove(int fd) {
+  struct epoll_event chevent = {0};
+  return epoll_ctl(evio_fd, EPOLL_CTL_DEL, fd, &chevent);
+}
+
+/**
+Adds a file descriptor to the polling object.
+*/
+int evio_add(int fd, void *callback_arg) {
+  struct epoll_event chevent = {0};
+  chevent.data.ptr = (void *)callback_arg;
+  chevent.events =
+      EPOLLOUT | EPOLLIN | EPOLLET | EPOLLERR | EPOLLRDHUP | EPOLLHUP;
+  return epoll_ctl(evio_fd, EPOLL_CTL_ADD, fd, &chevent);
+}
+
+/**
+Creates a timer file descriptor, system dependent.
+*/
+intptr_t evio_open_timer(void) {
+  return timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
+}
+
+/**
+Adds a timer file descriptor, so that callbacks will be called for it's events.
+*/
+intptr_t evio_add_timer(int fd, void *callback_arg,
+                        unsigned long milliseconds) {
+  struct epoll_event chevent;
+  chevent.data.ptr = (void *)callback_arg;
+  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(fd, 0, &new_t_data, NULL);
+  return epoll_ctl(evio_fd, EPOLL_CTL_ADD, fd, &chevent);
+}
+
+/** Rearms the timer. Required only by `epoll`.*/
+void evio_reset_timer(int timer_fd) {
+  char data[8]; // void * is 8 byte long
+  if (read(timer_fd, &data, 8) < 0)
+    data[0] = 0;
+}
+
+/**
+Reviews any pending events (up to EVIO_MAX_EVENTS) and calls any callbacks.
+ */
+int evio_review(const int timeout_millisec) {
+  if (evio_fd < 0)
+    return -1;
+  struct epoll_event events[EVIO_MAX_EVENTS];
+  /* wait for events and handle them */
+  int active_count =
+      epoll_wait(evio_fd, events, EVIO_MAX_EVENTS, timeout_millisec);
+
+  if (active_count > 0) {
+    for (int i = 0; i < active_count; i++) {
+      if (events[i].events & (~(EPOLLIN | EPOLLOUT))) {
+        // errors are hendled as disconnections (on_close)
+        evio_on_error(events[i].data.ptr);
+      } else {
+        // no error, then it's an active event(s)
+        if (events[i].events & EPOLLOUT) {
+          evio_on_ready(events[i].data.ptr);
+        }
+        if (events[i].events & EPOLLIN)
+          evio_on_data(events[i].data.ptr);
+      }
+    } // end for loop
+  } else if (active_count < 0) {
+    return -1;
+  }
+  return active_count;
+}
+
+#else
+/* *****************************************************************************
+BSD `kqueue` implementation
+***************************************************************************** */
+
+/**
+Creates the `epoll` or `kqueue` object.
+*/
+intptr_t evio_create() { return evio_fd = kqueue(); }
+
+/**
+Removes a file descriptor from the polling object.
+*/
+int evio_remove(int fd) {
+  struct kevent chevent[3];
+  EV_SET(chevent, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+  EV_SET(chevent + 1, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
+  EV_SET(chevent + 2, fd, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
+  return kevent(evio_fd, chevent, 3, NULL, 0, NULL);
+}
+
+/**
+Adds a file descriptor to the polling object.
+*/
+int evio_add(int fd, void *callback_arg) {
+  struct kevent chevent[2];
+  EV_SET(chevent, fd, EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0,
+         callback_arg);
+  EV_SET(chevent + 1, fd, EVFILT_WRITE, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0,
+         callback_arg);
+  return kevent(evio_fd, chevent, 2, NULL, 0, NULL);
+}
+
+/**
+Creates a timer file descriptor, system dependent.
+*/
+intptr_t evio_open_timer() {
+#ifdef P_tmpdir
+  char template[] = P_tmpdir "evio_facil_timer_XXXXXX";
+#else
+  char template[] = "/tmp/evio_facil_timer_XXXXXX";
+#endif
+  return mkstemp(template);
+}
+
+/**
+Adds a timer file descriptor, so that callbacks will be called for it's events.
+*/
+intptr_t evio_add_timer(int fd, void *callback_arg,
+                        unsigned long milliseconds) {
+  struct kevent chevent;
+  EV_SET(&chevent, fd, EVFILT_TIMER, EV_ADD | EV_ENABLE, 0, milliseconds,
+         callback_arg);
+  return kevent(evio_fd, &chevent, 1, NULL, 0, NULL);
+}
+
+/** Rearms the timer. Required only by `epoll`.*/
+void evio_reset_timer(int timer_fd) { (void)timer_fd; }
+
+/**
+Reviews any pending events (up to EVIO_MAX_EVENTS) and calls any callbacks.
+ */
+int evio_review(const int timeout_millisec) {
+  if (evio_fd < 0)
+    return -1;
+  struct kevent events[EVIO_MAX_EVENTS];
+
+  const struct timespec timeout = {.tv_sec = (timeout_millisec / 1024),
+                                   .tv_nsec =
+                                       ((timeout_millisec % 1024) * 1000000)};
+  /* wait for events and handle them */
+  int active_count =
+      kevent(evio_fd, NULL, 0, events, EVIO_MAX_EVENTS, &timeout);
+
+  if (active_count > 0) {
+    for (int i = 0; i < active_count; i++) {
+      if (events[i].flags & (EV_EOF | EV_ERROR)) {
+        // errors are hendled as disconnections (on_close)
+        evio_on_error(events[i].udata);
+      } else {
+        // no error, then it's an active event(s)
+        if (events[i].filter == EVFILT_WRITE) {
+          evio_on_ready(events[i].udata);
+        }
+        if (events[i].filter == EVFILT_READ || events[i].filter == EVFILT_TIMER)
+          evio_on_data(events[i].udata);
+      }
+    } // end for loop
+  } else if (active_count < 0) {
+    if (errno == EINTR)
+      return 0;
+    return -1;
+  }
+  return active_count;
+}
+
+#endif /* system dependent code */

data/ext/iodine/evio.h

@@ -0,0 +1,133 @@
+/*
+Copyright: Boaz Segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_FACIL_EVIO_H
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+This is an `epoll` / `kqueue` edge triggered wrapper, allowing for portability
+between BSD and Linux polling machanisms as well as routing events to hard-coded
+callbacks (weak function symbols) instead of the polling return values.
+
+The callbacks supported by thils library:
+
+* `evio_on_data(intptr_t)` called when data is available or on timer.
+* `evio_on_ready(intptr_t)` called when writing is possible.
+* `evio_on_error(intptr_t)` called when an error occured.
+* `evio_on_close(intptr_t)` called when the connection was remotely closed.
+
+*/
+#define H_FACIL_EVIO_H
+#define LIB_EVIO_VERSION_MAJOR 0
+#define LIB_EVIO_VERSION_MINOR 1
+#define LIB_EVIO_VERSION_PATCH 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EVIO_MAX_EVENTS
+#define EVIO_MAX_EVENTS 64
+#endif
+#ifndef EVIO_TICK
+#define EVIO_TICK 256 /** in milliseconsd */
+#endif
+
+/**
+Creates the `epoll` or `kqueue` object.
+
+It's impossible to add or remove file descriptors from the polling system before
+calling this method.
+
+Returns -1 on error, otherwise returns a unique value representing the `epoll`
+or `kqueue` object. The returned value can be safely ignored.
+
+NOTE: Once an `epoll` / `kqueue` object was opened, `fork` should be avoided,
+since ALL the events will be shared among the forked proccesses (while not ALL
+the file descriptors are expected to be shared).
+*/
+intptr_t evio_create(void);
+
+/**
+Reviews any pending events (up to EVIO_MAX_EVENTS) and calls any callbacks.
+
+Waits up to `timeout_millisec` for events to occur.
+
+Returns -1 on error, otherwise returns the number of events handled.
+*/
+int evio_review(const int timeout_millisec);
+
+/**
+Closes the `epoll` / `kqueue` object, releasing it's resources.
+*/
+void evio_close(void);
+
+/**
+returns true if the evio is available for adding or removing file descriptors.
+*/
+int evio_isactive(void);
+
+/* *****************************************************************************
+Adding and removing normal file descriptors.
+*/
+
+/**
+Adds a file descriptor to the polling object.
+
+Returns -1 on error, otherwise return value is system dependent and can be
+safely ignored.
+*/
+int evio_add(int fd, void *callback_arg);
+
+/**
+Removes a file descriptor from the polling object.
+
+Returns -1 on error, otherwise return value is system dependent. If the file
+descriptor did exist in the polling object, it isn't an error.
+*/
+int evio_remove(int fd);
+
+/* *****************************************************************************
+Timers.
+*/
+
+/**
+Creates a timer file descriptor, system dependent.
+
+Returns -1 on error, or a valid fd on success.
+
+NOTE: Systems have a limit on the number of timers that can be opened.
+*/
+intptr_t evio_open_timer(void);
+
+/**
+Adds a timer file descriptor, so that callbacks will be called for it's events.
+
+Returns -1 on error, otherwise return value is system dependent.
+*/
+intptr_t evio_add_timer(int fd, void *callback_arg, unsigned long milliseconds);
+
+/**
+Re-arms the timer.
+
+Required only by `epoll`. `kqueue` timers will continue cycling regardless.
+*/
+void evio_reset_timer(int timer_fd);
+
+/* *****************************************************************************
+Callbacks - override these.
+*/
+void evio_on_data(void *);
+void evio_on_ready(void *);
+void evio_on_error(void *);
+void evio_on_close(void *);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* H_FACIL_EVIO_H */