On 2026/09/23 18:49, Brad Smith wrote: > 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; > ++} >
asterisk looks ok, cpu use with Telegram is looking reasonably sane once it's settled down after startup. Kirill, does it seem ok for you too?
