RCORE-2055 Array Classification for enabling compression (#7564)

* update next-major

* specified part of new layout (new width encoding)

* new header format for compressed arrays

* code review

* code review

* start of classifying arrays for compression

* classification down to column types

* first attempt to cut through the BPlusTree madness

* [wip] start on 'type driven' write process

* all tests passing (but no compression enabled)

* enabled compression for signed integer leafs only

* removed some dubious constructions in cluster tree

* delete tmp array while classifying arrays

* enabled compression of links and backlinks (excl collections)

* also compress bplustree of integers/links (experimental)

* pref for compressing dicts (not working)

* wip

* wip

* finally: compressing collections (incl dicts)

* compressing timestamps now

* enabled compression on ObjectID, TypedLink and UUID

* also compressing Mixed properties (not list/dicts of Mixed)

* Array compression with collections in Mixed (#7412)

---------

Co-authored-by: Finn Schiermer Andersen <[email protected]>

* merge next-major + collection in mixed

* enable dynamic choice of compression method

* moved typed_write/typed_print for bptree into class

* Merge pull request #7432 from realm/fsa/clean_typed_write

moved typed_write/typed_print for bptree into class

* cleanup unrelated code changes

* fix compilation

* cleanup

* code review

* code review

* swap byte 3&4 with byte 6&7 for flex formats for storing A and B sizes

* Some modifications

* Move Encoding definition

* Testing

* Perserve type information in typed_write (#7598)

* call directly Array::destroy()

* Fix issue

* remove table from typed_print

* lint

* point fix avoid compressing history array

---------

Co-authored-by: Finn Schiermer Andersen <[email protected]>
Co-authored-by: Jørgen Edelbo <[email protected]>
Co-authored-by: Finn Schiermer Andersen <[email protected]>

Author: 3 people

src/realm/array.cpp

@@ -209,7 +209,6 @@ size_t Array::bit_width(int64_t v)
     return uint64_t(v) >> 31 ? 64 : uint64_t(v) >> 15 ? 32 : uint64_t(v) >> 7 ? 16 : 8;
 }
 
-
 void Array::init_from_mem(MemRef mem) noexcept
 {
     char* header = Node::init_from_mem(mem);
@@ -289,7 +288,7 @@ ref_type Array::do_write_shallow(_impl::ArrayWriterBase& out) const
 }
 
 
-ref_type Array::do_write_deep(_impl::ArrayWriterBase& out, bool only_if_modified) const
+ref_type Array::do_write_deep(_impl::ArrayWriterBase& out, bool only_if_modified, bool compress) const
 {
     // Temp array for updated refs
     Array new_array(Allocator::get_default());
@@ -304,7 +303,7 @@ ref_type Array::do_write_deep(_impl::ArrayWriterBase& out, bool only_if_modified
         bool is_ref = (value != 0 && (value & 1) == 0);
         if (is_ref) {
             ref_type subref = to_ref(value);
-            ref_type new_subref = write(subref, m_alloc, out, only_if_modified); // Throws
+            ref_type new_subref = write(subref, m_alloc, out, only_if_modified, compress); // Throws
             value = from_ref(new_subref);
         }
         new_array.add(value); // Throws
@@ -1334,3 +1333,46 @@ bool QueryStateFindAll<IntegerColumn>::match(size_t index) noexcept
 
     return (m_limit > m_match_count);
 }
+
+void Array::typed_print(std::string prefix) const
+{
+    std::cout << "Generic Array " << header_to_string(get_header()) << " @ " << m_ref;
+    if (!is_attached()) {
+        std::cout << " Unattached";
+        return;
+    }
+    if (size() == 0) {
+        std::cout << " Empty" << std::endl;
+        return;
+    }
+    std::cout << " size = " << size() << " {";
+    if (has_refs()) {
+        std::cout << std::endl;
+        for (unsigned n = 0; n < size(); ++n) {
+            auto pref = prefix + "  " + to_string(n) + ":\t";
+            RefOrTagged rot = get_as_ref_or_tagged(n);
+            if (rot.is_ref() && rot.get_as_ref()) {
+                Array a(m_alloc);
+                a.init_from_ref(rot.get_as_ref());
+                std::cout << pref;
+                a.typed_print(pref);
+            }
+            else if (rot.is_tagged()) {
+                std::cout << pref << rot.get_as_int() << std::endl;
+            }
+        }
+        std::cout << prefix << "}" << std::endl;
+    }
+    else {
+        std::cout << " Leaf of unknown type }" << std::endl;
+    }
+}
+
+ref_type ArrayPayload::typed_write(ref_type ref, _impl::ArrayWriterBase& out, Allocator& alloc)
+{
+    Array arr(alloc);
+    arr.init_from_ref(ref);
+    // By default we are not compressing
+    constexpr bool compress = false;
+    return arr.write(out, true, out.only_modified, compress);
+}

src/realm/array.hpp

@@ -379,11 +379,12 @@ class Array : public Node, public ArrayParent {
     ///
     /// \param only_if_modified Set to `false` to always write, or to `true` to
     /// only write the array if it has been modified.
-    ref_type write(_impl::ArrayWriterBase& out, bool deep, bool only_if_modified) const;
+    ref_type write(_impl::ArrayWriterBase& out, bool deep, bool only_if_modified, bool compress_in_flight) const;
 
     /// Same as non-static write() with `deep` set to true. This is for the
     /// cases where you do not already have an array accessor available.
-    static ref_type write(ref_type, Allocator&, _impl::ArrayWriterBase&, bool only_if_modified);
+    static ref_type write(ref_type, Allocator&, _impl::ArrayWriterBase&, bool only_if_modified,
+                          bool compress_in_flight);
 
     size_t find_first(int64_t value, size_t begin = 0, size_t end = size_t(-1)) const;
 
@@ -459,6 +460,13 @@ class Array : public Node, public ArrayParent {
     Array& operator=(const Array&) = delete; // not allowed
     Array(const Array&) = delete;            // not allowed
 
+    /// Takes a 64-bit value and returns the minimum number of bits needed
+    /// to fit the value. For alignment this is rounded up to nearest
+    /// log2. Possible results {0, 1, 2, 4, 8, 16, 32, 64}
+    static size_t bit_width(int64_t value);
+
+    void typed_print(std::string prefix) const;
+
 protected:
     // This returns the minimum value ("lower bound") of the representable values
     // for the given bit width. Valid widths are 0, 1, 2, 4, 8, 16, 32, and 64.
@@ -518,12 +526,6 @@ class Array : public Node, public ArrayParent {
     template <size_t w>
     int64_t get_universal(const char* const data, const size_t ndx) const;
 
-protected:
-    /// Takes a 64-bit value and returns the minimum number of bits needed
-    /// to fit the value. For alignment this is rounded up to nearest
-    /// log2. Posssible results {0, 1, 2, 4, 8, 16, 32, 64}
-    static size_t bit_width(int64_t value);
-
 protected:
     Getter m_getter = nullptr; // cached to avoid indirection
     const VTable* m_vtable = nullptr;
@@ -538,7 +540,7 @@ class Array : public Node, public ArrayParent {
 
 private:
     ref_type do_write_shallow(_impl::ArrayWriterBase&) const;
-    ref_type do_write_deep(_impl::ArrayWriterBase&, bool only_if_modified) const;
+    ref_type do_write_deep(_impl::ArrayWriterBase&, bool only_if_modified, bool compress) const;
 
     void _mem_usage(size_t& mem) const noexcept;
 
@@ -552,6 +554,23 @@ class Array : public Node, public ArrayParent {
     friend class ArrayWithFind;
 };
 
+class TempArray : public Array {
+public:
+    TempArray(size_t sz, Type type = Type::type_HasRefs)
+        : Array(Allocator::get_default())
+    {
+        create(type, false, sz);
+    }
+    ~TempArray()
+    {
+        destroy();
+    }
+    ref_type write(_impl::ArrayWriterBase& out)
+    {
+        return Array::write(out, false, false, false);
+    }
+};
+
 // Implementation:
 
 
@@ -829,7 +848,7 @@ inline void Array::destroy_deep() noexcept
     m_data = nullptr;
 }
 
-inline ref_type Array::write(_impl::ArrayWriterBase& out, bool deep, bool only_if_modified) const
+inline ref_type Array::write(_impl::ArrayWriterBase& out, bool deep, bool only_if_modified, bool compress) const
 {
     REALM_ASSERT(is_attached());
 
@@ -839,10 +858,11 @@ inline ref_type Array::write(_impl::ArrayWriterBase& out, bool deep, bool only_i
     if (!deep || !m_has_refs)
         return do_write_shallow(out); // Throws
 
-    return do_write_deep(out, only_if_modified); // Throws
+    return do_write_deep(out, only_if_modified, compress); // Throws
 }
 
-inline ref_type Array::write(ref_type ref, Allocator& alloc, _impl::ArrayWriterBase& out, bool only_if_modified)
+inline ref_type Array::write(ref_type ref, Allocator& alloc, _impl::ArrayWriterBase& out, bool only_if_modified,
+                             bool compress)
 {
     if (only_if_modified && alloc.is_read_only(ref))
         return ref;
@@ -853,7 +873,7 @@ inline ref_type Array::write(ref_type ref, Allocator& alloc, _impl::ArrayWriterB
     if (!array.m_has_refs)
         return array.do_write_shallow(out); // Throws
 
-    return array.do_write_deep(out, only_if_modified); // Throws
+    return array.do_write_deep(out, only_if_modified, compress); // Throws
 }
 
 inline void Array::add(int_fast64_t value)

src/realm/array_integer.hpp

@@ -70,6 +70,14 @@ class ArrayInteger : public Array, public ArrayPayload {
     }
     template <class cond>
     bool find(value_type value, size_t start, size_t end, QueryStateBase* state) const;
+
+    template <class T>
+    static ref_type typed_write(ref_type ref, T& out, Allocator& alloc)
+    {
+        Array arr(alloc);
+        arr.init_from_ref(ref);
+        return arr.write(out, false, out.only_modified, out.compress);
+    }
 };
 
 class ArrayIntNull : public Array, public ArrayPayload {
@@ -139,6 +147,14 @@ class ArrayIntNull : public Array, public ArrayPayload {
 
     size_t find_first(value_type value, size_t begin = 0, size_t end = npos) const;
 
+    template <class T>
+    static ref_type typed_write(ref_type ref, T& out, Allocator& alloc)
+    {
+        Array arr(alloc);
+        arr.init_from_ref(ref);
+        return arr.write(out, false, out.only_modified, out.compress);
+    }
+
 protected:
     void avoid_null_collision(int64_t value);
 

src/realm/array_mixed.cpp

@@ -18,6 +18,8 @@
 
 #include <realm/array_mixed.hpp>
 #include <realm/array_basic.hpp>
+#include <realm/dictionary.hpp>
+#include <realm/impl/array_writer.hpp>
 
 using namespace realm;
 
@@ -328,6 +330,89 @@ void ArrayMixed::verify() const
     // TODO: Implement
 }
 
+ref_type ArrayMixed::typed_write(ref_type top_ref, _impl::ArrayWriterBase& out, Allocator& alloc)
+{
+    if (out.only_modified && alloc.is_read_only(top_ref))
+        return top_ref;
+
+    ArrayRef top(alloc);
+    top.init_from_ref(top_ref);
+    size_t sz = top.size();
+    TempArray written_leaf(sz);
+
+    /*
+     Mixed stores things using different arrays. We need to take into account this in order to
+     understand what we need to compress and what we can instead leave not compressed.
+
+     The main subarrays are:
+
+     composite array : index 0
+     int array : index 1
+     pair_int array: index 2
+     string array: index 3
+     ref array: index 4
+     key array: index 5
+
+     Description of each array:
+     1. composite array: the data stored here is either a small int (< 32 bits) or an offset to one of
+        the other arrays where the actual data is.
+     2. int and pair int arrays, they are used for storing integers, timestamps, floats, doubles,
+     decimals, links. In general we can compress them, but we need to be careful, controlling the col_type
+     should prevent compressing data that we want to leave in the current format.
+     3. string array is for strings and binary data (no compression for now)
+     4. ref array is actually storing refs to collections. they can only be BPlusTree<int, Mixed> or
+     BPlusTree<string, Mixed>.
+     5. key array stores unique identifiers for collections in mixed (integers that can be compressed)
+     */
+    Array composite(alloc);
+    composite.init_from_ref(top.get_as_ref(0));
+    written_leaf.set_as_ref(0, composite.write(out, true, out.only_modified, false));
+    for (size_t i = 1; i < sz; ++i) {
+        auto ref = top.get(i);
+        ref_type new_ref = ref;
+        if (ref && !(out.only_modified && alloc.is_read_only(ref))) {
+            if (i < 3) { // int, and pair_int
+                // integer arrays
+                new_ref = Array::write(ref, alloc, out, out.only_modified, out.compress);
+            }
+            else if (i == 4) { // collection in mixed
+                ArrayRef arr_ref(alloc);
+                arr_ref.init_from_ref(ref);
+                auto ref_sz = arr_ref.size();
+                TempArray written_ref_leaf(ref_sz);
+
+                for (size_t k = 0; k < ref_sz; k++) {
+                    ref_type new_sub_ref = 0;
+                    if (auto sub_ref = arr_ref.get(k)) {
+                        auto header = alloc.translate(sub_ref);
+                        // Now we have to find out if the nested collection is a
+                        // dictionary or a list. If the top array has a size of 2
+                        // and it is not a BplusTree inner node, then it is a dictionary
+                        if (NodeHeader::get_size_from_header(header) == 2 &&
+                            !NodeHeader::get_is_inner_bptree_node_from_header(header)) {
+                            new_sub_ref = Dictionary::typed_write(sub_ref, out, alloc);
+                        }
+                        else {
+                            new_sub_ref = BPlusTree<Mixed>::typed_write(sub_ref, out, alloc);
+                        }
+                    }
+                    written_ref_leaf.set_as_ref(k, new_sub_ref);
+                }
+                new_ref = written_ref_leaf.write(out);
+            }
+            else if (i == 5) { // unique keys associated to collections in mixed
+                new_ref = Array::write(ref, alloc, out, out.only_modified, out.compress);
+            }
+            else {
+                // all the rest we don't want to compress it, at least for now (strings will be needed)
+                new_ref = Array::write(ref, alloc, out, out.only_modified, false);
+            }
+        }
+        written_leaf.set(i, new_ref);
+    }
+    return written_leaf.write(out);
+}
+
 void ArrayMixed::ensure_array_accessor(Array& arr, size_t ndx_in_parent) const
 {
     if (!arr.is_attached()) {

src/realm/array_mixed.hpp

@@ -100,6 +100,7 @@ class ArrayMixed : public ArrayPayload, private Array {
     int64_t get_key(size_t ndx) const;
 
     void verify() const;
+    static ref_type typed_write(ref_type ref, _impl::ArrayWriterBase& outs, Allocator& alloc);
 
 private:
     enum {

src/realm/array_timestamp.cpp

@@ -18,6 +18,7 @@
 
 #include <realm/array_timestamp.hpp>
 #include <realm/array_integer_tpl.hpp>
+#include <realm/impl/array_writer.hpp>
 
 using namespace realm;
 
@@ -244,4 +245,25 @@ void ArrayTimestamp::verify() const
     REALM_ASSERT(m_seconds.size() == m_nanoseconds.size());
 #endif
 }
+
+ref_type ArrayTimestamp::typed_write(ref_type ref, _impl::ArrayWriterBase& out, Allocator& alloc)
+{
+    // timestamps could be compressed, but the formats we support at the moment are not producing
+    // noticeable gains.
+    Array top(alloc);
+    top.init_from_ref(ref);
+    REALM_ASSERT_DEBUG(top.size() == 2);
+
+    TempArray written_top(2);
+
+    auto rot0 = top.get_as_ref_or_tagged(0);
+    auto rot1 = top.get_as_ref_or_tagged(1);
+    REALM_ASSERT_DEBUG(rot0.is_ref() && rot0.get_as_ref());
+    REALM_ASSERT_DEBUG(rot1.is_ref() && rot1.get_as_ref());
+    written_top.set_as_ref(0, Array::write(rot0.get_as_ref(), alloc, out, out.only_modified, false));
+    written_top.set_as_ref(1, Array::write(rot1.get_as_ref(), alloc, out, out.only_modified, false));
+
+    return written_top.write(out);
+}
+
 } // namespace realm

src/realm/array_timestamp.hpp

@@ -108,6 +108,7 @@ class ArrayTimestamp : public ArrayPayload, private Array {
     size_t find_first(Timestamp value, size_t begin, size_t end) const noexcept;
 
     void verify() const;
+    static ref_type typed_write(ref_type ref, _impl::ArrayWriterBase& out, Allocator& alloc);
 
 private:
     ArrayIntNull m_seconds;