Do not use std::vector = {} to release memory

Summary:
> It appears that invoking v = {}; for an std::vector<...> v is equivalent to v.clear(), which does not release its allocated memory. There are a number of places in the codebase where it appears to be used for that purpose however (mostly written by me). Replace those with std::vector<...>{}.swap(v); (using a helper function ClearShrink in util/vector.h).

For now the net.cpp changes are not applicable, as they depend on V2Transport backports. The change is useful anyway even if we just apply it to the headersync data. IIUC we could save  multiple megabytes of memory, that would otherwsise not be freed during the entire lifetime of the connection, per peer involved in header pre-sync . `m_redownloaded_headers` is a buffer that can stores block headers during the redownload phase of header synchronization.

This is a backport of [[bitcoin/bitcoin#28452 | core#28452]]

Test Plan: `ninja all check-all`

Reviewers: #bitcoin_abc, Fabien

Reviewed By: #bitcoin_abc, Fabien

Differential Revision: https://reviews.bitcoinabc.org/D18446

Author: sipa

src/headerssync.cpp

@@ -7,6 +7,7 @@
 #include <pow/pow.h>
 #include <timedata.h>
 #include <util/check.h>
+#include <util/vector.h>
 
 // The two constants below are computed using the simulation script on
 // https://gist.github.com/sipa/016ae445c132cdf65a2791534dfb7ae1
@@ -65,9 +66,9 @@ HeadersSyncState::HeadersSyncState(NodeId id,
  */
 void HeadersSyncState::Finalize() {
     Assume(m_download_state != State::FINAL);
-    m_header_commitments = {};
+    ClearShrink(m_header_commitments);
     m_last_header_received.SetNull();
-    m_redownloaded_headers = {};
+    ClearShrink(m_redownloaded_headers);
     m_redownload_buffer_last_hash.SetNull();
     m_redownload_buffer_first_prev_hash.SetNull();
     m_process_all_remaining_headers = false;

src/test/util_tests.cpp

@@ -2924,4 +2924,27 @@ BOOST_AUTO_TEST_CASE(remove_prefix) {
     BOOST_CHECK_EQUAL(RemovePrefix("", ""), "");
 }
 
+BOOST_AUTO_TEST_CASE(clearshrink_test) {
+    {
+        std::vector<uint8_t> v = {1, 2, 3};
+        ClearShrink(v);
+        BOOST_CHECK_EQUAL(v.size(), 0);
+        BOOST_CHECK_EQUAL(v.capacity(), 0);
+    }
+
+    {
+        std::vector<bool> v = {false, true, false, false, true, true};
+        ClearShrink(v);
+        BOOST_CHECK_EQUAL(v.size(), 0);
+        BOOST_CHECK_EQUAL(v.capacity(), 0);
+    }
+
+    {
+        std::deque<int> v = {1, 3, 3, 7};
+        ClearShrink(v);
+        BOOST_CHECK_EQUAL(v.size(), 0);
+        // std::deque has no capacity() we can observe.
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()

src/util/vector.h

@@ -48,6 +48,23 @@ template <typename V> inline V Cat(V v1, const V &v2) {
     return v1;
 }
 
+/** Clear a vector (or std::deque) and release its allocated memory. */
+template <typename V> inline void ClearShrink(V &v) noexcept {
+    // There are various ways to clear a vector and release its memory:
+    //
+    // 1. V{}.swap(v)
+    // 2. v = V{}
+    // 3. v = {}; v.shrink_to_fit();
+    // 4. v.clear(); v.shrink_to_fit();
+    //
+    // (2) does not appear to release memory in glibc debug mode, even if
+    // v.shrink_to_fit() follows. (3) and (4) rely on
+    // std::vector::shrink_to_fit, which is only a non-binding request.
+    // Therefore, we use method (1).
+
+    V{}.swap(v);
+}
+
 template <typename V, typename L>
 inline std::optional<V> FindFirst(const std::vector<V> &vec, const L fnc) {
     for (const auto &el : vec) {