On Tue, Sep 22, 2026 at 09:17:19PM +0100, Stuart Henderson wrote: > On 2026/09/22 21:04, Kirill A. Korinsky wrote: > > Well, check-shlib-syms states that here no difference... probably > > SHARED_LIBS really doesn't need a bump. > > it seemed that way to me (and I was quite happy to get rid of all those > patches!). > > > Anyway, here a diff which a bit hacky and fixes regression in tdesktop and > > 64gram, and I think in other similar places. > > > Thoughts? > > thanks, that makes sense. ok.
This looks like a more appropraite fix. Index: Makefile =================================================================== RCS file: /cvs/ports/devel/libdispatch/Makefile,v retrieving revision 1.13 diff -u -p -u -p -r1.13 Makefile --- Makefile 22 Sep 2026 20:26:42 -0000 1.13 +++ Makefile 23 Sep 2026 22:24:43 -0000 @@ -2,7 +2,7 @@ COMMENT = support for concurrent code ex PKGNAME = libdispatch-$V V = 6.4.0 -REVISION = 0 +REVISION = 1 GH_ACCOUNT = apple GH_PROJECT = swift-corelibs-libdispatch Index: patches/patch-src_event_event_config_h =================================================================== RCS file: patches/patch-src_event_event_config_h diff -N patches/patch-src_event_event_config_h --- patches/patch-src_event_event_config_h 22 Sep 2026 20:26:42 -0000 1.1 +++ /dev/null 1 Jan 1970 00:00:00 -0000 @@ -1,18 +0,0 @@ -https://github.com/swiftlang/swift-corelibs-libdispatch/pull/960 - -Index: src/event/event_config.h ---- src/event/event_config.h.orig -+++ src/event/event_config.h -@@ -116,9 +116,10 @@ - # define NOTE_FUNLOCK 0x00000100 - # endif - --// FreeBSD's kevent does not support those -+// FreeBSD's and OpenBSD's kevent does not support those -+// OpenBSD's NOTE_ABSTIME uses CLOCK_REALTIME - # ifndef NOTE_ABSOLUTE --# ifdef NOTE_ABSTIME -+# if defined(NOTE_ABSTIME) && !defined(__OpenBSD__) - # define NOTE_ABSOLUTE NOTE_ABSTIME - # else - # define NOTE_ABSOLUTE 0 Index: patches/patch-src_event_event_kevent_c =================================================================== RCS file: patches/patch-src_event_event_kevent_c diff -N patches/patch-src_event_event_kevent_c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-src_event_event_kevent_c 23 Sep 2026 22:24:43 -0000 @@ -0,0 +1,41 @@ +- Use relative kqueue deadlines for BSD uptime and monotonic timers + https://github.com/swiftlang/swift-corelibs-libdispatch/pull/943 + +Index: src/event/event_kevent.c +--- src/event/event_kevent.c.orig ++++ src/event/event_kevent.c +@@ -60,10 +60,22 @@ DISPATCH_STATIC_GLOBAL(struct dispatch_muxnote_bucket_ + #define DISPATCH_NOTE_CLOCK_UPTIME 0 + #endif + ++#if defined(__FreeBSD__) || defined(__OpenBSD__) ++// BSD NOTE_ABSTIME deadlines use CLOCK_REALTIME. ++#define DISPATCH_NOTE_ABSOLUTE_WALL NOTE_ABSOLUTE ++#define DISPATCH_NOTE_ABSOLUTE_MONOTONIC 0 ++#define DISPATCH_NOTE_ABSOLUTE_UPTIME 0 ++#else ++#define DISPATCH_NOTE_ABSOLUTE_WALL NOTE_ABSOLUTE ++#define DISPATCH_NOTE_ABSOLUTE_MONOTONIC NOTE_ABSOLUTE ++#define DISPATCH_NOTE_ABSOLUTE_UPTIME NOTE_ABSOLUTE ++#endif ++ + static const uint32_t _dispatch_timer_index_to_fflags[] = { + #define DISPATCH_TIMER_FFLAGS_INIT(kind, qos, note) \ + [DISPATCH_TIMER_INDEX(DISPATCH_CLOCK_##kind, DISPATCH_TIMER_QOS_##qos)] = \ +- DISPATCH_NOTE_CLOCK_##kind | NOTE_ABSOLUTE | NOTE_LEEWAY | (note) ++ DISPATCH_NOTE_CLOCK_##kind | DISPATCH_NOTE_ABSOLUTE_##kind | \ ++ NOTE_LEEWAY | (note) + DISPATCH_TIMER_FFLAGS_INIT(WALL, NORMAL, 0), + DISPATCH_TIMER_FFLAGS_INIT(UPTIME, NORMAL, 0), + DISPATCH_TIMER_FFLAGS_INIT(MONOTONIC, NORMAL, 0), +@@ -2406,6 +2418,10 @@ _dispatch_event_loop_timer_arm(dispatch_timer_heap_t d + } + #if !NOTE_ABSOLUTE + target = range.delay; ++#elif defined(__FreeBSD__) || defined(__OpenBSD__) ++ if (clock != DISPATCH_CLOCK_WALL) { ++ target -= _dispatch_time_now_cached(clock, nows); ++ } + #endif + + _dispatch_event_loop_timer_program(dth, tidx, target, range.leeway, Index: patches/patch-tests_CMakeLists_txt =================================================================== RCS file: patches/patch-tests_CMakeLists_txt diff -N patches/patch-tests_CMakeLists_txt --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-tests_CMakeLists_txt 23 Sep 2026 22:24:43 -0000 @@ -0,0 +1,17 @@ +- Use relative kqueue deadlines for BSD uptime and monotonic timers + https://github.com/swiftlang/swift-corelibs-libdispatch/pull/943 + +Index: tests/CMakeLists.txt +--- tests/CMakeLists.txt.orig ++++ tests/CMakeLists.txt +@@ -140,6 +140,10 @@ set(DISPATCH_C_TESTS + io_pipe_close + select) + ++if(UNIX) ++ list(APPEND DISPATCH_C_TESTS timer_idle) ++endif() ++ + # Tests that usually pass, but occasionally fail. + # Excluded by default for purposes of Swift CI + if(EXTENDED_TEST_SUITE) Index: patches/patch-tests_dispatch_timer_idle_c =================================================================== RCS file: patches/patch-tests_dispatch_timer_idle_c diff -N patches/patch-tests_dispatch_timer_idle_c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-tests_dispatch_timer_idle_c 23 Sep 2026 22:24:43 -0000 @@ -0,0 +1,157 @@ +- Use relative kqueue deadlines for BSD uptime and monotonic timers + https://github.com/swiftlang/swift-corelibs-libdispatch/pull/943 + +Index: tests/dispatch_timer_idle.c +--- tests/dispatch_timer_idle.c.orig ++++ tests/dispatch_timer_idle.c +@@ -0,0 +1,150 @@ ++/* ++ * This source file is part of the Swift.org open source project ++ * ++ * Copyright (c) 2026 Apple Inc. and the Swift project authors ++ * ++ * Licensed under Apache License v2.0 with Runtime Library Exception ++ * ++ * See https://swift.org/LICENSE.txt for license information ++ * See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors ++ * ++ */ ++ ++#include <dispatch/dispatch.h> ++ ++#include <bsdtests.h> ++#include "dispatch_test.h" ++ ++#include <errno.h> ++#include <stdatomic.h> ++#include <stdint.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <sys/resource.h> ++#include <time.h> ++ ++#define OBSERVATION_SECONDS 0.25 ++#define MAX_IDLE_CPU_RATIO 0.20 ++ ++static _Atomic int timer_fired; ++static volatile uint64_t spin_sink; ++ ++static void ++monotonic_now(struct timespec *value) ++{ ++ if (clock_gettime(CLOCK_MONOTONIC, value) != 0) { ++ perror("clock_gettime"); ++ exit(EXIT_FAILURE); ++ } ++} ++ ++static double ++seconds_between(struct timespec start, struct timespec end) ++{ ++ return (double)(end.tv_sec - start.tv_sec) + ++ (double)(end.tv_nsec - start.tv_nsec) / (double)NSEC_PER_SEC; ++} ++ ++static double ++timeval_seconds(struct timeval value) ++{ ++ return (double)value.tv_sec + ++ (double)value.tv_usec / (double)USEC_PER_SEC; ++} ++ ++static double ++process_cpu_seconds(void) ++{ ++ struct rusage usage; ++ ++ if (getrusage(RUSAGE_SELF, &usage) != 0) { ++ perror("getrusage"); ++ exit(EXIT_FAILURE); ++ } ++ return timeval_seconds(usage.ru_utime) + timeval_seconds(usage.ru_stime); ++} ++ ++static double ++measure_busy_cpu_ratio(void) ++{ ++ struct timespec wall_start, wall_now; ++ double cpu_start, cpu_end; ++ ++ monotonic_now(&wall_start); ++ cpu_start = process_cpu_seconds(); ++ do { ++ spin_sink++; ++ monotonic_now(&wall_now); ++ } while (seconds_between(wall_start, wall_now) < OBSERVATION_SECONDS); ++ cpu_end = process_cpu_seconds(); ++ ++ return (cpu_end - cpu_start) / seconds_between(wall_start, wall_now); ++} ++ ++static void ++unexpected_timer_fire(void *context) ++{ ++ (void)context; ++ atomic_store_explicit(&timer_fired, 1, memory_order_relaxed); ++} ++ ++static void ++observe_idle_timer(double *wall_seconds, double *cpu_seconds) ++{ ++ struct timespec wall_start, wall_end; ++ struct timespec remaining = { ++ .tv_sec = 0, ++ .tv_nsec = (long)(OBSERVATION_SECONDS * (double)NSEC_PER_SEC), ++ }; ++ dispatch_source_t timer; ++ double cpu_start; ++ int sleep_result; ++ ++ timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, ++ dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)); ++ test_ptr_notnull("dispatch_source_create", timer); ++ dispatch_source_set_event_handler_f(timer, unexpected_timer_fire); ++ dispatch_source_set_timer(timer, ++ dispatch_time(DISPATCH_TIME_NOW, 3600 * NSEC_PER_SEC), ++ DISPATCH_TIME_FOREVER, 0); ++ dispatch_resume(timer); ++ ++ monotonic_now(&wall_start); ++ cpu_start = process_cpu_seconds(); ++ do { ++ sleep_result = nanosleep(&remaining, &remaining); ++ } while (sleep_result == -1 && errno == EINTR); ++ if (sleep_result != 0) { ++ perror("nanosleep"); ++ exit(EXIT_FAILURE); ++ } ++ *cpu_seconds = process_cpu_seconds() - cpu_start; ++ monotonic_now(&wall_end); ++ *wall_seconds = seconds_between(wall_start, wall_end); ++ ++ dispatch_source_cancel(timer); ++ dispatch_release(timer); ++} ++ ++int ++main(void) ++{ ++ double busy_cpu_ratio, idle_wall_seconds, idle_cpu_seconds; ++ double idle_cpu_ratio, relative_cpu_ratio; ++ ++ dispatch_test_start("Dispatch idle timer CPU usage"); ++ ++ busy_cpu_ratio = measure_busy_cpu_ratio(); ++ observe_idle_timer(&idle_wall_seconds, &idle_cpu_seconds); ++ idle_cpu_ratio = idle_cpu_seconds / idle_wall_seconds; ++ relative_cpu_ratio = idle_cpu_ratio / busy_cpu_ratio; ++ ++ fprintf(stderr, "idle=%f busy=%f relative=%f\n", ++ idle_cpu_ratio, busy_cpu_ratio, relative_cpu_ratio); ++ test_long("timer fired", atomic_load_explicit(&timer_fired, ++ memory_order_relaxed), 0); ++ test_double_less_than("idle timer CPU ratio", relative_cpu_ratio, ++ MAX_IDLE_CPU_RATIO); ++ test_stop(); ++ return 0; ++}
