tools/generate-vmulcaddc-test.py

#!/usr/bin/env python
# Copyright 2019 Google LLC
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.

import argparse
import codecs
import math
import os
import re
import sys
import yaml

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from primes import next_prime
import xngen


parser = argparse.ArgumentParser(description='XNNPACK generator')
parser.add_argument("-s", "--spec", metavar="FILE", required=True,
                    help="Spec (YAML) file")
parser.add_argument("-o", "--output", metavar="FILE", required=True,
                    help='Output (C++ source) file')
parser.set_defaults(defines=list())


def indent(text):
  return "\n".join(map(lambda t: "  " + t if t else t, text.splitlines()))


def remove_duplicate_newlines(text):
  filtered_lines = list()
  last_newline = False
  for line in text.splitlines():
    is_newline = len(line.strip()) == 0
    if not is_newline or not last_newline:
      filtered_lines.append(line)
    last_newline = is_newline
  return "\n".join(filtered_lines)


ARCH_TO_MACRO_MAP = {
  "aarch32": "XNN_ARCH_ARM",
  "aarch64": "XNN_ARCH_ARM64",
  "x86": "XNN_ARCH_X86",
  "x86-64": "XNN_ARCH_X86_64",
}

ISA_TO_ARCH_MAP = {
  "neon": ["aarch32", "aarch64"],
  "neonfma": ["aarch32", "aarch64"],
  "neonfp16arith": ["aarch32", "aarch64"],
  "sse": ["x86", "x86-64"],
  "sse2": ["x86", "x86-64"],
  "avx": ["x86", "x86-64"],
  "avx512f": ["x86", "x86-64"],
  "psimd": [],
}

ISA_TO_CHECK_MAP = {
  "neon": "TEST_REQUIRES_ARM_NEON",
  "neonfma": "TEST_REQUIRES_ARM_NEON_FMA",
  "neonfp16arith": "TEST_REQUIRES_ARM_NEON_FP16_ARITH",
  "sse": "TEST_REQUIRES_X86_SSE",
  "sse2": "TEST_REQUIRES_X86_SSE2",
  "avx": "TEST_REQUIRES_X86_AVX",
  "avx512f": "TEST_REQUIRES_X86_AVX512F",
  "psimd": "TEST_REQUIRES_PSIMD",
}


def split_ukernel_name(name):
  match = re.match(r"^xnn_(f16|f32)_vmulcaddc_ukernel_c(\d+)__(.+)$", name)
  assert match is not None
  cr = int(match.group(2))

  arch = list()
  isa = None
  target_name = match.group(3)
  for target_part in target_name.split("_"):
    if target_part in ARCH_TO_MACRO_MAP:
      arch = [target_part]
    elif target_part in ISA_TO_ARCH_MAP:
      isa = target_part
  if isa and not arch:
    arch = ISA_TO_ARCH_MAP[isa]
  return cr, arch, isa


VMULCADDC_TEST_CODE = """\
TEST(${TEST_NAME}, c_eq_${CBLOCK}) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  VMulCAddCMicrokernelTester()
    .cr(${CR})
    .c(${CBLOCK})
    .m(${MBLOCK})
    .Test(${", ".join(TEST_ARGS)});
}

$if CBLOCK > 1:
  TEST(${TEST_NAME}, c_div_${CBLOCK}) {
    $if ISA_CHECK:
      ${ISA_CHECK};
    for (size_t c = ${CBLOCK * 2}; c < ${CBLOCK * 16}; c += ${CBLOCK * 3}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(${MBLOCK})
        .Test(${", ".join(TEST_ARGS)});
    }
  }

TEST(${TEST_NAME}, c_gt_${CBLOCK}) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t c = ${CBLOCK}; c < ${10 if CBLOCK == 1 else CBLOCK * 2}; c++) {
    VMulCAddCMicrokernelTester()
      .cr(${CR})
      .c(c)
      .m(${MBLOCK})
      .Test(${", ".join(TEST_ARGS)});
  }
}

$if CBLOCK > 1:
  TEST(${TEST_NAME}, c_lt_${CBLOCK}) {
    $if ISA_CHECK:
      ${ISA_CHECK};
    for (size_t c = 1; c < ${CBLOCK}; c++) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(${MBLOCK})
        .Test(${", ".join(TEST_ARGS)});
    }
  }

TEST(${TEST_NAME}, subtile) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = 1; m < ${MBLOCK}; m++) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}

TEST(${TEST_NAME}, multitile) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = ${MBLOCK + 1}; m < ${MBLOCK * 4}; m++) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}

TEST(${TEST_NAME}, x_stride) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = 1; m < ${MBLOCK * 3}; m += ${max(1, MBLOCK - 1)}) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .x_stride(${next_prime(CBLOCK * 5 + 1)})
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}

TEST(${TEST_NAME}, y_stride) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = 1; m < ${MBLOCK * 3}; m += ${max(1, MBLOCK - 1)}) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .y_stride(${next_prime(CBLOCK * 5 + 1)})
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}

TEST(${TEST_NAME}, inplace) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = 1; m < ${MBLOCK * 3}; m += ${max(1, MBLOCK - 1)}) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .inplace(true)
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}

TEST(${TEST_NAME}, qmin) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = 1; m < ${MBLOCK * 3}; m += ${max(1, MBLOCK - 1)}) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .qmin(128)
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}

TEST(${TEST_NAME}, qmax) {
  $if ISA_CHECK:
    ${ISA_CHECK};
  for (size_t m = 1; m < ${MBLOCK * 3}; m += ${max(1, MBLOCK - 1)}) {
    for (size_t c = 1; c <= ${CBLOCK * 5}; c += ${max(1, CBLOCK - 1)}) {
      VMulCAddCMicrokernelTester()
        .cr(${CR})
        .c(c)
        .m(m)
        .qmax(128)
        .Test(${", ".join(TEST_ARGS)});
    }
  }
}
"""


