[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[pinskia at gcc dot gnu dot org]

------- Comment #31 from pinskia at gcc dot gnu dot org  2005-10-27 00:47 -------
(In reply to comment #30)
> This patch could help; I need to benchmark it before submitting it.

Any news about this patch?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[mmitchel at gcc dot gnu dot org]

------- Comment #32 from mmitchel at gcc dot gnu dot org  2005-10-31 02:39 -------
Leaving as P2 as this is a significant pessimization on a significant piece of
code on relatively common processors.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[steven at gcc dot gnu dot org]

------- Comment #33 from steven at gcc dot gnu dot org  2005-11-16 09:42 -------
Zdenek, any news about your patch from comment #30?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rakdver at gcc dot gnu dot org]

------- Comment #34 from rakdver at gcc dot gnu dot org  2005-11-17 13:35 -------
It behaves somewhat erratically on SPEC2000 (it increases the overall score,
but there are some significant regressions).  And, it also causes us to produce
worse code for this testcase at the moment, due to a missunderstanding between
ivopts and fold; expression 

(unsigned char) (signed char) (int) (ptr + 1B) - (unsigned char) ptr

is produced, and it is not folded to 1.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rakdver at gcc dot gnu dot org]

------- Comment #35 from rakdver at gcc dot gnu dot org  2005-11-17 15:09 -------
Created an attachment (id=10263)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=10263&action=view)
Patch

After some playing with fold, I arrived to the following patch, that almost
works.  With the patch, the code for the loop is

<L0>:;
  MEM[base: ptr]{*ptr} = cleanse_ctr;
  ptr = ptr + 1B;
  cleanse_ctr = (unsigned char) (((signed char) ptr & 15) + (signed char)
cleanse_ctr + 17);
  len = len - 1;
  if (len != 0) goto <L0>; else goto <L2>;

Which seems just fine.  The assembler is

.L3:
        movb    (%edi), %al
        movb    %al, (%ecx)
        incl    %ecx
        movb    %cl, %al
        andl    $15, %eax
        movb    (%edi), %dl
        addl    $17, %edx
        addl    %edx, %eax
        movb    %al, (%edi)
        decl    %esi
        jne     .L3

Which also seems OK to me.  However, the "ugly" version we produce without the
patch:

.L4:
        movb    (%edi), %al
        movb    %al, (%ecx)
        incl    %ecx
        movb    -16(%ebp), %al
        addl    %esi, %eax
        andl    $15, %eax
        movb    (%edi), %dl
        addl    $17, %edx
        addl    %edx, %eax
        movb    %al, (%edi)
        incl    %esi
        cmpl    12(%ebp), %esi
        jne     .L4

Is faster by 30%, from reasons I just don't understand :-(


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[mmitchel at gcc dot gnu dot org]

------- Comment #36 from mmitchel at gcc dot gnu dot org  2006-02-24 00:25 -------
This issue will not be resolved in GCC 4.1.0; retargeted at GCC 4.1.1.


-- 

mmitchel at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.0.3                       |4.1.1


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[mmitchel at gcc dot gnu dot org]

------- Comment #37 from mmitchel at gcc dot gnu dot org  2006-05-25 02:32 -------
Will not be fixed in 4.1.1; adjust target milestone to 4.1.2.


-- 

mmitchel at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.1.1                       |4.1.2


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[pinskia at gcc dot gnu dot org]

------- Comment #38 from pinskia at gcc dot gnu dot org  2006-08-27 21:07 -------
For the reduced testcase in comment #12, we get:
.L2:
        movl    8(%ebp), %edx
        movl    -4(%edx,%ecx,4), %eax
        movl    %eax, (%esi)
        movl    16(%ebp), %edi
        movzbl  -1(%ecx,%edi), %edx
        movl    %edx, 64(%esi)
        xorl    %edx, %eax
        movl    %eax, 128(%esi)
        movl    12(%ebp), %edi
        movl    -4(%edi,%ecx,4), %eax
        xorl    -16(%ebp), %edx
        xorl    S@GOTOFF(%ebx,%edx,4), %eax
        movl    %eax, -4(%edi,%ecx,4)
        movl    %eax, -16(%ebp)
        addl    $1, %ecx
        addl    $4, %esi
        cmpl    $17, %ecx
        jne     .L2


