[improvement](be) Optimize projected fixed-width Parquet predicate filtering#65934
Merged
Gabriel39 merged 2 commits intoJul 23, 2026
Merged
Conversation
### What problem does this PR solve? Issue Number: N/A Related PR: apache#65921 Problem Summary: Projected PLAIN predicate columns could not use the raw fixed-value predicate path. Doris materialized every selected predicate value and later compacted the complete column even though the raw decoder had already identified survivors. Append matching raw values to the projected column in the same decoder pass while preserving predicate-only placeholders and all existing fallback conditions. The Parquet reader microbenchmark from apache#65921 improves median CPU time per raw row by 6.1%, 6.3%, 7.2%, and 10.5% at 1%, 10%, 50%, and 90% selectivity respectively. ### Release note None ### Check List (For Author) - Test: Unit Test and Manual test - Nine targeted ASAN unit tests, including projected/predicate-only/fallback/residual/nullable and benchmark scenario coverage - Release warm-cache microbenchmark with 10 repetitions on CPU 8 - clang-format and check-format - Behavior changed: No. This only changes how eligible projected PLAIN predicate survivors are materialized. - Does this need documentation: No
Contributor
|
Thank you for your contribution to Apache Doris. Please clearly describe your PR:
|
Contributor
Author
|
run buildall |
Contributor
Author
|
/review |
Gabriel39
marked this pull request as ready for review
July 23, 2026 01:40
Contributor
TPC-H: Total hot run time: 29505 ms |
![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=60&v=4){kind=small}
Contributor
There was a problem hiding this comment.
Request changes: the projected fixed-width PLAIN fast path has two patch-scoped P2 issues. It can degenerate into per-survivor virtual appends for fragmented match patterns, and its fused decode/projection work is omitted from the native decode/materialization stage timers.
Critical checkpoint conclusions:
- Concurrency and thread safety: no new thread, shared mutable state, lock, or atomic behavior is introduced; the reader scratch and destination column are mutated synchronously within one scan path.
- Error handling and lifecycle: Status values are propagated. Capability fallback occurs before value consumption, while incompatibility/corruption after progress remains terminal; no successful retry can expose a partially appended column.
- Memory safety and ownership: the destination is the mutable file-type column owned by the block. Exact physical/logical identity gates and nullable raw insertion preserve representation and null-map alignment. No lifetime or ownership defect was found, although the repeated growth operations are the performance issue called out inline.
- Data correctness and nullable handling: the compact filter and projected values come from the same ordered physical match stream. NULL remapping, prior sparse selections, later predicate/delete compaction, page/range fragmentation, and widened pending slices remain aligned. Converted or unsupported types/encodings fall back before raw consumption.
- Observability: incomplete. Eligible projected direct scans underreport the separately published DecodeValueTime and MaterializationTime stages; see the inline finding.
- Compatibility, configuration, persistence, and data writes: no configuration, serialized protocol, FE/BE variable, transaction, persistence, or data-write contract changes are involved. Predicate-only, dictionary, residual/delete, unsupported-type, and ordinary materialization paths were checked.
- Tests and performance: the added unit and scan tests cover sparse nullable mapping and the projected happy path, but both use a single contiguous survivor run and miss the alternating-match hot-loop case. I did not run builds or tests because this review environment explicitly prohibits them; validation was static against the authoritative bundled diff.
No user-specific focus was supplied. Review completion status: formally incomplete under the supplied convergence contract. A new valuable candidate appeared in round 3, and the contract caps review at three rounds; both current candidates were independently validated, deduplicated, and included here, but a fourth convergence round was not permitted.
| ++row; | ||
| } | ||
| if (row != run_begin) { | ||
| _projected_column->insert_many_raw_data( |
Contributor
There was a problem hiding this comment.
[P2] Keep native timing complete on projected direct scans
Projected predicate columns now append survivors in this branch and no longer pass through materialize_values(), which is where decode_value_time and materialization_time are incremented. filter_plain_values() calls decode_selected_fixed_values() and this line copies survivors, but neither contributes to the separately published DecodeValueTime/MaterializationTime, so every eligible projected direct scan underreports both stages. Please mirror the existing timing convention: an inclusive batch/span decode timer around the direct decoder/consumer call and a nested materialization timer around projected survivor writes, avoiding per-row timers.
| _data_type, _column_id, | ||
| _matches->data() + old_size)); | ||
| } | ||
| if (_projected_column != nullptr) { |
Contributor
There was a problem hiding this comment.
[P2] Avoid per-match-run column appends
With alternating predicate results, this loop invokes virtual insert_many_raw_data() once per survivor (N/2 calls), and each call resizes the vector before copying only 4/8 bytes; nullable output also grows its null map and nested column each time. The previous projected path materialized the batch and used vectorized filtering, so ordinary unsorted values can turn this fast path into thousands of virtual calls and tiny copies per batch. Both added tests have a single contiguous survivor run. Please reserve/grow once and compact survivors into the destination in a bounded batch/span operation, and cover an alternating-match case.
### What problem does this PR solve? Issue Number: N/A Related PR: apache#65921 Problem Summary: Generalize projected raw filter-and-project from PLAIN to eligible fixed-width encodings. BYTE_STREAM_SPLIT now supports identity-width INT32, INT64, FLOAT, and DOUBLE values; DELTA_BINARY_PACKED supports INT32 and INT64. Keep dictionary filtering on its existing specialized path, reject unsupported mixed page encodings before unsafe fallback, and extend the reader microbenchmark matrix across nullable predicate-only/projected scans and 1%, 10%, 50%, and 90% selectivity. ### Release note None ### Check List (For Author) - Test: Unit Test and Manual test - 17 targeted ASAN unit tests covering encodings, nullable mapping, projection, fallback, mixed-page safety, and scenario matrix - Release microbenchmark matrix with 16 BSS/Delta predicate scenarios, 10 repetitions on CPU 8 - Before/after Release microbench for projected 10% selectivity - clang-format 16, check-format, and git diff --check - Behavior changed: No. This extends the existing raw predicate optimization to equivalent fixed-width decoder outputs. - Does this need documentation: No
Contributor
BE UT Coverage ReportIncrement line coverage Increment coverage report
|
Contributor
Author
|
run buildall |
Contributor
Author
|
/review |
Gabriel39
changed the title
Gabriel39
changed the title
Contributor
TPC-H: Total hot run time: 30024 ms |
Contributor
There was a problem hiding this comment.
Request changes on the current head: the core fixed-width filter/project mapping and cursor lifecycle appear coherent, but four patch-scoped P2 issues remain in compatibility, count observability, end-to-end proof, and the benchmark registration contract. I did not duplicate the two existing threads for per-match-run appends and missing decode/materialization timers.
Critical checkpoint conclusions:
- Goal and proof: the production path does evaluate and project eligible PLAIN/BSS/Delta survivors in one decoder pass, and static tracing found its row mapping/cursor behavior coherent. The added tests do not prove the newly accepted encoding/type/null/page matrix end to end; see inline.
- Scope and clarity: the production change is focused around the scheduler/native reader/decoder interfaces, but the profile compatibility contract, current design text, and benchmark matrix contract were not updated consistently.
- Concurrency: no new thread, shared mutable state, lock, or atomic behavior is introduced; reader scratch and the destination column remain scan-local and synchronous.
- Lifecycle/static initialization: reader-owned scratch is bounded by the batch/Row Group lifecycle, and successful output ownership follows existing mutable-column/COW rules. No new static/global initialization or circular ownership is introduced.
- Configuration: no configuration item is added or changed.
- Compatibility: no storage/protocol/function-symbol rolling-upgrade issue was found, but removing the published
PlainPredicateDirectBatches/RowsRuntimeProfile keys without aliases is an operational compatibility break; see inline. - Parallel paths: PLAIN, BYTE_STREAM_SPLIT, DELTA_BINARY_PACKED, ordinary materialization, dictionary filtering, predicate-only/projected columns, residual/delete predicates, lazy outputs, page/range gaps, and fallback/error paths were traced. The direct count bookkeeping remains incomplete compared with ordinary/dictionary selection; see inline.
- Conditions and error handling: eligibility is limited to exact identity-width types, advertised encodings are prevalidated before cursor consumption, actual pages are rechecked, and late incompatibility returns corruption rather than retrying an advanced cursor. Status propagation is intact.
- Tests and results: the changed C++ tests have coherent expected rows for the cases they cover, but the BSS/Delta fixture does not assert its emitted encoding and the accepted matrix lacks value-checked nullable/fragmented/page coverage. No generated
.outfile is changed. I did not run builds or tests because the governing review prompt prohibits them; validation was static against the authoritative bundled diff. - Observability: the newly routed direct traffic omits
NativeReadCallsandReaderSelectRows; the separate decode/materialization timer omission is already covered by an existing inline thread. - Transactions, persistence, data writes, and FE-BE propagation: none are involved.
- Performance: the existing append-fragmentation thread covers the surviving hot-loop issue. The reported Delta comparison is directional under the benchmark guide's variance rule, as the PR already states. No additional nonduplicate CPU, memory, or lifetime issue survived review.
- Other: the deduplicated reader matrix now contains 151 cases while the current smoke contract still requires 137; see inline.
No user-specific focus was supplied. Review completion status: complete and converged after Round 2; all suspicious points were either accepted below, deduplicated to the two existing discussions, or dismissed with concrete code-path evidence.
| plain_predicate_direct_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PlainPredicateDirectRows", | ||
| TUnit::UNIT, parquet_profile, 1); | ||
| fixed_width_predicate_direct_batches = ADD_CHILD_COUNTER_WITH_LEVEL( | ||
| profile, "FixedWidthPredicateDirectBatches", TUnit::UNIT, parquet_profile, 1); |
Contributor
There was a problem hiding this comment.
[P2] Preserve the profile keys or update their compatibility contract
This removes the only PlainPredicateDirectBatches/Rows registrations, but the mandatory Parquet scan design still describes the predicate-only PLAIN path and tells operators/profile parsers to read those exact keys. After this change those lookups silently disappear, even for the existing PLAIN workload. Please preserve the old keys as deprecated aliases (or retain them with broadened semantics) and update the current-pipeline design to cover projected PLAIN/BSS/Delta behavior and the new names.
| RETURN_IF_ERROR(_native_reader->read_plain_filter( | ||
| conjuncts, column_id, filter, static_cast<size_t>(rows - *rows_read), &loop_filter, | ||
| &loop_rows, &eof, &loop_used)); | ||
| RETURN_IF_ERROR(_native_reader->read_fixed_width_filter( |
Contributor
There was a problem hiding this comment.
[P2] Keep the direct reader's count profile complete
read_with_filter() counts each native reader call in NativeReadCalls, and both ordinary and dictionary select() paths add their input selection to ReaderSelectRows. This fixed-width loop does neither, so a predicate-only direct scan can report zero native calls/selected rows for its only active reader; projected scans undercount them behind unrelated lazy-reader activity. This is separate from the existing decode/materialization timer thread. Please mirror both count updates here and assert them in the direct-path profile tests.
|
|
||
| TEST(ParquetV2NativeDecoderTest, RawFixedFilterSupportsIdentityWidthEncodingTypes) { | ||
| using Reader = ColumnChunkReader<false, false>; | ||
| EXPECT_TRUE(Reader::supports_raw_fixed_filter_encoding(tparquet::Encoding::BYTE_STREAM_SPLIT, |
Contributor
There was a problem hiding this comment.
[P2] Prove the newly accepted encoding/type matrix end to end
These assertions only test the whitelist. The new scan fixtures request BSS/Delta from Arrow but never verify the emitted footer/page encoding, and PLAIN increments the same direct counter, so both tests can stay green without exercising the new decoders. They also cover only required INT32 with one contiguous survivor run; the nullable benchmark checks row counts, not projected values. Please add value-checked filter/project coverage for every accepted BSS/Delta type (including nullable/fragmented and page transitions) and assert the fixture's actual encoding before treating the benchmark numbers as validation.
| scenario.operation = ReaderOperation::PREDICATE_SCAN; | ||
| add(scenario); | ||
| } | ||
| for (const auto encoding : {Encoding::BYTE_STREAM_SPLIT, Encoding::DELTA_BINARY_PACKED}) { |
Contributor
There was a problem hiding this comment.
[P2] Update and assert the reader registration total
This loop contributes 14 unique registrations, not 16, because each encoding's 10%-selectivity projected case already comes from the preceding loop. The total therefore grows from 137 to 151, while be/benchmark/parquet/AGENTS.md still tells smoke reviewers to expect 137 and to reject a result with a different count. Please assert reader_scenarios().size() == 151 and update the current listing/matrix counts (leaving the historical validation record tied to its old commit unchanged).
Contributor
TPC-DS: Total hot run time: 177426 ms |
Contributor
ClickBench: Total hot run time: 25.05 s |
Contributor
BE UT Coverage ReportIncrement line coverage Increment coverage report
|
yiguolei
approved these changes
Jul 23, 2026
Contributor
|
PR approved by at least one committer and no changes requested. |
github-actions
Bot
added
the
approved
Gabriel39
added a commit
to Gabriel39/incubator-doris
that referenced
this pull request
Jul 23, 2026
…ltering (apache#65934) ### What problem does this PR solve? Issue Number: N/A Related PR: apache#65921 Problem Summary: When a fixed-width Parquet predicate column was also projected, Doris materialized all selected predicate values and compacted the complete column after filtering. The native decoder had already produced the values needed by the raw predicate, so this added an avoidable materialize-and-compact pass. The overhead is visible in TPC-DS Q88. ### What is changed? Evaluate eligible predicates on decoded fixed-width values and append only matching values to the projected column in the same decoder pass. - Generalize the PLAIN-specific consumer and reader APIs into a fixed-width raw filter-and-project path. - Support PLAIN and BYTE_STREAM_SPLIT for identity-width INT32, INT64, FLOAT, and DOUBLE values. - Support DELTA_BINARY_PACKED for INT32 and INT64 values. - Prevalidate advertised chunk encodings before consuming definition levels. - Reject an unexpected unsupported late-page encoding instead of attempting a fallback after cursor progress. - Keep the existing dictionary-id filter and dictionary materialization path unchanged. The raw decoder cannot rewind after predicate evaluation. Therefore, when the predicate column is projected, survivors must be appended before the encoded values and definition-level cursor are consumed. Predicate-only columns retain their placeholder behavior. Nested columns, converted logical types, residual/delete predicates, unsupported expressions, and unsupported encodings continue to use the existing materializing fallback. ### Microbenchmark The reader microbenchmark from apache#65921 was run with a Release build, warm fixture cache, CPU 8, a one-second minimum time, and 10 repetitions. The matrix adds BYTE_STREAM_SPLIT and DELTA_BINARY_PACKED coverage with: - 10% alternating NULLs; - predicate-only and predicate-projected modes; - 1%, 10%, 50%, and 90% selectivity. All 16 combinations completed with the expected raw and selected row counts. Projected, 10% selectivity: | Encoding | CPU ns/raw row, master | CPU ns/raw row, PR | Improvement | CPU CV master / PR | |---|---:|---:|---:|---:| | BYTE_STREAM_SPLIT | 36.41 | 33.43 | 8.2% | 1.25% / 1.47% | | DELTA_BINARY_PACKED | 38.75 | 36.84 | 4.9% | 5.40% / 2.94% | The Delta baseline ran under sustained host load, so its result should be treated as directional. The original projected PLAIN results remain: | Selectivity | CPU ns/raw row, master | CPU ns/raw row, PR | Improvement | |---:|---:|---:|---:| | 1% | 32.80 | 30.80 | 6.1% | | 10% | 33.95 | 31.82 | 6.3% | | 50% | 37.76 | 35.05 | 7.2% | | 90% | 42.06 | 37.66 | 10.5% | ### Release note None ### Check List (For Author) - Test: Unit Test and Manual test - 17 targeted ASAN unit tests covering raw expression evaluation, nullable mapping, projected PLAIN/BSS/Delta scans, unsupported-type fallback, mixed-page safety, residual predicates, and benchmark matrix constraints - Release benchmark target linked successfully - 16-case BSS/Delta reader microbenchmark matrix - Before/after projected-filter microbenchmarks - clang-format 16, check-format, and `git diff --check` - clang-tidy was attempted but blocked by existing master/toolchain errors: unmatched `NOLINTEND` in `be/src/core/types.h` and missing `stddef.h` from the configured toolchain - Behavior changed: No. This extends the existing raw predicate optimization to equivalent fixed-width decoder output. - Does this need documentation: No (cherry picked from commit 1871546)
Gabriel39
added a commit
to Gabriel39/incubator-doris
that referenced
this pull request
Jul 23, 2026
…ltering (apache#65934) ### What problem does this PR solve? Issue Number: N/A Related PR: apache#65921 Problem Summary: When a fixed-width Parquet predicate column was also projected, Doris materialized all selected predicate values and compacted the complete column after filtering. The native decoder had already produced the values needed by the raw predicate, so this added an avoidable materialize-and-compact pass. The overhead is visible in TPC-DS Q88. ### What is changed? Evaluate eligible predicates on decoded fixed-width values and append only matching values to the projected column in the same decoder pass. - Generalize the PLAIN-specific consumer and reader APIs into a fixed-width raw filter-and-project path. - Support PLAIN and BYTE_STREAM_SPLIT for identity-width INT32, INT64, FLOAT, and DOUBLE values. - Support DELTA_BINARY_PACKED for INT32 and INT64 values. - Prevalidate advertised chunk encodings before consuming definition levels. - Reject an unexpected unsupported late-page encoding instead of attempting a fallback after cursor progress. - Keep the existing dictionary-id filter and dictionary materialization path unchanged. The raw decoder cannot rewind after predicate evaluation. Therefore, when the predicate column is projected, survivors must be appended before the encoded values and definition-level cursor are consumed. Predicate-only columns retain their placeholder behavior. Nested columns, converted logical types, residual/delete predicates, unsupported expressions, and unsupported encodings continue to use the existing materializing fallback. ### Microbenchmark The reader microbenchmark from apache#65921 was run with a Release build, warm fixture cache, CPU 8, a one-second minimum time, and 10 repetitions. The matrix adds BYTE_STREAM_SPLIT and DELTA_BINARY_PACKED coverage with: - 10% alternating NULLs; - predicate-only and predicate-projected modes; - 1%, 10%, 50%, and 90% selectivity. All 16 combinations completed with the expected raw and selected row counts. Projected, 10% selectivity: | Encoding | CPU ns/raw row, master | CPU ns/raw row, PR | Improvement | CPU CV master / PR | |---|---:|---:|---:|---:| | BYTE_STREAM_SPLIT | 36.41 | 33.43 | 8.2% | 1.25% / 1.47% | | DELTA_BINARY_PACKED | 38.75 | 36.84 | 4.9% | 5.40% / 2.94% | The Delta baseline ran under sustained host load, so its result should be treated as directional. The original projected PLAIN results remain: | Selectivity | CPU ns/raw row, master | CPU ns/raw row, PR | Improvement | |---:|---:|---:|---:| | 1% | 32.80 | 30.80 | 6.1% | | 10% | 33.95 | 31.82 | 6.3% | | 50% | 37.76 | 35.05 | 7.2% | | 90% | 42.06 | 37.66 | 10.5% | ### Release note None ### Check List (For Author) - Test: Unit Test and Manual test - 17 targeted ASAN unit tests covering raw expression evaluation, nullable mapping, projected PLAIN/BSS/Delta scans, unsupported-type fallback, mixed-page safety, residual predicates, and benchmark matrix constraints - Release benchmark target linked successfully - 16-case BSS/Delta reader microbenchmark matrix - Before/after projected-filter microbenchmarks - clang-format 16, check-format, and `git diff --check` - clang-tidy was attempted but blocked by existing master/toolchain errors: unmatched `NOLINTEND` in `be/src/core/types.h` and missing `stddef.h` from the configured toolchain - Behavior changed: No. This extends the existing raw predicate optimization to equivalent fixed-width decoder output. - Does this need documentation: No (cherry picked from commit 1871546)
yiguolei
pushed a commit
that referenced
this pull request
Jul 24, 2026
## Summary Backport the requested Apache Doris PRs to `branch-4.1` in their master merge order: 1. #63648 2. #64033 3. #64263 4. #64315 5. #63825 6. #65332 7. #65354 8. #65094 9. #65401 10. #65502 11. #65135 12. #65742 13. #65709 14. #65548 15. #65676 16. #65770 17. #65759 18. #65782 19. #65784 20. #65674 21. #65921 22. #65934 23. #65925 24. #65931 #64263, #65354, #65094, #65502, and #65770 are already effectively present on current `branch-4.1`, so this branch does not duplicate those commits. The remaining requested changes are represented by ordered backport commits followed by branch-4.1 compatibility fixes. ## Compatibility notes - Rebased onto the latest `upstream/branch-4.1` and retained both sides of the Iceberg scan conflict resolution. - Keep `be/src/format_v2` and `be/test/format_v2` exactly aligned with current `upstream/master`, as requested. - Apply branch-4.1 compatibility adaptations outside the format_v2 paths. - Preserve the selected PR behavior while avoiding dependencies on unrelated master-only changes. - #65921 supplies the Parquet benchmark scenario header required by `parquet_benchmark_scenarios_test.cpp`, fixing the BE UT compile failure. - Adapt branch-4.1 `VRuntimeFilterWrapper` at the master TableReader boundary so FileScannerV2 residual predicates keep globally rewritten slot indexes. - Keep non-transactional JDBC V2 connections usable by avoiding the unsupported auto-commit transition before Hikari invalidates the proxy. ## FE UT fix - Widen the auto-profile test timing margins to prevent CI scheduling delays from selecting the wrong threshold branch. - Keep the table-filter correctness assertions and use broader performance guardrails suitable for shared FE UT workers. ## Verification - Full local FE+BE build: `Successfully build Doris`. - ASAN BE UT build completed successfully; `test/doris_be_test` linked with exit code 0. - Related BE tests: 382/382 passed across 32 suites, including FileScannerV2, runtime filters, Parquet, Iceberg readers, and format_v2 coverage. - JDBC scanner UT: 3/3 passed; Maven reactor `BUILD SUCCESS`; Checkstyle reports 0 violations. - ClickHouse JDBC V2 regression: 1 suite, 0 failed suites, 0 fatal scripts. - Iceberg branch/tag regression (`iceberg_branch_complex_queries`): 1 suite, 0 failed suites, 0 fatal scripts. - Repository clang-format 16 check: passed for 4,191 files. - `git diff --check`: passed. - `be/src/format_v2` and `be/test/format_v2` have zero diff from current `upstream/master`. --------- Signed-off-by: Gabriel <liwenqiang@selectdb.com> Co-authored-by: daidai <changyuwei@selectdb.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
3 participants
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.
What problem does this PR solve?
Issue Number: N/A
Related PR: #65921
Problem Summary:
When a fixed-width Parquet predicate column was also projected, Doris materialized all selected predicate values and compacted the complete column after filtering. The native decoder had already produced the values needed by the raw predicate, so this added an avoidable materialize-and-compact pass. The overhead is visible in TPC-DS Q88.
What is changed?
Evaluate eligible predicates on decoded fixed-width values and append only matching values to the projected column in the same decoder pass.
The raw decoder cannot rewind after predicate evaluation. Therefore, when the predicate column is projected, survivors must be appended before the encoded values and definition-level cursor are consumed.
Predicate-only columns retain their placeholder behavior. Nested columns, converted logical types, residual/delete predicates, unsupported expressions, and unsupported encodings continue to use the existing materializing fallback.
Microbenchmark
The reader microbenchmark from #65921 was run with a Release build, warm fixture cache, CPU 8, a one-second minimum time, and 10 repetitions.
The matrix adds BYTE_STREAM_SPLIT and DELTA_BINARY_PACKED coverage with:
All 16 combinations completed with the expected raw and selected row counts.
Projected, 10% selectivity:
The Delta baseline ran under sustained host load, so its result should be treated as directional.
The original projected PLAIN results remain:
Release note
None
Check List (For Author)
git diff --checkNOLINTENDinbe/src/core/types.hand missingstddef.hfrom the configured toolchain