agoo 2.5.5 → 2.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 409a4fe687d9ff75a67d4b25f559b5baa9df782d828bfeb1645daf696ba30035
-  data.tar.gz: a57f3d142cdee7c3ac6fc9d73fd05e2b1e5e4c90a1a2f276e4af0f69764f232b
+  metadata.gz: cad69f3ff26f2495acc27644889572dceafba42fffe0bf15b27f3ed711f764a6
+  data.tar.gz: c47ac0aca4a90eebb507bf64d3da2508bc9ce1e608d281f351ea1745ad0cb745
 SHA512:
-  metadata.gz: e4f662d43b893105689f50df6a8942ec2e86e82bec8534cff159e5a5b634a5075c1a80283c474b855c41bdff208ed1f3d605ba5b98a0591bd385202a751ac884
-  data.tar.gz: 2fd33f0f3021820efc68a4b073526fa584ba4792d10cd25806a81b11131ffcd13d35863dc1c58a11a203f03e4d10e6943dedaf6b9f9adfbfacce97c46ea4e918
+  metadata.gz: cdd0fb689b6e1afa3b65c4cbb5b2c7151b7d76202aa0c58a57d30a8bf2e1d3cdb026f15a731745eab042f762639ed29094c065354c942cf4c2b20cd99c11d53b
+  data.tar.gz: 3c82c32e1e52ccd0da66b47c94365d236c27ea4c7be7812fb9a5d8a91d880c9d6838a4734e1ddf00f77ed3fd8de3a3583f83bdf4e02c235483c27da27d0573c4

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+### 2.5.6 - 2018-11-26
+
+Even more cleanup and minor performance tweak.
+
+- Changed the use of __ and _X in C code.
+
+- Resuse of some memory for responses.
+
+- Compile option to use epoll instead of poll. (its slower)
+
 ### 2.5.5 - 2018-11-12
 
 More optimizations and some cleanup.

data/README.md

@@ -38,7 +38,7 @@ gem install agoo
 
 Agoo is Japanese for a type of flying fish. This gem flies. It is a high
 performance HTTP server that serves static resource at hundreds of thousands
-of fetchs per second. A a simple hello world Ruby handler at over 100,000
+of fetches per second. A simple hello world Ruby handler at over 100,000
 requests per second on a desktop computer. That places Agoo at about 85 times
 faster than Sinatra and 1000 times faster than Rails. In both cases the
 latency was two orders of magnitude lower or more. Checkout the

data/ext/agoo/agoo.c

@@ -7,6 +7,7 @@
 
 #include "debug.h"
 #include "error_stream.h"
+#include "log.h"
 #include "pub.h"
 #include "rack_logger.h"
 #include "request.h"
