1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
/**
* Test that the find command can spill to disk while executing a blocking sort, if the client
* explicitly allows disk usage.
*
* Must be run with read commands enabled, since legacy OP_QUERY reads do not support the
* 'allowDiskUse' parameter.
* @tags: [requires_find_command]
*/
(function() {
"use strict";
load("jstests/libs/analyze_plan.js");
// Only allow blocking sort execution to use 100 kB of memory.
const kMaxMemoryUsageBytes = 100 * 1024;
// TODO (SERVER-43993): Documents can occupy twice as much memory as needed to just store the BSON
// contents of the documents, which is why we can exceed the 100kB memory limit with just 50
// documents, instead of the roughly 100 documents we might expect.
const kNumDocsWithinMemLimit = 35;
const kNumDocsExceedingMemLimit = 50;
const kMemoryLimitExceededErrCode = 16819;
const options = {
setParameter: "internalQueryMaxBlockingSortMemoryUsageBytes=" + kMaxMemoryUsageBytes
};
const conn = MongoRunner.runMongod(options);
assert.neq(null, conn, "mongod was unable to start up with options: " + tojson(options));
const testDb = conn.getDB("test");
const collection = testDb.external_sort_find;
// Construct a document that is just over 1 kB.
const charToRepeat = "-";
const templateDoc = {
padding: charToRepeat.repeat(1024)
};
// Insert data into the collection without exceeding the memory threshold.
for (let i = 0; i < kNumDocsWithinMemLimit; ++i) {
templateDoc.sequenceNumber = i;
assert.commandWorked(collection.insert(templateDoc));
}
// We should be able to successfully sort the collection with or without disk use allowed.
assert.eq(kNumDocsWithinMemLimit, collection.find().sort({sequenceNumber: -1}).itcount());
assert.eq(kNumDocsWithinMemLimit,
collection.find().sort({sequenceNumber: -1}).allowDiskUse().itcount());
function getSortStats(allowDiskUse) {
let cursor = collection.find().sort({sequenceNumber: -1});
if (allowDiskUse) {
cursor = cursor.allowDiskUse();
}
const explain = cursor.explain("executionStats");
return getPlanStage(explain.executionStats.executionStages, "SORT");
}
// Explain should report that less than 100 kB of memory was used, and we did not spill to disk.
// Test that this result is the same whether or not 'allowDiskUse' is set.
let sortStats = getSortStats(false);
assert.eq(sortStats.memLimit, kMaxMemoryUsageBytes);
assert.lt(sortStats.totalDataSizeSorted, kMaxMemoryUsageBytes);
assert.eq(sortStats.usedDisk, false);
sortStats = getSortStats(true);
assert.eq(sortStats.memLimit, kMaxMemoryUsageBytes);
assert.lt(sortStats.totalDataSizeSorted, kMaxMemoryUsageBytes);
assert.eq(sortStats.usedDisk, false);
// Add enough data to exceed the memory threshold.
for (let i = kNumDocsWithinMemLimit; i < kNumDocsExceedingMemLimit; ++i) {
templateDoc.sequenceNumber = i;
assert.commandWorked(collection.insert(templateDoc));
}
// The sort should fail if disk use is not allowed, but succeed if disk use is allowed.
assert.commandFailedWithCode(
testDb.runCommand({find: collection.getName(), sort: {sequenceNumber: -1}}),
kMemoryLimitExceededErrCode);
assert.eq(kNumDocsExceedingMemLimit,
collection.find().sort({sequenceNumber: -1}).allowDiskUse().itcount());
// Explain should report that the SORT stage failed if disk use is not allowed.
sortStats = getSortStats(false);
assert.eq(sortStats.failed, true);
assert.eq(sortStats.usedDisk, false);
assert.lt(sortStats.totalDataSizeSorted, kMaxMemoryUsageBytes);
assert(!sortStats.inputStage.hasOwnProperty("failed"));
// Explain should report that >=100 kB of memory was used, and that we spilled to disk.
sortStats = getSortStats(true);
assert.eq(sortStats.memLimit, kMaxMemoryUsageBytes);
assert.gte(sortStats.totalDataSizeSorted, kMaxMemoryUsageBytes);
assert.eq(sortStats.usedDisk, true);
// If disk use is not allowed but there is a limit, we should be able to avoid exceeding the memory
// limit.
assert.eq(kNumDocsWithinMemLimit,
collection.find().sort({sequenceNumber: -1}).limit(kNumDocsWithinMemLimit).itcount());
// Create a view on top of the collection. When a find command is run against the view without disk
// use allowed, the command should fail with the expected error code. When the find command allows
// disk use, however, the command should succeed.
assert.commandWorked(testDb.createView("identityView", collection.getName(), []));
const identityView = testDb.identityView;
assert.commandFailedWithCode(
testDb.runCommand({find: identityView.getName(), sort: {sequenceNumber: -1}}),
kMemoryLimitExceededErrCode);
assert.eq(kNumDocsExceedingMemLimit,
identityView.find().sort({sequenceNumber: -1}).allowDiskUse().itcount());
MongoRunner.stopMongod(conn);
}());
|
