Marge Bot pushed to branch wip/marge_bot_batch_merge_job at Glasgow Haskell Compiler / GHC Commits: 1cb1d672 by Wen Kokke at 2026-05-06T09:53:40-04:00 rts: Add dynamic trace flags API This commit adds an API to the RTS (exposed via Rts.h) that allows users to dynamically change the trace flags. Prior to this commit, users were able to stop and start the profiling and heap profiling timers (via startProfTimer/stopProfTimer and startHeapProfTimer/stopHeapProfTimer). This extends that functionality to also cover the core event types. The getTraceFlag/setTraceFlag functions read and write the values of the trace flag cache, which is allocated by Trace.c, rather than modifying the members of RtsFlags.TraceFlags. This is done under the assumption that the members of RtsFlags should not be modified after RTS initialisation. Consequently, if the user modifies the trace flags using setTraceFlag, the object returned by getTraceFlags (from base) will not reflect these changes. The trace flags are not protected by locks of any sort. Hence, these functions are not thread-safe. However, the trace flags are not modified by the RTS after initialisation, only read, so the race conditions introduced by one user modifying them are most likely benign. This PR also puts the trace flag cache in a single global struct, as opposed to a collection of global variables, and changes the types of the individual flags from uint8_t to bool, as these have the same size on both Clang and GCC and are a better semantic match. Prior to the change to uint8_t, they had type int, see 42c47cd6. Even with its deprecation in C23, I don't think there should be any issue depending on stdbool.h. The TRACE_X macros are redefined to access the global struct, with values cast to const bool to ensure they are read-only. - - - - - 9d54dc94 by Wen Kokke at 2026-05-06T09:53:40-04:00 rts: Ensure TRACE_X values are used in place of RtsFlags.TraceFlags.X - - - - - 418d737b by Wen Kokke at 2026-05-06T09:53:40-04:00 rts: Fix nonmoving-GC tracing The current nonmoving-GC tracing functions were written in a different style from the other tracing functions. They were directly implemented as, e.g., a traceConcMarkEnd function that called postConcMarkEnd. The other tracing functions are implemented as, e.g., traceThreadLabel_, a function that posts the thread label event, and traceThreadLabel, a macro that checks whether TRACE_scheduler is set. This commit fixes that implementation, and ensures that the nonmoving-GC tracing functions only emit events if nonmoving-GC tracing is enabled. - - - - - 99f4afa4 by Wen Kokke at 2026-05-06T09:53:40-04:00 rts: Add SymI_HasProto for get/setTraceFlag - - - - - 7e9eb8b9 by Wen Kokke at 2026-05-06T09:53:40-04:00 rts: Add SymI_HasProto for start/endEventLogging - - - - - 3a3045fb by Wen Kokke at 2026-05-06T09:53:41-04:00 rts: Add changelog entry - - - - - a3b339a4 by Teo Camarasu at 2026-05-06T09:54:25-04:00 interface-stability/base: don't distinguish ws-32 The interface of base is identical when the Word size is 32bits. Therefore, there is no need to have another file for this case. So, we delete it. Step towards: #26752 - - - - - eb922183 by Duncan Coutts at 2026-05-07T14:28:50+01:00 Add a rts posix FdWakup utility module This will be used to implement wakeupIOManager for in-RTS I/O managers. It provides a notification/wakeup mechanism using FDs, suitable for situations when a thread is blocked on a set of fds anyway. It uses the classic self-pipe trick, or equivalently eventfd on supported platforms. This will initially be used to implement prompt interrupt or shutdown of the posix ticker thread. - - - - - 01b0e233 by Duncan Coutts at 2026-05-07T14:28:50+01:00 Add prompt shutdown to the pthread ticker implementation. The Linux timerfd ticker monitors a pipe which is used by exitTicker to ensure a prompt wakeup and shutdown. The pthread ticker lacked this and so would only exit at the next ticker wakeup (10ms by default). This patch adds the same mechanism to the pthread ticker. This changes the pthread ticker from waiting by using nanosleep() to waiting using either ppoll() or select(), so that it can wait on both a time and a file descriptor. On Linux at least, a test program to compare the timing jitter of these APIs shows that using nanpsleep, ppoll or select makes no statistical difference to the maximum or average jitter. This is a step towards unifying the posix ticker implementations, so that we can have just one portable one (albeit with some limited cpp). It is also a step towards using the ticker as part of a more general implementation of wakeUpRts, since this will require a method to wake the rts from a signal handler context (ctl-c handler). - - - - - bc41d646 by Duncan Coutts at 2026-05-07T14:28:50+01:00 Update ticker header commentary It was antique and didn't apply even to the previous implementation, and certainly not to the updated one. - - - - - 4ed9a386 by Duncan Coutts at 2026-05-07T14:28:50+01:00 Remove the timerfd-based ticker implementation There does not appear to be any remaining advantage on Linux to using the timerfd ticker implementation over the portable one (using ppoll on Linux for precise timing). The eventfd implementation was originally added at a time when Linux was still using a signal based implementation. So it made sense at the time. See (closed) issue #10840. - - - - - 97504fa6 by Duncan Coutts at 2026-05-07T14:28:50+01:00 Consolidate to a single posix ticker implementation Previously we had four implementations, two using signals and two using threads. Having just one should make behaviour more consistent between platforms, and should make maintenance easier. - - - - - 79330223 by Facundo Domínguez at 2026-05-07T13:40:13-04:00 Generalize so_inline to specify which bindings should be preserved This commit generalizes the so_inline option of the simple optimizer so we can indicate with a predicate the specific bindings that should be kept. This feature is important for the LiquidHaskell plugin, which relies on the simple optimizer to make core programs easier to read, but needs to preserve bindings that are relevant for verification. See https://gitlab.haskell.org/ghc/ghc/-/issues/24386 for the full discussion. - - - - - 18 changed files: - + changelog.d/dynamic-trace-flags - + changelog.d/so_inline_is_a_predicate - compiler/GHC/Core/SimpleOpt.hs - compiler/GHC/Driver/Config.hs - rts/RtsSymbols.c - rts/Trace.c - rts/Trace.h - rts/include/rts/EventLogWriter.h - + rts/posix/FdWakeup.c - + rts/posix/FdWakeup.h - rts/posix/Ticker.c - − rts/posix/ticker/Pthread.c - − rts/posix/ticker/TimerFd.c - rts/rts.cabal - rts/sm/NonMoving.c - + testsuite/tests/ghc-api/T24386.hs - testsuite/tests/ghc-api/all.T - − testsuite/tests/interface-stability/base-exports.stdout-ws-32 Changes: ===================================== changelog.d/dynamic-trace-flags ===================================== @@ -0,0 +1,10 @@ +section: compiler +synopsis: Support dynamic trace flags in RTS +issues: #27186 +mrs: !15936 + +description: { + The RTS API now exposes the `RUNTIME_TRACE_FLAG` type and + the `getTraceFlags` and `setTraceFlags` functions that can be used to + change the trace flags at runtime. +} ===================================== changelog.d/so_inline_is_a_predicate ===================================== @@ -0,0 +1,12 @@ +section: ghc-lib +synopsis: Generalize the ``so_inline`` option of the simple optimizer to a predicate + that selects the bindings to preserve. + +issues: #24386 +mrs: !15988 + +description: { + The ``so_inline`` option of the simple optimizer was a boolean and now it is a + predicate taking a binding ``Id`` and returning a boolean. ``const b`` has the + same effect as formerly setting ``b``. +} ===================================== compiler/GHC/Core/SimpleOpt.hs ===================================== @@ -108,6 +108,93 @@ unfolding-info to the scrutinee's Id.) * Bad bad bad: then the x in case x of ... may be replaced with a version that has an unfolding. See ticket #25790 + +Note [Controlling inlining in the simple optimiser] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Sometimes, plugins that analyse Core programs may want to prevent the +inlining of certain bindings. While they could avoid running the simple +optimiser at all, that would leave plenty of generated bindings that do not +have a direct correspondence to the source code. + +For example, consider the following Haskell code: + + foo = z + where + z = z1 + z2 + z1 = 42 + z2 = 1 + +Before the simple optimizer runs, the Core programs is roughly: + + foo = + let + foo_aIb = + let + z2 + = let + z2_aHG = 1 + in + z2_aHG + in + let + z1 = + let + z1_aHR = 42 + in + z1_aHR + in + let + z = + let + z_aI5 = z1 + z2 + in + z_aI5 + in + z + in + foo_aIb + +After the simple optimizer runs, the Core program is: + + foo = 42 + 1 + +And the bindings for `z`, `z1`, and `z2` are all gone. If a plugin wanted to +analyse those bindings, it would have to deal with the unsimplified Core, but +cope with the generated bindings `z2_aHG`, `z1_aHR`, `z_aI5`, and `foo_aIb`, +all of which have no direct correspondence to the source code. + +Fortunately, a plugin can still improve the output by using the `so_inline` +field of `SimpleOpts`. The `so_inline` field is a /function/ of type +`(Id -> Bool)` that tells the simple optimiser whether or not to inline the `Id`. +The client of the GHC can thereby control precisely which bindings are inlined +and which are not. For instance, + + simplOptPgm + (defaultSimpleOpts { so_inline = (`notElem` ["z", "z1", "z2"]) }) + ... + +produces the following Core program: + + foo = + let + z2 = 1 + in + let + z1 = 42 + in + let + z = z1 + z2 + in + z + +which contains the bindings of interest and little else. + +For the specifics of how this affects a concrete plugin (Liquid Haskell), see +the discussion in https://gitlab.haskell.org/ghc/ghc/-/issues/24386 + +In addition to supporting clients of the GHC API, there is another use of +`so_inline` mentioned in 'simpleOptExprNoInline'. + -} -- | Simple optimiser options @@ -115,8 +202,11 @@ data SimpleOpts = SimpleOpts { so_uf_opts :: !UnfoldingOpts -- ^ Unfolding options , so_co_opts :: !OptCoercionOpts -- ^ Coercion optimiser options , so_eta_red :: !Bool -- ^ Eta reduction on? - , so_inline :: !Bool -- ^ False <=> do no inlining whatsoever, - -- even for trivial or used-once things + , so_inline :: !(Var -> Bool) -- ^ False <=> do no inline the given + -- binding whatsoever, even for trivial or + -- used-once things + -- + -- See Note [Controlling inlining in the simple optimiser] } -- | Default options for the Simple optimiser. @@ -125,7 +215,7 @@ defaultSimpleOpts = SimpleOpts { so_uf_opts = defaultUnfoldingOpts , so_co_opts = OptCoercionOpts { optCoercionEnabled = False } , so_eta_red = False - , so_inline = True + , so_inline = const True } simpleOptExpr :: HasDebugCallStack => SimpleOpts -> CoreExpr -> CoreExpr @@ -170,7 +260,7 @@ simpleOptExprNoInline :: HasDebugCallStack => SimpleOpts -> CoreExpr -> CoreExpr simpleOptExprNoInline opts expr = simple_opt_expr init_env expr where - init_opts = opts { so_inline = False } + init_opts = opts { so_inline = const False } init_env = (emptyEnv init_opts) { soe_subst = init_subst } init_subst = mkEmptySubst (mkInScopeSet (exprFreeVars expr)) @@ -639,12 +729,12 @@ simple_bind_pair env@(SOE { soe_inl = inl_env, soe_subst = subst, soe_opts = opt pre_inline_unconditionally :: Bool pre_inline_unconditionally - | not (so_inline opts) = False -- Not if so_inline is False - | isExportedId in_bndr = False - | stable_unf = False - | not active = False -- Note [Inline prag in simplOpt] - | not (safe_to_inline occ) = False - | otherwise = True + | not (so_inline opts in_bndr) = False -- Not if so_inline is False + | isExportedId in_bndr = False + | stable_unf = False + | not active = False -- Note [Inline prag in simplOpt] + | not (safe_to_inline occ) = False + | otherwise = True -- Unconditionally safe to inline safe_to_inline :: OccInfo -> Bool @@ -711,15 +801,15 @@ simple_out_bind_pair env@(SOE { soe_subst = subst, soe_opts = opts }) post_inline_unconditionally :: Bool post_inline_unconditionally - | not (so_inline opts) = False -- Not if so_inline is False - | isExportedId in_bndr = False -- Note [Exported Ids and trivial RHSs] - | stable_unf = False -- Note [Stable unfoldings and postInlineUnconditionally] - | not active = False -- in GHC.Core.Opt.Simplify.Utils - | is_loop_breaker = False -- If it's a loop-breaker of any kind, don't inline - -- because it might be referred to "earlier" - | exprIsTrivial out_rhs = True - | coercible_hack = True - | otherwise = False + | not (so_inline opts in_bndr) = False -- Not if so_inline is False + | isExportedId in_bndr = False -- Note [Exported Ids and trivial RHSs] + | stable_unf = False -- Note [Stable unfoldings and postInlineUnconditionally] + | not active = False -- in GHC.Core.Opt.Simplify.Utils + | is_loop_breaker = False -- If it's a loop-breaker of any kind, don't inline + -- because it might be referred to "earlier" + | exprIsTrivial out_rhs = True + | coercible_hack = True + | otherwise = False is_loop_breaker = isWeakLoopBreaker occ_info ===================================== compiler/GHC/Driver/Config.hs ===================================== @@ -26,7 +26,7 @@ initSimpleOpts dflags = SimpleOpts { so_uf_opts = unfoldingOpts dflags , so_co_opts = initOptCoercionOpts dflags , so_eta_red = gopt Opt_DoEtaReduction dflags - , so_inline = True + , so_inline = const True } -- | Instruct the interpreter evaluation to break... ===================================== rts/RtsSymbols.c ===================================== @@ -540,7 +540,12 @@ extern char **environ; SymI_HasProto(__word_encodeFloat) \ SymI_HasDataProto(stg_atomicallyzh) \ SymI_HasProto(barf) \ + SymI_HasProto(startEventLogging) \ + SymI_HasProto(endEventLogging) \ SymI_HasProto(flushEventLog) \ + SymI_HasProto(flushEventLog) \ + SymI_HasProto(getTraceFlag) \ + SymI_HasProto(setTraceFlag) \ SymI_HasProto(deRefStablePtr) \ SymI_HasProto(debugBelch) \ SymI_HasProto(errorBelch) \ ===================================== rts/Trace.c ===================================== @@ -29,14 +29,54 @@ #include <unistd.h> #endif -// events -uint8_t TRACE_sched; -uint8_t TRACE_gc; -uint8_t TRACE_nonmoving_gc; -uint8_t TRACE_spark_sampled; -uint8_t TRACE_spark_full; -uint8_t TRACE_user; -uint8_t TRACE_cap; +RUNTIME_TRACE_FLAG_CACHE RuntimeTraceFlagCache = {0}; + +bool getTraceFlag(RUNTIME_TRACE_FLAG flag) { + switch (flag) { + case TRACE_SCHEDULER: + return RuntimeTraceFlagCache.scheduler; + case TRACE_GC: + return RuntimeTraceFlagCache.gc; + case TRACE_NONMOVING_GC: + return RuntimeTraceFlagCache.nonmoving_gc; + case TRACE_SPARK_SAMPLED: + return RuntimeTraceFlagCache.spark_sampled; + case TRACE_SPARK_FULL: + return RuntimeTraceFlagCache.spark_full; + case TRACE_USER: + return RuntimeTraceFlagCache.user; + case TRACE_CAP: + return RuntimeTraceFlagCache.cap; + default: + return false; + } +} + +void setTraceFlag(RUNTIME_TRACE_FLAG flag, bool value) { + switch (flag) { + case TRACE_SCHEDULER: + RuntimeTraceFlagCache.scheduler = value; + break; + case TRACE_GC: + RuntimeTraceFlagCache.gc = value; + break; + case TRACE_NONMOVING_GC: + RuntimeTraceFlagCache.nonmoving_gc = value; + break; + case TRACE_SPARK_SAMPLED: + RuntimeTraceFlagCache.spark_sampled = value; + break; + case TRACE_SPARK_FULL: + RuntimeTraceFlagCache.spark_full = value; + break; + case TRACE_USER: + RuntimeTraceFlagCache.user = value; + break; + case TRACE_CAP: + RuntimeTraceFlagCache.cap = value; + break; + } +} #if defined(THREADED_RTS) static Mutex trace_utx; @@ -51,43 +91,41 @@ static void traceCap_stderr(Capability *cap, char *msg, ...); --------------------------------------------------------------------------- */ /* - * Update the TRACE_* globals. Must be called whenever RtsFlags.TraceFlags is - * modified. + * Initialise the runtime trace flags from RtsFlags.TraceFlags. */ -static void updateTraceFlagCache (void) -{ - // -Ds turns on scheduler tracing too - TRACE_sched = - RtsFlags.TraceFlags.scheduler || - RtsFlags.DebugFlags.scheduler; - - // -Dg turns on gc tracing too - TRACE_gc = - RtsFlags.TraceFlags.gc || - RtsFlags.DebugFlags.gc || - RtsFlags.DebugFlags.scheduler; - - TRACE_nonmoving_gc = - RtsFlags.TraceFlags.nonmoving_gc; - - TRACE_spark_sampled = - RtsFlags.TraceFlags.sparks_sampled; - - // -Dr turns on full spark tracing - TRACE_spark_full = - RtsFlags.TraceFlags.sparks_full || - RtsFlags.DebugFlags.sparks; - - TRACE_user = - RtsFlags.TraceFlags.user; - - // We trace cap events if we're tracing anything else - TRACE_cap = - TRACE_sched || - TRACE_gc || - TRACE_spark_sampled || - TRACE_spark_full || - TRACE_user; +static void updateTraceFlagCache(void) { + // -Ds turns on scheduler tracing too + RuntimeTraceFlagCache.scheduler = + RtsFlags.TraceFlags.scheduler || + RtsFlags.DebugFlags.scheduler; + + // -Dg turns on gc tracing too + RuntimeTraceFlagCache.gc = + RtsFlags.TraceFlags.gc || + RtsFlags.DebugFlags.gc || + RtsFlags.DebugFlags.scheduler; + + RuntimeTraceFlagCache.nonmoving_gc = + RtsFlags.TraceFlags.nonmoving_gc; + + RuntimeTraceFlagCache.spark_sampled = + RtsFlags.TraceFlags.sparks_sampled; + + // -Dr turns on full spark tracing + RuntimeTraceFlagCache.spark_full = + RtsFlags.TraceFlags.sparks_full || + RtsFlags.DebugFlags.sparks; + + RuntimeTraceFlagCache.user = + RtsFlags.TraceFlags.user; + + // We trace cap events if we're tracing anything else + RuntimeTraceFlagCache.cap = + TRACE_sched || + TRACE_gc || + TRACE_spark_sampled || + TRACE_spark_full || + TRACE_user; } void initTracing (void) @@ -880,59 +918,65 @@ void traceThreadLabel_(Capability *cap, } } -void traceConcMarkBegin(void) +void traceNonmovingGcEvent_ (EventTypeNum tag) { - if (eventlog_enabled) - postEventNoCap(EVENT_CONC_MARK_BEGIN); +#if defined(DEBUG) + if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) { + /* nothing - no string representation for nonmoving GC events */ + } else +#endif + { + /* currently most non-moving GC events are nullary events */ + postEventNoCap(tag); + } } -void traceConcMarkEnd(StgWord32 marked_obj_count) +void traceConcMarkEnd_(StgWord32 marked_obj_count) { - if (eventlog_enabled) +#if defined(DEBUG) + if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) { + /* nothing - no string representation for nonmoving GC events */ + } else +#endif + { postConcMarkEnd(marked_obj_count); + } } -void traceConcSyncBegin(void) -{ - if (eventlog_enabled) - postEventNoCap(EVENT_CONC_SYNC_BEGIN); -} - -void traceConcSyncEnd(void) -{ - if (eventlog_enabled) - postEventNoCap(EVENT_CONC_SYNC_END); -} - -void traceConcSweepBegin(void) -{ - if (eventlog_enabled) - postEventNoCap(EVENT_CONC_SWEEP_BEGIN); -} - -void traceConcSweepEnd(void) -{ - if (eventlog_enabled) - postEventNoCap(EVENT_CONC_SWEEP_END); -} - -void traceConcUpdRemSetFlush(Capability *cap) +void traceConcUpdRemSetFlush_(Capability *cap) { - if (eventlog_enabled) +#if defined(DEBUG) + if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) { + /* nothing - no string representation for nonmoving GC events */ + } else +#endif + { postConcUpdRemSetFlush(cap); + } } -void traceNonmovingHeapCensus(uint16_t blk_size, - const struct NonmovingAllocCensus *census) +void traceNonmovingHeapCensus_(uint16_t blk_size, const struct NonmovingAllocCensus *census) { - if (eventlog_enabled && TRACE_nonmoving_gc) +#if defined(DEBUG) + if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) { + /* nothing - no string representation for nonmoving GC events */ + } else +#endif + { postNonmovingHeapCensus(blk_size, census); + } } -void traceNonmovingPrunedSegments(uint32_t pruned_segments, uint32_t free_segments) +void traceNonmovingPrunedSegments_(uint32_t pruned_segments, uint32_t free_segments) { - if (eventlog_enabled && TRACE_nonmoving_gc) +#if defined(DEBUG) + if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) { + /* nothing - no string representation for nonmoving GC events */ + } else +#endif + { postNonmovingPrunedSegments(pruned_segments, free_segments); + } } void traceThreadStatus_ (StgTSO *tso USED_IF_DEBUG) ===================================== rts/Trace.h ===================================== @@ -70,16 +70,35 @@ enum CapsetType { CapsetTypeCustom = CAPSET_TYPE_CUSTOM, #define DEBUG_continuation RtsFlags.DebugFlags.continuation #define DEBUG_iomanager RtsFlags.DebugFlags.iomanager -// Event-enabled flags -// These semantically booleans but we use a dense packing to minimize their -// cache impact. -extern uint8_t TRACE_sched; -extern uint8_t TRACE_gc; -extern uint8_t TRACE_nonmoving_gc; -extern uint8_t TRACE_spark_sampled; -extern uint8_t TRACE_spark_full; -extern uint8_t TRACE_cap; -/* extern uint8_t TRACE_user; */ // only used in Trace.c +// These trace flags are shorthand for the members of the RuntimeTraceFlagCache +// struct. Within the RTS, these should be treated as read-only variables. +#define TRACE_sched ((const bool)RuntimeTraceFlagCache.scheduler) +#define TRACE_gc ((const bool)RuntimeTraceFlagCache.gc) +#define TRACE_nonmoving_gc ((const bool)RuntimeTraceFlagCache.nonmoving_gc) +#define TRACE_spark_sampled ((const bool)RuntimeTraceFlagCache.spark_sampled) +#define TRACE_spark_full ((const bool)RuntimeTraceFlagCache.spark_full) +#define TRACE_user ((const bool)RuntimeTraceFlagCache.user) +#define TRACE_cap ((const bool)RuntimeTraceFlagCache.cap) + +/* + * Runtime trace flags. + */ +typedef struct { + bool scheduler; + bool gc; + bool nonmoving_gc; + bool spark_sampled; + bool spark_full; + bool user; + bool cap; +} RUNTIME_TRACE_FLAG_CACHE; + +/* + * These flags should be used to determine whether or not some value should + * be traced at runtime, rather than the values in RtsFlags. These flags can + * be modified at runtime using setTraceFlag in `rts/EventLogWriter.h`. + */ +extern RUNTIME_TRACE_FLAG_CACHE RuntimeTraceFlagCache; // ----------------------------------------------------------------------------- // Posting events @@ -136,6 +155,52 @@ void traceGcEvent_ (Capability *cap, EventTypeNum tag); void traceGcEventAtT_ (Capability *cap, StgWord64 ts, EventTypeNum tag); +/* + * Record a nonmoving GC event. + */ +#define traceConcMarkBegin() \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingGcEvent_(EVENT_CONC_MARK_BEGIN); \ + } +#define traceConcMarkEnd(marked_obj_count) \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceConcMarkEnd_(marked_obj_count); \ + } +#define traceConcSyncBegin() \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingGcEvent_(EVENT_CONC_SYNC_BEGIN); \ + } +#define traceConcSyncEnd() \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingGcEvent_(EVENT_CONC_SYNC_END); \ + } +#define traceConcSweepBegin() \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingGcEvent_(EVENT_CONC_SWEEP_BEGIN); \ + } +#define traceConcSweepEnd() \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingGcEvent_(EVENT_CONC_SWEEP_END); \ + } +#define traceConcUpdRemSetFlush(cap) \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceConcUpdRemSetFlush_(cap); \ + } +#define traceNonmovingHeapCensus(blk_size, census) \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingHeapCensus_(blk_size, census); \ + } +#define traceNonmovingPrunedSegments(pruned_segments, free_segments) \ + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) { \ + traceNonmovingPrunedSegments_(pruned_segments, free_segments); \ + } + +void traceNonmovingGcEvent_ (EventTypeNum tag); +void traceConcMarkEnd_(StgWord32 marked_obj_count); +void traceConcUpdRemSetFlush_(Capability *cap); +void traceNonmovingHeapCensus_(uint16_t blk_size, const struct NonmovingAllocCensus *census); +void traceNonmovingPrunedSegments_(uint32_t pruned_segments, uint32_t free_segments); + /* * Record a heap event */ @@ -321,17 +386,6 @@ void traceProfSampleCostCentre(Capability *cap, void traceProfBegin(void); #endif /* PROFILING */ -void traceConcMarkBegin(void); -void traceConcMarkEnd(StgWord32 marked_obj_count); -void traceConcSyncBegin(void); -void traceConcSyncEnd(void); -void traceConcSweepBegin(void); -void traceConcSweepEnd(void); -void traceConcUpdRemSetFlush(Capability *cap); -void traceNonmovingHeapCensus(uint16_t blk_size, - const struct NonmovingAllocCensus *census); -void traceNonmovingPrunedSegments(uint32_t pruned_segments, uint32_t free_segments); - void traceIPE(const InfoProvEnt *ipe); void flushTrace(void); @@ -384,6 +438,7 @@ void flushTrace(void); #define traceConcSweepEnd() /* nothing */ #define traceConcUpdRemSetFlush(cap) /* nothing */ #define traceNonmovingHeapCensus(blk_size, census) /* nothing */ +#define traceNonmovingPrunedSegments(pruned_segments, free_segments) /* nothing */ #define flushTrace() /* nothing */ ===================================== rts/include/rts/EventLogWriter.h ===================================== @@ -78,3 +78,34 @@ void endEventLogging(void); * Flush the eventlog. cap can be NULL if one is not held. */ void flushEventLog(Capability **cap); + +/* + * An enumeration for the runtime trace flags. + */ +typedef enum { + TRACE_SCHEDULER, + TRACE_GC, + TRACE_NONMOVING_GC, + TRACE_SPARK_SAMPLED, + TRACE_SPARK_FULL, + TRACE_USER, + TRACE_CAP, +} RUNTIME_TRACE_FLAG; + +/* + * Get the value of the given runtime trace flag. + * + * Warning: The trace flag cache is not thread-safe. After initialisation, the + * RTS never writes to these values, but concurrently using getTraceFlag and + * setTraceFlag for the same flag is a race condition. + */ +bool getTraceFlag(RUNTIME_TRACE_FLAG flag); + +/* + * Set the value of the given runtime trace flag. + * + * Warning: The trace flag cache is not thread-safe. After initialisation, the + * RTS never writes to these values. However, inconsistent reads may lead to + * incorrect tracing for a short time after setting a trace flag. + */ +void setTraceFlag(RUNTIME_TRACE_FLAG flag, bool value); ===================================== rts/posix/FdWakeup.c ===================================== @@ -0,0 +1,141 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team 2025 + * + * Utilities for a simple fd-based cross-thread wakeup mechanism. + * + * This is used to provide a mechanism to wake a thread when it is blocked + * waiting on fds and timeouts. The mechanism works by including the read end + * fd into the set of fds the thread waits on, and when a wake up is needed, + * the write end fd is used. + * + * This is implemented using either eventfd() or pipe(). + * + * Linux 2.6.22+ and FreeBSD 13+ support eventfd. It is a single fd with a + * 64bit counter. It uses fewer resources than a pipe (less memory and one + * rather than two fds), and is a tad faster (on the order of 5-10%). Using + * write() adds to the counter, while read() reads and resets it. Thus + * multiple writes are combined automatically into a single corresponding + * read. + * + * Otherwise we use a classic unix pipe. + * + * In both implementations, multiple sendFdWakeup notifcations (without + * interleaved collectFdWakeup) are combined to a single notification. This + * is automatic given the semantics of eventfd, while for pipe we implement + * it explicitly by draining the pipe in collectFdWakeup. + * + * -------------------------------------------------------------------------*/ + +#include "rts/PosixSource.h" +#include "Rts.h" + +#include "FdWakeup.h" + +#include <fcntl.h> +#include <unistd.h> + +#ifdef HAVE_SYS_EVENTFD_H +#include <sys/eventfd.h> +#endif + +#if !defined(HAVE_EVENTFD) \ + || (defined(HAVE_EVENTFD) && !(defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK))) +static void fcntl_CLOEXEC_NONBLOCK(int fd) +{ + int res1 = fcntl(fd, F_SETFD, FD_CLOEXEC); + int res2 = fcntl(fd, F_SETFL, O_NONBLOCK); + if (RTS_UNLIKELY(res1 < 0 || res2 < 0)) { + sysErrorBelch("newFdWakeup fcntl()"); + stg_exit(EXIT_FAILURE); + } +} +#endif + +void newFdWakeup(int *wakeup_fd_r, int *wakeup_fd_w) +{ +#if defined(HAVE_EVENTFD) + int wakeup_fd; +#if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK) + wakeup_fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); +#else + wakeup_fd = eventfd(0, 0); + if (wakeup_fd >= 0) fcntl_CLOEXEC_NONBLOCK(wakeup_fd); +#endif + if (RTS_UNLIKELY(wakeup_fd < 0)) { + sysErrorBelch("newFdWakeup eventfd()"); + stg_exit(EXIT_FAILURE); + } + /* eventfd uses the same fd for each end */ + *wakeup_fd_r = wakeup_fd; + *wakeup_fd_w = wakeup_fd; +#else + int pipefd[2]; + int res; + res = pipe(pipefd); + if (RTS_UNLIKELY(res < 0)) { + sysErrorBelch("newFdWakeup pipe"); + stg_exit(EXIT_FAILURE); + } + fcntl_CLOEXEC_NONBLOCK(pipefd[0]); + fcntl_CLOEXEC_NONBLOCK(pipefd[1]); + *wakeup_fd_r = pipefd[0]; /* read end */ + *wakeup_fd_w = pipefd[1]; /* write end */ +#endif +} + +void closeFdWakeup(int wakeup_fd_r, int wakeup_fd_w) +{ +#if defined(HAVE_EVENTFD) + ASSERT(wakeup_fd_r == wakeup_fd_w); + close(wakeup_fd_r); +#else + ASSERT(wakeup_fd_r != wakeup_fd_w); + close(wakeup_fd_r); + close(wakeup_fd_w); +#endif +} + +/* This is safe to use from a signal handler. Using write() to a pipe + * or eventfd is fine. */ +void sendFdWakeup(int wakeup_fd_w) +{ + int res; +#if defined(HAVE_EVENTFD) + uint64_t val = 1; + res = write(wakeup_fd_w, &val, 8); +#else + unsigned char buf = 1; + res = write(wakeup_fd_w, &buf, 1); +#endif + if (RTS_UNLIKELY(res < 0)) { + /* Unlikely the pipe buffer will fill, but it would not be an error. */ + if (errno == EAGAIN) return; + sysErrorBelch("sendFdWakeup write"); + stg_exit(EXIT_FAILURE); + } +} + +void collectFdWakeup(int wakeup_fd_r) +{ + int res; +#if defined(HAVE_EVENTFD) + uint64_t buf; + /* eventfd combines events into one counter, so a single read is enough */ + res = read(wakeup_fd_r, &buf, 8); +#else + /* Drain the pipe buffer. Multiple wakeup notifications could + * have been sent before we have a chance to collect them. + */ + uint64_t buf; + do { + res = read(wakeup_fd_r, &buf, 8); + } while (res == 8); +#endif + if (RTS_UNLIKELY(res < 0)) { + /* After the first pipe read, it could block */ + if (errno == EAGAIN) return; + sysErrorBelch("collectFdWakeup read"); + stg_exit(EXIT_FAILURE); + } +} ===================================== rts/posix/FdWakeup.h ===================================== @@ -0,0 +1,40 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team 2025 + * + * Utilities for a simple fd-based cross-thread wakeup mechanism. + * + * It provides a mechanism for a thread that block on fds to add a simple + * wakeup/notification feature. + * + * Start with newFdWakeup, and pass the fd_r to the thread that needs the + * wakeup feature. The thread that needs to be woken should include the fd_r + * into the set of fds that the thread waits on (e.g. using poll or similar). + * If this fd becomes ready for read, the thread must call collectFdWakeup, + * and when a wake up is needed, the write end fd is used. In any other thread + * (or in a signal handler), call sendFdWakeup(fd_w) to (asynchronously) cause + * the wakeup. + * + * There is no message payload. Multiple wakeups may be combined (if they're + * sent multiple times before the notified thread can wake and call + * collectFdWakeup). + * + * The implementation uses pipe() or eventfd() on supported OSs. + * + * Prototypes for functions in FdWakeup.c + * + * -------------------------------------------------------------------------*/ + +#pragma once + +#include "BeginPrivate.h" + +void newFdWakeup(int *fd_r, int *fd_w); +void closeFdWakeup(int fd_r, int fd_w); + +/* This is safe to use from a signal handler */ +void sendFdWakeup(int fd_w); +void collectFdWakeup(int fd_r); + +#include "EndPrivate.h" + ===================================== rts/posix/Ticker.c ===================================== @@ -1,19 +1,53 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team, 1995-2007 + * (c) The GHC Team, 1995-2026 * - * Posix implementation(s) of the interval timer for profiling and pre-emptive - * scheduling. + * The posix implementation of the interval timer, used for pre-emptive + * scheduling of Haskell threads, and for sample based profiling. + * + * This file defines the "ticker": the platform-specific service to install and + * run the timer. See rts/Timer.c for the platform-dependent view of interval + * timing. * * ---------------------------------------------------------------------------*/ -/* The interval timer is used for profiling and for context switching. - * This file defines the platform-specific services to install and run the - * timers, and we call this the ticker. See rts/Timer.c for the - * platform-dependent view of interval timing. +/* This implementation uses a posix thread which repeatedly blocks on a timeout + * using either the ppoll() or select() API. This lets it also block on a file + * descriptor for early wakeup. + * + * The design uses a simple relative time delay with no catchup. That is, time + * spent by the ticker thread itself (e.g. flushing eventlog buffers) is not + * accounted for, and the next tick is delayed by that much (modulo wakeup + * jitter). This is probably the right thing to do: generally in realtime + * systems one does not want to try to catch up when behind, since that tends + * towards oversubscribing resources. Graceful degredation is usually + * preferable. + * + * Experimental results (on Linux 6.18 on x86-64) to measure the typical + * difference between the requested wakeup time and actual wakeup time for + * different delay intervals: + * + * interval typical actual wakeup time after due time + * 10000us 340 -- 400us (this is the default interval) + * 1000us 55 -- 100us + * 100us 55us + * 10us 55us + * + * While there's quite a bit of variance to these numbers, the results do not + * vary significantly between using select, ppoll or nanosleep. + * + * On Linux at least, for longer delays the kernel allows itself lower wakeup + * accuracy (which allows it to save power by coalescing multiple wakeups). + * Similarly, the reason for 55us on the low end is that the default thread + * timer slack on Linux is 50us, and context switch time accounts for the + * remainder. + * + * In conclusion, on Linux at least, the accuracy is fine, both for the + * default interval (10ms, 10000us) and for shorter intervals used during + * profiling. * * Historically we had ticker implementations using signals. This was always a - * rather shakey thing to do but we had few alternatives. + * rather shakey thing to do but we originally had few alternatives. * - One problem with using signals is that there are severe limits on what * code can be called from signal handlers. In particular it's not possible * to take locks in a signal handler contex. This was enough for contex @@ -23,17 +57,245 @@ * calls (#10840) or can be overwritten by user code. */ -/* Select a ticker implementation to use: - * - * On modern Linux, FreeBSD and NetBSD we can use timerfd_create and a thread - * that waits on it using poll. Linux has had timerfd since version 2.6.25. - * NetBSD has had timerfd since version 10, and FreeBSD since version 15. - * - * For older version of linux/bsd without timerfd, and for all other posix - * platforms, we use the implementation using posix pthreads and nanosleep(). +#include "rts/PosixSource.h" +#include "Rts.h" + +#include "Ticker.h" +#include "RtsUtils.h" +#include "Proftimer.h" +#include "Schedule.h" +#include "posix/Clock.h" +#include "posix/FdWakeup.h" + +#if defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1 +/* We prefer the ppoll() function if available since it allows sanely waiting + * on a single fd with precise timeouts (nanosecond precision). It is not in + * the posix standard however and some platforms (notably glibc and freebsd) + * need special CPP defines to make it available: + */ +#define _GNU_SOURCE 1 +#define __BSD_VISIBLE 1 +#include <signal.h> +#include <poll.h> +#else +/* Otherwise we use the classic select(), which does have microsecond + * precision, but requires we build three whole 1024 bit (128 byte) fd sets + * just to wait on one fd. */ -#if defined(HAVE_SYS_TIMERFD_H) -#include "ticker/TimerFd.c" +#include <sys/select.h> +#endif + +#include <time.h> +#if HAVE_SYS_TIME_H +# include <sys/time.h> +#endif + +#if defined(HAVE_SIGNAL_H) +# include <signal.h> +#endif + +#include <string.h> + +#include <pthread.h> +#if defined(HAVE_PTHREAD_NP_H) +#include <pthread_np.h> +#endif +#include <unistd.h> +#include <fcntl.h> + +static Time itimer_interval = DEFAULT_TICK_INTERVAL; + +// Should we be firing ticks? +// Writers to this must hold the mutex below. +static bool stopped = false; + +// should the ticker thread exit? +// This can be set without holding the mutex. +static bool exited = true; + +// Signaled when we want to (re)start the timer +static Condition start_cond; +static Mutex mutex; +static OSThreadId thread; + +// fds for interrupting the ticker +static int interruptfd_r = -1, interruptfd_w = -1; + +static void *itimer_thread_func(void *_handle_tick) +{ + TickProc handle_tick = _handle_tick; + +#if defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1 + struct pollfd pollfds[1]; + + pollfds[0].fd = interruptfd_r; + pollfds[0].events = POLLIN; + + struct timespec ts = { .tv_sec = TimeToSeconds(itimer_interval) + , .tv_nsec = TimeToNS(itimer_interval) % 1000000000 + }; #else -#include "ticker/Pthread.c" + fd_set selectfds; + FD_ZERO(&selectfds); + FD_SET(interruptfd_r, &selectfds); + + struct timeval tv = { .tv_sec = TimeToSeconds(itimer_interval) + /* convert remainder time in nanoseconds + to microseconds, rounding up: */ + , .tv_usec = ((TimeToNS(itimer_interval) % 1000000000) + + 999) / 1000 + }; +#endif + + // Relaxed is sufficient: If we don't see that exited was set in one iteration we will + // see it next time. + while (!RELAXED_LOAD_ALWAYS(&exited)) { + +#if defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1 + int nfds = 1; + int nready = ppoll(pollfds, nfds, &ts, NULL); +#else + struct timeval tv_tmp = tv; // copy since select may change this value. + int nfds = interruptfd_r+1; + int nready = select(nfds, &selectfds, NULL, NULL, &tv_tmp); +#endif + // In either case (ppoll or select), the result nready is the number + // of fds that are ready. + if (RTS_LIKELY(nready == 0)) { + // Timer expired, not interrupted, continue. + } else if (nready > 0) { + // We only monitor one fd (the interruptfd_r), so we know + // it is that fd that is ready without any further checks. + collectFdWakeup(interruptfd_r); + // No further action needed, continue on to handling the final tick + // and then stop. + + // Note that we rely on sendFdWakeup and select/poll to provide the + // happens-before relation. So if 'exited' was set before calling + // sendFdWakeup, then we should be able to reliably read it after. + // And thus reading 'exited' in the while loop guard is ok. + } else { + // While the RTS attempts to mask signals, some foreign libraries + // that rely on signal delivery may unmask them. Consequently we + // may see EINTR. See #24610. + if (errno != EINTR) { + sysErrorBelch("Ticker: poll failed: %s", strerror(errno)); + } + } + + // first try a cheap test + if (RELAXED_LOAD_ALWAYS(&stopped)) { + OS_ACQUIRE_LOCK(&mutex); + // should we really stop? + if (stopped) { + waitCondition(&start_cond, &mutex); + } + OS_RELEASE_LOCK(&mutex); + } else { + handle_tick(0); + } + } + + return NULL; +} + +void +initTicker (Time interval, TickProc handle_tick) +{ + itimer_interval = interval; + stopped = true; + exited = false; +#if defined(HAVE_SIGNAL_H) + sigset_t mask, omask; + int sigret; +#endif + int ret; + + initCondition(&start_cond); + initMutex(&mutex); + + /* Open the interrupt fd synchronously. + * + * We used to do it in itimer_thread_func (i.e. in the timer thread) but it + * meant that some user code could run before it and get confused by the + * allocation of the timerfd. + * + * See hClose002 which unsafely closes a file descriptor twice expecting an + * exception the second time: it sometimes failed when the second call to + * "close" closed our own timerfd which inadvertently reused the same file + * descriptor closed by the first call! (see #20618) + */ + + if (interruptfd_r != -1) { + // don't leak the old file descriptors after a fork (#25280) + closeFdWakeup(interruptfd_r, interruptfd_w); + } + newFdWakeup(&interruptfd_r, &interruptfd_w); + + /* + * Create the thread with all blockable signals blocked, leaving signal + * handling to the main and/or other threads. This is especially useful in + * the non-threaded runtime, where applications might expect sigprocmask(2) + * to effectively block signals. + */ +#if defined(HAVE_SIGNAL_H) + sigfillset(&mask); + sigret = pthread_sigmask(SIG_SETMASK, &mask, &omask); +#endif + ret = createAttachedOSThread(&thread, "ghc_ticker", itimer_thread_func, (void*)handle_tick); +#if defined(HAVE_SIGNAL_H) + if (sigret == 0) + pthread_sigmask(SIG_SETMASK, &omask, NULL); #endif + + if (ret != 0) { + barf("Ticker: Failed to spawn thread: %s", strerror(errno)); + } +} + +void +startTicker(void) +{ + OS_ACQUIRE_LOCK(&mutex); + RELAXED_STORE(&stopped, false); + signalCondition(&start_cond); + OS_RELEASE_LOCK(&mutex); +} + +/* There may be at most one additional tick fired after a call to this */ +void +stopTicker(void) +{ + OS_ACQUIRE_LOCK(&mutex); + RELAXED_STORE(&stopped, true); + OS_RELEASE_LOCK(&mutex); +} + +/* There may be at most one additional tick fired after a call to this */ +void +exitTicker (bool wait) +{ + ASSERT(!SEQ_CST_LOAD(&exited)); + SEQ_CST_STORE(&exited, true); + // ensure that ticker wakes up if stopped + startTicker(); + sendFdWakeup(interruptfd_w); + + // wait for ticker to terminate if necessary + if (wait) { + if (pthread_join(thread, NULL)) { + sysErrorBelch("Ticker: Failed to join: %s", strerror(errno)); + } + closeFdWakeup(interruptfd_r, interruptfd_w); + closeMutex(&mutex); + closeCondition(&start_cond); + } else { + pthread_detach(thread); + } +} + +int +rtsTimerSignal(void) +{ + return SIGALRM; +} ===================================== rts/posix/ticker/Pthread.c deleted ===================================== @@ -1,195 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1995-2007 - * - * Interval timer for profiling and pre-emptive scheduling. - * - * ---------------------------------------------------------------------------*/ - -/* - * We use a realtime timer by default. I found this much more - * reliable than a CPU timer: - * - * Experiments with different frequencies: using - * CLOCK_REALTIME/CLOCK_MONOTONIC on Linux 2.6.32, - * 1000us has <1% impact on runtime - * 100us has ~2% impact on runtime - * 10us has ~40% impact on runtime - * - * using CLOCK_PROCESS_CPUTIME_ID on Linux 2.6.32, - * I cannot get it to tick faster than 10ms (10000us) - * which isn't great for profiling. - * - * In the threaded RTS, we can't tick in CPU time because the thread - * which has the virtual timer might be idle, so the tick would never - * fire. Therefore we used to tick in realtime in the threaded RTS and - * in CPU time otherwise, but now we always tick in realtime, for - * several reasons: - * - * - resolution (see above) - * - consistency (-threaded is the same as normal) - * - more consistency: Windows only has a realtime timer - * - * Note we want to use CLOCK_MONOTONIC rather than CLOCK_REALTIME, - * because the latter may jump around (NTP adjustments, leap seconds - * etc.). - */ - -#include "rts/PosixSource.h" -#include "Rts.h" - -#include "Ticker.h" -#include "RtsUtils.h" -#include "Proftimer.h" -#include "Schedule.h" -#include "posix/Clock.h" -#include <poll.h> - -#include <time.h> -#if HAVE_SYS_TIME_H -# include <sys/time.h> -#endif - -#if defined(HAVE_SIGNAL_H) -# include <signal.h> -#endif - -#include <string.h> - -#include <pthread.h> -#if defined(HAVE_PTHREAD_NP_H) -#include <pthread_np.h> -#endif -#include <unistd.h> -#include <fcntl.h> - -/* - * TFD_CLOEXEC has been added in Linux 2.6.26. - * If it is not available, we use fcntl(F_SETFD). - */ -#if !defined(TFD_CLOEXEC) -#define TFD_CLOEXEC 0 -#endif - -static Time itimer_interval = DEFAULT_TICK_INTERVAL; - -// Should we be firing ticks? -// Writers to this must hold the mutex below. -static bool stopped = false; - -// should the ticker thread exit? -// This can be set without holding the mutex. -static bool exited = true; - -// Signaled when we want to (re)start the timer -static Condition start_cond; -static Mutex mutex; -static OSThreadId thread; - -static void *itimer_thread_func(void *_handle_tick) -{ - TickProc handle_tick = _handle_tick; - - // Relaxed is sufficient: If we don't see that exited was set in one iteration we will - // see it next time. - while (!RELAXED_LOAD_ALWAYS(&exited)) { - if (rtsSleep(itimer_interval) != 0) { - sysErrorBelch("Ticker: sleep failed: %s", strerror(errno)); - } - - // first try a cheap test - if (RELAXED_LOAD_ALWAYS(&stopped)) { - OS_ACQUIRE_LOCK(&mutex); - // should we really stop? - if (stopped) { - waitCondition(&start_cond, &mutex); - } - OS_RELEASE_LOCK(&mutex); - } else { - handle_tick(0); - } - } - - return NULL; -} - -void -initTicker (Time interval, TickProc handle_tick) -{ - itimer_interval = interval; - stopped = true; - exited = false; -#if defined(HAVE_SIGNAL_H) - sigset_t mask, omask; - int sigret; -#endif - int ret; - - initCondition(&start_cond); - initMutex(&mutex); - - /* - * Create the thread with all blockable signals blocked, leaving signal - * handling to the main and/or other threads. This is especially useful in - * the non-threaded runtime, where applications might expect sigprocmask(2) - * to effectively block signals. - */ -#if defined(HAVE_SIGNAL_H) - sigfillset(&mask); - sigret = pthread_sigmask(SIG_SETMASK, &mask, &omask); -#endif - ret = createAttachedOSThread(&thread, "ghc_ticker", itimer_thread_func, (void*)handle_tick); -#if defined(HAVE_SIGNAL_H) - if (sigret == 0) - pthread_sigmask(SIG_SETMASK, &omask, NULL); -#endif - - if (ret != 0) { - barf("Ticker: Failed to spawn thread: %s", strerror(errno)); - } -} - -void -startTicker(void) -{ - OS_ACQUIRE_LOCK(&mutex); - RELAXED_STORE(&stopped, false); - signalCondition(&start_cond); - OS_RELEASE_LOCK(&mutex); -} - -/* There may be at most one additional tick fired after a call to this */ -void -stopTicker(void) -{ - OS_ACQUIRE_LOCK(&mutex); - RELAXED_STORE(&stopped, true); - OS_RELEASE_LOCK(&mutex); -} - -/* There may be at most one additional tick fired after a call to this */ -void -exitTicker (bool wait) -{ - ASSERT(!SEQ_CST_LOAD(&exited)); - SEQ_CST_STORE(&exited, true); - // ensure that ticker wakes up if stopped - startTicker(); - - // wait for ticker to terminate if necessary - if (wait) { - if (pthread_join(thread, NULL)) { - sysErrorBelch("Ticker: Failed to join: %s", strerror(errno)); - } - closeMutex(&mutex); - closeCondition(&start_cond); - } else { - pthread_detach(thread); - } -} - -int -rtsTimerSignal(void) -{ - return SIGALRM; -} ===================================== rts/posix/ticker/TimerFd.c deleted ===================================== @@ -1,291 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1995-2023 - * - * Interval timer for profiling and pre-emptive scheduling. - * - * ---------------------------------------------------------------------------*/ - -/* - * We use a realtime timer by default. I found this much more - * reliable than a CPU timer: - * - * Experiments with different frequencies: using - * CLOCK_REALTIME/CLOCK_MONOTONIC on Linux 2.6.32, - * 1000us has <1% impact on runtime - * 100us has ~2% impact on runtime - * 10us has ~40% impact on runtime - * - * using CLOCK_PROCESS_CPUTIME_ID on Linux 2.6.32, - * I cannot get it to tick faster than 10ms (10000us) - * which isn't great for profiling. - * - * In the threaded RTS, we can't tick in CPU time because the thread - * which has the virtual timer might be idle, so the tick would never - * fire. Therefore we used to tick in realtime in the threaded RTS and - * in CPU time otherwise, but now we always tick in realtime, for - * several reasons: - * - * - resolution (see above) - * - consistency (-threaded is the same as normal) - * - more consistency: Windows only has a realtime timer - * - * Note we want to use CLOCK_MONOTONIC rather than CLOCK_REALTIME, - * because the latter may jump around (NTP adjustments, leap seconds - * etc.). - */ - -#include "rts/PosixSource.h" -#include "Rts.h" - -#include "Ticker.h" -#include "RtsUtils.h" -#include "Proftimer.h" -#include "Schedule.h" -#include "posix/Clock.h" -#include <poll.h> - -#include <time.h> -#if HAVE_SYS_TIME_H -# include <sys/time.h> -#endif - -#if defined(HAVE_SIGNAL_H) -# include <signal.h> -#endif - -#include <string.h> - -#include <pthread.h> -#if defined(HAVE_PTHREAD_NP_H) -#include <pthread_np.h> -#endif -#include <unistd.h> -#include <fcntl.h> - -#include <sys/timerfd.h> - - -/* - * TFD_CLOEXEC has been added in Linux 2.6.26. - * If it is not available, we use fcntl(F_SETFD). - */ -#if !defined(TFD_CLOEXEC) -#define TFD_CLOEXEC 0 -#endif - -static Time itimer_interval = DEFAULT_TICK_INTERVAL; - -// Should we be firing ticks? -// Writers to this must hold the mutex below. -static bool stopped = false; - -// should the ticker thread exit? -// This can be set without holding the mutex. -static bool exited = true; - -// Signaled when we want to (re)start the timer -static Condition start_cond; -static Mutex mutex; -static OSThreadId thread; - -// file descriptor for the timer (Linux only) -static int timerfd = -1; - -// pipe for signaling exit -static int pipefds[2]; - -static void *itimer_thread_func(void *_handle_tick) -{ - TickProc handle_tick = _handle_tick; - uint64_t nticks; - ssize_t r = 0; - struct pollfd pollfds[2]; - - pollfds[0].fd = pipefds[0]; - pollfds[0].events = POLLIN; - pollfds[1].fd = timerfd; - pollfds[1].events = POLLIN; - - // Relaxed is sufficient: If we don't see that exited was set in one iteration we will - // see it next time. - while (!RELAXED_LOAD_ALWAYS(&exited)) { - if (poll(pollfds, 2, -1) == -1) { - // While the RTS attempts to mask signals, some foreign libraries - // may rely on signal delivery may unmask them. Consequently we may - // see EINTR. See #24610. - if (errno != EINTR) { - sysErrorBelch("Ticker: poll failed: %s", strerror(errno)); - } - } - - // We check the pipe first, even though the timerfd may also have triggered. - if (pollfds[0].revents & POLLIN) { - // the pipe is ready for reading, the only possible reason is that we're exiting - exited = true; // set this again to make sure even RELAXED_LOAD will read the proper value - // no further action needed, skip ahead to handling the final tick and then stopping - } - else if (pollfds[1].revents & POLLIN) { // the timerfd is ready for reading - r = read(timerfd, &nticks, sizeof(nticks)); // this should never block now - - if ((r == 0) && (errno == 0)) { - /* r == 0 is expected only for non-blocking fd (in which case - * errno should be EAGAIN) but we use a blocking fd. - * - * Due to a kernel bug (cf https://lkml.org/lkml/2019/8/16/335) - * on some platforms we could see r == 0 and errno == 0. - */ - IF_DEBUG(scheduler, debugBelch("read(timerfd) returned 0 with errno=0. This is a known kernel bug. We just ignore it.")); - } - else if (r != sizeof(nticks) && errno != EINTR) { - barf("Ticker: read(timerfd) failed with %s and returned %zd", strerror(errno), r); - } - } - - // first try a cheap test - if (RELAXED_LOAD_ALWAYS(&stopped)) { - OS_ACQUIRE_LOCK(&mutex); - // should we really stop? - if (stopped) { - waitCondition(&start_cond, &mutex); - } - OS_RELEASE_LOCK(&mutex); - } else { - handle_tick(0); - } - } - - close(timerfd); - return NULL; -} - -void -initTicker (Time interval, TickProc handle_tick) -{ - itimer_interval = interval; - stopped = true; - exited = false; -#if defined(HAVE_SIGNAL_H) - sigset_t mask, omask; - int sigret; -#endif - int ret; - - initCondition(&start_cond); - initMutex(&mutex); - - /* Open the file descriptor for the timer synchronously. - * - * We used to do it in itimer_thread_func (i.e. in the timer thread) but it - * meant that some user code could run before it and get confused by the - * allocation of the timerfd. - * - * See hClose002 which unsafely closes a file descriptor twice expecting an - * exception the second time: it sometimes failed when the second call to - * "close" closed our own timerfd which inadvertently reused the same file - * descriptor closed by the first call! (see #20618) - */ - struct itimerspec it; - it.it_value.tv_sec = TimeToSeconds(itimer_interval); - it.it_value.tv_nsec = TimeToNS(itimer_interval) % 1000000000; - it.it_interval = it.it_value; - - if (timerfd != -1) { - // don't leak the old file descriptors after a fork (#25280) - close(timerfd); - close(pipefds[0]); - close(pipefds[1]); - timerfd = -1; - } - - timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC); - if (timerfd == -1) { - barf("timerfd_create: %s", strerror(errno)); - } - if (!TFD_CLOEXEC) { - fcntl(timerfd, F_SETFD, FD_CLOEXEC); - } - if (timerfd_settime(timerfd, 0, &it, NULL)) { - barf("timerfd_settime: %s", strerror(errno)); - } - - if (pipe(pipefds) < 0) { - barf("pipe: %s", strerror(errno)); - } - - /* - * Create the thread with all blockable signals blocked, leaving signal - * handling to the main and/or other threads. This is especially useful in - * the non-threaded runtime, where applications might expect sigprocmask(2) - * to effectively block signals. - */ -#if defined(HAVE_SIGNAL_H) - sigfillset(&mask); - sigret = pthread_sigmask(SIG_SETMASK, &mask, &omask); -#endif - ret = createAttachedOSThread(&thread, "ghc_ticker", itimer_thread_func, (void*)handle_tick); -#if defined(HAVE_SIGNAL_H) - if (sigret == 0) - pthread_sigmask(SIG_SETMASK, &omask, NULL); -#endif - - if (ret != 0) { - barf("Ticker: Failed to spawn thread: %s", strerror(errno)); - } -} - -void -startTicker(void) -{ - OS_ACQUIRE_LOCK(&mutex); - RELAXED_STORE(&stopped, false); - signalCondition(&start_cond); - OS_RELEASE_LOCK(&mutex); -} - -/* There may be at most one additional tick fired after a call to this */ -void -stopTicker(void) -{ - OS_ACQUIRE_LOCK(&mutex); - RELAXED_STORE(&stopped, true); - OS_RELEASE_LOCK(&mutex); -} - -/* There may be at most one additional tick fired after a call to this */ -void -exitTicker (bool wait) -{ - ASSERT(!SEQ_CST_LOAD(&exited)); - SEQ_CST_STORE(&exited, true); - // ensure that ticker wakes up if stopped - startTicker(); - - // wait for ticker to terminate if necessary - if (wait) { - // write anything to the pipe to trigger poll() in the ticker thread - if (write(pipefds[1], "stop", 5) < 0) { - sysErrorBelch("Ticker: Failed to write to pipe: %s", strerror(errno)); - } - - if (pthread_join(thread, NULL)) { - sysErrorBelch("Ticker: Failed to join: %s", strerror(errno)); - } - - // These need to happen AFTER the ticker thread has finished to prevent a race condition - // where the ticker thread closes the read end of the pipe before we're done writing to it. - close(pipefds[0]); - close(pipefds[1]); - - closeMutex(&mutex); - closeCondition(&start_cond); - } else { - pthread_detach(thread); - } -} - -int -rtsTimerSignal(void) -{ - return SIGALRM; -} ===================================== rts/rts.cabal ===================================== @@ -582,11 +582,9 @@ library posix/Ticker.c posix/OSMem.c posix/OSThreads.c + posix/FdWakeup.c posix/Poll.c posix/Select.c posix/Signals.c posix/Timeout.c posix/TTY.c - -- ticker/*.c - -- We don't want to compile posix/ticker/*.c, these will be #included - -- from Ticker.c ===================================== rts/sm/NonMoving.c ===================================== @@ -1339,7 +1339,7 @@ concurrent_marking: nonmovingPrintAllocatorCensus(!concurrent); #endif #if defined(TRACING) - if (RtsFlags.TraceFlags.nonmoving_gc) + if (RTS_UNLIKELY(TRACE_nonmoving_gc)) nonmovingTraceAllocatorCensus(); #endif ===================================== testsuite/tests/ghc-api/T24386.hs ===================================== @@ -0,0 +1,123 @@ + +-- This test checks that bindings are preserved when configuring the simple +-- optimizer to not inline bindings with names selected by a predicate. +-- +-- This feature is important for the LiquidHaskell plugin, which relies on the +-- simple optimizer to make core programs easier to read, but needs to preserve +-- bindings that are relevant for verification. +-- +-- See https://gitlab.haskell.org/ghc/ghc/-/issues/24386 for the full discussion. +-- + +import Control.Monad +import Data.List (find) +import Data.Time (getCurrentTime) +import GHC +import GHC.Core +import GHC.Core.SimpleOpt +import GHC.Data.StringBuffer +import GHC.Driver.Config +import GHC.Driver.DynFlags +import GHC.Driver.Env.Types +import GHC.Types.Name +import GHC.Unit.Module.ModGuts +import GHC.Unit.Types +import GHC.Utils.Error +import GHC.Utils.Outputable + +import System.Environment (getArgs) + + +main :: IO () +main = + testLocalBindingsDesugaring + +testLocalBindingsDesugaring :: IO () +testLocalBindingsDesugaring = do + let inputSource = unlines + [ "module LocalBindingsDesugaring where" + , "f :: ()" + , "f = z" + , " where" + , " z = ()" + ] + + isExpectedDesugaring p = case findExpr "f" p of + Just (Let (NonRec b _) _) + -> isIdNamed "z" b + _ -> False + + isIdNamed name v = occNameString (occName v) == name + + coreProgram <- + compileToCore + (not . isIdNamed "z") + "LocalBindingsDesugaring" + inputSource + unless (isExpectedDesugaring coreProgram) $ + fail $ unlines $ + "Unexpected desugaring: No local binding for `z` found in the Core program." + : map showPprQualified coreProgram + +-- | Find the Core expression bound to the given name. +findExpr :: String -> CoreProgram -> Maybe CoreExpr +findExpr _ [] = + Nothing +findExpr name (p:ps) = case p of + NonRec b e + | occNameString (occName b) == name + -> Just e + Rec binds + | Just (_, e) <- find (\(b, _e) -> occNameString (occName b) == name) binds + -> Just e + _ -> findExpr name ps + +showPprQualified :: Outputable a => a -> String +showPprQualified = showSDocQualified . ppr + +showSDocQualified :: SDoc -> String +showSDocQualified = renderWithContext ctx + where + ctx = defaultSDocContext { sdocStyle = cmdlineParserStyle } + + + +compileToCore :: (Id -> Bool) -> String -> String -> IO [CoreBind] +compileToCore keepBindings modName inputSource = do + [libdir] <- getArgs + now <- getCurrentTime + runGhc (Just libdir) $ do + df1 <- getSessionDynFlags + GHC.setSessionDynFlags $ df1 { GHC.backend = GHC.bytecodeBackend } + let target = Target { + targetId = TargetFile (modName ++ ".hs") Nothing + , targetUnitId = homeUnitId_ df1 + , targetAllowObjCode = False + , targetContents = Just (stringToStringBuffer inputSource, now) + } + setTargets [target] + void $ GHC.depanal [] False + + dsMod <- getModSummary + (mkModule mainUnit (mkModuleName modName)) + >>= parseModule + >>= typecheckModule NoTcMPlugins + >>= desugarModule + hsc_env <- getSession + return $ mg_binds $ simpleOptimize keepBindings hsc_env $ dm_core_module dsMod + +-- Run the simple optimizer +simpleOptimize :: (Id -> Bool) -> GHC.HscEnv -> ModGuts -> ModGuts +simpleOptimize keepBindings hsc_env guts@(ModGuts + { mg_module = mgmod + , mg_binds = binds + , mg_rules = rules + }) = + let dflags = hsc_dflags hsc_env + simpl_opts = (initSimpleOpts dflags) { so_inline = keepBindings } + (binds2, rules2, _occ_anald_binds) = + simpleOptPgm simpl_opts mgmod binds rules + in guts + { mg_binds = binds2 + , mg_rules = rules2 + } ===================================== testsuite/tests/ghc-api/all.T ===================================== @@ -81,3 +81,4 @@ test('T26910', [ extra_run_opts(f'"{config.libdir}"') test('TypeMapStringLiteral', normal, compile_and_run, ['-package ghc']) test('T25121_status', normal, compile_and_run, ['-package ghc']) +test('T24386', [extra_run_opts(f'"{config.libdir}"')], compile_and_run, ['-package ghc']) ===================================== testsuite/tests/interface-stability/base-exports.stdout-ws-32 deleted ===================================== The diff for this file was not included because it is too large. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/be21a344ce54e887dd4d30c8d6d1fcd... -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/be21a344ce54e887dd4d30c8d6d1fcd... You're receiving this email because of your account on gitlab.haskell.org.