Mailinglist Archive: opensuse (4244 mails)

< Previous Next >
Re: [opensuse] OpenSUSE 10.3 benchmarking: slower than 10.2?
  • From: Lew Wolfgang <wolfgang@xxxxxxxxxxxxxxx>
  • Date: Sat, 13 Oct 2007 16:24:53 -0700
  • Message-id: <471153C5.6080100@xxxxxxxxxxxxxxx>
nordi wrote:
> Ian Smith wrote:
>> I've been doing some benchmarking of OpenSUSE using UnixBench 5.1.  I
>> noticed that 10.3 is 15% - 25% slower than 10.2.  (10.2 was 50% faster
>> than 10.1, yay!).
> The benchmark is really showing very strange numbers. The shell script
> benchmark (consisting mainly of sort and grep) is only _half_ as fast in
> 10.3 as in 10.2 in your measurements. I ran that test on my system and
> got similar results. Interestingly, the performance is much higher if I
> switch to runlevel 1!!! Here are my results for "./Run shell1" on a
> Pentium M at 1.3Ghz:

I didn't try Ian's benchmarks, but I did fiddle around
a bit with a floating-point intensive one that I've
been using for years.  It calculates very long FFT's
and displays the accuracy.

Bottom line is I didn't see any significant differences
between runlevels 1 and 5.  The benchmark ran in 8.7
seconds as measured by "time".

It did run a bit faster in 10.3 than 10.2.  However, this
wasn't a fair test since my 10.2 is 32-bit, my 10.3 64-bit
on the same computer.  Interesting nevertheless, and all
in runlevel 5.

10.2 (with 10.2 binary) 0m9.866s
10.3 (with 10.2 binary) 0m9.871s
10.3 (with 10.3 binary) 0m8.734s

Here are the particulars:

10.2
Linux train 2.6.18.8-0.5-bigsmp #1 SMP Fri Jun 22 12:17:53 UTC 2007 i686 i686 i386 GNU/Linux

10.3
Linux train 2.6.22.9-0.4-default #1 SMP 2007/10/05 21:32:04 UTC x86_64 x86_64 x86_64 GNU/Linux

10.2
real    0m9.866s
user    0m9.825s
sys     0m0.040s

10.3 (running 10.2 binary)
real    0m9.871s
user    0m9.813s
sys     0m0.060s

10.3 (running 10.3 binary)
real    0m8.734s
user    0m8.701s
sys     0m0.036s

Here's the source for the benchmark.  For the purposes
of this report, all versions were compiled:
gcc -O3 edelbench.c -lm

/* Dave Edelblut's Benchmark */
#include <math.h>
#include <time.h>
#define NP_MAX 8388608
/* #define NP_MAX 16777216 */
#define DATA_TYPE float
/* #define DATA_TYPE double */
typedef struct { DATA_TYPE r; DATA_TYPE i; } complex;

/*
       A Duhamel-Hollman split-radix dif fft
       Ref: Electronics Letters, Jan. 5, 1984
       Complex input and output data in arrays x and y
       Length is n
*/

