From a270181e4059512728c286f6aff14219354cf0cf Mon Sep 17 00:00:00 2001 From: Razya Ladelsky Date: Mon, 29 Oct 2007 11:57:39 +0000 Subject: [PATCH] 2007-10-29 Razya Ladelsky Automatic parallelization reduction tests. * testsuite/gcc.dg/tree-ssa/reduc-1.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-1char.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-1short.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-2.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-2char.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-2short.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-3.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-6.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-7.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-8.c: New test. * testsuite/gcc.dg/tree-ssa/reduc-9.c: New test. From-SVN: r129718 --- gcc/ChangeLog | 20 ++++- gcc/testsuite/gcc.dg/tree-ssa/reduc-1.c | 57 ++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-1char.c | 52 +++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-1short.c | 52 +++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-2.c | 54 +++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-2char.c | 53 +++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-2short.c | 51 ++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-3.c | 42 ++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-6.c | 55 +++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-7.c | 82 ++++++++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-8.c | 80 +++++++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/reduc-9.c | 80 +++++++++++++++++++ 12 files changed, 676 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-1.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-1char.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-1short.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-2.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-2char.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-2short.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-3.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-6.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-7.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-8.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/reduc-9.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 309d865be6a..1de91aa54ae 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,4 +1,20 @@ -2007-09-23 Razya Ladelsky +2007-10-29 Razya Ladelsky + + Automatic parallelization reduction tests. + + * testsuite/gcc.dg/tree-ssa/reduc-1.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-1char.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-1short.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-2.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-2char.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-2short.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-3.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-6.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-7.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-8.c: New test. + * testsuite/gcc.dg/tree-ssa/reduc-9.c: New test. + +2007-10-29 Razya Ladelsky Zdenek Dvorak OMP_ATOMIC Changes, testsuite changes. @@ -11,7 +27,7 @@ * testsuite/g++.dg/gomp/atomic-9.C: Same. * testsuite/g++.dg/gomp/atomic-10.C: Same. -2007-09-23 Razya Ladelsky +2007-10-29 Razya Ladelsky Zdenek Dvorak OMP_ATOMIC Changes, diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-1.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-1.c new file mode 100644 index 00000000000..c7f53e1e50d --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-1.c @@ -0,0 +1,57 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 242 + +/* Reduction of unsigned-int. */ + +void main1 (unsigned int x, unsigned int max_result, unsigned int min_result) +{ + int i; + unsigned int ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + unsigned int uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + unsigned int udiff = 2; + unsigned int umax = x; + unsigned int umin = x; + + /* Summation. */ + for (i = 0; i < N; i++) { + udiff += (ub[i] - uc[i]); + } + + /* Maximum. */ + for (i = 0; i < N; i++) { + umax = umax < uc[i] ? uc[i] : umax; + } + + /* Minimum. */ + for (i = 0; i < N; i++) { + umin = umin > uc[i] ? uc[i] : umin; + } + + /* check results: */ + if (udiff != DIFF) + abort (); + if (umax != max_result) + abort (); + if (umin != min_result) + abort (); +} + +int main (void) +{ + + main1 (100, 100, 1); + main1 (0, 15, 0); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-1char.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-1char.c new file mode 100644 index 00000000000..87f758a4e46 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-1char.c @@ -0,0 +1,52 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 242 + +__attribute__ ((noinline)) void +main1 (unsigned char x, unsigned char max_result, unsigned char min_result) +{ + int i; + unsigned char ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + unsigned char uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + unsigned char udiff = 2; + unsigned char umax = x; + unsigned char umin = x; + + for (i = 0; i < N; i++) { + udiff += (unsigned char)(ub[i] - uc[i]); + } + + for (i = 0; i < N; i++) { + umax = umax < uc[i] ? uc[i] : umax; + } + + for (i = 0; i < N; i++) { + umin = umin > uc[i] ? uc[i] : umin; + } + + /* check results: */ + if (udiff != DIFF) + abort (); + if (umax != max_result) + abort (); + if (umin != min_result) + abort (); +} + +int main (void) +{ + main1 (100, 100, 1); + main1 (0, 15, 0); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-1short.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-1short.c new file mode 100644 index 00000000000..75d09544f8c --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-1short.c @@ -0,0 +1,52 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 242 + +__attribute__ ((noinline)) void +main1 (unsigned short x, unsigned short max_result, unsigned short min_result) +{ + int i; + unsigned short ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + unsigned short uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + unsigned short udiff = 2; + unsigned short umax = x; + unsigned short umin = x; + + for (i = 0; i < N; i++) { + udiff += (unsigned short)(ub[i] - uc[i]); + } + + for (i = 0; i < N; i++) { + umax = umax < uc[i] ? uc[i] : umax; + } + + for (i = 0; i < N; i++) { + umin = umin > uc[i] ? uc[i] : umin; + } + + /* check results: */ + if (udiff != DIFF) + abort (); + if (umax != max_result) + abort (); + if (umin != min_result) + abort (); +} + +int main (void) +{ + main1 (100, 100, 1); + main1 (0, 15, 0); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-2.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-2.c new file mode 100644 index 00000000000..d462f894f2e --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-2.c @@ -0,0 +1,54 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 240 + +/* Reduction of signed-int. */ + +__attribute__ ((noinline)) +void main1 (int x, int max_result, int min_result) +{ + int i; + int b[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + int c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + int diff = 0; + int max = x; + int min = x; + + for (i = 0; i < N; i++) { + diff += (b[i] - c[i]); + } + + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != min_result) + abort (); +} + +int main (void) +{ + main1 (100, 100, 1); + main1 (0, 15, 0); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-2char.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-2char.c new file mode 100644 index 00000000000..15acb3bcc9a --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-2char.c @@ -0,0 +1,53 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 121 + +__attribute__ ((noinline)) +void main1 (signed char x, signed char max_result, signed char min_result) +{ + int i; + signed char b[N] = {1,2,3,6,8,10,12,14,16,18,20,22,24,26,28,30}; + signed char c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + signed char diff = 2; + signed char max = x; + signed char min = x; + + for (i = 0; i < N; i++) { + diff += (signed char)(b[i] - c[i]); + } + + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != min_result) + abort (); +} + +int main (void) +{ + main1 (100, 100, 1); + main1 (0, 15, 0); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-2short.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-2short.c new file mode 100644 index 00000000000..f98402ee251 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-2short.c @@ -0,0 +1,51 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 242 + +__attribute__ ((noinline)) +void main1 (short x, short max_result, short min_result) +{ + int i; + short b[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + short c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + short diff = 2; + short max = x; + short min = x; + + for (i = 0; i < N; i++) { + diff += (short)(b[i] - c[i]); + } + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != min_result) + abort (); +} + +int main (void) +{ + main1 (100, 100, 1); + main1 (0, 15, 0); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-3.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-3.c new file mode 100644 index 00000000000..31ed2bc11c2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-3.c @@ -0,0 +1,42 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 + +/* Reduction of unsigned-int. */ + +__attribute__ ((noinline)) +int main1 (int n, int res) +{ + int i; + unsigned int ub[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + unsigned int uc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + unsigned int udiff; + + udiff = 0; + for (i = 0; i < n; i++) { + udiff += (ub[i] - uc[i]); + } + + /* check results: */ + if (udiff != res) + abort (); + + return 0; +} + +int main (void) +{ + main1 (N, 240); + main1 (N-1, 210); + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 1 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 1 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-6.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-6.c new file mode 100644 index 00000000000..b3a28a965b5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-6.c @@ -0,0 +1,55 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include +#include + +#define N 16 +#define DIFF 242 + +__attribute__ ((noinline)) +int main1 (float x, float max_result) +{ + int i; + float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; + float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + float diff = 2; + float max = x; + float min = 10; + + for (i = 0; i < N; i++) { + diff += (b[i] - c[i]); + } + + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != 0) + abort (); + + return 0; +} + +int main (void) +{ + main1 (100 ,100); + main1 (0, 15); + return 0; +} + +/* need -ffast-math to parallelize these loops. */ +/* { dg-final { scan-tree-dump-times "Detected reduction" 0 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 0 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "FAILED: it is not a part of reduction" 3 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-7.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-7.c new file mode 100644 index 00000000000..90bbc9806c7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-7.c @@ -0,0 +1,82 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include + +#define N 32 + +extern void abort (void); +typedef unsigned char T; + +__attribute__ ((noinline)) void +testmax (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum < lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +__attribute__ ((noinline)) void +testmin (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum > lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +int main (void) +{ + static unsigned char const A[N] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f + }; + + static unsigned char const B[N] = { + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f + }; + + static unsigned char const C[N] = { + 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + }; + + + testmin (A, 10, 1); + testmin (B, 0x7f, 0x70); + testmin (C, 0x7f, 0x09); + + testmax (A, 0, 0x7f); + testmax (B, 0, 0x8f); + testmax (C, 0, 0xff); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-8.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-8.c new file mode 100644 index 00000000000..4801dc782cc --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-8.c @@ -0,0 +1,80 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include + +#define N 32 + +extern void abort (void); +typedef signed char T; + +__attribute__ ((noinline)) void +testmax (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum < lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +__attribute__ ((noinline)) void +testmin (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum > lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +int main (void) +{ + static signed char const A[N] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f + }; + + static signed char const B[N] = { + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f + }; + + static signed char const C[N] = { + 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + }; + + testmin (A, 0, 0); + testmin (B, 0, 0x80); + testmin (C, 0, 0x80); + + testmax (A, 0, 0x7f); + testmax (B, 0, 0x7f); + testmax (C, 0, 0x77); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reduc-9.c b/gcc/testsuite/gcc.dg/tree-ssa/reduc-9.c new file mode 100644 index 00000000000..68ed1de6175 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/reduc-9.c @@ -0,0 +1,80 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */ + +#include + +#define N 32 + +extern void abort (void); +typedef unsigned short T; + +__attribute__ ((noinline)) void +testmax (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum < lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +__attribute__ ((noinline)) void +testmin (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum > lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +int main (void) +{ + static unsigned short const A[N] = { + 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, + 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, + 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, + 0x7ff8, 0x7ff9, 0x7ffa, 0x7ffb, 0x7ffc, 0x7ffd, 0x7ffe, 0x7fff + }; + + static unsigned short const B[N] = { + 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, + 0x7ff8, 0x7ff9, 0x7ffa, 0x7ffb, 0x7ffc, 0x7ffd, 0x7ffe, 0x7fff, + 0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007, + 0x8008, 0x8009, 0x800a, 0x800b, 0x800c, 0x800d, 0x800e, 0x800f + }; + + static unsigned short const C[N] = { + 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9, 0xfff8, + 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, + 0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007, + 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, + }; + + testmin (A, 10, 1); + testmin (B, 0x7fff, 0x7000); + testmin (C, 0x7fff, 0x0009); + + testmax (A, 0, 0x7fff); + testmax (B, 0, 0x800f); + testmax (C, 0, 0xffff); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "final_cleanup" } } */