Performance: data access speed (Array, DataSeries)

[fx.practic]

Hello.

Say, I make my own wighted moving average.

I have sets of coefficient ( k[2,Period] ).
On each bar I multiplicate Period last Closes prices at appropriate coefficient.

I made 3 almost same algorithms:

Variant = "Variant 1";
for( int i = 0; i < Period; i++ ) 
{ 
	sum_0 += Close[i] * K[0][i];
	sum_1 += Close[i] * K[1][i];
}

Variant = "Variant 2";
for( int i = 0; i < Period; i++ ) 
{ 
	double close = Close[i]; 
	sum_0 += close * K[0][i];
	sum_1 += close * K[1][i];
}

Variant = "Variant 3";
for( int i = 0; i < Period; i++ ) 
{ 
	double close = Close[i];
	sum_0 += K[0][i];
	sum_1 += K[1][i];
}

Speed test results (for Period = 10000) on screenshot.

Variant 1: 0.38 ms \ bar
Variant 1: 0.33 ms \ bar
Variant 1: 0.33 ms \ bar

I want pay attention that "Variant 3" have no multiplication at all - all time spend for data access only.

My conclusion: calculations take almost no time. All time spend at data access.

My question: how can we decrease data access time using safe code?

[fx.practic]

Then I decide to check my conclusion.
Instead of array of arrays I made array of structures:

struct K_struct
{
	public double	m0;
	public double	m1;
	public double	m2;
	public double	m3;
	public double	m4;
	public double	m5;
	public double	m6;
	public double	m7;
	public double	m8;
	public double	m9;
			
	public double	n0;
	public double	n1;
	public double	n2;
	public double	n3;
	public double	n4;
	public double	n5;
	public double	n6;
	public double	n7;
	public double	n8;
	public double	n9;
}

K_struct[] K = new K_struct[Period/10];

and

Variant = "Struct";
for( int i = 0; i < Period/10; i++ ) 
{ 
	double close = Close[i];
				
	sum_m += K[i/10].m0 * close;
	sum_m += K[i/10].m1 * close;
	sum_m += K[i/10].m2 * close;
	sum_m += K[i/10].m3 * close;
	sum_m += K[i/10].m4 * close;
	sum_m += K[i/10].m5 * close;
	sum_m += K[i/10].m6 * close;
	sum_m += K[i/10].m7 * close;
	sum_m += K[i/10].m8 * close;
	sum_m += K[i/10].m9 * close;
	
	sum_n += K[i/10].n0 * close;
	sum_n += K[i/10].n1 * close;
	sum_n += K[i/10].n2 * close;
	sum_n += K[i/10].n3 * close;
	sum_n += K[i/10].n4 * close;
	sum_n += K[i/10].n5 * close;
	sum_n += K[i/10].n6 * close;
	sum_n += K[i/10].n7 * close;
	sum_n += K[i/10].n8 * close;
	sum_n += K[i/10].n9 * close;
}

This works 10 times faster.

Is there another - more convenient and universal - way to decrease access speed?

Dll on C++? Dll on assembler? But it is not programmer-friendly.

[sledge]

Slow down a second.

You need a couple more variants to test.

Move the declaration out of the loop. Keep the assignment in the loop. (#2).

And completely remove it in variant#3.

Hard to exactly know how the compiler optimizes this code if at all without seeing the generated machine language.

Here is an excellent book, a little old, but it will get you thinking too much.

http://www.amazon.com/Inner-Loops-Sourcebook-Software-Development/dp/0201479605