io-event 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92dd9a674f53250bb7307226c47bfa3fc4853c8a363509fc02d99a23fcd39194
-  data.tar.gz: 6aca8cca51546cccb4696c4744e2be05b251cb81058bc9c44ca1deb42bb1930a
+  metadata.gz: 601c49b58251e4e77e4cfaf2140e834c038ca811c7980dd034f2160440ef7cb2
+  data.tar.gz: db9a38fc187e6a79d70b38fbb778670ba34d7263f15857aa155dec529117f68c
 SHA512:
-  metadata.gz: b12806d9e7e9c184bec13d81792f4f77ed68162e90ada118e89015aeba5571a66f6a8aa7395d40bf923c95d61438c4121cd238433ca6b3874320b60a44d09929
-  data.tar.gz: 27c2c7d7de7b94bddb174298996192495f8edab54b42ed58cb54f61623210504db5101924dda15e6fd7dc54df81d6fdbaff44ca42608c662febba2c17d260555
+  metadata.gz: 2fd3ca69bacc5f41c70b5502224c2baf5b66d394ea8205dfd8f4da85d61f1d5d0aae1406e649394fbd9fbb7a4b275a8502b65548341c0e2e61e8d4e3b6147ff0
+  data.tar.gz: 239deeba624f0d2a5bdffdd6ceb2d6660317b7564da5c466887f6cee1492b30fe1828f7012e65d19c59ecd997ed625d5effb7e24522b51a7e24324363590d7a2

data/ext/io/event/selector/epoll.c

@@ -152,6 +152,7 @@ void close_internal(struct IO_Event_Selector_EPoll *selector)
 		IO_Event_Interrupt_close(&selector->interrupt);
 	}
 }
