(no subject)

[Adam Burton]

coxalan wrote:

> Hello!
> 
> I realized that this code:
> 
> int func() {
>     int res;
>     int[] g;
>     g.length = 10;
>     foreach(v; g) {
>         res += v;
>     }
>     return res;
> }
> 
> void main() {
>     for(int i=0; i<10000000; i++) {
>         func;
>     }
> }
> 
> runs about 7 times slower than this one:
> 
> class Funcclass {
>     int[] g;
> 
>     this() {
>         g.length = 10;
>     }
> 
>     int func() {
>         int res;
>         foreach(v; g) {
>             res += v;
>         }
>         return res;
>     }
> }
> 
> void main() {
>     auto fc = new Funcclass;
>     for(int i=0; i<10000000; i++) {
>         fc.func;
>     }
> }
> 
> The compilation was done with -O -release.
> The difference comes from all the memory-allocating and garbage collecting
> in the first case.
> 
> My question is:
> Is it the default solution to put the function 'func' and the array 'g' as
> members into a common class? Or are there other / more elegant solutions
> for this?
> 
> Thanks!

Hi,
In the second instance you are reusing an array, maybe that's it?

Code 1:
> int func() {
>     int res;
>     int[] g;
>     g.length = 10;
>     foreach(v; g) {
>         res += v;
>     }
>     return res;
> }
> 
> void main() {
>     for(int i=0; i<10000000; i++) {
>         func;
>     }
> }

So in the above you 10000000 times you call a function that creates an
array, then cycles through the array adding up the contents then returns
the result.

Code 2:
> class Funcclass {
>     int[] g;
> 
>     this() {
>         g.length = 10;
>     }
> 
>     int func() {
>         int res;
>         foreach(v; g) {
>             res += v;
>         }
>         return res;
>     }
> }
> 
> void main() {
>     auto fc = new Funcclass;
>     for(int i=0; i<10000000; i++) {
>         fc.func;
>     }
> }

In this one you create an object, which in turn makes an array, then
10000000 times call the objects method which cycles through the same array
each time adding up the contents then return the result.

Code 2 removes the overhead of array creation. Additionally, looking back at
Code 1 had the array been of a larger type (say a complex class) or you
have limited resources in memory (10000000*(10*4Bytes) = 381.4MBytes
(excluding the little extra arrays add like the length property), so lets
say you have 256/512MB of memory for example with other programs
running :-) ) at certain points through out the loop the GC will be forced
to collect the discarded int[10]'s which is some additional overhead to
reclaim memory for more arrays.

Regards,
Adam