www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - AAs of struct or array

reply bearophile <bearophileHUGS lycos.com> writes:
I have noticed a significant speed difference between foo1 and foo2 (D2 code):

import std.c.stdio: printf;

int foo1(int x, int y) {
    static int[int[2]] cache;
    int[2] args = [x, y];
    cache[args] = x;
    return x;
}

int foo2(int x, int y) {
    static struct Pair { int x, y; }
    static int[Pair] cache;
    Pair args = Pair(x, y);
    cache[args] = x;
    return x;
}

void main() {
    enum int N = 600;
    int tot;
    foreach (x; 1 .. N)
        foreach (y; 1 .. N)
            tot += foo2(x, y); // use foo1 or foo2 here
    printf("%d\n", tot);
}


Bye,
bearophile
May 27 2010
next sibling parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
bearophile wrote:

 I have noticed a significant speed difference between foo1 and foo2 (D2 code):
 
 import std.c.stdio: printf;
 
 int foo1(int x, int y) {
     static int[int[2]] cache;
     int[2] args = [x, y];
     cache[args] = x;



Most of it comes from the use of that temporary. -O doesn't help either.

This makes foo1 only slightly slower than foo2:

//     int[2] args = [x, y];
     cache[[x, y]] = x;


     return x;
 }
 
 int foo2(int x, int y) {
     static struct Pair { int x, y; }
     static int[Pair] cache;
     Pair args = Pair(x, y);
     cache[args] = x;
     return x;
 }
 
 void main() {
     enum int N = 600;
     int tot;
     foreach (x; 1 .. N)
         foreach (y; 1 .. N)
             tot += foo2(x, y); // use foo1 or foo2 here
     printf("%d\n", tot);
 }
 
 
 Bye,
 bearophile



Ali
May 27 2010
parent reply bearophile <bearophileHUGS lycos.com> writes:
Ali Çehreli:

 Most of it comes from the use of that temporary. -O doesn't help either.



Right. I will probably put this in Bugzilla, even if it's a low priority thing.

Bye,
bearophile
May 27 2010
parent bearophile <bearophileHUGS lycos.com> writes:
http://d.puremagic.com/issues/show_bug.cgi?id=4244
May 27 2010
prev sibling parent Pelle <pelle.mansson gmail.com> writes:
On 05/27/2010 02:33 PM, bearophile wrote:

 I have noticed a significant speed difference between foo1 and foo2 (D2 code):

 import std.c.stdio: printf;

 int foo1(int x, int y) {
      static int[int[2]] cache;
      int[2] args = [x, y];
      cache[args] = x;
      return x;
 }

 int foo2(int x, int y) {
      static struct Pair { int x, y; }
      static int[Pair] cache;
      Pair args = Pair(x, y);
      cache[args] = x;
      return x;
 }

 void main() {
      enum int N = 600;
      int tot;
      foreach (x; 1 .. N)
          foreach (y; 1 .. N)
              tot += foo2(x, y); // use foo1 or foo2 here
      printf("%d\n", tot);
 }


 Bye,
 bearophile



On my machine, foo1 takes around 9 times longer.

Why is this?
May 27 2010