faiss 0.5.0 → 0.5.1

data/vendor/faiss/faiss/impl/svs_io.h

@@ -0,0 +1,67 @@
+/*
+ * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/*
+ * Portions Copyright 2025 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <streambuf>
+#include <vector>
+
+#include <faiss/impl/io.h>
+
+namespace faiss {
+namespace svs_io {
+
+// Bridges IOWriter to std::ostream for streaming serialization.
+// No buffering concerns since consumer is expected to write everything
+// he receives.
+struct WriterStreambuf : std::streambuf {
+    IOWriter* w;
+    explicit WriterStreambuf(IOWriter* w_);
+    ~WriterStreambuf() override;
+
+   protected:
+    std::streamsize xsputn(const char* s, std::streamsize n) override;
+    int overflow(int ch) override;
+};
+
+// Bridges IOReader to std::istream for streaming deserialization.
+// Uses minimal buffering (single byte) to avoid over-reading from IOReader,
+// which would advance its position beyond what the stream consumer actually
+// read. This ensures subsequent direct reads from IOReader continue at the
+// correct position. Bulk reads via xsgetn() forward directly to IOReader
+// without intermediate buffering.
+struct ReaderStreambuf : std::streambuf {
+    IOReader* r;
+    char single_char_buffer; // Single-byte buffer for underflow() operations
+
+    explicit ReaderStreambuf(IOReader* rr);
+    ~ReaderStreambuf() override;
+
+   protected:
+    int_type underflow() override;
+    std::streamsize xsgetn(char* s, std::streamsize n) override;
+};
+
+} // namespace svs_io
+} // namespace faiss

data/vendor/faiss/faiss/index_factory.cpp

@@ -52,6 +52,13 @@
 #include <faiss/IndexBinaryHNSW.h>
 #include <faiss/IndexBinaryHash.h>
 #include <faiss/IndexBinaryIVF.h>
+
+#ifdef FAISS_ENABLE_SVS
+#include <faiss/svs/IndexSVSFlat.h>
+#include <faiss/svs/IndexSVSVamana.h>
+#include <faiss/svs/IndexSVSVamanaLVQ.h>
+#include <faiss/svs/IndexSVSVamanaLeanVec.h>
+#endif
 #include <faiss/IndexIDMap.h>
 #include <algorithm>
 #include <cctype>
@@ -193,8 +200,6 @@ std::vector<size_t> aq_parse_nbits(std::string stok) {
     return nbits;
 }
 
-const std::string rabitq_pattern = "(RaBitQ)";
-
 /***************************************************************
  * Parse VectorTransform
  */
@@ -457,12 +462,21 @@ IndexIVF* parse_IndexIVF(
         }
         return index_ivf;
     }