+
 static
 void IO_Event_Selector_EPoll_Type_free(void *_selector)
 {

data/ext/io/event/selector/kqueue.c

@@ -371,7 +371,7 @@ VALUE IO_Event_Selector_KQueue_loop(VALUE self) {
 
 VALUE IO_Event_Selector_KQueue_idle_duration(VALUE self) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_EPoll, &IO_Event_Selector_KQueue_Type, selector);
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
 	double duration = selector->idle_duration.tv_sec + (selector->idle_duration.tv_nsec / 1000000000.0);
 	

data/lib/io/event/priority_heap.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2021, by Wander Hillen.
+# Copyright, 2021-2024, by Samuel Williams.
+
+class IO
+	module Event
+		# A priority queue implementation using a standard binary minheap. It uses straight comparison
+		# of its contents to determine priority.
+		# See <https://en.wikipedia.org/wiki/Binary_heap> for explanations of the main methods.
+		class PriorityHeap
+			def initialize
+				# The heap is represented with an array containing a binary tree. See
+				# https://en.wikipedia.org/wiki/Binary_heap#Heap_implementation for how this array
+				# is built up.
+				@contents = []
+			end
+			
+			# Returns the earliest timer or nil if the heap is empty.
+			def peek
+				@contents[0]
+			end
+			
+			# Returns the number of elements in the heap
+			def size
+				@contents.size
+			end
+			
+			# Returns the earliest timer if the heap is non-empty and removes it from the heap.
+			# Returns nil if the heap is empty. (and doesn't change the heap in that case)
+			def pop
+				# If the heap is empty:
+				if @contents.empty?
+					return nil
+				end
+				
+				# If we have only one item, no swapping is required:
+				if @contents.size == 1
+					return @contents.pop
+				end
+				
+				# Take the root of the tree:
+				value = @contents[0]
+				
+				# Remove the last item in the tree:
+				last = @contents.pop
+				
+				# Overwrite the root of the tree with the item:
+				@contents[0] = last
+				
+				# Bubble it down into place:
+				bubble_down(0)
+				
+				# validate!
+				
+				return value
+			end
+			
+			# Inserts a new timer into the heap, then rearranges elements until the heap invariant is true again.
+			def push(element)
+				# Insert the item at the end of the heap:
+				@contents.push(element)
+				
+				# Bubble it up into position:
+				bubble_up(@contents.size - 1)
+				
+				# validate!
+				
+				return self
+			end
+			
+			# Empties out the heap, discarding all elements
+			def clear!
+				@contents = []
+			end
+			
+			# Validate the heap invariant. Every element except the root must not be smaller than
+			# its parent element. Note that it MAY be equal.
+			def valid?
+				# notice we skip index 0 on purpose, because it has no parent
+				(1..(@contents.size - 1)).all? { |e| @contents[e] >= @contents[(e - 1) / 2] }
+			end
+			
+			private
+			
+			# Left here for reference, but unused.
+			# def swap(i, j)
+			# 	@contents[i], @contents[j] = @contents[j], @contents[i]
+			# end
+			
+			def bubble_up(index)
+				parent_index = (index - 1) / 2 # watch out, integer division!
+				
+				while index > 0 && @contents[index] < @contents[parent_index]
+					# if the node has a smaller value than its parent, swap these nodes
+					# to uphold the minheap invariant and update the index of the 'current'
+					# node. If the node is already at index 0, we can also stop because that
+					# is the root of the heap.
+					# swap(index, parent_index)
+					@contents[index], @contents[parent_index] = @contents[parent_index], @contents[index]
+					
+					index = parent_index
+					parent_index = (index - 1) / 2 # watch out, integer division!
+				end
+			end
+			
+			def bubble_down(index)
+				swap_value = 0
+				swap_index = nil
+				
+				while true
+					left_index = (2 * index) + 1
+					left_value = @contents[left_index]
+					
+					if left_value.nil?
+						# This node has no children so it can't bubble down any further.
+						# We're done here!
+						return
+					end
+					
+					# Determine which of the child nodes has the smallest value:
+					right_index = left_index + 1
+					right_value = @contents[right_index]
+					
+					if right_value.nil? or right_value > left_value
+						swap_value = left_value
+						swap_index = left_index
+					else
+						swap_value = right_value
+						swap_index = right_index
+					end
+					
+					if @contents[index] < swap_value
+						# No need to swap, the minheap invariant is already satisfied:
+						return
+					else
+						# At least one of the child node has a smaller value than the current node, swap current node with that child and update current node for if it might need to bubble down even further:
+						# swap(index, swap_index)
+						@contents[index], @contents[swap_index] = @contents[swap_index], @contents[index]
+						
+						index = swap_index
+					end
+				end
+			end
+		end
+	end
+end

data/lib/io/event/selector/select.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2023, by Samuel Williams.
+# Copyright, 2021-2024, by Samuel Williams.
 # Copyright, 2023, by Math Ieu.
 
 require_relative '../interrupt'

data/lib/io/event/timers.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'priority_heap'
+
+class IO
+	module Event
+		class Timers
+			class Handle
+				def initialize(offset, block)
+					@offset = offset
+					@block = block
+				end
+				
+				def < other
+					@offset < other.offset
+				end
+				
+				def > other
+					@offset > other.offset
+				end
+				
+				attr :offset
+				attr :block
+				
+				def call(...)
+					@block.call(...)
+				end
+				
+				def cancel!
+					@block = nil
+				end
+				
+				def cancelled?
+					@block.nil?
+				end
+			end
+			
+			def initialize
+				@heap = PriorityHeap.new
+				@scheduled = []
+			end
+			
+			def size
+				flush!
+				
+				return @heap.size
+			end
+			
+			def schedule(offset, block)
+				handle = Handle.new(offset, block)
+				@scheduled << handle
+				
+				return handle
+			end
+			
+			def after(timeout, &block)
+				schedule(now + timeout, block)
+			end
+			
+			def wait_interval(now = self.now)
+				flush!
+				
+				while handle = @heap.peek
+					if handle.cancelled?
+						@heap.pop
+					else
+						return handle.offset - now
+					end
+				end
+			end
+			
+			def now
+				::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+			end
+			
+			def fire(now = self.now)
+				# Flush scheduled timers into the heap:
+				flush!
+				
+				# Get the earliest timer:
+				while handle = @heap.peek
+					if handle.cancelled?
+						@heap.pop
+					elsif handle.offset <= now
+						# Remove the earliest timer from the heap:
+						@heap.pop
+						
+						# Call the block:
+						handle.call(now)
+					else
+						break
+					end
+				end
+			end
+			
+			protected def flush!
+				while handle = @scheduled.pop
+					@heap.push(handle) unless handle.cancelled?
+				end
+			end
+		end
+	end
+end

data/lib/io/event/version.rb

@@ -5,6 +5,6 @@
 
 class IO
 	module Event
-		VERSION = "1.5.1"
+		VERSION = "1.6.0"
 	end
 end

data/lib/io/event.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2023, by Samuel Williams.
+# Copyright, 2021-2024, by Samuel Williams.
 
 require_relative 'event/version'
 require_relative 'event/selector'
+require_relative 'event/timers'
 
 begin
 	require 'IO_Event'

data/license.md

@@ -1,5 +1,6 @@
 # MIT License
 
+Copyright, 2021, by Wander Hillen.  
 Copyright, 2021-2024, by Samuel Williams.  
 Copyright, 2021, by Delton Ding.  
 Copyright, 2021-2024, by Benoit Daloze.  

metadata

@@ -1,11 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Samuel Williams
 - Math Ieu
+- Wander Hillen
 - Benoit Daloze
 - Bruno Sutic
 - Alex Matchneer
@@ -43,7 +44,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-03-04 00:00:00.000000000 Z
+date: 2024-06-03 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -72,10 +73,12 @@ files:
 - lib/io/event.rb
 - lib/io/event/debug/selector.rb
 - lib/io/event/interrupt.rb
+- lib/io/event/priority_heap.rb
 - lib/io/event/selector.rb
 - lib/io/event/selector/nonblock.rb
 - lib/io/event/selector/select.rb
 - lib/io/event/support.rb
+- lib/io/event/timers.rb
 - lib/io/event/version.rb
 - license.md
 - readme.md