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
|
'use strict';
/**
* agg_base.js
*
* Base workload for aggregation. Inserts a bunch of documents in its setup,
* then each thread does an aggregation with an empty $match.
*/
var $config = (function() {
var data = {
numDocs: 1000,
// Use 12KB documents by default. This number is useful because 12,000 documents each of
// size 12KB take up more than 100MB in total, and 100MB is the in-memory limit for $sort
// and $group.
docSize: 12 * 1000
};
var getStringOfLength = (function() {
var cache = {};
return function getStringOfLength(size) {
if (!cache[size]) {
cache[size] = new Array(size + 1).join('x');
}
return cache[size];
};
})();
function padDoc(doc, size) {
// first set doc.padding so that Object.bsonsize will include the field name and other
// overhead
doc.padding = "";
var paddingLength = size - Object.bsonsize(doc);
assertAlways.lte(
0, paddingLength, 'document is already bigger than ' + size + ' bytes: ' + tojson(doc));
doc.padding = getStringOfLength(paddingLength);
assertAlways.eq(size, Object.bsonsize(doc));
return doc;
}
var states = {
query: function query(db, collName) {
var count = db[collName].aggregate([]).itcount();
assertWhenOwnColl.eq(count, this.numDocs);
}
};
var transitions = {query: {query: 1}};
function setup(db, collName, cluster) {
// load example data
var bulk = db[collName].initializeUnorderedBulkOp();
for (var i = 0; i < this.numDocs; ++i) {
// note: padDoc caches the large string after allocating it once, so it's ok to call it
// in this loop
bulk.insert(padDoc({
flag: i % 2 ? true : false,
rand: Random.rand(),
randInt: Random.randInt(this.numDocs)
},
this.docSize));
}
var res = bulk.execute();
assertWhenOwnColl.writeOK(res);
assertWhenOwnColl.eq(this.numDocs, res.nInserted);
assertWhenOwnColl.eq(this.numDocs, db[collName].find().itcount());
assertWhenOwnColl.eq(this.numDocs / 2, db[collName].find({flag: false}).itcount());
assertWhenOwnColl.eq(this.numDocs / 2, db[collName].find({flag: true}).itcount());
}
return {
// Using few threads and iterations because each iteration is fairly expensive compared to
// other workloads' iterations. (Each does a collection scan over a few thousand documents
// rather than a few dozen documents.)
threadCount: 5,
iterations: 10,
states: states,
startState: 'query',
transitions: transitions,
data: data,
setup: setup,
};
})();
|