-    if (match(rabitq_pattern)) {
-        return new IndexIVFRaBitQ(get_q(), d, nlist, mt, own_il);
-    }
-    if (match("RaBitQfs(_[0-9]+)?")) {
-        int bbs = mres_to_int(sm[1], 32, 1);
-        return new IndexIVFRaBitQFastScan(get_q(), d, nlist, mt, bbs, own_il);
+    // IndexIVFRaBitQ with optional nb_bits (1-9)
+    // Accepts: "RaBitQ" (default 1-bit) or "RaBitQ{nb_bits}" (e.g., "RaBitQ4")
+    if (match("RaBitQ([1-9])?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        return new IndexIVFRaBitQ(get_q(), d, nlist, mt, own_il, nb_bits);
+    }
+    // Accepts: "RaBitQfs" (default 1-bit, batch size 32)
+    //          "RaBitQfs{nb_bits}" (e.g., "RaBitQfs4")
+    //          "RaBitQfs_64" (1-bit, batch size 64)
+    //          "RaBitQfs{nb_bits}_{bbs}" (e.g., "RaBitQfs4_64")
+    if (match("RaBitQfs([1-9])?(_[0-9]+)?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        int bbs = mres_to_int(sm[2], 32, 1);
+        return new IndexIVFRaBitQFastScan(
+                get_q(), d, nlist, mt, bbs, own_il, nb_bits);
     }
     return nullptr;
 }
@@ -485,6 +499,11 @@ IndexHNSW* parse_IndexHNSW(
         return new IndexHNSWFlat(d, hnsw_M, mt);
     }
 
+    if (match("FlatPanorama([0-9]+)?")) {
+        int nlevels = mres_to_int(sm[1], 8); // default to 8 levels
+        return new IndexHNSWFlatPanorama(d, hnsw_M, nlevels, mt);
+    }
+
     if (match("PQ([0-9]+)(x[0-9]+)?(np)?")) {
         int M = std::stoi(sm[1].str());
         int nbit = mres_to_int(sm[2], 8, 1);
@@ -551,6 +570,109 @@ IndexNSG* parse_IndexNSG(
     return nullptr;
 }
 
+#ifdef FAISS_ENABLE_SVS
+/***************************************************************
+ * Parse IndexSVS
+ */
+
+SVSStorageKind parse_lvq(const std::string& lvq_string) {
+    if (lvq_string == "LVQ4x0") {
+        return SVSStorageKind::SVS_LVQ4x0;
+    }
+    if (lvq_string == "LVQ4x4") {
+        return SVSStorageKind::SVS_LVQ4x4;
+    }
+    if (lvq_string == "LVQ4x8") {
+        return SVSStorageKind::SVS_LVQ4x8;
+    }
+    FAISS_ASSERT(!"not supported SVS LVQ level");
+}
+
+SVSStorageKind parse_leanvec(const std::string& leanvec_string) {
+    if (leanvec_string == "LeanVec4x4") {
+        return SVSStorageKind::SVS_LeanVec4x4;
+    }
+    if (leanvec_string == "LeanVec4x8") {
+        return SVSStorageKind::SVS_LeanVec4x8;
+    }
+    if (leanvec_string == "LeanVec8x8") {
+        return SVSStorageKind::SVS_LeanVec8x8;
+    }
+    FAISS_ASSERT(!"not supported SVS Leanvec level");
+}
+
+Index* parse_svs_datatype(
+        const std::string& index_type,
+        const std::string& arg_string,
+        const std::string& datatype_string,
+        int d,
+        MetricType mt) {
+    std::smatch sm;
+
+    if (datatype_string.empty()) {
+        if (index_type == "Vamana")
+            return new IndexSVSVamana(d, std::stoul(arg_string), mt);
+        if (index_type == "Flat")
+            return new IndexSVSFlat(d, mt);
+        FAISS_ASSERT(!"Unspported SVS index type");
+    }
+    if (re_match(datatype_string, "FP16", sm)) {
+        if (index_type == "Vamana")
+            return new IndexSVSVamana(
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_FP16);
+        FAISS_ASSERT(!"Unspported SVS index type for Float16");
+    }
+    if (re_match(datatype_string, "SQI8", sm)) {
+        if (index_type == "Vamana")
+            return new IndexSVSVamana(
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
+        FAISS_ASSERT(!"Unspported SVS index type for SQI8");
+    }
+    if (re_match(datatype_string, "(LVQ[0-9]+x[0-9]+)", sm)) {
+        if (index_type == "Vamana")
+            return new IndexSVSVamanaLVQ(
+                    d, std::stoul(arg_string), mt, parse_lvq(sm[0].str()));
+        FAISS_ASSERT(!"Unspported SVS index type for LVQ");
+    }
+    if (re_match(datatype_string, "(LeanVec[0-9]+x[0-9]+)(_[0-9]+)?", sm)) {
+        std::string leanvec_d_string =
+                sm[2].length() > 0 ? sm[2].str().substr(1) : "0";
+        int leanvec_d = std::stoul(leanvec_d_string);
+
+        if (index_type == "Vamana")
+            return new IndexSVSVamanaLeanVec(
+                    d,
+                    std::stoul(arg_string),
+                    mt,
+                    leanvec_d,
+                    parse_leanvec(sm[1].str()));
+        FAISS_ASSERT(!"Unspported SVS index type for LeanVec");
+    }
+    return nullptr;
+}
+
+Index* parse_IndexSVS(const std::string& code_string, int d, MetricType mt) {
+    std::smatch sm;
+    if (re_match(code_string, "Flat(,.+)?", sm)) {
+        std::string datatype_string =
+                sm[1].length() > 0 ? sm[1].str().substr(1) : "";
+        return parse_svs_datatype("Flat", "", datatype_string, d, mt);
+    }
+    if (re_match(code_string, "Vamana([0-9]+)(,.+)?", sm)) {
+        Index* index{nullptr};
+        std::string degree_string = sm[1].str();
+        std::string datatype_string =
+                sm[2].length() > 0 ? sm[2].str().substr(1) : "";
+        return parse_svs_datatype(
+                "Vamana", degree_string, datatype_string, d, mt);
+    }
+    if (re_match(code_string, "IVF([0-9]+)(,.+)?", sm)) {
+        FAISS_ASSERT(!"Unspported SVS index type");
+    }
+    return nullptr;
+}
+#endif // FAISS_ENABLE_SVS
+
 /***************************************************************
  * Parse basic indexes
  */
@@ -569,6 +691,18 @@ Index* parse_other_indexes(
         return new IndexFlat(d, metric);
     }
 
+    // IndexFlatL2Panorama
+    if (match("FlatL2Panorama([0-9]+)(_[0-9]+)?")) {
+        FAISS_THROW_IF_NOT(metric == METRIC_L2);
+        int nlevels = std::stoi(sm[1].str());
+        if (sm[2].length() > 0) {
+            int batch_size = std::stoi(sm[2].str().substr(1));
+            return new IndexFlatL2Panorama(d, nlevels, (size_t)batch_size);
+        } else {
+            return new IndexFlatL2Panorama(d, nlevels);
+        }
+    }
+
     // IndexLSH
     if (match("LSH([0-9]*)(r?)(t?)")) {
         int nbits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : d;
@@ -685,15 +819,17 @@ Index* parse_other_indexes(
         }
     }
 
-    // IndexRaBitQ
-    if (match(rabitq_pattern)) {
-        return new IndexRaBitQ(d, metric);
+    // IndexRaBitQ with optional nb_bits (1-9)
+    // Accepts: "RaBitQ" (default 1-bit) or "RaBitQ{nb_bits}" (e.g., "RaBitQ4")
+    if (match("RaBitQ([1-9])?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        return new IndexRaBitQ(d, metric, nb_bits);
     }
 
-    // IndexRaBitQFastScan
-    if (match("RaBitQfs(_[0-9]+)?")) {
-        int bbs = mres_to_int(sm[1], 32, 1);
-        return new IndexRaBitQFastScan(d, metric, bbs);
+    if (match("RaBitQfs([1-9])?(_[0-9]+)?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        int bbs = mres_to_int(sm[2], 32, 1);
+        return new IndexRaBitQFastScan(d, metric, bbs, nb_bits);
     }
 
     return nullptr;
@@ -736,6 +872,18 @@ std::unique_ptr<Index> index_factory_sub(
         return std::unique_ptr<Index>(idmap);
     }
 
+    // handle refine Panorama
+    // TODO(aknayar): Add tests to test_factory.py
+    if (re_match(description, "(.+),RefinePanorama\\((.+)\\)", sm)) {
+        std::unique_ptr<Index> filter_index =
+                index_factory_sub(d, sm[1].str(), metric);
+        std::unique_ptr<Index> refine_index =
+                index_factory_sub(d, sm[2].str(), metric);
+        auto* index_rf = new IndexRefinePanorama(
+                filter_index.release(), refine_index.release());
+        return std::unique_ptr<Index>(index_rf);
+    }
+
     // handle refines
     if (re_match(description, "(.+),RFlat", sm) ||
         re_match(description, "(.+),Refine\\((.+)\\)", sm)) {
@@ -842,6 +990,25 @@ std::unique_ptr<Index> index_factory_sub(
         return std::unique_ptr<Index>(index);
     }
 
+#ifdef FAISS_ENABLE_SVS
+    if (re_match(description, "SVS((?:Flat|Vamana|IVF).*)", sm)) {
+        std::string code_string = sm[1].str();
+        if (verbose) {
+            printf("parsing SVS string %s code_string=%s",
+                   description.c_str(),
+                   code_string.c_str());
+        }
+
+        Index* index = parse_IndexSVS(code_string, d, metric);
+        FAISS_THROW_IF_NOT_FMT(
+                index,
+                "could not parse SVS code description %s in %s",
+                code_string.c_str(),
+                description.c_str());
+        return std::unique_ptr<Index>(index);
+    }
+#endif // FAISS_ENABLE_SVS
+
     // NSG variants (it was unclear in the old version that the separator was a
     // "," so we support both "_" and ",")
     if (re_match(description, "NSG([0-9]*)([,_].*)?", sm)) {

data/vendor/faiss/faiss/invlists/BlockInvertedLists.h

@@ -20,7 +20,7 @@ struct IDSelector;
 /** Inverted Lists that are organized by blocks.
  *
  * Different from the regular inverted lists, the codes are organized by blocks
- * of size block_size bytes that reprsent a set of n_per_block. Therefore, code
+ * of size block_size bytes that represent a set of n_per_block. Therefore, code
  * allocations are always rounded up to block_size bytes. The codes are also
  * aligned on 32-byte boundaries for use with SIMD.
  *

data/vendor/faiss/faiss/invlists/DirectMap.cpp

@@ -53,7 +53,7 @@ void DirectMap::set_type(
             for (long ofs = 0; ofs < list_size; ofs++) {
                 FAISS_THROW_IF_NOT_MSG(
                         0 <= idlist[ofs] && idlist[ofs] < ntotal,
-                        "direct map supported only for seuquential ids");
+                        "direct map supported only for sequential ids");
                 array[idlist[ofs]] = lo_build(key, ofs);
             }
         } else if (new_type == Hashtable) {

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

@@ -229,7 +229,7 @@ bool InvertedLists::is_empty(size_t list_no, void* inverted_list_context)
     }
 }
 
-// implemnent iterator on top of get_codes / get_ids
+// implement iterator on top of get_codes / get_ids
 namespace {
 
 struct CodeArrayIterator : InvertedListsIterator {
@@ -358,7 +358,8 @@ ArrayInvertedListsPanorama::ArrayInvertedListsPanorama(
           n_levels(n_levels),
           level_width(
                   (((code_size / sizeof(float)) + n_levels - 1) / n_levels) *
-                  sizeof(float)) {
+                  sizeof(float)),
+          pano(code_size, n_levels, kBatchSize) {
     FAISS_THROW_IF_NOT(n_levels > 0);
     FAISS_THROW_IF_NOT(code_size % sizeof(float) == 0);
     FAISS_THROW_IF_NOT_MSG(
@@ -390,8 +391,11 @@ size_t ArrayInvertedListsPanorama::add_entries(
     codes[list_no].resize(num_batches * kBatchSize * code_size);
     cum_sums[list_no].resize(num_batches * kBatchSize * (n_levels + 1));
 
-    copy_codes_to_level_layout(list_no, o, n_entry, code);
-    compute_cumulative_sums(list_no, o, n_entry, code);
+    // Cast to float* is safe here as we guarantee codes are always float
+    // vectors for `IndexIVFFlatPanorama` (verified by the constructor).
+    const float* vectors = reinterpret_cast<const float*>(code);
+    pano.copy_codes_to_level_layout(codes[list_no].data(), o, n_entry, code);
+    pano.compute_cumulative_sums(cum_sums[list_no].data(), o, n_entry, vectors);
 
     return o;
 }
@@ -406,8 +410,14 @@ void ArrayInvertedListsPanorama::update_entries(
     assert(n_entry + offset <= ids[list_no].size());
 
     memcpy(&ids[list_no][offset], ids_in, sizeof(ids_in[0]) * n_entry);
-    copy_codes_to_level_layout(list_no, offset, n_entry, code);
-    compute_cumulative_sums(list_no, offset, n_entry, code);
+
+    // Cast to float* is safe here as we guarantee codes are always float
+    // vectors for `IndexIVFFlatPanorama` (verified by the constructor).
+    const float* vectors = reinterpret_cast<const float*>(code);
+    pano.copy_codes_to_level_layout(
+            codes[list_no].data(), offset, n_entry, code);
+    pano.compute_cumulative_sums(
+            cum_sums[list_no].data(), offset, n_entry, vectors);
 }
 
 void ArrayInvertedListsPanorama::resize(size_t list_no, size_t new_size) {
@@ -426,21 +436,8 @@ const uint8_t* ArrayInvertedListsPanorama::get_single_code(
 
     uint8_t* recons_buffer = new uint8_t[code_size];
 
-    const uint8_t* codes_base = codes[list_no].data();
-
-    size_t batch_no = offset / kBatchSize;
-    size_t pos_in_batch = offset % kBatchSize;
-    size_t batch_offset = batch_no * kBatchSize * code_size;
-
-    for (size_t level = 0; level < n_levels; level++) {
-        size_t level_offset = level * level_width * kBatchSize;
-        const uint8_t* src = codes_base + batch_offset + level_offset +
-                pos_in_batch * level_width;
-        uint8_t* dest = recons_buffer + level * level_width;
-        size_t copy_size =
-                std::min(level_width, code_size - level * level_width);
-        memcpy(dest, src, copy_size);
-    }
+    float* recons = reinterpret_cast<float*>(recons_buffer);
+    pano.reconstruct(offset, recons, codes[list_no].data());
 
     return recons_buffer;
 }
@@ -463,94 +460,6 @@ InvertedListsIterator* ArrayInvertedListsPanorama::get_iterator(
     return nullptr;
 }
 
-void ArrayInvertedListsPanorama::compute_cumulative_sums(
-        size_t list_no,
-        size_t offset,
-        size_t n_entry,
-        const uint8_t* code) {
-    // Cast to float* is safe here as we guarantee codes are always float
-    // vectors for `IndexIVFFlatPanorama` (verified by the constructor).
-    const float* vectors = reinterpret_cast<const float*>(code);
-    const size_t d = code_size / sizeof(float);
-
-    std::vector<float> suffix_sums(d + 1);
-
-    for (size_t entry_idx = 0; entry_idx < n_entry; entry_idx++) {
-        size_t current_pos = offset + entry_idx;
-        size_t batch_no = current_pos / kBatchSize;
-        size_t pos_in_batch = current_pos % kBatchSize;
-
-        const float* vector = vectors + entry_idx * d;
-
-        // Compute suffix sums of squared values.
-        suffix_sums[d] = 0.0f;
-        for (int j = d - 1; j >= 0; j--) {
-            float squared_val = vector[j] * vector[j];
-            suffix_sums[j] = suffix_sums[j + 1] + squared_val;
-        }
-
-        // Store cumulative sums in batch-oriented layout.
-        size_t cumsum_batch_offset = batch_no * kBatchSize * (n_levels + 1);
-        float* cumsum_base = cum_sums[list_no].data();
-
-        const size_t level_width_floats = level_width / sizeof(float);
-        for (size_t level = 0; level < n_levels; level++) {
-            size_t start_idx = level * level_width_floats;
-            size_t cumsum_offset =
-                    cumsum_batch_offset + level * kBatchSize + pos_in_batch;
-            if (start_idx < d) {
-                cumsum_base[cumsum_offset] = sqrt(suffix_sums[start_idx]);
-            } else {
-                cumsum_base[cumsum_offset] = 0.0f;
-            }
-        }
-
-        // Last level sum is always 0.
-        size_t cumsum_offset =
-                cumsum_batch_offset + n_levels * kBatchSize + pos_in_batch;
-        cumsum_base[cumsum_offset] = 0.0f;
-    }
-}
-
-// Helper method to copy codes into level-oriented batch layout at a given
-// offset in the list.
-void ArrayInvertedListsPanorama::copy_codes_to_level_layout(
-        size_t list_no,
-        size_t offset,
-        size_t n_entry,
-        const uint8_t* code) {
-    uint8_t* codes_base = codes[list_no].data();
-    size_t current_pos = offset;
-    for (size_t entry_idx = 0; entry_idx < n_entry;) {
-        // Determine which batch we're in and position within that batch.
-        size_t batch_no = current_pos / kBatchSize;
-        size_t pos_in_batch = current_pos % kBatchSize;
-        size_t entries_in_this_batch =
-                std::min(n_entry - entry_idx, kBatchSize - pos_in_batch);
-
-        // Copy entries into level-oriented layout for this batch.
-        size_t batch_offset = batch_no * kBatchSize * code_size;
-        for (size_t level = 0; level < n_levels; level++) {
-            size_t level_offset = level * level_width * kBatchSize;
-            size_t start_byte = level * level_width;
-            size_t copy_size =
-                    std::min(level_width, code_size - level * level_width);
-
-            for (size_t i = 0; i < entries_in_this_batch; i++) {
-                const uint8_t* src =
-                        code + (entry_idx + i) * code_size + start_byte;
-                uint8_t* dest = codes_base + batch_offset + level_offset +
-                        (pos_in_batch + i) * level_width;
-
-                memcpy(dest, src, copy_size);
-            }
-        }
-
-        entry_idx += entries_in_this_batch;
-        current_pos += entries_in_this_batch;
-    }
-}
-
 /*****************************************************************
  * Meta-inverted list implementations
  *****************************************************************/

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

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include <faiss/MetricType.h>
+#include <faiss/impl/Panorama.h>
 #include <faiss/impl/maybe_owned_vector.h>
 
 namespace faiss {
@@ -283,6 +284,7 @@ struct ArrayInvertedListsPanorama : ArrayInvertedLists {
     std::vector<MaybeOwnedVector<float>> cum_sums;
     const size_t n_levels;
     const size_t level_width; // in code units
+    Panorama pano;
 
     ArrayInvertedListsPanorama(size_t nlist, size_t code_size, size_t n_levels);
 
@@ -318,24 +320,6 @@ struct ArrayInvertedListsPanorama : ArrayInvertedLists {
 
     /// Frees codes returned by `get_single_code`.
     void release_codes(size_t list_no, const uint8_t* codes) const override;
-
-   private:
-    /// Helper method to copy codes into level-oriented batch layout at a given
-    /// offset in the list.
-    void copy_codes_to_level_layout(
-            size_t list_no,
-            size_t offset,
-            size_t n_entry,
-            const uint8_t* code);
-
-    /// Helper method to compute the cumulative sums of the codes.
-    /// The cumsums also follow the level-oriented batch layout to minimize the
-    /// number of random memory accesses.
-    void compute_cumulative_sums(
-            size_t list_no,
-            size_t offset,
-            size_t n_entry,
-            const uint8_t* code);
 };
 
 /*****************************************************************

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

@@ -372,7 +372,7 @@ OnDiskInvertedLists::~OnDiskInvertedLists() {
     if (ptr != nullptr) {
         int err = munmap(ptr, totsize);
         if (err != 0) {
-            fprintf(stderr, "mumap error: %s", strerror(errno));
+            fprintf(stderr, "munmap error: %s", strerror(errno));
         }
     }
     delete locks;

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

@@ -121,7 +121,7 @@ struct OnDiskInvertedLists : InvertedLists {
 
     LockLevels* locks;
 
-    // encapsulates the threads that are busy prefeteching
+    // encapsulates the threads that are busy prefetching
     struct OngoingPrefetch;
     OngoingPrefetch* pf;
     int prefetch_nthread;