Maximum Speed Needed

**lixo1** · 20th March 2009, 18:15

Hi fullmetalcoder,

Thank you for your help, but unfortunately I got another time 15min. (my cpu flags has sse and sse2).

It's very strange!
Now, about multiple thread: in my case the "thread" is very simple it's a simple for() like the code bellow:

Qt Code:

Switch view

for (i=0;i<12;i++) {compt[i][0]=0;}
      for (ii=0;ii<=2;ii=ii+1)
      {
        for (i=0;i<12;i++) {compt[i][1]=0;}
      for (jj=0;jj<=2;jj=jj+1)
      {
        for (i=0;i<12;i++) {compt[i][2]=0;}
      for (kk=0;kk<=2;kk=kk+1)
      {
        for (i=0;i<12;i++) {compt[i][3]=0;}
      for (ll=0;ll<=2;ll=ll+1)
      {
            for (i=0;i<12;i++) {compt[i][4]=0;}
          for (mm=0;mm<=2;mm=mm+1)
          {
            for (i=0;i<12;i++) {compt[i][5]=0;}
          for (nn=0;nn<=2;nn=nn+1)
          {
            for (i=0;i<12;i++) {compt[i][6]=0;}
          for (oo=0;oo<=2;oo=oo+1)
          {
            for (i=0;i<12;i++) {compt[i][7]=0;}
          for (pp=0;pp<=2;pp=pp+1)
          {
 
                        for (i=0;i<12;i++) {compt[i][8]=0;}
                      for (psi=0;psi<2*M_PI;psi=psi+step)
                      {
                             for (i=0;i<12;i++) {compt[i][9]=0;}
                           for (phi=0;phi<2*M_PI;phi=phi+step)
                           {
                                 for (i=0;i<12;i++) {compt[i][10]=0;}
                               for (teta=0;teta<M_PI;teta=teta+step)
                               {    //*V 90
                                    compt[0][10]=compt[0][10]  +  sin(teta)*(0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                         + eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                        * (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                         + eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]));
 
                                    compt[1][10]=compt[1][10]  +      sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp])
                                         +  2  *sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                       +  eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                       +  eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
 
                                    compt[2][10]=compt[2][10]  +  sin(teta)*0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
                                    //*H 90
                                    compt[3][10]=compt[3][10]  +  sin(teta)*(0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                         + eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                        * (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                         + eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]));
                                    compt[4][10]=compt[4][10]  +      sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp])
                                         +  0.5*sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                       +  eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                       +  eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
                                    compt[5][10]=compt[5][10]  +  sin(teta)*0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
                               //Cancel process if stop requested
                               if(isTerminated){goto end;}
 
                               }
                               for (i=0;i<12;i++) {compt[i][9]=compt[i][9]+compt[i][10];}
                           }
                           for (i=0;i<12;i++) {compt[i][8]=compt[i][8]+compt[i][9];}
                      }
                      for (i=0;i<12;i++) {compt[i][7]=compt[i][7]+compt[i][8];}
          }
          for (i=0;i<12;i++) {compt[i][6]=compt[i][6]+compt[i][7];}
          }
          for (i=0;i<12;i++) {compt[i][5]=compt[i][5]+compt[i][6];}
          }
          for (i=0;i<12;i++) {compt[i][4]=compt[i][4]+compt[i][5];}
          }
          for (i=0;i<12;i++) {compt[i][3]=compt[i][3]+compt[i][4];}         
      }
 
      //Increment ProgressBar + set number in %
      if(DipCoefChecked){ percent++; emit progbar(percent);}
      else{ percent +=2; emit progbar(percent); }
 
      for (i=0;i<12;i++) {compt[i][2]=compt[i][2]+compt[i][3];}
      }
      for (i=0;i<12;i++) {compt[i][1]=compt[i][1]+compt[i][2];}
      }
      for (i=0;i<12;i++) {compt[i][0]=compt[i][0]+compt[i][1];}
      }

