Refactor logging messages in operators and subgraph nodes
PiperOrigin-RevId: 314654928
diff --git a/BUILD.bazel b/BUILD.bazel
index 2836f0d..9761f8b 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -1806,6 +1806,15 @@
"//conditions:default": ["-DXNN_LOG_LEVEL=2"],
})
+LOGGING_SRCS = select({
+ # No logging in optimized mode
+ ":optimized_build": [],
+ "//conditions:default": [
+ "src/operator-strings.c",
+ "src/subgraph-strings.c",
+ ],
+})
+
LOGGING_HDRS = [
"src/xnnpack/log.h",
]
@@ -2404,6 +2413,27 @@
aarch64_srcs = AARCH64_ASM_UKERNELS,
)
+xnnpack_cc_library(
+ name = "logging_utils",
+ srcs = LOGGING_SRCS,
+ hdrs = INTERNAL_HDRS + LOGGING_HDRS,
+ copts = LOGGING_COPTS + [
+ "-Isrc",
+ "-Iinclude",
+ ] + select({
+ ":debug_build": [],
+ "//conditions:default": xnnpack_min_size_copts(),
+ }),
+ gcc_copts = xnnpack_gcc_std_copts(),
+ msvc_copts = xnnpack_msvc_std_copts(),
+ visibility = xnnpack_visibility(),
+ deps = [
+ "@FP16",
+ "@clog",
+ "@pthreadpool",
+ ],
+)
+
xnnpack_aggregate_library(
name = "ukernels",
aarch32_deps = [
@@ -2534,6 +2564,7 @@
gcc_copts = xnnpack_gcc_std_copts(),
msvc_copts = xnnpack_msvc_std_copts(),
deps = [
+ ":logging_utils",
"@FP16",
"@FXdiv",
"@clog",
@@ -2555,6 +2586,7 @@
gcc_copts = xnnpack_gcc_std_copts(),
msvc_copts = xnnpack_msvc_std_copts(),
deps = [
+ ":logging_utils",
"@FP16",
"@FXdiv",
"@clog",
@@ -2574,6 +2606,7 @@
gcc_copts = xnnpack_gcc_std_copts(),
msvc_copts = xnnpack_msvc_std_copts(),
deps = [
+ ":logging_utils",
"@pthreadpool",
],
)
@@ -2594,6 +2627,7 @@
gcc_copts = xnnpack_gcc_std_copts(),
msvc_copts = xnnpack_msvc_std_copts(),
deps = [
+ ":logging_utils",
"@pthreadpool",
],
)
@@ -2628,6 +2662,7 @@
msvc_copts = xnnpack_msvc_std_copts(),
deps = [
":indirection",
+ ":logging_utils",
"@FP16",
"@FXdiv",
"@clog",
@@ -2658,6 +2693,7 @@
msvc_copts = xnnpack_msvc_std_copts(),
deps = [
":indirection_test_mode",
+ ":logging_utils",
"@FP16",
"@FXdiv",
"@clog",
@@ -2672,7 +2708,7 @@
"src/runtime.c",
"src/subgraph.c",
"src/tensor.c",
- ] + SUBGRAPH_SRCS,
+ ] + SUBGRAPH_SRCS + LOGGING_SRCS,
hdrs = ["include/xnnpack.h"],
copts = LOGGING_COPTS + [
"-Isrc",
@@ -2690,10 +2726,11 @@
visibility = xnnpack_visibility(),
deps = [
":enable_assembly",
+ ":logging_utils",
":memory_planner",
- ":ukernels",
":operator_run",
":operators",
+ ":ukernels",
"@clog",
"@FP16",
"@pthreadpool",
@@ -2710,7 +2747,7 @@
"src/runtime.c",
"src/subgraph.c",
"src/tensor.c",
- ] + SUBGRAPH_SRCS,
+ ] + SUBGRAPH_SRCS + LOGGING_SRCS,
hdrs = ["include/xnnpack.h"],
copts = LOGGING_COPTS + [
"-Isrc",
@@ -2730,10 +2767,11 @@
visibility = xnnpack_visibility(),
deps = [
":enable_assembly",
+ ":logging_utils",
":memory_planner_test_mode",
- ":ukernels_test_mode",
":operator_run_test_mode",
":operators_test_mode",
+ ":ukernels_test_mode",
"@clog",
"@FP16",
"@pthreadpool",
@@ -2771,9 +2809,10 @@
visibility = xnnpack_visibility(),
deps = [
":enable_assembly",
- ":ukernels",
+ ":logging_utils",
":operator_run",
":operators",
+ ":ukernels",
"@clog",
"@pthreadpool",
] + select({
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7a8b55f..c5bd838 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -199,7 +199,11 @@
src/subgraph/static-constant-pad.c
src/subgraph/unpooling-2d.c)
-SET(XNNPACK_COLD_SRCS ${XNNPACK_OPERATOR_SRCS})
+SET(XNNPACK_LOGGING_SRCS
+ src/operator-strings.c
+ src/subgraph-strings.c)
+
+SET(XNNPACK_COLD_SRCS ${XNNPACK_OPERATOR_SRCS} ${XNNPACK_SUBGRAPH_SRCS} ${XNNPACK_LOGGING_SRCS})
LIST(APPEND XNNPACK_COLD_SRCS
src/init.c
src/memory.c
diff --git a/src/operator-strings.c b/src/operator-strings.c
new file mode 100644
index 0000000..883c430
--- /dev/null
+++ b/src/operator-strings.c
@@ -0,0 +1,98 @@
+// 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.
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <xnnpack/common.h>
+#include <xnnpack/log.h>
+#include <xnnpack/subgraph.h>
+
+
+const char* xnn_operator_type_to_string(enum xnn_operator_type type) {
+ switch (type) {
+ case xnn_operator_type_invalid:
+ return "Invalid";
+ case xnn_operator_type_add_nc_f32:
+ return "Add (NC, F32)";
+ case xnn_operator_type_add_nd_f32:
+ return "Add (ND, F32)";
+ case xnn_operator_type_add_nc_q8:
+ return "Add (NC, Q8)";
+ case xnn_operator_type_argmax_pooling_nhwc_f32:
+ return "ArgMax Pooling (NHWC, F32)";
+ case xnn_operator_type_average_pooling_nhwc_f32:
+ return "Average Pooling (NHWC, F32)";
+ case xnn_operator_type_average_pooling_nhwc_q8:
+ return "Average Pooling (NHWC, Q8)";
+ case xnn_operator_type_channel_pad_nc_x32:
+ return "Channel Pad (NC, X32)";
+ case xnn_operator_type_channel_shuffle_nc_x32:
+ return "Channel Shuffle (NC, X32)";
+ case xnn_operator_type_channel_shuffle_nc_x8:
+ return "Channel Shuffle (NC, X8)";
+ case xnn_operator_type_clamp_nc_f32:
+ return "Clamp (NC, F32)";
+ case xnn_operator_type_clamp_nc_u8:
+ return "Clamp (NC, U8)";
+ case xnn_operator_type_constant_pad_nd_x32:
+ return "Constant Pad (ND, X32)";
+ case xnn_operator_type_convolution_nhwc_f32:
+ return "Convolution (NHWC, F32)";
+ case xnn_operator_type_convolution_nhwc_q8:
+ return "Convolution (NHWC, Q8)";
+ case xnn_operator_type_convolution_nchw_f32:
+ return "Convolution (NCHW, F32)";
+ case xnn_operator_type_deconvolution_nhwc_f32:
+ return "Deconvolution (NHWC, F32)";
+ case xnn_operator_type_deconvolution_nhwc_q8:
+ return "Deconvolution (NHWC, Q8)";
+ case xnn_operator_type_divide_nd_f32:
+ return "Divide (ND, F32)";
+ case xnn_operator_type_fully_connected_nc_f32:
+ return "Fully Connected (NC, F32)";
+ case xnn_operator_type_fully_connected_nc_q8:
+ return "Fully Connected (NC, Q8)";
+ case xnn_operator_type_global_average_pooling_nwc_f32:
+ return "Global Average Pooling (NWC, F32)";
+ case xnn_operator_type_global_average_pooling_nwc_q8:
+ return "Global Average Pooling (NWC, Q8)";
+ case xnn_operator_type_global_average_pooling_ncw_f32:
+ return "Global Average Pooling (NCW, F32)";
+ case xnn_operator_type_hardswish_nc_f32:
+ return "HardSwish (NC, F32)";
+ case xnn_operator_type_leaky_relu_nc_q8:
+ return "Leaky ReLU (NC, Q8)";
+ case xnn_operator_type_max_pooling_nhwc_f32:
+ return "Max Pooling (NHWC, F32)";
+ case xnn_operator_type_max_pooling_nhwc_u8:
+ return "Max Pooling (NHWC, U8)";
+ case xnn_operator_type_maximum_nd_f32:
+ return "Maximum (ND, F32)";
+ case xnn_operator_type_minimum_nd_f32:
+ return "Minimum (ND, F32)";
+ case xnn_operator_type_multiply_nd_f32:
+ return "Multiply (ND, F32)";
+ case xnn_operator_type_prelu_nc_f32:
+ return "PReLU (NC, F32)";
+ case xnn_operator_type_resize_bilinear_nhwc_f32:
+ return "Resize Bilinear (NHWC, F32)";
+ case xnn_operator_type_sigmoid_nc_f32:
+ return "Sigmoid (NC, F32)";
+ case xnn_operator_type_sigmoid_nc_q8:
+ return "Sigmoid (NC, Q8)";
+ case xnn_operator_type_softmax_nc_f32:
+ return "Softmax (NC, F32)";
+ case xnn_operator_type_softmax_nc_q8:
+ return "Softmax (NC, Q8)";
+ case xnn_operator_type_subtract_nd_f32:
+ return "Subtract (ND, F32)";
+ case xnn_operator_type_unpooling_nhwc_x32:
+ return "Unpooling (NHWC, X32)";
+ }
+ XNN_UNREACHABLE;
+ return NULL;
+}
diff --git a/src/operators/add-nc.c b/src/operators/add-nc.c
index 1ec6cb5..dcbf36e 100644
--- a/src/operators/add-nc.c
+++ b/src/operators/add-nc.c
@@ -40,7 +40,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Add operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8));
goto error;
}
@@ -48,57 +49,60 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Add operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), channels);
goto error;
}
if (a_stride < channels) {
xnn_log_error(
- "failed to create Add operator with A element stride of %zu: "
+ "failed to create %s operator with A element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- a_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), a_stride, channels);
goto error;
}
if (b_stride < channels) {
xnn_log_error(
- "failed to create Add operator with B element stride of %zu: "
+ "failed to create %s operator with B element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- b_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), b_stride, channels);
goto error;
}
if (sum_stride < channels) {
xnn_log_error(
- "failed to create Add operator with Sum element stride of %zu: "
+ "failed to create %s operator with Sum element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- sum_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), sum_stride, channels);
goto error;
}
if (a_scale <= 0.0f || !isnormal(a_scale)) {
xnn_log_error(
- "failed to create Add operator with %.7g A scale: scale must be finite, normalized, and positive", a_scale);
+ "failed to create %s operator with %.7g A scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), a_scale);
goto error;
}
if (b_scale <= 0.0f || !isnormal(b_scale)) {
xnn_log_error(
- "failed to create Add operator with %.7g B scale: scale must be finite, normalized, and positive", b_scale);
+ "failed to create %s operator with %.7g B scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), b_scale);
goto error;
}
if (sum_scale <= 0.0f || !isnormal(sum_scale)) {
xnn_log_error(
- "failed to create Add operator with %.7g output scale: scale must be finite, normalized, and positive",
- sum_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), sum_scale);
goto error;
}
if (sum_min >= sum_max) {
xnn_log_error(
- "failed to create Add operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
- sum_min, sum_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), sum_min, sum_max);
goto error;
}
@@ -107,16 +111,16 @@
const float a_output_scale = a_scale / sum_scale;
if (a_output_scale < 0x1.0p-14f || a_output_scale >= 0x1.0p+8f) {
xnn_log_error(
- "failed to create Add operator with %.7g A-to-output scale ratio: scale ratio must be in [2**-14, 2**8) range",
- a_output_scale);
+ "failed to create %s operator with %.7g A-to-output scale ratio: scale ratio must be in [2**-14, 2**8) range",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), a_output_scale);
goto error;
}
const float b_output_scale = b_scale / sum_scale;
if (b_output_scale < 0x1.0p-14f || b_output_scale >= 0x1.0p+8f) {
xnn_log_error(
- "failed to create Add operator with %.7g A-to-output scale ratio: scale ratio must be in [2**-14, 2**8) range",
- b_output_scale);
+ "failed to create %s operator with %.7g A-to-output scale ratio: scale ratio must be in [2**-14, 2**8) range",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8), b_output_scale);
goto error;
}
@@ -124,7 +128,9 @@
add_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (add_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Add operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_add_nc_q8));
goto error;
}
@@ -165,7 +171,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Add operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32));
goto error;
}
@@ -173,50 +180,53 @@
if (channels == 0) {
xnn_log_error(
- "failed to create add operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32), channels);
goto error;
}
if (a_stride < channels) {
xnn_log_error(
- "failed to create Add operator with A element stride of %zu: "
+ "failed to create %s operator with A element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- a_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32), a_stride, channels);
goto error;
}
if (b_stride < channels) {
xnn_log_error(
- "failed to create Add operator with B element stride of %zu: "
+ "failed to create %s operator with B element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- b_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32), b_stride, channels);
goto error;
}
if (sum_stride < channels) {
xnn_log_error(
- "failed to create Add operator with Sum element stride of %zu: "
+ "failed to create %s operator with Sum element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- sum_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32), sum_stride, channels);
goto error;
}
if (isnan(sum_min)) {
xnn_log_error(
- "failed to create Add operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32));
goto error;
}
if (isnan(sum_max)) {
xnn_log_error(
- "failed to create Add operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32));
goto error;
}
if (sum_min >= sum_max) {
xnn_log_error(
- "failed to create Add operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
- sum_min, sum_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32), sum_min, sum_max);
goto error;
}
@@ -224,7 +234,9 @@
add_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (add_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Add operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_add_nc_f32));
goto error;
}
@@ -256,13 +268,16 @@
pthreadpool_t threadpool)
{
if (add_op->type != xnn_operator_type_add_nc_q8) {
- xnn_log_error("failed to setup Add (NC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8),
+ xnn_operator_type_to_string(add_op->type));
return xnn_status_invalid_parameter;
}
add_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Add operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_q8));
return xnn_status_uninitialized;
}
@@ -319,13 +334,16 @@
pthreadpool_t threadpool)
{
if (add_op->type != xnn_operator_type_add_nc_f32) {
- xnn_log_error("failed to setup Add (NC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32),
+ xnn_operator_type_to_string(add_op->type));
return xnn_status_invalid_parameter;
}
add_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Add operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_add_nc_f32));
return xnn_status_uninitialized;
}
diff --git a/src/operators/argmax-pooling-nhwc.c b/src/operators/argmax-pooling-nhwc.c
index 5b21747..907f39d 100644
--- a/src/operators/argmax-pooling-nhwc.c
+++ b/src/operators/argmax-pooling-nhwc.c
@@ -58,7 +58,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Argmax Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
goto error;
}
@@ -67,62 +68,61 @@
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to create Argmax Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32), pooling_width, pooling_height);
goto error;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to create Argmax Pooling operator with 1 pooling element: "
- "1x1 pooling is meaningless");
+ "failed to create %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
goto error;
}
if (channels == 0) {
xnn_log_error(
- "failed to create Argmax Pooling operator with %zu channels: "
- "number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Argmax Pooling operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Argmax Pooling operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32), output_pixel_stride, channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Argmax Pooling operator with NaN output lower bound: "
- "lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Argmax Pooling operator with NaN output upper bound: "
- "upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Argmax Pooling operator with [%.7g, %.7g] output range: "
+ "failed to create %s operator with [%.7g, %.7g] output range: "
"lower bound must be below upper bound",
- output_min, output_max);
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32), output_min, output_max);
goto error;
}
@@ -130,8 +130,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Argmax Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -141,7 +142,9 @@
argmax_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (argmax_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Argmax Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
goto error;
}
@@ -187,20 +190,23 @@
pthreadpool_t threadpool)
{
if (argmax_pooling_op->type != xnn_operator_type_argmax_pooling_nhwc_f32) {
- xnn_log_error("failed to setup Argmax Pooling (NHWC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32),
+ xnn_operator_type_to_string(argmax_pooling_op->type));
return xnn_status_invalid_parameter;
}
argmax_pooling_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Argmax Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Argmax Pooling operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32), input_width, input_height);
return xnn_status_invalid_parameter;
}
@@ -251,9 +257,12 @@
// Micro-kernel may read up to (mr - 1) elements after the end of indirection buffer.
const size_t indirection_buffer_size = sizeof(void*) * ((mr - 1) + output_height * step_height);
- const void** indirection_buffer = (const void**) xnn_reallocate_memory(argmax_pooling_op->indirection_buffer, indirection_buffer_size);
+ const void** indirection_buffer =
+ (const void**) xnn_reallocate_memory(argmax_pooling_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(xnn_operator_type_argmax_pooling_nhwc_f32));
return xnn_status_out_of_memory;
}
argmax_pooling_op->indirection_buffer = indirection_buffer;
diff --git a/src/operators/average-pooling-nhwc.c b/src/operators/average-pooling-nhwc.c
index 657c6c6..d03ba22 100644
--- a/src/operators/average-pooling-nhwc.c
+++ b/src/operators/average-pooling-nhwc.c
@@ -65,7 +65,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8));
goto error;
}
@@ -74,70 +75,67 @@
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to create Average Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), pooling_width, pooling_height);
goto error;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to create Average Pooling operator with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to create %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8));
goto error;
}
if (stride_height == 0 || stride_width == 0) {
xnn_log_error(
- "failed to create Average Pooling operator with %" PRIu32 "x%" PRIu32 " stride: "
- "stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), stride_width, stride_height);
goto error;
}
if (channels == 0) {
xnn_log_error(
- "failed to create Average Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Average Pooling operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Average Pooling operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), output_pixel_stride, channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Average Pooling operator with %.7g input scale: "
- "scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), input_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Average Pooling operator with %.7g output scale: "
- "scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Average Pooling operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8), output_min, output_max);
goto error;
}
@@ -145,8 +143,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Average Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -157,16 +156,18 @@
const float input_output_scale = input_scale / output_scale;
if (input_output_scale < 0x1.0p-8f || input_output_scale >= 0x1.0p+8f) {
xnn_log_error(
- "failed to create Average Pooling operator with %.7g input scale and %.7g output scale: "
+ "failed to create %s operator with %.7g input scale and %.7g output scale: "
"input-to-output scale ratio (%.7f) must be in [2**-8, 2**8) range",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8),
input_scale, output_scale, input_output_scale);
goto error;
}
if (pooling_size >= 16777216) {
xnn_log_error(
- "failed to create Average Pooling operator with %"PRIu32" (%" PRIu32 "x%" PRIu32 ") pooling elements: "
+ "failed to create %s operator with %"PRIu32" (%" PRIu32 "x%" PRIu32 ") pooling elements: "
"the number of elements in the pooling area must be below 2**24",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8),
pooling_size, pooling_width, pooling_height);
goto error;
}
@@ -175,14 +176,18 @@
average_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (average_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Average Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8));
goto error;
}
- void* zero_buffer = xnn_allocate_simd_memory(channels * sizeof(uint8_t) + XNN_EXTRA_BYTES);
+ const size_t zero_bytes = channels * sizeof(uint8_t) + XNN_EXTRA_BYTES;
+ void* zero_buffer = xnn_allocate_simd_memory(zero_bytes);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Average Pooling zero padding",
- channels * sizeof(uint8_t) + XNN_EXTRA_BYTES);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_bytes, xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8));
goto error;
}
memset(zero_buffer, input_zero_point, channels * sizeof(uint8_t));
@@ -252,7 +257,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32));
goto error;
}
@@ -261,65 +267,67 @@
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to create Average Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32), pooling_width, pooling_height);
goto error;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to create Average Pooling operator with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to create %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32));
goto error;
}
if (stride_height == 0 || stride_width == 0) {
xnn_log_error(
- "failed to create Average Pooling operator with %" PRIu32 "x%" PRIu32 " stride: "
- "stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32), stride_width, stride_height);
goto error;
}
if (channels == 0) {
xnn_log_error(
- "failed to create Average Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Average Pooling operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Average Pooling operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32), output_pixel_stride, channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Average Pooling operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Average Pooling operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Average Pooling operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32), output_min, output_max);
goto error;
}
@@ -327,8 +335,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Average Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -338,14 +347,18 @@
average_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (average_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Average Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32));
goto error;
}
- void* zero_buffer = xnn_allocate_zero_simd_memory(channels * sizeof(float) + XNN_EXTRA_BYTES);
+ const size_t zero_bytes = channels * sizeof(float) + XNN_EXTRA_BYTES;
+ void* zero_buffer = xnn_allocate_zero_simd_memory(zero_bytes);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Average Pooling zero padding",
- channels * sizeof(float) + XNN_EXTRA_BYTES);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_bytes, xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32));
goto error;
}
average_pooling_op->zero_buffer = zero_buffer;
@@ -410,14 +423,15 @@
average_pooling_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(average_pooling_op->type));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Average Pooling operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(average_pooling_op->type), input_width, input_height);
return xnn_status_invalid_parameter;
}
@@ -506,9 +520,11 @@
// Micro-kernel may read up to (mr - 1) elements after the end of indirection buffer.
const size_t indirection_buffer_size = sizeof(void*) * ((mr - 1) + batch_size * output_height * step_height);
- const void** indirection_buffer = (const void**) xnn_reallocate_memory(average_pooling_op->indirection_buffer, indirection_buffer_size);
+ const void** indirection_buffer =
+ (const void**) xnn_reallocate_memory(average_pooling_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error("failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(average_pooling_op->type));
return xnn_status_out_of_memory;
}
average_pooling_op->indirection_buffer = indirection_buffer;
@@ -533,9 +549,11 @@
/* This part is specific to FP32, needs revision if Q8 gets a PAVGPOOL micro-kernel */
if (input_height != last_input_height || input_width != last_input_width) {
const size_t pixelwise_buffer_size = output_height * output_width * sizeof(float);
- float* pixelwise_buffer = (float*) xnn_reallocate_memory(average_pooling_op->pixelwise_buffer, pixelwise_buffer_size);
+ float* pixelwise_buffer =
+ (float*) xnn_reallocate_memory(average_pooling_op->pixelwise_buffer, pixelwise_buffer_size);
if (pixelwise_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for pixelwise buffer", pixelwise_buffer_size);
+ xnn_log_error("failed to allocate %zu bytes for %s operator pixelwise buffer",
+ pixelwise_buffer_size, xnn_operator_type_to_string(average_pooling_op->type));
return xnn_status_out_of_memory;
}
average_pooling_op->pixelwise_buffer = pixelwise_buffer;
@@ -632,7 +650,9 @@
pthreadpool_t threadpool)
{
if (average_pooling_op->type != xnn_operator_type_average_pooling_nhwc_q8) {
- xnn_log_error("failed to setup Average Pooling (Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_q8),
+ xnn_operator_type_to_string(average_pooling_op->type));
return xnn_status_invalid_parameter;
}
@@ -677,7 +697,9 @@
pthreadpool_t threadpool)
{
if (average_pooling_op->type != xnn_operator_type_average_pooling_nhwc_f32) {
- xnn_log_error("failed to setup Average Pooling (F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_average_pooling_nhwc_f32),
+ xnn_operator_type_to_string(average_pooling_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/binary-elementwise-nd.c b/src/operators/binary-elementwise-nd.c
index 806b8ea..cb9ee1e 100644
--- a/src/operators/binary-elementwise-nd.c
+++ b/src/operators/binary-elementwise-nd.c
@@ -28,7 +28,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Add/Subtract/Multiply/Divide/Minimum/Maximum operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(operator_type));
goto error;
}
@@ -36,20 +37,22 @@
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Add/Subtract/Multiply/Divide/Minimum/Maximum operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(operator_type));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Add/Subtract/Multiply/Divide/Minimum/Maximum operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(operator_type));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Add/Subtract/Multiply/Divide/Minimum/Maximum operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(operator_type), output_min, output_max);
goto error;
}
@@ -57,7 +60,9 @@
binary_elementwise_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (binary_elementwise_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Add/Subtract/Multiply/Divide/Minimum/Maximum operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(operator_type));
goto error;
}
@@ -148,34 +153,41 @@
size_t num_threads)
{
if (binary_elementwise_op->type != expected_operator_type) {
- xnn_log_error("failed to setup Add/Subtract/Multiply/Divide/Minimum/Maximum (ND, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(expected_operator_type),
+ xnn_operator_type_to_string(binary_elementwise_op->type));
return xnn_status_invalid_parameter;
}
binary_elementwise_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Add/Subtract/Multiply/Divide/Minimum/Maximum operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(binary_elementwise_op->type));
return xnn_status_uninitialized;
}
if (max(num_input1_dims, num_input2_dims) > XNN_MAX_TENSOR_DIMS) {
xnn_log_error(
- "failed to setup Add/Subtract/Multiply/Divide/Minimum/Maximum operator with %zu and %zu dimensions in input shapes: "
+ "failed to setup %s operator with %zu and %zu dimensions in input shapes: "
"the number of input dimensions must not exceed %d",
- num_input1_dims, num_input2_dims, XNN_MAX_TENSOR_DIMS);
+ xnn_operator_type_to_string(binary_elementwise_op->type), num_input1_dims, num_input2_dims, XNN_MAX_TENSOR_DIMS);
return xnn_status_unsupported_parameter;
}
for (size_t i = 0; i < num_input1_dims; i++) {
if (input1_shape[i] == 0) {
- xnn_log_error("failed to setup Add/Subtract/Multiply/Divide/Minimum/Maximum operator: shape dimension #%zu of input #1 is zero", i);
+ xnn_log_error(
+ "failed to setup %s operator: shape dimension #%zu of input #1 is zero",
+ xnn_operator_type_to_string(binary_elementwise_op->type), i);
return xnn_status_invalid_parameter;
}
}
for (size_t i = 0; i < num_input2_dims; i++) {
if (input2_shape[i] == 0) {
- xnn_log_error("failed to setup Add/Subtract/Multiply/Divide/Minimum/Maximum operator: shape dimension #%zu of input #2 is zero", i);
+ xnn_log_error(
+ "failed to setup %s operator: shape dimension #%zu of input #2 is zero",
+ xnn_operator_type_to_string(binary_elementwise_op->type), i);
return xnn_status_invalid_parameter;
}
}
@@ -227,8 +239,10 @@
compressed_input2_shape[num_compressed_dims - 1] *= input1_dim;
compressed_output_shape[num_compressed_dims - 1] *= input1_dim;
} else {
- xnn_log_error("failed to setup Add/Subtract/Multiply/Divide/Minimum/Maximum operator: "
+ xnn_log_error(
+ "failed to setup %s operator: "
"shape dimension #%zu of input1 (%zu) does not match shape dimension #%zu of input2 (%zu)",
+ xnn_operator_type_to_string(binary_elementwise_op->type),
num_input1_dims - i, input1_dim, num_input2_dims - i, input2_dim);
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/channel-pad-nc.c b/src/operators/channel-pad-nc.c
index ffe25b8..24f253b 100644
--- a/src/operators/channel-pad-nc.c
+++ b/src/operators/channel-pad-nc.c
@@ -30,7 +30,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Channel Pad operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32));
goto error;
}
@@ -38,24 +39,25 @@
if (input_channels == 0) {
xnn_log_error(
- "failed to create Channel Pad operator with %zu input channels: number of channels must be non-zero",
- input_channels);
+ "failed to create %s operator with %zu input channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32), input_channels);
goto error;
}
if (input_stride < input_channels) {
xnn_log_error(
- "failed to create Channel Pad operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of input channels (%zu)",
- input_stride, input_channels);
+ xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32), input_stride, input_channels);
goto error;
}
const size_t output_channels = pad_before_channels + input_channels + pad_after_channels;
if (output_stride < output_channels) {
xnn_log_error(
- "failed to create Channel Pad operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of output channels (%zu+%zu+%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32),
output_stride, pad_before_channels, input_channels, pad_after_channels);
goto error;
}
@@ -64,7 +66,9 @@
channel_pad_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (channel_pad_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Channel Pad operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32));
goto error;
}
@@ -96,13 +100,16 @@
pthreadpool_t threadpool)
{
if (channel_pad_op->type != xnn_operator_type_channel_pad_nc_x32) {
- xnn_log_error("failed to setup Channel Pad (X32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32),
+ xnn_operator_type_to_string(channel_pad_op->type));
return xnn_status_invalid_parameter;
}
channel_pad_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Channel Pad operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_channel_pad_nc_x32));
return xnn_status_uninitialized;
}
diff --git a/src/operators/channel-shuffle-nc.c b/src/operators/channel-shuffle-nc.c
index 75e877a..77ed9a7 100644
--- a/src/operators/channel-shuffle-nc.c
+++ b/src/operators/channel-shuffle-nc.c
@@ -32,7 +32,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Channel Shuffle operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(operator_type));
goto error;
}
@@ -40,31 +41,32 @@
if (groups <= 1) {
xnn_log_error(
- "failed to create Channel Shuffle operator with %zu groups: at least two groups required", groups);
+ "failed to create %s operator with %zu groups: at least two groups required",
+ xnn_operator_type_to_string(operator_type), groups);
goto error;
}
if (group_channels == 0) {
xnn_log_error(
- "failed to create Channel Shuffle operator with %zu group channels: number of group channels must be non-zero",
- group_channels);
+ "failed to create %s operator with %zu group channels: number of group channels must be non-zero",
+ xnn_operator_type_to_string(operator_type), group_channels);
goto error;
}
const size_t channels = groups * group_channels;
if (input_stride < channels) {
xnn_log_error(
- "failed to create Channel Shuffle operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zux%zu)",
- input_stride, groups, group_channels);
+ xnn_operator_type_to_string(operator_type), input_stride, groups, group_channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Channel Shuffle operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zux%zu)",
- output_stride, groups, group_channels);
+ xnn_operator_type_to_string(operator_type), output_stride, groups, group_channels);
goto error;
}
@@ -72,7 +74,9 @@
channel_shuffle_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (channel_shuffle_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Channel Shuffle operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(operator_type));
goto error;
}
@@ -142,7 +146,8 @@
channel_shuffle_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Channel Shuffle operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(channel_shuffle_op->type));
return xnn_status_uninitialized;
}
@@ -200,7 +205,9 @@
pthreadpool_t threadpool)
{
if (channel_shuffle_op->type != xnn_operator_type_channel_shuffle_nc_x8) {
- xnn_log_error("failed to setup Channel Shuffle (NC, X8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_channel_shuffle_nc_x8),
+ xnn_operator_type_to_string(channel_shuffle_op->type));
return xnn_status_invalid_parameter;
}
@@ -221,7 +228,9 @@
pthreadpool_t threadpool)
{
if (channel_shuffle_op->type != xnn_operator_type_channel_shuffle_nc_x32) {
- xnn_log_error("failed to setup Channel Shuffle (NC, X32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_channel_shuffle_nc_x32),
+ xnn_operator_type_to_string(channel_shuffle_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/clamp-nc.c b/src/operators/clamp-nc.c
index 02a1f65..22aa917 100644
--- a/src/operators/clamp-nc.c
+++ b/src/operators/clamp-nc.c
@@ -32,7 +32,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Clamp operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8));
goto error;
}
@@ -40,30 +41,31 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Clamp operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Clamp operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Clamp operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8), output_stride, channels);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Clamp operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8), output_min, output_max);
goto error;
}
@@ -71,7 +73,9 @@
clamp_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (clamp_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Clamp operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8));
goto error;
}
@@ -106,7 +110,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Clamp operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32));
goto error;
}
@@ -114,42 +119,45 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Clamp operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Clamp operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Clamp operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32), output_stride, channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Clamp operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Clamp operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Clamp operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32), output_min, output_max);
goto error;
}
@@ -157,7 +165,9 @@
clamp_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (clamp_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Clamp operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32));
goto error;
}
@@ -187,13 +197,16 @@
pthreadpool_t threadpool)
{
if (clamp_op->type != xnn_operator_type_clamp_nc_u8) {
- xnn_log_error("failed to setup Clamp (NC, U8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8),
+ xnn_operator_type_to_string(clamp_op->type));
return xnn_status_invalid_parameter;
}
clamp_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Clamp operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8));
return xnn_status_uninitialized;
}
@@ -247,13 +260,16 @@
pthreadpool_t threadpool)
{
if (clamp_op->type != xnn_operator_type_clamp_nc_f32) {
- xnn_log_error("failed to setup Clamp (NC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_f32),
+ xnn_operator_type_to_string(clamp_op->type));
return xnn_status_invalid_parameter;
}
clamp_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Clamp operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_clamp_nc_u8));
return xnn_status_uninitialized;
}
diff --git a/src/operators/constant-pad-nd.c b/src/operators/constant-pad-nd.c
index d0e79fb..0dc5c32 100644
--- a/src/operators/constant-pad-nd.c
+++ b/src/operators/constant-pad-nd.c
@@ -27,7 +27,9 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Constant Pad operator: XNNPACK is not initialized");
+ xnn_log_error(
+ "failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_constant_pad_nd_x32));
goto error;
}
@@ -35,7 +37,9 @@
constant_pad_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (constant_pad_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Constant Pad operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_constant_pad_nd_x32));
goto error;
}
@@ -75,27 +79,32 @@
size_t num_threads)
{
if (constant_pad_op->type != expected_operator_type) {
- xnn_log_error("failed to setup Constant Pad (ND, X32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(expected_operator_type),
+ xnn_operator_type_to_string(constant_pad_op->type));
return xnn_status_invalid_parameter;
}
constant_pad_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Constant Pad operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(constant_pad_op->type));
return xnn_status_uninitialized;
}
if (num_dims > XNN_MAX_TENSOR_DIMS) {
xnn_log_error(
- "failed to setup Constant Pad operator with %zu dimensions in input shape: "
+ "failed to setup %s operator with %zu dimensions in input shape: "
"the number of input dimensions must not exceed %d",
- num_dims, XNN_MAX_TENSOR_DIMS);
+ xnn_operator_type_to_string(constant_pad_op->type), num_dims, XNN_MAX_TENSOR_DIMS);
return xnn_status_unsupported_parameter;
}
for (size_t i = 0; i < num_dims; i++) {
if (input_shape[i] == 0) {
- xnn_log_error("failed to setup Constant Pad operator: input shape dimension #%zu is zero", i);
+ xnn_log_error(
+ "failed to setup %s operator: input shape dimension #%zu is zero",
+ xnn_operator_type_to_string(constant_pad_op->type), i);
return xnn_status_invalid_parameter;
}
}
diff --git a/src/operators/convolution-nchw.c b/src/operators/convolution-nchw.c
index f7b47bb..cffd251 100644
--- a/src/operators/convolution-nchw.c
+++ b/src/operators/convolution-nchw.c
@@ -59,7 +59,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Convolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
@@ -67,74 +68,72 @@
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), kernel_width, kernel_height);
goto error;
}
if (subsampling_width == 0 || subsampling_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " subsampling: "
- "subsampling dimensions must be non-zero",
- subsampling_width, subsampling_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " subsampling: subsampling dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), subsampling_width, subsampling_height);
goto error;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), dilation_width, dilation_height);
goto error;
}
if (groups == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to create %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), groups);
goto error;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to create Convolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to create %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), group_input_channels);
goto error;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to create Convolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to create %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), group_output_channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Convolution operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Convolution operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Convolution operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), output_min, output_max);
goto error;
}
if ((flags & XNN_FLAG_DEPTHWISE_CONVOLUTION) != 0 && group_input_channels != 1) {
xnn_log_error(
- "failed to create Depthwise Convolution operator with %zu input channels per group: "
- "Depthwise Convolution must have exactly 1 input channel per group",
- group_input_channels);
+ "failed to create depthwise %s operator with %zu input channels per group: "
+ "depthwise convolution must have exactly 1 input channel per group",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), group_input_channels);
goto error;
}
@@ -187,7 +186,8 @@
dwconv_parameters = &xnn_params.f32.dwconv_chw_5x5s2;
} else {
xnn_log_error(
- "failed to create Convolution operator: only selected Convolution parameters are supported");
+ "failed to create %s operator: only selected convolution parameters are supported",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
@@ -195,7 +195,9 @@
convolution_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (convolution_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Convolution operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
@@ -275,7 +277,9 @@
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
convolution_op->num_nonzero_values = num_nonzero_values;
@@ -386,7 +390,9 @@
(group_input_channels * kernel_height * kernel_width + 1 /* bias */) * sizeof(float);
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
@@ -414,7 +420,9 @@
const size_t packed_weights_size = groups * (kernel_height * kernel_width + 1 /* bias */) * sizeof(float);
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
goto error;
}
@@ -488,14 +496,15 @@
convolution_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Convolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Convolution operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32), input_width, input_height);
return xnn_status_invalid_parameter;
}
@@ -504,8 +513,9 @@
const size_t input_neurons = groups * group_input_channels * input_height * input_width;
if (input_batch_stride < input_neurons) {
xnn_log_error(
- "failed to setup Convolution operator with input batch stride of %zu: "
+ "failed to setup %s operator with input batch stride of %zu: "
"stride must be at least as large as the number of input neurons (%" PRIu32 "x%zux%zux%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32),
input_batch_stride, groups, group_input_channels, input_height, input_width);
return xnn_status_invalid_parameter;
}
@@ -525,8 +535,9 @@
const size_t output_neurons = groups * group_output_channels * output_height * output_width;
if (output_batch_stride < output_neurons) {
xnn_log_error(
- "failed to setup Convolution operator with output batch stride of %zu: "
+ "failed to setup %s operator with output batch stride of %zu: "
"stride must be at least as large as the number of output neurons (%" PRIu32 "x%zux%zux%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32),
output_batch_stride, groups, group_output_channels, output_height, output_width);
return xnn_status_invalid_parameter;
}
@@ -563,8 +574,9 @@
const int32_t diff = input_channel_diffs[i];
const int64_t increment = (int64_t) diff * input_size;
if ((int64_t) (int32_t) increment != increment) {
- xnn_log_error("failed to setup Convolution operator with sparse kernel representation: "
- "input increment exceeds int32_t range");
+ xnn_log_error(
+ "failed to setup %s operator with sparse kernel representation: input increment exceeds int32_t range",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
return xnn_status_unsupported_parameter;
}
input_increments[i] = (int32_t) increment;
@@ -606,7 +618,9 @@
const size_t zero_size = (input_width * convolution_op->group_input_channels << log2_input_element_size) + XNN_EXTRA_BYTES;
void* zero_buffer = xnn_reallocate_memory(convolution_op->zero_buffer, zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for zero padding", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
return xnn_status_out_of_memory;
}
memset(zero_buffer, 0, zero_size);
@@ -653,7 +667,9 @@
const size_t zero_size = (input_width << log2_input_element_size) + 2 * XNN_EXTRA_BYTES;
void* zero_buffer = xnn_reallocate_memory(convolution_op->zero_buffer, zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for zero padding", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32));
return xnn_status_out_of_memory;
}
memset(zero_buffer, 0, zero_size);
@@ -707,7 +723,9 @@
pthreadpool_t threadpool)
{
if (convolution_op->type != xnn_operator_type_convolution_nchw_f32) {
- xnn_log_error("failed to setup Convolution (NCHW, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nchw_f32),
+ xnn_operator_type_to_string(convolution_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/convolution-nhwc.c b/src/operators/convolution-nhwc.c
index b77577c..c740ba8 100644
--- a/src/operators/convolution-nhwc.c
+++ b/src/operators/convolution-nhwc.c
@@ -44,7 +44,7 @@
return divide_round_up(input_dimension, subsampling_dimension);
}
-static const struct dwconv_parameters* find_dwigemm_ukernel(
+static const struct dwconv_parameters* find_dwconv_ukernel(
size_t kernel_size,
const struct dwconv_parameters* ukernel,
size_t num_ukernels)
@@ -91,7 +91,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Convolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8));
goto error;
}
@@ -99,54 +100,52 @@
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), kernel_width, kernel_height);
goto error;
}
if (subsampling_width == 0 || subsampling_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " subsampling: "
- "subsampling dimensions must be non-zero",
- subsampling_width, subsampling_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " subsampling: subsampling dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), subsampling_width, subsampling_height);
goto error;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), dilation_width, dilation_height);
goto error;
}
if (groups == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to create %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), groups);
goto error;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to create Convolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to create %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), group_input_channels);
goto error;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to create Convolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to create %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), group_output_channels);
goto error;
}
const size_t input_channels = groups * group_input_channels;
if (input_pixel_stride < input_channels) {
xnn_log_error(
- "failed to create Convolution operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of input channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8),
input_pixel_stride, groups, group_input_channels);
goto error;
}
@@ -154,46 +153,46 @@
const size_t output_channels = groups * group_output_channels;
if (output_pixel_stride < output_channels) {
xnn_log_error(
- "failed to create Convolution operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of output channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8),
output_pixel_stride, groups, group_output_channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Convolution operator with %.7g input scale: scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), input_scale);
goto error;
}
if (kernel_scale <= 0.0f || !isnormal(kernel_scale)) {
xnn_log_error(
- "failed to create Convolution operator with %.7g kernel scale: scale must be finite, normalized, and positive",
- kernel_scale);
+ "failed to create %s operator with %.7g kernel scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), kernel_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Convolution operator with %.7g output scale: scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Convolution operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), output_min, output_max);
goto error;
}
if ((flags & XNN_FLAG_DEPTHWISE_CONVOLUTION) != 0 && group_input_channels != 1) {
xnn_log_error(
- "failed to create Depthwise Convolution operator with %zu input channels per group: "
- "Depthwise Convolution must have exactly 1 input channel per group",
- group_input_channels);
+ "failed to create depthwise %s operator with %zu input channels per group: "
+ "depthwise convolution must have exactly 1 input channel per group",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8), group_input_channels);
goto error;
}
@@ -201,8 +200,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -213,8 +213,9 @@
const float convolution_scale = input_scale * kernel_scale / output_scale;
if (convolution_scale >= 1.0f) {
xnn_log_error(
- "failed to create Convolution operator with %.7g input scale, %.7g kernel scale, and %.7g output scale: "
+ "failed to create %s operator with %.7g input scale, %.7g kernel scale, and %.7g output scale: "
"convolution scale %.7g is greater or equal to 1.0",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8),
input_scale, kernel_scale, output_scale, convolution_scale);
goto error;
}
@@ -223,7 +224,9 @@
convolution_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (convolution_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Convolution operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8));
goto error;
}
@@ -232,7 +235,7 @@
enum xnn_ukernel_type ukernel_type = xnn_ukernel_type_none;
const struct dwconv_parameters* dwconv_parameters = NULL;
if (group_input_channels == 1 && group_output_channels == 1 && groups > 1 &&
- (dwconv_parameters = find_dwigemm_ukernel(kernel_size, xnn_params.q8.dwconv, XNN_MAX_Q8_DWCONV_UKERNELS)) != NULL)
+ (dwconv_parameters = find_dwconv_ukernel(kernel_size, xnn_params.q8.dwconv, XNN_MAX_Q8_DWCONV_UKERNELS)) != NULL)
{
ukernel_type = xnn_ukernel_type_dwconv;
} else if (kernel_size == 1 && subsampling_height == 1 && subsampling_width == 1 && !any_padding) {
@@ -252,7 +255,9 @@
const size_t packed_weights_size = (sizeof(uint8_t) * kernel_size + sizeof(int32_t)) * c_stride;
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8));
goto error;
}
@@ -291,7 +296,9 @@
(sizeof(uint8_t) * kernel_size * k_stride + sizeof(int32_t)) * n_stride;
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_group_weights_size * groups);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_group_weights_size * groups);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_group_weights_size * groups, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8));
goto error;
}
memset(convolution_op->packed_weights, kernel_zero_point, packed_group_weights_size * groups);
@@ -346,7 +353,9 @@
if (any_padding || tf_same_padding) {
void* zero_buffer = xnn_allocate_simd_memory(zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for zero padding", zero_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8));
goto error;
}
memset(zero_buffer, input_zero_point, zero_size);
@@ -420,7 +429,9 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Convolution operator: XNNPACK is not initialized");
+ xnn_log_error(
+ "failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
@@ -428,54 +439,52 @@
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), kernel_width, kernel_height);
goto error;
}
if (subsampling_width == 0 || subsampling_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " subsampling: "
- "subsampling dimensions must be non-zero",
- subsampling_width, subsampling_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " subsampling: subsampling dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), subsampling_width, subsampling_height);
goto error;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), dilation_width, dilation_height);
goto error;
}
if (groups == 0) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to create %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), groups);
goto error;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to create Convolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to create %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), group_input_channels);
goto error;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to create Convolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to create %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), group_output_channels);
goto error;
}
const size_t input_channels = groups * group_input_channels;
if (input_pixel_stride < input_channels) {
xnn_log_error(
- "failed to create Convolution operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of input channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32),
input_pixel_stride, groups, group_input_channels);
goto error;
}
@@ -483,37 +492,39 @@
const size_t output_channels = groups * group_output_channels;
if (output_pixel_stride < output_channels) {
xnn_log_error(
- "failed to create Convolution operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of output channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32),
output_pixel_stride, groups, group_output_channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Convolution operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Convolution operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Convolution operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), output_min, output_max);
goto error;
}
if ((flags & XNN_FLAG_DEPTHWISE_CONVOLUTION) != 0 && group_input_channels != 1) {
xnn_log_error(
- "failed to create Depthwise Convolution operator with %zu input channels per group: "
- "Depthwise Convolution must have exactly 1 input channel per group",
- group_input_channels);
+ "failed to create depthwise %s operator with %zu input channels per group: "
+ "depthwise convolution must have exactly 1 input channel per group",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32), group_input_channels);
goto error;
}
@@ -521,8 +532,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Convolution operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -532,7 +544,9 @@
convolution_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (convolution_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Convolution operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
@@ -544,7 +558,7 @@
if (group_input_channels == 1 && group_output_channels == 1 && kernel_size == 1 && unit_subsampling && !any_padding) {
ukernel_type = xnn_ukernel_type_vmulcaddc;
} else if (group_input_channels == 1 && group_output_channels == 1 && (dwconv_parameters =
- find_dwigemm_ukernel(kernel_size, xnn_params.f32.dwconv, XNN_MAX_F32_DWCONV_UKERNELS)) != NULL)
+ find_dwconv_ukernel(kernel_size, xnn_params.f32.dwconv, XNN_MAX_F32_DWCONV_UKERNELS)) != NULL)
{
ukernel_type = xnn_ukernel_type_dwconv;
} else if (kernel_size == 1 && unit_subsampling && !any_padding) {
@@ -563,7 +577,9 @@
const size_t packed_weights_size = 2 * sizeof(float) * c_stride;
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
@@ -586,7 +602,9 @@
const size_t packed_weights_size = (kernel_size + 1) * sizeof(float) * c_stride;
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
@@ -627,7 +645,9 @@
const size_t packed_group_weights_size = (kernel_size * k_stride + 1) * sizeof(float) * n_stride;
convolution_op->packed_weights = xnn_allocate_simd_memory(packed_group_weights_size * groups);
if (convolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_group_weights_size * groups);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_group_weights_size * groups, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
memset(convolution_op->packed_weights, 0, packed_group_weights_size * groups);
@@ -687,7 +707,9 @@
if (any_padding || tf_same_padding) {
void* zero_buffer = xnn_allocate_zero_simd_memory(zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for zero padding", zero_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_size, xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32));
goto error;
}
convolution_op->zero_buffer = zero_buffer;
@@ -745,14 +767,15 @@
convolution_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Convolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(convolution_op->type));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Convolution operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(convolution_op->type), input_width, input_height);
return xnn_status_invalid_parameter;
}
@@ -808,7 +831,8 @@
const size_t groups = convolution_op->groups;
const size_t group_input_channels = convolution_op->group_input_channels;
- const size_t w_stride = (round_up_po2(group_input_channels, convolution_op->ukernel.gemm.kr) << log2_filter_element_size) + bias_element_size;
+ const size_t w_stride = bias_element_size +
+ (round_up_po2(group_input_channels, convolution_op->ukernel.gemm.kr) << log2_filter_element_size);
const size_t group_output_channels = convolution_op->group_output_channels;
uint32_t mr = convolution_op->ukernel.gemm.mr;
@@ -910,7 +934,9 @@
{
const void** indirection_buffer = (const void**) xnn_reallocate_memory((void*) convolution_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(convolution_op->type));
return xnn_status_out_of_memory;
}
convolution_op->indirection_buffer = indirection_buffer;
@@ -1025,7 +1051,9 @@
const void** indirection_buffer =
(const void**) xnn_reallocate_memory((void*) convolution_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(convolution_op->type));
return xnn_status_out_of_memory;
}
convolution_op->indirection_buffer = indirection_buffer;
@@ -1106,7 +1134,9 @@
pthreadpool_t threadpool)
{
if (convolution_op->type != xnn_operator_type_convolution_nhwc_q8) {
- xnn_log_error("failed to setup Convolution (NHWC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_q8),
+ xnn_operator_type_to_string(convolution_op->type));
return xnn_status_invalid_parameter;
}
@@ -1132,7 +1162,9 @@
pthreadpool_t threadpool)
{
if (convolution_op->type != xnn_operator_type_convolution_nhwc_f32) {
- xnn_log_error("failed to setup Convolution (NHWC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_convolution_nhwc_f32),
+ xnn_operator_type_to_string(convolution_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/deconvolution-nhwc.c b/src/operators/deconvolution-nhwc.c
index 81de3c9..9514e52 100644
--- a/src/operators/deconvolution-nhwc.c
+++ b/src/operators/deconvolution-nhwc.c
@@ -71,7 +71,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Deconvolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8));
goto error;
}
@@ -79,53 +80,52 @@
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), kernel_width, kernel_height);
goto error;
}
if (stride_width == 0 || stride_height == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), stride_width, stride_height);
goto error;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), dilation_width, dilation_height);
goto error;
}
if (groups == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to create %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), groups);
goto error;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to create %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), group_input_channels);
goto error;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to create %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), group_output_channels);
goto error;
}
const size_t input_channels = groups * group_input_channels;
if (input_pixel_stride < input_channels) {
xnn_log_error(
- "failed to create Deconvolution operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of output channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8),
input_pixel_stride, groups, group_input_channels);
goto error;
}
@@ -133,46 +133,47 @@
const size_t output_channels = groups * group_output_channels;
if (output_pixel_stride < output_channels) {
xnn_log_error(
- "failed to create Deconvolution operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of output channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8),
output_pixel_stride, groups, group_output_channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Deconvolution operator with %.7g input scale: scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), input_scale);
goto error;
}
if (kernel_scale <= 0.0f || !isnormal(kernel_scale)) {
xnn_log_error(
- "failed to create Deconvolution operator with %.7g kernel scale: scale must be finite, normalized, and positive",
- kernel_scale);
+ "failed to create %s operator with %.7g kernel scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), kernel_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Deconvolution operator with %.7g output scale: scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Deconvolution operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8), output_min, output_max);
goto error;
}
const bool any_padding = (output_padding_left | output_padding_top | output_padding_right | output_padding_bottom) != 0;
if (any_padding && (flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8),
output_padding_top, output_padding_left, output_padding_bottom, output_padding_right);
goto error;
}
@@ -182,8 +183,9 @@
const float deconvolution_scale = input_scale * kernel_scale / output_scale;
if (deconvolution_scale >= 1.0f) {
xnn_log_error(
- "failed to create Deconvolution operator with %.7g input scale, %.7g kernel scale, and %.7g output scale: "
- "Deconvolution operator scale %.7g is greater or equal to 1.0",
+ "failed to create %s operator with %.7g input scale, %.7g kernel scale, and %.7g output scale: "
+ "deconvolution scale %.7g is greater or equal to 1.0",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8),
input_scale, kernel_scale, output_scale, deconvolution_scale);
goto error;
}
@@ -192,7 +194,9 @@
deconvolution_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (deconvolution_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Deconvolution operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8));
goto error;
}
@@ -216,7 +220,9 @@
const size_t subconvolution_buffer_size = sizeof(struct subconvolution_params) * subkernels;
deconvolution_op->subconvolution_buffer = xnn_allocate_zero_memory(subconvolution_buffer_size);
if (deconvolution_op->subconvolution_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for subconvolution buffer", subconvolution_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator subconvolution buffer",
+ subconvolution_buffer_size, xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8));
goto error;
}
@@ -235,7 +241,9 @@
}
deconvolution_op->packed_weights = xnn_allocate_simd_memory(packed_group_weights_size * groups);
if (deconvolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_group_weights_size * groups);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_group_weights_size * groups, xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8));
goto error;
}
memset(deconvolution_op->packed_weights, kernel_zero_point, packed_group_weights_size * groups);
@@ -263,7 +271,9 @@
size_t zero_size = sizeof(uint8_t) * k_stride + XNN_EXTRA_BYTES;
void* zero_buffer = xnn_allocate_simd_memory(zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for zero padding", zero_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_size, xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8));
goto error;
}
memset(zero_buffer, input_zero_point, zero_size);
@@ -358,7 +368,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Deconvolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
@@ -366,53 +377,52 @@
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), kernel_width, kernel_height);
goto error;
}
if (stride_width == 0 || stride_height == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), stride_width, stride_height);
goto error;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), dilation_width, dilation_height);
goto error;
}
if (groups == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to create %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), groups);
goto error;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to create %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), group_input_channels);
goto error;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to create %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), group_output_channels);
goto error;
}
const size_t input_channels = groups * group_input_channels;
if (input_pixel_stride < input_channels) {
xnn_log_error(
- "failed to create Deconvolution operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of output channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32),
input_pixel_stride, groups, group_input_channels);
goto error;
}
@@ -420,37 +430,40 @@
const size_t output_channels = groups * group_output_channels;
if (output_pixel_stride < output_channels) {
xnn_log_error(
- "failed to create Deconvolution operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of output channels (%" PRIu32 "x%zu)",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32),
output_pixel_stride, groups, group_output_channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Deconvolution operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Deconvolution operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Deconvolution operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32), output_min, output_max);
goto error;
}
const bool any_padding = (output_padding_left | output_padding_top | output_padding_right | output_padding_bottom) != 0;
if (any_padding && (flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
xnn_log_error(
- "failed to create Deconvolution operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32),
output_padding_top, output_padding_left, output_padding_bottom, output_padding_right);
goto error;
}
@@ -459,7 +472,9 @@
deconvolution_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (deconvolution_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Deconvolution operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
@@ -496,7 +511,9 @@
const size_t subconvolution_buffer_size = sizeof(struct subconvolution_params) * subkernels;
deconvolution_op->subconvolution_buffer = xnn_allocate_zero_memory(subconvolution_buffer_size);
if (deconvolution_op->subconvolution_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for subconvolution buffer", subconvolution_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator subconvolution buffer",
+ subconvolution_buffer_size, xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
@@ -515,7 +532,9 @@
}
deconvolution_op->packed_weights = xnn_allocate_simd_memory(packed_group_weights_size * groups);
if (deconvolution_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_group_weights_size * groups);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_group_weights_size * groups, xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
memset(deconvolution_op->packed_weights, 0, packed_group_weights_size * groups);
@@ -541,7 +560,9 @@
const size_t zero_size = k_stride * sizeof(float) + XNN_EXTRA_BYTES;
void* zero_buffer = xnn_allocate_zero_simd_memory(zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for zero padding", zero_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_size, xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32));
goto error;
}
deconvolution_op->zero_buffer = zero_buffer;
@@ -636,7 +657,9 @@
{
const void** indirection_buffer = (const void**) xnn_reallocate_memory(deconvolution_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(deconvolution_op->type));
return xnn_status_out_of_memory;
}
deconvolution_op->indirection_buffer = indirection_buffer;
@@ -774,7 +797,9 @@
const void** indirection_buffer =
(const void**) xnn_reallocate_memory(deconvolution_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(deconvolution_op->type));
return xnn_status_out_of_memory;
}
deconvolution_op->indirection_buffer = indirection_buffer;
@@ -895,30 +920,31 @@
deconvolution_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Deconvolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(deconvolution_op->type));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Deconvolution with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(deconvolution_op->type), input_width, input_height);
return xnn_status_invalid_parameter;
}
if (adjustment_height >= deconvolution_op->stride_height) {
xnn_log_error(
- "failed to setup Deconvolution with %" PRIu32 " height adjustment: "
+ "failed to setup %s operator with %" PRIu32 " height adjustment: "
"height adjustment must be smaller than height stride (%" PRIu32 ")",
- adjustment_height, deconvolution_op->stride_height);
+ xnn_operator_type_to_string(deconvolution_op->type), adjustment_height, deconvolution_op->stride_height);
return xnn_status_invalid_parameter;
}
if (adjustment_width >= deconvolution_op->stride_width) {
xnn_log_error(
- "failed to setup Deconvolution with %" PRIu32 " width adjustment: "
+ "failed to setup %s operator with %" PRIu32 " width adjustment: "
"width adjustment must be smaller than width stride (%" PRIu32 ")",
- adjustment_width, deconvolution_op->stride_width);
+ xnn_operator_type_to_string(deconvolution_op->type), adjustment_width, deconvolution_op->stride_width);
return xnn_status_invalid_parameter;
}
@@ -996,7 +1022,9 @@
pthreadpool_t threadpool)
{
if (deconvolution_op->type != xnn_operator_type_deconvolution_nhwc_q8) {
- xnn_log_error("failed to setup Deconvolution (NHWC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_q8),
+ xnn_operator_type_to_string(deconvolution_op->type));
return xnn_status_invalid_parameter;
}
@@ -1025,7 +1053,9 @@
pthreadpool_t threadpool)
{
if (deconvolution_op->type != xnn_operator_type_deconvolution_nhwc_f32) {
- xnn_log_error("failed to setup Deconvolution (NHWC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_deconvolution_nhwc_f32),
+ xnn_operator_type_to_string(deconvolution_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/fully-connected-nc.c b/src/operators/fully-connected-nc.c
index fb796c7..85cd577 100644
--- a/src/operators/fully-connected-nc.c
+++ b/src/operators/fully-connected-nc.c
@@ -45,7 +45,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Fully Connected operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8));
goto error;
}
@@ -53,60 +54,59 @@
if (input_channels == 0) {
xnn_log_error(
- "failed to create Fully Connected operator with %zu input channels: number of channels must be non-zero",
- input_channels);
+ "failed to create %s operator with %zu input channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), input_channels);
goto error;
}
if (output_channels == 0) {
xnn_log_error(
- "failed to create Fully Connected operator with %zu output channels: number of channels must be non-zero",
- output_channels);
+ "failed to create %s operator with %zu output channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), output_channels);
goto error;
}
if (input_stride < input_channels) {
xnn_log_error(
- "failed to create Fully Connected operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of input channels (%zu)",
- input_stride, input_channels);
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), input_stride, input_channels);
goto error;
}
if (output_stride < output_channels) {
xnn_log_error(
- "failed to create Fully Connected operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of output channels (%zu)",
- output_stride, output_channels);
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), output_stride, output_channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Fully Connected operator with %.7g input scale: scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), input_scale);
goto error;
}
if (kernel_scale <= 0.0f || !isnormal(kernel_scale)) {
xnn_log_error(
- "failed to create Fully Connected operator with %.7g kernel scale: scale must be finite, normalized, and positive",
- kernel_scale);
+ "failed to create %s operator with %.7g kernel scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), kernel_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Fully Connected operator with %.7g output scale: scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Fully Connected operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8), output_min, output_max);
goto error;
}
@@ -115,8 +115,9 @@
const float requantization_scale = input_scale * kernel_scale / output_scale;
if (requantization_scale >= 1.0f) {
xnn_log_error(
- "failed to create Fully Connected operator with %.7g input scale, %.7g kernel scale, and %.7g output scale: "
+ "failed to create %s operator with %.7g input scale, %.7g kernel scale, and %.7g output scale: "
"requantization scale %.7g is greater or equal to 1.0",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8),
input_scale, kernel_scale, output_scale, requantization_scale);
goto error;
}
@@ -125,7 +126,8 @@
fully_connected_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (fully_connected_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Fully Connected operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error("failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8));
goto error;
}
@@ -135,10 +137,11 @@
const size_t n_stride = round_up(output_channels, nr);
const size_t k_stride = round_up_po2(input_channels, kr);
- fully_connected_op->packed_weights = xnn_allocate_simd_memory(n_stride * (k_stride * sizeof(uint8_t) + sizeof(int32_t)));
+ const size_t packed_weights_size = n_stride * (k_stride * sizeof(uint8_t) + sizeof(int32_t));
+ fully_connected_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (fully_connected_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights",
- n_stride * (k_stride * sizeof(uint8_t) + sizeof(int32_t)));
+ xnn_log_error("failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8));
goto error;
}
memset(fully_connected_op->packed_weights, kernel_zero_point, n_stride * (k_stride * sizeof(uint8_t) + sizeof(int32_t)));
@@ -207,7 +210,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Fully Connected operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32));
goto error;
}
@@ -215,50 +219,52 @@
if (input_channels == 0) {
xnn_log_error(
- "failed to create Fully Connected operator with %zu input channels: number of channels must be non-zero",
- input_channels);
+ "failed to create %s operator with %zu input channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32), input_channels);
goto error;
}
if (output_channels == 0) {
xnn_log_error(
- "failed to create Fully Connected operator with %zu output channels: number of channels must be non-zero",
- output_channels);
+ "failed to create %s operator with %zu output channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32), output_channels);
goto error;
}
if (input_stride < input_channels) {
xnn_log_error(
- "failed to create Fully Connected operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of input channels (%zu)",
- input_stride, input_channels);
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32), input_stride, input_channels);
goto error;
}
if (output_stride < output_channels) {
xnn_log_error(
- "failed to create Fully Connected operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of output channels (%zu)",
- output_stride, output_channels);
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32), output_stride, output_channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Fully Connected operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Fully Connected operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Fully Connected operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32), output_min, output_max);
goto error;
}
@@ -266,7 +272,9 @@
fully_connected_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (fully_connected_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Fully Connected operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32));
goto error;
}
@@ -277,10 +285,12 @@
const size_t n_stride = round_up(output_channels, nr);
const size_t k_stride = round_up_po2(input_channels, kr);
- fully_connected_op->packed_weights = xnn_allocate_simd_memory(n_stride * (k_stride * sizeof(float) + sizeof(float)));
+ const size_t packed_weights_size = n_stride * (k_stride * sizeof(float) + sizeof(float));
+ fully_connected_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (fully_connected_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights",
- n_stride * (k_stride * sizeof(float) + sizeof(float)));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32));
goto error;
}
memset(fully_connected_op->packed_weights, 0, n_stride * (k_stride * sizeof(float) + sizeof(float)));
@@ -348,7 +358,8 @@
fully_connected_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Fully Connected operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(fully_connected_op->type));
return xnn_status_uninitialized;
}
@@ -420,7 +431,9 @@
pthreadpool_t threadpool)
{
if (fully_connected_op->type != xnn_operator_type_fully_connected_nc_q8) {
- xnn_log_error("failed to setup Fully Connected (NC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_q8),
+ xnn_operator_type_to_string(fully_connected_op->type));
return xnn_status_invalid_parameter;
}
@@ -444,7 +457,9 @@
pthreadpool_t threadpool)
{
if (fully_connected_op->type != xnn_operator_type_fully_connected_nc_f32) {
- xnn_log_error("failed to setup Fully Connected (NC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_fully_connected_nc_f32),
+ xnn_operator_type_to_string(fully_connected_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/global-average-pooling-ncw.c b/src/operators/global-average-pooling-ncw.c
index a18f4ac..80076b2 100644
--- a/src/operators/global-average-pooling-ncw.c
+++ b/src/operators/global-average-pooling-ncw.c
@@ -28,7 +28,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Global Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32));
goto error;
}
@@ -36,36 +37,37 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Global Average Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32), channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Global Average Pooling operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Global Average Pooling operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Global Average Pooling operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32), output_min, output_max);
goto error;
}
status = xnn_status_unsupported_parameter;
if (xnn_params.f32.gavgpool_cw.ukernel == NULL) {
xnn_log_error(
- "failed to create Global Average Pooling operator: "
- "only selected configurations parameters are supported");
+ "failed to create %s operator: only selected configurations parameters are supported",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32));
goto error;
}
@@ -73,7 +75,9 @@
global_average_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (global_average_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Global Average Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32));
goto error;
}
@@ -102,18 +106,23 @@
pthreadpool_t threadpool)
{
if (global_average_pooling_op->type != xnn_operator_type_global_average_pooling_ncw_f32) {
- xnn_log_error("failed to setup Global Average Pooling (F32, NCW) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32),
+ xnn_operator_type_to_string(global_average_pooling_op->type));
return xnn_status_invalid_parameter;
}
global_average_pooling_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Global Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32));
return xnn_status_uninitialized;
}
if (width == 0) {
- xnn_log_error("failed to setup Global Average Pooling operator with width %zu: width must be non-zero", width);
+ xnn_log_error(
+ "failed to setup %s operator with width %zu: width must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_ncw_f32), width);
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/global-average-pooling-nwc.c b/src/operators/global-average-pooling-nwc.c
index 993a5f6..0ca860b 100644
--- a/src/operators/global-average-pooling-nwc.c
+++ b/src/operators/global-average-pooling-nwc.c
@@ -37,7 +37,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Global Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8));
goto error;
}
@@ -45,48 +46,45 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Global Average Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Global Average Pooling operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Global Average Pooling operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), output_stride, channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Global Average Pooling operator with %.7g input scale: "
- "scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), input_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Global Average Pooling operator with %.7g output scale: "
- "scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Global Average Pooling operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), output_min, output_max);
goto error;
}
@@ -95,9 +93,8 @@
const float input_output_scale = input_scale / output_scale;
if (input_output_scale < 0x1.0p-8f || input_output_scale >= 0x1.0p+8f) {
xnn_log_error(
- "failed to create Global Average Pooling operator with %.7g input-to-output scale ratio: "
- "scale ratio must be in [2**-8, 2**8) range",
- input_output_scale);
+ "failed to create %s operator with %.7g input-to-output scale ratio: scale ratio must be in [2**-8, 2**8) range",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), input_output_scale);
goto error;
}
@@ -105,14 +102,18 @@
global_average_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (global_average_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Global Average Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8));
goto error;
}
- void* zero_buffer = xnn_allocate_zero_simd_memory(channels * sizeof(uint8_t) + XNN_EXTRA_BYTES);
+ const size_t zero_size = channels * sizeof(uint8_t) + XNN_EXTRA_BYTES;
+ void* zero_buffer = xnn_allocate_zero_simd_memory(zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Global Average Pooling zero padding",
- channels * sizeof(uint8_t) + XNN_EXTRA_BYTES);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_size, xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8));
goto error;
}
global_average_pooling_op->zero_buffer = zero_buffer;
@@ -153,7 +154,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Global Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32));
goto error;
}
@@ -161,44 +163,45 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Global Average Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Global Average Pooling operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Global Average Pooling operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32), output_stride, channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Global Average Pooling operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Global Average Pooling operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Global Average Pooling operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32), output_min, output_max);
goto error;
}
@@ -206,14 +209,18 @@
global_average_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (global_average_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Global Average Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32));
goto error;
}
- void* zero_buffer = xnn_allocate_zero_simd_memory(channels * sizeof(float) + XNN_EXTRA_BYTES);
+ const size_t zero_size = channels * sizeof(float) + XNN_EXTRA_BYTES;
+ void* zero_buffer = xnn_allocate_zero_simd_memory(zero_size);
if (zero_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Global Average Pooling zero padding",
- channels * sizeof(float) + XNN_EXTRA_BYTES);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator zero padding",
+ zero_size, xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32));
goto error;
}
global_average_pooling_op->zero_buffer = zero_buffer;
@@ -245,18 +252,22 @@
pthreadpool_t threadpool)
{
if (global_average_pooling_op->type != xnn_operator_type_global_average_pooling_nwc_q8) {
- xnn_log_error("failed to setup Global Average Pooling (NWC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8),
+ xnn_operator_type_to_string(global_average_pooling_op->type));
return xnn_status_invalid_parameter;
}
global_average_pooling_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Global Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8));
return xnn_status_uninitialized;
}
if (width == 0) {
- xnn_log_error("failed to setup Global Average Pooling operator with width %zu: width must be non-zero", width);
+ xnn_log_error("failed to setup %s operator with width %zu: width must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_q8), width);
return xnn_status_invalid_parameter;
}
@@ -315,18 +326,22 @@
pthreadpool_t threadpool)
{
if (global_average_pooling_op->type != xnn_operator_type_global_average_pooling_nwc_f32) {
- xnn_log_error("failed to setup Global Average Pooling (NWC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32),
+ xnn_operator_type_to_string(global_average_pooling_op->type));
return xnn_status_invalid_parameter;
}
global_average_pooling_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Global Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32));
return xnn_status_uninitialized;
}
if (width == 0) {
- xnn_log_error("failed to setup Global Average Pooling operator with width %zu: width must be non-zero", width);
+ xnn_log_error("failed to setup %s operator with width %zu: width must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_global_average_pooling_nwc_f32), width);
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/hardswish-nc.c b/src/operators/hardswish-nc.c
index c3f4b6c..46adba3 100644
--- a/src/operators/hardswish-nc.c
+++ b/src/operators/hardswish-nc.c
@@ -27,7 +27,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create HardSwish operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32));
goto error;
}
@@ -35,23 +36,24 @@
if (channels == 0) {
xnn_log_error(
- "failed to create HardSwish operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create HardSwish operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create HardSwish operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32), output_stride, channels);
goto error;
}
@@ -59,7 +61,9 @@
hardswish_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (hardswish_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for xnn_operator structure", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32));
goto error;
}
@@ -89,13 +93,16 @@
pthreadpool_t threadpool)
{
if (hardswish_op->type != xnn_operator_type_hardswish_nc_f32) {
- xnn_log_error("failed to setup HardSwish (F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32),
+ xnn_operator_type_to_string(hardswish_op->type));
return xnn_status_invalid_parameter;
}
hardswish_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup HardSwish operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_hardswish_nc_f32));
return xnn_status_uninitialized;
}
diff --git a/src/operators/leaky-relu-nc.c b/src/operators/leaky-relu-nc.c
index fda6b3a..4eeb5f1 100644
--- a/src/operators/leaky-relu-nc.c
+++ b/src/operators/leaky-relu-nc.c
@@ -36,7 +36,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Leaky ReLU operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8));
goto error;
}
@@ -44,58 +45,59 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Leaky ReLU operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Leaky ReLU operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Leaky ReLU operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), output_stride, channels);
goto error;
}
if (negative_slope <= 0.0f || !isnormal(negative_slope)) {
xnn_log_error(
- "failed to create Leaky ReLU operator with %.7g negative slope: slope must be finite, normalized, and positive",
- negative_slope);
+ "failed to create %s operator with %.7g negative slope: slope must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), negative_slope);
goto error;
}
if (negative_slope > 1.0f) {
xnn_log_error(
- "failed to create Leaky ReLU operator with %.7g negative slope: slope must not exceed 1.0", negative_slope);
+ "failed to create %s operator with %.7g negative slope: slope must not exceed 1.0",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), negative_slope);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Leaky ReLU operator with %.7g input scale: scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), input_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Leaky ReLU operator with %.7g output scale: scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Leaky ReLU operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), output_min, output_max);
goto error;
}
@@ -104,9 +106,9 @@
const float input_output_scale = input_scale / output_scale;
if (input_output_scale < 0x1.0p-8f || input_output_scale >= 0x1.0p+8f) {
xnn_log_error(
- "failed to create Leaky ReLU operator with %.7g input-to-output scale ratio: "
+ "failed to create %s operator with %.7g input-to-output scale ratio: "
"scale ratio must be in [2**-8, 2**8) range",
- input_output_scale);
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8), input_output_scale);
goto error;
}
@@ -114,13 +116,17 @@
leaky_relu_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (leaky_relu_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Leaky ReLU operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8));
goto error;
}
leaky_relu_op->lookup_table = xnn_allocate_simd_memory(256 * sizeof(uint8_t));
if (leaky_relu_op->lookup_table == NULL) {
- xnn_log_error("failed to allocate 256 bytes for Leaky ReLU lookup table");
+ xnn_log_error(
+ "failed to allocate 256 bytes for %s operator lookup table",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8));
goto error;
}
@@ -164,13 +170,17 @@
pthreadpool_t threadpool)
{
if (leaky_relu_op->type != xnn_operator_type_leaky_relu_nc_q8) {
- xnn_log_error("failed to setup Leaky ReLU (NC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8),
+ xnn_operator_type_to_string(leaky_relu_op->type));
return xnn_status_invalid_parameter;
}
leaky_relu_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Leaky ReLU operator: XNNPACK is not initialized");
+ xnn_log_error(
+ "failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_leaky_relu_nc_q8));
return xnn_status_uninitialized;
}
diff --git a/src/operators/max-pooling-nhwc.c b/src/operators/max-pooling-nhwc.c
index 908615e..0990a20 100644
--- a/src/operators/max-pooling-nhwc.c
+++ b/src/operators/max-pooling-nhwc.c
@@ -65,7 +65,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Max Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8));
goto error;
}
@@ -74,62 +75,60 @@
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), pooling_width, pooling_height);
goto error;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to create Max Pooling operator with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to create %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8));
goto error;
}
if (stride_height == 0 || stride_width == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "x%" PRIu32 " stride: "
- "stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), stride_width, stride_height);
goto error;
}
if (dilation_height == 0 || dilation_width == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), dilation_width, dilation_height);
goto error;
}
if (channels == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Max Pooling operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Max Pooling operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), output_pixel_stride, channels);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Max Pooling operator with [%" PRIu8 ", %" PRIu8 "] output range: "
- "range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8), output_min, output_max);
goto error;
}
@@ -137,8 +136,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -148,7 +148,9 @@
max_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (max_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Max Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8));
goto error;
}
@@ -206,7 +208,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Max Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32));
return xnn_status_uninitialized;
}
@@ -215,74 +218,75 @@
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32),
pooling_width, pooling_height);
goto error;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to create Max Pooling operator with 1 pooling element: "
- "1x1 pooling is meaningless");
+ "failed to create %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32));
goto error;
}
if (stride_height == 0 || stride_width == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "x%" PRIu32 " stride: "
- "stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32), stride_width, stride_height);
goto error;
}
if (dilation_height == 0 || dilation_width == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32), dilation_width, dilation_height);
goto error;
}
if (channels == 0) {
xnn_log_error(
- "failed to create Max Pooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Max Pooling operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Max Pooling operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32), output_pixel_stride, channels);
goto error;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to create Max Pooling with NaN output lower bound: lower bound must be non-NaN");
+ "failed to create %s with NaN output lower bound: lower bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32));
goto error;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to create Max Pooling with NaN output upper bound: upper bound must be non-NaN");
+ "failed to create %s with NaN output upper bound: upper bound must be non-NaN",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32));
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Max Pooling with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to create %s with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32), output_min, output_max);
goto error;
}
@@ -290,8 +294,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to create Max Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to create %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
goto error;
}
@@ -301,7 +306,9 @@
max_pooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (max_pooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Max Pooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32));
goto error;
}
@@ -353,14 +360,15 @@
if (!xnn_params.initialized) {
xnn_log_error(
- "failed to setup Max Pooling operator: XNNPACK is not initialized");
+ "failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(max_pooling_op->type));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Max Pooling operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(max_pooling_op->type), input_width, input_height);
return xnn_status_invalid_parameter;
}
@@ -418,7 +426,8 @@
{
// Micro-kernel may read up to (mr - 1) elements after the end of indirection buffer.
const size_t indirection_buffer_size = sizeof(void*) * ((mr - 1) + output_height * step_height);
- const void** indirection_buffer = (const void**) xnn_reallocate_memory(max_pooling_op->indirection_buffer, indirection_buffer_size);
+ const void** indirection_buffer =
+ (const void**) xnn_reallocate_memory(max_pooling_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
return xnn_status_out_of_memory;
@@ -476,7 +485,9 @@
pthreadpool_t threadpool)
{
if (max_pooling_op->type != xnn_operator_type_max_pooling_nhwc_u8) {
- xnn_log_error("failed to setup Max Pooling (NHWC, U8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_u8),
+ xnn_operator_type_to_string(max_pooling_op->type));
return xnn_status_invalid_parameter;
}
@@ -501,7 +512,9 @@
pthreadpool_t threadpool)
{
if (max_pooling_op->type != xnn_operator_type_max_pooling_nhwc_f32) {
- xnn_log_error("failed to setup Max Pooling (NHWC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_max_pooling_nhwc_f32),
+ xnn_operator_type_to_string(max_pooling_op->type));
return xnn_status_invalid_parameter;
}
diff --git a/src/operators/prelu-nc.c b/src/operators/prelu-nc.c
index 7536f20..c9d70c7 100644
--- a/src/operators/prelu-nc.c
+++ b/src/operators/prelu-nc.c
@@ -29,7 +29,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create PReLU operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32));
goto error;
}
@@ -37,23 +38,24 @@
if (channels == 0) {
xnn_log_error(
- "failed to create PReLU operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create PReLU operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create PReLU operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32), output_stride, channels);
goto error;
}
@@ -61,15 +63,18 @@
prelu_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (prelu_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for PReLU operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32));
goto error;
}
- const size_t packed_channels = round_up_po2(channels, XNN_EXTRA_BYTES / sizeof(float));
- prelu_op->packed_weights = xnn_allocate_simd_memory(packed_channels * sizeof(float));
+ const size_t packed_weights_size = channels * sizeof(float) + XNN_EXTRA_BYTES;
+ prelu_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (prelu_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed slope data",
- packed_channels * sizeof(float));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32));
goto error;
}
memcpy(prelu_op->packed_weights, negative_slope, channels * sizeof(float));
@@ -99,13 +104,16 @@
pthreadpool_t threadpool)
{
if (prelu_op->type != xnn_operator_type_prelu_nc_f32) {
- xnn_log_error("failed to setup PReLU (NC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32),
+ xnn_operator_type_to_string(prelu_op->type));
return xnn_status_invalid_parameter;
}
prelu_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup PReLU operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_prelu_nc_f32));
return xnn_status_uninitialized;
}
diff --git a/src/operators/resize-bilinear-nhwc.c b/src/operators/resize-bilinear-nhwc.c
index 3f350f9..8de7d69 100644
--- a/src/operators/resize-bilinear-nhwc.c
+++ b/src/operators/resize-bilinear-nhwc.c
@@ -31,7 +31,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Resize Bilinear operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32));
goto error;
}
@@ -39,24 +40,24 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Resize Bilinear operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Resize Bilinear operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Resize Bilinear operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), output_pixel_stride, channels);
goto error;
}
@@ -64,7 +65,9 @@
resize_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (resize_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Resize Bilinear operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32));
goto error;
}
@@ -98,43 +101,44 @@
pthreadpool_t threadpool)
{
if (resize_op->type != xnn_operator_type_resize_bilinear_nhwc_f32) {
- xnn_log_error("failed to setup Resize Bilinear (NHWC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32),
+ xnn_operator_type_to_string(resize_op->type));
return xnn_status_invalid_parameter;
}
resize_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Resize Bilinear operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Resize Bilinear operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), input_width, input_height);
return xnn_status_invalid_parameter;
}
if (max(input_width, input_height) >= 16777216) {
xnn_log_error(
- "failed to setup Resize Bilinear operator with %zux%zu input: "
- "input dimensions must be below 2**24",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be below 2**24",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), input_width, input_height);
return xnn_status_unsupported_parameter;
}
if (output_width == 0 || output_height == 0) {
xnn_log_error(
- "failed to setup Resize Bilinear operator with %zux%zu output: output dimensions must be non-zero",
- output_width, output_height);
+ "failed to setup %s operator with %zux%zu output: output dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), output_width, output_height);
return xnn_status_invalid_parameter;
}
if (max(output_width, output_height) >= 16777216) {
xnn_log_error(
- "failed to setup Resize Bilinear operator with %zux%zu output: "
- "output dimensions must be below 2**24",
- output_width, output_height);
+ "failed to setup %s operator with %zux%zu output: output dimensions must be below 2**24",
+ xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32), output_width, output_height);
return xnn_status_unsupported_parameter;
}
@@ -149,7 +153,9 @@
const void** indirection_buffer = (const void**) xnn_reallocate_memory(resize_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32));
return xnn_status_out_of_memory;
}
resize_op->indirection_buffer = indirection_buffer;
@@ -158,7 +164,9 @@
xnn_release_simd_memory(resize_op->packed_weights);
resize_op->packed_weights = xnn_allocate_simd_memory(packed_weights_size);
if (resize_op->packed_weights == NULL) {
- xnn_log_error("failed to allocate %zu bytes for packed weights", packed_weights_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator packed weights",
+ packed_weights_size, xnn_operator_type_to_string(xnn_operator_type_resize_bilinear_nhwc_f32));
return xnn_status_out_of_memory;
}
}
diff --git a/src/operators/sigmoid-nc.c b/src/operators/sigmoid-nc.c
index 8ea899c..8724153 100644
--- a/src/operators/sigmoid-nc.c
+++ b/src/operators/sigmoid-nc.c
@@ -35,7 +35,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Sigmoid operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
goto error;
}
@@ -43,44 +44,45 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Sigmoid operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Sigmoid operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Sigmoid operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_stride, channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create Sigmoid operator with %.7g input scale: scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), input_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create Sigmoid operator with %.7g output scale: scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_scale);
goto error;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to create Sigmoid operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
- output_min, output_max);
+ "failed to create %s operator with [%" PRIu8 ", %" PRIu8 "] output range: range min must be below range max",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_min, output_max);
goto error;
}
@@ -88,15 +90,15 @@
if (output_scale != 0x1.0p-8f) {
xnn_log_error(
- "failed to create Sigmoid operator with %.7g output scale: only output scale of 1/256 is supported",
- output_scale);
+ "failed to create %s operator with %.7g output scale: only output scale of 1/256 is supported",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_scale);
goto error;
}
if (output_zero_point != 0) {
xnn_log_error(
- "failed to create Sigmoid operator with %" PRIu8 " output zero point: only output zero point of 0 is supported",
- output_zero_point);
+ "failed to create %s operator with %" PRIu8 " output zero point: only output zero point of 0 is supported",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_zero_point);
goto error;
}
@@ -104,13 +106,17 @@
sigmoid_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (sigmoid_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Sigmoid operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
goto error;
}
sigmoid_op->lookup_table = xnn_allocate_simd_memory(256 * sizeof(uint8_t));
if (sigmoid_op->lookup_table == NULL) {
- xnn_log_error("failed to allocate 256 bytes for Sigmoid lookup table");
+ xnn_log_error(
+ "failed to allocate 256 bytes for %s operator lookup table",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
goto error;
}
@@ -158,7 +164,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Sigmoid operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32));
goto error;
}
@@ -166,32 +173,24 @@
if (channels == 0) {
xnn_log_error(
- "failed to create Sigmoid operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create Sigmoid operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create Sigmoid operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
- goto error;
- }
-
- status = xnn_status_unsupported_hardware;
-
- if (xnn_params.f32.sigmoid == NULL) {
- xnn_log_error(
- "failed to create Sigmoid operator: "
- "only selected hardware configurations are supported");
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32), output_stride, channels);
goto error;
}
@@ -199,7 +198,9 @@
sigmoid_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (sigmoid_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for xnn_operator structure", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32));
goto error;
}
@@ -228,13 +229,16 @@
pthreadpool_t threadpool)
{
if (sigmoid_op->type != xnn_operator_type_sigmoid_nc_q8) {
- xnn_log_error("failed to setup Sigmoid (Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8),
+ xnn_operator_type_to_string(sigmoid_op->type));
return xnn_status_invalid_parameter;
}
sigmoid_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Sigmoid operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
return xnn_status_uninitialized;
}
@@ -292,13 +296,16 @@
pthreadpool_t threadpool)
{
if (sigmoid_op->type != xnn_operator_type_sigmoid_nc_f32) {
- xnn_log_error("failed to setup Sigmoid (F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32),
+ xnn_operator_type_to_string(sigmoid_op->type));
return xnn_status_invalid_parameter;
}
sigmoid_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Sigmoid operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32));
return xnn_status_uninitialized;
}
diff --git a/src/operators/softmax-nc.c b/src/operators/softmax-nc.c
index 6351ae8..f438103 100644
--- a/src/operators/softmax-nc.c
+++ b/src/operators/softmax-nc.c
@@ -33,7 +33,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create SoftMax operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
goto error;
}
@@ -41,37 +42,38 @@
if (channels == 0) {
xnn_log_error(
- "failed to create SoftMax operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create SoftMax operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create SoftMax operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_stride, channels);
goto error;
}
if (input_scale <= 0.0f || !isnormal(input_scale)) {
xnn_log_error(
- "failed to create SoftMax operator with %.7g input scale: scale must be finite, normalized, and positive",
- input_scale);
+ "failed to create %s operator with %.7g input scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), input_scale);
goto error;
}
if (output_scale <= 0.0f || !isnormal(output_scale)) {
xnn_log_error(
- "failed to create SoftMax operator with %.7g output scale: scale must be finite, normalized, and positive",
- output_scale);
+ "failed to create %s operator with %.7g output scale: scale must be finite, normalized, and positive",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_scale);
goto error;
}
@@ -79,16 +81,15 @@
if (output_scale != 0x1.0p-8f) {
xnn_log_error(
- "failed to create SoftMax operator with %.7g output scale: only output scale of 1/256 is supported",
- output_scale);
+ "failed to create %s operator with %.7g output scale: only output scale of 1/256 is supported",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_scale);
goto error;
}
if (output_zero_point != 0) {
xnn_log_error(
- "failed to create SoftMax operator with %" PRIu8 " output zero point: "
- "only output zero point of 0 is supported",
- output_zero_point);
+ "failed to create %s operator with %" PRIu8 " output zero point: only output zero point of 0 is supported",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8), output_zero_point);
goto error;
}
@@ -96,13 +97,17 @@
softmax_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (softmax_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for SoftMax operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
goto error;
}
softmax_op->lookup_table = xnn_allocate_simd_memory(256 * sizeof(uint32_t));
if (softmax_op->lookup_table == NULL) {
- xnn_log_error("failed to allocate 256 bytes for SoftMax lookup table");
+ xnn_log_error(
+ "failed to allocate 256 bytes for %s operator lookup table",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
goto error;
}
@@ -138,13 +143,16 @@
pthreadpool_t threadpool)
{
if (softmax_op->type != xnn_operator_type_softmax_nc_q8) {
- xnn_log_error("failed to setup SoftMax (NC, Q8) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_softmax_nc_q8),
+ xnn_operator_type_to_string(softmax_op->type));
return xnn_status_invalid_parameter;
}
softmax_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup SoftMax operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_q8));
return xnn_status_uninitialized;
}
@@ -186,7 +194,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create SoftMax operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32));
goto error;
}
@@ -194,23 +203,24 @@
if (channels == 0) {
xnn_log_error(
- "failed to create SoftMax operator with %zu channels: number of channels must be non-zero", channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32), channels);
goto error;
}
if (input_stride < channels) {
xnn_log_error(
- "failed to create SoftMax operator with input element stride of %zu: "
+ "failed to create %s operator with input element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32), input_stride, channels);
goto error;
}
if (output_stride < channels) {
xnn_log_error(
- "failed to create SoftMax operator with output element stride of %zu: "
+ "failed to create %s operator with output element stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32), output_stride, channels);
goto error;
}
@@ -218,7 +228,9 @@
softmax_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (softmax_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for SoftMax operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32));
goto error;
}
@@ -247,13 +259,16 @@
pthreadpool_t threadpool)
{
if (softmax_op->type != xnn_operator_type_softmax_nc_f32) {
- xnn_log_error("failed to setup SoftMax (NC, F32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_softmax_nc_f32),
+ xnn_operator_type_to_string(softmax_op->type));
return xnn_status_invalid_parameter;
}
softmax_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup SoftMax operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_sigmoid_nc_f32));
return xnn_status_uninitialized;
}
diff --git a/src/operators/unpooling-nhwc.c b/src/operators/unpooling-nhwc.c
index a423053..fb22849 100644
--- a/src/operators/unpooling-nhwc.c
+++ b/src/operators/unpooling-nhwc.c
@@ -46,7 +46,8 @@
enum xnn_status status = xnn_status_uninitialized;
if (!xnn_params.initialized) {
- xnn_log_error("failed to create Unpooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to create %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32));
goto error;
}
@@ -55,38 +56,39 @@
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to create Unpooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to create %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32), pooling_width, pooling_height);
goto error;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to create Unpooling operator with 1 pooling element: 1x1 unpooling is meaningless");
+ "failed to create %s operator with 1 pooling element: 1x1 unpooling is meaningless",
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32));
goto error;
}
if (channels == 0) {
xnn_log_error(
- "failed to create Unpooling operator with %zu channels: number of channels must be non-zero",
- channels);
+ "failed to create %s operator with %zu channels: number of channels must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32), channels);
goto error;
}
if (input_pixel_stride < channels) {
xnn_log_error(
- "failed to create Unpooling operator with input pixel stride of %zu: "
+ "failed to create %s operator with input pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- input_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32), input_pixel_stride, channels);
goto error;
}
if (output_pixel_stride < channels) {
xnn_log_error(
- "failed to create Unpooling operator with output pixel stride of %zu: "
+ "failed to create %s operator with output pixel stride of %zu: "
"stride must be at least as large as the number of channels (%zu)",
- output_pixel_stride, channels);
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32), output_pixel_stride, channels);
goto error;
}
@@ -94,7 +96,9 @@
unpooling_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
if (unpooling_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Unpooling operator descriptor", sizeof(struct xnn_operator));
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator descriptor",
+ sizeof(struct xnn_operator), xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32));
goto error;
}
@@ -133,20 +137,23 @@
pthreadpool_t threadpool)
{
if (unpooling_op->type != xnn_operator_type_unpooling_nhwc_x32) {
- xnn_log_error("failed to setup Unpooling (X32) operator: operator type mismatch");
+ xnn_log_error("failed to setup operator: operator type mismatch (expected %s, got %s)",
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32),
+ xnn_operator_type_to_string(unpooling_op->type));
return xnn_status_invalid_parameter;
}
unpooling_op->state = xnn_run_state_invalid;
if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Unpooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to setup %s operator: XNNPACK is not initialized",
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32));
return xnn_status_uninitialized;
}
if (input_width == 0 || input_height == 0) {
xnn_log_error(
- "failed to setup Unpooling operator with %zux%zu input: input dimensions must be non-zero",
- input_width, input_height);
+ "failed to setup %s operator with %zux%zu input: input dimensions must be non-zero",
+ xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32), input_width, input_height);
return xnn_status_invalid_parameter;
}
@@ -186,10 +193,11 @@
const size_t pooling_size = pooling_height * pooling_width;
const size_t indirection_buffer_size = sizeof(void*) * (batch_size * input_height * input_width * pooling_size);
-
void** indirection_buffer = (void**) xnn_reallocate_memory(unpooling_op->indirection_buffer, indirection_buffer_size);
if (indirection_buffer == NULL) {
- xnn_log_error("failed to allocate %zu bytes for indirection buffer", indirection_buffer_size);
+ xnn_log_error(
+ "failed to allocate %zu bytes for %s operator indirection buffer",
+ indirection_buffer_size, xnn_operator_type_to_string(xnn_operator_type_unpooling_nhwc_x32));
return xnn_status_out_of_memory;
}
unpooling_op->indirection_buffer = (const void**) indirection_buffer;
diff --git a/src/subgraph-strings.c b/src/subgraph-strings.c
new file mode 100644
index 0000000..f1e0025
--- /dev/null
+++ b/src/subgraph-strings.c
@@ -0,0 +1,54 @@
+// 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.
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <xnnpack/common.h>
+#include <xnnpack/log.h>
+#include <xnnpack/subgraph.h>
+
+
+const char* xnn_node_type_to_string(enum xnn_node_type type) {
+ switch (type) {
+ case xnn_node_type_invalid:
+ return "Invalid";
+ case xnn_node_type_add2:
+ return "Add2";
+ case xnn_node_type_argmax_pooling_2d:
+ return "ArgMax Pooling 2D";
+ case xnn_node_type_average_pooling_2d:
+ return "Average Pooling 2D";
+ case xnn_node_type_clamp:
+ return "Clamp";
+ case xnn_node_type_constant_pad:
+ return "Constant Pad";
+ case xnn_node_type_convolution_2d:
+ return "Convolution 2D";
+ case xnn_node_type_deconvolution_2d:
+ return "Deconvolution 2D";
+ case xnn_node_type_depthwise_convolution_2d:
+ return "Depthwise Convolution 2D";
+ case xnn_node_type_fully_connected:
+ return "Fully Connected";
+ case xnn_node_type_hardswish:
+ return "HardSwish";
+ case xnn_node_type_multiply2:
+ return "Multiply2";
+ case xnn_node_type_max_pooling_2d:
+ return "Max Pooling 2D";
+ case xnn_node_type_prelu:
+ return "PReLU";
+ case xnn_node_type_sigmoid:
+ return "Sigmoid";
+ case xnn_node_type_softmax:
+ return "Softmax";
+ case xnn_node_type_unpooling_2d:
+ return "Unpooling 2D";
+ }
+ XNN_UNREACHABLE;
+ return NULL;
+}
diff --git a/src/subgraph/add2.c b/src/subgraph/add2.c
index 78a0e65..971daea 100644
--- a/src/subgraph/add2.c
+++ b/src/subgraph/add2.c
@@ -23,48 +23,50 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Add2 operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_add2));
return xnn_status_uninitialized;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Add2 operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_add2));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Add2 operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_add2));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Add2 operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_add2), output_min, output_max);
return xnn_status_invalid_parameter;
}
if (input1_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Add2 operator with the first input ID #%" PRIu32 ": invalid Value ID",
- input1_id);
+ "failed to define %s operator with the first input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_add2), input1_id);
return xnn_status_invalid_parameter;
}
if (input2_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Add2 operator with the second input ID #%" PRIu32 ": invalid Value ID",
- input2_id);
+ "failed to define %s operator with the second input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_add2), input2_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Add2 operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_add2), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/argmax-pooling-2d.c b/src/subgraph/argmax-pooling-2d.c
index 623300b..e81ab8a 100644
--- a/src/subgraph/argmax-pooling-2d.c
+++ b/src/subgraph/argmax-pooling-2d.c
@@ -27,43 +27,45 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define ArgMax Pooling: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d));
return xnn_status_uninitialized;
}
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to define ArgMax Pooling with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), pooling_width, pooling_height);
return xnn_status_invalid_parameter;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to define ArgMax Pooling with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d));
return xnn_status_invalid_parameter;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define ArgMax Pooling with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), input_id);
return xnn_status_invalid_parameter;
}
if (output_value_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define ArgMax Pooling with output value ID #%" PRIu32 ": invalid Value ID",
- output_value_id);
+ "failed to define %s operator with output value ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_value_id);
return xnn_status_invalid_parameter;
}
if (output_index_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define ArgMax Pooling with output index ID #%" PRIu32 ": invalid Value ID",
- output_index_id);
+ "failed to define %s operator with output index ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_index_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/average-pooling-2d.c b/src/subgraph/average-pooling-2d.c
index c8efaeb..9d56f00 100644
--- a/src/subgraph/average-pooling-2d.c
+++ b/src/subgraph/average-pooling-2d.c
@@ -30,49 +30,53 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Average Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
return xnn_status_uninitialized;
}
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to define Average Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d), pooling_width, pooling_height);
return xnn_status_invalid_parameter;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to define Average Pooling operator with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
return xnn_status_invalid_parameter;
}
if (stride_height == 0 || stride_width == 0) {
xnn_log_error(
- "failed to define Average Pooling operator with %" PRIu32 "x%" PRIu32 " stride: "
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " stride: "
"stride dimensions must be non-zero",
- stride_width, stride_height);
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d), stride_width, stride_height);
return xnn_status_invalid_parameter;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Average Pooling with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Average Pooling with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Average Pooling with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d), output_min, output_max);
return xnn_status_invalid_parameter;
}
@@ -80,8 +84,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to define Average Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to define %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
return xnn_status_invalid_parameter;
}
@@ -89,15 +94,15 @@
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Average Pooling operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Average Pooling operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_average_pooling_2d), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/clamp.c b/src/subgraph/clamp.c
index 8bb5dfa..8886496 100644
--- a/src/subgraph/clamp.c
+++ b/src/subgraph/clamp.c
@@ -22,21 +22,22 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Clamp operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_clamp));
return xnn_status_uninitialized;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Clamp operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_clamp), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Clamp operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_clamp), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/convolution-2d.c b/src/subgraph/convolution-2d.c
index 44e8b73..0057d25 100644
--- a/src/subgraph/convolution-2d.c
+++ b/src/subgraph/convolution-2d.c
@@ -37,100 +37,99 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Convolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d));
return xnn_status_uninitialized;
}
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to define Convolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), kernel_width, kernel_height);
return xnn_status_invalid_parameter;
}
if (subsampling_width == 0 || subsampling_height == 0) {
xnn_log_error(
- "failed to define Convolution operator with %" PRIu32 "x%" PRIu32 " subsampling: "
- "subsampling dimensions must be non-zero",
- subsampling_width, subsampling_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " subsampling: subsampling dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), subsampling_width, subsampling_height);
return xnn_status_invalid_parameter;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to define Convolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), dilation_width, dilation_height);
return xnn_status_invalid_parameter;
}
if (groups == 0) {
xnn_log_error(
- "failed to define Convolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to define %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), groups);
return xnn_status_invalid_parameter;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to define Convolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to define %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), group_input_channels);
return xnn_status_invalid_parameter;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to define Convolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to define %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), group_output_channels);
return xnn_status_invalid_parameter;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Convolution operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Convolution operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Convolution operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), output_min, output_max);
return xnn_status_invalid_parameter;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Convolution operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), input_id);
return xnn_status_invalid_parameter;
}
if (filter_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Convolution operator with filter ID #%" PRIu32 ": invalid Value ID",
- filter_id);
+ "failed to define %s operator with filter ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), filter_id);
return xnn_status_invalid_parameter;
}
if (bias_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Convolution operator with bias ID #%" PRIu32 ": invalid Value ID",
- bias_id);
+ "failed to define %s operator with bias ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), bias_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Convolution operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_convolution_2d), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/deconvolution-2d.c b/src/subgraph/deconvolution-2d.c
index 1ac2654..f87be9e 100644
--- a/src/subgraph/deconvolution-2d.c
+++ b/src/subgraph/deconvolution-2d.c
@@ -39,100 +39,99 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Deconvolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d));
return xnn_status_uninitialized;
}
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to define Deconvolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), kernel_width, kernel_height);
return xnn_status_invalid_parameter;
}
if (upsampling_width == 0 || upsampling_height == 0) {
xnn_log_error(
- "failed to define Deconvolution operator with %" PRIu32 "x%" PRIu32 " upsampling: "
- "upsampling dimensions must be non-zero",
- upsampling_width, upsampling_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " upsampling: upsampling dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), upsampling_width, upsampling_height);
return xnn_status_invalid_parameter;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to define Deconvolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), dilation_width, dilation_height);
return xnn_status_invalid_parameter;
}
if (groups == 0) {
xnn_log_error(
- "failed to define Deconvolution operator with %" PRIu32 " groups: number of groups must be non-zero", groups);
+ "failed to define %s operator with %" PRIu32 " groups: number of groups must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), groups);
return xnn_status_invalid_parameter;
}
if (group_input_channels == 0) {
xnn_log_error(
- "failed to define Deconvolution operator with %zu input channels per group: "
- "number of channels must be non-zero",
- group_input_channels);
+ "failed to define %s operator with %zu input channels per group: number of channels must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), group_input_channels);
return xnn_status_invalid_parameter;
}
if (group_output_channels == 0) {
xnn_log_error(
- "failed to define Deconvolution operator with %zu output channels per group: "
- "number of channels must be non-zero",
- group_output_channels);
+ "failed to define %s operator with %zu output channels per group: number of channels must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), group_output_channels);
return xnn_status_invalid_parameter;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Deconvolution operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Deconvolution operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Deconvolution operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), output_min, output_max);
return xnn_status_invalid_parameter;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Deconvolution operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), input_id);
return xnn_status_invalid_parameter;
}
if (filter_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Deconvolution operator with filter ID #%" PRIu32 ": invalid Value ID",
- filter_id);
+ "failed to define %s operator with filter ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), filter_id);
return xnn_status_invalid_parameter;
}
if (bias_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Deconvolution operator with bias ID #%" PRIu32 ": invalid Value ID",
- bias_id);
+ "failed to define %s operator with bias ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), bias_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Deconvolution operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_deconvolution_2d), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/depthwise-convolution-2d.c b/src/subgraph/depthwise-convolution-2d.c
index 58614f5..733ea5b 100644
--- a/src/subgraph/depthwise-convolution-2d.c
+++ b/src/subgraph/depthwise-convolution-2d.c
@@ -36,94 +36,92 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Depthwise Convolution operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d));
return xnn_status_uninitialized;
}
if (kernel_width == 0 || kernel_height == 0) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
- kernel_width, kernel_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " kernel: kernel dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), kernel_width, kernel_height);
return xnn_status_invalid_parameter;
}
if (subsampling_width == 0 || subsampling_height == 0) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with %" PRIu32 "x%" PRIu32 " subsampling: "
- "subsampling dimensions must be non-zero",
- subsampling_width, subsampling_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " subsampling: subsampling dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), subsampling_width, subsampling_height);
return xnn_status_invalid_parameter;
}
if (dilation_width == 0 || dilation_height == 0) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), dilation_width, dilation_height);
return xnn_status_invalid_parameter;
}
if (depth_multiplier == 0) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with %" PRIu32 " depth multiplier: "
- "depth multiplier must be non-zero",
- depth_multiplier);
+ "failed to define %s operator with %" PRIu32 " depth multiplier: depth multiplier must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), depth_multiplier);
return xnn_status_invalid_parameter;
}
if (input_channels == 0) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with %zu input channels: "
- "number of channels must be non-zero",
- input_channels);
+ "failed to define %s operator with %zu input channels: number of channels must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), input_channels);
return xnn_status_invalid_parameter;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), output_min, output_max);
return xnn_status_invalid_parameter;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), input_id);
return xnn_status_invalid_parameter;
}
if (filter_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with filter ID #%" PRIu32 ": invalid Value ID",
- filter_id);
+ "failed to define %s operator with filter ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), filter_id);
return xnn_status_invalid_parameter;
}
if (bias_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with bias ID #%" PRIu32 ": invalid Value ID",
- bias_id);
+ "failed to define %s operator with bias ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), bias_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Depthwise Convolution operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_depthwise_convolution_2d), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/fully-connected.c b/src/subgraph/fully-connected.c
index 3e2e6b2..0cedcd5 100644
--- a/src/subgraph/fully-connected.c
+++ b/src/subgraph/fully-connected.c
@@ -24,55 +24,57 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Fully Connected operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_fully_connected));
return xnn_status_uninitialized;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Fully Connected operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_fully_connected));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Fully Connected operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_fully_connected));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Fully Connected operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_fully_connected), output_min, output_max);
return xnn_status_invalid_parameter;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Fully Connected operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_fully_connected), input_id);
return xnn_status_invalid_parameter;
}
if (filter_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Fully Connected operator with filter ID #%" PRIu32 ": invalid Value ID",
- filter_id);
+ "failed to define %s operator with filter ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_fully_connected), filter_id);
return xnn_status_invalid_parameter;
}
if (bias_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Fully Connected operator with bias ID #%" PRIu32 ": invalid Value ID",
- bias_id);
+ "failed to define %s operator with bias ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_fully_connected), bias_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Fully Connected operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_fully_connected), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/hardswish.c b/src/subgraph/hardswish.c
index b281bbd..36d58d2 100644
--- a/src/subgraph/hardswish.c
+++ b/src/subgraph/hardswish.c
@@ -20,21 +20,22 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define HardSwish operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_hardswish));
return xnn_status_uninitialized;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define HardSwish operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_hardswish), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define HardSwish operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_hardswish), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/max-pooling-2d.c b/src/subgraph/max-pooling-2d.c
index 0f4e5f6..895765c 100644
--- a/src/subgraph/max-pooling-2d.c
+++ b/src/subgraph/max-pooling-2d.c
@@ -32,57 +32,59 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Max Pooling operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d));
return xnn_status_uninitialized;
}
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to define Max Pooling operator with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d), pooling_width, pooling_height);
return xnn_status_invalid_parameter;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to define Max Pooling operator with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d));
return xnn_status_invalid_parameter;
}
if (stride_height == 0 || stride_width == 0) {
xnn_log_error(
- "failed to define Max Pooling operator with %" PRIu32 "x%" PRIu32 " stride: "
- "stride dimensions must be non-zero",
- stride_width, stride_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " stride: stride dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d), stride_width, stride_height);
return xnn_status_invalid_parameter;
}
if (dilation_height == 0 || dilation_width == 0) {
xnn_log_error(
- "failed to define Max Pooling operator with %" PRIu32 "x%" PRIu32 " dilation: "
- "dilation dimensions must be non-zero",
- dilation_width, dilation_height);
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " dilation: dilation dimensions must be non-zero",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d), dilation_width, dilation_height);
return xnn_status_invalid_parameter;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Max Pooling with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Max Pooling with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Max Pooling with [%.7g, %.7g] output range: lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d), output_min, output_max);
return xnn_status_invalid_parameter;
}
@@ -90,8 +92,9 @@
if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
if (any_padding) {
xnn_log_error(
- "failed to define Max Pooling operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
+ "failed to define %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
"TensorFlow SAME padding can't be combined with explicit padding specification",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d),
input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
return xnn_status_invalid_parameter;
}
@@ -99,15 +102,15 @@
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Max Pooling operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Max Pooling operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_max_pooling_2d), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/multiply2.c b/src/subgraph/multiply2.c
index 4289db2..c3094f9 100644
--- a/src/subgraph/multiply2.c
+++ b/src/subgraph/multiply2.c
@@ -23,48 +23,50 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Multiply2 operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_multiply2));
return xnn_status_uninitialized;
}
if (isnan(output_min)) {
xnn_log_error(
- "failed to define Multiply2 operator with NaN output lower bound: lower bound must be non-NaN");
+ "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_multiply2));
return xnn_status_invalid_parameter;
}
if (isnan(output_max)) {
xnn_log_error(
- "failed to define Multiply2 operator with NaN output upper bound: upper bound must be non-NaN");
+ "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
+ xnn_node_type_to_string(xnn_node_type_multiply2));
return xnn_status_invalid_parameter;
}
if (output_min >= output_max) {
xnn_log_error(
- "failed to define Multiply2 operator with [%.7g, %.7g] output range: "
- "lower bound must be below upper bound",
- output_min, output_max);
+ "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
+ xnn_node_type_to_string(xnn_node_type_multiply2), output_min, output_max);
return xnn_status_invalid_parameter;
}
if (input1_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Multiply2 operator with the first input ID #%" PRIu32 ": invalid Value ID",
- input1_id);
+ "failed to define %s operator with the first input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_multiply2), input1_id);
return xnn_status_invalid_parameter;
}
if (input2_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Multiply2 operator with the second input ID #%" PRIu32 ": invalid Value ID",
- input2_id);
+ "failed to define %s operator with the second input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_multiply2), input2_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Multiply2 operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_multiply2), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/prelu.c b/src/subgraph/prelu.c
index 7c93337..26a2625 100644
--- a/src/subgraph/prelu.c
+++ b/src/subgraph/prelu.c
@@ -21,28 +21,29 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define PReLU operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_prelu));
return xnn_status_uninitialized;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define PReLU operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_prelu), input_id);
return xnn_status_invalid_parameter;
}
if (slope_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define PReLU operator with slope ID #%" PRIu32 ": invalid Value ID",
- slope_id);
+ "failed to define %s operator with slope ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_prelu), slope_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define PReLU operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_prelu), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/sigmoid.c b/src/subgraph/sigmoid.c
index 281a9e4..fb5a592 100644
--- a/src/subgraph/sigmoid.c
+++ b/src/subgraph/sigmoid.c
@@ -20,21 +20,22 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Sigmoid operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_sigmoid));
return xnn_status_uninitialized;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Sigmoid operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_sigmoid), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Sigmoid operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_sigmoid), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/softmax.c b/src/subgraph/softmax.c
index 3812d92..85e355d 100644
--- a/src/subgraph/softmax.c
+++ b/src/subgraph/softmax.c
@@ -20,21 +20,22 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define SoftMax operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_softmax));
return xnn_status_uninitialized;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define SoftMax operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_softmax), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define SoftMax operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_softmax), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/static-constant-pad.c b/src/subgraph/static-constant-pad.c
index 7b9e40c..9e1c365 100644
--- a/src/subgraph/static-constant-pad.c
+++ b/src/subgraph/static-constant-pad.c
@@ -26,21 +26,22 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define Constant Pad operator: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_constant_pad));
return xnn_status_uninitialized;
}
if (input_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Constant Pad operator with input ID #%" PRIu32 ": invalid Value ID",
- input_id);
+ "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_constant_pad), input_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define Constant Pad operator with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_constant_pad), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/subgraph/unpooling-2d.c b/src/subgraph/unpooling-2d.c
index 7d70ee0..74e0d1e 100644
--- a/src/subgraph/unpooling-2d.c
+++ b/src/subgraph/unpooling-2d.c
@@ -27,43 +27,45 @@
uint32_t flags)
{
if (!xnn_params.initialized) {
- xnn_log_error("failed to define UnPooling: XNNPACK is not initialized");
+ xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
+ xnn_node_type_to_string(xnn_node_type_unpooling_2d));
return xnn_status_uninitialized;
}
const uint32_t pooling_size = pooling_height * pooling_width;
if (pooling_size == 0) {
xnn_log_error(
- "failed to define UnPooling with %" PRIu32 "x%" PRIu32 " pooling size: "
+ "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
"pooling size dimensions must be non-zero",
- pooling_width, pooling_height);
+ xnn_node_type_to_string(xnn_node_type_unpooling_2d), pooling_width, pooling_height);
return xnn_status_invalid_parameter;
}
if (pooling_size == 1) {
xnn_log_error(
- "failed to define UnPooling with 1 pooling element: 1x1 pooling is meaningless");
+ "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
+ xnn_node_type_to_string(xnn_node_type_unpooling_2d));
return xnn_status_invalid_parameter;
}
if (input_value_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define UnPooling with input value ID #%" PRIu32 ": invalid Value ID",
- input_value_id);
+ "failed to define %s operator with input value ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_unpooling_2d), input_value_id);
return xnn_status_invalid_parameter;
}
if (input_index_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define UnPooling with input index ID #%" PRIu32 ": invalid Value ID",
- input_index_id);
+ "failed to define %s operator with input index ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_unpooling_2d), input_index_id);
return xnn_status_invalid_parameter;
}
if (output_id >= subgraph->num_values) {
xnn_log_error(
- "failed to define UnPooling with output ID #%" PRIu32 ": invalid Value ID",
- output_id);
+ "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
+ xnn_node_type_to_string(xnn_node_type_unpooling_2d), output_id);
return xnn_status_invalid_parameter;
}
diff --git a/src/xnnpack/log.h b/src/xnnpack/log.h
index cb2ad0d..0c1f39f 100644
--- a/src/xnnpack/log.h
+++ b/src/xnnpack/log.h
@@ -12,6 +12,9 @@
#include <clog.h>
+#include <xnnpack/operator.h>
+#include <xnnpack/subgraph.h>
+
#ifndef XNN_LOG_LEVEL
#error "Undefined XNN_LOG_LEVEL"
#endif
@@ -21,3 +24,24 @@
CLOG_DEFINE_LOG_WARNING(xnn_log_warning, "XNNPACK", XNN_LOG_LEVEL);
CLOG_DEFINE_LOG_ERROR(xnn_log_error, "XNNPACK", XNN_LOG_LEVEL);
CLOG_DEFINE_LOG_FATAL(xnn_log_fatal, "XNNPACK", XNN_LOG_LEVEL);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if XNN_LOG_LEVEL == 0
+ inline static const char* xnn_operator_type_to_string(enum xnn_operator_type type) {
+ return "Unknown";
+ }
+
+ inline static const char* xnn_node_type_to_string(enum xnn_node_type type) {
+ return "Unknown";
+ }
+#else
+ const char* xnn_operator_type_to_string(enum xnn_operator_type type);
+ const char* xnn_node_type_to_string(enum xnn_node_type type);
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
diff --git a/src/xnnpack/operator.h b/src/xnnpack/operator.h
index 1cfc3b1..cd39d62 100644
--- a/src/xnnpack/operator.h
+++ b/src/xnnpack/operator.h
@@ -45,7 +45,7 @@
};
enum xnn_operator_type {
- xnn_operator_type_none = 0,
+ xnn_operator_type_invalid = 0,
xnn_operator_type_add_nc_f32,
xnn_operator_type_add_nd_f32,
xnn_operator_type_add_nc_q8,