Ticket #671: readahead-improved.patch

xapian-core/api/query.cc

@@ -144 +144 @@
     return TermIterator(new VectorTermList(v.begin(), v.end()));
 }
 
+const TermIterator
+Query::get_unique_terms_begin() const
+{
+    if (!internal.get())
+        return TermIterator();
+
+    vector<pair<Xapian::termpos, string> > terms;
+    internal->gather_terms(static_cast<void*>(&terms));
+    sort(terms.begin(), terms.end(), [](
+                const pair<Xapian::termpos, string>& a,
+                const pair<Xapian::termpos, string>& b) {
+        return a.second < b.second;
+    });
+
+    vector<string> v;
+    vector<pair<Xapian::termpos, string> >::const_iterator i;
+    const string * old_term = NULL;
+    for (i = terms.begin(); i != terms.end(); ++i) {
+        // Remove duplicate term names.
+        if (old_term && *old_term == i->second)
+            continue;
+
+        v.push_back(i->second);
+        old_term = &(i->second);
+    }
+    return TermIterator(new VectorTermList(v.begin(), v.end()));
+}
+
 Xapian::termcount
 Query::get_length() const
 {

xapian-core/backends/chert/chert_database.cc

@@ -472 +472 @@
     }
 }
 
+void
+ChertDatabase::request_document(Xapian::docid did) const
+{
+    record_table.readahead_for_record(did);
+}
+
+void
+ChertDatabase::readahead_for_query(const Xapian::Query &query)
+{
+    Xapian::TermIterator t;
+    for (t = query.get_unique_terms_begin(); t != Xapian::TermIterator(); ++t) {
+        const string & term = *t;
+        postlist_table.readahead_key(ChertPostListTable::make_key(term));
+    }
+}
+
 bool
 ChertDatabase::reopen()
 {

xapian-core/backends/chert/chert_database.h

@@ -298 +298 @@
                                     Xapian::ReplicationInfo * info);
         string get_revision_info() const;
         string get_uuid() const;
+
+        void request_document(Xapian::docid /*did*/) const;
+        void readahead_for_query(const Xapian::Query &query);
         //@}
 
         XAPIAN_NORETURN(void throw_termlist_table_close_exception() const);

xapian-core/backends/chert/chert_record.cc

@@ -79 +79 @@
     if (!del(make_key(did)))
         throw Xapian::DocNotFoundError("Can't delete non-existent document #" + str(did));
 }
+
+void
+ChertRecordTable::readahead_for_record(Xapian::docid did) const
+{
+    readahead_key(make_key(did));
+}

xapian-core/backends/chert/chert_record.h

@@ -68 +68 @@
         /** Delete a record from the table.
          */
         void delete_record(Xapian::docid did);
+
+        void readahead_for_record(Xapian::docid did) const;
 };
 
 #endif /* OM_HGUARD_CHERT_RECORD_H */

xapian-core/backends/chert/chert_table.cc

@@ -1137 +1137 @@
 }
 
 bool
+ChertTable::readahead_key(const string &key) const
+{
+    LOGCALL(DB, bool, "ChertTable::readahead_key", key);
+    Assert(!key.empty());
+
+    // Two cases:
+    //
+    // handle = -1:  Lazy table which isn't yet open
+    //
+    // handle = -2:  Table has been closed.  Since the readahead is just a
+    // hint, we can safely ignore it for a closed table.
+    if (handle < 0)
+        RETURN(false);
+
+    // If the table only has one level, there are no branch blocks to preread.
+    if (level == 0)
+        RETURN(false);
+
+    form_key(key);
+    Key ktkey = kt.key();
+
+    // We'll only readahead the first level, since descending the B-tree would
+    // require actual reads that would likely hurt performance more than help.
+    const byte * p = C[level].p;
+    int c = find_in_block(p, ktkey, false, C[level].c);
+    uint4 n = Item(p, c).block_given_by();
+    if (n != last_readahead) {
+        /* Use the base bit_map_size not the bitmap's size, because the latter
+         * is uninitialised in readonly mode.
+         */
+        Assert(n / CHAR_BIT < base.get_bit_map_size());
+
+        io_readahead_block(handle, block_size, n);
+        last_readahead = n;
+    }
+    RETURN(true);
+}
+
+bool
 ChertTable::get_exact_entry(const string &key, string & tag) const
 {
     LOGCALL(DB, bool, "ChertTable::get_exact_entry", key | tag);

xapian-core/backends/chert/chert_table.h

@@ -334 +334 @@
          */
         void close(bool permanent=false);
 
+        bool readahead_key(const string &key) const;
+
         /** Determine whether the btree exists on disk.
          */
         bool exists() const;
@@ -794 +796 @@
         /// If true, don't create the table until it's needed.
         bool lazy;
 
+        /// Last block readahead_key() preread.
+        mutable uint4 last_readahead;
+
         /* Debugging methods */
 //      void report_block_full(int m, int n, const byte * p);
 };

xapian-core/backends/database.cc

@@ -50 +50 @@
 }
 
 