int cfft( complex *x, int np )
{
int i,j,k,m,n,i0,i1,i2,i3,is,id,n1,n2,n4 ;
DATA_TYPE  a,e,a3,cc1,ss1,cc3,ss3,r1,r2,s1,s2,s3,xt ;
  x = x - 1;
  i = 2; m = 1; while (i < np) { i = i+i; m = m+1; };
  n = i; if (n != np) {
    for (i = np+1; i <= n; i++)  { x[i].r=0.0; x[i].i=0.0; };
    /* printf("\nuse %d point fft\n",n); */ }
  n2 = n+n;
  for (k = 1;  k <= m-1; k++ ) {
    n2 = n2 / 2; n4 = n2 / 4; e = 2.0 * M_PI / n2; a = 0.0;
    for (j = 1; j<= n4 ; j++) {
      a3 = 3.0*a; cc1 = cos(a); ss1 = sin(a);
      cc3 = cos(a3); ss3 = sin(a3); a = j*e; is = j; id = 2*n2;
          while ( is < n ) {
          for (i0 = is; i0 <= n-1; i0 = i0 + id) {
             i1 = i0 + n4; i2 = i1 + n4; i3 = i2 + n4;
             r1    = x[i0].r - x[i2].r;
             x[i0].r = x[i0].r + x[i2].r;
             r2    = x[i1].r - x[i3].r;
             x[i1].r = x[i1].r + x[i3].r;
             s1    = x[i0].i - x[i2].i;
             x[i0].i = x[i0].i + x[i2].i;
             s2    = x[i1].i - x[i3].i;
             x[i1].i = x[i1].i + x[i3].i;
             s3    = r1 - s2; r1 = r1 + s2; s2 = r2 - s1; r2 = r2 + s1;
             x[i2].r = r1*cc1 - s2*ss1;
             x[i2].i = -s2*cc1 - r1*ss1;
             x[i3].r = s3*cc3 + r2*ss3;
                     x[i3].i = r2*cc3 - s3*ss3;
         }
       is = 2*id - n2 + j; id = 4*id;
        }
    }
  }

  /*
---------------------Last stage, length=2 butterfly---------------------
*/
  is = 1; id = 4;
  while ( is < n) {
  for (i0 = is; i0 <= n; i0 = i0 + id) {
      i1 = i0 + 1; r1 = x[i0].r;
      x[i0].r = r1 + x[i1].r;
      x[i1].r = r1 - x[i1].r;
      r1 = x[i0].i;
      x[i0].i = r1 + x[i1].i;
      x[i1].i = r1 - x[i1].i;
    }
  is = 2*id - 1; id = 4 * id; }
  /*
c--------------------------Bit reverse counter
*/
  j = 1; n1 = n - 1;
  for (i = 1; i <= n1; i++) {
    if (i < j) {
          xt = x[j].r;
      x[j].r = x[i].r; x[i].r = xt;
      xt = x[j].i; x[j].i = x[i].i;
      x[i].i = xt;
    }
    k = n / 2; while (k < j) { j = j - k; k = k / 2; }
    j = j + k;
  }
  return(n);
  }


/*
program to test fast fourier transform in double precision;
*/

void main()
{
int i,j,ib,np,npm,n2,kr,ki;
double a,enp,t,rx,y,zr,zi,pi,el_t;
clock_t ct0,ct1,ct2,ctd;
static complex x[NP_MAX];

pi = M_PI;
np = 1024;
ct0 = clock();
      printf("\n fft benchmark - double precision - GNU C\n");
      while (np <= NP_MAX){
          printf("np =%7d",np);  enp = np; npm = np/2-1;  t = pi/enp;
          x[0].r = (enp - 1.0) / 2.0;  x[0].i = 0;
          n2 = np / 2;  x[n2].r = -0.5; x[n2].i = 0.0;
          for (i = 1; i <= npm; i++) {  j = np - i;
              x[i].r = -0.5; x[j].r = -0.5;
              y = t * i;  y = -cos(y)/sin(y)/2.0;
              x[i].i = y; x[j].i = -y;
          }
          ct1 = clock(); i = cfft(x,np); ct2 = clock(); ctd = ct2 - ct1;
          el_t = (double) ctd; el_t = el_t / CLOCKS_PER_SEC;
          printf("%6.1f sec   ",el_t);
          zr = 0.0; zi = 0.0; kr = 0; ki = 0; npm = np-1;
          for (i = 0; i <= npm; i++ ) {
              a = fabs(x[i].r - i );  if (zr < a) { zr = a; kr = i; }
              a = fabs(x[i].i);       if (zi < a) { zi = a; ki = i; }
          }
          printf("re %7d  %10.2g  im %7d  %10.2g\n",kr,zr,ki,zi);
          np = 2 * np;
      }

      ct2 = clock(); el_t = (ct2 - ct0);
      el_t = el_t / CLOCKS_PER_SEC;
      printf("The total run time was %6.1f sec.\n",el_t);
}


-- 
To unsubscribe, e-mail: opensuse+unsubscribe@xxxxxxxxxxxx
For additional commands, e-mail: opensuse+help@xxxxxxxxxxxx

< Previous Next >
References