Why are many sessions faster in MongoDB than one?

Question

To use transactions in MongoDB you have to start a session first. When you have many transactions, you can either reuse an existing session or create a new one for every transaction.

I benchmarked (code below) both options and the result is puzzling me. Using a fresh session for each transaction seems to be significantly faster (~2 to 3 times faster) than using a single session for all transactions.

Can anybody explain why this is so? How do sessions work under the hood? What are their implications? What costs do the imply (and when and why)? I really want to understand and I am grateful for any pointers.

Stopwatch sw = new Stopwatch();

coll1.InsertOne(new BsonDocument { { "Seq", 0 } });
sw.Start();
for (int i = 1; i <= reps; i++) {
    using (var session = client.StartSession()) {
        session.StartTransaction();
        coll1.InsertOne(session: session, document: new BsonDocument { { "Seq", i } });
        session.CommitTransaction();
    }
}
sw.Stop();
Console.WriteLine($"{reps / sw.Elapsed.TotalSeconds} OP/s with fresh sessions.");

coll2.InsertOne(new BsonDocument { { "Seq", 0 } });
sw.Restart();
using (var session = client.StartSession()) {
    for (int i = 1; i <= reps; i++) {
        session.StartTransaction();
        coll2.InsertOne(session: session, document: new BsonDocument { { "Seq", i } });
        session.CommitTransaction();
    }
}
sw.Stop();
Console.WriteLine($"{reps / sw.Elapsed.TotalSeconds} OP/s with common session.");

I also tried running the single session code first giving me the same result.

Answer 1

From the documentation.

Isolation

Operations within a causally consistent session are not isolated from operations outside the session. If a concurrent write operation interleaves between the session’s write and read operations, the session’s read operation may return results that reflect a write operation that occurred after the session’s write operation.

It means that operations of different sessions could go in parallel without frequent blocking.