Attachment #895782 for bug #933827

View | Details | Raw Unified | Return to bug 933827
Collapse All | Expand All




    }
    visibility = [ ":skcms" ]
  }
  skia_source_set("skcms_TransformSkx") {
    sources = skcms_TransformSkx
    if (!is_win) {
      cflags = [
        "-w",
        "-mavx512f",
        "-mavx512dq",
        "-mavx512cd",
        "-mavx512bw",
        "-mavx512vl",
        "-std=c11",
      ]
    } else {
      cflags = [ "/arch:AVX512" ]
    }
    visibility = [ ":skcms" ]
  }
} else {
  skia_source_set("skcms_TransformHsw") {
    sources = []
    visibility = [ ":skcms" ]
  }
  skia_source_set("skcms_TransformSkx") {
    sources = []
    visibility = [ ":skcms" ]
  }
}

source_set("skcms_TransformBaseline_and_public") {

  deps = [
    ":skcms_TransformBaseline_and_public",
    ":skcms_TransformHsw",
    ":skcms_TransformSkx",
  ]
  public =
      rebase_path(skcms_public_headers, ".", "//third_party/skia/modules/skcms")

Lines 2787-2797 Link Here

(-)a/third_party/skia/modules/skcms/skcms.cc (-5 lines)
2787	auto run = baseline::run_program;	2787	auto run = baseline::run_program;
2788	switch (cpu_type()) {	2788	switch (cpu_type()) {
2789	case CpuType::SKX:	2789	case CpuType::SKX:
2790	#if !defined(SKCMS_DISABLE_SKX)
2791	run = skx::run_program;
2792	break;
2793	#endif
2794
2795	case CpuType::HSW:	2790	case CpuType::HSW:
2796	#if !defined(SKCMS_DISABLE_HSW)	2791	#if !defined(SKCMS_DISABLE_HSW)
2797	run = hsw::run_program;	2792	run = hsw::run_program;




if (current_cpu == "x64" || current_cpu == "x86") {
  xnnpack_deps = [
    ":amalgam_avx-no-avx2-no-f16c-no-fma",
    ":amalgam_avx2-avxvnni-f16c-fma",
    ":amalgam_avx512f",
    ":amalgam_f16c-fma-avx2",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni",
    ":amalgam_f16c-fma-no-avx2",
    ":amalgam_f16c-no-avx2-no-fma",
    ":amalgam_sse2-no-sse3",


  xnnpack_standalone_deps = [
    ":amalgam_avx-no-avx2-no-f16c-no-fma_standalone",
    ":amalgam_avx2-avxvnni-f16c-fma_standalone",
    ":amalgam_avx512f_standalone",
    ":amalgam_f16c-fma-avx2_standalone",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi_standalone",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni_standalone",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni_standalone",
    ":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl_standalone",
    ":amalgam_f16c-fma-no-avx2_standalone",
    ":amalgam_f16c-no-avx2-no-fma_standalone",
    ":amalgam_sse2-no-sse3_standalone",

    }
  }

  source_set("amalgam_avx2-avxvnni-f16c-fma") {
    cflags = [
      "-mavx2",
      "-mavxvnni",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avxvnni.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool",
    ]

    public_configs = [ ":xnnpack_config" ]
  }

  # This is a target that cannot depend on //base.
  source_set("amalgam_avx2-avxvnni-f16c-fma_standalone") {
    cflags = [
      "-mavx2",
      "-mavxvnni",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avxvnni.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool:pthreadpool_standalone",
    ]

    public_configs = [ ":xnnpack_config" ]

    if (!(is_android && use_order_profiling)) {
      assert_no_deps = [ "//base" ]
    }
  }

  source_set("amalgam_avx512f") {
    cflags = [ "-mavx512f" ]

    sources = [ "src/src/amalgam/gen/avx512f.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool",
    ]

    public_configs = [ ":xnnpack_config" ]
  }

  # This is a target that cannot depend on //base.
  source_set("amalgam_avx512f_standalone") {
    cflags = [ "-mavx512f" ]

    sources = [ "src/src/amalgam/gen/avx512f.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool:pthreadpool_standalone",
    ]

    public_configs = [ ":xnnpack_config" ]

    if (!(is_android && use_order_profiling)) {
      assert_no_deps = [ "//base" ]
    }
  }

  source_set("amalgam_f16c-fma-avx2") {
    cflags = [
      "-mavx2",


    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool:pthreadpool_standalone",
    ]

    public_configs = [ ":xnnpack_config" ]

    if (!(is_android && use_order_profiling)) {
      assert_no_deps = [ "//base" ]
    }
  }

  source_set("amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vl",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avx512skx.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool",
    ]

    public_configs = [ ":xnnpack_config" ]
  }

  # This is a target that cannot depend on //base.
  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl_standalone") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vl",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avx512skx.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool:pthreadpool_standalone",
    ]

    public_configs = [ ":xnnpack_config" ]

    if (!(is_android && use_order_profiling)) {
      assert_no_deps = [ "//base" ]
    }
  }

  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vbmi",
      "-mavx512vl",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avx512vbmi.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool",
    ]

    public_configs = [ ":xnnpack_config" ]
  }

  # This is a target that cannot depend on //base.
  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi_standalone") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vbmi",
      "-mavx512vl",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avx512vbmi.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool:pthreadpool_standalone",
    ]

    public_configs = [ ":xnnpack_config" ]

    if (!(is_android && use_order_profiling)) {
      assert_no_deps = [ "//base" ]
    }
  }

  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vl",
      "-mavx512vnni",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avx512vnni.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool",
    ]

    public_configs = [ ":xnnpack_config" ]
  }

  # This is a target that cannot depend on //base.
  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni_standalone") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vl",
      "-mavx512vnni",
      "-mf16c",
      "-mfma",
    ]

    sources = [ "src/src/amalgam/gen/avx512vnni.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool:pthreadpool_standalone",
    ]

    public_configs = [ ":xnnpack_config" ]

    if (!(is_android && use_order_profiling)) {
      assert_no_deps = [ "//base" ]
    }
  }

  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vl",
      "-mavx512vnni",
      "-mf16c",
      "-mfma",
      "-mgfni",
    ]

    sources = [ "src/src/amalgam/gen/avx512vnnigfni.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [
      "//third_party/cpuinfo",
      "//third_party/fp16",
      "//third_party/fxdiv",
      "//third_party/pthreadpool",
    ]

    public_configs = [ ":xnnpack_config" ]
  }

  # This is a target that cannot depend on //base.
  source_set(
      "amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni_standalone") {
    cflags = [
      "-mavx512bw",
      "-mavx512cd",
      "-mavx512dq",
      "-mavx512f",
      "-mavx512vl",
      "-mavx512vnni",
      "-mf16c",
      "-mfma",
      "-mgfni",
    ]

    sources = [ "src/src/amalgam/gen/avx512vnnigfni.c" ]

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]

    deps = [




  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vadd_minmax_ukernel__avx512f_u32;
      f32_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx512f_u32;
      f32_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx512f_u32;
      f32_vadd_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
      f32_vadd_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vadd_minmax_ukernel__avx_u16;
      f32_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx_u16;
      f32_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vdiv_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdiv_minmax_ukernel__avx512f_u32;
      f32_vdiv_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdivc_minmax_ukernel__avx512f_u32;
      f32_vdiv_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrdivc_minmax_ukernel__avx512f_u32;
      f32_vdiv_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
      f32_vdiv_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vdiv_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdiv_minmax_ukernel__avx_u16;
      f32_vdiv_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdivc_minmax_ukernel__avx_u16;
      f32_vdiv_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrdivc_minmax_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vmax_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmax_ukernel__avx512f_u32;
      f32_vmax_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx512f_u32;
      f32_vmax_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx512f_u32;
      f32_vmax_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vmax_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmax_ukernel__avx_u16;
      f32_vmax_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx_u16;
      f32_vmax_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vmin_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmin_ukernel__avx512f_u32;
      f32_vmin_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx512f_u32;
      f32_vmin_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx512f_u32;
      f32_vmin_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vmin_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmin_ukernel__avx_u16;
      f32_vmin_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx_u16;
      f32_vmin_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vmul_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmul_minmax_ukernel__avx512f_u32;
      f32_vmul_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx512f_u32;
      f32_vmul_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx512f_u32;
      f32_vmul_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
      f32_vmul_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vmul_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmul_minmax_ukernel__avx_u16;
      f32_vmul_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx_u16;
      f32_vmul_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vsub_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsub_minmax_ukernel__avx512f_u32;
      f32_vsub_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsubc_minmax_ukernel__avx512f_u32;
      f32_vsub_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrsubc_minmax_ukernel__avx512f_u32;
      f32_vsub_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
      f32_vsub_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vsub_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsub_minmax_ukernel__avx_u16;
      f32_vsub_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsubc_minmax_ukernel__avx_u16;
      f32_vsub_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrsubc_minmax_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_vsqrdiff_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiff_ukernel__avx512f_u32;
      f32_vsqrdiff_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx512f_u32;
      f32_vsqrdiff_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx512f_u32;
      f32_vsqrdiff_config.minmax.element_tile = 32;
    } else if (hardware_config->use_x86_avx) {
      f32_vsqrdiff_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiff_ukernel__avx_u16;
      f32_vsqrdiff_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx_u16;
      f32_vsqrdiff_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qs8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vadd_minmax_ukernel__avx512skx_mul32_ld128_u16;
      qs8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
      qs8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
      qs8_vadd_config.init.qs8_add = xnn_init_qs8_add_minmax_avx512_params;
      qs8_vadd_config.minmax.element_tile = 16;
    } else if (hardware_config->use_x86_avx2) {
      qs8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vadd_minmax_ukernel__avx2_mul32_ld64_u16;
      qs8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;
      qs8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qu8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vadd_minmax_ukernel__avx512skx_mul32_ld128_u16;
      qu8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
      qu8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
      qu8_vadd_config.init.qu8_add = xnn_init_qu8_add_minmax_avx512_params;
      qu8_vadd_config.minmax.element_tile = 16;
    } else if (hardware_config->use_x86_avx2) {
      qu8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vadd_minmax_ukernel__avx2_mul32_ld64_u16;
      qu8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;
      qu8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;




  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_fma3) {
      f32_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_f32_dwconv_minmax_ukernel_3p16c__avx512f;
      f32_dwconv_config[0].init.f32 = xnn_init_f32_minmax_scalar_params;
      f32_dwconv_config[0].channel_tile = 16;
      f32_dwconv_config[0].channel_subtile = 16;
      f32_dwconv_config[0].channel_round = 1;
      f32_dwconv_config[0].primary_tile = 3;

      f32_dwconv_config[1].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_f32_dwconv_minmax_ukernel_4p16c__avx512f;
      f32_dwconv_config[1].init.f32 = xnn_init_f32_minmax_scalar_params;
      f32_dwconv_config[1].channel_tile = 16;
      f32_dwconv_config[1].channel_subtile = 16;
      f32_dwconv_config[1].channel_round = 1;
      f32_dwconv_config[1].primary_tile = 4;

      f32_dwconv_config[2].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_f32_dwconv_minmax_ukernel_9p16c__avx512f;
      f32_dwconv_config[2].init.f32 = xnn_init_f32_minmax_scalar_params;
      f32_dwconv_config[2].channel_tile = 16;
      f32_dwconv_config[2].channel_subtile = 16;
      f32_dwconv_config[2].channel_round = 1;
      f32_dwconv_config[2].primary_tile = 9;

      // Multipass microkernel "acc" value should match unipass and also match across different hardware config.
      // Accumulation (FMA) can produce different results, which results in tests only failing on certain platforms.
      #if XNN_ENABLE_DWCONV_MULTIPASS
        f32_dwconv_config[3].minmax.multipass = (xnn_dwconv_multipass_ukernel_fn) xnn_f32_dwconv_minmax_ukernel_5f5m5l32c16s1r__avx512f;
        f32_dwconv_config[3].init.f32 = xnn_init_f32_minmax_scalar_params;
        f32_dwconv_config[3].channel_tile = 32;
        f32_dwconv_config[3].channel_subtile = 16;
        f32_dwconv_config[3].channel_round = 1;
        f32_dwconv_config[3].primary_tile = 5;
        f32_dwconv_config[3].middle_tile = 5;
        f32_dwconv_config[3].last_tile = 5;
      #else
        f32_dwconv_config[3].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_f32_dwconv_minmax_ukernel_25p16c__avx512f;
        f32_dwconv_config[3].init.f32 = xnn_init_f32_minmax_scalar_params;
        f32_dwconv_config[3].channel_tile = 16;
        f32_dwconv_config[3].channel_subtile = 16;
        f32_dwconv_config[3].channel_round = 1;
        f32_dwconv_config[3].primary_tile = 25;
      #endif  // XNN_ENABLE_DWCONV_MULTIPASS
    } else if (hardware_config->use_x86_fma3) {
      f32_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_f32_dwconv_minmax_ukernel_3p16c__fma3;
      f32_dwconv_config[0].init.f32 = xnn_init_f32_minmax_avx_params;
      f32_dwconv_config[0].channel_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qs8_qc8w_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_qc8w_dwconv_minmax_fp32_ukernel_3p32c__avx512skx_mul32;
      qs8_qc8w_dwconv_config[0].init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512_params;
      qs8_qc8w_dwconv_config[0].channel_tile = 32;
      qs8_qc8w_dwconv_config[0].channel_subtile = 32;
      qs8_qc8w_dwconv_config[0].channel_round = 1;
      qs8_qc8w_dwconv_config[1].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_qc8w_dwconv_minmax_fp32_ukernel_9p32c__avx512skx_mul32;
      qs8_qc8w_dwconv_config[1].init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512_params;
      qs8_qc8w_dwconv_config[1].channel_tile = 32;
      qs8_qc8w_dwconv_config[1].channel_subtile = 32;
      qs8_qc8w_dwconv_config[1].channel_round = 1;
      qs8_qc8w_dwconv_config[2].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_qc8w_dwconv_minmax_fp32_ukernel_25p32c__avx512skx_mul32;
      qs8_qc8w_dwconv_config[2].init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512_params;
      qs8_qc8w_dwconv_config[2].channel_tile = 32;
      qs8_qc8w_dwconv_config[2].channel_subtile = 32;
      qs8_qc8w_dwconv_config[2].channel_round = 1;
    } else if (hardware_config->use_x86_avx2) {
      qs8_qc8w_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_qc8w_dwconv_minmax_fp32_ukernel_3p16c__avx2_mul32;
      qs8_qc8w_dwconv_config[0].init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx2_params;
      qs8_qc8w_dwconv_config[0].channel_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qs8_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_dwconv_minmax_fp32_ukernel_9p32c__avx512skx_mul32;
      qs8_dwconv_config[0].init.qs8 = xnn_init_qs8_conv_minmax_fp32_avx512_params;
      qs8_dwconv_config[0].channel_tile = 32;
      qs8_dwconv_config[0].channel_subtile = 32;
      qs8_dwconv_config[0].channel_round = 1;
      qs8_dwconv_config[1].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_dwconv_minmax_fp32_ukernel_25p32c__avx512skx_mul32;
      qs8_dwconv_config[1].init.qs8 = xnn_init_qs8_conv_minmax_fp32_avx512_params;
      qs8_dwconv_config[1].channel_tile = 32;
      qs8_dwconv_config[1].channel_subtile = 32;
      qs8_dwconv_config[1].channel_round = 1;
    } else if (hardware_config->use_x86_avx2) {
      qs8_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qs8_dwconv_minmax_fp32_ukernel_9p16c__avx2_mul32;
      qs8_dwconv_config[0].init.qs8 = xnn_init_qs8_conv_minmax_fp32_avx2_params;
      qs8_dwconv_config[0].channel_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qu8_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qu8_dwconv_minmax_fp32_ukernel_9p32c__avx512skx_mul32;
      qu8_dwconv_config[0].init.qu8 = xnn_init_qu8_conv_minmax_fp32_avx512_params;
      qu8_dwconv_config[0].channel_tile = 32;
      qu8_dwconv_config[0].channel_subtile = 32;
      qu8_dwconv_config[0].channel_round = 1;
      qu8_dwconv_config[1].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qu8_dwconv_minmax_fp32_ukernel_25p32c__avx512skx_mul32;
      qu8_dwconv_config[1].init.qu8 = xnn_init_qu8_conv_minmax_fp32_avx512_params;
      qu8_dwconv_config[1].channel_tile = 32;
      qu8_dwconv_config[1].channel_subtile = 32;
      qu8_dwconv_config[1].channel_round = 1;
    } else if (hardware_config->use_x86_avx2) {
      qu8_dwconv_config[0].minmax.unipass = (xnn_dwconv_unipass_ukernel_fn) xnn_qu8_dwconv_minmax_fp32_ukernel_9p16c__avx2_mul32;
      qu8_dwconv_config[0].init.qu8 = xnn_init_qu8_conv_minmax_fp32_avx2_params;
      qu8_dwconv_config[0].channel_tile = 16;




  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_fma3) {
      f32_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_gemm_minmax_ukernel_1x16__avx512f_broadcast);
      f32_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_gemm_minmax_ukernel_7x16__avx512f_broadcast);
      f32_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_f32_igemm_minmax_ukernel_1x16__avx512f_broadcast);
      f32_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_f32_igemm_minmax_ukernel_7x16__avx512f_broadcast);
      f32_gemm_config.init.f32 = xnn_init_f32_minmax_scalar_params;
      f32_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_f32_gemm_gio_w;
      f32_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_x32_packw_gemm_goi_ukernel_x16__avx512f_u4_prfm;
      f32_gemm_config.mr = 7;
      f32_gemm_config.nr = 16;
    } else if (hardware_config->use_x86_fma3) {
      switch (cpuinfo_get_core(0)->uarch) {
        case cpuinfo_uarch_zen:
        case cpuinfo_uarch_dhyana:

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_qc4w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc4w_gemm_minmax_ukernel_1x32__avx512skx_broadcast);
      f32_qc4w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc4w_gemm_minmax_ukernel_7x32__avx512skx_broadcast);
      f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx512_params;
      f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_f32_qc4w_gemm_goi_w;
      f32_qc4w_gemm_config.mr = 7;
      f32_qc4w_gemm_config.nr = 32;
    } else if (hardware_config->use_x86_avx2) {
      f32_qc4w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc4w_gemm_minmax_ukernel_1x16__avx2_broadcast);
      f32_qc4w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc4w_gemm_minmax_ukernel_3x16__avx2_broadcast);
      f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx_params;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc8w_gemm_minmax_ukernel_1x32__avx512skx_broadcast);
      f32_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc8w_gemm_minmax_ukernel_7x32__avx512skx_broadcast);
      f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_scalar_params;
      f32_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_f32_qs8w_gemm_gio_w;
      f32_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_x8_packw_gemm_goi_ukernel_x32__scalar_int_u2;
      f32_qc8w_gemm_config.mr = 7;
      f32_qc8w_gemm_config.nr = 32;
    } else if (hardware_config->use_x86_avx2) {
      f32_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc8w_gemm_minmax_ukernel_1x16__avx2_broadcast);
      f32_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_f32_qc8w_gemm_minmax_ukernel_5x16__avx2_broadcast);
      f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_avx_params;

  #elif (XNN_ARCH_X86 || XNN_ARCH_X86_64) && !XNN_PLATFORM_MOBILE
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_1x8c8__avx512vnnigfni_prfm);
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_7x8c8__avx512vnnigfni_prfm);
      qd8_f16_qc4w_gemm_config.init.f16_qc4w = xnn_init_f16_qc4w_minmax_avxvnni_params;
      qd8_f16_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f16_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f16_qc4w_gemm_config.mr = 7;
      qd8_f16_qc4w_gemm_config.nr = 8;
      qd8_f16_qc4w_gemm_config.log2_kr = 3;
      qd8_f16_qc4w_gemm_config.planes = 2;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnni) {
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_1x8c8__avx512vnni_prfm);
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_7x8c8__avx512vnni_prfm);
      qd8_f16_qc4w_gemm_config.init.f16_qc4w = xnn_init_f16_qc4w_minmax_avxvnni_params;
      qd8_f16_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f16_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f16_qc4w_gemm_config.mr = 7;
      qd8_f16_qc4w_gemm_config.nr = 8;
      qd8_f16_qc4w_gemm_config.log2_kr = 3;
      qd8_f16_qc4w_gemm_config.planes = 2;
    #if XNN_ENABLE_AVXVNNI
      } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avxvnni) {
        qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_1x8c8__avxvnni_prfm);
        qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_5x8c8__avxvnni_prfm);
        qd8_f16_qc4w_gemm_config.init.f16_qc4w = xnn_init_f16_qc4w_minmax_avxvnni_params;
        qd8_f16_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
        qd8_f16_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
        qd8_f16_qc4w_gemm_config.mr = 5;
        qd8_f16_qc4w_gemm_config.nr = 8;
        qd8_f16_qc4w_gemm_config.log2_kr = 3;
        qd8_f16_qc4w_gemm_config.planes = 2;
    #endif
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_1x8c8__avx512skx);
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_5x8c8__avx512skx);
      qd8_f16_qc4w_gemm_config.init.f16_qc4w = xnn_init_f16_qc4w_minmax_avx_params;
      qd8_f16_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f16_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f16_qc4w_gemm_config.mr = 5;
      qd8_f16_qc4w_gemm_config.nr = 8;
      qd8_f16_qc4w_gemm_config.log2_kr = 3;
      qd8_f16_qc4w_gemm_config.planes = 2;
    } else if (hardware_config->use_x86_avx2) {
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_1x8c8__avx2);
      qd8_f16_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc4w_gemm_minmax_ukernel_3x8c8__avx2);
      qd8_f16_qc4w_gemm_config.init.f16_qc4w = xnn_init_f16_qc4w_minmax_avx_params;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x16c8__avx512vnnigfni_prfm);
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_7x16c8__avx512vnnigfni_prfm);
      qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx512vnni_params;
      qd8_f32_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f32_qc4w_gemm_config.mr = 7;
      qd8_f32_qc4w_gemm_config.nr = 16;
      qd8_f32_qc4w_gemm_config.log2_kr = 3;
      qd8_f32_qc4w_gemm_config.planes = 2;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnni) {
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x16c8__avx512vnni_prfm);
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_7x16c8__avx512vnni_prfm);
      qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx512vnni_params;
      qd8_f32_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f32_qc4w_gemm_config.mr = 7;
      qd8_f32_qc4w_gemm_config.nr = 16;
      qd8_f32_qc4w_gemm_config.log2_kr = 3;
      qd8_f32_qc4w_gemm_config.planes = 2;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnnigfni) {
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x8c8__avx512vnnigfni_prfm);
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_7x8c8__avx512vnnigfni_prfm);
      qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx512vnni_params;
      qd8_f32_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f32_qc4w_gemm_config.mr = 7;
      qd8_f32_qc4w_gemm_config.nr = 8;
      qd8_f32_qc4w_gemm_config.log2_kr = 3;
      qd8_f32_qc4w_gemm_config.planes = 2;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnni) {
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x8c8__avx512vnni_prfm);
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_7x8c8__avx512vnni_prfm);
      qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx512vnni_params;
      qd8_f32_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f32_qc4w_gemm_config.mr = 7;
      qd8_f32_qc4w_gemm_config.nr = 8;
      qd8_f32_qc4w_gemm_config.log2_kr = 3;
      qd8_f32_qc4w_gemm_config.planes = 2;
    #if XNN_ENABLE_AVXVNNI
      } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avxvnni) {
        qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x8c8__avxvnni_prfm);
        qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_5x8c8__avxvnni_prfm);
        qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avxvnni_params;
        qd8_f32_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
        qd8_f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
        qd8_f32_qc4w_gemm_config.mr = 5;
        qd8_f32_qc4w_gemm_config.nr = 8;
        qd8_f32_qc4w_gemm_config.log2_kr = 3;
        qd8_f32_qc4w_gemm_config.planes = 2;
    #endif
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x16c8__avx512skx_prfm);
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_7x16c8__avx512skx_prfm);
      qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_scalar_params;
      qd8_f32_qc4w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_qc4w_gemm_gio_w;
      qd8_f32_qc4w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_qc4w_gemm_goi_w;
      qd8_f32_qc4w_gemm_config.mr = 7;
      qd8_f32_qc4w_gemm_config.nr = 16;
      qd8_f32_qc4w_gemm_config.log2_kr = 3;
      qd8_f32_qc4w_gemm_config.planes = 2;
    } else if (hardware_config->use_x86_avx2) {
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_1x8c8__avx2);
      qd8_f32_qc4w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc4w_gemm_minmax_ukernel_3x8c8__avx2);
      qd8_f32_qc4w_gemm_config.init.f32_qc4w = xnn_init_f32_qc4w_minmax_avx_params;

  #elif (XNN_ARCH_X86 || XNN_ARCH_X86_64) && !XNN_PLATFORM_MOBILE
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_1x8c8__avx512vnni_prfm);
      qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_7x8c8__avx512vnni_prfm);
      qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_1x8c8__avx512vnni_prfm);
      qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_7x8c8__avx512vnni_prfm);
      qd8_f16_qc8w_gemm_config.init.f16 = xnn_init_f16_minmax_avxvnni_params;
      qd8_f16_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qd8_f16_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qd8_f16_qc8w_gemm_config.mr = 7;
      qd8_f16_qc8w_gemm_config.nr = 8;
      qd8_f16_qc8w_gemm_config.log2_kr = 3;
    #if XNN_ENABLE_AVXVNNI
      } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avxvnni) {
        // AVX VNNI should be checked before AVX512SKX as it performs better with VNNI microkernels
        qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_1x8c8__avxvnni_prfm);
        qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_5x8c8__avxvnni_prfm);
        qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_1x8c8__avxvnni_prfm);
        qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_5x8c8__avxvnni_prfm);
        qd8_f16_qc8w_gemm_config.init.f16 = xnn_init_f16_minmax_avxvnni_params;
        qd8_f16_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
        qd8_f16_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
        qd8_f16_qc8w_gemm_config.mr = 5;
        qd8_f16_qc8w_gemm_config.nr = 8;
        qd8_f16_qc8w_gemm_config.log2_kr = 3;
    #endif
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_1x8c8__avx512skx);
      qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_5x8c8__avx512skx);
      qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_1x8c8__avx512skx);
      qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_5x8c8__avx512skx);
      qd8_f16_qc8w_gemm_config.init.f16 = xnn_init_f16_minmax_avx_params;
      qd8_f16_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qd8_f16_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qd8_f16_qc8w_gemm_config.mr = 5;
      qd8_f16_qc8w_gemm_config.nr = 8;
      qd8_f16_qc8w_gemm_config.log2_kr = 3;
    } else if (hardware_config->use_x86_avx2) {
      qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_1x8c8__avx2);
      qd8_f16_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f16_qc8w_gemm_minmax_ukernel_3x8c8__avx2);
      qd8_f16_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f16_qc8w_igemm_minmax_ukernel_1x8c8__avx2);

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
    if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512amx) {
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_1x16c4__avx512amx);
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_7x16c4__avx512amx);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_1x16c4__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_7x16c4__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_avx512vnni_params;
      qd8_f32_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qd8_f32_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qd8_f32_qc8w_gemm_config.mr = 7;
      qd8_f32_qc8w_gemm_config.nr = 16;
      qd8_f32_qc8w_gemm_config.log2_kr = 2;
    } else
    #endif
    if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnni) {
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_1x16c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_7x16c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_1x16c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_7x16c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_avx512vnni_params;
      qd8_f32_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qd8_f32_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qd8_f32_qc8w_gemm_config.mr = 7;
      qd8_f32_qc8w_gemm_config.nr = 16;
      qd8_f32_qc8w_gemm_config.log2_kr = 3;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnni) {
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_1x8c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_7x8c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_1x8c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_7x8c8__avx512vnni_prfm);
      qd8_f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_avxvnni_params;
      qd8_f32_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qd8_f32_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qd8_f32_qc8w_gemm_config.mr = 7;
      qd8_f32_qc8w_gemm_config.nr = 8;
      qd8_f32_qc8w_gemm_config.log2_kr = 3;
    #if XNN_ENABLE_AVXVNNI
      } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avxvnni) {
        // AVX VNNI should be checked before AVX512SKX as it performs better with VNNI microkernels
        qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_1x8c8__avxvnni_prfm);
        qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_5x8c8__avxvnni_prfm);
        qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_1x8c8__avxvnni_prfm);
        qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_5x8c8__avxvnni_prfm);
        qd8_f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_avxvnni_params;
        qd8_f32_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
        qd8_f32_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
        qd8_f32_qc8w_gemm_config.mr = 5;
        qd8_f32_qc8w_gemm_config.nr = 8;
        qd8_f32_qc8w_gemm_config.log2_kr = 3;
    #endif
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_1x16c8__avx512skx_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_7x16c8__avx512skx_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_1x16c8__avx512skx_prfm);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_7x16c8__avx512skx_prfm);
      qd8_f32_qc8w_gemm_config.init.f32 = xnn_init_f32_minmax_scalar_params;
      qd8_f32_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qd8_f32_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qd8_f32_qc8w_gemm_config.mr = 7;
      qd8_f32_qc8w_gemm_config.nr = 16;
      qd8_f32_qc8w_gemm_config.log2_kr = 3;
    } else if (hardware_config->use_x86_avx2) {
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_1x8c8__avx2);
      qd8_f32_qc8w_gemm_config.minmax.dqgemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_dqgemm_ukernel((xnn_dqgemm_ukernel_fn) xnn_qd8_f32_qc8w_gemm_minmax_ukernel_3x8c8__avx2);
      qd8_f32_qc8w_gemm_config.minmax.dqigemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_dqigemm_ukernel((xnn_dqigemm_ukernel_fn) xnn_qd8_f32_qc8w_igemm_minmax_ukernel_1x8c8__avx2);

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x16c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_7x16c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_1x16c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_7x16c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512vnni_params;
      qs8_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_to_qu8_gemm_gio_w;
      qs8_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_to_qu8_gemm_goi_w;
      qs8_qc8w_gemm_config.pack_igemm_goki = (xnn_pack_conv_goki_w_fn) xnn_pack_qs8_to_qu8_conv_goki_w;
      qs8_qc8w_gemm_config.pack_igemm_kgo = (xnn_pack_conv_kgo_w_fn) xnn_pack_qs8_to_qu8_conv_kgo_w;
      qs8_qc8w_gemm_config.pack_deconv_goki = (xnn_pack_deconv_goki_w_fn) xnn_pack_qs8_to_qu8_deconv_goki_w;
      qs8_qc8w_gemm_config.mr = 7;
      qs8_qc8w_gemm_config.nr = 16;
      qs8_qc8w_gemm_config.log2_kr = 3;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512vnni) {
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x8c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_7x8c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_1x8c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_7x8c8__avx512vnni_prfm);
      qs8_qc8w_gemm_config.init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avxvnni_params;
      qs8_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_to_qu8_gemm_gio_w;
      qs8_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_to_qu8_gemm_goi_w;
      qs8_qc8w_gemm_config.pack_igemm_goki = (xnn_pack_conv_goki_w_fn) xnn_pack_qs8_to_qu8_conv_goki_w;
      qs8_qc8w_gemm_config.pack_igemm_kgo = (xnn_pack_conv_kgo_w_fn) xnn_pack_qs8_to_qu8_conv_kgo_w;
      qs8_qc8w_gemm_config.pack_deconv_goki = (xnn_pack_deconv_goki_w_fn) xnn_pack_qs8_to_qu8_deconv_goki_w;
      qs8_qc8w_gemm_config.mr = 7;
      qs8_qc8w_gemm_config.nr = 8;
      qs8_qc8w_gemm_config.log2_kr = 3;
    #if XNN_ENABLE_AVXVNNI
      } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avxvnni) {
        qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x8c8__avxvnni_prfm);
        qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_5x8c8__avxvnni_prfm);
        qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_1x8c8__avxvnni_prfm);
        qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(5)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_5x8c8__avxvnni_prfm);
        qs8_qc8w_gemm_config.init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512vnni_params;
        qs8_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_to_qu8_gemm_gio_w;
        qs8_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_to_qu8_gemm_goi_w;
        qs8_qc8w_gemm_config.pack_igemm_goki = (xnn_pack_conv_goki_w_fn) xnn_pack_qs8_to_qu8_conv_goki_w;
        qs8_qc8w_gemm_config.pack_igemm_kgo = (xnn_pack_conv_kgo_w_fn) xnn_pack_qs8_to_qu8_conv_kgo_w;
        qs8_qc8w_gemm_config.pack_deconv_goki = (xnn_pack_deconv_goki_w_fn) xnn_pack_qs8_to_qu8_deconv_goki_w;
        qs8_qc8w_gemm_config.mr = 5;
        qs8_qc8w_gemm_config.nr = 8;
        qs8_qc8w_gemm_config.log2_kr = 3;
    #endif
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x16c8__avx512skx_prfm);
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_7x16c8__avx512skx_prfm);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_1x16c8__avx512skx_prfm);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_7x16c8__avx512skx_prfm);
      qs8_qc8w_gemm_config.init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512_params;
      qs8_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qs8_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qs8_qc8w_gemm_config.pack_igemm_goki = (xnn_pack_conv_goki_w_fn) xnn_pack_qs8_conv_goki_w;
      qs8_qc8w_gemm_config.pack_igemm_kgo = (xnn_pack_conv_kgo_w_fn) xnn_pack_qs8_conv_kgo_w;
      qs8_qc8w_gemm_config.pack_deconv_goki = (xnn_pack_deconv_goki_w_fn) xnn_pack_qs8_deconv_goki_w;
      qs8_qc8w_gemm_config.mr = 7;
      qs8_qc8w_gemm_config.nr = 16;
      qs8_qc8w_gemm_config.log2_kr = 3;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x8c8__avx512skx);
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(4)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_4x8c8__avx512skx);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_1x8c8__avx512skx);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(4)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_4x8c8__avx512skx);
      qs8_qc8w_gemm_config.init.qs8_qc8w = xnn_init_qs8_qc8w_conv_minmax_fp32_avx512_params;
      qs8_qc8w_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qs8_gemm_gio_w;
      qs8_qc8w_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qs8_gemm_goi_w;
      qs8_qc8w_gemm_config.pack_igemm_goki = (xnn_pack_conv_goki_w_fn) xnn_pack_qs8_conv_goki_w;
      qs8_qc8w_gemm_config.pack_igemm_kgo = (xnn_pack_conv_kgo_w_fn) xnn_pack_qs8_conv_kgo_w;
      qs8_qc8w_gemm_config.pack_deconv_goki = (xnn_pack_deconv_goki_w_fn) xnn_pack_qs8_deconv_goki_w;
      qs8_qc8w_gemm_config.mr = 4;  // TODO: upgrade to 5x8 prfm when supported
      qs8_qc8w_gemm_config.nr = 8;
      qs8_qc8w_gemm_config.log2_kr = 3;
    } else if (hardware_config->use_x86_avx2) {
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x8c8__avx2);
      qs8_qc8w_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_3x8c8__avx2);
      qs8_qc8w_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qs8_qc8w_igemm_minmax_fp32_ukernel_1x8c8__avx2);

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qu8_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qu8_gemm_minmax_fp32_ukernel_1x16c8__avx512skx_prfm);
      qu8_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qu8_gemm_minmax_fp32_ukernel_7x16c8__avx512skx_prfm);
      qu8_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qu8_igemm_minmax_fp32_ukernel_1x16c8__avx512skx_prfm);
      qu8_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(7)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qu8_igemm_minmax_fp32_ukernel_7x16c8__avx512skx_prfm);
      qu8_gemm_config.init.qu8 = xnn_init_qu8_conv_minmax_fp32_avx512_params;
      qu8_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qu8_gemm_gio_w;
      qu8_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qu8_gemm_goi_w;
      qu8_gemm_config.mr = 7;
      qu8_gemm_config.nr = 16;
      qu8_gemm_config.log2_kr = 3;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {
      qu8_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qu8_gemm_minmax_fp32_ukernel_1x8c8__avx512skx);
      qu8_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(4)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qu8_gemm_minmax_fp32_ukernel_4x8c8__avx512skx);
      qu8_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qu8_igemm_minmax_fp32_ukernel_1x8c8__avx512skx);
      qu8_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(4)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qu8_igemm_minmax_fp32_ukernel_4x8c8__avx512skx);
      qu8_gemm_config.init.qu8 = xnn_init_qu8_conv_minmax_fp32_avx512_params;
      qu8_gemm_config.pack_gemm_gio = (xnn_packw_gemm_gio_ukernel_fn) xnn_pack_qu8_gemm_gio_w;
      qu8_gemm_config.pack_gemm_goi = (xnn_packw_gemm_goi_ukernel_fn) xnn_pack_qu8_gemm_goi_w;
      qu8_gemm_config.mr = 4;  // TODO: upgrade to 5x8 prfm when supported
      qu8_gemm_config.nr = 8;
      qu8_gemm_config.log2_kr = 3;
    } else if (hardware_config->use_x86_avx2) {
      qu8_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qu8_gemm_minmax_fp32_ukernel_1x8c8__avx2);
      qu8_gemm_config.minmax.gemm[XNN_MR_TO_INDEX(3)] = xnn_init_hmp_gemm_ukernel((xnn_gemm_ukernel_fn) xnn_qu8_gemm_minmax_fp32_ukernel_3x8c8__avx2);
      qu8_gemm_config.minmax.igemm[XNN_MR_TO_INDEX(1)] = xnn_init_hmp_igemm_ukernel((xnn_igemm_ukernel_fn) xnn_qu8_igemm_minmax_fp32_ukernel_1x8c8__avx2);




    hardware_config.use_x86_f16c = cpuinfo_has_x86_f16c();
    hardware_config.use_x86_fma3 = cpuinfo_has_x86_fma3();
    hardware_config.use_x86_avx2 = cpuinfo_has_x86_avx2();
    hardware_config.use_x86_avx512f = 0;
    hardware_config.use_x86_avx512skx = 0;
    hardware_config.use_x86_avx512vbmi = 0;
    hardware_config.use_x86_avx512vnni = 0;
    hardware_config.use_x86_avx512vnnigfni = 0;
    hardware_config.use_x86_avx512vnnigfni = hardware_config.use_x86_avx512vnni && cpuinfo_has_x86_gfni();