Does someone know if this ok produced code or not, I never a good reader of x86
code?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[mmitchel at gcc dot gnu dot org]

-- 

mmitchel at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.1.2                       |4.1.3


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[pinskia at gcc dot gnu dot org]

------- Comment #39 from pinskia at gcc dot gnu dot org  2007-07-04 21:53 -------
I think this has been imrpvoed for 4.3, it would be nice if someone did some
timings for 4.3.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[steven at gcc dot gnu dot org]

------- Comment #40 from steven at gcc dot gnu dot org  2007-11-19 10:04 -------
Can someone please redo the timings for GCC 4.3?


-- 

steven at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |WAITING


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Comment #41 from dank at kegel dot com  2007-11-19 12:27 -------
OK, I'll see if I can get that done.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dsh at gcc dot gnu dot org]

------- Comment #42 from dsh at gcc dot gnu dot org  2007-11-28 17:19 -------
Created an attachment (id=14656)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=14656&action=view)
Benchmarks

I ran the benchmarks for the minimal testcase (using Dan Kegel's script) on a
Core 2 Duo, AMD Dual Core Opteron, and a Pentium 3 using GCC 2.95.3, 3.4.3,
4.0.1, and 4.3.0 from svn.  I'm still looking for a Pentium 4 to test on.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Comment #43 from dank at kegel dot com  2007-11-28 18:01 -------
Of the results posted above, the only interesting one that is still slower 
than gcc-2.95 is a pentium 3 with -fPIC.
(Happily, gcc-4.3 is an improvement there, but it's still worse than 2.95.)
Oddly, this one does better with athlon-xp tuning.

/proc/cpuinfo info                                       pic?   tune           
[t_34/t_295, t_401/t_295, t_43/t_295]
cpu family 6,model 11, Intel(R) Pentium(R) III CPU - S 1266MHz, -fPIC
tune=pentium3   [1.37, 1.72, 1.20]

cpu family 6,model 11, Intel(R) Pentium(R) III CPU - S 1266MHz, -fPIC
tune=athlon-xp [2.16, 2.49, 1.10]

I'm not sure how important Pentium III performance is anymore.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2/4.3 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rguenth at gcc dot gnu dot org]

-- 

rguenth at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|WAITING                     |NEW
   Last reconfirmed|2005-06-01 22:55:36         |2008-01-25 20:57:23
               date|                            |


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1/4.2 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rguenth at gcc dot gnu dot org]

------- Comment #44 from rguenth at gcc dot gnu dot org  2008-01-26 13:46 -------
Fixed for 4.3.  WONTFIX for the branches.


-- 

rguenth at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
         Resolution|                            |FIXED
            Summary|[4.0/4.1/4.2/4.3 Regression]|[4.0/4.1/4.2 Regression]
                   |openssl is slower when      |openssl is slower when
                   |compiled with gcc 4.0 than  |compiled with gcc 4.0 than
                   |3.3                         |3.3
   Target Milestone|4.1.3                       |4.3.0


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[mmitchel at gcc dot gnu dot org]

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.0.2                       |4.0.3


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rakdver at atrey dot karlin dot mff dot cuni dot cz]

