test18.c

来自「shpf 1.9一个并行编译器」· C语言 代码 · 共 926 行 · 第 1/2 页

}

static void ad_accumProdDoubleDouble(void* acc, void* arg1, void* arg2) {
  *((double*) acc) += *((double*) arg1) * *((double*) arg2) ;
}

static void ad_accumProdDoubleComplex(void* acc, void* arg1, void* arg2) {
  float* facc  = (float*) acc ;
  float* farg2 = (float*) arg2 ;

  facc [0] += *((double*) arg1) * farg2 [0] ;
  facc [1] += *((double*) arg1) * farg2 [1] ;
}

static void ad_accumProdComplexInt(void* acc, void* arg1, void* arg2) {
  float* facc  = (float*) acc ;
  float* farg1 = (float*) arg1 ;

  facc [0] += farg1 [0] * *((int*) arg2) ;
  facc [1] += farg1 [1] * *((int*) arg2) ;
}

static void ad_accumProdComplexFloat(void* acc, void* arg1, void* arg2) {
  float* facc  = (float*) acc ;
  float* farg1 = (float*) arg1 ;

  facc [0] += farg1 [0] * *((float*) arg2) ;
  facc [1] += farg1 [1] * *((float*) arg2) ;
}

static void ad_accumProdComplexDouble(void* acc, void* arg1, void* arg2) {
  float* facc  = (float*) acc ;
  float* farg1 = (float*) arg1 ;

  facc [0] += farg1 [0] * *((double*) arg2) ;
  facc [1] += farg1 [1] * *((double*) arg2) ;
}

static void ad_accumProdComplexComplex(void* acc, void* arg1, void* arg2) {
  float* facc  = (float*) acc ;
  float* farg1 = (float*) arg1 ;
  float* farg2 = (float*) arg2 ;

  facc [0] += farg1 [0] * farg2 [0] - farg1 [1] * farg2 [1] ;
  facc [1] += farg1 [1] * farg2 [0] + farg1 [0] * farg2 [1] ;
}

static void ad_accumOrAndLogicalLogical(void* acc, void* arg1, void* arg2) {
  *((int*) acc) = *((int*) acc) || (*((int*) arg1) && *((int*) arg2)) ;
}


