SERVER-19564: Vectorize index write

4 files changed, 56 insertions, 25 deletions

diff --git a/src/mongo/db/catalog/collection.cpp b/src/mongo/db/catalog/collection.cpp
index c754ce46254..91c364ae622 100644
--- a/src/mongo/db/catalog/collection.cpp
+++ b/src/mongo/db/catalog/collection.cpp
@@ -434,20 +434,21 @@ Status Collection::_insertDocuments(OperationContext* txn,
     //       under the RecordStore, this feels broken since that should be a
     //       collection access method probably
 
-    // These will be vectorized (insertRecords, indexRecords) in a future patch
+    // insertRecord(s) will be vectorized in a future patch
+    std::vector<BsonRecord> bsonRecords;
     for (vector<BSONObj>::iterator it = begin; it != end; it++) {
         StatusWith<RecordId> loc = _recordStore->insertRecord(
             txn, it->objdata(), it->objsize(), _enforceQuota(enforceQuota));
         if (!loc.isOK())
             return loc.getStatus();
+        BsonRecord bsonRecord = {loc.getValue(), &(*it)};
+        bsonRecords.push_back(bsonRecord);
+
         invariant(RecordId::min() < loc.getValue());
         invariant(loc.getValue() < RecordId::max());
-
-        Status status = _indexCatalog.indexRecord(txn, *it, loc.getValue());
-        if (!status.isOK())
-            return status;
     }
-    return Status::OK();
+
+    return _indexCatalog.indexRecords(txn, bsonRecords);
 }
 
 Status Collection::aboutToDeleteCapped(OperationContext* txn,
@@ -580,7 +581,10 @@ StatusWith<RecordId> Collection::updateDocument(OperationContext* txn,
                 debug->nmoved += 1;
         }
 
-        Status s = _indexCatalog.indexRecord(txn, newDoc, newLocation.getValue());
+        std::vector<BsonRecord> bsonRecords;
+        BsonRecord bsonRecord = {newLocation.getValue(), &newDoc};
+        bsonRecords.push_back(bsonRecord);
+        Status s = _indexCatalog.indexRecords(txn, bsonRecords);
         if (!s.isOK())
             return StatusWith<RecordId>(s);
         invariant(sid == txn->recoveryUnit()->getSnapshotId());
diff --git a/src/mongo/db/catalog/index_catalog.cpp b/src/mongo/db/catalog/index_catalog.cpp
index 940b2fa9810..9b713cc0a23 100644
--- a/src/mongo/db/catalog/index_catalog.cpp
+++ b/src/mongo/db/catalog/index_catalog.cpp
@@ -1109,21 +1109,38 @@ bool isDupsAllowed(IndexDescriptor* desc) {
 }
 }
 
-Status IndexCatalog::_indexRecord(OperationContext* txn,
-                                  IndexCatalogEntry* index,
-                                  const BSONObj& obj,
-                                  const RecordId& loc) {
-    const MatchExpression* filter = index->getFilterExpression();
-    if (filter && !filter->matchesBSON(obj)) {
-        return Status::OK();
-    }
-
+Status IndexCatalog::_indexFilteredRecords(OperationContext* txn,
+                                           IndexCatalogEntry* index,
+                                           const std::vector<BsonRecord>& bsonRecords) {
     InsertDeleteOptions options;
     options.logIfError = false;
     options.dupsAllowed = isDupsAllowed(index->descriptor());
 
-    int64_t inserted;
-    return index->accessMethod()->insert(txn, obj, loc, options, &inserted);
+    for (auto bsonRecord : bsonRecords) {
+        int64_t inserted;
+        invariant(bsonRecord.id != RecordId());
+        Status status = index->accessMethod()->insert(
+            txn, *bsonRecord.docPtr, bsonRecord.id, options, &inserted);
+        if (!status.isOK())
+            return status;
+    }
+    return Status::OK();
+}
+
+Status IndexCatalog::_indexRecords(OperationContext* txn,
+                                   IndexCatalogEntry* index,
+                                   const std::vector<BsonRecord>& bsonRecords) {
+    const MatchExpression* filter = index->getFilterExpression();
+    if (!filter)
+        return _indexFilteredRecords(txn, index, bsonRecords);
+
+    std::vector<BsonRecord> filteredBsonRecords;
+    for (auto bsonRecord : bsonRecords) {
+        if (filter->matchesBSON(*(bsonRecord.docPtr)))
+            filteredBsonRecords.push_back(bsonRecord);
+    }
+
+    return _indexFilteredRecords(txn, index, filteredBsonRecords);
 }
 
 Status IndexCatalog::_unindexRecord(OperationContext* txn,
@@ -1152,10 +1169,11 @@ Status IndexCatalog::_unindexRecord(OperationContext* txn,
 }
 
 
-Status IndexCatalog::indexRecord(OperationContext* txn, const BSONObj& obj, const RecordId& loc) {
+Status IndexCatalog::indexRecords(OperationContext* txn,
+                                  const std::vector<BsonRecord>& bsonRecords) {
     for (IndexCatalogEntryContainer::const_iterator i = _entries.begin(); i != _entries.end();
          ++i) {
-        Status s = _indexRecord(txn, *i, obj, loc);
+        Status s = _indexRecords(txn, *i, bsonRecords);
         if (!s.isOK())
             return s;
     }
diff --git a/src/mongo/db/catalog/index_catalog.h b/src/mongo/db/catalog/index_catalog.h
index 9cb9186a25e..bb3edea07b1 100644
--- a/src/mongo/db/catalog/index_catalog.h
+++ b/src/mongo/db/catalog/index_catalog.h
@@ -36,6 +36,7 @@
 #include "mongo/db/jsobj.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/record_id.h"
+#include "mongo/db/storage/record_store.h"
 #include "mongo/platform/unordered_map.h"
 
 namespace mongo {
@@ -263,7 +264,7 @@ public:
     // ----- data modifiers ------
 
     // this throws for now
-    Status indexRecord(OperationContext* txn, const BSONObj& obj, const RecordId& loc);
+    Status indexRecords(OperationContext* txn, const std::vector<BsonRecord>& bsonRecords);
 
     void unindexRecord(OperationContext* txn, const BSONObj& obj, const RecordId& loc, bool noWarn);
 
@@ -294,10 +295,13 @@ private:
 
     void _checkMagic() const;
 
-    Status _indexRecord(OperationContext* txn,
-                        IndexCatalogEntry* index,
-                        const BSONObj& obj,
-                        const RecordId& loc);
+    Status _indexFilteredRecords(OperationContext* txn,
+                                 IndexCatalogEntry* index,
+                                 const std::vector<BsonRecord>& bsonRecords);
+
+    Status _indexRecords(OperationContext* txn,
+                         IndexCatalogEntry* index,
+                         const std::vector<BsonRecord>& bsonRecords);
 
     Status _unindexRecord(OperationContext* txn,
                           IndexCatalogEntry* index,
diff --git a/src/mongo/db/storage/record_store.h b/src/mongo/db/storage/record_store.h
index a5a6a459db3..4321c1a187c 100644
--- a/src/mongo/db/storage/record_store.h
+++ b/src/mongo/db/storage/record_store.h
@@ -91,6 +91,11 @@ struct Record {
     RecordData data;
 };
 
+struct BsonRecord {
+    RecordId id;
+    const BSONObj* docPtr;
+};
+
 /**
  * Retrieves Records from a RecordStore.
  *