def generate_test_cases(ukernel, cr, c_block, m_block, isa):
  """Generates all tests cases for a VMULCADDC micro-kernel.

  Args:
    ukernel: C name of the micro-kernel function.
    cr: CR parameter of the DWCONV micro-kernel.
    c_block: Number of C values processed per one iteration of the inner loop of
             the micro-kernel.
    m_block: Number of M values processed per one iteration of the outer loop of
             the micro-kernel.
    isa: instruction set required to run the micro-kernel. Generated unit test
         will skip execution if the host processor doesn't support this ISA.

  Returns:
    Code for the test case.
  """
  _, test_name = ukernel.split("_", 1)
  _, datatype, ukernel_type, _ = ukernel.split("_", 3)
  test_args = [ukernel]
  if not isa or isa == "psimd":
    test_args.append("VMulCAddCMicrokernelTester::Variant::Scalar")
  return xngen.preprocess(VMULCADDC_TEST_CODE, {
      "TEST_NAME": test_name.upper().replace("UKERNEL_", ""),
      "TEST_ARGS": test_args,
      "DATATYPE": datatype,
      "CR": cr,
      "CBLOCK": c_block,
      "MBLOCK": m_block,
      "ISA_CHECK": ISA_TO_CHECK_MAP.get(isa, ""),
      "next_prime": next_prime,
      "sqrt": math.sqrt,
    })


def main(args):
  options = parser.parse_args(args)

  with codecs.open(options.spec, "r", encoding="utf-8") as spec_file:
    spec_yaml = yaml.safe_load(spec_file)
    if not isinstance(spec_yaml, list):
      raise ValueError("expected a list of micro-kernels in the spec")

    tests = """\
// Copyright 2019 Google LLC
//
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree.
//
// Auto-generated file. Do not edit!
//   Specification: {specification}
//   Generator: {generator}


#include <gtest/gtest.h>

#include <xnnpack/common.h>
#include <xnnpack/isa-checks.h>

#include <xnnpack/vmulcaddc.h>
#include "vmulcaddc-microkernel-tester.h"
""".format(specification=options.spec, generator=sys.argv[0])

    for ukernel_spec in spec_yaml:
      name = ukernel_spec["name"]
      m_block = int(ukernel_spec["m-block"])
      cr, arch, isa = split_ukernel_name(name)

      # specification can override architecture
      arch = ukernel_spec.get("arch", arch)

      test_case = generate_test_cases(name, cr, cr, m_block, isa)
      test_case = remove_duplicate_newlines(test_case)
      tests += "\n\n"
      if arch:
        guard_macro = " || ".join(map(ARCH_TO_MACRO_MAP.get, arch))
        tests += "#if %s\n" % guard_macro
        tests += indent(test_case) + "\n"
        tests += "#endif  // %s\n" % guard_macro
      elif isa == "psimd":
        guard_macro = "!XNN_ARCH_ASMJS && !XNN_ARCH_WASM"
        tests += "#if %s\n" % guard_macro
        tests += indent(test_case) + "\n"
        tests += "#endif  // %s\n" % guard_macro
      else:
        tests += test_case

    with codecs.open(options.output, "w", encoding="utf-8") as output_file:
      output_file.write(tests)


if __name__ == "__main__":
  main(sys.argv[1:])