omp_parallel_sections_reduction.c | Explore in Territory

// RUN: %libomp-compile-and-run
#include <stdio.h>
#include <math.h>
#include "omp_testsuite.h"

int test_omp_parallel_sections_reduction()
{
  int sum;
  int known_sum;
  double dpt;
  double dsum;
  double dknown_sum;
  double dt=0.5; /* base of geometric row for + and - test*/
  double rounding_error= 1.E-5;
  int diff;
  double ddiff;
  int product;
  int known_product;
  int logic_and;
  int bit_and;
  int logic_or;
  int bit_or;
  int exclusiv_bit_or;
  int logics[1000];
  int i;
  int result;

  sum = 7;
  dsum=0;
  product =1;
  dpt = 1;
  logic_and=1;
  bit_and=1;
  logic_or=0;
  bit_or=0;
  exclusiv_bit_or=0;
  result =0;
  /*  int my_islarger;*/
  /*int is_larger=1;*/

  // Test summation of integers
  known_sum = (999*1000)/2+7;
  #pragma omp parallel sections private(i) reduction(+:sum)
  {
    #pragma omp section
    {
      for (i=1;i<300;i++) {
        sum=sum+i;
      }
    }
    #pragma omp section
    {
      for (i=300;i<700;i++) {
        sum=sum+i;
      }
    }
    #pragma omp section
    {
      for (i=700;i<1000;i++) {
        sum=sum+i;
      }
    }
  }
  if(known_sum!=sum) {
    result++;
    fprintf(stderr,"Error in sum with integers: Result was %d"
      " instead of %d.\n",sum, known_sum);
  }

  // Test differences of integers
  diff = (999*1000)/2;
  #pragma omp parallel sections private(i) reduction(-:diff)
  {
    #pragma omp section
    {
      for (i=1;i<300;i++) {
        diff=diff-i;
      }
    }
    #pragma omp section
    {
      for (i=300;i<700;i++) {
        diff=diff-i;
      }
    }
    #pragma omp section
    {
      for (i=700;i<1000;i++) {
        diff=diff-i;
      }
    }
  }
  if(diff != 0) {
    result++;
    fprintf(stderr,"Error in Difference with integers: Result was %d"
      " instead of 0.\n",diff);
  }

  // Test summation of doubles
  for (i=0;i<20;++i) {
    dpt*=dt;
  }
  dknown_sum = (1-dpt)/(1-dt);
  #pragma omp parallel sections private(i) reduction(+:dsum)
  {
    #pragma omp section
    {
      for (i=0;i<6;++i) {
        dsum += pow(dt,i);
      }
    }
    #pragma omp section
    {
      for (i=6;i<12;++i) {
        dsum += pow(dt,i);
      }
    }
    #pragma omp section
    {
      for (i=12;i<20;++i) {
        dsum += pow(dt,i);
      }
    }
  }
  if( fabs(dsum-dknown_sum) > rounding_error ) {
    result++;
    fprintf(stderr,"Error in sum with doubles: Result was %f"
      " instead of %f (Difference: %E)\n",
      dsum, dknown_sum, dsum-dknown_sum);
  }

  // Test differences of doubles
  dpt=1;
  for (i=0;i<20;++i) {
    dpt*=dt;
  }
  fprintf(stderr,"\n");
  ddiff = (1-dpt)/(1-dt);
  #pragma omp parallel sections private(i) reduction(-:ddiff)
  {
    #pragma omp section
    {
      for (i=0;i<6;++i) {
        ddiff -= pow(dt,i);
      }
    }
    #pragma omp section
    {
      for (i=6;i<12;++i) {
        ddiff -= pow(dt,i);
      }
    }
    #pragma omp section
    {
      for (i=12;i<20;++i) {
        ddiff -= pow(dt,i);
      }
    }
  }
  if( fabs(ddiff) > rounding_error) {
    result++;
    fprintf(stderr,"Error in Difference with doubles: Result was %E"
      " instead of 0.0\n",ddiff);
  }

  // Test product of integers
  known_product = 3628800;
  #pragma omp parallel sections private(i) reduction(*:product)
  {
    #pragma omp section
    {
      for(i=1;i<3;i++) {
        product *= i;
      }
    }
    #pragma omp section
    {
      for(i=3;i<7;i++) {
        product *= i;
      }
    }
    #pragma omp section
    {
      for(i=7;i<11;i++) {
        product *= i;
      }
    }
  }
  if(known_product != product) {
    result++;
    fprintf(stderr,"Error in Product with integers: Result was %d"
      " instead of %d\n",product,known_product);
  }

  // Test logical AND
  for(i=0;i<1000;i++) {
    logics[i]=1;
  }

  #pragma omp parallel sections private(i) reduction(&&:logic_and)
  {
    #pragma omp section
    {
      for (i=1;i<300;i++) {
        logic_and = (logic_and && logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=300;i<700;i++) {
        logic_and = (logic_and && logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=700;i<1000;i++) {
        logic_and = (logic_and && logics[i]);
      }
    }
  }
  if(!logic_and) {
    result++;
    fprintf(stderr,"Error in logic AND part 1\n");
  }
  logic_and = 1;
  logics[501] = 0;

  #pragma omp parallel sections private(i) reduction(&&:logic_and)
  {
    #pragma omp section
    {
      for (i=1;i<300;i++) {
        logic_and = (logic_and && logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=300;i<700;i++) {
        logic_and = (logic_and && logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=700;i<1000;i++) {
        logic_and = (logic_and && logics[i]);
      }
    }
  }
  if(logic_and) {
    result++;
    fprintf(stderr,"Error in logic AND part 2");
  }

  // Test logical OR
  for(i=0;i<1000;i++) {
    logics[i]=0;
  }

  #pragma omp parallel sections private(i) reduction(||:logic_or)
  {
    #pragma omp section
    {
      for (i=1;i<300;i++) {
        logic_or = (logic_or || logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=300;i<700;i++) {
        logic_or = (logic_or || logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=700;i<1000;i++) {
        logic_or = (logic_or || logics[i]);
      }
    }
  }
  if(logic_or) {
    result++;
    fprintf(stderr,"Error in logic OR part 1\n");
  }

  logic_or = 0;
  logics[501]=1;

  #pragma omp parallel sections private(i) reduction(||:logic_or)
  {
    #pragma omp section
    {
      for (i=1;i<300;i++) {
        logic_or = (logic_or || logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=300;i<700;i++) {
        logic_or = (logic_or || logics[i]);
      }
    }
    #pragma omp section
    {
      for (i=700;i<1000;i++) {
        logic_or = (logic_or || logics[i]);
      }
    }
  }
  if(!logic_or) {
    result++;
    fprintf(stderr,"Error in logic OR part 2\n");
  }

  // Test bitwise AND
  for(i=0;i<1000;++i) {
    logics[i]=1;
  }

  #pragma omp parallel sections private(i) reduction(&:bit_and)
  {
    #pragma omp section
    {
      for(i=0;i<300;++i) {
        bit_and = (bit_and & logics[i]);
      }
    }
    #pragma omp section
    {
      for(i=300;i<700;++i) {
        bit_and = (bit_and & logics[i]);
      }
    }
    #pragma omp section
    {
      for(i=700;i<1000;++i) {
        bit_and = (bit_and & logics[i]);
      }
    }
  }
  if(!bit_and) {
    result++;
    fprintf(stderr,"Error in BIT AND part 1\n");
  }

  bit_and = 1;
  logics[501]=0;

  #pragma omp parallel sections private(i) reduction(&:bit_and)
  {
    #pragma omp section
    {
      for(i=0;i<300;++i) {
        bit_and = bit_and & logics[i];
      }
    }
    #pragma omp section
    {
      for(i=300;i<700;++i) {
        bit_and = bit_and & logics[i];
      }
    }
    #pragma omp section
    {
      for(i=700;i<1000;++i) {
        bit_and = bit_and & logics[i];
      }
    }
  }
  if(bit_and) {
    result++;
    fprintf(stderr,"Error in BIT AND part 2");
  }

  // Test bitwise OR
  for(i=0;i<1000;i++) {
    logics[i]=0;
  }

  #pragma omp parallel sections private(i) reduction(|:bit_or)
  {
    #pragma omp section
    {
      for(i=0;i<300;++i) {
        bit_or = bit_or | logics[i];
      }
    }
    #pragma omp section
    {
      for(i=300;i<700;++i) {
        bit_or = bit_or | logics[i];
      }
    }
    #pragma omp section
    {
      for(i=700;i<1000;++i) {
        bit_or = bit_or | logics[i];
      }
    }
  }
  if(bit_or) {
    result++;
    fprintf(stderr,"Error in BIT OR part 1\n");
  }
  bit_or = 0;
  logics[501]=1;

  #pragma omp parallel sections private(i) reduction(|:bit_or)
  {
    #pragma omp section
    {
      for(i=0;i<300;++i) {
        bit_or = bit_or | logics[i];
      }
    }
    #pragma omp section
    {
      for(i=300;i<700;++i) {
        bit_or = bit_or | logics[i];
      }
    }
    #pragma omp section
    {
      for(i=700;i<1000;++i) {
        bit_or = bit_or | logics[i];
      }
    }
  }
  if(!bit_or) {
    result++;
    fprintf(stderr,"Error in BIT OR part 2\n");
  }

  // Test bitwise XOR
  for(i=0;i<1000;i++) {
    logics[i]=0;
  }

  #pragma omp parallel sections private(i) reduction(^:exclusiv_bit_or)
  {
    #pragma omp section
    {
      for(i=0;i<300;++i) {
        exclusiv_bit_or = exclusiv_bit_or ^ logics[i];
      }
    }
    #pragma omp section
    {
      for(i=300;i<700;++i) {
        exclusiv_bit_or = exclusiv_bit_or ^ logics[i];
      }
    }
    #pragma omp section
    {
      for(i=700;i<1000;++i) {
        exclusiv_bit_or = exclusiv_bit_or ^ logics[i];
      }
    }
  }
  if(exclusiv_bit_or) {
    result++;
    fprintf(stderr,"Error in EXCLUSIV BIT OR part 1\n");
  }

  exclusiv_bit_or = 0;
  logics[501]=1;

  #pragma omp parallel sections private(i) reduction(^:exclusiv_bit_or)
  {
    #pragma omp section
    {
      for(i=0;i<300;++i) {
        exclusiv_bit_or = exclusiv_bit_or ^ logics[i];
      }
    }
    #pragma omp section
    {
      for(i=300;i<700;++i) {
        exclusiv_bit_or = exclusiv_bit_or ^ logics[i];
      }
    }
    #pragma omp section
    {
      for(i=700;i<1000;++i) {
        exclusiv_bit_or = exclusiv_bit_or ^ logics[i];
      }
    }
  }
  if(!exclusiv_bit_or) {
    result++;
    fprintf(stderr,"Error in EXCLUSIV BIT OR part 2\n");
  }

  /*printf("\nResult:%d\n",result);*/
  return (result==0);
}

int main()
{
  int i;
  int num_failed=0;

  for(i = 0; i < REPETITIONS; i++) {
    if(!test_omp_parallel_sections_reduction()) {
      num_failed++;
    }
  }
  return num_failed;
}
llvm/openmp/runtime/test/worksharing/sections/omp_parallel_sections_reduction.c