#if XNN_ENABLE_AVX512AMX
    // TODO(fbarchard): Use cpuinfo_has_x86_amx_int8 when available.
    // Infer AMX support from Sapphire Rapids having fp16 and amx.
    hardware_config.use_x86_avx512amx = 0;
#if XNN_ARCH_X86_64 && defined(__linux__) && !defined(CHROMIUM)
    if (hardware_config.use_x86_avx512amx) {
      size_t status = xnn_syscall(SYS_arch_prctl, ARCH_REQ_XCOMP_PERM, XFEATURE_XTILEDATA, 0);

    hardware_config.use_x86_avx512amx = 0;
#endif
#if XNN_ENABLE_AVXVNNI
    hardware_config.use_x86_avxvnni = 0;
#else
    hardware_config.use_x86_avxvnni = 0;
#endif

Lines 77-87 Link Here

(-)a/third_party/xnnpack/src/src/configs/prelu-config.c (-5 / +1 lines)
77	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	77	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
78	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	78	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
79	assert(hardware_config != NULL);	79	assert(hardware_config != NULL);
80	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	80	if (hardware_config->use_x86_avx) {
81	f32_prelu_config.ukernel = (xnn_prelu_ukernel_fn) xnn_f32_prelu_ukernel__avx512f_2x16;
82	f32_prelu_config.row_tile = 2;
83	f32_prelu_config.channel_tile = 16;
84	} else if (hardware_config->use_x86_avx) {
85	f32_prelu_config.ukernel = (xnn_prelu_ukernel_fn) xnn_f32_prelu_ukernel__avx_2x16;	81	f32_prelu_config.ukernel = (xnn_prelu_ukernel_fn) xnn_f32_prelu_ukernel__avx_2x16;
86	f32_prelu_config.row_tile = 2;	82	f32_prelu_config.row_tile = 2;
87	f32_prelu_config.channel_tile = 16;	83	f32_prelu_config.channel_tile = 16;




  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_rminmax_config = (struct xnn_reduce_config) {
        .ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rminmax_ukernel__avx512f_u64_acc4,
        .element_tile = 64,
      };
    } else if (hardware_config->use_x86_avx) {
      f32_rminmax_config = (struct xnn_reduce_config) {
        .ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rminmax_ukernel__avx_u32_acc4,
        .init.f32_default = xnn_init_f32_default_avx_params,

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_rsum_config = (struct xnn_reduce_config) {
        .ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rsum_ukernel__avx512f_u64_acc4,
        .init.f32_scale = xnn_init_f32_scale_scalar_params,
        .element_tile = 64,
      };
    } else if (hardware_config->use_x86_avx) {
      f32_rsum_config = (struct xnn_reduce_config) {
        .ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rsum_ukernel__avx_u32_acc4,
        .init.f32_scale = xnn_init_f32_scale_avx_params,

Lines 68-76 Link Here

(-)a/third_party/xnnpack/src/src/configs/rmax-config.c (-3 / +1 lines)
68	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	68	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
69	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	69	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
70	assert(hardware_config != NULL);	70	assert(hardware_config != NULL);
71	if (hardware_config->use_x86_avx512f) {	71	if (hardware_config->use_x86_avx) {
72	f32_rmax_config.ukernel = (xnn_rmax_ukernel_fn) xnn_f32_rmax_ukernel__avx512f_u64_acc4;
73	} else if (hardware_config->use_x86_avx) {
74	f32_rmax_config.ukernel = (xnn_rmax_ukernel_fn) xnn_f32_rmax_ukernel__avx_u32_acc4;	72	f32_rmax_config.ukernel = (xnn_rmax_ukernel_fn) xnn_f32_rmax_ukernel__avx_u32_acc4;
75	f32_rmax_config.init.f32 = xnn_init_f32_default_avx_params;	73	f32_rmax_config.init.f32 = xnn_init_f32_default_avx_params;
76	} else {	74	} else {




  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_f16c) {
      f16_to_f32_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f16_f32_vcvt_ukernel__avx512skx_u16;
      f16_to_f32_cvt_config.element_tile = 16;
    } else if (hardware_config->use_x86_f16c) {
      f16_to_f32_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f16_f32_vcvt_ukernel__f16c_u16;
      f16_to_f32_cvt_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_abs_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vabs_ukernel__avx512f_u16;
      f32_abs_config.init.f32_abs = xnn_init_f32_abs_avx512_params;
      f32_abs_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_abs_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vabs_ukernel__avx_u16;
      f32_abs_config.init.f32_abs = xnn_init_f32_abs_avx_params;
      f32_abs_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_clamp_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vclamp_ukernel__avx512f_u16;
      f32_clamp_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
      f32_clamp_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_clamp_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vclamp_ukernel__avx_u16;
      f32_clamp_config.init.f32_minmax = xnn_init_f32_minmax_avx_params;
      f32_clamp_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_elu_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_velu_ukernel__avx512f_rr1_p6_u128;
      f32_elu_config.init.f32_elu = xnn_init_f32_elu_avx512_rr1_p6_params;
      f32_elu_config.element_tile = 128;
    } else if (hardware_config->use_x86_avx2) {
      f32_elu_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_velu_ukernel__avx2_rr1_lut4_p4_perm_u56;
      f32_elu_config.init.f32_elu = xnn_init_f32_elu_avx2_rr1_lut4_p4_params;
      f32_elu_config.element_tile = 56;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_fma3) {
      f32_hswish_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vhswish_ukernel__avx512f_u16;
      f32_hswish_config.init.f32_hswish = xnn_init_f32_hswish_avx512_params;
      f32_hswish_config.element_tile = 16;
    } else if (hardware_config->use_x86_fma3) {
      f32_hswish_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vhswish_ukernel__fma3_u16;
      f32_hswish_config.init.f32_hswish = xnn_init_f32_hswish_avx_params;
      f32_hswish_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_lrelu_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vlrelu_ukernel__avx512f_u16;
      f32_lrelu_config.init.f32_lrelu = xnn_init_f32_lrelu_scalar_params;
      f32_lrelu_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_lrelu_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vlrelu_ukernel__avx_u16;
      f32_lrelu_config.init.f32_lrelu = xnn_init_f32_lrelu_avx_params;
      f32_lrelu_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_neg_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vneg_ukernel__avx512f_u16;
      f32_neg_config.init.f32_neg = xnn_init_f32_neg_avx512_params;
      f32_neg_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_neg_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vneg_ukernel__avx_u16;
      f32_neg_config.init.f32_neg = xnn_init_f32_neg_avx_params;
      f32_neg_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_rndd_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndd_ukernel__avx512f_u16;
      f32_rndd_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_rndd_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndd_ukernel__avx_u16;
      f32_rndd_config.init.f32_rnd = xnn_init_f32_rnd_avx_params;
      f32_rndd_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_rndne_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndne_ukernel__avx512f_u16;
      f32_rndne_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_rndne_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndne_ukernel__avx_u16;
      f32_rndne_config.init.f32_rnd = xnn_init_f32_rnd_avx_params;
      f32_rndne_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_rndu_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndu_ukernel__avx512f_u16;
      f32_rndu_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_rndu_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndu_ukernel__avx_u16;
      f32_rndu_config.init.f32_rnd = xnn_init_f32_rnd_avx_params;
      f32_rndu_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_rndz_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndz_ukernel__avx512f_u16;
      f32_rndz_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_rndz_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrndz_ukernel__avx_u16;
      f32_rndz_config.init.f32_rnd = xnn_init_f32_rnd_avx_params;
      f32_rndz_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_sigmoid_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vsigmoid_ukernel__avx512f_rr2_lut32_p2_perm2_scalef_div_u64;
      f32_sigmoid_config.init.f32_sigmoid = xnn_init_f32_sigmoid_avx512_rr2_lut32_p2_params;
      f32_sigmoid_config.element_tile = 64;
    } else if (hardware_config->use_x86_avx2) {
      f32_sigmoid_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vsigmoid_ukernel__avx2_rr1_p5_div_u40;
      f32_sigmoid_config.init.f32_sigmoid = xnn_init_f32_sigmoid_avx2_rr1_p5_params;
      f32_sigmoid_config.element_tile = 40;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx) {
      f32_sqr_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vsqr_ukernel__avx512f_u16;
      f32_sqr_config.element_tile = 16;
    } else if (hardware_config->use_x86_avx) {
      f32_sqr_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vsqr_ukernel__avx_u16;
      f32_sqr_config.init.f32_default = xnn_init_f32_default_avx_params;
      f32_sqr_config.element_tile = 16;

  #if XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_fma3) {
      f32_rsqrt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrsqrt_ukernel__avx512f_rsqrt_u32;
      f32_rsqrt_config.init.f32_rsqrt = xnn_init_f32_rsqrt_avx512_params;
      f32_rsqrt_config.element_tile = 32;
    } else if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_fma3) {
      f32_rsqrt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vrsqrt_ukernel__fma3_rsqrt_u16;
      f32_rsqrt_config.init.f32_rsqrt = xnn_init_f32_rsqrt_fma3_params;
      f32_rsqrt_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_tanh_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vtanh_ukernel__avx512skx_expm1minus_rr1_lut4_p4h3ts_perm_div_u64;
      f32_tanh_config.init.f32_tanh = xnn_init_f32_tanh_avx512_expm1minus_rr1_lut4_p4h3_perm_params;
      f32_tanh_config.element_tile = 64;
    } else if (hardware_config->use_x86_avx2) {
      f32_tanh_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_vtanh_ukernel__avx2_expm1minus_rr1_lut4_p4h3ts_perm_div_u32;
      f32_tanh_config.init.f32_tanh = xnn_init_f32_tanh_avx_expm1minus_rr1_lut4_p4h3_perm_params;
      f32_tanh_config.element_tile = 32;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_f16c) {
      f32_to_f16_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_f16_vcvt_ukernel__avx512skx_u16;
      f32_to_f16_cvt_config.element_tile = 16;
    } else if (hardware_config->use_x86_f16c) {
      f32_to_f16_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_f16_vcvt_ukernel__f16c_u16;
      f32_to_f16_cvt_config.init.f32_f16_cvt = xnn_init_f32_f16_cvt_f16c_params;
      f32_to_f16_cvt_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_to_qs8_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_qs8_vcvt_ukernel__avx512skx_u128;
      f32_to_qs8_cvt_config.init.f32_qs8_cvt = xnn_init_f32_qs8_cvt_avx512_params;
      f32_to_qs8_cvt_config.element_tile = 128;
    } else if (hardware_config->use_x86_avx2) {
      f32_to_qs8_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_qs8_vcvt_ukernel__avx2_u64;
      f32_to_qs8_cvt_config.init.f32_qs8_cvt = xnn_init_f32_qs8_cvt_avx2_params;
      f32_to_qs8_cvt_config.element_tile = 64;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      f32_to_qu8_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_qu8_vcvt_ukernel__avx512skx_u128;
      f32_to_qu8_cvt_config.init.f32_qu8_cvt = xnn_init_f32_qu8_cvt_avx512_params;
      f32_to_qu8_cvt_config.element_tile = 128;
    } else if (hardware_config->use_x86_avx2) {
      f32_to_qu8_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_f32_qu8_vcvt_ukernel__avx2_u64;
      f32_to_qu8_cvt_config.init.f32_qu8_cvt = xnn_init_f32_qu8_cvt_avx2_params;
      f32_to_qu8_cvt_config.element_tile = 64;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qs8_to_f32_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_qs8_f32_vcvt_ukernel__avx512skx_u32;
      qs8_to_f32_cvt_config.init.qs8_f32_cvt = xnn_init_qs8_f32_cvt_avx512_params;
      qs8_to_f32_cvt_config.element_tile = 32;
    } else if (hardware_config->use_x86_avx2) {
      qs8_to_f32_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_qs8_f32_vcvt_ukernel__avx2_u16;
      qs8_to_f32_cvt_config.init.qs8_f32_cvt = xnn_init_qs8_f32_cvt_avx_params;
      qs8_to_f32_cvt_config.element_tile = 16;

  #elif XNN_ARCH_X86 || XNN_ARCH_X86_64
    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);
    if (hardware_config->use_x86_avx2) {
      qu8_to_f32_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_qu8_f32_vcvt_ukernel__avx512skx_u32;
      qu8_to_f32_cvt_config.init.qu8_f32_cvt = xnn_init_qu8_f32_cvt_avx512_params;
      qu8_to_f32_cvt_config.element_tile = 32;
    } else if (hardware_config->use_x86_avx2) {
      qu8_to_f32_cvt_config.ukernel = (xnn_vunary_ukernel_fn) xnn_qu8_f32_vcvt_ukernel__avx2_u16;
      qu8_to_f32_cvt_config.init.qu8_f32_cvt = xnn_init_qu8_f32_cvt_avx_params;
      qu8_to_f32_cvt_config.element_tile = 16;




    const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
    assert(hardware_config != NULL);

    if (hardware_config->use_x86_avx2) {
      if (hardware_config->use_x86_avx512vbmi) {
        x8_lut_config.microkernel = xnn_x8_lut_ukernel__avx512vbmi_vpermx2b_u128;
        x8_lut_config.tile_size = 128;
      } else {
        x8_lut_config.microkernel = xnn_x8_lut_ukernel__avx512skx_vpshufb_u64;
        x8_lut_config.tile_size = 64;
      }
    } else if (hardware_config->use_x86_avx2) {
      x8_lut_config.microkernel = xnn_x8_lut_ukernel__avx2_u128;
      x8_lut_config.tile_size = 128;
    } else if (hardware_config->use_x86_avx) {

Return to bug 933827

Lines 338-350 Link Here

(-)a/third_party/xnnpack/src/src/configs/binary-elementwise-config.c (-60 / +9 lines)
338	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	338	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
339	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	339	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
340	assert(hardware_config != NULL);	340	assert(hardware_config != NULL);
341	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	341	if (hardware_config->use_x86_avx) {
342	f32_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vadd_minmax_ukernel__avx512f_u32;
343	f32_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx512f_u32;
344	f32_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx512f_u32;
345	f32_vadd_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
346	f32_vadd_config.minmax.element_tile = 32;
347	} else if (hardware_config->use_x86_avx) {
348	f32_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vadd_minmax_ukernel__avx_u16;	342	f32_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vadd_minmax_ukernel__avx_u16;
349	f32_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx_u16;	343	f32_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx_u16;
350	f32_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx_u16;	344	f32_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vaddc_minmax_ukernel__avx_u16;
Lines 429-441 Link Here
429	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	423	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
430	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	424	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
431	assert(hardware_config != NULL);	425	assert(hardware_config != NULL);
432	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	426	if (hardware_config->use_x86_avx) {
433	f32_vdiv_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdiv_minmax_ukernel__avx512f_u32;
434	f32_vdiv_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdivc_minmax_ukernel__avx512f_u32;
435	f32_vdiv_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrdivc_minmax_ukernel__avx512f_u32;
436	f32_vdiv_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
437	f32_vdiv_config.minmax.element_tile = 32;
438	} else if (hardware_config->use_x86_avx) {
439	f32_vdiv_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdiv_minmax_ukernel__avx_u16;	427	f32_vdiv_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdiv_minmax_ukernel__avx_u16;
440	f32_vdiv_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdivc_minmax_ukernel__avx_u16;	428	f32_vdiv_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vdivc_minmax_ukernel__avx_u16;
441	f32_vdiv_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrdivc_minmax_ukernel__avx_u16;	429	f32_vdiv_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrdivc_minmax_ukernel__avx_u16;
Lines 517-528 Link Here
517	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	505	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
518	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	506	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
519	assert(hardware_config != NULL);	507	assert(hardware_config != NULL);
520	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	508	if (hardware_config->use_x86_avx) {
521	f32_vmax_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmax_ukernel__avx512f_u32;
522	f32_vmax_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx512f_u32;
523	f32_vmax_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx512f_u32;
524	f32_vmax_config.minmax.element_tile = 32;
525	} else if (hardware_config->use_x86_avx) {
526	f32_vmax_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmax_ukernel__avx_u16;	509	f32_vmax_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmax_ukernel__avx_u16;
527	f32_vmax_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx_u16;	510	f32_vmax_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx_u16;
528	f32_vmax_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx_u16;	511	f32_vmax_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmaxc_ukernel__avx_u16;
Lines 590-601 Link Here
590	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	573	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
591	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	574	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
592	assert(hardware_config != NULL);	575	assert(hardware_config != NULL);
593	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	576	if (hardware_config->use_x86_avx) {
594	f32_vmin_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmin_ukernel__avx512f_u32;
595	f32_vmin_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx512f_u32;
596	f32_vmin_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx512f_u32;
597	f32_vmin_config.minmax.element_tile = 32;
598	} else if (hardware_config->use_x86_avx) {
599	f32_vmin_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmin_ukernel__avx_u16;	577	f32_vmin_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmin_ukernel__avx_u16;
600	f32_vmin_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx_u16;	578	f32_vmin_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx_u16;
601	f32_vmin_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx_u16;	579	f32_vmin_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vminc_ukernel__avx_u16;
Lines 666-678 Link Here
666	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	644	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
667	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	645	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
668	assert(hardware_config != NULL);	646	assert(hardware_config != NULL);
669	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	647	if (hardware_config->use_x86_avx) {
670	f32_vmul_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmul_minmax_ukernel__avx512f_u32;
671	f32_vmul_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx512f_u32;
672	f32_vmul_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx512f_u32;
673	f32_vmul_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
674	f32_vmul_config.minmax.element_tile = 32;
675	} else if (hardware_config->use_x86_avx) {
676	f32_vmul_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmul_minmax_ukernel__avx_u16;	648	f32_vmul_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmul_minmax_ukernel__avx_u16;
677	f32_vmul_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx_u16;	649	f32_vmul_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx_u16;
678	f32_vmul_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx_u16;	650	f32_vmul_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vmulc_minmax_ukernel__avx_u16;
Lines 757-769 Link Here
757	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	729	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
758	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	730	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
759	assert(hardware_config != NULL);	731	assert(hardware_config != NULL);
760	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	732	if (hardware_config->use_x86_avx) {
761	f32_vsub_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsub_minmax_ukernel__avx512f_u32;
762	f32_vsub_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsubc_minmax_ukernel__avx512f_u32;
763	f32_vsub_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrsubc_minmax_ukernel__avx512f_u32;
764	f32_vsub_config.init.f32_minmax = xnn_init_f32_minmax_scalar_params;
765	f32_vsub_config.minmax.element_tile = 32;
766	} else if (hardware_config->use_x86_avx) {
767	f32_vsub_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsub_minmax_ukernel__avx_u16;	733	f32_vsub_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsub_minmax_ukernel__avx_u16;
768	f32_vsub_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsubc_minmax_ukernel__avx_u16;	734	f32_vsub_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsubc_minmax_ukernel__avx_u16;
769	f32_vsub_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrsubc_minmax_ukernel__avx_u16;	735	f32_vsub_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vrsubc_minmax_ukernel__avx_u16;
Lines 845-856 Link Here
845	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	811	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
846	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	812	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
847	assert(hardware_config != NULL);	813	assert(hardware_config != NULL);
848	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	814	if (hardware_config->use_x86_avx) {
849	f32_vsqrdiff_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiff_ukernel__avx512f_u32;
850	f32_vsqrdiff_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx512f_u32;
851	f32_vsqrdiff_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx512f_u32;
852	f32_vsqrdiff_config.minmax.element_tile = 32;
853	} else if (hardware_config->use_x86_avx) {
854	f32_vsqrdiff_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiff_ukernel__avx_u16;	815	f32_vsqrdiff_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiff_ukernel__avx_u16;
855	f32_vsqrdiff_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx_u16;	816	f32_vsqrdiff_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx_u16;
856	f32_vsqrdiff_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx_u16;	817	f32_vsqrdiff_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_f32_vsqrdiffc_ukernel__avx_u16;
Lines 907-919 Link Here
907	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	868	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
908	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	869	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
909	assert(hardware_config != NULL);	870	assert(hardware_config != NULL);
910	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {	871	if (hardware_config->use_x86_avx2) {
911	qs8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vadd_minmax_ukernel__avx512skx_mul32_ld128_u16;
912	qs8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
913	qs8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
914	qs8_vadd_config.init.qs8_add = xnn_init_qs8_add_minmax_avx512_params;
915	qs8_vadd_config.minmax.element_tile = 16;
916	} else if (hardware_config->use_x86_avx2) {
917	qs8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vadd_minmax_ukernel__avx2_mul32_ld64_u16;	872	qs8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vadd_minmax_ukernel__avx2_mul32_ld64_u16;
918	qs8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;	873	qs8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;
919	qs8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;	874	qs8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qs8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;
Lines 1045-1057 Link Here
1045	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	1000	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
1046	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	1001	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
1047	assert(hardware_config != NULL);	1002	assert(hardware_config != NULL);
1048	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512skx) {	1003	if (hardware_config->use_x86_avx2) {
1049	qu8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vadd_minmax_ukernel__avx512skx_mul32_ld128_u16;
1050	qu8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
1051	qu8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx512skx_mul32_ld128_u16;
1052	qu8_vadd_config.init.qu8_add = xnn_init_qu8_add_minmax_avx512_params;
1053	qu8_vadd_config.minmax.element_tile = 16;
1054	} else if (hardware_config->use_x86_avx2) {
1055	qu8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vadd_minmax_ukernel__avx2_mul32_ld64_u16;	1004	qu8_vadd_config.minmax.op_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vadd_minmax_ukernel__avx2_mul32_ld64_u16;
1056	qu8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;	1005	qu8_vadd_config.minmax.opc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;
1057	qu8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;	1006	qu8_vadd_config.minmax.ropc_ukernel = (xnn_vbinary_ukernel_fn) xnn_qu8_vaddc_minmax_ukernel__avx2_mul32_ld64_u16;

Lines 112-127 Link Here

(-)a/third_party/xnnpack/src/src/configs/hardware-config.c (-8 / +7 lines)
112	hardware_config.use_x86_f16c = cpuinfo_has_x86_f16c();	112	hardware_config.use_x86_f16c = cpuinfo_has_x86_f16c();
113	hardware_config.use_x86_fma3 = cpuinfo_has_x86_fma3();	113	hardware_config.use_x86_fma3 = cpuinfo_has_x86_fma3();
114	hardware_config.use_x86_avx2 = cpuinfo_has_x86_avx2();	114	hardware_config.use_x86_avx2 = cpuinfo_has_x86_avx2();
115	hardware_config.use_x86_avx512f = cpuinfo_has_x86_avx512f();	115	hardware_config.use_x86_avx512f = 0;
116	hardware_config.use_x86_avx512skx = hardware_config.use_x86_avx512f &&	116	hardware_config.use_x86_avx512skx = 0;
117	cpuinfo_has_x86_avx512bw() && cpuinfo_has_x86_avx512dq() && cpuinfo_has_x86_avx512vl();	117	hardware_config.use_x86_avx512vbmi = 0;
118	hardware_config.use_x86_avx512vbmi = hardware_config.use_x86_avx512skx && cpuinfo_has_x86_avx512vbmi();	118	hardware_config.use_x86_avx512vnni = 0;
119	hardware_config.use_x86_avx512vnni = hardware_config.use_x86_avx512skx && cpuinfo_has_x86_avx512vnni();	119	hardware_config.use_x86_avx512vnnigfni = 0;
120	hardware_config.use_x86_avx512vnnigfni = hardware_config.use_x86_avx512vnni && cpuinfo_has_x86_gfni();
121	#if XNN_ENABLE_AVX512AMX	120	#if XNN_ENABLE_AVX512AMX
122	// TODO(fbarchard): Use cpuinfo_has_x86_amx_int8 when available.	121	// TODO(fbarchard): Use cpuinfo_has_x86_amx_int8 when available.
123	// Infer AMX support from Sapphire Rapids having fp16 and amx.	122	// Infer AMX support from Sapphire Rapids having fp16 and amx.
124	hardware_config.use_x86_avx512amx = hardware_config.use_x86_avx512vnnigfni && cpuinfo_has_x86_avx512fp16();	123	hardware_config.use_x86_avx512amx = 0;
125	#if XNN_ARCH_X86_64 && defined(__linux__) && !defined(CHROMIUM)	124	#if XNN_ARCH_X86_64 && defined(__linux__) && !defined(CHROMIUM)
126	if (hardware_config.use_x86_avx512amx) {	125	if (hardware_config.use_x86_avx512amx) {
127	size_t status = xnn_syscall(SYS_arch_prctl, ARCH_REQ_XCOMP_PERM, XFEATURE_XTILEDATA, 0);	126	size_t status = xnn_syscall(SYS_arch_prctl, ARCH_REQ_XCOMP_PERM, XFEATURE_XTILEDATA, 0);
Lines 135-141 Link Here
135	hardware_config.use_x86_avx512amx = 0;	134	hardware_config.use_x86_avx512amx = 0;
136	#endif	135	#endif
137	#if XNN_ENABLE_AVXVNNI	136	#if XNN_ENABLE_AVXVNNI
138	hardware_config.use_x86_avxvnni = hardware_config.use_x86_avx2 && cpuinfo_has_x86_avxvnni();	137	hardware_config.use_x86_avxvnni = 0;
139	#else	138	#else
140	hardware_config.use_x86_avxvnni = 0;	139	hardware_config.use_x86_avxvnni = 0;
141	#endif	140	#endif

Lines 106-117 Link Here

(-)a/third_party/xnnpack/src/src/configs/reduce-config.c (-13 / +2 lines)
106	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	106	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
107	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	107	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
108	assert(hardware_config != NULL);	108	assert(hardware_config != NULL);
109	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	109	if (hardware_config->use_x86_avx) {
110	f32_rminmax_config = (struct xnn_reduce_config) {
111	.ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rminmax_ukernel__avx512f_u64_acc4,
112	.element_tile = 64,
113	};
114	} else if (hardware_config->use_x86_avx) {
115	f32_rminmax_config = (struct xnn_reduce_config) {	110	f32_rminmax_config = (struct xnn_reduce_config) {
116	.ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rminmax_ukernel__avx_u32_acc4,	111	.ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rminmax_ukernel__avx_u32_acc4,
117	.init.f32_default = xnn_init_f32_default_avx_params,	112	.init.f32_default = xnn_init_f32_default_avx_params,
Lines 173-185 Link Here
173	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64	168	#elif XNN_ARCH_X86 \|\| XNN_ARCH_X86_64
174	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();	169	const struct xnn_hardware_config* hardware_config = xnn_init_hardware_config();
175	assert(hardware_config != NULL);	170	assert(hardware_config != NULL);
176	if (!XNN_PLATFORM_MOBILE && hardware_config->use_x86_avx512f) {	171	if (hardware_config->use_x86_avx) {
177	f32_rsum_config = (struct xnn_reduce_config) {
178	.ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rsum_ukernel__avx512f_u64_acc4,
179	.init.f32_scale = xnn_init_f32_scale_scalar_params,
180	.element_tile = 64,
181	};
182	} else if (hardware_config->use_x86_avx) {
183	f32_rsum_config = (struct xnn_reduce_config) {	172	f32_rsum_config = (struct xnn_reduce_config) {
184	.ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rsum_ukernel__avx_u32_acc4,	173	.ukernel = (xnn_reduce_ukernel_fn) xnn_f32_rsum_ukernel__avx_u32_acc4,
185	.init.f32_scale = xnn_init_f32_scale_avx_params,	174	.init.f32_scale = xnn_init_f32_scale_avx_params,

Lines 769-800 Link Here

(-)a/skia/BUILD.gn (-22 lines)
769	}	769	}
770	visibility = [ ":skcms" ]	770	visibility = [ ":skcms" ]
771	}	771	}
772	skia_source_set("skcms_TransformSkx") {
773	sources = skcms_TransformSkx
774	if (!is_win) {
775	cflags = [
776	"-w",
777	"-mavx512f",
778	"-mavx512dq",
779	"-mavx512cd",
780	"-mavx512bw",
781	"-mavx512vl",
782	"-std=c11",
783	]
784	} else {
785	cflags = [ "/arch:AVX512" ]
786	}
787	visibility = [ ":skcms" ]
788	}
789	} else {	772	} else {
790	skia_source_set("skcms_TransformHsw") {	773	skia_source_set("skcms_TransformHsw") {
791	sources = []	774	sources = []
792	visibility = [ ":skcms" ]	775	visibility = [ ":skcms" ]
793	}	776	}
794	skia_source_set("skcms_TransformSkx") {
795	sources = []
796	visibility = [ ":skcms" ]
797	}
798	}	777	}
799		778
800	source_set("skcms_TransformBaseline_and_public") {	779	source_set("skcms_TransformBaseline_and_public") {
Lines 823-829 Link Here
823	deps = [	802	deps = [
824	":skcms_TransformBaseline_and_public",	803	":skcms_TransformBaseline_and_public",
825	":skcms_TransformHsw",	804	":skcms_TransformHsw",
826	":skcms_TransformSkx",
827	]	805	]
828	public =	806	public =
829	rebase_path(skcms_public_headers, ".", "//third_party/skia/modules/skcms")	807	rebase_path(skcms_public_headers, ".", "//third_party/skia/modules/skcms")

Lines 61-73 Link Here

(-)a/third_party/xnnpack/BUILD.gn (-359 lines)
61	if (current_cpu == "x64" \|\| current_cpu == "x86") {	61	if (current_cpu == "x64" \|\| current_cpu == "x86") {
62	xnnpack_deps = [	62	xnnpack_deps = [
63	":amalgam_avx-no-avx2-no-f16c-no-fma",	63	":amalgam_avx-no-avx2-no-f16c-no-fma",
64	":amalgam_avx2-avxvnni-f16c-fma",
65	":amalgam_avx512f",
66	":amalgam_f16c-fma-avx2",	64	":amalgam_f16c-fma-avx2",
67	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl",
68	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi",
69	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni",
70	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni",
71	":amalgam_f16c-fma-no-avx2",	65	":amalgam_f16c-fma-no-avx2",
72	":amalgam_f16c-no-avx2-no-fma",	66	":amalgam_f16c-no-avx2-no-fma",
73	":amalgam_sse2-no-sse3",	67	":amalgam_sse2-no-sse3",
Lines 83-95 Link Here
83		77
84	xnnpack_standalone_deps = [	78	xnnpack_standalone_deps = [
85	":amalgam_avx-no-avx2-no-f16c-no-fma_standalone",	79	":amalgam_avx-no-avx2-no-f16c-no-fma_standalone",
86	":amalgam_avx2-avxvnni-f16c-fma_standalone",
87	":amalgam_avx512f_standalone",
88	":amalgam_f16c-fma-avx2_standalone",	80	":amalgam_f16c-fma-avx2_standalone",
89	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi_standalone",
90	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni_standalone",
91	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni_standalone",
92	":amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl_standalone",
93	":amalgam_f16c-fma-no-avx2_standalone",	81	":amalgam_f16c-fma-no-avx2_standalone",
94	":amalgam_f16c-no-avx2-no-fma_standalone",	82	":amalgam_f16c-no-avx2-no-fma_standalone",
95	":amalgam_sse2-no-sse3_standalone",	83	":amalgam_sse2-no-sse3_standalone",
Lines 304-405 Link Here
304	}	292	}
305	}	293	}
306		294
307	source_set("amalgam_avx2-avxvnni-f16c-fma") {
308	cflags = [
309	"-mavx2",
310	"-mavxvnni",
311	"-mf16c",
312	"-mfma",
313	]
314
315	sources = [ "src/src/amalgam/gen/avxvnni.c" ]
316
317	configs -= [ "//build/config/compiler:chromium_code" ]
318	configs += [ "//build/config/compiler:no_chromium_code" ]
319	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
320
321	deps = [
322	"//third_party/cpuinfo",
323	"//third_party/fp16",
324	"//third_party/fxdiv",
325	"//third_party/pthreadpool",
326	]
327
328	public_configs = [ ":xnnpack_config" ]
329	}
330
331	# This is a target that cannot depend on //base.
332	source_set("amalgam_avx2-avxvnni-f16c-fma_standalone") {
333	cflags = [
334	"-mavx2",
335	"-mavxvnni",
336	"-mf16c",
337	"-mfma",
338	]
339
340	sources = [ "src/src/amalgam/gen/avxvnni.c" ]
341
342	configs -= [ "//build/config/compiler:chromium_code" ]
343	configs += [ "//build/config/compiler:no_chromium_code" ]
344	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
345
346	deps = [
347	"//third_party/cpuinfo",
348	"//third_party/fp16",
349	"//third_party/fxdiv",
350	"//third_party/pthreadpool:pthreadpool_standalone",
351	]
352
353	public_configs = [ ":xnnpack_config" ]
354
355	if (!(is_android && use_order_profiling)) {
356	assert_no_deps = [ "//base" ]
357	}
358	}
359
360	source_set("amalgam_avx512f") {
361	cflags = [ "-mavx512f" ]
362
363	sources = [ "src/src/amalgam/gen/avx512f.c" ]
364
365	configs -= [ "//build/config/compiler:chromium_code" ]
366	configs += [ "//build/config/compiler:no_chromium_code" ]
367	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
368
369	deps = [
370	"//third_party/cpuinfo",
371	"//third_party/fp16",
372	"//third_party/fxdiv",
373	"//third_party/pthreadpool",
374	]
375
376	public_configs = [ ":xnnpack_config" ]
377	}
378
379	# This is a target that cannot depend on //base.
380	source_set("amalgam_avx512f_standalone") {
381	cflags = [ "-mavx512f" ]
382
383	sources = [ "src/src/amalgam/gen/avx512f.c" ]
384
385	configs -= [ "//build/config/compiler:chromium_code" ]
386	configs += [ "//build/config/compiler:no_chromium_code" ]
387	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
388
389	deps = [
390	"//third_party/cpuinfo",
391	"//third_party/fp16",
392	"//third_party/fxdiv",
393	"//third_party/pthreadpool:pthreadpool_standalone",
394	]
395
396	public_configs = [ ":xnnpack_config" ]
397
398	if (!(is_android && use_order_profiling)) {
399	assert_no_deps = [ "//base" ]
400	}
401	}
402
403	source_set("amalgam_f16c-fma-avx2") {	295	source_set("amalgam_f16c-fma-avx2") {
404	cflags = [	296	cflags = [
405	"-mavx2",	297	"-mavx2",
Lines 435-691 Link Here
435		327
436	configs -= [ "//build/config/compiler:chromium_code" ]	328	configs -= [ "//build/config/compiler:chromium_code" ]
437	configs += [ "//build/config/compiler:no_chromium_code" ]	329	configs += [ "//build/config/compiler:no_chromium_code" ]
438	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
439
440	deps = [
441	"//third_party/cpuinfo",
442	"//third_party/fp16",
443	"//third_party/fxdiv",
444	"//third_party/pthreadpool:pthreadpool_standalone",
445	]
446
447	public_configs = [ ":xnnpack_config" ]
448
449	if (!(is_android && use_order_profiling)) {
450	assert_no_deps = [ "//base" ]
451	}
452	}
453
454	source_set("amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl") {
455	cflags = [
456	"-mavx512bw",
457	"-mavx512cd",
458	"-mavx512dq",
459	"-mavx512f",
460	"-mavx512vl",
461	"-mf16c",
462	"-mfma",
463	]
464
465	sources = [ "src/src/amalgam/gen/avx512skx.c" ]
466
467	configs -= [ "//build/config/compiler:chromium_code" ]
468	configs += [ "//build/config/compiler:no_chromium_code" ]
469	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
470
471	deps = [
472	"//third_party/cpuinfo",
473	"//third_party/fp16",
474	"//third_party/fxdiv",
475	"//third_party/pthreadpool",
476	]
477
478	public_configs = [ ":xnnpack_config" ]
479	}
480
481	# This is a target that cannot depend on //base.
482	source_set(
483	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl_standalone") {
484	cflags = [
485	"-mavx512bw",
486	"-mavx512cd",
487	"-mavx512dq",
488	"-mavx512f",
489	"-mavx512vl",
490	"-mf16c",
491	"-mfma",
492	]
493
494	sources = [ "src/src/amalgam/gen/avx512skx.c" ]
495
496	configs -= [ "//build/config/compiler:chromium_code" ]
497	configs += [ "//build/config/compiler:no_chromium_code" ]
498	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
499
500	deps = [
501	"//third_party/cpuinfo",
502	"//third_party/fp16",
503	"//third_party/fxdiv",
504	"//third_party/pthreadpool:pthreadpool_standalone",
505	]
506
507	public_configs = [ ":xnnpack_config" ]
508
509	if (!(is_android && use_order_profiling)) {
510	assert_no_deps = [ "//base" ]
511	}
512	}
513
514	source_set(
515	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi") {
516	cflags = [
517	"-mavx512bw",
518	"-mavx512cd",
519	"-mavx512dq",
520	"-mavx512f",
521	"-mavx512vbmi",
522	"-mavx512vl",
523	"-mf16c",
524	"-mfma",
525	]
526
527	sources = [ "src/src/amalgam/gen/avx512vbmi.c" ]
528
529	configs -= [ "//build/config/compiler:chromium_code" ]
530	configs += [ "//build/config/compiler:no_chromium_code" ]
531	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
532
533	deps = [
534	"//third_party/cpuinfo",
535	"//third_party/fp16",
536	"//third_party/fxdiv",
537	"//third_party/pthreadpool",
538	]
539
540	public_configs = [ ":xnnpack_config" ]
541	}
542
543	# This is a target that cannot depend on //base.
544	source_set(
545	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vbmi_standalone") {
546	cflags = [
547	"-mavx512bw",
548	"-mavx512cd",
549	"-mavx512dq",
550	"-mavx512f",
551	"-mavx512vbmi",
552	"-mavx512vl",
553	"-mf16c",
554	"-mfma",
555	]
556
557	sources = [ "src/src/amalgam/gen/avx512vbmi.c" ]
558
559	configs -= [ "//build/config/compiler:chromium_code" ]
560	configs += [ "//build/config/compiler:no_chromium_code" ]
561	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
562
563	deps = [
564	"//third_party/cpuinfo",
565	"//third_party/fp16",
566	"//third_party/fxdiv",
567	"//third_party/pthreadpool:pthreadpool_standalone",
568	]
569
570	public_configs = [ ":xnnpack_config" ]
571
572	if (!(is_android && use_order_profiling)) {
573	assert_no_deps = [ "//base" ]
574	}
575	}
576
577	source_set(
578	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni") {
579	cflags = [
580	"-mavx512bw",
581	"-mavx512cd",
582	"-mavx512dq",
583	"-mavx512f",
584	"-mavx512vl",
585	"-mavx512vnni",
586	"-mf16c",
587	"-mfma",
588	]
589
590	sources = [ "src/src/amalgam/gen/avx512vnni.c" ]
591
592	configs -= [ "//build/config/compiler:chromium_code" ]
593	configs += [ "//build/config/compiler:no_chromium_code" ]
594	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
595
596	deps = [
597	"//third_party/cpuinfo",
598	"//third_party/fp16",
599	"//third_party/fxdiv",
600	"//third_party/pthreadpool",
601	]
602
603	public_configs = [ ":xnnpack_config" ]
604	}
605
606	# This is a target that cannot depend on //base.
607	source_set(
608	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni_standalone") {
609	cflags = [
610	"-mavx512bw",
611	"-mavx512cd",
612	"-mavx512dq",
613	"-mavx512f",
614	"-mavx512vl",
615	"-mavx512vnni",
616	"-mf16c",
617	"-mfma",
618	]
619
620	sources = [ "src/src/amalgam/gen/avx512vnni.c" ]
621
622	configs -= [ "//build/config/compiler:chromium_code" ]
623	configs += [ "//build/config/compiler:no_chromium_code" ]
624	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
625
626	deps = [
627	"//third_party/cpuinfo",
628	"//third_party/fp16",
629	"//third_party/fxdiv",
630	"//third_party/pthreadpool:pthreadpool_standalone",
631	]
632
633	public_configs = [ ":xnnpack_config" ]
634
635	if (!(is_android && use_order_profiling)) {
636	assert_no_deps = [ "//base" ]
637	}
638	}
639
640	source_set(
641	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni") {
642	cflags = [
643	"-mavx512bw",
644	"-mavx512cd",
645	"-mavx512dq",
646	"-mavx512f",
647	"-mavx512vl",
648	"-mavx512vnni",
649	"-mf16c",
650	"-mfma",
651	"-mgfni",
652	]
653
654	sources = [ "src/src/amalgam/gen/avx512vnnigfni.c" ]
655
656	configs -= [ "//build/config/compiler:chromium_code" ]
657	configs += [ "//build/config/compiler:no_chromium_code" ]
658	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
659
660	deps = [
661	"//third_party/cpuinfo",
662	"//third_party/fp16",
663	"//third_party/fxdiv",
664	"//third_party/pthreadpool",
665	]
666
667	public_configs = [ ":xnnpack_config" ]
668	}
669
670	# This is a target that cannot depend on //base.
671	source_set(
672	"amalgam_f16c-fma-avx512f-avx512cd-avx512bw-avx512dq-avx512vl-avx512vnni-gfni_standalone") {
673	cflags = [
674	"-mavx512bw",
675	"-mavx512cd",
676	"-mavx512dq",
677	"-mavx512f",
678	"-mavx512vl",
679	"-mavx512vnni",
680	"-mf16c",
681	"-mfma",
682	"-mgfni",
683	]
684
685	sources = [ "src/src/amalgam/gen/avx512vnnigfni.c" ]
686
687	configs -= [ "//build/config/compiler:chromium_code" ]
688	configs += [ "//build/config/compiler:no_chromium_code" ]
689	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]	330	configs += [ "//build/config/sanitizers:cfi_icall_generalize_pointers" ]
690		331
691	deps = [	332	deps = [