void main(int argc, char* argv[]) {
  AdlibInit(argc, argv) ;

//  !hpf$ processors q(2, 3)
//
//  !hpf$ template s(4, 100)
//  !hpf$ distribute s(block, cyclic(6)) onto q
//
//  integer a(80)
//  real b(80)
//  double precision c(80)
//  logical m(80)
//  !hpf$ align a(j) with s(2, 15 + j) 
//  !hpf$ align b(:) with a(:)
//  !hpf$ align c(:) with a(:)
//  !hpf$ align m(:) with a(:)

  Procs2 q(2, 3) ;

  Range s1(4,   q.dim(0), BLK) ;
  Range s2(100, q.dim(1), CYC, 6) ;

  Group r(q / s1(1)) ;
  Range x = s2.subrng(80, 15) ;

  Array1<int>    a(r, x) ;
  Array1<float>  b(r, x) ;
  Array1<double> c(r, x) ;
  Array1<int>    m(r, x) ;

//  do i = 1, 80
//    if(i < 13) then
//      a(i) = i
//      b(i) = i
//      c(i) = i
//    else
//      a(i) = 1
//      b(i) = 1
//      c(i) = 1
//    endif
//    m(i) = .false.
//  enddo
//
//  m(3)  = .true.
//  m(5)  = .true.
//  m(7)  = .true.
//  m(9)  = .true.

  on(r) {
    where(x) {
      if(x + 1 < 13) {
        a(x) = x + 1 ;
        b(x) = x + 1 ;
        c(x) = x + 1 ;
      }
      else {
        a(x) = 1 ;
        b(x) = 1 ;
        c(x) = 1 ;
      }
      m(x) = 0 ;
    } erewh(x) ;

    { Subscript s(x(2)) ;
      at(s) m(s) = 1 ; ta(s) ;
    }
    
    { Subscript s(x(4)) ;
      at(s) m(s) = 1 ; ta(s) ;
    }
    
    { Subscript s(x(6)) ;
      at(s) m(s) = 1 ; ta(s) ;
    }
    
    { Subscript s(x(8)) ;
      at(s) m(s) = 1 ; ta(s) ;
    }
  } no(r) ;

//  print "(i15,f15.2,f15.2)", maxval(a), maxval(b), maxval(c)

  { int res ;
    reduce(sizeof(int), (char*) &res, a,
           &ad_mostNegInt,
           (void (*)(void*, void*)) &ad_accumMaxInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce(sizeof(float), (char*) &res, b,
           &ad_mostNegFloat,
           (void (*)(void*, void*)) &ad_accumMaxFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce(sizeof(double), (char*) &res, c,
           &ad_mostNegDouble,
           (void (*)(void*, void*)) &ad_accumMaxDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", &
//        & maxval(a, mask = m), maxval(b, mask = m), maxval(c, mask = m)

  { int res ;
    reduce2(sizeof(int), (char*) &res, a, m,
            &ad_mostNegInt,
            (void (*)(void*, void*, void*)) &ad_accumMaxIfIntInt,
            (void (*)(void*, void*)) &ad_accumMaxInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce2(sizeof(float), (char*) &res, b, m,
            &ad_mostNegFloat,
            (void (*)(void*, void*, void*)) &ad_accumMaxIfFloatInt,
            (void (*)(void*, void*)) &ad_accumMaxFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce2(sizeof(double), (char*) &res, c, m,
            &ad_mostNegDouble,
            (void (*)(void*, void*, void*)) &ad_accumMaxIfDoubleInt,
            (void (*)(void*, void*)) &ad_accumMaxDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", minval(a), minval(b), minval(c)

  { int res ;
    reduce(sizeof(int), (char*) &res, a,
           &ad_mostPosInt,
           (void (*)(void*, void*)) &ad_accumMinInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce(sizeof(float), (char*) &res, b,
           &ad_mostPosFloat,
           (void (*)(void*, void*)) &ad_accumMinFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce(sizeof(double), (char*) &res, c,
           &ad_mostPosDouble,
           (void (*)(void*, void*)) &ad_accumMinDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", &
//        & minval(a, mask = m), minval(b, mask = m), minval(c, mask = m)

  { int res ;
    reduce2(sizeof(int), (char*) &res, a, m,
            &ad_mostPosInt,
            (void (*)(void*, void*, void*)) &ad_accumMinIfIntInt,
            (void (*)(void*, void*)) &ad_accumMinInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce2(sizeof(float), (char*) &res, b, m,
            &ad_mostPosFloat,
            (void (*)(void*, void*, void*)) &ad_accumMinIfFloatInt,
            (void (*)(void*, void*)) &ad_accumMinFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce2(sizeof(double), (char*) &res, c, m,
            &ad_mostPosDouble,
            (void (*)(void*, void*, void*)) &ad_accumMinIfDoubleInt,
            (void (*)(void*, void*)) &ad_accumMinDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", sum(a), sum(b), sum(c)

  { int res ;
    reduce(sizeof(int), (char*) &res, a,
           &ad_zeroInt,
           (void (*)(void*, void*)) &ad_accumInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce(sizeof(float), (char*) &res, b,
           &ad_zeroFloat,
           (void (*)(void*, void*)) &ad_accumFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce(sizeof(double), (char*) &res, c,
           &ad_zeroDouble,
           (void (*)(void*, void*)) &ad_accumDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", &
//        & sum(a, mask = m), sum(b, mask = m), sum(c, mask = m)

  { int res ;
    reduce2(sizeof(int), (char*) &res, a, m,
            &ad_zeroInt,
            (void (*)(void*, void*, void*)) &ad_accumIfIntInt,
            (void (*)(void*, void*)) &ad_accumInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce2(sizeof(float), (char*) &res, b, m,
            &ad_zeroFloat,
            (void (*)(void*, void*, void*)) &ad_accumIfFloatInt,
            (void (*)(void*, void*)) &ad_accumFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce2(sizeof(double), (char*) &res, c, m,
            &ad_zeroDouble,
            (void (*)(void*, void*, void*)) &ad_accumIfDoubleInt,
            (void (*)(void*, void*)) &ad_accumDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", product(a), product(b), product(c)

  { int res ;
    reduce(sizeof(int), (char*) &res, a,
           &ad_unitInt,
           (void (*)(void*, void*)) &ad_accumMulInt) ;

    gprintf("%15d", res) ;
  }

  { float res ;
    reduce(sizeof(float), (char*) &res, b,
           &ad_unitFloat,
           (void (*)(void*, void*)) &ad_accumMulFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce(sizeof(double), (char*) &res, c,
           &ad_unitDouble,
           (void (*)(void*, void*)) &ad_accumMulDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

//  print "(i15,f15.2,f15.2)", &
//        & product(a, mask = m), product(b, mask = m), product(c, mask = m)

  { int res ;
    reduce2(sizeof(int), (char*) &res, a, m,
            &ad_unitInt,
            (void (*)(void*, void*, void*)) &ad_accumMulIfIntInt,
            (void (*)(void*, void*)) &ad_accumMulInt) ;
    gprintf("%15d", res) ;
  }

  { float res ;
    reduce2(sizeof(float), (char*) &res, b, m,
            &ad_unitFloat,
            (void (*)(void*, void*, void*)) &ad_accumMulIfFloatInt,
            (void (*)(void*, void*)) &ad_accumMulFloat) ;
    gprintf("%15.2f", res) ;
  }

  { double res ;
    reduce2(sizeof(double), (char*) &res, c, m,
            &ad_unitDouble,
            (void (*)(void*, void*, void*)) &ad_accumMulIfDoubleInt,
            (void (*)(void*, void*)) &ad_accumMulDouble) ;
    gprintf("%15.2f", res) ;
  }

  gprintf("\n") ;

  int res ;

//  print "(i15,i15,i15)", maxloc(a), maxloc(b), maxloc(c)

  { int dummy ;
    maxLoc(sizeof(int), (char*) &dummy, &res, a,
           &ad_mostNegInt,
           &ad_accumMaxInt) ;
    gprintf("%15d", res) ;
  }

  { float dummy ;
    maxLoc(sizeof(float), (char*) &dummy, &res, b,
           &ad_mostNegFloat,
           &ad_accumMaxFloat) ;
    gprintf("%15d", res) ;
  }

  { double dummy ;
    maxLoc(sizeof(double), (char*) &dummy, &res, c,
           &ad_mostNegDouble,
           &ad_accumMaxDouble) ;
    gprintf("%15d", res) ;
  }

  gprintf("\n") ;

//  print "(i15,i15,i15)", &
//        & maxloc(a, mask = m), maxloc(b, mask = m), maxloc(c, mask = m)

  { int dummy ;
    maxLoc2(sizeof(int), (char*) &dummy, &res, a, m,
            &ad_mostNegInt,
            &ad_accumMaxIfIntInt,
            &ad_accumMaxInt) ;
    gprintf("%15d", res) ;
  }

  { float dummy ;
    maxLoc2(sizeof(float), (char*) &dummy, &res, b, m,
            &ad_mostNegFloat,
            &ad_accumMaxIfFloatInt,
            &ad_accumMaxFloat) ;
    gprintf("%15d", res) ;
  }

  { double dummy ;
    maxLoc2(sizeof(double), (char*) &dummy, &res, c, m,
            &ad_mostNegDouble,
            &ad_accumMaxIfDoubleInt,
            &ad_accumMaxDouble) ;
    gprintf("%15d", res) ;
  }

  gprintf("\n") ;

//  print "(i15,i15,i15)", minloc(a), minloc(b), minloc(c)

  { int dummy ;
    maxLoc(sizeof(int), (char*) &dummy, &res, a,
           &ad_mostPosInt,
           &ad_accumMinInt) ;
    gprintf("%15d", res) ;
  }

  { float dummy ;
    maxLoc(sizeof(float), (char*) &dummy, &res, b,
           &ad_mostPosFloat,
           &ad_accumMinFloat) ;
    gprintf("%15d", res) ;
  }

  { double dummy ;
    maxLoc(sizeof(double), (char*) &dummy, &res, c,
           &ad_mostPosDouble,
           &ad_accumMinDouble) ;
    gprintf("%15d", res) ;
  }

  gprintf("\n") ;

//  print "(i15,i15,i15)", &
//        & minloc(a, mask = m), minloc(b, mask = m), minloc(c, mask = m)

  { int dummy ;
    maxLoc2(sizeof(int), (char*) &dummy, &res, a, m,
            &ad_mostPosInt,
            &ad_accumMinIfIntInt,
            &ad_accumMinInt) ;
    gprintf("%15d", res) ;
  }

  { float dummy ;
    maxLoc2(sizeof(float), (char*) &dummy, &res, b, m,
            &ad_mostPosFloat,
            &ad_accumMinIfFloatInt,
            &ad_accumMinFloat) ;
    gprintf("%15d", res) ;
  }

  { double dummy ;
    maxLoc2(sizeof(double), (char*) &dummy, &res, c, m,
            &ad_mostPosDouble,
            &ad_accumMinIfDoubleInt,
            &ad_accumMinDouble) ;
    gprintf("%15d", res) ;
  }

  gprintf("\n") ;

  AdlibFinalize() ;
}