faiss 0.2.6 → 0.2.7

data/vendor/faiss/faiss/invlists/DirectMap.h

@@ -15,6 +15,8 @@
 
 namespace faiss {
 
+struct IDSelector;
+
 // When offsets list id + offset are encoded in an uint64
 // we call this LO = list-offset
 
@@ -34,8 +36,6 @@ inline uint64_t lo_offset(uint64_t lo) {
  * Direct map: a way to map back from ids to inverted lists
  */
 struct DirectMap {
-    typedef Index::idx_t idx_t;
-
     enum Type {
         NoMap = 0,    // default
         Array = 1,    // sequential ids (only for add, no add_with_ids)
@@ -91,8 +91,6 @@ struct DirectMap {
 
 /// Thread-safe way of updating the direct_map
 struct DirectMapAdd {
-    typedef Index::idx_t idx_t;
-
     using Type = DirectMap::Type;
 
     DirectMap& direct_map;

data/vendor/faiss/faiss/invlists/InvertedLists.cpp

@@ -10,23 +10,32 @@
 #include <faiss/invlists/InvertedLists.h>
 
 #include <cstdio>
+#include <memory>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/utils.h>
 
 namespace faiss {
 
+InvertedListsIterator::~InvertedListsIterator() {}
+
 /*****************************************
  * InvertedLists implementation
  ******************************************/
 
 InvertedLists::InvertedLists(size_t nlist, size_t code_size)
-        : nlist(nlist), code_size(code_size) {}
+        : nlist(nlist), code_size(code_size), use_iterator(false) {}
 
 InvertedLists::~InvertedLists() {}
 
-InvertedLists::idx_t InvertedLists::get_single_id(size_t list_no, size_t offset)
-        const {
+bool InvertedLists::is_empty(size_t list_no) const {
+    return use_iterator
+            ? !std::unique_ptr<InvertedListsIterator>(get_iterator(list_no))
+                       ->is_available()
+            : list_size(list_no) == 0;
+}
+
+idx_t InvertedLists::get_single_id(size_t list_no, size_t offset) const {
     assert(offset < list_size(list_no));
     const idx_t* ids = get_ids(list_no);
     idx_t id = ids[offset];
@@ -67,6 +76,10 @@ void InvertedLists::reset() {
     }
 }
 
+InvertedListsIterator* InvertedLists::get_iterator(size_t /*list_no*/) const {
+    FAISS_THROW_MSG("get_iterator is not supported");
+}
+
 void InvertedLists::merge_from(InvertedLists* oivf, size_t add_id) {
 #pragma omp parallel for
     for (idx_t i = 0; i < nlist; i++) {
@@ -87,6 +100,98 @@ void InvertedLists::merge_from(InvertedLists* oivf, size_t add_id) {
     }
 }
 
+size_t InvertedLists::copy_subset_to(
+        InvertedLists& oivf,
+        subset_type_t subset_type,
+        idx_t a1,
+        idx_t a2) const {
+    FAISS_THROW_IF_NOT(nlist == oivf.nlist);
+    FAISS_THROW_IF_NOT(code_size == oivf.code_size);
+    FAISS_THROW_IF_NOT_FMT(
+            subset_type >= 0 && subset_type <= 4,
+            "subset type %d not implemented",
+            subset_type);
+    size_t accu_n = 0;
+    size_t accu_a1 = 0;
+    size_t accu_a2 = 0;
+    size_t n_added = 0;
+
+    size_t ntotal = 0;
+    if (subset_type == 2) {
+        ntotal = compute_ntotal();
+    }
+
+    for (idx_t list_no = 0; list_no < nlist; list_no++) {
+        size_t n = list_size(list_no);
+        ScopedIds ids_in(this, list_no);
+
+        if (subset_type == SUBSET_TYPE_ID_RANGE) {
+            for (idx_t i = 0; i < n; i++) {
+                idx_t id = ids_in[i];
+                if (a1 <= id && id < a2) {
+                    oivf.add_entry(
+                            list_no,
+                            get_single_id(list_no, i),
+                            ScopedCodes(this, list_no, i).get());
+                    n_added++;
+                }
+            }
+        } else if (subset_type == SUBSET_TYPE_ID_MOD) {
+            for (idx_t i = 0; i < n; i++) {
+                idx_t id = ids_in[i];
+                if (id % a1 == a2) {
+                    oivf.add_entry(
+                            list_no,
+                            get_single_id(list_no, i),
+                            ScopedCodes(this, list_no, i).get());
+                    n_added++;
+                }
+            }
+        } else if (subset_type == SUBSET_TYPE_ELEMENT_RANGE) {
+            // see what is allocated to a1 and to a2
+            size_t next_accu_n = accu_n + n;
+            size_t next_accu_a1 = next_accu_n * a1 / ntotal;
+            size_t i1 = next_accu_a1 - accu_a1;
+            size_t next_accu_a2 = next_accu_n * a2 / ntotal;
+            size_t i2 = next_accu_a2 - accu_a2;
+
+            for (idx_t i = i1; i < i2; i++) {
+                oivf.add_entry(
+                        list_no,
+                        get_single_id(list_no, i),
+                        ScopedCodes(this, list_no, i).get());
+            }
+
+            n_added += i2 - i1;
+            accu_a1 = next_accu_a1;
+            accu_a2 = next_accu_a2;
+        } else if (subset_type == SUBSET_TYPE_INVLIST_FRACTION) {
+            size_t i1 = n * a2 / a1;
+            size_t i2 = n * (a2 + 1) / a1;
+
+            for (idx_t i = i1; i < i2; i++) {
+                oivf.add_entry(
+                        list_no,
+                        get_single_id(list_no, i),
+                        ScopedCodes(this, list_no, i).get());
+            }
+
+            n_added += i2 - i1;
+        } else if (subset_type == SUBSET_TYPE_INVLIST) {
+            if (list_no >= a1 && list_no < a2) {
+                oivf.add_entries(
+                        list_no,
+                        n,
+                        ScopedIds(this, list_no).get(),
+                        ScopedCodes(this, list_no).get());
+                n_added += n;
+            }
+        }
+        accu_n += n;
+    }
+    return n_added;
+}
+
 double InvertedLists::imbalance_factor() const {
     std::vector<int> hist(nlist);
 
@@ -109,7 +214,9 @@ void InvertedLists::print_stats() const {
     }
     for (size_t i = 0; i < sizes.size(); i++) {
         if (sizes[i]) {
-            printf("list size in < %d: %d instances\n", 1 << i, sizes[i]);
+            printf("list size in < %zu: %d instances\n",
+                   static_cast<size_t>(1) << i,
+                   sizes[i]);
         }
     }
 }
@@ -158,7 +265,7 @@ const uint8_t* ArrayInvertedLists::get_codes(size_t list_no) const {
     return codes[list_no].data();
 }
 
-const InvertedLists::idx_t* ArrayInvertedLists::get_ids(size_t list_no) const {
+const idx_t* ArrayInvertedLists::get_ids(size_t list_no) const {
     assert(list_no < nlist);
     return ids[list_no].data();
 }
@@ -267,7 +374,7 @@ void HStackInvertedLists::release_codes(size_t, const uint8_t* codes) const {
     delete[] codes;
 }
 
-const Index::idx_t* HStackInvertedLists::get_ids(size_t list_no) const {
+const idx_t* HStackInvertedLists::get_ids(size_t list_no) const {
     idx_t *ids = new idx_t[list_size(list_no)], *c = ids;
 
     for (int i = 0; i < ils.size(); i++) {
@@ -281,8 +388,7 @@ const Index::idx_t* HStackInvertedLists::get_ids(size_t list_no) const {
     return ids;
 }
 
-Index::idx_t HStackInvertedLists::get_single_id(size_t list_no, size_t offset)
-        const {
+idx_t HStackInvertedLists::get_single_id(size_t list_no, size_t offset) const {
     for (int i = 0; i < ils.size(); i++) {
         const InvertedLists* il = ils[i];
         size_t sz = il->list_size(list_no);
@@ -312,8 +418,6 @@ void HStackInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
 
 namespace {
 
-using idx_t = InvertedLists::idx_t;
-
 idx_t translate_list_no(const SliceInvertedLists* sil, idx_t list_no) {
     FAISS_THROW_IF_NOT(list_no >= 0 && list_no < sil->nlist);
     return list_no + sil->i0;
@@ -349,12 +453,11 @@ void SliceInvertedLists::release_codes(size_t list_no, const uint8_t* codes)
     return il->release_codes(translate_list_no(this, list_no), codes);
 }
 
-const Index::idx_t* SliceInvertedLists::get_ids(size_t list_no) const {
+const idx_t* SliceInvertedLists::get_ids(size_t list_no) const {
     return il->get_ids(translate_list_no(this, list_no));
 }
 
-Index::idx_t SliceInvertedLists::get_single_id(size_t list_no, size_t offset)
-        const {
+idx_t SliceInvertedLists::get_single_id(size_t list_no, size_t offset) const {
     return il->get_single_id(translate_list_no(this, list_no), offset);
 }
 
@@ -380,8 +483,6 @@ void SliceInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
 
 namespace {
 
-using idx_t = InvertedLists::idx_t;
-
 // find the invlist this number belongs to
 int translate_list_no(const VStackInvertedLists* vil, idx_t list_no) {
     FAISS_THROW_IF_NOT(list_no >= 0 && list_no < vil->nlist);
@@ -449,14 +550,13 @@ void VStackInvertedLists::release_codes(size_t list_no, const uint8_t* codes)
     return ils[i]->release_codes(list_no, codes);
 }
 
-const Index::idx_t* VStackInvertedLists::get_ids(size_t list_no) const {
+const idx_t* VStackInvertedLists::get_ids(size_t list_no) const {
     int i = translate_list_no(this, list_no);
     list_no -= cumsz[i];
     return ils[i]->get_ids(list_no);
 }
 
-Index::idx_t VStackInvertedLists::get_single_id(size_t list_no, size_t offset)
-        const {
+idx_t VStackInvertedLists::get_single_id(size_t list_no, size_t offset) const {
     int i = translate_list_no(this, list_no);
     list_no -= cumsz[i];
     return ils[i]->get_single_id(list_no, offset);

data/vendor/faiss/faiss/invlists/InvertedLists.h

@@ -15,11 +15,18 @@
  * the interface.
  */
 
-#include <faiss/Index.h>
+#include <faiss/MetricType.h>
 #include <vector>
 
 namespace faiss {
 
+struct InvertedListsIterator {
+    virtual ~InvertedListsIterator();
+    virtual bool is_available() const = 0;
+    virtual void next() = 0;
+    virtual std::pair<idx_t, const uint8_t*> get_id_and_codes() = 0;
+};
+
 /** Table of inverted lists
  * multithreading rules:
  * - concurrent read accesses are allowed
@@ -28,13 +35,14 @@ namespace faiss {
  *   are allowed
  */
 struct InvertedLists {
-    typedef Index::idx_t idx_t;
-
     size_t nlist;     ///< number of possible key values
     size_t code_size; ///< code size per vector in bytes
+    bool use_iterator;
 
     InvertedLists(size_t nlist, size_t code_size);
 
+    virtual ~InvertedLists();
+
     /// used for BlockInvertedLists, where the codes are packed into groups
     /// and the individual code size is meaningless
     static const size_t INVALID_CODE_SIZE = static_cast<size_t>(-1);
@@ -42,9 +50,15 @@ struct InvertedLists {
     /*************************
      *  Read only functions */
 
+    // check if the list is empty
+    bool is_empty(size_t list_no) const;
+
     /// get the size of a list
     virtual size_t list_size(size_t list_no) const = 0;
 
+    /// get iterable for lists that use_iterator
+    virtual InvertedListsIterator* get_iterator(size_t list_no) const;
+
     /** get the codes for an inverted list
      * must be released by release_codes
      *
@@ -105,10 +119,36 @@ struct InvertedLists {
 
     virtual void reset();
 
+    /*************************
+     * high level functions  */
+
     /// move all entries from oivf (empty on output)
     void merge_from(InvertedLists* oivf, size_t add_id);
 
-    virtual ~InvertedLists();
+    // how to copy a subset of elements from the inverted lists
+    // This depends on two integers, a1 and a2.
+    enum subset_type_t : int {
+        // depends on IDs
+        SUBSET_TYPE_ID_RANGE = 0, // copies ids in [a1, a2)
+        SUBSET_TYPE_ID_MOD = 1,   // copies ids if id % a1 == a2
+        // depends on order within invlists
+        SUBSET_TYPE_ELEMENT_RANGE =
+                2, // copies fractions of invlists so that a1 elements are left
+                   // before and a2 after
+        SUBSET_TYPE_INVLIST_FRACTION =
+                3, // take fraction a2 out of a1 from each invlist, 0 <= a2 < a1
+        // copy only inverted lists a1:a2
+        SUBSET_TYPE_INVLIST = 4
+    };
+
+    /** copy a subset of the entries index to the other index
+     * @return number of entries copied
+     */
+    size_t copy_subset_to(
+            InvertedLists& other,
+            subset_type_t subset_type,
+            idx_t a1,
+            idx_t a2) const;
 
     /*************************
      * statistics            */

data/vendor/faiss/faiss/invlists/OnDiskInvertedLists.cpp

@@ -154,7 +154,7 @@ struct OnDiskInvertedLists::OngoingPrefetch {
             const OnDiskInvertedLists* od = pf->od;
             od->locks->lock_1(list_no);
             size_t n = od->list_size(list_no);
-            const Index::idx_t* idx = od->get_ids(list_no);
+            const idx_t* idx = od->get_ids(list_no);
             const uint8_t* codes = od->get_codes(list_no);
             int cs = 0;
             for (size_t i = 0; i < n; i++) {
@@ -389,7 +389,7 @@ const uint8_t* OnDiskInvertedLists::get_codes(size_t list_no) const {
     return ptr + lists[list_no].offset;
 }
 
-const Index::idx_t* OnDiskInvertedLists::get_ids(size_t list_no) const {
+const idx_t* OnDiskInvertedLists::get_ids(size_t list_no) const {
     if (lists[list_no].offset == INVALID_OFFSET) {
         return nullptr;
     }
@@ -781,7 +781,7 @@ InvertedLists* OnDiskInvertedListsIOHook::read_ArrayInvertedLists(
         OnDiskInvertedLists::List& l = ails->lists[i];
         l.size = l.capacity = sizes[i];
         l.offset = o;
-        o += l.size * (sizeof(OnDiskInvertedLists::idx_t) + ails->code_size);
+        o += l.size * (sizeof(idx_t) + ails->code_size);
     }
     // resume normal reading of file
     fseek(fdesc, o, SEEK_SET);

data/vendor/faiss/faiss/invlists/OnDiskInvertedLists.h

@@ -31,7 +31,7 @@ struct OnDiskOneList {
 
 /** On-disk storage of inverted lists.
  *
- * The data is stored in a mmapped chunk of memory (base ptointer ptr,
+ * The data is stored in a mmapped chunk of memory (base pointer ptr,
  * size totsize). Each list is a range of memory that contains (object
  * List) that contains:
  *

data/vendor/faiss/faiss/python/python_callbacks.cpp

@@ -118,7 +118,7 @@ PyCallbackIDSelector::PyCallbackIDSelector(PyObject* callback)
     Py_INCREF(callback);
 }
 
-bool PyCallbackIDSelector::is_member(idx_t id) const {
+bool PyCallbackIDSelector::is_member(faiss::idx_t id) const {
     FAISS_THROW_IF_NOT((id >> 32) == 0);
     PyThreadLock gil;
     PyObject* result = PyObject_CallFunction(callback, "(n)", int(id));

data/vendor/faiss/faiss/python/python_callbacks.h

@@ -54,7 +54,7 @@ struct PyCallbackIDSelector : faiss::IDSelector {
 
     explicit PyCallbackIDSelector(PyObject* callback);
 
-    bool is_member(idx_t id) const override;
+    bool is_member(faiss::idx_t id) const override;
 
     ~PyCallbackIDSelector() override;
 };

data/vendor/faiss/faiss/utils/AlignedTable.h

@@ -98,7 +98,9 @@ struct AlignedTableTightAlloc {
     AlignedTableTightAlloc<T, A>& operator=(
             const AlignedTableTightAlloc<T, A>& other) {
         resize(other.numel);
-        memcpy(ptr, other.ptr, sizeof(T) * numel);
+        if (numel > 0) {
+            memcpy(ptr, other.ptr, sizeof(T) * numel);
+        }
         return *this;
     }
 

data/vendor/faiss/faiss/utils/Heap.cpp

@@ -9,6 +9,7 @@
 
 /* Function for soft heap */
 
+#include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/Heap.h>
 
 namespace faiss {
@@ -32,7 +33,7 @@ void HeapArray<C>::addn(size_t nj, const T* vin, TI j0, size_t i0, int64_t ni) {
     if (ni == -1)
         ni = nh;
     assert(i0 >= 0 && i0 + ni <= nh);
-#pragma omp parallel for
+#pragma omp parallel for if (ni * nj > 100000)
     for (int64_t i = i0; i < i0 + ni; i++) {
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
@@ -62,7 +63,7 @@ void HeapArray<C>::addn_with_ids(
     if (ni == -1)
         ni = nh;
     assert(i0 >= 0 && i0 + ni <= nh);
-#pragma omp parallel for
+#pragma omp parallel for if (ni * nj > 100000)
     for (int64_t i = i0; i < i0 + ni; i++) {
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
@@ -78,9 +79,38 @@ void HeapArray<C>::addn_with_ids(
     }
 }
 
+template <typename C>
+void HeapArray<C>::addn_query_subset_with_ids(
+        size_t nsubset,
+        const TI* subset,
+        size_t nj,
+        const T* vin,
+        const TI* id_in,
+        int64_t id_stride) {
+    FAISS_THROW_IF_NOT_MSG(id_in, "anonymous ids not supported");
+    if (id_stride < 0) {
+        id_stride = nj;
+    }
+#pragma omp parallel for if (nsubset * nj > 100000)
+    for (int64_t si = 0; si < nsubset; si++) {
+        T i = subset[si];
+        T* __restrict simi = get_val(i);
+        TI* __restrict idxi = get_ids(i);
+        const T* ip_line = vin + si * nj;
+        const TI* id_line = id_in + si * id_stride;
+
+        for (size_t j = 0; j < nj; j++) {
+            T ip = ip_line[j];
+            if (C::cmp(simi[0], ip)) {
+                heap_replace_top<C>(k, simi, idxi, ip, id_line[j]);
+            }
+        }
+    }
+}
+
 template <typename C>
 void HeapArray<C>::per_line_extrema(T* out_val, TI* out_ids) const {
-#pragma omp parallel for
+#pragma omp parallel for if (nh * k > 100000)
     for (int64_t j = 0; j < nh; j++) {
         int64_t imin = -1;
         typename C::T xval = C::Crev::neutral();
@@ -109,4 +139,110 @@ template struct HeapArray<CMax<float, int64_t>>;
 template struct HeapArray<CMin<int, int64_t>>;
 template struct HeapArray<CMax<int, int64_t>>;
 
+/**********************************************************
+ * merge knn search results
+ **********************************************************/
+
+/** Merge result tables from several shards. The per-shard results are assumed
+ * to be sorted. Note that the C comparator is reversed w.r.t. the usual top-k
+ * element heap because we want the best (ie. lowest for L2) result to be on
+ * top, not the worst.
+ *
+ * @param all_distances  size (nshard, n, k)
+ * @param all_labels     size (nshard, n, k)
+ * @param distances      output distances, size (n, k)
+ * @param labels         output labels, size (n, k)
+ */
+template <class idx_t, class C>
+void merge_knn_results(
+        size_t n,
+        size_t k,
+        typename C::TI nshard,
+        const typename C::T* all_distances,
+        const idx_t* all_labels,
+        typename C::T* distances,
+        idx_t* labels) {
+    using distance_t = typename C::T;
+    if (k == 0) {
+        return;
+    }
+    long stride = n * k;
+#pragma omp parallel if (n * nshard * k > 100000)
+    {
+        std::vector<int> buf(2 * nshard);
+        // index in each shard's result list
+        int* pointer = buf.data();
+        // (shard_ids, heap_vals): heap that indexes
+        // shard -> current distance for this shard
+        int* shard_ids = pointer + nshard;
+        std::vector<distance_t> buf2(nshard);
+        distance_t* heap_vals = buf2.data();
+#pragma omp for
+        for (long i = 0; i < n; i++) {
+            // the heap maps values to the shard where they are
+            // produced.
+            const distance_t* D_in = all_distances + i * k;
+            const idx_t* I_in = all_labels + i * k;
+            int heap_size = 0;
+
+            // push the first element of each shard (if not -1)
+            for (long s = 0; s < nshard; s++) {
+                pointer[s] = 0;
+                if (I_in[stride * s] >= 0) {
+                    heap_push<C>(
+                            ++heap_size,
+                            heap_vals,
+                            shard_ids,
+                            D_in[stride * s],
+                            s);
+                }
+            }
+
+            distance_t* D = distances + i * k;
+            idx_t* I = labels + i * k;
+
+            int j;
+            for (j = 0; j < k && heap_size > 0; j++) {
+                // pop element from best shard
+                int s = shard_ids[0]; // top of heap
+                int& p = pointer[s];
+                D[j] = heap_vals[0];
+                I[j] = I_in[stride * s + p];
+
+                // pop from shard, advance pointer for this shard
+                heap_pop<C>(heap_size--, heap_vals, shard_ids);
+                p++;
+                if (p < k && I_in[stride * s + p] >= 0) {
+                    heap_push<C>(
+                            ++heap_size,
+                            heap_vals,
+                            shard_ids,
+                            D_in[stride * s + p],
+                            s);
+                }
+            }
+            for (; j < k; j++) {
+                I[j] = -1;
+                D[j] = C::Crev::neutral();
+            }
+        }
+    }
+}
+
+// explicit instanciations
+#define INSTANTIATE(C, distance_t)                                \
+    template void merge_knn_results<int64_t, C<distance_t, int>>( \
+            size_t,                                               \
+            size_t,                                               \
+            int,                                                  \
+            const distance_t*,                                    \
+            const int64_t*,                                       \
+            distance_t*,                                          \
+            int64_t*);
+
+INSTANTIATE(CMin, float);
+INSTANTIATE(CMax, float);
+INSTANTIATE(CMin, int32_t);
+INSTANTIATE(CMax, int32_t);
+
 } // namespace faiss

data/vendor/faiss/faiss/utils/Heap.h

@@ -413,6 +413,19 @@ struct HeapArray {
             size_t i0 = 0,
             int64_t ni = -1);
 
+    /** same as addn_with_ids, but for just a subset of queries
+     *
+     * @param nsubset  number of query entries to update
+     * @param subset   indexes of queries to update, in 0..nh-1, size nsubset
+     */
+    void addn_query_subset_with_ids(
+            size_t nsubset,
+            const TI* subset,
+            size_t nj,
+            const T* vin,
+            const TI* id_in = nullptr,
+            int64_t id_stride = 0);
+
     /// reorder all the heaps
     void reorder();
 
@@ -431,7 +444,7 @@ typedef HeapArray<CMin<int, int64_t>> int_minheap_array_t;
 typedef HeapArray<CMax<float, int64_t>> float_maxheap_array_t;
 typedef HeapArray<CMax<int, int64_t>> int_maxheap_array_t;
 
-// The heap templates are instanciated explicitly in Heap.cpp
+// The heap templates are instantiated explicitly in Heap.cpp
 
 /*********************************************************************
  * Indirect heaps: instead of having
@@ -492,6 +505,27 @@ inline void indirect_heap_push(
     bh_ids[i] = id;
 }
 
+/** Merge result tables from several shards. The per-shard results are assumed
+ * to be sorted. Note that the C comparator is reversed w.r.t. the usual top-k
+ * element heap because we want the best (ie. lowest for L2) result to be on
+ * top, not the worst. Also, it needs to hold an index of a shard id (ie.
+ * usually int32 is more than enough).
+ *
+ * @param all_distances  size (nshard, n, k)
+ * @param all_labels     size (nshard, n, k)
+ * @param distances      output distances, size (n, k)
+ * @param labels         output labels, size (n, k)
+ */
+template <class idx_t, class C>
+void merge_knn_results(
+        size_t n,
+        size_t k,
+        typename C::TI nshard,
+        const typename C::T* all_distances,
+        const idx_t* all_labels,
+        typename C::T* distances,
+        idx_t* labels);
+
 } // namespace faiss
 
 #endif /* FAISS_Heap_h */