+void
+Database::Internal::readahead_for_query (const Xapian::Query &)
+{
+}
+
 Xapian::doccount
 Database::Internal::get_value_freq(Xapian::valueno) const
 {

xapian-core/backends/database.h

@@ -48 +48 @@
 
 namespace Xapian {
 
+class Query;
 struct ReplicationInfo;
 
 /** Base class for databases.
@@ -105 +106 @@
          */
         virtual void keep_alive();
 
+        virtual void readahead_for_query (const Xapian::Query & query);
+
         //////////////////////////////////////////////////////////////////
         // Database statistics:
         // ====================

xapian-core/backends/glass/glass_database.cc

@@ -347 +347 @@
     changes.commit(new_revision, flags);
 }
 
+void
+GlassDatabase::request_document(Xapian::docid did) const
+{
+    docdata_table.readahead_for_document(did);
+}
+
+void
+GlassDatabase::readahead_for_query(const Xapian::Query &query)
+{
+    Xapian::TermIterator t;
+    for (t = query.get_unique_terms_begin(); t != Xapian::TermIterator(); ++t) {
+        const string & term = *t;
+        postlist_table.readahead_key(GlassPostListTable::make_key(term));
+    }
+}
+
 bool
 GlassDatabase::reopen()
 {

xapian-core/backends/glass/glass_database.h

@@ -286 +286 @@
                                     Xapian::ReplicationInfo * info);
         string get_revision_info() const;
         string get_uuid() const;
+
+        void request_document(Xapian::docid /*did*/) const;
+        void readahead_for_query(const Xapian::Query &query);
         //@}
 
         XAPIAN_NORETURN(void throw_termlist_table_close_exception() const);

xapian-core/backends/glass/glass_docdata.h

@@ -99 +99 @@
      *               there's no such document, or the document has no data).
      */
     bool delete_document_data(Xapian::docid did) { return del(make_key(did)); }
+
+    void readahead_for_document(Xapian::docid did) const {
+        readahead_key(make_key(did));
+    }
 };
 
 #endif // XAPIAN_INCLUDED_GLASS_DOCDATA_H

xapian-core/backends/glass/glass_table.cc

@@ -1157 +1157 @@
 }
 
 bool
+GlassTable::readahead_key(const string &key) const
+{
+    LOGCALL(DB, bool, "GlassTable::readahead_key", key);
+    Assert(!key.empty());
+
+    // Two cases:
+    //
+    // handle = -1:  Lazy table which isn't yet open
+    //
+    // handle = -2:  Table has been closed.  Since the readahead is just a
+    // hint, we can safely ignore it for a closed table.
+    if (handle < 0)
+        RETURN(false);
+
+    // If the table only has one level, there are no branch blocks to preread.
+    if (level == 0)
+        RETURN(false);
+
+    form_key(key);
+    Key ktkey = kt.key();
+
+    // We'll only readahead the first level, since descending the B-tree would
+    // require actual reads that would likely hurt performance more than help.
+    const byte * p = C[level].get_p();
+    int c = find_in_block(p, ktkey, false, C[level].c);
+    uint4 n = Item(p, c).block_given_by();
+    if (n != last_readahead) {
+        io_readahead_block(handle, block_size, n);
+        last_readahead = n;
+    }
+    RETURN(true);
+}
+
+bool
 GlassTable::get_exact_entry(const string &key, string & tag) const
 {
     LOGCALL(DB, bool, "GlassTable::get_exact_entry", key | tag);
@@ -1454 +1488 @@
           split_p(0),
           compress_strategy(compress_strategy_),
           comp_stream(compress_strategy_),
-          lazy(lazy_)
+          lazy(lazy_),
+          last_readahead(uint4(-1))
 {
     LOGCALL_CTOR(DB, "GlassTable", tablename_ | path_ | readonly_ | compress_strategy_ | lazy_);
 }

xapian-core/backends/glass/glass_table.h

@@ -346 +346 @@
          */
         void close(bool permanent=false);
 
+        bool readahead_key(const string &key) const;
+
         /** Determine whether the btree exists on disk.
          */
         bool exists() const;
@@ -752 +754 @@
         /// If true, don't create the table until it's needed.
         bool lazy;
 
+        /// Last block readahead_key() preread.
+        mutable uint4 last_readahead;
+
         /* Debugging methods */
 //      void report_block_full(int m, int n, const byte * p);
 };

xapian-core/common/io_utils.cc

@@ -162 +162 @@
 }
 
 void
+io_readahead_block(int fd, size_t n, off_t b)
+{
+#ifdef HAVE_POSIX_FADVISE
+    off_t o = b * n;
+    posix_fadvise(fd, o, n, POSIX_FADV_WILLNEED);
+#endif
+}
+
+void
 io_read_block(int fd, char * p, size_t n, off_t b)
 {
     off_t o = b * n;

xapian-core/common/io_utils.h

@@ -116 +116 @@
     io_write(fd, reinterpret_cast<const char *>(p), n);
 }
 
+/// Readahead block b size n bytes from file descriptor fd
+void io_readahead_block(int fd, size_t n, off_t b);
+
 /// Read block b size n bytes into buffer p from file descriptor fd.
 void io_read_block(int fd, char * p, size_t n, off_t b);
 

xapian-core/configure.ac

@@ -800 +800 @@
 )
 
 AC_CHECK_FUNCS([fsync])
+AC_CHECK_FUNCS([posix_fadvise])
 
 dnl HP-UX has pread and pwrite, but they don't work!  Apparently this problem
 dnl manifests when largefile support is enabled, and we definitely want that

xapian-core/include/xapian/query.h

@@ -252 +252 @@
         return TermIterator();
     }
 
+    const TermIterator get_unique_terms_begin() const;
+
     Xapian::termcount get_length() const XAPIAN_PURE_FUNCTION;
 
     bool XAPIAN_NOTHROW(empty() const) XAPIAN_PURE_FUNCTION {

xapian-core/matcher/multimatch.cc

@@ -332 +332 @@
                 is_remote[i] = true;
             } else {
                 smatch = new LocalSubMatch(subdb, query, qlen, subrsets[i], weight);
+                subdb->readahead_for_query(query);
             }
 #else
             // Avoid unused parameter warnings.