[libcxx-commits] [libcxx] [libc++] Update our release notes for the upcoming release (PR #174625)

[Nikolas Klauser via libcxx-commits]

https://github.com/philnik777 created https://github.com/llvm/llvm-project/pull/174625

None

>From bd61e8a1c5c58da5c55252bc3685f5181e077839 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Tue, 6 Jan 2026 18:20:22 +0100
Subject: [PATCH] [libc++] Update our release notes for the upcoming release

---
 libcxx/docs/ReleaseNotes/22.rst | 76 +++++++++++++++------------------
 1 file changed, 35 insertions(+), 41 deletions(-)

diff --git a/libcxx/docs/ReleaseNotes/22.rst b/libcxx/docs/ReleaseNotes/22.rst
index 3e2b3e6633bb1..9edd0b79cd648 100644
--- a/libcxx/docs/ReleaseNotes/22.rst
+++ b/libcxx/docs/ReleaseNotes/22.rst
@@ -59,48 +59,45 @@ Implemented Papers
 Improvements and New Features
 -----------------------------
 
-- The performance of ``map::map(const map&)`` has been improved up to 2.3x
-- The performance of ``map::operator=(const map&)`` has been improved by up to 11x
-- The performance of ``unordered_set::unordered_set(const unordered_set&)`` has been improved by up to 3.3x.
-- The performance of ``unordered_set::operator=(const unordered_set&)`` has been improved by up to 5x.
-- The performance of ``map::erase`` and ``set::erase`` has been improved by up to 2x
-- The performance of ``find(key)`` in ``map``, ``set``, ``multimap`` and ``multiset`` has been improved by up to 2.3x
-- Some reallocations are now avoided in `std::filesystem::path::lexically_relative`, resulting in a performance
-  improvement of up to 1.7x.
-- The performance of the ``(iterator, iterator)`` constructors of ``map``, ``set``, ``multimap`` and ``multiset``
-  has been improved by up to 3x
-- The performance of ``insert(iterator, iterator)`` of ``map``, ``set``, ``multimap`` and ``multiset`` has been improved
-  by up to 2.5x
-- The performance of ``erase(iterator, iterator)`` in the unordered containers has been improved by up to 1.9x
-- The performance of ``map::insert_or_assign`` has been improved by up to 2x
-- ``ofstream::write`` has been optimized to pass through large strings to system calls directly instead of copying them
-  in chunks into a buffer.
-- Multiple internal types have been refactored to use ``[[no_unique_address]]``, resulting in faster compile times and
-  reduced debug information.
+- The performance of the associative and unordered container has been significantly improved. This is an overview of the
+  different functions and by up to how much they have been improved:
+
+  - ``map::map(const map&)``: 2.3x
+  - ``map::operator=(const map&)``: 11x
+  - ``unordered_set::unordered_set(const unordered_set&)``: 3.3x
+  - ``unordered_set::operator=(const unordered_set&)``: 5x
+  - ``erase`` of ``map`` and ``set``: 2x
+  - ``find(key)`` of ``map``, ``set``, ``multimap`` and ``multiset``: 2.3x
+  - ``(iterator, iterator)`` constructors of ``map``, ``set``, ``multimap`` and ``multiset``: 3x
+  - ``insert(iterator, iterator)`` of ``map``, ``set``, ``multimap`` and ``multiset``: 2.5x
+  - ``erase(iterator, iterator)`` of the unordered containers: 1.9x
+  - ``map::insert_or_assign``: 2x
+
+- The performance of a lot of algorithms has been improved. This is an overview of the different functions and by up to
+  how much they have been improved:
+
+  - ``std::find`` for integral types: 2x
+  - ``std::for_each`` and ``ranges::for_each`` over the associative containers: 2x
+  - ``std::rotate``: 3x
+  - Some have been specifically optimized for segmented iterators:
+
+    - ``std::distance`` and ``std::ranges::distance`` on non-random-access iterators: 1600x
+    - ``{std,ranges}::{fill, fill_n}``: 10x
+    - ``std::{generate, generate_n}`` and ``std::ranges::generate_n``: 1.8x
+
+- There have also been performance improvements in other library facilities:
+
+  - ``vector<bool>::reserve()``: 2x
+  - ``num_get::do_get`` integral overloads: 2.8x
+  - Some reallocations are now avoided in ``std::filesystem::path::lexically_relative``: 1.7x
+  - ``ofstream::write`` passes large strings to system calls directly instead of copying them in chunks into a buffer
+  - ``std::align`` is now an inline function, which allows the compiler to better optimize calls to it
 
-- The performance of ``std::find`` has been improved by up to 2x for integral types
-- The ``std::distance`` and ``std::ranges::distance`` algorithms have been optimized for segmented iterators (e.g.,
-  ``std::join_view`` iterators), reducing the complexity from ``O(n)`` to ``O(n / segment_size)``. Benchmarks show
-  performance improvements of over 1600x in favorable cases with large segment sizes (e.g., 1024).
-- The ``std::{fill, fill_n}`` and ``std::ranges::{fill, fill_n}`` algorithms have been optimized for segmented iterators,
-  resulting in a performance improvement of at least 10x for ``std::deque<int>`` iterators and
-  ``std::join_view<std::vector<std::vector<int>>>`` iterators.
-- The ``std::{generate, generate_n}`` and ``std::ranges::generate_n`` algorithms have been optimized for segmented
-  iterators, resulting in a performance improvement for ``std::deque<short>`` and
-  ``std::join_view<vector<vector<short>>>`` iterators.
 - ``std::atomic::wait`` has been refactored to accept more types to use platform native wait functions directly.
   This is guarded behind the ABI Macro ``_LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE``.
-- The performance of ``vector<bool>::reserve()`` has been improved by up to 2x.
-
-- ``std::for_each`` and ``ranges::for_each`` have been optimized to iterate more efficiently over the associative
-  containers, resulting in performance improvements of up to 2x.
-
-- The ``num_get::do_get`` integral overloads have been optimized, resulting in a performance improvement of up to 2.8x.
 
-- The performance of ``std::align`` has been improved by making it an inline function, which allows the compiler to
-  better optimize calls to it.
-
-- ``rotate`` has been optimized, resulting in a performance improvement of up to 3x.
+- Multiple internal types have been refactored to use ``[[no_unique_address]]``, resulting in faster compile times and
+  reduced debug information.
 
 Deprecations and Removals
 -------------------------
@@ -133,9 +130,6 @@ ABI Affecting Changes
   potentially inheriting from the types they wrap. At this point in time we are not aware of any ABI changes caused by
   this.
 
-- ``std::align`` is now implemented as an inline function and its definition is removed from the
-   libc++ built library in ABI v2, or when the ``_LIBCPP_ABI_DO_NOT_EXPORT_ALIGN`` ABI configuration is enabled.
-
 - ``ranges::iota_view`` is now aware of ``__int128``. This causes ``iota_view::difference_type`` to change from
   ``long long`` to ``__int128`` in some cases.