#include "m512_test_util.h"
#include <math.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
/*
 * Here we check for _mm512_[mask_]reduce_[add|mul|min|max] intrinsics.
 */
typedef __int64 s64;
typedef unsigned __int64 u64;

typedef float f32;
typedef double f64;

typedef int s32;
typedef unsigned int u32;

int verbose = 0;
#define VERBOSE (verbose > 1)
#define SHOW_OP (verbose > 2)
#define SCALE_TRACE (verbose > 3)

typedef enum {
  REDUCE_ADD,
  REDUCE_MUL,
  REDUCE_MIN,
  REDUCE_MAX,
  REDUCE_OR,
  REDUCE_AND
} OPER;

__mmask16 mask_true = 0xffff;

#define MASK(mask, n) ((mask & (0x1 << n)) != 0)

#define IMin(i, j) (((i) <= (j)) ? (i) : (j))
#define IMax(i, j) (((i) >= (j)) ? (i) : (j))

#define MULOP(a, b) (a * b)
#define ADDOP(a, b) (a + b)
#define OROP(a, b) (a | b)
#define ANDOP(a, b) (a & b)

#define DO_MASK_COPY(len, output, mask, input, def)                            \
  {                                                                            \
    int n;                                                                     \
                                                                               \
    for (n = 0; n < len; n += 1) {                                             \
      if (MASK(mask, n)) {                                                     \
        output[n] = input[n];                                                  \
      } else {                                                                 \
        output[n] = def;                                                       \
      }                                                                        \
    }                                                                          \
  }

#define DO_REDUCE_8(res, mask, input, dtype, oper, initval)                    \
  {                                                                            \
    dtype dtype##tmp[4];                                                       \
    V512 vtmp;                                                                 \
    DO_MASK_COPY(8, vtmp.dtype, mask, input, initval);                         \
                                                                               \
    dtype##tmp[0] = oper(vtmp.dtype[0], vtmp.dtype[4]);                        \
    dtype##tmp[1] = oper(vtmp.dtype[1], vtmp.dtype[5]);                        \
    dtype##tmp[2] = oper(vtmp.dtype[2], vtmp.dtype[6]);                        \
    dtype##tmp[3] = oper(vtmp.dtype[3], vtmp.dtype[7]);                        \
                                                                               \
    dtype##tmp[0] = oper(dtype##tmp[0], dtype##tmp[1]);                        \
    dtype##tmp[2] = oper(dtype##tmp[2], dtype##tmp[3]);                        \
                                                                               \
    res = oper(dtype##tmp[0], dtype##tmp[2]);                                  \
  }

static __int64 NOINLINE mask_s64_reduce_op(OPER op, __mmask16 mask,
                                           __int64 s64op1[8]) {
  int handled = 0;
  __int64 res;

  switch (op) {

  case REDUCE_ADD:
    handled = 1;
    DO_REDUCE_8(res, mask, s64op1, s64, ADDOP, 0);
    break;

  case REDUCE_MUL:
    handled = 1;
    DO_REDUCE_8(res, mask, s64op1, s64, MULOP, 1);
    break;

  case REDUCE_MIN:
    handled = 1;
    DO_REDUCE_8(res, mask, s64op1, s64, IMin, 0x7fffffffffffffff);
    break;

  case REDUCE_MAX:
    handled = 1;
    DO_REDUCE_8(res, mask, s64op1, s64, IMax, 0x8000000000000000);
    break;

  case REDUCE_OR:
    handled = 1;
    DO_REDUCE_8(res, mask, s64op1, s64, OROP, 0);
    break;

  case REDUCE_AND:
    handled = 1;
    DO_REDUCE_8(res, mask, s64op1, s64, ANDOP, 0xffffffffffffffff);
    break;

  default:
    printf("FAIL: mask_s64_reduce_op: bad op\n");
    exit(1);
    break;
  }
  if (!handled) {
    printf("FAIL: mask_s64_reduce_op: unsupported op\n");
  }
  return (res);
}

static __int64 NOINLINE mask_u64_reduce_op(OPER op, __mmask16 mask,
                                           unsigned __int64 u64op1[8]) {
  int handled = 0;
  __int64 res;

  switch (op) {

  case REDUCE_MIN:
    handled = 1;
    DO_REDUCE_8(res, mask, u64op1, u64, IMin, 0xffffffffffffffff);
    break;

  case REDUCE_MAX:
    handled = 1;
    DO_REDUCE_8(res, mask, u64op1, u64, IMax, 0x0000000000000000);
    break;

  default:
    printf("FAIL: mask_u64_reduce_op: bad op\n");
    exit(1);
    break;
  }
  if (!handled) {
    printf("FAIL: mask_u64_reduce_op: unsupported op\n");
  }
  return (res);
}

static void NOINLINE init_s64(__int64 s64out[8], __int64 s64op1[8]) {
  int i = 0;
  for (i = 0; i < 8; i += 1) {
    s64out[i] = s64op1[i];
  }
}

static void NOINLINE print_s64(char *pfx, __int64 var) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf("%15lld", var);
  printf("\n");
}