------- Additional Comments From rakdver at atrey dot karlin dot mff dot cuni dot cz  2005-06-25 11:32 -------
Subject: Re:  [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

> ------- Additional Comments From steven at gcc dot gnu dot org  2005-06-25 10:15 -------
> Re. comment #25, as far as I can tell there are registers available in 
> that loop.  To quote the loop from comment #12: 
>  
> .L4:     
>         movb    (%esi), %al 
>         movb    %al, (%edx) 
>         leal    (%ecx,%edi), %eax 
>         andl    $15, %eax 
>         incl    %ecx 
>         addb    (%esi), %al 
>         incl    %edx 
>         addl    $17, %eax 
>         cmpl    %ecx, 12(%ebp) 
>         movb    %al, (%esi) 
>         jne     .L4 
>  
> Checking off used registers in this loop: 
> %esi x 
> %edi x 
> %eax x 
> %ebx 
> %ecx x 
> %edx x 
>  
> So %ebx at least is free (and iiuc, with -fomit-frame-pointer %ebp is 
> also free, right?).  Maybe the allocator thinks %ebx can't be used 
> because it is the PIC register. 

yes, ebx cannot be used because of pic, and -fomit-frame-pointer is off
by default.

> Here is what mainline today ("GCC: (GNU) 4.1.0 20050625 (experimental)") 
> gives me (x86-64 compiler with "-m32 -march=i686 -O3 -fPIC"): 
>  
> .L4: 
>         movzbl  (%esi), %eax 
>         movb    %al, (%ecx) 
>         incl    %ecx 
>         movzbl  -13(%ebp), %eax 
>         movzbl  (%esi), %edx 
>         incb    -13(%ebp) 
>         andb    $15, %al 
>         addb    $17, %dl 
>         addb    %dl, %al 
>         cmpl    %edi, %ecx 
>         movb    %al, (%esi) 
>         jne     .L4 
>  
> The .optimized tree dump looks like this: 
>  
> <bb 0>: 
>   len.23 = len - 1; 
>   if (len.23 != 4294967295) goto <L6>; else goto <L2>; 

> And the first two lines are 
> also just weird, it is probably cheaper on almost any machine to do 
>   len.23 = len; 
>   if (len.23 != 0) goto <L6>; else goto <L2>; 
>  
> <L6>: 
>   len.23 = len.23 - 1; 
>   (etc...) 

Not really.  On i686, there should be no difference.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[steven at gcc dot gnu dot org]

------- Additional Comments From steven at gcc dot gnu dot org  2005-06-25 10:15 -------
Re. comment #25, as far as I can tell there are registers available in 
that loop.  To quote the loop from comment #12: 
 
.L4:     
        movb    (%esi), %al 
        movb    %al, (%edx) 
        leal    (%ecx,%edi), %eax 
        andl    $15, %eax 
        incl    %ecx 
        addb    (%esi), %al 
        incl    %edx 
        addl    $17, %eax 
        cmpl    %ecx, 12(%ebp) 
        movb    %al, (%esi) 
        jne     .L4 
 
Checking off used registers in this loop: 
%esi x 
%edi x 
%eax x 
%ebx 
%ecx x 
%edx x 
 
So %ebx at least is free (and iiuc, with -fomit-frame-pointer %ebp is 
also free, right?).  Maybe the allocator thinks %ebx can't be used 
because it is the PIC register. 
 
Here is what mainline today ("GCC: (GNU) 4.1.0 20050625 (experimental)") 
gives me (x86-64 compiler with "-m32 -march=i686 -O3 -fPIC"): 
 
.L4: 
        movzbl  (%esi), %eax 
        movb    %al, (%ecx) 
        incl    %ecx 
        movzbl  -13(%ebp), %eax 
        movzbl  (%esi), %edx 
        incb    -13(%ebp) 
        andb    $15, %al 
        addb    $17, %dl 
        addb    %dl, %al 
        cmpl    %edi, %ecx 
        movb    %al, (%esi) 
        jne     .L4 
 
The .optimized tree dump looks like this: 
 
<bb 0>: 
  len.23 = len - 1; 
  if (len.23 != 4294967295) goto <L6>; else goto <L2>; 
 
<L6>:; 
  ivtmp.19 = (unsigned char) (signed char) (int) (ptr + 1B); 
  ptr.27 = ptr; 
 
<L0>:; 
  MEM[base: ptr.27] = cleanse_ctr; 
  ptr.27 = ptr.27 + 1B; 
  cleanse_ctr = (unsigned char) (((signed char) ivtmp.19 & 15) 
                                 + (signed char) cleanse_ctr + 17); 
  ivtmp.19 = ivtmp.19 + 1; 
  if (ptr.27 != (unsigned char *) (ptr + (void *) len.23 + 1B)) goto <L0>; 
else goto <L2>; 
 
<L2>:; 
  cleanse_ctr = (unsigned char) ((signed char) cleanse_ctr + 63); 
  return; 
 
Note how the loop test is against ptr.  Also, as far as I can tell the 
right hand side of the test (i.e. "(ptr + (void *) len.23 + 1B)") is loop 
invariant and should have been moved out.  And the first two lines are 
also just weird, it is probably cheaper on almost any machine to do 
 
  len.23 = len; 
  if (len.23 != 0) goto <L6>; else goto <L2>; 
 
<L6>: 
  len.23 = len.23 - 1; 
  (etc...) 
 
In summary, we just produce crap code here ;-) 
 
 

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rakdver at gcc dot gnu dot org]