for (i=0;i<12;i++) {compt[i][0]=0;}
      for (ii=0;ii<=2;ii=ii+1)
      {
        for (i=0;i<12;i++) {compt[i][1]=0;}
      for (jj=0;jj<=2;jj=jj+1)
      {
        for (i=0;i<12;i++) {compt[i][2]=0;}
      for (kk=0;kk<=2;kk=kk+1)
      {
        for (i=0;i<12;i++) {compt[i][3]=0;}
      for (ll=0;ll<=2;ll=ll+1)
      {
            for (i=0;i<12;i++) {compt[i][4]=0;}
          for (mm=0;mm<=2;mm=mm+1)
          {
            for (i=0;i<12;i++) {compt[i][5]=0;}
          for (nn=0;nn<=2;nn=nn+1)
          {
            for (i=0;i<12;i++) {compt[i][6]=0;}
          for (oo=0;oo<=2;oo=oo+1)
          {
            for (i=0;i<12;i++) {compt[i][7]=0;}
          for (pp=0;pp<=2;pp=pp+1)
          {

                        for (i=0;i<12;i++) {compt[i][8]=0;}
                      for (psi=0;psi<2*M_PI;psi=psi+step)
                      {
                             for (i=0;i<12;i++) {compt[i][9]=0;}
                           for (phi=0;phi<2*M_PI;phi=phi+step)
                           {
                                 for (i=0;i<12;i++) {compt[i][10]=0;}
                               for (teta=0;teta<M_PI;teta=teta+step)
                               {    //*V 90
                                    compt[0][10]=compt[0][10]  +  sin(teta)*(0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                         + eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                        * (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                         + eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]));

                                    compt[1][10]=compt[1][10]  +      sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp])
                                         +  2  *sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                       +  eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                       +  eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);

                                    compt[2][10]=compt[2][10]  +  sin(teta)*0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(0,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(0,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
                                    //*H 90
                                    compt[3][10]=compt[3][10]  +  sin(teta)*(0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                         + eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                        * (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                         + eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(0,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]));
                                    compt[4][10]=compt[4][10]  +      sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(0,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp])
                                         +  0.5*sin(teta)*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                       +  eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(0,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                       +  eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(0,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
                                    compt[5][10]=compt[5][10]  +  sin(teta)*0.5*step*step*step*(eulerb(2,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll]
                                                                        + eulerb(1,ii,teta,phi,psi)*eulerb(2,jj,teta,phi,psi)*eulerb(1,kk,teta,phi,psi)*eulerb(1,ll,teta,phi,psi)*gamma_a[ii][jj][kk][ll])
                                                                      *  (eulerb(2,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]
                                                                        + eulerb(1,mm,teta,phi,psi)*eulerb(2,nn,teta,phi,psi)*eulerb(1,oo,teta,phi,psi)*eulerb(1,pp,teta,phi,psi)*gamma_a[mm][nn][oo][pp]);
                               //Cancel process if stop requested
                               if(isTerminated){goto end;}

                               }
                               for (i=0;i<12;i++) {compt[i][9]=compt[i][9]+compt[i][10];}
                           }
                           for (i=0;i<12;i++) {compt[i][8]=compt[i][8]+compt[i][9];}
                      }
                      for (i=0;i<12;i++) {compt[i][7]=compt[i][7]+compt[i][8];}
          }
          for (i=0;i<12;i++) {compt[i][6]=compt[i][6]+compt[i][7];}
          }
          for (i=0;i<12;i++) {compt[i][5]=compt[i][5]+compt[i][6];}
          }
          for (i=0;i<12;i++) {compt[i][4]=compt[i][4]+compt[i][5];}
          }
          for (i=0;i<12;i++) {compt[i][3]=compt[i][3]+compt[i][4];}         
      }

      //Increment ProgressBar + set number in %
      if(DipCoefChecked){ percent++; emit progbar(percent);}
      else{ percent +=2; emit progbar(percent); }

      for (i=0;i<12;i++) {compt[i][2]=compt[i][2]+compt[i][3];}
      }
      for (i=0;i<12;i++) {compt[i][1]=compt[i][1]+compt[i][2];}
      }
      for (i=0;i<12;i++) {compt[i][0]=compt[i][0]+compt[i][1];}
      }

To copy to clipboard, switch view to plain text mode

**fullmetalcoder** · 20th March 2009, 19:23

So you used added the flags to your project and it did not change anything right? Well, did you

rebuild your whole app (changing compiler flags is not taken into account by make deps check AFAIK)
check that these flags were passed to the compiler (quick look at the compile log would be enough), there could be something as simple as a spelling error in the variable name or something akin

Maybe I'm a bit touchy but your code is among the worst formatted I have ever seen and this has a dramatic effect on readability...

