io-event 1.2.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fceb6b2998209f5520e3444be04fcb1846ca35f84a17133c0e28ae484c4e729d
-  data.tar.gz: cbaf0dce0a19528e7b12d0962f571b37f6b7c459ead50f355a6ca6e0502c8a4c
+  metadata.gz: 3362ef0fb1bd825601c2476c06e99d32aa911a4e66b189b1518f40b6246b1ab6
+  data.tar.gz: a41015ab836dd0e28656427001882a87ba26a424395babb81aecd0e6d07d5fdd
 SHA512:
-  metadata.gz: 3dc61a581b53a198b40bdcfe8a46d1cf597e7748a700673ec4d2a5a26c05d0cc945e795e20e85c0d6f76e3d11cc18b9bc1e2b3b6265d0ac77f3ce01a339f0c51
-  data.tar.gz: acdf0b46bac22e77ecf2234e80c9f597ffdef01bd9a93799dfc599bd89f39e337b466f660ff60a11c1dd57d8f30527c7e4dc6c7f61de40dd01f00e5ae470ed87
+  metadata.gz: e1563b616697985daed4bb585bfdeaec00f6dfbaa9f377e99b278a9070f5ee32b475136e0f8f7626e4238a0d623a0bdb745ef03a612ec0de4b7f2eb9ef2f4510
+  data.tar.gz: d061bea14bd722ae77eddc68e81d0c4138a5de1b1b12e6fce22a45bc62391c7bf3d9dd25cf0f876361309b04d9e480a06c9752128103c999a504d01e6ffb78d3

data/ext/extconf.rb

@@ -2,27 +2,8 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021, by Samuel Williams.
-
-# Copyright, 2021, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# Copyright, 2021-2023, by Samuel Williams.
+# Copyright, 2023, by Math Ieu.
 
 return if RUBY_DESCRIPTION =~ /jruby/
 
@@ -35,6 +16,10 @@ extension_name = 'IO_Event'
 
 $CFLAGS << " -Wall -Wno-unknown-pragmas -std=c99"
 
+if ENV.key?('RUBY_DEBUG')
+	$CFLAGS << " -DRUBY_DEBUG -O0"
+end
+
 $srcs = ["io/event/event.c", "io/event/selector/selector.c"]
 $VPATH << "$(srcdir)/io/event"
 $VPATH << "$(srcdir)/io/event/selector"
@@ -50,9 +35,7 @@ if have_header('sys/epoll.h')
 	$srcs << "io/event/selector/epoll.c"
 end
 
-# The order matters, because we MUST have EV_UDATA_SPECIFIC.
-# The `have_header` call is just to add the -D to the compiler flags.
-if have_const('EV_UDATA_SPECIFIC', 'sys/event.h') and have_header('sys/event.h')
+if have_header('sys/event.h')
 	$srcs << "io/event/selector/kqueue.c"
 end
 

data/ext/io/event/selector/array.h

@@ -0,0 +1,135 @@
+// Released under the MIT License.
+// Copyright, 2023, by Samuel Williams.
+
+// Provides a simple implementation of unique pointers to elements of the given size.
+
+#include <stdlib.h>
+#include <errno.h>
+#include <assert.h>
+
+struct IO_Event_Array {
+	// The array of pointers to elements:
+	void **base;
+	
+	// The allocated size of the array:
+	size_t count;
+	
+	// The biggest item we've seen so far:
+	size_t limit;
+	
+	// The size of each element that is allocated:
+	size_t element_size;
+	
+	void (*element_initialize)(void*);
+	void (*element_free)(void*);
+};
+
+inline static void IO_Event_Array_allocate(struct IO_Event_Array *array, size_t count, size_t element_size)
+{
+	if (count) {
+		array->base = (void**)calloc(count, sizeof(void*));
+		array->count = count;
+	} else {
+		array->base = NULL;
+		array->count = 0;
+	}
+	
+	array->limit = 0;
+	array->element_size = element_size;
+}
+
+inline static size_t IO_Event_Array_memory_size(const struct IO_Event_Array *array)
+{
+	// Upper bound.
+	return array->count * (sizeof(void*) + array->element_size);
+}
+
+inline static void IO_Event_Array_free(struct IO_Event_Array *array)
+{
+	for (size_t i = 0; i < array->limit; i += 1) {
+		void *element = array->base[i];
+		if (element) {
+			array->element_free(element);
+			free(element);
+		}
+	}
+	
+	if (array->base)
+		free(array->base);
+	
+	array->base = NULL;
+	array->count = 0;
+	array->limit = 0;
+}
+
+inline static int IO_Event_Array_resize(struct IO_Event_Array *array, size_t count)
+{
+	if (count <= array->count) {
+		return 0;
+	}
+	
+	// Compute the next multiple (ideally a power of 2):
+	size_t new_count = array->count;
+	while (new_count < count) {
+		new_count *= 2;
+	}
+	
+	void **new_base = (void**)realloc(array->base, new_count * sizeof(void*));
+	
+	if (new_base == NULL) {
+		return -1;
+	}
+	
+	// Zero out the new memory:
+	memset(new_base + array->count, 0, (new_count - array->count) * sizeof(void*));
+	
+	array->base = (void**)new_base;
+	array->count = new_count;
+	
+	return 1;
+}
+
+inline static void* IO_Event_Array_lookup(struct IO_Event_Array *array, size_t index)
+{
+	size_t count = index + 1;
+	
+	// Resize the array if necessary:
+	if (count > array->count) {
+		if (IO_Event_Array_resize(array, count) == -1) {
+			return NULL;
+		}
+	}
+	
+	// Get the element:
+	void **element = array->base + index;
+	
+	// Allocate the element if it doesn't exist:
+	if (*element == NULL) {
+		*element = malloc(array->element_size);
+		
+		if (array->element_initialize) {
+			array->element_initialize(*element);
+		}
+		
+		// Update the limit:
+		if (count > array->limit) array->limit = count;
+	}
+	
+	return *element;
+}
+
+// Push a new element onto the end of the array.
+inline static void* IO_Event_Array_push(struct IO_Event_Array *array)
+{
+	return IO_Event_Array_lookup(array, array->limit);
+}
+
+inline static void IO_Event_Array_each(struct IO_Event_Array *array, void (*callback)(void*))
+{
+	for (size_t i = 0; i < array->limit; i += 1) {
+		void *element = array->base[i];
+		if (element) {
+			callback(element);
+		}
+	}
+}