realm / realm-core / github_pull_request_281750

    {

    }

    {

        size_t pos = m_owner.get_free_space(size);

        // Write the block

        char* dest_addr = translate(pos);

        REALM_ASSERT_RELEASE(dest_addr && (reinterpret_cast<size_t>(dest_addr) & 7) == 0);

        memcpy(dest_addr, &checksum, 4);

        memcpy(dest_addr + 4, data + 4, size - 4);

        // return ref of the written array

        ref_type ref = to_ref(pos);

        return ref;

    }

    {

        return m_alloc.translate_memory_pos(ref);

    }

{

    if (start_ref < m_base_ref)

    if (start_ref + size > m_base_ref + m_map.get_size())

        return false;

    return true;

}

{

    // align to 1MB boundary

    size_t page_mask = m_alignment - 1;

    return start_ref & ~page_mask;

}

{

    size_t window_size = start_ref + size - m_base_ref;

    // always map at least to match alignment

    if (window_size < m_alignment)

        window_size = m_alignment;

    // but never map beyond end of file

    size_t file_size = to_size_t(f.get_size());

    REALM_ASSERT_DEBUG_EX(start_ref + size <= file_size, start_ref + size, file_size);

    if (window_size > file_size - m_base_ref)

        window_size = file_size - m_base_ref;

    return window_size;

}

{

    size_t aligned_ref = aligned_to_mmap_block(start_ref);

    if (aligned_ref != m_base_ref)

    size_t window_size = get_window_size(f, start_ref, size);

    m_map.sync();

    m_map.unmap();

    m_map.map(f, File::access_ReadWrite, window_size, 0, m_base_ref);

    return true;

}

{

    m_base_ref = aligned_to_mmap_block(start_ref);

    size_t window_size = get_window_size(f, start_ref, size);

    m_map.map(f, File::access_ReadWrite, window_size, 0, m_base_ref);

#if REALM_ENABLE_ENCRYPTION

    if (auto p = m_map.get_encrypted_mapping())

        p->set_marker(write_marker);

}

{

    m_map.sync();

    m_map.unmap();

}

{

    m_map.flush();

}

{

    flush();

    m_map.sync();

}

{

    return m_map.get_addr() + (ref - m_base_ref);

}

{

    realm::util::encryption_read_barrier_for_write(start_addr, size, m_map.get_encrypted_mapping());

}

{

    realm::util::encryption_write_barrier(start_addr, size, m_map.get_encrypted_mapping());

}

