This is the mail archive of the mailing list for the GCC project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH][i386] Properly scale vec_construct cost


currently vec_construct cost is simply TYPE_VECTOR_SUBPARTS / 2 + 1,
a reasonable estimate only of other target stmt costs are close to 1.
The idea was you need that many vector stmts thus the following patch
which should fix skewed costs for bdver2 for example with a
vec_stmt_cost of 6.

Fixing this gets important for a fix for PR62283 which will consider
building vectors up from parts during basic-block vectorization
and relies on the cost model to reject too expensive ones.
For example gcc.dg/vect/bb-slp-14.c will now be vectorized (with
the generic cost model and just SSE2) as

Cost model analysis:
  Vector inside of basic block cost: 2
  Vector prologue cost: 7
  Vector epilogue cost: 0
  Scalar cost of basic block: 10

        subq    $24, %rsp
        .cfi_def_cfa_offset 32
        movl    in+12(%rip), %eax
        testl   %edi, %edi
        movd    in+4(%rip), %xmm0
        movd    in(%rip), %xmm1
        movl    %eax, 12(%rsp)
        movd    in+4(%rip), %xmm4
        movd    12(%rsp), %xmm3
        movl    %edi, 12(%rsp)
        punpckldq       %xmm4, %xmm1
        punpckldq       %xmm3, %xmm0
        punpcklqdq      %xmm0, %xmm1
        movd    12(%rsp), %xmm0
        movl    %esi, 12(%rsp)
        movd    12(%rsp), %xmm5
        paddd   .LC2(%rip), %xmm1
        movdqa  %xmm1, %xmm2
        psrlq   $32, %xmm1
        punpckldq       %xmm5, %xmm0
        punpcklqdq      %xmm0, %xmm0
        pmuludq %xmm0, %xmm2
        psrlq   $32, %xmm0
        pmuludq %xmm1, %xmm0
        pshufd  $8, %xmm2, %xmm1
        pshufd  $8, %xmm0, %xmm0
        punpckldq       %xmm0, %xmm1
        movaps  %xmm1, out(%rip)
        je      .L12

vs. the scalar variant

        subq    $8, %rsp
        .cfi_def_cfa_offset 16
        movl    in(%rip), %edx
        movl    in+4(%rip), %eax
        movl    in+12(%rip), %ecx
        addl    $23, %edx
        imull   %edi, %edx
        leal    31(%rcx), %r8d
        movl    %edx, out(%rip)
        leal    142(%rax), %edx
        addl    $2, %eax
        imull   %edi, %eax
        imull   %esi, %edx
        movl    %eax, out+8(%rip)
        movl    %r8d, %eax
        imull   %esi, %eax
        testl   %edi, %edi
        movl    %edx, out+4(%rip)
        movl    %eax, out+12(%rip)
        je      .L12

Some excessive PRE across the conditional asm() keeps part
of the scalar computes live (yes, the cost model accounts
for that).  Previously we didn't vectorize the basic-block
because the loads from in[] could not be vectorized.  Now
we will build up a vector from the scalar loads.

The vectorized code is generated from

  <bb 2>:
  vect_cst_.19_43 = {x_10(D), y_13(D), x_10(D), y_13(D)};
  _3 = in[0];
  _5 = in[1];
  _8 = in[3];
  vect_cst_.16_47 = {_3, _5, _5, _8};
  vect_a0_4.15_42 = vect_cst_.16_47 + { 23, 142, 2, 31 };
  vect__11.18_44 = vect_a0_4.15_42 * vect_cst_.19_43;
  MEM[(unsigned int *)&out] = vect__11.18_44;

thus the code we generate for

  _3 = in[0];
  _5 = in[1];
  _8 = in[3];
  vect_cst_.16_47 = {_3, _5, _5, _8};

is quite bad.  It get's better for -mavx but I wonder where we
should try to optimize code generation for constructors...
(we can vectorize the loads by enhancing load permutation support,
of course - another vectorizer improvement I have some partial
patches for).

Well, anyway - below for the "obvoious" cost model patch.

Boostrapped on x86_64-unknown-linux-gnu, testing in progress.

Ok for trunk?


2015-04-21  Richard Biener  <>

	* config/i386/i386.c (ix86_builtin_vectorization_cost): Scale
	vec_construct cost by vec_stmt_cost.

Index: gcc/config/i386/i386.c
--- gcc/config/i386/i386.c	(revision 222230)
+++ gcc/config/i386/i386.c	(working copy)
@@ -46731,7 +46731,7 @@ ix86_builtin_vectorization_cost (enum ve
       case vec_construct:
 	elements = TYPE_VECTOR_SUBPARTS (vectype);
-	return elements / 2 + 1;
+	return ix86_cost->vec_stmt_cost * (elements / 2 + 1);
         gcc_unreachable ();

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]