iodine 0.6.5 → 0.7.0

data/ext/iodine/defer.h

@@ -1,148 +0,0 @@
-/*
-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.
-
-The defer library could produce a single page "memory leak", since the last task
-buffer is nenver freed (it's left "on call" for new events). To avoid this leak
-call `defer_clear_queue` before exiting the program.
-*/
-#define H_DEFER_H
-#define LIB_DEFER_VERSION_MAJOR 0
-#define LIB_DEFER_VERSION_MINOR 1
-#define LIB_DEFER_VERSION_PATCH 2
-
-/* child process reaping is can be enabled as a default */
-#ifndef NO_CHILD_REAPER
-#define NO_CHILD_REAPER 0
-#endif
-
-#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);
-
-/** Clears the queue without performing any of the tasks. */
-void defer_clear_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.
- *
- * The `defer_idle` callback will be used to handle waiting threads. It can be
- * used to sleep, or run background tasks. It will run concurrently and
- * continuesly for all the threads in the pool that are idling.
- *
- * If `defer_idle` is NULL, a fallback to `nanosleep` will be used.
- */
-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.
- *
- * This function MUST be called in order to free the pool's data (the
- * `pool_pt`).
- */
-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 *), void *arg);
-
-/**
- * OVERRIDE THIS to replace the default pthread implementation.
- *
- * Frees the memory asociated with a thread indentifier (allows the thread to
- * run it's course, just the identifier is freed).
- */
-void defer_free_thread(void *p_thr);
-
-/**
- * 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);
-
-/**
- * OVERRIDE THIS to replace the default pthread implementation.
- *
- * Throttles or reschedules the current running thread. Default implementation
- * simply micro-sleeps.
- */
-void defer_thread_throttle(unsigned long microsec);
-
-/**
- * OVERRIDE THIS to replace the default nanosleep implementation.
- *
- * A thread entering this function should wait for new evennts.
- */
-void defer_thread_wait(pool_pt pool, void *p_thr);
-
-/**
- * OVERRIDE THIS to replace the default implementation (which does nothing).
- *
- * This should signal a single waiting thread to wake up (a new task entered the
- * queue).
- */
-void defer_thread_signal(void);
-
-/** Call this function after forking, to make sure no locks are engaged. */
-void defer_on_fork(void);
-
-#ifdef DEBUG
-/** minor testing facilities */
-void defer_test(void);
-#endif
-
-#ifdef __cplusplus
-} /* closing brace for extern "C" */
-#endif
-
-#endif

data/ext/iodine/evio.c

@@ -1,26 +0,0 @@
-/*
-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"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-/* *****************************************************************************
-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; }

data/ext/iodine/evio.h

@@ -1,161 +0,0 @@
-/*
-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` ONE-SHOT polling wrapper, allowing for portability
-between BSD and Linux polling machanisms and routing events to hard-coded
-callbacks (weak function symbols).
-
-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 2
-#define LIB_EVIO_VERSION_PATCH 0
-
-#if defined(__linux__)
-#define EVIO_ENGINE_EPOLL 1
-#elif defined(__APPLE__) || defined(__unix__)
-#define EVIO_ENGINE_KQUEUE 1
-#else
-#error This library currently supports only Unix based systems with kqueue or epoll (i.e. Linux and BSD)
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef EVIO_MAX_EVENTS
-#define EVIO_MAX_EVENTS 64
-#endif
-#ifndef EVIO_TICK
-#define EVIO_TICK 512 /** in milliseconsd */
-#endif
-
-#if (EVIO_MAX_EVENTS & 1)
-#error EVIO_MAX_EVENTS must be an EVEN number.
-#endif
-#if EVIO_MAX_EVENTS <= 3
-#error EVIO_MAX_EVENTS must be an GREATER than 4.
-#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 processes (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);
-
-/** Waits up to `timeout_millisec` for events. Events aren't reviewed. */
-int evio_wait(const int timeout_millisec);
-
-/**
-Closes the `epoll` / `kqueue` object, releasing it's resources (important if
-forking!).
-*/
-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 (ONE SHOT).
-*/
-
-/**
-Adds a file descriptor to the polling object (ONE SHOT), both for read / write
-readiness.
-
-Returns -1 on error, otherwise return value is system dependent and can be
-safely ignored.
-*/
-int evio_add(int fd, void *callback_arg);
-
-/**
-Adds a file descriptor to the polling object (ONE SHOT), to be polled for
-incoming data (`evio_on_data` wil be called).
-
-Returns -1 on error, otherwise return value is system dependent and can be
-safely ignored.
-*/
-int evio_add_read(int fd, void *callback_arg);
-
-/**
-Adds a file descriptor to the polling object (ONE SHOT), to be polled for
-outgoing buffer readiness data (`evio_on_ready` wil be called).
-
-Returns -1 on error, otherwise return value is system dependent and can be
-safely ignored.
-*/
-int evio_add_write(int fd, void *callback_arg);
-
-/**
-Removes a file descriptor from the polling object.
-*/
-void 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.
-*/
-int 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.
-*/
-int evio_set_timer(int fd, void *callback_arg, unsigned long milliseconds);
-
-/* *****************************************************************************
-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 */

