Repository navigation
Declutter formatting changes and more before rebase - #215
Merged
Merged
Conversation
Reverts whitespace and line-wrapping changes the fork made to upstream v16.14.2 lines (clang-formatted ast.h, collapsed blank lines, rewrapped signatures and initializer lists), and puts new parameters on their own lines so the upstream lines around them stay byte-identical. Whitespace only: the comment-stripped token streams and preprocessor directives of every touched file are unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The driver loading and recordreplay:: helpers in node.cc and the record/replay process binding methods in node_process_methods.cc move unchanged into node_recordreplay.cc, leaving declarations and one call per hook in the upstream files, so rebases only have to carry those. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
sweepCache() has a single caller in each file, so the recording check becomes an early return there instead of wrapping (and re-indenting) the upstream call. ~Worker declares the watchdog before the upstream lock, so it is still joined after the lock is released without moving the upstream body into a new scope; the only reordering is that the Debug() line is now logged before the join. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
thread-id.cc's file-local thread_local works when recording/replaying (the Chromium fork already uses it), so the pthread-key replacement and its #define go. g_thread_in_wasm_code keeps its replacement: restoring the extern thread_local makes every replay fail with "Call to unbound symbol _ZTHN2v88internal12trap_handler21g_thread_in_wasm_codeE", since other files reach it through its TLS wrapper, so its comments now say so. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Chromium fork has it back too. DCHECKs aren't compiled into Release builds. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
It returned early unconditionally, so process.title and --title did nothing even when node wasn't recording (e.g. RECORD_REPLAY_DONT_RECORD), failing test-process-title-cli. Recording skips it as well as replaying, so both report the same title. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The strtod workaround only accepted "0" for a zero result, so "0.0", "-0" or an underflowing number failed to parse. Check that strtod read something instead, as the istringstream it replaces did. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
bhackett1024
added a commit
that referenced
this pull request
Nov 5, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, #168, #169, #176, #178, #181 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 6, 2026
Add src/node_recordreplay.cc with Replay's node integration: loading the driver (InitializeRecordReplay and OpenDriverHandle, from RECORD_REPLAY_DRIVER or the copy embedded in the binary), the symbol table of driver function pointers, attaching the recorder with the build ID, recording the command line arguments and the argv metadata, and RecordReplayFinishRecording, which appends the recording ID to RECORD_REPLAY_RECORDING_ID_FILE unless the recording is unusable. The node::recordreplay namespace holds the helpers the rest of node uses: callback region scopes, whether the recording has finished, whether a call is inside a callback the driver intercepts, whether events are available (recording or replaying, with events neither disallowed nor passed through and no divergence) or recorded, and ThrowIfEventsUnavailable, which makes an operation that cannot be replayed throw instead of running unrecorded. Expose the recording primitives to JavaScript as process binding methods: RecordReplayLog, the CDP message pair (a callback for responses and events, and sending a message through a process-owned inspector session), the annotation hook, assertions, script ignoring, the recording ID, the current execution point and elapsed time, and the external references for all of them. Replay's own session connects, dispatches and delivers messages to the frontend as replay code with events disallowed, so none of that work can diverge, and the session is reset from AtExit, where node normally waits for external debugger frontends to disconnect: process.exit() skips Environment destruction, so the session would otherwise survive until static destruction, after V8's platform has been disposed. That also disables the debugger, which leaves WebAssembly modules tiered down (see V8Debugger::disable). In node.cc, initialize record/replay and mark the sibling group map ordered before anything else, apply the old space limit the driver asks for (REPLAY_RECORD_MAX_OLD_SPACE_MB / REPLAY_REPLAY_MAX_OLD_SPACE_MB, read through RecordReplayMaxOldSpaceMb) as a V8 flag after the command line's, so that the arguments and process.execArgv stay the same when replaying, print the build ID and exit for --print-build-id, create the first checkpoint on the main thread before the entry script runs, and leave V8's WebAssembly trap handler disabled while recording/replaying, so V8 keeps emitting bounds checks instead of relying on a SIGSEGV the recorder treats as a crash. Rebase note: nearly all of this is new code in src/node_recordreplay.cc, so conflicts should only come from the call sites, which are one line each. InitializeRecordReplay() must run early in InitializeOncePerProcess, before V8, OpenSSL and the platform are initialized, and the driver's old space limit is applied after node has processed the command line's V8 options, so that it wins. The --print-build-id early return sits with the other print-and-exit options, and StartExecution creates a checkpoint on the main thread before running the entry script. The process methods are only added to the process_methods binding, so upstream changes to how bindings register methods (for example env->SetMethod(target, ...) becoming SetMethod(context, target, ...) in later v16 releases) must be applied to these registrations too, and the method names must stay in sync with lib/internal/bootstrap/node.js. Includes later changes from #123, #130, #151, #155, #164, #166, #167, #168, #169, #176, #178, #181 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 6, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 10, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
pushed a commit
that referenced
this pull request
Nov 11, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 11, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 11, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Andarist
added a commit
that referenced
this pull request
Nov 12, 2026
Replace std::once_flag/std::call_once with pthread_once_t/pthread_once in ICU mutex code to ensure deterministic behavior during recording. Skip the TimeZoneNames and TimeZoneGenericNames cache sweeps when recording or replaying. Both caches are shared by all threads, and every 100th access sweeps the cache, reading the clock with uprv_getUTCtime() on whichever thread got there; each isolate's DateCache loads the time zone names eagerly, so workers starting together access the cache concurrently and the replay could make that call on another thread than the recording did. The sweep only frees entries nobody has used for three minutes, so skipping it is safe. umtx_isRecordingOrReplaying() asks V8 (see the threading and platform commit for its weak definitions, which ICU's host tools need), and the check is an early return in sweepCache(), which has a single caller in each file, so the upstream call sites stay unchanged. Rebase note: ICU is vendored, so a new ICU drop has to be re-patched rather than merged. The invariant is that nothing in ICU reads the clock, or runs one-time initialization, on whichever thread happens to get there first, since that thread differs when replaying. Includes later changes from #176 and #215. Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com> Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Three changes that make the fork's diff against upstream v16.14.2 smaller and easier to rebase, without changing behavior:
The deps/v8 code layout is unchanged on purpose: it matches replayio/chromium-v8, which keeps porting between the two easy.
Testing: the build succeeds. The node-recording suite passes 128 of 129. The one failure, long-full-gc-ephemeron-chain, also fails on an unmodified HEAD build.