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

[via libcxx-commits]

Author: Nikolas Klauser
Date: 2026-01-08T13:26:04+01:00
New Revision: 9a8421fa6191d2e1047e3dc8c72a22fa810f9aee

URL: https://github.com/llvm/llvm-project/commit/9a8421fa6191d2e1047e3dc8c72a22fa810f9aee
DIFF: https://github.com/llvm/llvm-project/commit/9a8421fa6191d2e1047e3dc8c72a22fa810f9aee.diff

LOG: [libc++] Update our release notes for the upcoming release (#174625)

Added: 
    

Modified: 
    libcxx/docs/ReleaseNotes/22.rst

Removed: 
    


################################################################################
diff  --git a/libcxx/docs/ReleaseNotes/22.rst b/libcxx/docs/ReleaseNotes/22.rst
index 39e667f98bc65..aea8cca6f3cee 100644
--- a/libcxx/docs/ReleaseNotes/22.rst
+++ b/libcxx/docs/ReleaseNotes/22.rst
@@ -59,49 +59,48 @@ 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 associative and unordered containers has been significantly improved. This is an overview of the
+  
diff erent 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 many algorithms has been improved. This is an overview of the 
diff erent 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
+
+  - ``std::search_n`` for random access iterators now tries to skip elements.
+    In contrived cases improvements of 70,000x have been observed.
+
+- 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 performance fo ``search_n`` has been significantly improved.
-- 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
 -------------------------
@@ -134,9 +133,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::
diff erence_type`` to change from
   ``long long`` to ``__int128`` in some cases.