------- Additional Comments From rakdver at gcc dot gnu dot org  2005-06-25 02:49 -------
Ivopts seem to do several quite doubtful decisions in this testcase.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot gnu   |rakdver at gcc dot gnu dot
                   |dot org                     |org
             Status|NEW                         |ASSIGNED


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dann at godzilla dot ics dot uci dot edu]

------- Additional Comments From dann at godzilla dot ics dot uci dot edu  2005-06-24 17:41 -------
(In reply to comment #21)

> The slow routine appears to be the buffer cleaning routine,
> though I haven't verified this with oprofile yet.
> Here's its loop:
> static char cleanse_ctr;
> ...
>     while (len--) {
>         *(ptr++) = cleanse_ctr;
>         cleanse_ctr += (17 + (unsigned char) ((int) ptr & 0xF));
>     }

[Not entirely related, but..] There's one obvious way to improve this loop. 
The compiler cannot prove that the write *(ptr++) does not alias the global
variable cleanse_ptr, so it will read it from memory in each iteration.
To avoid the extra memory read just do something like:

void OPENSSL_cleanse(unsigned char *ptr, unsigned int len)
{
  unsigned char local_cleanse_ctr = cleanse_ctr;
  while (len--) {
        *(ptr++) = local_cleanse_ctr;
        local_cleanse_ctr += (17 + (unsigned char) ((int) ptr & 0xF));
    }
  local_cleanse_ctr += 63;
  cleanse_ctr = local_cleanse_ctr;  
}


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[rakdver at atrey dot karlin dot mff dot cuni dot cz]

------- Additional Comments From rakdver at atrey dot karlin dot mff dot cuni dot cz  2005-06-24 16:24 -------
Subject: Re:  [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

> I don't see how the precious register would matter much.  But this compare 
> with memory is strange: 
>  
>         cmpl    %ecx, 12(%ebp) 
>  
> Why isn't len loaded into a register?? 

You answer your own question -- because there is no register free;
that's why the precisious register maters that much.

(I guess; I may be wrong).

Zdenek


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[steven at gcc dot gnu dot org]

------- Additional Comments From steven at gcc dot gnu dot org  2005-06-24 15:53 -------
I don't see how the precious register would matter much.  But this compare 
with memory is strange: 
 
        cmpl    %ecx, 12(%ebp) 
 
Why isn't len loaded into a register?? 

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-24 15:01 -------
And, for what it's worth, the latest 4.1 snapshot also suffers from this.



-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-24 15:00 -------
Michael Meissner looked at the code, and saw that
gcc-2.95.3 converts the loop to a countdown loop,
but gcc-3.x doesn't, which wastes a precious register.

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-18 22:45 -------
I asked the fellow who posted the original problem report to give
me the results of 'cat /proc/cpuinfo' on the affected machine.
Here it is:

vendor_id       : GenuineIntel
cpu family      : 6
model           : 8
model name      : Pentium III (Coppermine)
stepping        : 10
cpu MHz         : 896.153

This is the same as one of the two affected CPU types here.

The slow routine appears to be the buffer cleaning routine,
though I haven't verified this with oprofile yet.
Here's its loop:
static char cleanse_ctr;
...
    while (len--) {
        *(ptr++) = cleanse_ctr;
        cleanse_ctr += (17 + (unsigned char) ((int) ptr & 0xF));
    }
and the output of -O3 -fPIC for both gcc-2.95.3 and gcc-4.0.0:

--- gcc-2.95.3 ---
.L5:    
        movl cleanse_ctr@GOT(%ebx),%edi
        movb (%edi),%al
        movb %al,(%edx)
        incl %edx
        movb (%edi),%cl
        addb $17,%cl
        movb %dl,%al
        andb $15,%al
        addb %al,%cl
        movb %cl,(%edi)
        subl $1,%esi
        jnc .L5
.L4:

--- gcc-4 ---    
.L4:    
        movb    (%esi), %al
        movb    %al, (%edx)
        leal    (%ecx,%edi), %eax
        andl    $15, %eax
        incl    %ecx
        addb    (%esi), %al
        incl    %edx
        addl    $17, %eax
        cmpl    %ecx, 12(%ebp)
        movb    %al, (%esi)
        jne     .L4

It's not obvious to me why the gcc-4.0.0 generated code
should be slower when run on some CPUs, if in fact it is.
Is it the fact that the loop condition is checked with
a cmp against memory instead of a flag being set by subtracting
1 from a register?

(And where's the best place to learn about how to predict
how long assembly snippets like this will take to run
on various modern CPUs, anyway?)


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-18 17:46 -------
The above tests did not use -mcpu on gcc-2.95.3,
so they were comparing apples to oranges, kind of.

I reran them on a PIII with gcc-2.95.3 -mcpu=$tune -O3 
and gcc-[34] -mtune=$tune -O3.  The problem persists
even when using the most appropriate tuning option
for the CPU in question.

cpu family 6,model 8, Pentium III (Coppermine):
-fPIC -mcpu=pentium -O3 
gcc-2.95.3: 7.61
gcc-3.4.3: 27.43
gcc-4.0.0: 17.57

cpu family 6,model 8, Pentium III (Coppermine):
-fPIC -mcpu=pentiumpro -O3
gcc-2.95.3: 9.27
gcc-3.4.3: 10.09
gcc-4.0.0: 13.96

cpu family 15, model 2, Intel(R) Xeon(TM) CPU 2.60GHz:
-fPIC -mtune=pentium4 -O3 
gcc-2.95.3: 1.91 seconds
gcc-3.4.3:  3.89
gcc-4.0.0:  3.27



-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-18 06:38 -------
To be clear, here are the two most worrying rows from the above table,
expanded a bit.  These are the runtimes of foo4.i in seconds.
The cpu family, model, and name are as shown by /proc/cpuinfo.

cpu family 15, model 2, Intel(R) Xeon(TM) CPU 2.60GHz:
-fPIC -mtune=pentium4 -O3 
gcc-2.95.3: 1.91 seconds
gcc-3.4.3:  3.89
gcc-4.0.0:  3.27

cpu family 6, model 8, Pentium III (Coppermine)
-fPIC -mtune=pentium3 -O3
gcc-2.95.3: 9.15
gcc-3.4.3: 10.10
gcc-4.0.0: 13.20

gcc-4.0.0 produces code that runs 1.7 and 1.4 times slower than gcc-2.95.3
on these (fairly common!) cpus, even when the proper -mtune is used.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-18 06:24 -------
Looks to me like gcc-3.4.3 is known to fail, too, depending on the CPU.
Anthony Danalis and I came up with a little script to run foo4.i
on various processors with various values for -mtune, which I'll
attach; here are the results for four different x86 variants.

The last two columns are the time on gcc-3.4.3 and gcc-4.0.0
divided by the time on gcc-2.95.3, so any value above 1.0 in
the last column is a performance regression.  
Rows are sorted by the last column.  The first five
rows represent performance regressions for gcc-3.4.3;
the first three also represent performance regressions
for gcc-4.0.0.

family,model,name               pic?  tune      [t_295, t_343, t_400]
[t_295/t_295, t_343/t_295, t_400/t_295]

6,8, Pentium III (Coppermine),  -fPIC athlon-xp [9.25, 16.22, 18.79]  [1.00,
1.75, 2.03]
15,2, Xeon(TM) CPU 2.60GHz,     -fPIC pentium4  [1.91, 3.89, 3.27]    [1.00,
2.04, 1.71]
6,8, Pentium III (Coppermine),  -fPIC pentium3  [9.15, 10.10, 13.20]  [1.00,
1.10, 1.44]
15,2, Xeon(TM) CPU 2.60GHz,     -fPIC athlon-xp [1.91, 2.00, 1.95]    [1.00,
1.05, 1.02]
6,8, Pentium III (Coppermine),  -fPIC pentium4  [9.27, 10.49,  8.87]  [1.00,
1.13, 0.96]

--- ok below this line ---

6,8, Pentium III (Coppermine),        pentium4  [14.74, 13.71, 14.12] [1.00,
0.93, 0.96]
15,4, Athlon(tm) 64 3000+,      -fPIC pentium4  [4.12, 3.68, 3.74]    [1.00,
0.89, 0.91]
15,4, Pentium(R) 4 CPU 3.20GHz, -fPIC pentium4  [2.48, 2.18, 2.09]    [1.00,
0.88, 0.84]
15,4, Athlon(tm) 64 3000+,      -fPIC athlon-xp [4.12, 3.50, 3.20]    [1.00,
0.85, 0.78]
15,4, Pentium(R) 4 CPU 3.20GHz,       pentium4  [2.17, 1.07, 1.07]    [1.00,
0.49, 0.49]
6,8, Pentium III (Coppermine),        pentium3  [14.22,  6.26,  6.46] [1.00,
0.44, 0.45]
6,8, Pentium III (Coppermine),        athlon-xp [14.93,  6.26,  6.27] [1.00,
0.42, 0.42]
15,4, Athlon(tm) 64 3000+,            pentium4  [3.65, 1.39, 1.39]    [1.00,
0.38, 0.38]
15,4, Athlon(tm) 64 3000+,            athlon-xp [3.65, 1.39, 1.40]    [1.00,
0.38, 0.38]
15,2, Xeon(TM) CPU 2.60GHz,           pentium4  [6.42, 0.97, 0.98]    [1.00,
0.15, 0.15]


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2005-06-17 01:10 -------
(In reply to comment #14)
> We're learning more about this bug.
> Anthony Danalis has boiled down the testcase much further;
> I'll attach the reduced testcase as foo4.i.

Yes you know what the difference is between those two, the second one is not really a P4 but really a 
new core, Intel marketing at its best.

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[dank at kegel dot com]

------- Additional Comments From dank at kegel dot com  2005-06-17 00:59 -------
We're learning more about this bug.
Anthony Danalis has boiled down the testcase much further;
I'll attach the reduced testcase as foo4.i.

It looks like it shows up if your /proc/cpuinfo says

vendor_id       : GenuineIntel
cpu family      : 15
model           : 2
model name      : Intel(R) Pentium(R) 4 CPU 2.80GHz
stepping        : 9
cpu MHz         : 2793.051
cache size      : 512 KB

but not if your /proc/cpuinfo says
vendor_id       : GenuineIntel
cpu family      : 15
model           : 4
model name      : Intel(R) Pentium(R) 4 CPU 3.20GHz
stepping        : 1
cpu MHz         : 3200.255
cache size      : 1024 KB

But here's the fun part: on the newer CPU with the bigger
cache, gcc-2.95.3 was just as slow as gcc-3.4.3/gcc-4.0.0.
Go figure.

We'll add more details once we've got more info.



-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923

[Bug target/19923] [4.0/4.1 Regression] openssl is slower when compiled with gcc 4.0 than 3.3

[giovannibajo at libero dot it]

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|openssl is slower when      |[4.0/4.1 Regression] openssl
                   |compiled with gcc 4.0 than  |is slower when compiled with
                   |3.3                         |gcc 4.0 than 3.3
   Target Milestone|---                         |4.0.2


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19923