Another important fact is that you use HUGE assignements in the inner loop which are probably not very well optimized by GCC because it cannot make any assumptions on the values returned by sin() and eulerb() (specifically it cannot guess that several calls to these with the exact same parameter will return the same result). Besides most, if not all your assignements could be changed to use the += operator (for readability and to make sure the compiler optimize as much as possible). You could also compute step*step*step only once and out of the loop (making it const could help optimizations as well).

suggested refactoring (which I am not entierely doing for you

) :

Qt Code:

Switch view

for (i=0;i<12;i++)
{compt[i][0]=0;}
 
const stepCube = step * step * step;
 
for (ii=0;ii<=2;ii=ii+1)
{
  for (i=0;i<12;i++)
  {compt[i][1]=0;}
 
  for (jj=0;jj<=2;jj=jj+1)
  {
    for (i=0;i<12;i++)
    {compt[i][2]=0;}
 
   for (kk=0;kk<=2;kk=kk+1)
   {
     for (i=0;i<12;i++)
     {compt[i][3]=0;}
 
     for (ll=0;ll<=2;ll=ll+1)
     {
       for (i=0;i<12;i++)
       {compt[i][4]=0;}
 
        const double gammaIJKL = gamma_a[ii][jj][kk][ll]; 
       for (mm=0;mm<=2;mm=mm+1)
       {
         for (i=0;i<12;i++)
         {compt[i][5]=0;}
 
         for (nn=0;nn<=2;nn=nn+1)
         {
           for (i=0;i<12;i++)
           {compt[i][6]=0;}
 
           for (oo=0;oo<=2;oo=oo+1)
           {
             for (i=0;i<12;i++)
             {compt[i][7]=0;}
 
             for (pp=0;pp<=2;pp=pp+1)
             {
               for (i=0;i<12;i++)
               {compt[i][8]=0;}
 
               const double gammaMNOP = gamma_a[mm][nn][oo][pp];
               for (psi=0;psi<2*M_PI;psi=psi+step)
               {
                 for (i=0;i<12;i++)
                 {compt[i][9]=0;}
 
                 for (phi=0;phi<2*M_PI;phi=phi+step)
                 {
                   for (i=0;i<12;i++)
                   {compt[i][10]=0;}
 
                   for (teta=0;teta<M_PI;teta=teta+step)
                   {    //*V 90
                      const double sinTheta = sin(teta);
                      const double stsc = sinTheta * stepCube;
                      const double euler1i = eulerb(1,ii,teta,phi,psi);
                      const double euler2i = eulerb(2,ii,teta,phi,psi);
                      const double euler1i2i = euler1i + euler2i;
 
                      const double euler0j = eulerb(0,jj,teta,phi,psi);
                      const double euler0k = eulerb(0,kk,teta,phi,psi);
                      const double euler0l = eulerb(0,ll,teta,phi,psi);
 
                      const double euler1j = eulerb(1,jj,teta,phi,psi);
                      const double euler1k = eulerb(1,kk,teta,phi,psi);
                      const double euler1l = eulerb(1,ll,teta,phi,psi);
 
                      const double euler2j = eulerb(2,jj,teta,phi,psi);
                      const double euler2k = eulerb(2,kk,teta,phi,psi);
                      const double euler2l = eulerb(2,ll,teta,phi,psi);
 
                      compt[0][10] += stsc * 0.5 *
                            euler1i2i*euler0j*euler0k*euler0l*gammaIJKL
                        *
                            euler1m2m*euler0n*euler0o*euler0p*gammaMNOP;
          ...

for (i=0;i<12;i++)
{compt[i][0]=0;}

const stepCube = step * step * step;

for (ii=0;ii<=2;ii=ii+1)
{
  for (i=0;i<12;i++)
  {compt[i][1]=0;}
  
  for (jj=0;jj<=2;jj=jj+1)
  {
    for (i=0;i<12;i++)
    {compt[i][2]=0;}

   for (kk=0;kk<=2;kk=kk+1)
   {
     for (i=0;i<12;i++)
     {compt[i][3]=0;}
          
     for (ll=0;ll<=2;ll=ll+1)
     {
       for (i=0;i<12;i++)
       {compt[i][4]=0;}

        const double gammaIJKL = gamma_a[ii][jj][kk][ll]; 
       for (mm=0;mm<=2;mm=mm+1)
       {
         for (i=0;i<12;i++)
         {compt[i][5]=0;}

         for (nn=0;nn<=2;nn=nn+1)
         {
           for (i=0;i<12;i++)
           {compt[i][6]=0;}

           for (oo=0;oo<=2;oo=oo+1)
           {
             for (i=0;i<12;i++)
             {compt[i][7]=0;}

             for (pp=0;pp<=2;pp=pp+1)
             {
               for (i=0;i<12;i++)
               {compt[i][8]=0;}
               
               const double gammaMNOP = gamma_a[mm][nn][oo][pp];
               for (psi=0;psi<2*M_PI;psi=psi+step)
               {
                 for (i=0;i<12;i++)
                 {compt[i][9]=0;}

                 for (phi=0;phi<2*M_PI;phi=phi+step)
                 {
                   for (i=0;i<12;i++)
                   {compt[i][10]=0;}
                   
                   for (teta=0;teta<M_PI;teta=teta+step)
                   {    //*V 90
                      const double sinTheta = sin(teta);
                      const double stsc = sinTheta * stepCube;
                      const double euler1i = eulerb(1,ii,teta,phi,psi);
                      const double euler2i = eulerb(2,ii,teta,phi,psi);
                      const double euler1i2i = euler1i + euler2i;
                      
                      const double euler0j = eulerb(0,jj,teta,phi,psi);
                      const double euler0k = eulerb(0,kk,teta,phi,psi);
                      const double euler0l = eulerb(0,ll,teta,phi,psi);
                      
                      const double euler1j = eulerb(1,jj,teta,phi,psi);
                      const double euler1k = eulerb(1,kk,teta,phi,psi);
                      const double euler1l = eulerb(1,ll,teta,phi,psi);
                      
                      const double euler2j = eulerb(2,jj,teta,phi,psi);
                      const double euler2k = eulerb(2,kk,teta,phi,psi);
                      const double euler2l = eulerb(2,ll,teta,phi,psi);
                      
                      compt[0][10] += stsc * 0.5 *
                            euler1i2i*euler0j*euler0k*euler0l*gammaIJKL
                        *
                            euler1m2m*euler0n*euler0o*euler0p*gammaMNOP;
          ...

To copy to clipboard, switch view to plain text mode

Of course since the step is fixed during the whole loop you could (and probably should) precompute most of the values (sinTheta, eulerXXX...) and put them in vector/hash (for fast lookup) to reuse them in the inner loop instead of recomputing them every time.

With all these optimizations I'm willing to bet you can go below one minute, despite your algorithm being rather suboptimal.

**wysota** · 20th March 2009, 19:28

I would do such computations in assembly if I were you... If you have a multicore or multicpu machine available try parallelizing the computation. Furthermore replace the for loops with something faster. The first loop can be replaced by memset() for example. Also optimize your code to make proper use of the data cache in your processor. Cache partial results - there is no need to recompute sin(teta) and all the other stuff all the time.

And lose the goto

**lixo1** · 20th March 2009, 20:15

Hi fullmetalcoder,

Absolutely thank you very much for all patience, help and example, I will modify all code.
I'm an amateur (in particular a physicist) so sorry very much for my chaotic readability.

wysota > And lose the goto
What you recommend to use?
I don't use "return;" because after the loop I delete my arrays.

Cheers,
Louis

**wysota** · 20th March 2009, 21:27

Originally Posted by lixo1

wysota > And lose the goto
What you recommend to use?
I don't use "return;" because after the loop I delete my arrays.

There are numerous ways to do it. The easiest one is to allocate all the data on the stack and not on the heap (the latter using the "new" operator). Another is to delete the data using an external function call and then call return. You can also use the "break" keyword to bail out of a loop.

**lni** · 20th March 2009, 21:50

You are computing the same thing a billion times

For instance, you put sin( teta ) in the inner most loop, repeatedly compute the same sin( teta ) in every single outer loop. You can make a sin( teta ) array by computing only once. sin( teta ) is very slow instruction.

Also, you have step * step * step which is another constant, but it is computed 3 trillion times

In the function calls, don't call a function with same arguments many times, such as eulerb( 2, ii, teta, phi, psi ). You can do:

double foo = eulerb( 2, ii, teta, phi, psi );

and then use this foo to replace the same function calls.

Have fun

**wysota** · 20th March 2009, 22:32

You can even use the "register" keyword to hint the compiler about most often used variables.

**fullmetalcoder** · 21st March 2009, 08:29

Originally Posted by wysota

I would do such computations in assembly if I were you...

You're going to scare him to death with such advices. Besides, well written C code can perform pretty well and is be a lot more maintainable and portable than assembly.

Originally Posted by wysota

You can even use the "register" keyword to hint the compiler about most often used variables.

This would actually be a bad idea given the number of most used variables and the fact that modern compilers are typically smarter about guessing an optimal register allocation strategy than the user could ever be.

**wysota** · 21st March 2009, 09:08

Originally Posted by fullmetalcoder

Besides, well written C code can perform pretty well and is be a lot more maintainable and portable than assembly.

I'm guessing he's not much about portability here and it's obviously some formula that is unlikely to change so the benefit of using assembly (or even NVIDIA's CUDA technology) is huge.

This would actually be a bad idea given the number of most used variables and the fact that modern compilers are typically smarter about guessing an optimal register allocation strategy than the user could ever be.

I would not agree here.

**fullmetalcoder** · 21st March 2009, 09:42

Originally Posted by wysota

I would not agree here.

Well, maybe some individuals are able to best the compiler regarding register allocation strategy but then it is very likely that they are able produce more optimized assembly code which renders the register keyword useless.

AFAIK careful use of const and restrict keywords (with strict aliasing enabled for the later to be of any use) are pretty good hints to give to the compiler in such a situation and register is unlikely to make a big difference.

Originally Posted by wysota

I'm guessing he's not much about portability here and it's obviously some formula that is unlikely to change so the benefit of using assembly (or even NVIDIA's CUDA technology) is huge.

True enough but given the difficulty encountered to write it in C, I doubt that he will be tempted to learn assembly. CUDA might be a viable alternative as it does not require use of assembly AFAIK but its biggest advantage is that it offers massive parallelization and the algorithm above looks like an iterative approximation to me so I'm not sure parallelizing it will be easy...

**lixo1** · 21st March 2009, 10:04

Hi guys,

This post is a well of culture!
Great thank you for all these high level informations, I would like only to ask you if it is possible, to link some web page tutorial (or simple book titles) about the different strategies, because it's very difficult to find informations about these technologies if we don't work with it.

Only a thing: my application need to be redistributable on any windows/linux/mac.

Thank you very much, for this great post.
Cheers,
Louis

**fullmetalcoder** · 21st March 2009, 10:12

NVidia CUDA : http://www.nvidia.com/object/cuda_home.html

Some blog posts on restrict keyword and strict aliasing.

I can't seem to find a link to that blog discussing the use of the register keyword so you'll have to search yourself.

**lixo1** · 21st March 2009, 10:26

Great thank you very much.

**songyuncen** · 22nd March 2009, 12:58

Here is my suggestion in order, hope help.
1. Using better algorithm is the first choice.Such as using look up table to make a balance between time and space.
2. Parallel :
(1) parallel in threads : I think OpenMP is a much easier solution instead of other multithread techniques. However it is not supported in express version of Visual C++. It's a set of compiler directives which make your computation parallel automatically.
(2) parallel in instruction : It's very hard for compiler to find the parallelism in your compution even if the SIMD flag has been turn on. So the assembly code from these compiler just use these SIMD instructions to accomplish sequence tasks mostly. You need write the main part of of your computation in assemly language or some platform-independent wraper all by yourself. It speeds your computation more than multi-thread technique.
(3) CUDA/OpenCL or some thing call heterogeneous systems parallel computation maybe. It's really fast. It's hard for me to learn with little graphics computation architecture knowledge and you need a Nvidia card in your computer, it's make your software hard to deploy freely.
3 embedded computation : ASIC/FPGA or DSP processors. OK, I'm going far now ...

**lixo1** · 22nd March 2009, 13:33

Hi wysota,

Thank you very much for the example, now I understand what I have to do.
To start I will implement a QtConcurrent, to verify the needed time.
Thank you another time,
Cheers,
Louis

Thread: Maximum Speed Needed

Thread Tools

Search Thread

Display

Hybrid View

Re: Maximum Speed Needed

Re: Maximum Speed Needed

The following user says thank you to fullmetalcoder for this useful post:

Re: Maximum Speed Needed

The following user says thank you to wysota for this useful post:

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Re: Maximum Speed Needed

Similar Threads

how can i enhance the speed of drawing massive data graph by QGraphicsViewFrame

Axis's minimum and maximum

Bookmarks

Bookmarks

Posting Permissions