2092 lines
55 KiB
Python
2092 lines
55 KiB
Python
# Copyright 2020 Google LLC
|
|
#
|
|
# This source code is licensed under the BSD-style license found in the
|
|
# LICENSE file in the root directory of this source tree.
|
|
#
|
|
# Description:
|
|
# XNNPACK - optimized floating-point neural network operators library
|
|
|
|
load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
|
|
load("@bazel_skylib//lib:selects.bzl", "selects") # buildifier: disable=out-of-order-load
|
|
load("@rules_python//python:py_binary.bzl", "py_binary")
|
|
load(
|
|
":build_defs.bzl",
|
|
"xnnpack_cc_library",
|
|
"xnnpack_cxx_library",
|
|
"xnnpack_if_kleidiai_enabled",
|
|
"xnnpack_min_size_copts",
|
|
"xnnpack_slinky_deps",
|
|
"xnnpack_source_list_file",
|
|
"xnnpack_transitive_source_list",
|
|
"xnnpack_visibility",
|
|
)
|
|
load(
|
|
":build_params.bzl",
|
|
"xnnpack_archs",
|
|
"xnnpack_cc_library_for_arch",
|
|
"xnnpack_cond_for_arch",
|
|
"xnnpack_configurable_defines",
|
|
"xnnpack_list_sum",
|
|
"xnnpack_select_if",
|
|
"xnnpack_simd_f16_archs",
|
|
"xnnpack_simd_f32_archs",
|
|
"xnnpack_simd_s16_archs",
|
|
"xnnpack_simd_s32_archs",
|
|
"xnnpack_simd_s8_archs",
|
|
)
|
|
load(
|
|
"//gen:microkernels.bzl",
|
|
"all_srcs_for_arch",
|
|
"non_prod_asm_srcs_for_arch",
|
|
"non_prod_c_srcs_for_arch",
|
|
"prod_asm_srcs_for_arch",
|
|
"prod_c_srcs_for_arch",
|
|
)
|
|
load(
|
|
":build_srcs.bzl",
|
|
"LOGGING_SRCS",
|
|
"OPERATOR_SRCS",
|
|
"SUBGRAPH_SRCS",
|
|
"TABLE_SRCS",
|
|
"XNNPACK_SRCS",
|
|
)
|
|
|
|
licenses(["notice"])
|
|
|
|
exports_files(["LICENSE"])
|
|
|
|
exports_files(["preamble.js.lds"])
|
|
|
|
MICROKERNEL_DEFS = [
|
|
"src/f16-avgpool/f16-avgpool-minmax.h",
|
|
"src/f16-dwconv/f16-dwconv-minmax-multipass.h",
|
|
"src/f16-dwconv/f16-dwconv-minmax-unipass.h",
|
|
"src/f16-f32-vcvt/f16-f32-vcvt.h",
|
|
"src/f16-maxpool/f16-maxpool-minmax.h",
|
|
"src/f16-pavgpool/f16-pavgpool-minmax.h",
|
|
"src/f16-qu8-vcvt/f16-qu8-vcvt.h",
|
|
"src/f16-qs8-vcvt/f16-qs8-vcvt.h",
|
|
"src/f16-vabs/f16-vabs.h",
|
|
"src/f16-vbinary/f16-vadd.h",
|
|
"src/f16-vbinary/f16-vaddc.h",
|
|
"src/f16-vbinary/f16-vcmul.h",
|
|
"src/f16-vbinary/f16-vdiv.h",
|
|
"src/f16-vbinary/f16-vdivc.h",
|
|
"src/f16-vbinary/f16-vmax.h",
|
|
"src/f16-vbinary/f16-vmaxc.h",
|
|
"src/f16-vbinary/f16-vmin.h",
|
|
"src/f16-vbinary/f16-vminc.h",
|
|
"src/f16-vbinary/f16-vmul.h",
|
|
"src/f16-vbinary/f16-vmulc.h",
|
|
"src/f16-vbinary/f16-vprelu.h",
|
|
"src/f16-vbinary/f16-vpreluc.h",
|
|
"src/f16-vbinary/f16-vrdivc.h",
|
|
"src/f16-vbinary/f16-vrpreluc.h",
|
|
"src/f16-vbinary/f16-vrsubc.h",
|
|
"src/f16-vbinary/f16-vsqrdiff.h",
|
|
"src/f16-vbinary/f16-vsqrdiffc.h",
|
|
"src/f16-vbinary/f16-vsub.h",
|
|
"src/f16-vbinary/f16-vsubc.h",
|
|
"src/f16-vclamp/f16-vclamp.h",
|
|
"src/f16-velu/f16-velu.h",
|
|
"src/f16-vhswish/f16-vhswish.h",
|
|
"src/f16-vlrelu/f16-vlrelu.h",
|
|
"src/f16-vneg/f16-vneg.h",
|
|
"src/f16-vrnd/f16-vrndd.h",
|
|
"src/f16-vrnd/f16-vrndne.h",
|
|
"src/f16-vrnd/f16-vrndu.h",
|
|
"src/f16-vrnd/f16-vrndz.h",
|
|
"src/f16-vrsqrt/f16-vrsqrt.h",
|
|
"src/f16-vsigmoid/f16-vsigmoid.h",
|
|
"src/f16-vsqr/f16-vsqr.h",
|
|
"src/f16-vsqrt/f16-vsqrt.h",
|
|
"src/f16-vtanh/f16-vtanh.h",
|
|
"src/f32-avgpool/f32-avgpool-minmax.h",
|
|
"src/f32-dwconv/f32-dwconv-minmax-multipass.h",
|
|
"src/f32-dwconv/f32-dwconv-minmax-unipass.h",
|
|
"src/f32-dwconv/f32-dwconv-multipass.h",
|
|
"src/f32-dwconv/f32-dwconv-unipass.h",
|
|
"src/f32-f16-vcvt/f32-f16-vcvt.h",
|
|
"src/f32-maxpool/f32-maxpool-minmax.h",
|
|
"src/f32-pavgpool/f32-pavgpool-minmax.h",
|
|
"src/f32-qs8-vcvt/f32-qs8-vcvt.h",
|
|
"src/f32-qu8-vcvt/f32-qu8-vcvt.h",
|
|
"src/f32-raddextexp/f32-raddextexp.h",
|
|
"src/f32-vabs/f32-vabs.h",
|
|
"src/f32-vbinary/f32-vadd.h",
|
|
"src/f32-vbinary/f32-vaddc.h",
|
|
"src/f32-vbinary/f32-vcmul.h",
|
|
"src/f32-vbinary/f32-vcopysign.h",
|
|
"src/f32-vbinary/f32-vcopysignc.h",
|
|
"src/f32-vbinary/f32-vdiv.h",
|
|
"src/f32-vbinary/f32-vdivc.h",
|
|
"src/f32-vbinary/f32-vmax.h",
|
|
"src/f32-vbinary/f32-vmaxc.h",
|
|
"src/f32-vbinary/f32-vmin.h",
|
|
"src/f32-vbinary/f32-vminc.h",
|
|
"src/f32-vbinary/f32-vmul.h",
|
|
"src/f32-vbinary/f32-vmulc.h",
|
|
"src/f32-vbinary/f32-vprelu.h",
|
|
"src/f32-vbinary/f32-vpreluc.h",
|
|
"src/f32-vbinary/f32-vrcopysignc.h",
|
|
"src/f32-vbinary/f32-vrdivc.h",
|
|
"src/f32-vbinary/f32-vrpreluc.h",
|
|
"src/f32-vbinary/f32-vrsubc.h",
|
|
"src/f32-vbinary/f32-vsqrdiff.h",
|
|
"src/f32-vbinary/f32-vsqrdiffc.h",
|
|
"src/f32-vbinary/f32-vsub.h",
|
|
"src/f32-vbinary/f32-vsubc.h",
|
|
"src/f32-vclamp/f32-vclamp.h",
|
|
"src/f32-velu/f32-velu.h",
|
|
"src/f32-vexp/f32-vexp.h",
|
|
"src/f32-vgelu/f32-vgelu.h",
|
|
"src/f32-vhswish/f32-vhswish.h",
|
|
"src/f32-vlog/f32-vlog.h",
|
|
"src/f32-vlrelu/f32-vlrelu.h",
|
|
"src/f32-vneg/f32-vneg.h",
|
|
"src/f32-vrelu/f32-vrelu.h",
|
|
"src/f32-vrnd/f32-vrndd.h",
|
|
"src/f32-vrnd/f32-vrndne.h",
|
|
"src/f32-vrnd/f32-vrndu.h",
|
|
"src/f32-vrnd/f32-vrndz.h",
|
|
"src/f32-vrsqrt/f32-vrsqrt.h",
|
|
"src/f32-vscaleexpminusmax/f32-vscaleexpminusmax.h",
|
|
"src/f32-vscaleextexp/f32-vscaleextexp.h",
|
|
"src/f32-vsigmoid/f32-vsigmoid.h",
|
|
"src/f32-vsqr/f32-vsqr.h",
|
|
"src/f32-vsqrt/f32-vsqrt.h",
|
|
"src/f32-vtanh/f32-vtanh.h",
|
|
"src/qs8-dwconv/qs8-dwconv-minmax-multipass-fp32.h",
|
|
"src/qs8-dwconv/qs8-dwconv-minmax-multipass-rndnu.h",
|
|
"src/qs8-dwconv/qs8-dwconv-minmax-unipass-fp32.h",
|
|
"src/qs8-dwconv/qs8-dwconv-minmax-unipass-rndnu.h",
|
|
"src/qs8-f16-vcvt/qs8-f16-vcvt.h",
|
|
"src/qs8-f32-vcvt/qs8-f32-vcvt.h",
|
|
"src/qs8-packw/qs8-packw.h",
|
|
"src/qs8-qc4w-packw/qs8-qc4w-packw.h",
|
|
"src/qs8-qc8w-dwconv/qs8-qc8w-dwconv-minmax-multipass-fp32.h",
|
|
"src/qs8-qc8w-dwconv/qs8-qc8w-dwconv-minmax-unipass-fp32.h",
|
|
"src/qs8-vadd/qs8-vadd-minmax.h",
|
|
"src/qs8-vaddc/qs8-vaddc-minmax.h",
|
|
"src/qs8-vcvt/qs8-vcvt.h",
|
|
"src/qs8-vlrelu/qs8-vlrelu.h",
|
|
"src/qs8-vmul/qs8-vmul-minmax-fp32.h",
|
|
"src/qs8-vmul/qs8-vmul-minmax-rndnu.h",
|
|
"src/qs8-vmulc/qs8-vmulc-minmax-fp32.h",
|
|
"src/qs8-vmulc/qs8-vmulc-minmax-rndnu.h",
|
|
"src/qu8-avgpool/qu8-avgpool-minmax.h",
|
|
"src/qu8-dwconv/qu8-dwconv-minmax-multipass-fp32.h",
|
|
"src/qu8-dwconv/qu8-dwconv-minmax-multipass-rndnu.h",
|
|
"src/qu8-dwconv/qu8-dwconv-minmax-unipass-fp32.h",
|
|
"src/qu8-dwconv/qu8-dwconv-minmax-unipass-rndnu.h",
|
|
"src/qu8-f32-vcvt/qu8-f32-vcvt.h",
|
|
"src/qu8-vadd/qu8-vadd-minmax.h",
|
|
"src/qu8-vaddc/qu8-vaddc-minmax.h",
|
|
"src/qu8-vcvt/qu8-vcvt.h",
|
|
"src/qu8-vlrelu/qu8-vlrelu.h",
|
|
"src/qu8-vmul/qu8-vmul-minmax-fp32.h",
|
|
"src/qu8-vmul/qu8-vmul-minmax-rndnu.h",
|
|
"src/qu8-vmulc/qu8-vmulc-minmax-fp32.h",
|
|
"src/qu8-vmulc/qu8-vmulc-minmax-rndnu.h",
|
|
"src/s8-maxpool/s8-maxpool-minmax.h",
|
|
"src/s8-vclamp/s8-vclamp.h",
|
|
"src/s32-f32-vcvt/s32-f32-vcvt.h",
|
|
"src/u8-maxpool/u8-maxpool-minmax.h",
|
|
"src/u8-vclamp/u8-vclamp.h",
|
|
"src/xx-fill/xx-fill.h",
|
|
"src/xx-pad/xx-pad.h",
|
|
"src/xx-transposev/xx-transposev.h",
|
|
"src/x8-packq/x8-packq.h",
|
|
"src/x8-packw/x8-packw.h",
|
|
"src/x8-transposec/x8-transposec.h",
|
|
"src/x16-packw/x16-packw.h",
|
|
"src/x16-transposec/x16-transposec.h",
|
|
"src/x24-transposec/x24-transposec.h",
|
|
"src/x32-packb/x32-packb.h",
|
|
"src/x32-pack-lh/x32-pack-lh.h",
|
|
"src/x32-packw/x32-packw.h",
|
|
"src/x32-packx/x32-packx.h",
|
|
"src/x32-transposec/x32-transposec.h",
|
|
"src/x32-zerob/x32-zerob.h",
|
|
"src/x64-transposec/x64-transposec.h",
|
|
]
|
|
|
|
MICROKERNEL_HDRS = [
|
|
"src/xnnpack/argmaxpool.h",
|
|
"src/xnnpack/avgpool.h",
|
|
"src/xnnpack/conv.h",
|
|
"src/xnnpack/dwconv.h",
|
|
"src/xnnpack/fill.h",
|
|
"src/xnnpack/gemm.h",
|
|
"src/xnnpack/ibilinear.h",
|
|
"src/xnnpack/igemm.h",
|
|
"src/xnnpack/lut.h",
|
|
"src/xnnpack/maxpool.h",
|
|
"src/xnnpack/packb.h",
|
|
"src/xnnpack/packq.h",
|
|
"src/xnnpack/packw.h",
|
|
"src/xnnpack/packx.h",
|
|
"src/xnnpack/pad.h",
|
|
"src/xnnpack/pack-lh.h",
|
|
"src/xnnpack/pavgpool.h",
|
|
"src/xnnpack/ppmm.h",
|
|
"src/xnnpack/quantization.h",
|
|
"src/xnnpack/raddexpminusmax.h",
|
|
"src/xnnpack/raddextexp.h",
|
|
"src/xnnpack/raddstoreexpminusmax.h",
|
|
"src/xnnpack/reduce.h",
|
|
"src/xnnpack/spmm.h",
|
|
"src/xnnpack/transpose.h",
|
|
"src/xnnpack/unpool.h",
|
|
"src/xnnpack/vbinary.h",
|
|
"src/xnnpack/vcvt.h",
|
|
"src/xnnpack/vmulcaddc.h",
|
|
"src/xnnpack/vscaleexpminusmax.h",
|
|
"src/xnnpack/vscaleextexp.h",
|
|
"src/xnnpack/vunary.h",
|
|
"src/xnnpack/zerob.h",
|
|
"src/xnnpack/zip.h",
|
|
] + MICROKERNEL_DEFS
|
|
|
|
MICROKERNEL_DEPS = [
|
|
":assembly",
|
|
":common",
|
|
":hardware_config",
|
|
":math",
|
|
":microkernels_h",
|
|
":microparams",
|
|
":prefetch",
|
|
":tables",
|
|
":unaligned",
|
|
]
|
|
|
|
SIMD_HEADERS = [
|
|
"src/xnnpack/simd/f32-avx-base.h",
|
|
"src/xnnpack/simd/f32-generic-functions.h",
|
|
] + [
|
|
"src/xnnpack/simd/f32-" + arch + ".h"
|
|
for arch in xnnpack_simd_f32_archs()
|
|
] + [
|
|
"src/xnnpack/simd/f16-" + arch + ".h"
|
|
for arch in xnnpack_simd_f16_archs()
|
|
] + [
|
|
"src/xnnpack/simd/s16-" + arch + ".h"
|
|
for arch in xnnpack_simd_s16_archs()
|
|
] + [
|
|
"src/xnnpack/simd/s32-" + arch + ".h"
|
|
for arch in xnnpack_simd_s32_archs()
|
|
] + [
|
|
"src/xnnpack/simd/s8-" + arch + ".h"
|
|
for arch in xnnpack_simd_s8_archs()
|
|
]
|
|
|
|
exports_files(SIMD_HEADERS)
|
|
|
|
INTERNAL_MICROKERNEL_HDRS = MICROKERNEL_HDRS + SIMD_HEADERS + [
|
|
"src/xnnpack/cache.h",
|
|
"src/xnnpack/intrinsics-polyfill.h",
|
|
"src/xnnpack/requantization-stubs.h",
|
|
"src/xnnpack/unaligned.h",
|
|
]
|
|
|
|
ALL_MICROKERNEL_SRCS = xnnpack_list_sum(
|
|
[all_srcs_for_arch(arch) for arch in xnnpack_archs()],
|
|
[],
|
|
)
|
|
|
|
filegroup(
|
|
name = "microkernel_source_files",
|
|
data = ALL_MICROKERNEL_SRCS + ["src/microparams-init.c"],
|
|
visibility = xnnpack_visibility(),
|
|
)
|
|
|
|
filegroup(
|
|
name = "microkernel_header_files",
|
|
data = MICROKERNEL_HDRS + ["src/xnnpack/microparams.h"],
|
|
visibility = xnnpack_visibility(),
|
|
)
|
|
|
|
# Collection of internal microkernel related headers that declares all the microkernel functions.
|
|
xnnpack_cc_library(
|
|
name = "microkernels_h",
|
|
hdrs = INTERNAL_MICROKERNEL_HDRS,
|
|
deps = [
|
|
":common",
|
|
":config_hdrs",
|
|
":fp16",
|
|
":math",
|
|
":memory",
|
|
":microparams",
|
|
":mutex",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "xnnpack_h",
|
|
hdrs = ["include/xnnpack.h"],
|
|
deps = [
|
|
"@pthreadpool",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "experiments_config",
|
|
srcs = ["src/configs/experiments-config.c"],
|
|
hdrs = ["include/experiments-config.h"],
|
|
visibility = xnnpack_visibility(),
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "common",
|
|
hdrs = ["src/xnnpack/common.h"],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "init_once",
|
|
hdrs = ["src/xnnpack/init-once.h"],
|
|
deps = [
|
|
":common",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "microparams",
|
|
hdrs = [
|
|
"src/xnnpack/microparams.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "hardware_config",
|
|
srcs = ["src/configs/hardware-config.c"],
|
|
hdrs = [
|
|
"src/xnnpack/hardware-config.h",
|
|
"src/xnnpack/microfnptr.h",
|
|
"src/xnnpack/microparams.h",
|
|
],
|
|
defines = xnnpack_configurable_defines(),
|
|
deps = [
|
|
":common",
|
|
":init_once",
|
|
":logging",
|
|
] + select({
|
|
":cpuinfo_enabled": ["@cpuinfo"],
|
|
"//conditions:default": [],
|
|
}),
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "config_hdrs",
|
|
hdrs = [
|
|
"src/xnnpack/config.h",
|
|
"src/xnnpack/config-types.h",
|
|
],
|
|
deps = [
|
|
":hardware_config",
|
|
":params",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "microkernel_configs",
|
|
srcs = XNNPACK_SRCS,
|
|
hdrs = [
|
|
"src/xnnpack/config.h",
|
|
"src/xnnpack/config-types.h",
|
|
"src/xnnpack/microfnptr.h",
|
|
"src/xnnpack/microparams.h",
|
|
],
|
|
copts = select({
|
|
":cpuinfo_enabled": ["-DXNN_ENABLE_CPUINFO=1"],
|
|
"//conditions:default": ["-DXNN_ENABLE_CPUINFO=0"],
|
|
}),
|
|
defines = xnnpack_configurable_defines(),
|
|
deps = [
|
|
":common",
|
|
":config_hdrs",
|
|
":experiments_config",
|
|
":hardware_config",
|
|
":init_once",
|
|
":logging",
|
|
":math",
|
|
":microkernels_h",
|
|
":microparams_init",
|
|
":packing",
|
|
":prod_microkernels",
|
|
":xnnpack_h",
|
|
] + select({
|
|
":cpuinfo_enabled": ["@cpuinfo"],
|
|
"//conditions:default": [],
|
|
}),
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "params",
|
|
srcs = ["src/params.c"],
|
|
hdrs = [
|
|
"src/xnnpack/microfnptr.h",
|
|
"src/xnnpack/params.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
":microparams",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "fp16",
|
|
hdrs = ["src/xnnpack/fp16.h"],
|
|
compatible_with = [],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "math",
|
|
hdrs = ["src/xnnpack/math.h"],
|
|
deps = [
|
|
":common",
|
|
":config_hdrs",
|
|
":fp16",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "prefetch",
|
|
hdrs = ["src/xnnpack/prefetch.h"],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "unaligned",
|
|
hdrs = ["src/xnnpack/unaligned.h"],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "microparams_init",
|
|
srcs = ["src/microparams-init.c"],
|
|
hdrs = ["src/xnnpack/microparams-init.h"],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":microparams",
|
|
":requantization",
|
|
":unaligned",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "node_type",
|
|
hdrs = [
|
|
"src/xnnpack/node-type.h",
|
|
"src/xnnpack/node-type-defs.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "allocation_type",
|
|
hdrs = [
|
|
"src/xnnpack/allocation-type.h",
|
|
"src/xnnpack/allocation-type-defs.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "operator_type",
|
|
hdrs = [
|
|
"src/xnnpack/operator-type.h",
|
|
"src/xnnpack/operator-type-defs.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "microkernel_type",
|
|
hdrs = [
|
|
"src/xnnpack/microkernel-type.h",
|
|
"src/xnnpack/microkernel-type-defs.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "internal",
|
|
hdrs = ["src/xnnpack/internal.h"],
|
|
deps = [
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "allocator",
|
|
srcs = [
|
|
"src/allocator.c",
|
|
],
|
|
hdrs = ["src/xnnpack/allocator.h"],
|
|
deps = [
|
|
":common",
|
|
":logging",
|
|
":math",
|
|
":params",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "aligned_allocator",
|
|
hdrs = [
|
|
"src/xnnpack/aligned-allocator.h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cxx_library(
|
|
name = "buffer",
|
|
hdrs = ["src/xnnpack/buffer.h"],
|
|
deps = [":datatype"],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "isa_checks",
|
|
hdrs = [
|
|
"src/xnnpack/isa-checks.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
":hardware_config",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "memory",
|
|
srcs = [
|
|
"src/memory.c",
|
|
],
|
|
hdrs = ["src/xnnpack/memory.h"],
|
|
# Override using xnnpack_gcc_std_copts, as it defines -std=c99, which then makes MAP_ANONYMOUS
|
|
# undefined
|
|
gcc_copts = [],
|
|
deps = [
|
|
":common",
|
|
":logging",
|
|
":math",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "quantization",
|
|
hdrs = ["src/xnnpack/quantization.h"],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":microparams",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "requantization",
|
|
hdrs = ["src/xnnpack/requantization.h"],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":microparams",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "requantization_stubs",
|
|
hdrs = ["src/xnnpack/requantization-stubs.h"],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "tables",
|
|
srcs = TABLE_SRCS,
|
|
deps = [
|
|
":common",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "assembly",
|
|
hdrs = ["src/xnnpack/assembly.h"],
|
|
compatible_with = [],
|
|
)
|
|
|
|
genrule(
|
|
name = "generated_microkernel_lists",
|
|
srcs = glob([
|
|
"**/*.c",
|
|
"**/*.cc",
|
|
"**/*.S",
|
|
]),
|
|
outs = ([
|
|
"testdata/gen/microkernels.bzl",
|
|
"testdata/cmake/gen/microkernels.cmake",
|
|
] + ["testdata/gen/" + arch + "_microkernels.bzl" for arch in xnnpack_archs()] +
|
|
["testdata/cmake/gen/" + arch + "_microkernels.cmake" for arch in xnnpack_archs()]),
|
|
cmd = ("$(location //tools:update_microkernels) " +
|
|
"--output $(RULEDIR)/testdata " +
|
|
"--root_dir %s" % (package_name() if package_name() else ".")),
|
|
compatible_with = [],
|
|
tools = ["//tools:update_microkernels"],
|
|
visibility = ["//:__subpackages__"],
|
|
)
|
|
|
|
filegroup(
|
|
name = "cmake_microkernel_lists",
|
|
srcs = glob([
|
|
"cmake/gen/*.cmake",
|
|
]),
|
|
visibility = ["//:__subpackages__"],
|
|
)
|
|
|
|
# Generate the prod/all microkernel libraries for each architecture.
|
|
[
|
|
[
|
|
xnnpack_cc_library_for_arch(
|
|
name = arch + "_prod_microkernels",
|
|
srcs = prod_asm_srcs_for_arch(arch) + prod_c_srcs_for_arch(arch),
|
|
arch = arch,
|
|
compatible_with = [],
|
|
defines = xnnpack_configurable_defines(),
|
|
# Internal build flag.
|
|
tags = ["nobuilder"],
|
|
deps = MICROKERNEL_DEPS,
|
|
),
|
|
xnnpack_cc_library_for_arch(
|
|
name = arch + "_all_microkernels",
|
|
srcs = non_prod_asm_srcs_for_arch(arch) + non_prod_c_srcs_for_arch(arch),
|
|
arch = arch,
|
|
compatible_with = [],
|
|
defines = xnnpack_configurable_defines(),
|
|
tags = ["nobuilder"],
|
|
deps = MICROKERNEL_DEPS + [":" + arch + "_prod_microkernels"],
|
|
),
|
|
]
|
|
for arch in xnnpack_archs()
|
|
]
|
|
|
|
xnnpack_cc_library(
|
|
name = "log_level_default",
|
|
defines = select({
|
|
# No logging in optimized mode
|
|
":optimized_build": ["XNN_LOG_LEVEL=0"],
|
|
# Info logging in debug mode. Use `--define=xnn_log_level=debug` for full logging.
|
|
":debug_build": ["XNN_LOG_LEVEL=4"],
|
|
# Error-only logging in default (fastbuild) mode
|
|
"//conditions:default": ["XNN_LOG_LEVEL=2"],
|
|
}),
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "logging",
|
|
srcs = LOGGING_SRCS,
|
|
hdrs = ["src/xnnpack/log.h"],
|
|
copts = select({
|
|
":debug_build": [],
|
|
"//conditions:default": xnnpack_min_size_copts(),
|
|
}) + select({
|
|
":xnn_log_to_stdio_explicit_true": ["-DXNN_LOG_TO_STDIO=1"],
|
|
"//conditions:default": [],
|
|
}),
|
|
defines = select({
|
|
":xnn_log_level_explicit_none": ["XNN_LOG_LEVEL=0"],
|
|
":xnn_log_level_explicit_fatal": ["XNN_LOG_LEVEL=1"],
|
|
":xnn_log_level_explicit_error": ["XNN_LOG_LEVEL=2"],
|
|
":xnn_log_level_explicit_warning": ["XNN_LOG_LEVEL=3"],
|
|
":xnn_log_level_explicit_info": ["XNN_LOG_LEVEL=4"],
|
|
":xnn_log_level_explicit_debug": ["XNN_LOG_LEVEL=5"],
|
|
"//conditions:default": [],
|
|
}),
|
|
visibility = xnnpack_visibility(),
|
|
deps = select({
|
|
":xnn_log_level_explicit_none": [],
|
|
":xnn_log_level_explicit_fatal": [],
|
|
":xnn_log_level_explicit_error": [],
|
|
":xnn_log_level_explicit_warning": [],
|
|
":xnn_log_level_explicit_info": [],
|
|
":xnn_log_level_explicit_debug": [],
|
|
"//conditions:default": [":log_level_default"],
|
|
}) + [
|
|
":allocation_type",
|
|
":common",
|
|
":microkernel_type",
|
|
":node_type",
|
|
":operator_type",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
[
|
|
cc_library(
|
|
name = lib + "_microkernels",
|
|
compatible_with = [],
|
|
defines = xnnpack_configurable_defines(),
|
|
hdrs_check = "strict",
|
|
linkstatic = True,
|
|
visibility = ["//:__subpackages__"],
|
|
deps = xnnpack_list_sum(
|
|
[
|
|
xnnpack_select_if(
|
|
xnnpack_cond_for_arch(arch),
|
|
[":" + arch + "_" + lib + "_microkernels"],
|
|
)
|
|
for arch in xnnpack_archs()
|
|
],
|
|
[],
|
|
),
|
|
)
|
|
for lib in ("prod", "all")
|
|
]
|
|
|
|
xnnpack_cc_library(
|
|
name = "im2col",
|
|
srcs = ["src/im2col.c"],
|
|
hdrs = [
|
|
"src/xnnpack/im2col.h",
|
|
],
|
|
deps = [":common"],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "indirection",
|
|
srcs = ["src/indirection.c"],
|
|
hdrs = ["src/xnnpack/indirection.h"],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":microparams",
|
|
":operator_h",
|
|
":xnnpack_h",
|
|
"@FXdiv",
|
|
],
|
|
)
|
|
|
|
xnnpack_cxx_library(
|
|
name = "packing",
|
|
srcs = ["src/reference/packing.cc"],
|
|
hdrs = ["src/xnnpack/pack.h"],
|
|
defines = xnnpack_configurable_defines(),
|
|
deps = [
|
|
":common",
|
|
":config_hdrs",
|
|
":logging",
|
|
":math",
|
|
":microparams",
|
|
":params",
|
|
":unaligned",
|
|
":xnnpack_h",
|
|
] + xnnpack_if_kleidiai_enabled([
|
|
"@KleidiAI//kai/ukernels/matmul",
|
|
]),
|
|
)
|
|
|
|
py_binary(
|
|
name = "generate_build_identifier_py",
|
|
srcs = ["scripts/generate-build-identifier.py"],
|
|
main = "scripts/generate-build-identifier.py",
|
|
tags = ["notap"], # This should only be built as part of the related genrule.
|
|
target_compatible_with = select({
|
|
"//build_config:emscripten": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
}),
|
|
)
|
|
|
|
# This target gathers the transitive sources from its deps and adds them to the
|
|
# srcs attribute.
|
|
xnnpack_transitive_source_list(
|
|
name = "build_identifier_ukernel_srcs",
|
|
srcs = ["src/reference/packing.cc"],
|
|
deps = [":prod_microkernels"],
|
|
)
|
|
|
|
# Windows builds fail on the generate_build_identifier genrule because the
|
|
# command line is too long when expanding the source file paths to feed to the
|
|
# Python generation script. To work around this, we write those files to a
|
|
# single file that we.
|
|
#
|
|
# This is what the below command does. It ONLY exposes the list file as an output.
|
|
#
|
|
# See the next genrule comment for the rest of the explanation.
|
|
xnnpack_source_list_file(
|
|
name = "build_identifier_ukernel_srcs_list",
|
|
srcs = [":build_identifier_ukernel_srcs"],
|
|
compatible_with = [],
|
|
)
|
|
|
|
# When the python script gets executed, the files it has access to are limited
|
|
# to what is explicitely requested in the `srcs` attribute. We add the "list"
|
|
# and the source paths to the sources to make them available to the Python
|
|
# script and only expand the list file path to keep the command line short
|
|
# enough to avoid having Windows break down.
|
|
#
|
|
# I have not found a way to transitively pull the source files from the "list"
|
|
# target and make them available from the Python script without adding them to
|
|
# the `srcs` attribute (making them expanded in the "$(SRCS)" variable), thus
|
|
# the repetition.
|
|
genrule(
|
|
name = "generate_build_identifier",
|
|
srcs = [
|
|
":build_identifier_ukernel_srcs_list",
|
|
":build_identifier_ukernel_srcs",
|
|
],
|
|
outs = ["src/build_identifier.c"],
|
|
cmd = "$(location generate_build_identifier_py) --output $@ --input_file_list $(location :build_identifier_ukernel_srcs_list)",
|
|
tools = [":generate_build_identifier_py"],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "build_identifier",
|
|
srcs = ["src/build_identifier.c"],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "cache",
|
|
srcs = ["src/cache.c"],
|
|
hdrs = ["src/xnnpack/cache.h"],
|
|
deps = [
|
|
":allocator",
|
|
":common",
|
|
":logging",
|
|
":math",
|
|
":memory",
|
|
":mutex",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
# Define a library with just the header to remove circular dependencies:
|
|
# operator-run (compute) <-> operators.
|
|
xnnpack_cc_library(
|
|
name = "compute_h",
|
|
hdrs = [
|
|
"src/xnnpack/compute.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":params",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "microkernel_utils",
|
|
srcs = ["src/microkernel-utils.c"],
|
|
hdrs = ["src/xnnpack/microkernel-utils.h"],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
],
|
|
)
|
|
|
|
# Define a library with just the header to remove circular dependencies:
|
|
# indirection <-> operators.
|
|
xnnpack_cc_library(
|
|
name = "operator_h",
|
|
hdrs = [
|
|
"src/xnnpack/operator.h",
|
|
],
|
|
deps = [
|
|
":allocator",
|
|
":cache",
|
|
":compute_h",
|
|
":microkernel_type",
|
|
":operator_type",
|
|
":params",
|
|
"@pthreadpool",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "operator_utils",
|
|
srcs = ["src/operator-utils.c"],
|
|
hdrs = ["src/xnnpack/operator-utils.h"],
|
|
deps = [
|
|
":allocator",
|
|
":common",
|
|
":logging",
|
|
":math",
|
|
":operator_h",
|
|
":operator_type",
|
|
":params",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cxx_library(
|
|
name = "reference_ukernels",
|
|
srcs = [
|
|
"src/reference/binary-elementwise.cc",
|
|
"src/reference/unary-elementwise.cc",
|
|
],
|
|
hdrs = [
|
|
"src/xnnpack/reference-config.h",
|
|
"src/xnnpack/reference-utils.h",
|
|
],
|
|
compatible_with = [],
|
|
defines = xnnpack_configurable_defines(),
|
|
deps = [
|
|
":common",
|
|
":config_hdrs",
|
|
":datatype",
|
|
":hardware_config",
|
|
":math",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "datatype",
|
|
srcs = ["src/datatype.c"],
|
|
hdrs = ["src/xnnpack/datatype.h"],
|
|
compatible_with = [],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "operators",
|
|
srcs = OPERATOR_SRCS,
|
|
hdrs = [
|
|
"src/xnnpack/compute.h",
|
|
"src/xnnpack/operator.h",
|
|
],
|
|
copts = select({
|
|
":debug_build": [],
|
|
"//conditions:default": xnnpack_min_size_copts(),
|
|
}) + select({
|
|
":xnn_enable_hmp_explicit_false": ["-DXNN_MAX_UARCH_TYPES=1"],
|
|
"//conditions:default": [],
|
|
}),
|
|
defines = xnnpack_configurable_defines(),
|
|
deps = [
|
|
":allocator",
|
|
":cache",
|
|
":common",
|
|
":datatype",
|
|
":fp16",
|
|
":indirection",
|
|
":logging",
|
|
":math",
|
|
":microkernel_configs",
|
|
":microkernel_type",
|
|
":microkernel_utils",
|
|
":microkernels_h",
|
|
":microparams_init",
|
|
":node_type",
|
|
":normalization",
|
|
":operator_type",
|
|
":operator_utils",
|
|
":packing",
|
|
":params",
|
|
":quantization",
|
|
":reference_ukernels",
|
|
":xnnpack_h",
|
|
"@pthreadpool",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "subgraph_h",
|
|
hdrs = [
|
|
"src/xnnpack/subgraph.h",
|
|
],
|
|
compatible_with = [],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "subgraph",
|
|
srcs = SUBGRAPH_SRCS,
|
|
hdrs = [
|
|
"src/xnnpack/memory-planner.h",
|
|
"src/xnnpack/reshape-helpers.h",
|
|
"src/xnnpack/subgraph.h",
|
|
"src/xnnpack/subgraph-validation.h",
|
|
],
|
|
defines = xnnpack_configurable_defines(),
|
|
deps = [
|
|
":allocation_type",
|
|
":allocator",
|
|
":cache",
|
|
":common",
|
|
":config_hdrs",
|
|
":datatype",
|
|
":fp16",
|
|
":hardware_config",
|
|
":internal",
|
|
":logging",
|
|
":math",
|
|
":memory",
|
|
":microkernel_type",
|
|
":microkernels_h",
|
|
":node_type",
|
|
":operator_type",
|
|
":operator_utils",
|
|
":operators",
|
|
":params",
|
|
":requantization",
|
|
":subgraph_h",
|
|
":xnnpack_h",
|
|
"@pthreadpool",
|
|
] + xnnpack_slinky_deps(),
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "mutex",
|
|
srcs = [
|
|
"src/mutex.c",
|
|
],
|
|
hdrs = [
|
|
"src/xnnpack/mutex.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
":logging",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "normalization",
|
|
srcs = ["src/normalization.c"],
|
|
hdrs = [
|
|
"src/xnnpack/normalization.h",
|
|
],
|
|
deps = [
|
|
":common",
|
|
":math",
|
|
":xnnpack_h",
|
|
],
|
|
)
|
|
|
|
xnnpack_cc_library(
|
|
name = "XNNPACK",
|
|
srcs = [
|
|
"src/init.c",
|
|
],
|
|
hdrs = [
|
|
"include/xnnpack.h",
|
|
],
|
|
copts = select({
|
|
":debug_build": [],
|
|
"//conditions:default": xnnpack_min_size_copts(),
|
|
}) + select({
|
|
":xnn_enable_hmp_explicit_false": ["-DXNN_MAX_UARCH_TYPES=1"],
|
|
"//conditions:default": [],
|
|
}),
|
|
visibility = xnnpack_visibility(),
|
|
deps = [
|
|
":allocator",
|
|
":build_identifier",
|
|
":common",
|
|
":config_hdrs",
|
|
":hardware_config",
|
|
":init_once",
|
|
":logging",
|
|
":math",
|
|
":microkernels_h",
|
|
":microparams",
|
|
":microparams_init",
|
|
":operators",
|
|
":params",
|
|
":subgraph",
|
|
"@pthreadpool",
|
|
],
|
|
)
|
|
|
|
# Specialized XNNPACK version for TensorFlow Lite. Excludes operators currently
|
|
# not used by the TensorFlow Lite XNNPACK delegate to minimize code size.
|
|
xnnpack_cc_library(
|
|
name = "xnnpack_for_tflite",
|
|
srcs = [
|
|
"src/init.c",
|
|
],
|
|
hdrs = ["include/xnnpack.h"],
|
|
copts = select({
|
|
":debug_build": [],
|
|
"//conditions:default": xnnpack_min_size_copts(),
|
|
}) + select({
|
|
":xnn_enable_hmp_explicit_false": ["-DXNN_MAX_UARCH_TYPES=1"],
|
|
"//conditions:default": [],
|
|
}),
|
|
visibility = xnnpack_visibility(),
|
|
deps = [
|
|
":allocator",
|
|
":hardware_config",
|
|
":init_once",
|
|
":logging",
|
|
":params",
|
|
"@pthreadpool",
|
|
],
|
|
)
|
|
|
|
# Specialized XNNPACK version for TensorFlow.js. Excludes operators currently
|
|
# not used by the TensorFlow.js WebAssembly backend to minimize code size.
|
|
xnnpack_cc_library(
|
|
name = "xnnpack_for_tfjs",
|
|
srcs = [
|
|
"src/init.c",
|
|
],
|
|
hdrs = ["include/xnnpack.h"],
|
|
copts = select({
|
|
":debug_build": [],
|
|
"//conditions:default": xnnpack_min_size_copts(),
|
|
}) + select({
|
|
":xnn_enable_hmp_explicit_false": ["-DXNN_MAX_UARCH_TYPES=1"],
|
|
"//conditions:default": [],
|
|
}),
|
|
visibility = xnnpack_visibility(),
|
|
deps = [
|
|
":allocator",
|
|
":hardware_config",
|
|
":init_once",
|
|
":logging",
|
|
":params",
|
|
"@pthreadpool",
|
|
],
|
|
)
|
|
|
|
############################# Build configurations #############################
|
|
|
|
# Enables usage of ARM FP16 (FP16 arithmetics) scalar kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_fp16_scalar_explicit_true",
|
|
define_values = {"xnn_enable_arm_fp16_scalar": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM FP16 (FP16 arithmetics) scalar kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_fp16_scalar_explicit_false",
|
|
define_values = {"xnn_enable_arm_fp16_scalar": "false"},
|
|
)
|
|
|
|
# Enables usage of ARM FP16 (FP16 arithmetics) vector kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_fp16_vector_explicit_true",
|
|
define_values = {"xnn_enable_arm_fp16_vector": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM FP16 (FP16 arithmetics) vector kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_fp16_vector_explicit_false",
|
|
define_values = {"xnn_enable_arm_fp16_vector": "false"},
|
|
)
|
|
|
|
# Enables usage of ARM BF16 (BF16 arithmetics) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_bf16_explicit_true",
|
|
define_values = {"xnn_enable_arm_bf16": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM BF16 (BF16 arithmetics) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_bf16_explicit_false",
|
|
define_values = {"xnn_enable_arm_bf16": "false"},
|
|
)
|
|
|
|
# Enables usage of ARM DotProd (integer dot product) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_dotprod_explicit_true",
|
|
define_values = {"xnn_enable_arm_dotprod": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM DotProd (integer dot product) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_dotprod_explicit_false",
|
|
define_values = {"xnn_enable_arm_dotprod": "false"},
|
|
)
|
|
|
|
# Enables usage of ARM I8MM (8-bit integer matrix multiply accumulate) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_i8mm_explicit_true",
|
|
define_values = {"xnn_enable_arm_i8mm": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM I8MM (8-bit integer matrix multiply accumulate) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_i8mm_explicit_false",
|
|
define_values = {"xnn_enable_arm_i8mm": "false"},
|
|
)
|
|
|
|
# Enables usage of ARM SME kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_sme_explicit_true",
|
|
define_values = {"xnn_enable_arm_sme": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM SME kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_sme_explicit_false",
|
|
define_values = {"xnn_enable_arm_sme": "false"},
|
|
)
|
|
|
|
# Enables usage of ARM SME2 kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_sme2_explicit_true",
|
|
define_values = {"xnn_enable_arm_sme2": "true"},
|
|
)
|
|
|
|
# Disables usage of ARM SME2 kernels.
|
|
config_setting(
|
|
name = "xnn_enable_arm_sme2_explicit_false",
|
|
define_values = {"xnn_enable_arm_sme2": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512F (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512f_explicit_true",
|
|
define_values = {"xnn_enable_avx512f": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512F (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512f_explicit_false",
|
|
define_values = {"xnn_enable_avx512f": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512SKX (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512skx_explicit_true",
|
|
define_values = {"xnn_enable_avx512skx": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512SKX (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512skx_explicit_false",
|
|
define_values = {"xnn_enable_avx512skx": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512VBMI (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512vbmi_explicit_true",
|
|
define_values = {"xnn_enable_avx512vbmi": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512VBMI (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512vbmi_explicit_false",
|
|
define_values = {"xnn_enable_avx512vbmi": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512VNNI (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512vnni_explicit_true",
|
|
define_values = {"xnn_enable_avx512vnni": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512VNNI (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512vnni_explicit_false",
|
|
define_values = {"xnn_enable_avx512vnni": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512VNNIGFNI (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512vnnigfni_explicit_true",
|
|
define_values = {"xnn_enable_avx512vnnigfni": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512VNNIGFNI (evex512) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512vnnigfni_explicit_false",
|
|
define_values = {"xnn_enable_avx512vnnigfni": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512-AMX (integer matrix multiply) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512amx_explicit_true",
|
|
define_values = {"xnn_enable_avx512amx": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512-AMX (integer matrix multiply) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512amx_explicit_false",
|
|
define_values = {"xnn_enable_avx512amx": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX512-FP16 (fp16 arithmetic) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512fp16_explicit_true",
|
|
define_values = {"xnn_enable_avx512fp16": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX512-FP16 (fp16 arithmetic) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx512fp16_explicit_false",
|
|
define_values = {"xnn_enable_avx512fp16": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX-VNNI (integer dot product) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avxvnni_explicit_true",
|
|
define_values = {"xnn_enable_avxvnni": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX-VNNI (integer dot product) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avxvnni_explicit_false",
|
|
define_values = {"xnn_enable_avxvnni": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX-VNNI-INT8 (integer dot product) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avxvnniint8_explicit_true",
|
|
define_values = {"xnn_enable_avxvnniint8": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX-VNNI-INT8 (integer dot product) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avxvnniint8_explicit_false",
|
|
define_values = {"xnn_enable_avxvnniint8": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX256SKX (evex256) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx256skx_explicit_true",
|
|
define_values = {"xnn_enable_avx256skx": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX256SKX (evex256) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx256skx_explicit_false",
|
|
define_values = {"xnn_enable_avx256skx": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX256VNNI (evex256) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx256vnni_explicit_true",
|
|
define_values = {"xnn_enable_avx256vnni": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX256VNNI (evex256) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx256vnni_explicit_false",
|
|
define_values = {"xnn_enable_avx256vnni": "false"},
|
|
)
|
|
|
|
# Enables usage of Intel AVX256VNNIGFNI (evex256) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx256vnnigfni_explicit_true",
|
|
define_values = {"xnn_enable_avx256vnnigfni": "true"},
|
|
)
|
|
|
|
# Disables usage of Intel AVX256VNNIGFNI (evex256) kernels.
|
|
config_setting(
|
|
name = "xnn_enable_avx256vnnigfni_explicit_false",
|
|
define_values = {"xnn_enable_avx256vnnigfni": "false"},
|
|
)
|
|
|
|
# Enables usage of Hexagon HVX kernels.
|
|
config_setting(
|
|
name = "xnn_enable_hvx_explicit_true",
|
|
define_values = {"xnn_enable_hvx": "true"},
|
|
)
|
|
|
|
# Disables usage of Hexagon HVX kernels.
|
|
config_setting(
|
|
name = "xnn_enable_hvx_explicit_false",
|
|
define_values = {"xnn_enable_hvx": "false"},
|
|
)
|
|
|
|
# Enables usage of RISC-V Vector kernels.
|
|
config_setting(
|
|
name = "xnn_enable_riscv_vector_explicit_true",
|
|
define_values = {"xnn_enable_riscv_vector": "true"},
|
|
)
|
|
|
|
# Disables usage of RISC-V Vector kernels.
|
|
config_setting(
|
|
name = "xnn_enable_riscv_vector_explicit_false",
|
|
define_values = {"xnn_enable_riscv_vector": "false"},
|
|
)
|
|
|
|
# Enables usage of RISC-V FP16 (FP16 arithmetics) vector kernels.
|
|
config_setting(
|
|
name = "xnn_enable_riscv_fp16_vector_explicit_true",
|
|
define_values = {"xnn_enable_riscv_fp16_vector": "true"},
|
|
)
|
|
|
|
# Disables usage of RISC-V FP16 (FP16 arithmetics) vector kernels.
|
|
config_setting(
|
|
name = "xnn_enable_riscv_fp16_vector_explicit_false",
|
|
define_values = {"xnn_enable_riscv_fp16_vector": "false"},
|
|
)
|
|
|
|
# Enables usage of cpuinfo library.
|
|
config_setting(
|
|
name = "xnn_enable_cpuinfo_explicit_true",
|
|
define_values = {"xnn_enable_cpuinfo": "true"},
|
|
)
|
|
|
|
# Disables usage of cpuinfo library.
|
|
config_setting(
|
|
name = "xnn_enable_cpuinfo_explicit_false",
|
|
define_values = {"xnn_enable_cpuinfo": "false"},
|
|
)
|
|
|
|
# Enables usage of the KleidiAI library.
|
|
config_setting(
|
|
name = "xnn_enable_kleidiai_explicit_true",
|
|
define_values = {"xnn_enable_kleidiai": "true"},
|
|
)
|
|
|
|
# Disables usage of the KleidiAI library.
|
|
config_setting(
|
|
name = "xnn_enable_kleidiai_explicit_false",
|
|
define_values = {"xnn_enable_kleidiai": "false"},
|
|
)
|
|
|
|
# Enables usage of assembly kernels.
|
|
config_setting(
|
|
name = "xnn_enable_assembly_explicit_true",
|
|
define_values = {"xnn_enable_assembly": "true"},
|
|
)
|
|
|
|
# Disables usage of assembly kernels.
|
|
config_setting(
|
|
name = "xnn_enable_assembly_explicit_false",
|
|
define_values = {"xnn_enable_assembly": "false"},
|
|
)
|
|
|
|
# Enables usage of sparse inference.
|
|
config_setting(
|
|
name = "xnn_enable_sparse_explicit_true",
|
|
define_values = {"xnn_enable_sparse": "true"},
|
|
)
|
|
|
|
# Disables usage of sparse inference.
|
|
config_setting(
|
|
name = "xnn_enable_sparse_explicit_false",
|
|
define_values = {"xnn_enable_sparse": "false"},
|
|
)
|
|
|
|
# Disables usage of HMP-aware optimizations.
|
|
config_setting(
|
|
name = "xnn_enable_hmp_explicit_false",
|
|
define_values = {"xnn_enable_hmp": "false"},
|
|
)
|
|
|
|
# Enable usage of optimized memory allocation
|
|
config_setting(
|
|
name = "xnn_enable_memopt_explicit_true",
|
|
define_values = {"xnn_enable_memopt": "true"},
|
|
)
|
|
|
|
# Disable usage of optimized memory allocation
|
|
config_setting(
|
|
name = "xnn_enable_memopt_explicit_false",
|
|
define_values = {"xnn_enable_memopt": "false"},
|
|
)
|
|
|
|
# Enables usage of slinky locality optimizations
|
|
config_setting(
|
|
name = "slinky_enabled",
|
|
define_values = {"xnn_use_slinky": "true"},
|
|
)
|
|
|
|
# Enables usage of mr heuristic to select microkernels.
|
|
config_setting(
|
|
name = "xnn_enable_gemm_m_specialization_explicit_true",
|
|
define_values = {"xnn_enable_gemm_m_specialization": "true"},
|
|
)
|
|
|
|
# Disables usage of mr heuristic to select microkernels.
|
|
config_setting(
|
|
name = "xnn_enable_gemm_m_specialization_explicit_false",
|
|
define_values = {"xnn_enable_gemm_m_specialization": "false"},
|
|
)
|
|
|
|
# Enables usage of DWCONV multipass kernels.
|
|
config_setting(
|
|
name = "xnn_enable_dwconv_multipass_explicit_true",
|
|
define_values = {"xnn_enable_dwconv_multipass": "true"},
|
|
)
|
|
|
|
# Disables usage of DWCONV multipass kernels.
|
|
config_setting(
|
|
name = "xnn_enable_dwconv_multipass_explicit_false",
|
|
define_values = {"xnn_enable_dwconv_multipass": "false"},
|
|
)
|
|
|
|
# Force logging to stderr/stdout
|
|
config_setting(
|
|
name = "xnn_log_to_stdio_explicit_true",
|
|
define_values = {"xnn_log_to_stdio": "true"},
|
|
)
|
|
|
|
# Fully disable logging
|
|
config_setting(
|
|
name = "xnn_log_level_explicit_none",
|
|
define_values = {"xnn_log_level": "none"},
|
|
)
|
|
|
|
# Log fatal errors only
|
|
config_setting(
|
|
name = "xnn_log_level_explicit_fatal",
|
|
define_values = {"xnn_log_level": "fatal"},
|
|
)
|
|
|
|
# Log fatal and non-fatal errors
|
|
config_setting(
|
|
name = "xnn_log_level_explicit_error",
|
|
define_values = {"xnn_log_level": "error"},
|
|
)
|
|
|
|
# Log warnings and errors
|
|
config_setting(
|
|
name = "xnn_log_level_explicit_warning",
|
|
define_values = {"xnn_log_level": "warning"},
|
|
)
|
|
|
|
# Log information messages, warnings and errors
|
|
config_setting(
|
|
name = "xnn_log_level_explicit_info",
|
|
define_values = {"xnn_log_level": "info"},
|
|
)
|
|
|
|
# Log all messages, including debug messages
|
|
config_setting(
|
|
name = "xnn_log_level_explicit_debug",
|
|
define_values = {"xnn_log_level": "debug"},
|
|
)
|
|
|
|
# Builds with -c dbg
|
|
config_setting(
|
|
name = "debug_build",
|
|
values = {
|
|
"compilation_mode": "dbg",
|
|
},
|
|
)
|
|
|
|
# Builds with -c opt
|
|
config_setting(
|
|
name = "optimized_build",
|
|
values = {
|
|
"compilation_mode": "opt",
|
|
},
|
|
)
|
|
|
|
######################## Composite build configurations #######################
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_fp16_scalar_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:aarch32",
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "arm_fp16_scalar_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_fp16_scalar_explicit_true": ":xnn_enable_arm_fp16_scalar_explicit_true",
|
|
":xnn_enable_arm_fp16_scalar_explicit_false": ":xnn_enable_arm_fp16_scalar_explicit_true",
|
|
"//conditions:default": ":arm_fp16_scalar_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_fp16_vector_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:aarch32",
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_neondotfp16_enabled",
|
|
match_all = [
|
|
":arm_fp16_vector_enabled",
|
|
":arm_dotprod_enabled",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "arm_fp16_vector_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_fp16_vector_explicit_true": ":xnn_enable_arm_fp16_vector_explicit_true",
|
|
":xnn_enable_arm_fp16_vector_explicit_false": ":xnn_enable_arm_fp16_vector_explicit_true",
|
|
"//conditions:default": ":arm_fp16_vector_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_aarch64_fp16_vector_enabled",
|
|
match_all = [
|
|
":arm_fp16_vector_enabled",
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_bf16_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "arm_bf16_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_bf16_explicit_true": ":xnn_enable_arm_bf16_explicit_true",
|
|
":xnn_enable_arm_bf16_explicit_false": ":xnn_enable_arm_bf16_explicit_true",
|
|
"//conditions:default": ":arm_bf16_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_dotprod_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:aarch32",
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "arm_dotprod_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_dotprod_explicit_true": ":xnn_enable_arm_dotprod_explicit_true",
|
|
":xnn_enable_arm_dotprod_explicit_false": ":xnn_enable_arm_dotprod_explicit_true",
|
|
"//conditions:default": ":arm_dotprod_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_aarch64_dotprod_enabled",
|
|
match_all = [
|
|
":arm_dotprod_enabled",
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "arm_i8mm_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:aarch64",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "arm_i8mm_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_i8mm_explicit_true": ":xnn_enable_arm_i8mm_explicit_true",
|
|
":xnn_enable_arm_i8mm_explicit_false": ":xnn_enable_arm_i8mm_explicit_true",
|
|
"//conditions:default": ":arm_i8mm_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
alias(
|
|
name = "arm_sme_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_sme_explicit_true": ":xnn_enable_arm_sme_explicit_true",
|
|
":xnn_enable_arm_sme_explicit_false": ":xnn_enable_arm_sme_explicit_true",
|
|
"//conditions:default": ":xnn_enable_arm_sme_explicit_true",
|
|
}),
|
|
)
|
|
|
|
alias(
|
|
name = "arm_sme2_enabled",
|
|
actual = select({
|
|
":xnn_enable_arm_sme2_explicit_true": ":xnn_enable_arm_sme2_explicit_true",
|
|
":xnn_enable_arm_sme2_explicit_false": ":xnn_enable_arm_sme2_explicit_true",
|
|
"//conditions:default": ":xnn_enable_arm_sme2_explicit_true",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512f_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512f_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512f_explicit_true": ":xnn_enable_avx512f_explicit_true",
|
|
":xnn_enable_avx512f_explicit_false": ":xnn_enable_avx512f_explicit_true",
|
|
"//conditions:default": ":avx512f_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512skx_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512skx_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512skx_explicit_true": ":xnn_enable_avx512skx_explicit_true",
|
|
":xnn_enable_avx512skx_explicit_false": ":xnn_enable_avx512skx_explicit_true",
|
|
"//conditions:default": ":avx512skx_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512vbmi_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512vbmi_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512vbmi_explicit_true": ":xnn_enable_avx512vbmi_explicit_true",
|
|
":xnn_enable_avx512vbmi_explicit_false": ":xnn_enable_avx512vbmi_explicit_true",
|
|
"//conditions:default": ":avx512vbmi_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512vnni_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512vnni_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512vnni_explicit_true": ":xnn_enable_avx512vnni_explicit_true",
|
|
":xnn_enable_avx512vnni_explicit_false": ":xnn_enable_avx512vnni_explicit_true",
|
|
"//conditions:default": ":avx512vnni_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512vnnigfni_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512vnnigfni_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512vnnigfni_explicit_true": ":xnn_enable_avx512vnnigfni_explicit_true",
|
|
":xnn_enable_avx512vnnigfni_explicit_false": ":xnn_enable_avx512vnnigfni_explicit_true",
|
|
"//conditions:default": ":avx512vnnigfni_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512amx_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512amx_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512amx_explicit_true": ":xnn_enable_avx512amx_explicit_true",
|
|
":xnn_enable_avx512amx_explicit_false": ":xnn_enable_avx512amx_explicit_true",
|
|
"//build_config:windows_lexan": ":xnn_enable_avx512amx_explicit_true",
|
|
"//conditions:default": ":avx512amx_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx512fp16_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx512fp16_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx512fp16_explicit_true": ":xnn_enable_avx512fp16_explicit_true",
|
|
":xnn_enable_avx512fp16_explicit_false": ":xnn_enable_avx512fp16_explicit_true",
|
|
"//build_config:windows_lexan": ":xnn_enable_avx512fp16_explicit_true",
|
|
"//conditions:default": ":avx512fp16_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avxvnni_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avxvnni_enabled",
|
|
actual = select({
|
|
":xnn_enable_avxvnni_explicit_true": ":xnn_enable_avxvnni_explicit_true",
|
|
":xnn_enable_avxvnni_explicit_false": ":xnn_enable_avxvnni_explicit_true",
|
|
"//conditions:default": ":avxvnni_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avxvnniint8_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avxvnniint8_enabled",
|
|
actual = select({
|
|
":xnn_enable_avxvnniint8_explicit_true": ":xnn_enable_avxvnniint8_explicit_true",
|
|
":xnn_enable_avxvnniint8_explicit_false": ":xnn_enable_avxvnniint8_explicit_true",
|
|
"//build_config:ios_x86_64": ":xnn_enable_avxvnniint8_explicit_true",
|
|
"//build_config:ios": ":xnn_enable_avxvnniint8_explicit_true",
|
|
"//conditions:default": ":avxvnniint8_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx256skx_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx256skx_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx256skx_explicit_true": ":xnn_enable_avx256skx_explicit_true",
|
|
":xnn_enable_avx256skx_explicit_false": ":xnn_enable_avx256skx_explicit_true",
|
|
"//conditions:default": ":avx256skx_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx256vnni_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx256vnni_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx256vnni_explicit_true": ":xnn_enable_avx256vnni_explicit_true",
|
|
":xnn_enable_avx256vnni_explicit_false": ":xnn_enable_avx256vnni_explicit_true",
|
|
"//conditions:default": ":avx256vnni_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "avx256vnnigfni_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "avx256vnnigfni_enabled",
|
|
actual = select({
|
|
":xnn_enable_avx256vnnigfni_explicit_true": ":xnn_enable_avx256vnnigfni_explicit_true",
|
|
":xnn_enable_avx256vnnigfni_explicit_false": ":xnn_enable_avx256vnnigfni_explicit_true",
|
|
"//conditions:default": ":avx256vnnigfni_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "hvx_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:hexagon",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "hvx_enabled",
|
|
actual = select({
|
|
":xnn_enable_hvx_explicit_true": ":xnn_enable_hvx_explicit_true",
|
|
":xnn_enable_hvx_explicit_false": ":xnn_enable_hvx_explicit_true",
|
|
"//conditions:default": ":hvx_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "riscv_vector_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:riscv",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "riscv_vector_enabled",
|
|
actual = select({
|
|
":xnn_enable_riscv_vector_explicit_true": ":xnn_enable_riscv_vector_explicit_true",
|
|
":xnn_enable_riscv_vector_explicit_false": ":xnn_enable_riscv_vector_explicit_true",
|
|
"//conditions:default": ":riscv_vector_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "riscv_fp16_vector_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:riscv",
|
|
],
|
|
)
|
|
|
|
# Temporary disable fp16 vectors on Android
|
|
alias(
|
|
name = "riscv_fp16_vector_enabled",
|
|
actual = select({
|
|
":xnn_enable_riscv_fp16_vector_explicit_true": ":xnn_enable_riscv_fp16_vector_explicit_true",
|
|
":xnn_enable_riscv_fp16_vector_explicit_false": ":xnn_enable_riscv_fp16_vector_explicit_true",
|
|
"//build_config:android": ":xnn_enable_riscv_fp16_vector_explicit_false",
|
|
"//conditions:default": ":riscv_fp16_vector_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "cpuinfo_enabled_by_default",
|
|
match_any = [
|
|
"//build_config:aarch32",
|
|
"//build_config:aarch64",
|
|
"//build_config:x86",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "cpuinfo_enabled",
|
|
actual = select({
|
|
":xnn_enable_cpuinfo_explicit_true": ":xnn_enable_cpuinfo_explicit_true",
|
|
":xnn_enable_cpuinfo_explicit_false": ":xnn_enable_cpuinfo_explicit_true",
|
|
"//conditions:default": ":cpuinfo_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "kleidiai_enabled_by_default",
|
|
match_all = [
|
|
"//build_config:aarch64",
|
|
":arm_i8mm_enabled",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "kleidiai_enabled",
|
|
actual = select({
|
|
":xnn_enable_kleidiai_explicit_true": ":xnn_enable_kleidiai_explicit_true",
|
|
":xnn_enable_kleidiai_explicit_false": ":xnn_enable_kleidiai_explicit_true",
|
|
"//conditions:default": ":kleidiai_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "assembly_enabled_by_default",
|
|
match_any = [
|
|
"//conditions:default",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "assembly_enabled",
|
|
actual = select({
|
|
":xnn_enable_assembly_explicit_true": ":xnn_enable_assembly_explicit_true",
|
|
":xnn_enable_assembly_explicit_false": ":xnn_enable_assembly_explicit_true",
|
|
"//conditions:default": ":assembly_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "sparse_enabled_by_default",
|
|
match_any = [
|
|
"//conditions:default",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "sparse_enabled",
|
|
actual = select({
|
|
":xnn_enable_sparse_explicit_true": ":xnn_enable_sparse_explicit_true",
|
|
":xnn_enable_sparse_explicit_false": ":xnn_enable_sparse_explicit_true",
|
|
"//conditions:default": ":sparse_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "memopt_enabled_by_default",
|
|
match_any = [
|
|
"//conditions:default",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "memopt_enabled",
|
|
actual = select({
|
|
":xnn_enable_memopt_explicit_true": ":xnn_enable_memopt_explicit_true",
|
|
":xnn_enable_memopt_explicit_false": ":xnn_enable_memopt_explicit_true",
|
|
"//conditions:default": ":memopt_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "gemm_m_specialization_enabled_by_default",
|
|
match_any = [
|
|
"//conditions:default",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "gemm_m_specialization_enabled",
|
|
actual = select({
|
|
":xnn_enable_gemm_m_specialization_explicit_true": ":xnn_enable_gemm_m_specialization_explicit_true",
|
|
":xnn_enable_gemm_m_specialization_explicit_false": ":xnn_enable_gemm_m_specialization_explicit_true",
|
|
"//conditions:default": ":gemm_m_specialization_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
selects.config_setting_group(
|
|
name = "dwconv_multipass_enabled_by_default",
|
|
match_any = [
|
|
"//conditions:default",
|
|
],
|
|
)
|
|
|
|
alias(
|
|
name = "dwconv_multipass_enabled",
|
|
actual = select({
|
|
":xnn_enable_dwconv_multipass_explicit_true": ":xnn_enable_dwconv_multipass_explicit_true",
|
|
":xnn_enable_dwconv_multipass_explicit_false": ":xnn_enable_dwconv_multipass_explicit_true",
|
|
"//conditions:default": ":dwconv_multipass_enabled_by_default",
|
|
}),
|
|
)
|
|
|
|
bzl_library(
|
|
name = "build_defs_bzl",
|
|
srcs = ["build_defs.bzl"],
|
|
visibility = ["//visibility:private"],
|
|
)
|
|
|
|
bzl_library(
|
|
name = "build_params_bzl",
|
|
srcs = ["build_params.bzl"],
|
|
visibility = ["//visibility:private"],
|
|
)
|