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
This commit is contained in:
Razya Ladelsky
parent
e19149bfb0
commit
a270181e40
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -0,0 +1,57 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
/* { dg-do compile } */
|
||||
/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#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" } } */
|
||||
Loading…
Reference in New Issue