data/ext/iodine/evio_callbacks.c

@@ -1,26 +0,0 @@
-/*
-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"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-/* *****************************************************************************
-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; }

data/ext/iodine/evio_epoll.c

@@ -1,251 +0,0 @@
-/*
-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"
-
-#ifdef EVIO_ENGINE_EPOLL
-
-#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>
-
-/* *****************************************************************************
-Global data and system independant code
-***************************************************************************** */
-
-/* epoll tester, in and out */
-static int evio_fd[3] = {-1, -1, -1};
-
-/** Closes the `epoll` / `kqueue` object, releasing it's resources. */
-void evio_close() {
-  for (int i = 0; i < 3; ++i) {
-    if (evio_fd[i] != -1) {
-      close(evio_fd[i]);
-      evio_fd[i] = -1;
-    }
-  }
-}
-
-/**
-returns true if the evio is available for adding or removing file descriptors.
-*/
-int evio_isactive(void) { return evio_fd[0] >= 0; }
-
-/* *****************************************************************************
-Linux `epoll` implementation
-***************************************************************************** */
-#include <sys/epoll.h>
-#include <sys/timerfd.h>
-
-/**
-Creates the `epoll` or `kqueue` object.
-*/
-intptr_t evio_create() {
-  evio_close();
-  for (int i = 0; i < 3; ++i) {
-    evio_fd[i] = epoll_create1(EPOLL_CLOEXEC);
-    if (evio_fd[i] == -1)
-      goto error;
-  }
-  for (int i = 1; i < 3; ++i) {
-    struct epoll_event chevent = {
-        .events = (EPOLLOUT | EPOLLIN), .data.fd = evio_fd[i],
-    };
-    if (epoll_ctl(evio_fd[0], EPOLL_CTL_ADD, evio_fd[i], &chevent) == -1)
-      goto error;
-  }
-  return 0;
-error:
-#if DEBUB
-  perror("ERROR: (evoid) failed to initialize");
-#endif
-  evio_close();
-  return -1;
-}
-
-/**
-Removes a file descriptor from the polling object.
-*/
-void evio_remove(int fd) {
-  if (evio_fd[0] < 0)
-    return;
-  struct epoll_event chevent = {.events = (EPOLLOUT | EPOLLIN), .data.fd = fd};
-  epoll_ctl(evio_fd[1], EPOLL_CTL_DEL, fd, &chevent);
-  epoll_ctl(evio_fd[2], EPOLL_CTL_DEL, fd, &chevent);
-}
-
-static inline int evio_add2(int fd, void *callback_arg, uint32_t events,
-                            int ep_fd) {
-  struct epoll_event chevent;
-  errno = 0;
-  chevent = (struct epoll_event){
-      .events = events, .data.ptr = (void *)callback_arg,
-  };
-  int ret = epoll_ctl(ep_fd, EPOLL_CTL_MOD, fd, &chevent);
-  if (ret == -1 && errno == ENOENT) {
-    errno = 0;
-    chevent = (struct epoll_event){
-        .events = events, .data.ptr = (void *)callback_arg,
-    };
-    ret = epoll_ctl(ep_fd, EPOLL_CTL_ADD, fd, &chevent);
-  }
-  return ret;
-}
-
-/**
-Adds a file descriptor to the polling object.
-*/
-int evio_add(int fd, void *callback_arg) {
-  if (evio_add2(fd, callback_arg,
-                (EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
-                evio_fd[1]) == -1)
-    return -1;
-  if (evio_add2(fd, callback_arg,
-                (EPOLLOUT | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
-                evio_fd[2]) == -1)
-    return -1;
-  return 0;
-}
-
-/**
-Adds a file descriptor to the polling object (ONE SHOT), to be polled for
-incoming data (`evio_on_data` wil be called).
-*/
-int evio_add_read(int fd, void *callback_arg) {
-  return evio_add2(fd, callback_arg,
-                   (EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
-                   evio_fd[1]);
-}
-
-/**
-Adds a file descriptor to the polling object (ONE SHOT), to be polled for
-outgoing buffer readiness data (`evio_on_ready` wil be called).
-*/
-int evio_add_write(int fd, void *callback_arg) {
-  return evio_add2(fd, callback_arg,
-                   (EPOLLOUT | EPOLLRDHUP | EPOLLHUP | EPOLLONESHOT),
-                   evio_fd[2]);
-}
-
-/**
-Creates a timer file descriptor, system dependent.
-*/
-int evio_open_timer(void) {
-#ifndef TFD_NONBLOCK
-  int fd = timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
-  if (fd != -1) { /* make sure it's a non-blocking timer. */
-#if defined(O_NONBLOCK)
-    /* Fixme: O_NONBLOCK is defined but broken on SunOS 4.1.x and AIX 3.2.5. */
-    int flags;
-    if (-1 == (flags = fcntl(fd, F_GETFL, 0)))
-      flags = 0;
-    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
-      goto error;
-#else
-    /* no O_NONBLOCK, use the old way of doing it */
-    static int flags = 1;
-    if (ioctl(fd, FIOBIO, &flags) == -1)
-      goto error;
-#endif
-  }
-  return fd;
-error:
-  close(fd);
-  return -1;
-#else
-  return timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
-#endif
-}
-
-/**
-Adds a timer file descriptor, so that callbacks will be called for it's events.
-*/
-int evio_set_timer(int fd, void *callback_arg, unsigned long milliseconds) {
-
-  if (evio_fd[0] < 0)
-    return -1;
-  /* clear out existing timer marker, if exists. */
-  char data[8]; // void * is 8 byte long
-  if (read(fd, &data, 8) < 0)
-    data[0] = 0;
-  /* set file's time value */
-  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;
-  if (timerfd_settime(fd, 0, &new_t_data, NULL) == -1)
-    return -1;
-  /* add to epoll */
-  return evio_add2(fd, callback_arg, (EPOLLIN | EPOLLONESHOT), evio_fd[1]);
-}
-
-/**
-Reviews any pending events (up to EVIO_MAX_EVENTS) and calls any callbacks.
- */
-int evio_review(const int timeout_millisec) {
-  if (evio_fd[0] < 0)
-    return -1;
-  struct epoll_event internal[2];
-  struct epoll_event events[EVIO_MAX_EVENTS];
-  int total = 0;
-  /* wait for events and handle them */
-  int internal_count = epoll_wait(evio_fd[0], internal, 2, timeout_millisec);
-  if (internal_count == -1)
-    return -1;
-  if (internal_count == 0)
-    return 0;
-  for (int j = 0; j < internal_count; ++j) {
-    int active_count =
-        epoll_wait(internal[j].data.fd, events, EVIO_MAX_EVENTS, 0);
-    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
-      total += active_count;
-    }
-  }
-
-  return total;
-}
-
-#include <poll.h>
-
-/** Waits up to `timeout_millisec` for events. No events are signaled. */
-int evio_wait(const int timeout_millisec) {
-  if (evio_fd[0] < 0)
-    return -1;
-  struct pollfd pollfd = {
-      .fd = evio_fd[0], .events = POLLIN,
-  };
-  return poll(&pollfd, 1, timeout_millisec);
-}
-
-#endif /* system dependent code */