{

    m_map_windows.reserve(num_map_windows);

    if (sizeof(int*) == 4) {                  // 32 bit address space

    else {

        // large address space - just choose a size so that we have a single window

        size_t total_size = m_alloc.get_total_size();

        size_t wanted_size = 1;

        while (total_size) {

            total_size >>= 1;

            wanted_size <<= 1;

        }

        if (wanted_size < 1 * 1024 * 1024)

            wanted_size = 1 * 1024 * 1024; // minimum 1M

        m_window_alignment = wanted_size;

    }

#endif

}

{

}

GroupCommitter::~GroupCommitter() = default;

{

    Array& top = m_group.m_top;

    m_logical_size = size_t(top.get_as_ref_or_tagged(Group::s_file_size_ndx).get_as_int());

    // When we make a commit, we will at least need room for the version

    while (top.size() <= Group::s_version_ndx) {

        top.add(0); // Throws

    }

    m_free_positions.set_parent(&top, Group::s_free_pos_ndx);

    m_free_lengths.set_parent(&top, Group::s_free_size_ndx);

    m_free_versions.set_parent(&top, Group::s_free_version_ndx);

    ref_type free_positions_ref = m_free_positions.get_ref_from_parent();

    if (free_positions_ref) {

        m_free_positions.init_from_ref(free_positions_ref);

    }

    else {

        m_free_positions.create(Array::type_Normal); // Throws

        _impl::DestroyGuard<Array> dg(&m_free_positions);

        m_free_positions.update_parent(); // Throws

        dg.release();

    }

    if (ref_type ref = m_free_lengths.get_ref_from_parent()) {

        m_free_lengths.init_from_ref(ref);

        REALM_ASSERT_RELEASE_EX(m_free_positions.size() == m_free_lengths.size(), top.get_ref(),

                                m_free_positions.size(), m_free_lengths.size());

    }

    else {

        m_free_lengths.create(Array::type_Normal); // Throws

        _impl::DestroyGuard<Array> dg(&m_free_lengths);

        m_free_lengths.update_parent(); // Throws

        dg.release();

    }

    DB::version_type initial_version = 0;

    if (ref_type ref = m_free_versions.get_ref_from_parent()) {

        m_free_versions.init_from_ref(ref);

        REALM_ASSERT_RELEASE_EX(m_free_versions.size() == m_free_lengths.size(), top.get_ref(),

                                m_free_versions.size(), m_free_lengths.size());

    }

    else {

        int_fast64_t value = int_fast64_t(initial_version);

        top.set(6, 1 + 2 * uint64_t(initial_version)); // Throws

        size_t n = m_free_positions.size();

        bool context_flag = false;

        m_free_versions.create(Array::type_Normal, context_flag, n, value); // Throws

        _impl::DestroyGuard<Array> dg(&m_free_versions);

        m_free_versions.update_parent(); // Throws

        dg.release();

    }

    m_evacuation_limit = 0;

    m_backoff = 0;

}

{

    switch (m_durability) {

        case Durability::Full:

        case Durability::Unsafe:

            m_window_mgr.sync_all_mappings();

            break;

        case Durability::MemOnly:

            m_window_mgr.flush_all_mappings();

    }

}

GroupWriter::~GroupWriter() = default;

{

    auto sz = to_size_t(m_alloc.get_file_size());

    return sz;

}

{

    for (const auto& window : m_map_windows) {

        window->flush();

    }

}

{

    if (m_durability == Durability::Unsafe)

        return;

    for (const auto& window : m_map_windows) {

        window->sync();

    }

}

{

    auto match = std::find_if(m_map_windows.begin(), m_map_windows.end(), [&](const auto& window) {

        return window->matches(start_ref, size) || window->extends_to_match(m_alloc.get_file(), start_ref, size);

    });

    if (match != m_map_windows.end()) {

        // move matching window to top (to keep LRU order)

        std::rotate(m_map_windows.begin(), match, match + 1);

        return m_map_windows[0].get();

    }

    // no window found, make room for a new one at the top

    if (m_map_windows.size() == num_map_windows) {

    auto new_window =

        std::make_unique<MapWindow>(m_window_alignment, m_alloc.get_file(), start_ref, size, m_write_marker);

    m_map_windows.insert(m_map_windows.begin(), std::move(new_window));

    return m_map_windows[0].get();

}

{

    class Collector : public Array::MemUsageHandler {

    public:

        Collector(std::vector<Reachable>& reachable)

            : m_reachable(reachable)

        {

        }

        void handle(ref_type ref, size_t, size_t used) override

        {

            m_reachable.emplace_back(Reachable{ref, used});

        }

        std::vector<Reachable>& m_reachable;

    };

    // collect reachable blocks in all reachable versions

    for (auto& [version, info] : m_top_ref_map) {

        Collector collector(info.reachable_blocks);

        // skip any empty entries

        if (info.top_ref == 0)

            continue;

        Array array(m_alloc);

        array.init_from_ref(info.top_ref);

        array.report_memory_usage(collector);

        std::sort(info.reachable_blocks.begin(), info.reachable_blocks.end(),

                  [](const Reachable& a, const Reachable& b) {

                      return a.pos < b.pos;

                  });

    }

}

{

    struct FreeList {

        Array positions;

        Array lengths;

        Array versions;

        ref_type top_ref;

        ref_type logical_file_size;

        uint64_t version;

        bool initialized = false;

        FreeList(Allocator& alloc, ref_type top, ref_type logical_file_size, uint64_t version)

            : positions(alloc)

            , lengths(alloc)

            , versions(alloc)

            , top_ref(top)

            , logical_file_size(logical_file_size)

            , version(version)

        {

        }

    };

    using FreeListMap = std::vector<std::unique_ptr<FreeList>>;

    FreeListMap old_freelists;

    old_freelists.reserve(m_top_ref_map.size());

    for (auto& [version, info] : m_top_ref_map) {

        if (version < m_oldest_reachable_version)

        auto e = std::make_unique<FreeList>(m_alloc, info.top_ref, info.logical_file_size, version);

        old_freelists.push_back(std::move(e));

    }

    // little helper: get the youngest version older than given

    auto get_earlier = [&](uint64_t version) -> FreeList* {

        auto it = std::lower_bound(old_freelists.begin(), old_freelists.end(), version,

                                   [](const std::unique_ptr<FreeList>& e, uint64_t v) {

                                       return e->version < v;

                                   });

        // There will always be at least one freelist:

        REALM_ASSERT(it != old_freelists.end());

        REALM_ASSERT(it != old_freelists.begin());

        --it;

        REALM_ASSERT((*it)->version < version);

        return it->get();

    };

    // find (if possible) youngest time stamp in any block in a sequence that fully covers a given one.

    auto find_cover_for = [&](const FreeSpaceEntry& entry, FreeList& free_list) -> std::optional<uint64_t> {

        auto entry_end = std::min(entry.ref + entry.size, free_list.logical_file_size);

        if (entry.ref >= entry_end) {

            return 0; // block completely beyond end of file

        }

        if (!free_list.initialized) {

            // setup arrays

            free_list.initialized = true;

            if (free_list.top_ref) {

                Array top_array(m_alloc);

                top_array.init_from_ref(free_list.top_ref);

                if (top_array.size() > Group::s_free_version_ndx) {

                    // we have a freelist with versioning info

                    free_list.positions.init_from_ref(top_array.get_as_ref(Group::s_free_pos_ndx));

                    free_list.lengths.init_from_ref(top_array.get_as_ref(Group::s_free_size_ndx));

                    free_list.versions.init_from_ref(top_array.get_as_ref(Group::s_free_version_ndx));

                }

            }

        }

        if (!free_list.positions.is_attached()) {

        const size_t limit = free_list.positions.size();

        if (limit == 0) {

        const size_t index = free_list.positions.upper_bound_int(entry.ref) - 1;

        if (index == size_t(-1)) {

            return {}; // no free blocks before the 'ref' we are looking for

        }

        REALM_ASSERT(index < limit); // follows from above

        const auto start_pos = static_cast<ref_type>(free_list.positions.get(index));

        REALM_ASSERT(start_pos <= entry.ref);

        auto end_pos = start_pos + static_cast<ref_type>(free_list.lengths.get(index));

        if (end_pos <= entry.ref) {

            return {}; // free block ends before the 'ref' we are looking for

        }

        uint64_t found_version = free_list.versions.get(index);

        // coalesce any subsequent contiguous entries

        for (auto next = index + 1;

             next < limit && free_list.positions.get(next) == (int64_t)end_pos && end_pos < entry_end; ++next) {

            end_pos += static_cast<ref_type>(free_list.lengths.get(next));

            // pick youngest (highest) version of blocks

            found_version = std::max<uint64_t>(found_version, free_list.versions.get(next));

        }

        // is the block fully covered by range established above?

        if (end_pos < entry_end) {

            return {}; // no, it isn't

        }

        REALM_ASSERT(found_version <= entry.released_at_version);

        return found_version;

    };

    // check if a given entry overlaps a reachable block. Only used in debug mode.

    auto is_referenced = [&](FreeSpaceEntry& entry) -> bool {

#ifdef REALM_DEBUG

        bool referenced = false;

        ALLOC_DBG_COUT("    Considering [" << entry.ref << ", " << entry.size << "]-" << entry.released_at_version

                                           << " {");

        auto end = m_top_ref_map.end();

        for (auto top_ref_map = m_top_ref_map.begin(); top_ref_map != end && !referenced; ++top_ref_map) {

            auto info_begin = top_ref_map->second.reachable_blocks.begin();

            auto info_end = top_ref_map->second.reachable_blocks.end();

            auto it = std::lower_bound(info_begin, info_end, entry.ref, [](const Reachable& a, size_t val) {

                return val > a.pos;

            });

            if (it != info_end) {

                if (it != info_begin)

                    --it;

                while (it != info_end && it->pos < entry.ref + entry.size) {

                    if (it->pos + it->size > entry.ref) {

                        ALLOC_DBG_COUT(top_ref_map->first << " ");

                        referenced = true;

                        break;

                    }

                    ++it;

                }

            }

        }

        if (!referenced) {

            ALLOC_DBG_COUT("none");

        }

        ALLOC_DBG_COUT("} ");

        return referenced;

    };

    auto backdate_single_entry = [&](FreeSpaceEntry& entry) -> void {

        const auto referenced = is_referenced(entry);

        // early out if the reference is to the most recent version

        if (entry.released_at_version == m_current_version) {

        while (entry.released_at_version) {

            // early out for references before oldest freelist:

            if (entry.released_at_version <= this->m_oldest_reachable_version) {

                REALM_ASSERT_DEBUG(!referenced);

                break;

            }

            auto earlier_it = get_earlier(entry.released_at_version);

            ALLOC_DBG_COUT(" - earlier freelist: " << earlier_it->version);

            if (auto covering_version = find_cover_for(entry, *earlier_it)) {

                ALLOC_DBG_COUT("  backdating [" << entry.ref << ", " << entry.size << "]  version: "

                                                << entry.released_at_version << " -> " << *covering_version);

                REALM_ASSERT_DEBUG(!referenced);

                entry.released_at_version = *covering_version;

            }

            else {

                ALLOC_DBG_COUT("  not free at that point");

                REALM_ASSERT_DEBUG(referenced);

                break;

            }

        }

        ALLOC_DBG_COUT(std::endl);

    };

#ifdef REALM_DEBUG

    map_reachable();

#endif

    for (auto&& entry : m_not_free_in_file) {

        backdate_single_entry(entry);

    }

}

{

    Array& top = m_group.m_top;

    if (top.size() > Group::s_evacuation_point_ndx) {

        if (auto val = top.get(Group::s_evacuation_point_ndx)) {

            Array arr(m_alloc);

            if (val & 1) {

                m_evacuation_limit = size_t(val >> 1);

                arr.create(Node::type_Normal);

                arr.add(uint64_t(m_evacuation_limit));

                arr.add(0); // Backoff = false

                top.set_as_ref(Group::s_evacuation_point_ndx, arr.get_ref());

            }

            else {

                arr.init_from_ref(to_ref(val));

                auto sz = arr.size();

                REALM_ASSERT(sz >= 2);

                m_evacuation_limit = size_t(arr.get(0));

                m_backoff = arr.get(1);

                if (m_backoff > 0) {

                    --m_backoff;

                }

                else {

                    for (size_t i = 2; i < sz; i++) {

                        m_evacuation_progress.push_back(size_t(arr.get(i)));

                    }

                }

                // We give up if the freelists were allocated above the evacuation limit

                if (m_evacuation_limit > 0 && m_free_positions.get_ref() > m_evacuation_limit) {

                    // Wait 10 commits until trying again

                    m_backoff = 10;

                    m_evacuation_limit = 0;

                    if (auto logger = m_group.get_logger()) {

                }

            }

        }

    }

}

{

    ALLOC_DBG_COUT("Commit nr " << m_current_version << "   ( from " << m_oldest_reachable_version << " )"

                                << std::endl);

    read_in_freelist();

    // Now, 'm_size_map' holds all free elements candidate for recycling

    Array& top = m_group.m_top;

    ALLOC_DBG_COUT("  Allocating file space for data:" << std::endl);

    // Recursively write all changed arrays (but not 'top' and free-lists yet,

    // as they are going to change along the way.) If free space is available in

    // the attached database file, we use it, but this does not include space

    // that has been release during the current transaction (or since the last

    // commit), as that would lead to clobbering of the previous database

    // version.

    bool deep = true, only_if_modified = true;

    std::unique_ptr<InMemoryWriter> in_memory_writer;

    _impl::ArrayWriterBase* writer = this;

    if (m_alloc.is_in_memory()) {

        in_memory_writer = std::make_unique<InMemoryWriter>(*this);

        writer = in_memory_writer.get();

    }

    ref_type names_ref = m_group.m_table_names.write(*writer, deep, only_if_modified); // Throws

    ref_type tables_ref = m_group.m_tables.write(*writer, deep, only_if_modified);     // Throws

    int_fast64_t value_1 = from_ref(names_ref);

    int_fast64_t value_2 = from_ref(tables_ref);

    top.set(0, value_1); // Throws

    top.set(1, value_2); // Throws

    // If file has a history and is opened in shared mode, write the new history

    // to the file. If the file has a history, but si not opened in shared mode,

    // discard the history, as it could otherwise be left in an inconsistent state.

    if (top.size() > Group::s_hist_ref_ndx) {

        if (ref_type history_ref = top.get_as_ref(Group::s_hist_ref_ndx)) {

            Allocator& alloc = top.get_alloc();

            ref_type new_history_ref = Array::write(history_ref, alloc, *writer, only_if_modified); // Throws

            top.set(Group::s_hist_ref_ndx, from_ref(new_history_ref));                              // Throws

        }

    }

    if (top.size() > Group::s_evacuation_point_ndx) {

        ref_type ref = top.get_as_ref(Group::s_evacuation_point_ndx);

        if (m_evacuation_limit || m_backoff) {

            REALM_ASSERT(ref);

            Array arr(m_alloc);

            arr.init_from_ref(ref);

            arr.truncate(2);

            arr.set(0, int64_t(m_evacuation_limit));

            if (m_backoff == 0 && m_evacuation_progress.empty()) {

                // We have done a scan - Now we should just wait for the nodes still

                // being in the evacuation zone being released by the transactions

                // still holding on to them. This could take many commits.

                m_backoff = 1000;

            }

            arr.set(1, m_backoff); // Backoff from scanning

            for (auto index : m_evacuation_progress) {

                arr.add(int64_t(index));

            }

            ref = arr.write(*writer, false, only_if_modified);

            top.set_as_ref(Group::s_evacuation_point_ndx, ref);

        }

        else if (ref) {

            Array::destroy(ref, m_alloc);

            top.set(Group::s_evacuation_point_ndx, 0);

        }

    }

    ALLOC_DBG_COUT("  Freelist size after allocations: " << m_size_map.size() << std::endl);

    // We now back-date (if possible) any blocks freed in versions which

    // are becoming unreachable.

    if (m_any_new_unreachables)

        backdate();

    // We now have a bit of a chicken-and-egg problem. We need to write the

    // free-lists to the file, but the act of writing them will consume free

    // space, and thereby change the free-lists. To solve this problem, we

    // calculate an upper bound on the amount af space required for all of the

    // remaining arrays and allocate the space as one big chunk. This way we can

    // finalize the free-lists before writing them to the file.

    size_t max_free_list_size = m_size_map.size();

    // We need to add to the free-list any space that was freed during the

    // current transaction, but to avoid clobering the previous version, we

    // cannot add it yet. Instead we simply account for the space

    // required. Since we will modify the free-lists themselves, we must ensure

    // that the original arrays used by the free-lists are counted as part of

    // the space that was freed during the current transaction. Note that a

    // copy-on-write on m_free_positions, for example, also implies a

    // copy-on-write on Group::m_top.

    ALLOC_DBG_COUT("  In-mem freelist before/after consolidation: " << m_group.m_alloc.m_free_read_only.size());

    size_t free_read_only_size = m_group.m_alloc.consolidate_free_read_only(); // Throws

    ALLOC_DBG_COUT("/" << free_read_only_size << std::endl);

    max_free_list_size += free_read_only_size;

    max_free_list_size += m_not_free_in_file.size();

    max_free_list_size += m_under_evacuation.size();

    // The final allocation of free space (i.e., the call to

    // reserve_free_space() below) may add extra entries to the free-lists.

    // We reserve room for the worst case scenario, which is as follows:

    // If the database has *max* theoretical fragmentation, it'll need one

    // entry in the free list for every 16 bytes, because both allocated and

    // free chunks are at least 8 bytes in size. For databases smaller than 2Gb

    // each free list entry requires 16 bytes (4 for the position, 4 for the

    // size and 8 for the version). The worst case scenario thus needs access

    // to a contiguous address range equal to existing database size.

    // This growth requires at the most 8 extension steps, each adding one entry

    // to the free list. The worst case occurs when you will have to expand the

    // size to over 2 GB where each entry suddenly requires 24 bytes. In this

    // case you will need 2 extra steps.

    // Another limit is due to the fact than an array holds less than 0x1000000

    // entries, so the total free list size will be less than 0x16000000. So for

    // bigger databases the space required for free lists will be relatively less.

    max_free_list_size += 10;

    size_t max_free_space_needed =

        Array::get_max_byte_size(top.size()) + size_per_free_list_entry() * max_free_list_size;

    ALLOC_DBG_COUT("  Allocating file space for freelists:" << std::endl);

    // Reserve space for remaining arrays. We ask for some extra bytes beyond the

    // maximum number that is required. This ensures that even if we end up

    // using the maximum size possible, we still do not end up with a zero size

    // free-space chunk as we deduct the actually used size from it.

    auto reserve = reserve_free_space(max_free_space_needed + 8); // Throws

    size_t reserve_pos = reserve->second;

    size_t reserve_size = reserve->first;

    // Now we can check, if we can reduce the logical file size. This can be done

    // when there is only one block in m_under_evacuation, which means that all

    // nodes in this range have been moved

    if (m_under_evacuation.size() == 1) {

        auto& elem = m_under_evacuation.back();

        if (elem.ref + elem.size == m_logical_size) {

            // This is at the end of the file

            size_t pos = elem.ref;

            m_logical_size = util::round_up_to_page_size(pos);

            elem.size = (m_logical_size - pos);

            if (elem.size == 0)

                m_under_evacuation.clear();

            top.set(Group::s_file_size_ndx, RefOrTagged::make_tagged(m_logical_size));

            auto ref = top.get_as_ref(Group::s_evacuation_point_ndx);

            REALM_ASSERT(ref);

            Array::destroy(ref, m_alloc);

            top.set(Group::s_evacuation_point_ndx, 0);

            m_evacuation_limit = 0;

            if (auto logger = m_group.get_logger()) {

                logger->log(util::Logger::Level::detail, "New logical size %1", m_logical_size);

            }

        }

    }

    // At this point we have allocated all the space we need, so we can add to

    // the free-lists any free space created during the current transaction (or

    // since last commit). Had we added it earlier, we would have risked

    // clobbering the previous database version. Note, however, that this risk

    // would only have been present in the non-transactional case where there is

    // no version tracking on the free-space chunks.

    // Now, let's update the realm-style freelists, which will later be written to file.

    // Function returns index of element holding the space reserved for the free

    // lists in the file.

    size_t reserve_ndx = recreate_freelist(reserve_pos);

    ALLOC_DBG_COUT("  Freelist size after merge: " << m_free_positions.size() << "   freelist space required: "

                                                   << max_free_space_needed << std::endl);

    // Before we calculate the actual sizes of the free-list arrays, we must

    // make sure that the final adjustments of the free lists (i.e., the

    // deduction of the actually used space from the reserved chunk,) will not

    // change the byte-size of those arrays.

    // size_t reserve_pos = to_size_t(m_free_positions.get(reserve_ndx));

    REALM_ASSERT_3(reserve_size, >, max_free_space_needed);

    int_fast64_t value_4 = to_int64(reserve_pos + max_free_space_needed);

    // Ensure that this arrays does not reposition itself

    m_free_positions.ensure_minimum_width(value_4); // Throws

    // Get final sizes of free-list arrays

    size_t free_positions_size = m_free_positions.get_byte_size();

    size_t free_sizes_size = m_free_lengths.get_byte_size();

    size_t free_versions_size = m_free_versions.get_byte_size();

    REALM_ASSERT(Array::get_wtype_from_header(Array::get_header_from_data(m_free_versions.m_data)) ==

                 Array::wtype_Bits);

    // Calculate write positions

    ref_type reserve_ref = to_ref(reserve_pos);

    ref_type free_positions_ref = reserve_ref;

    ref_type free_sizes_ref = free_positions_ref + free_positions_size;

    ref_type free_versions_ref = free_sizes_ref + free_sizes_size;

    ref_type top_ref = free_versions_ref + free_versions_size;

    // Update top to point to the calculated positions

    top.set(Group::s_free_pos_ndx, from_ref(free_positions_ref));               // Throws

    top.set(Group::s_free_size_ndx, from_ref(free_sizes_ref));                  // Throws

    top.set(Group::s_free_version_ndx, from_ref(free_versions_ref));            // Throws

    top.set(Group::s_version_ndx, RefOrTagged::make_tagged(m_current_version)); // Throws

    // Compacting files smaller than 1 Mb is not worth the effort. Arbitrary chosen value.

    static constexpr size_t minimal_compaction_size = 0x100000;

    if (m_logical_size >= minimal_compaction_size && m_evacuation_limit == 0 && m_backoff == 0) {

        // We might have allocated a bigger chunk than needed for the free lists, so if we

        // add what we have reserved and subtract what was requested, we get a better measure

        // for what will be free eventually. Also subtract the locked space as this is not

        // actually free.

        size_t free_space = m_free_space_size + reserve_size - max_free_space_needed - m_locked_space_size;

        REALM_ASSERT(m_logical_size > free_space);

        size_t used_space = m_logical_size - free_space;

        if (free_space > 2 * used_space) {

            // Clean up potential

            auto limit = util::round_up_to_page_size(used_space + used_space / 2);

            // If we make the file too small, there is a big chance it will grow immediately afterwards

            static constexpr size_t minimal_evac_limit = 0x10000;

            m_evacuation_limit = std::max(minimal_evac_limit, limit);

            // From now on, we will only allocate below this limit

            // Save the limit in the file

            while (top.size() <= Group::s_evacuation_point_ndx) {

                top.add(0);

            }

            top.set(Group::s_evacuation_point_ndx, RefOrTagged::make_tagged(m_evacuation_limit));

            if (auto logger = m_group.get_logger()) {

                logger->log(util::Logger::Level::detail, "Start compaction with limit %1", m_evacuation_limit);

            }

        }

    }

    // Get final sizes

    size_t top_byte_size = top.get_byte_size();

    ref_type end_ref = top_ref + top_byte_size;

    REALM_ASSERT_3(size_t(end_ref), <=, reserve_pos + max_free_space_needed);

    // Deduct the used space from the reserved chunk. Note that we have made

    // sure that the remaining size is never zero. Also, by the call to

    // m_free_positions.ensure_minimum_width() above, we have made sure that

    // m_free_positions has the capacity to store the new larger value without

    // reallocation.

    size_t rest = reserve_pos + reserve_size - size_t(end_ref);

    size_t used = size_t(end_ref) - reserve_pos;

    REALM_ASSERT_3(rest, >, 0);

    int_fast64_t value_8 = from_ref(end_ref);

    int_fast64_t value_9 = to_int64(rest);

    // value_9 is guaranteed to be smaller than the existing entry in the array and hence will not cause bit

    // expansion

    REALM_ASSERT_3(value_8, <=, Array::ubound_for_width(m_free_positions.get_width()));

    REALM_ASSERT_3(value_9, <=, Array::ubound_for_width(m_free_lengths.get_width()));

    m_free_positions.set(reserve_ndx, value_8); // Throws

    m_free_lengths.set(reserve_ndx, value_9);   // Throws

    m_free_space_size += rest;

    // The free-list now have their final form, so we can write them to the file

    // char* start_addr = m_file_map.get_addr() + reserve_ref;

    if (m_alloc.is_in_memory()) {