@@ -20,7 +21,7 @@
 void
 agoo_shutdown() {
     rserver_shutdown(Qnil);
-    log_close();
+    agoo_log_close();
 }
 
 /* Document-method: shutdown
@@ -49,7 +50,7 @@ ragoo_publish(VALUE self, VALUE subject, VALUE message) {
     const char	*subj = extract_subject(subject, &slen);
 
     rb_check_type(message, T_STRING);
-    server_publish(pub_publish(subj, slen, StringValuePtr(message), (int)RSTRING_LEN(message)));
+    agoo_server_publish(agoo_pub_publish(subj, slen, StringValuePtr(message), (int)RSTRING_LEN(message)));
 
     return Qnil;
 }
@@ -66,7 +67,7 @@ static VALUE
 ragoo_unsubscribe(VALUE self, VALUE subject) {
     rb_check_type(subject, T_STRING);
 
-    server_publish(pub_unsubscribe(NULL, StringValuePtr(subject), (int)RSTRING_LEN(subject)));
+    agoo_server_publish(agoo_pub_unsubscribe(NULL, StringValuePtr(subject), (int)RSTRING_LEN(subject)));
 
     return Qnil;
 }

data/ext/agoo/atomic.h

@@ -0,0 +1,120 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_ATOMIC_H
+#define AGOO_ATOMIC_H
+
+#if HAVE_STDATOMIC_H
+
+#include <stdatomic.h>
+
+#define	AGOO_ATOMIC_INT_INIT(v)	(v)
+
+static inline void
+agoo_atomic_flag_init(atomic_flag *flagp) {
+    atomic_flag_clear(flagp);
+}
+
+#else
+
+// This is a poor attempt to implement the stdatomic calls needed for this
+// project. No attempt was made to make it either fast or memory efficient. It
+// works for older compilers and it turns out the overall impact on
+// performance is small.
+
+#include <stdbool.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct _agooAtom {
+    volatile void	*value;
+    pthread_mutex_t	lock;
+} *agooAtom;
+
+#define	_Atomic(T) struct _agooAtom
+
+#define	AGOO_ATOMIC_INT_INIT(v)	{ .value = (v), .lock = PTHREAD_MUTEX_INITIALIZER }
+#define	ATOMIC_FLAG_INIT	{ .value = NULL, .lock = PTHREAD_MUTEX_INITIALIZER }
+
+typedef struct _agooAtom	atomic_flag;
+typedef struct _agooAtom	atomic_int;
+
+static inline void
+agoo_atomic_flag_init(atomic_flag *flagp) {
+    flagp->value = NULL;
+    pthread_mutex_init(&flagp->lock, NULL);
+}
+
+static inline void
+atomic_init(agooAtom a, void *value) {
+    a->value = value;
+    pthread_mutex_init(&a->lock, NULL);
+}
+
+#define atomic_store(a, v) _atomic_store((a), (void*)(v))
+
+static inline void
+_atomic_store(agooAtom a, void *value) {
+    pthread_mutex_lock(&a->lock);
+    a->value = value;
+    pthread_mutex_unlock(&a->lock);
+}
+
+static inline void*
+atomic_load(agooAtom a) {
+    void	*value;
+    
+    pthread_mutex_lock(&a->lock);
+    value = (void*)a->value;
+    pthread_mutex_unlock(&a->lock);
+
+    return value;
+}
+
+static inline int
+atomic_fetch_add(agooAtom a, int delta) {
+    int	before;
+    
+    pthread_mutex_lock(&a->lock);
+    before = (int)(long)a->value;
+    a->value = (void*)(long)(before + delta);
+    pthread_mutex_unlock(&a->lock);
+
+    return before;
+}
+
+static inline int
+atomic_fetch_sub(agooAtom a, int delta) {
+    int	before;
+    
+    pthread_mutex_lock(&a->lock);
+    before = (int)(long)a->value;
+    a->value = (void*)(long)(before - delta);
+    pthread_mutex_unlock(&a->lock);
+
+    return before;
+}
+
+static inline void
+atomic_flag_clear(agooAtom a) {
+    pthread_mutex_lock(&a->lock);
+    a->value = NULL;
+    pthread_mutex_unlock(&a->lock);
+}
+
+static inline bool
+atomic_flag_test_and_set(agooAtom a) {
+    volatile void	*prev;
+    
+    pthread_mutex_lock(&a->lock);
+    if (NULL == (prev = a->value)) {
+	a->value = (void*)"true";
+    }
+    pthread_mutex_unlock(&a->lock);
+
+    return (NULL != prev);
+}
+
+#endif
+
+#endif // AGOO_ATOMIC_H

data/ext/agoo/bind.c

@@ -13,21 +13,21 @@
 #include "debug.h"
 #include "log.h"
 
-Bind
-bind_port(Err err, int port) {
-    Bind	b = (Bind)malloc(sizeof(struct _Bind));
+agooBind
+agoo_bind_port(agooErr err, int port) {
+    agooBind	b = (agooBind)malloc(sizeof(struct _agooBind));
 
     if (NULL != b) {
 	char	id[1024];
 	
 	DEBUG_ALLOC(mem_bind, b);
-	memset(b, 0, sizeof(struct _Bind));
+	memset(b, 0, sizeof(struct _agooBind));
 	b->port = port;
 	b->family = AF_INET;
 	snprintf(id, sizeof(id) - 1, "http://:%d", port);
 	strcpy(b->scheme, "http");
 	b->id = strdup(id);
-	b->kind = CON_HTTP;
+	b->kind = AGOO_CON_HTTP;
 	b->read = NULL;
 	b->write = NULL;
 	b->events = NULL;
@@ -35,17 +35,17 @@ bind_port(Err err, int port) {
     return b;
 }
 
-static Bind
-url_tcp(Err err, const char *url, const char *scheme) {
+static agooBind
+url_tcp(agooErr err, const char *url, const char *scheme) {
     char		*colon = index(url, ':');
     struct in_addr	addr = { .s_addr = 0 };
     int			port;
-    Bind		b;
+    agooBind		b;
     
     if (NULL == colon) {
 	port = 80;
     } else if (15 < colon - url) {
-	err_set(err, ERR_ARG, "%s bind address is not valid, too long. (%s)", scheme, url);
+	agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid, too long. (%s)", scheme, url);
 	return NULL;
     } else if (':' == *url) {
 	port = atoi(colon + 1);
@@ -55,16 +55,16 @@ url_tcp(Err err, const char *url, const char *scheme) {
 	strncpy(buf, url, colon - url);
 	buf[colon - url] = '\0';
 	if (0 == inet_aton(buf, &addr)) {
-	    err_set(err, ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
+	    agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
 	    return NULL;
 	}
 	port = atoi(colon + 1);
     }
-    if (NULL != (b = (Bind)malloc(sizeof(struct _Bind)))) {
+    if (NULL != (b = (agooBind)malloc(sizeof(struct _agooBind)))) {
 	char	id[64];
 	
 	DEBUG_ALLOC(mem_bind, b);
-	memset(b, 0, sizeof(struct _Bind));
+	memset(b, 0, sizeof(struct _agooBind));
 
 	b->port = port;
 	b->addr4 = addr;
@@ -73,25 +73,25 @@ url_tcp(Err err, const char *url, const char *scheme) {
 	b->id = strdup(id);
 	strncpy(b->scheme, scheme, sizeof(b->scheme));
 	b->scheme[sizeof(b->scheme) - 1] = '\0';
-	b->kind = CON_HTTP;
+	b->kind = AGOO_CON_HTTP;
 	b->read = NULL;
 	b->write = NULL;
 	b->events = NULL;
 
 	return b;
     }
-    err_set(err, ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a Bind.");
     
     return b;
 }
 
-static Bind
-url_tcp6(Err err, const char *url, const char *scheme) {
+static agooBind
+url_tcp6(agooErr err, const char *url, const char *scheme) {
     struct in6_addr	addr;
     char		*end = index(url, ']');
     int			port = 80;
     char		buf[256];
-    Bind		b;
+    agooBind		b;
     
     if (':' == *(end + 1)) {
 	port = atoi(end + 2);
@@ -100,14 +100,14 @@ url_tcp6(Err err, const char *url, const char *scheme) {
     buf[end - url - 1] = '\0';
     memset(&addr, 0, sizeof(addr));
     if (0 == inet_pton(AF_INET6, buf, &addr)) {
-	err_set(err, ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
+	agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
 	return NULL;
     }
-    if (NULL != (b = (Bind)malloc(sizeof(struct _Bind)))) {
+    if (NULL != (b = (agooBind)malloc(sizeof(struct _agooBind)))) {
 	char	str[INET6_ADDRSTRLEN + 1];
 	
 	DEBUG_ALLOC(mem_bind, b);
-	memset(b, 0, sizeof(struct _Bind));
+	memset(b, 0, sizeof(struct _agooBind));
 
 	b->port = port;
 	b->addr6 = addr;
@@ -116,56 +116,56 @@ url_tcp6(Err err, const char *url, const char *scheme) {
 	b->id = strdup(buf);
 	strncpy(b->scheme, scheme, sizeof(b->scheme));
 	b->scheme[sizeof(b->scheme) - 1] = '\0';
-	b->kind = CON_HTTP;
+	b->kind = AGOO_CON_HTTP;
 	b->read = NULL;
 	b->write = NULL;
 	b->events = NULL;
 
 	return b;
     }
-    err_set(err, ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a Bind.");
     
     return b;
 }
 
-static Bind
-url_named(Err err, const char *url) {
+static agooBind
+url_named(agooErr err, const char *url) {
     if ('\0' == *url) {
-	err_set(err, ERR_ARG, "Named Unix sockets names must not be empty.");
+	agoo_err_set(err, AGOO_ERR_ARG, "Named Unix sockets names must not be empty.");
 	return NULL;
     } else {
-	Bind	b = (Bind)malloc(sizeof(struct _Bind));
+	agooBind	b = (agooBind)malloc(sizeof(struct _agooBind));
 
 	if (NULL != b) {
 	    const char	*fmt = "unix://%s";
 	    char	id[1024];
 	
 	    DEBUG_ALLOC(mem_bind, b);
-	    memset(b, 0, sizeof(struct _Bind));
+	    memset(b, 0, sizeof(struct _agooBind));
 	    b->name = strdup(url);
 	    snprintf(id, sizeof(id) - 1, fmt, url);
 	    b->id = strdup(id);
 	    strcpy(b->scheme, "unix");
-	    b->kind = CON_HTTP;
+	    b->kind = AGOO_CON_HTTP;
 	    b->read = NULL;
 	    b->write = NULL;
 	    b->events = NULL;
 	}
 	return b;
     }
-    err_set(err, ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a Bind.");
 
     return NULL;
 }
 
-static Bind
-url_ssl(Err err, const char *url) {
+static agooBind
+url_ssl(agooErr err, const char *url) {
     // TBD
     return NULL;
 }
 
-Bind
-bind_url(Err err, const char *url) {
+agooBind
+agoo_bind_url(agooErr err, const char *url) {
     if (0 == strncmp("tcp://", url, 6)) {
 	if ('[' == url[6]) {
 	    return url_tcp6(err, url + 6, "tcp");
@@ -207,7 +207,7 @@ bind_url(Err err, const char *url) {
 }
 
 void
-bind_destroy(Bind b) {
+agoo_bind_destroy(agooBind b) {
     DEBUG_FREE(mem_bind, b);
     free(b->id);
     free(b->name);
@@ -218,7 +218,7 @@ bind_destroy(Bind b) {
 }
 
 static int
-usual_listen(Err err, Bind b) {
+usual_listen(agooErr err, agooBind b) {
     int		optval = 1;
     int	domain = PF_INET;
 
@@ -226,9 +226,9 @@ usual_listen(Err err, Bind b) {
 	domain = PF_INET6;
     }
     if (0 >= (b->fd = socket(domain, SOCK_STREAM, IPPROTO_TCP))) {
-	log_cat(&error_cat, "Server failed to open server socket on port %d. %s.", b->port, strerror(errno));
+	agoo_log_cat(&agoo_error_cat, "Server failed to open server socket on port %d. %s.", b->port, strerror(errno));
 
-	return err_set(err, errno, "Server failed to open server socket. %s.", strerror(errno));
+	return agoo_err_set(err, errno, "Server failed to open server socket. %s.", strerror(errno));
     }
 #ifdef OSX_OS 
     setsockopt(b->fd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
@@ -244,9 +244,9 @@ usual_listen(Err err, Bind b) {
 	addr.sin6_addr = b->addr6;
 	addr.sin6_port = htons(b->port);
 	if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
-	    log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+	    agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
 
-	    return err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
+	    return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
 	}
     } else {
 	struct sockaddr_in	addr;
@@ -256,47 +256,47 @@ usual_listen(Err err, Bind b) {
 	addr.sin_addr = b->addr4;
 	addr.sin_port = htons(b->port);
 	if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
-	    log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+	    agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
 
-	    return err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
+	    return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
 	}
     }
     listen(b->fd, 1000);
 
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 static int
-named_listen(Err err, Bind b) {
+named_listen(agooErr err, agooBind b) {
     struct sockaddr_un	addr;
 
     remove(b->name);
     if (0 >= (b->fd = socket(AF_UNIX, SOCK_STREAM, 0))) {
-	log_cat(&error_cat, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
+	agoo_log_cat(&agoo_error_cat, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
 
-	return err_set(err, errno, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
+	return agoo_err_set(err, errno, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
     }
     memset(&addr, 0, sizeof(addr));
     addr.sun_family = AF_UNIX;
     strcpy(addr.sun_path, b->name);
     if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
-	log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+	agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
 
-	return err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
+	return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
     }
     listen(b->fd, 100);
 
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 static int
-ssl_listen(Err err, Bind b) {
+ssl_listen(agooErr err, agooBind b) {
     // TBD
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 int
-bind_listen(Err err, Bind b) {
+agoo_bind_listen(agooErr err, agooBind b) {
     if (NULL != b->name) {
 	return named_listen(err, b);
     }
@@ -307,7 +307,7 @@ bind_listen(Err err, Bind b) {
 }
 
 void
-bind_close(Bind b) {
+agoo_bind_close(agooBind b) {
     if (0 != b->fd) {
 	close(b->fd);
 	b->fd = 0;