static void NOINLINE print_u64(char *pfx, u64 var) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf("%15llu", var);
  printf("\n");
}

static void NOINLINE print_ivec(char *pfx, __int64 ivec[]) {
  char *fmt = "%5ld %5ld %5ld %5ld ";
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf(fmt, ivec[7], ivec[6], ivec[5], ivec[4]);
  printf(fmt, ivec[3], ivec[2], ivec[1], ivec[0]);
  printf("\n");
}

static void NOINLINE print_uvec(char *pfx, unsigned __int64 ivec[]) {
  char *fmt = "%5lu %5lu %5lu %5lu ";
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf(fmt, ivec[7], ivec[6], ivec[5], ivec[4]);
  printf(fmt, ivec[3], ivec[2], ivec[1], ivec[0]);
  printf("\n");
}

#define PRINT_MASK(bits, width, pfx, var)                                      \
  print_mask(bits, "%" #width "d ", pfx, var)

static void NOINLINE print_mask(int bits, char *fmt, char *pfx,
                                __mmask16 mask) {
  int i;
  if (pfx) {
    printf("%s: ", pfx);
  }
  for (i = bits; i >= 1; i -= 1) {
    printf(fmt, MASK(mask, (i - 1)));
  }
  printf("\n");
}

#define CHECK_PRINT(STATUS, FUNC)                                              \
  if (!(STATUS)) {                                                             \
    printf("FAIL " #FUNC "\n");                                                \
    err += 1;                                                                  \
  } else if (VERBOSE) {                                                        \
    printf("PASS " #FUNC "\n");                                                \
  }

#define CHECK_REDUCE_S64(FUNC)                                                 \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_ivec("Opand1", v1.s64);                                            \
      print_s64("Scalar", result);                                             \
      print_s64("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_REDUCE_U64(FUNC)                                                 \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_uvec("Opand1", v1.u64);                                            \
      print_u64("Scalar", result);                                             \
      print_u64("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_MASK_REDUCE_S64(FUNC)                                            \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_ivec("Opand1", v1.s64);                                            \
      PRINT_MASK(8, 5, "  Mask", mask);                                        \
      print_s64("Scalar", result);                                             \
      print_s64("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_MASK_REDUCE_U64(FUNC)                                            \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_uvec("Opand1", v1.u64);                                            \
      PRINT_MASK(8, 5, "  Mask", mask);                                        \
      print_u64("Scalar", result);                                             \
      print_u64("Vector", mresult);                                            \
    }                                                                          \
  }

#define DOONE_REDUCE_S64(OP, FUNC)                                             \
  {                                                                            \
    __int64 result;                                                            \
    __int64 mresult;                                                           \
    result = mask_s64_reduce_op(OP, mask_true, v1.s64);                        \
    mresult = FUNC(v1.zmmi);                                                   \
    CHECK_REDUCE_S64(FUNC);                                                    \
  }

#define DOONE_MASK_REDUCE_S64(OP, mask, FUNC)                                  \
  {                                                                            \
    __int64 result;                                                            \
    __int64 mresult;                                                           \
    result = mask_s64_reduce_op(OP, mask, v1.s64);                             \
    mresult = FUNC(mask, v1.zmmi);                                             \
    CHECK_MASK_REDUCE_S64(FUNC);                                               \
  }

#define DOONE_REDUCE_U64(OP, FUNC)                                             \
  {                                                                            \
    unsigned __int64 result;                                                   \
    unsigned __int64 mresult;                                                  \
    result = mask_u64_reduce_op(OP, mask_true, v1.u64);                        \
    mresult = FUNC(v1.zmmi);                                                   \
    CHECK_REDUCE_U64(FUNC);                                                    \
  }

#define DOONE_MASK_REDUCE_U64(OP, mask, FUNC)                                  \
  {                                                                            \
    unsigned __int64 result;                                                   \
    unsigned __int64 mresult;                                                  \
    result = mask_u64_reduce_op(OP, mask, v1.u64);                             \
    mresult = FUNC(mask, v1.zmmi);                                             \
    CHECK_MASK_REDUCE_U64(FUNC);                                               \
  }

__mmask16 mvals[] = {0, 0x82a5};
__int64 init1[8] = {7, 1, 11, 3, 1, 1, 2, 3};

void NOINLINE init() {
  volatile int i;

  for (i = 0; i < 8; i++) {
    init1[i] = init1[i]; /* No change, but compiler does not know this. */
  }
}

int main(int argc, char *argv[]) {
  int i;
  int err = 0;

  V512 v1;
  __mmask16 mask = 0;

  verbose = argc;

  init();

  /* zmmi/s64 tests ---------------------------------------- */
  /* _mm512_reduce_add_epi64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_S64(REDUCE_ADD, _mm512_reduce_add_epi64);

  /* _mm512_reduce_mul_epi64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_S64(REDUCE_MUL, _mm512_reduce_mul_epi64);

  /* _mm512_reduce_min_epi64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_S64(REDUCE_MIN, _mm512_reduce_min_epi64);

  /* _mm512_reduce_max_epi64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_S64(REDUCE_MAX, _mm512_reduce_max_epi64);

  /* _mm512_reduce_and_epi64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_S64(REDUCE_AND, _mm512_reduce_and_epi64);

  /* _mm512_reduce_or_epi64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_S64(REDUCE_OR, _mm512_reduce_or_epi64);

  /* _mm512_reduce_min_epu64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_U64(REDUCE_MIN, _mm512_reduce_min_epu64);

  /* _mm512_reduce_max_epu64 */
  init_s64(v1.s64, init1);
  DOONE_REDUCE_U64(REDUCE_MAX, _mm512_reduce_max_epu64);

  for (i = 0; i < 2; i += 1) {
    mask = mvals[i];
    /* _mm512_mask_reduce_min_epu64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_U64(REDUCE_MIN, mask, _mm512_mask_reduce_min_epu64);

    /* _mm512_mask_reduce_max_epu64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_U64(REDUCE_MAX, mask, _mm512_mask_reduce_max_epu64);
  }

  for (i = 0; i < 2; i += 1) {
    mask = mvals[i];
    /* _mm512_mask_reduce_add_epi64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_S64(REDUCE_ADD, mask, _mm512_mask_reduce_add_epi64);

    /* _mm512_mask_reduce_mul_epi64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_S64(REDUCE_MUL, mask, _mm512_mask_reduce_mul_epi64);

    /* _mm512_mask_reduce_min_epi64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_S64(REDUCE_MIN, mask, _mm512_mask_reduce_min_epi64);

    /* _mm512_mask_reduce_max_epi64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_S64(REDUCE_MAX, mask, _mm512_mask_reduce_max_epi64);

    /* _mm512_mask_reduce_and_epi64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_S64(REDUCE_AND, mask, _mm512_mask_reduce_and_epi64);

    /* _mm512_mask_reduce_or_epi64 */
    init_s64(v1.s64, init1);
    DOONE_MASK_REDUCE_S64(REDUCE_OR, mask, _mm512_mask_reduce_or_epi64);
  }

  if (err) {
    printf("FAILED\n");
    return 1;
  }

  printf("PASSED\n");
  return 0;
}