File Coverage

blib/lib/Hypersonic/Event.pm

Criterion	Covered	Total	%
statement	31	51	60.7
branch	13	32	40.6
condition	2	14	14.2
subroutine	7	11	63.6
pod	6	7	85.7
total	59	115	51.3

package Hypersonic::Event;

use strict;
use warnings;
use 5.010;

our $VERSION = '0.15';

# Hypersonic::Event - Event backend registry and selection
#
# This module provides a central registry for event loop backends and
# automatic detection of the best available backend for the platform.
# All event loop implementations are JIT-compiled via XS::JIT::Builder.

# Backend registry - maps name to module
my %BACKENDS = (
    io_uring    => 'Hypersonic::Event::IOUring',     # Linux 5.1+ (fastest)
    epoll       => 'Hypersonic::Event::Epoll',       # Linux (fast)
    kqueue      => 'Hypersonic::Event::Kqueue',      # BSD/macOS (fast)
    iocp        => 'Hypersonic::Event::IOCP',        # Windows (fast, completion-based)
    event_ports => 'Hypersonic::Event::EventPorts',  # Solaris/illumos (fast)
    poll        => 'Hypersonic::Event::Poll',        # POSIX fallback
    select      => 'Hypersonic::Event::Select',      # Universal (Windows support)
);

# Priority order for auto-selection (first available wins)
my @PRIORITY = qw(io_uring epoll kqueue iocp event_ports poll select);

# Check if io_uring is available (Linux 5.1+ with liburing)
sub _has_io_uring {
    return 0 unless $^O eq 'linux';

    # Check kernel version >= 5.1
    my $ver = `uname -r 2>/dev/null` || '';
    my ($major, $minor) = $ver =~ /^(\d+)\.(\d+)/;
    return 0 unless $major && ($major > 5 || ($major == 5 && $minor >= 1));

    # Check for liburing.h in common locations
    for my $path (
        '/usr/include/liburing.h',
        '/usr/local/include/liburing.h',
        '/usr/include/x86_64-linux-gnu/liburing.h',
    ) {
        return 1 if -f $path;
    }

    return 0;
}

# Select best available backend for this platform
sub best_backend {
    my $class = shift;

    # Windows prefers IOCP (falls back to select if unavailable)
    if ($^O eq 'MSWin32') {
        my $mod = $BACKENDS{iocp};
        eval "require $mod";
        return 'iocp' if !$@ && $mod->available;
        return 'select';
    }

    for my $name (@PRIORITY) {
        my $mod = $BACKENDS{$name} or next;

        # Try to load the module
        eval "require $mod";
        next if $@;

        # Check if it's available on this platform
        next unless $mod->available;

        return $name;
    }

    die "No event backend available for platform: $^O";
}

# Get backend module by name (loads if needed)
sub backend {
    my ($class, $name) = @_;
    $name //= $class->best_backend;

    my $mod = $BACKENDS{$name}
        or die "Unknown event backend: $name (available: " . join(', ', sort keys %BACKENDS) . ")";

    eval "require $mod" or die "Cannot load $mod: $@";

    die "$mod is not available on this platform"
        unless $mod->available;

    return $mod;
}

# List all backends that work on this system
sub available_backends {
    my $class = shift;
    my @available;

    for my $name (@PRIORITY) {
        my $mod = $BACKENDS{$name} or next;

        eval "require $mod";
        next if $@;

        push @available, $name if $mod->available;
    }

    return @available;
}

# Return the backend priority order
sub backend_priority {
    return @PRIORITY;
}

# List all registered backends (whether available or not)
sub all_backends {
    return sort keys %BACKENDS;
}

# Register a custom backend
sub register_backend {
    my ($class, $name, $module) = @_;

    die "Backend name required" unless $name;
    die "Module name required" unless $module;

    $BACKENDS{$name} = $module;

    return 1;
}

# Unregister a backend
sub unregister_backend {
    my ($class, $name) = @_;
    delete $BACKENDS{$name};
}

1;

__END__