Template talk:T data a

vak

val

vam

vbk

vbl

vbm

Preprocessor node count: 1 + (# of calls of data templates) * (8 + # of data in each data template)=1+6*(8+3) Post-expand include size: 2 * total result) Template argument size: names of get templates used, plus total result Expensive parser function count: 0

Preprocessor node count: 67/1000000 Post-expand include size: 36/2048000 bytes Template argument size: 48/2048000 bytes Expensive parser function count: 0/500

If we retrieve all data of a m*n matrix separately, each once, each with a size s, and l=length of each get template name:

Preprocessor node count: 1 + (# of data) * (8 + # of data in each data template) = 1 + mn(8+n) Post-expand include size: 2 * all data) = 2mns Template argument size: (# of data) * length of each get template name, plus all data = mn(s+l) Expensive parser function count: 0

mn * max (8+n,s,(s+l)/2) < 1,000,000

largest mn for n<=max (s,(s+l)/2) - 8, then mn < 1,000,000 / max (s,(s+l)/2)

Example: s=10, l=10:

n>1, mn(8+n)<1,000,000
n=1, m<100,000

largest mn for n=1 and n=2: 100,000

Example: m=2000 (there are 1250 country data templates, allow some growth), then n<=18.

If we retrieve all data from k columns of a m*n matrix separately, each once, each with a size s:

Preprocessor node count: 1 + mk(8+n) Post-expand include size: 2mks Template argument size: mk(s+l) Expensive parser function count: 0

mk * max (8+n,s,(s+l)/2) < 1,000,000

largest mk for n<=max (s,(s+l)/2) - 8, then mk < 1,000,000 / max (s,(s+l)/2)

Example: s=10, length of each get template name = 10:

mk(8+n)<1,000,000
mk<204,800 i.e., not an extra restriction

Example: m=2000, then k(8+n)<=500.

abvakcdvalefvamgh

Preprocessor node count: 16/1000000 (1 + 15 instead of 1 + 11 each) Post-expand include size: 18/2048000 bytes (same) Template argument size: 18/2048000 bytes (less because of a single parameter name, shorter than the three names together)

Preprocessor node count: 10/1000000 (1+9) Post-expand include size: 0/2048000 bytes Template argument size: 4/2048000 bytes

Preprocessor node count getting k data with one template: 1 + m(3 + 2k + 2n)

k n 6 + 2k + n
1 1 7
1 3 11
3 3 15

n=4:

k n nc-1 
0 1 7
0 3 9
0 4 10
0 n 6+n
1 1 9
1 3 11
1 4 12
1 n 8+n
3 3 15 33
3 4 16
k n 6+2k+n / k(8+n)
    all k at once / each separately

Example: m=2000, then 6+2k+n<=500 or k(8+n)<=500.

If we retrieve all data from k columns of a m*n matrix, per row at once, each row once, each item with a size s:

Preprocessor node count: 1 + m(6+2k+n) Post-expand include size: 2mks Template argument size: m(ks+l)

m * max (6+2k+n,ks,(ks+l)/2) < 1,000,000

n restricts m for a pair (k,s) if 6+2k+n>max(ks,(ks+l)/2), typically if 6+2k+n>ks, i.e. n>k(s-2)-6

With s=1: m(6+2k+n)<1,000,000

n always restricts m, with n=k: m(2+k)<=333,333

if m=2000: k + (n-k)/3<=164

If we retrieve all data from a m*1 matrix, each once, each item with a size s:

Preprocessor node count: 1 + 9m Post-expand include size: 2ms Template argument size: m(s+l)

m * max (9,s,(s+l)/2) < 1,000,000

If we retrieve all data from k columns of a 1*n matrix separately, each once, each with a size s:

Preprocessor node count: 1 + k(8+n) Post-expand include size: 2ks Template argument size: k(s+l)

k * max (8+n,s,(s+l)/2) < 1,000,000

If we retrieve all data from k columns of a 1*n matrix, at once, each item with a size s:

Preprocessor node count: 7+2k+n Post-expand include size: 2ks Template argument size: ks+l

max (6+2k+n,ks,(ks+l)/2) < 1,000,000