Rename Pad operator to Constant Pad in Operator API
PiperOrigin-RevId: 312838474
diff --git a/BUILD.bazel b/BUILD.bazel
index df27a47..f872073 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -57,6 +57,7 @@
"src/operators/channel-pad-nc.c",
"src/operators/channel-shuffle-nc.c",
"src/operators/clamp-nc.c",
+ "src/operators/constant-pad-nd.c",
"src/operators/convolution-nchw.c",
"src/operators/convolution-nhwc.c",
"src/operators/deconvolution-nhwc.c",
@@ -66,7 +67,6 @@
"src/operators/hardswish-nc.c",
"src/operators/leaky-relu-nc.c",
"src/operators/max-pooling-nhwc.c",
- "src/operators/pad-nd.c",
"src/operators/prelu-nc.c",
"src/operators/resize-bilinear-nhwc.c",
"src/operators/sigmoid-nc.c",
@@ -3592,6 +3592,15 @@
)
xnnpack_unit_test(
+ name = "constant_pad_nd_test",
+ srcs = [
+ "test/constant-pad-nd.cc",
+ "test/constant-pad-operator-tester.h",
+ ],
+ deps = OPERATOR_TEST_DEPS,
+)
+
+xnnpack_unit_test(
name = "convolution_nhwc_test",
srcs = [
"test/convolution-nhwc.cc",
@@ -3709,15 +3718,6 @@
)
xnnpack_unit_test(
- name = "pad_nd_test",
- srcs = [
- "test/pad-nd.cc",
- "test/pad-operator-tester.h",
- ],
- deps = OPERATOR_TEST_DEPS,
-)
-
-xnnpack_unit_test(
name = "prelu_nc_test",
srcs = [
"test/prelu-nc.cc",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02578b9..33a0bb6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -165,6 +165,7 @@
src/operators/channel-pad-nc.c
src/operators/channel-shuffle-nc.c
src/operators/clamp-nc.c
+ src/operators/constant-pad-nd.c
src/operators/convolution-nchw.c
src/operators/convolution-nhwc.c
src/operators/deconvolution-nhwc.c
@@ -174,7 +175,6 @@
src/operators/hardswish-nc.c
src/operators/leaky-relu-nc.c
src/operators/max-pooling-nhwc.c
- src/operators/pad-nd.c
src/operators/prelu-nc.c
src/operators/resize-bilinear-nhwc.c
src/operators/sigmoid-nc.c
@@ -1992,6 +1992,15 @@
TARGET_LINK_LIBRARIES(clamp-nc-test PRIVATE XNNPACK gtest gtest_main)
ADD_TEST(clamp-nc-test clamp-nc-test)
+ ADD_EXECUTABLE(constant-pad-nd-test test/constant-pad-nd.cc)
+ SET_TARGET_PROPERTIES(constant-pad-nd-test PROPERTIES
+ CXX_STANDARD 11
+ CXX_STANDARD_REQUIRED YES
+ CXX_EXTENSIONS NO)
+ TARGET_INCLUDE_DIRECTORIES(constant-pad-nd-test PRIVATE src test)
+ TARGET_LINK_LIBRARIES(constant-pad-nd-test PRIVATE XNNPACK gtest gtest_main)
+ ADD_TEST(constant-pad-nd-test constant-pad-nd-test)
+
ADD_EXECUTABLE(convolution-nhwc-test test/convolution-nhwc.cc)
SET_TARGET_PROPERTIES(convolution-nhwc-test PROPERTIES
CXX_STANDARD 11
@@ -2109,15 +2118,6 @@
TARGET_LINK_LIBRARIES(multiply-nd-test PRIVATE XNNPACK gtest gtest_main)
ADD_TEST(multiply-nd-test multiply-nd-test)
- ADD_EXECUTABLE(pad-nd-test test/pad-nd.cc)
- SET_TARGET_PROPERTIES(pad-nd-test PROPERTIES
- CXX_STANDARD 11
- CXX_STANDARD_REQUIRED YES
- CXX_EXTENSIONS NO)
- TARGET_INCLUDE_DIRECTORIES(pad-nd-test PRIVATE src test)
- TARGET_LINK_LIBRARIES(pad-nd-test PRIVATE XNNPACK gtest gtest_main)
- ADD_TEST(pad-nd-test pad-nd-test)
-
ADD_EXECUTABLE(prelu-nc-test test/prelu-nc.cc)
SET_TARGET_PROPERTIES(prelu-nc-test PROPERTIES
CXX_STANDARD 11
diff --git a/include/xnnpack.h b/include/xnnpack.h
index 129093d..a82d81c 100644
--- a/include/xnnpack.h
+++ b/include/xnnpack.h
@@ -1246,13 +1246,13 @@
void* output,
pthreadpool_t threadpool);
-enum xnn_status xnn_create_pad_nd_x32(
+enum xnn_status xnn_create_constant_pad_nd_x32(
const void* padding_value,
uint32_t flags,
- xnn_operator_t* pad_op_out);
+ xnn_operator_t* constant_pad_op_out);
-enum xnn_status xnn_setup_pad_nd_x32(
- xnn_operator_t pad_op,
+enum xnn_status xnn_setup_constant_pad_nd_x32(
+ xnn_operator_t constant_pad_op,
size_t num_dims,
const size_t* input_shape,
const size_t* pre_padding,
diff --git a/src/operators/constant-pad-nd.c b/src/operators/constant-pad-nd.c
new file mode 100644
index 0000000..d0e79fb
--- /dev/null
+++ b/src/operators/constant-pad-nd.c
@@ -0,0 +1,195 @@
+// 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 <assert.h>
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <xnnpack.h>
+#include <xnnpack/allocator.h>
+#include <xnnpack/log.h>
+#include <xnnpack/operator.h>
+#include <xnnpack/params-init.h>
+#include <xnnpack/params.h>
+
+
+static enum xnn_status create_constant_pad_nd(
+ uint32_t padding_value,
+ uint32_t flags,
+ enum xnn_operator_type operator_type,
+ xnn_operator_t* constant_pad_op_out)
+{
+ xnn_operator_t constant_pad_op = NULL;
+ enum xnn_status status = xnn_status_uninitialized;
+
+ if (!xnn_params.initialized) {
+ xnn_log_error("failed to create Constant Pad operator: XNNPACK is not initialized");
+ goto error;
+ }
+
+ status = xnn_status_out_of_memory;
+
+ 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));
+ goto error;
+ }
+
+ constant_pad_op->pad_value = padding_value;
+
+ constant_pad_op->type = operator_type;
+ constant_pad_op->ukernel.type = xnn_ukernel_type_pad;
+
+ constant_pad_op->state = xnn_run_state_invalid;
+
+ *constant_pad_op_out = constant_pad_op;
+ return xnn_status_success;
+
+error:
+ xnn_delete_operator(constant_pad_op);
+ return status;
+}
+
+enum xnn_status xnn_create_constant_pad_nd_x32(
+ const void* padding_value,
+ uint32_t flags,
+ xnn_operator_t* constant_pad_op_out)
+{
+ return create_constant_pad_nd(
+ *((uint32_t*) padding_value), flags, xnn_operator_type_constant_pad_nd_x32, constant_pad_op_out);
+}
+
+static enum xnn_status setup_constant_pad_nd(
+ xnn_operator_t constant_pad_op,
+ enum xnn_operator_type expected_operator_type,
+ size_t num_dims,
+ const size_t* input_shape,
+ const size_t* pre_paddings,
+ const size_t* post_paddings,
+ const void* input,
+ void* output,
+ 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");
+ 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");
+ 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: "
+ "the number of input dimensions must not exceed %d",
+ 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);
+ return xnn_status_invalid_parameter;
+ }
+ }
+
+ size_t num_squeezed_dims = 0;
+ size_t normalized_pre_paddings[XNN_MAX_TENSOR_DIMS];
+ size_t normalized_input_shape[XNN_MAX_TENSOR_DIMS];
+ size_t normalized_output_shape[XNN_MAX_TENSOR_DIMS];
+ for (size_t i = 0; i < XNN_MAX_TENSOR_DIMS; i++) {
+ normalized_pre_paddings[i] = 0;
+ normalized_input_shape[i] = 1;
+ normalized_output_shape[i] = 1;
+ }
+
+ bool is_previous_dim_padded = true;
+ for (size_t i = 0; i < num_dims; i++) {
+ const size_t pre_padding = pre_paddings[num_dims - 1 - i];
+ const size_t post_padding = post_paddings[num_dims - 1 - i];
+ const size_t input_dim = input_shape[num_dims - 1 - i];
+
+ const bool is_current_dim_padded = (pre_padding | post_padding) != 0;
+ if (is_current_dim_padded || is_previous_dim_padded) {
+ normalized_pre_paddings[XNN_MAX_TENSOR_DIMS - 1 - num_squeezed_dims] = pre_padding;
+ normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1 - num_squeezed_dims] = input_dim;
+ normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1 - num_squeezed_dims] = pre_padding + input_dim + post_padding;
+
+ num_squeezed_dims += 1;
+ is_previous_dim_padded = is_current_dim_padded;
+ } else {
+ assert(!is_previous_dim_padded);
+ assert(pre_padding == 0);
+ assert(post_padding == 0);
+ assert(i != 0);
+
+ normalized_input_shape[XNN_MAX_TENSOR_DIMS - num_squeezed_dims] *= input_dim;
+ normalized_output_shape[XNN_MAX_TENSOR_DIMS - num_squeezed_dims] *= input_dim;
+ }
+ }
+
+ constant_pad_op->context.pad = (struct pad_context) {
+ .input = input,
+ .output = output,
+ .padding_value = constant_pad_op->pad_value,
+ .fill_ukernel = xnn_params.x32.fill.ukernel,
+ .pad_ukernel = xnn_params.x32.pad.ukernel,
+ };
+
+ for (size_t i = 0; i < XNN_MAX_TENSOR_DIMS; i++) {
+ constant_pad_op->context.pad.pre_paddings[i] = normalized_pre_paddings[XNN_MAX_TENSOR_DIMS - 1 - i];
+ constant_pad_op->context.pad.input_size[i] = normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1 - i];
+ }
+ size_t input_stride = normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1];
+ size_t output_stride = normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1];
+ for (size_t i = 1; i < XNN_MAX_TENSOR_DIMS; i++) {
+ constant_pad_op->context.pad.input = (const void*)
+ ((uintptr_t) constant_pad_op->context.pad.input - constant_pad_op->context.pad.pre_paddings[i] * input_stride * sizeof(float));
+ constant_pad_op->context.pad.input_stride[i - 1] = input_stride * sizeof(float);
+ constant_pad_op->context.pad.output_stride[i - 1] = output_stride * sizeof(float);
+ input_stride *= normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1 - i];
+ output_stride *= normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1 - i];
+ }
+ constant_pad_op->context.pad.input_size[0] *= sizeof(float);
+ constant_pad_op->context.pad.output_size[0] = normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1] * sizeof(float);
+ constant_pad_op->context.pad.pre_paddings[0] *= sizeof(float);
+ constant_pad_op->context.pad.post_paddings[0] =
+ constant_pad_op->context.pad.output_size[0] - constant_pad_op->context.pad.pre_paddings[0] - constant_pad_op->context.pad.input_size[0];
+
+ constant_pad_op->compute.type = xnn_parallelization_type_5d_tile_2d;
+ constant_pad_op->compute.task_5d_tile_2d = (pthreadpool_task_5d_tile_2d_t) xnn_compute_pad_5d;
+ constant_pad_op->compute.range[0] = normalized_output_shape[0];
+ constant_pad_op->compute.range[1] = normalized_output_shape[1];
+ constant_pad_op->compute.range[2] = normalized_output_shape[2];
+ constant_pad_op->compute.range[3] = normalized_output_shape[3];
+ constant_pad_op->compute.range[4] = normalized_output_shape[4];
+ constant_pad_op->compute.tile[0] = 1;
+ constant_pad_op->compute.tile[1] = 1;
+ constant_pad_op->state = xnn_run_state_ready;
+
+ return xnn_status_success;
+}
+
+enum xnn_status xnn_setup_constant_pad_nd_x32(
+ xnn_operator_t constant_pad_op,
+ size_t num_dims,
+ const size_t* input_shape,
+ const size_t* pre_padding,
+ const size_t* post_padding,
+ const void* input,
+ void* output,
+ pthreadpool_t threadpool)
+{
+ return setup_constant_pad_nd(
+ constant_pad_op, xnn_operator_type_constant_pad_nd_x32,
+ num_dims, input_shape, pre_padding, post_padding,
+ input, output,
+ pthreadpool_get_threads_count(threadpool));
+}
diff --git a/src/operators/pad-nd.c b/src/operators/pad-nd.c
deleted file mode 100644
index 7762d45..0000000
--- a/src/operators/pad-nd.c
+++ /dev/null
@@ -1,195 +0,0 @@
-// 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 <assert.h>
-#include <math.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <xnnpack.h>
-#include <xnnpack/allocator.h>
-#include <xnnpack/log.h>
-#include <xnnpack/operator.h>
-#include <xnnpack/params-init.h>
-#include <xnnpack/params.h>
-
-
-static enum xnn_status create_pad_nd(
- uint32_t padding_value,
- uint32_t flags,
- enum xnn_operator_type operator_type,
- xnn_operator_t* pad_op_out)
-{
- xnn_operator_t pad_op = NULL;
- enum xnn_status status = xnn_status_uninitialized;
-
- if (!xnn_params.initialized) {
- xnn_log_error("failed to create Pad operator: XNNPACK is not initialized");
- goto error;
- }
-
- status = xnn_status_out_of_memory;
-
- pad_op = xnn_allocate_zero_simd_memory(sizeof(struct xnn_operator));
- if (pad_op == NULL) {
- xnn_log_error("failed to allocate %zu bytes for Pad operator descriptor", sizeof(struct xnn_operator));
- goto error;
- }
-
- pad_op->pad_value = padding_value;
-
- pad_op->type = operator_type;
- pad_op->ukernel.type = xnn_ukernel_type_pad;
-
- pad_op->state = xnn_run_state_invalid;
-
- *pad_op_out = pad_op;
- return xnn_status_success;
-
-error:
- xnn_delete_operator(pad_op);
- return status;
-}
-
-enum xnn_status xnn_create_pad_nd_x32(
- const void* padding_value,
- uint32_t flags,
- xnn_operator_t* pad_op_out)
-{
- return create_pad_nd(
- *((uint32_t*) padding_value), flags, xnn_operator_type_pad_nd_x32, pad_op_out);
-}
-
-static enum xnn_status setup_pad_nd(
- xnn_operator_t pad_op,
- enum xnn_operator_type expected_operator_type,
- size_t num_dims,
- const size_t* input_shape,
- const size_t* pre_paddings,
- const size_t* post_paddings,
- const void* input,
- void* output,
- size_t num_threads)
-{
- if (pad_op->type != expected_operator_type) {
- xnn_log_error("failed to setup Pad (ND, X32) operator: operator type mismatch");
- return xnn_status_invalid_parameter;
- }
- pad_op->state = xnn_run_state_invalid;
-
- if (!xnn_params.initialized) {
- xnn_log_error("failed to setup Pad operator: XNNPACK is not initialized");
- return xnn_status_uninitialized;
- }
-
- if (num_dims > XNN_MAX_TENSOR_DIMS) {
- xnn_log_error(
- "failed to setup Pad operator with %zu dimensions in input shape: "
- "the number of input dimensions must not exceed %d",
- 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 Pad operator: input shape dimension #%zu is zero", i);
- return xnn_status_invalid_parameter;
- }
- }
-
- size_t num_squeezed_dims = 0;
- size_t normalized_pre_paddings[XNN_MAX_TENSOR_DIMS];
- size_t normalized_input_shape[XNN_MAX_TENSOR_DIMS];
- size_t normalized_output_shape[XNN_MAX_TENSOR_DIMS];
- for (size_t i = 0; i < XNN_MAX_TENSOR_DIMS; i++) {
- normalized_pre_paddings[i] = 0;
- normalized_input_shape[i] = 1;
- normalized_output_shape[i] = 1;
- }
-
- bool is_previous_dim_padded = true;
- for (size_t i = 0; i < num_dims; i++) {
- const size_t pre_padding = pre_paddings[num_dims - 1 - i];
- const size_t post_padding = post_paddings[num_dims - 1 - i];
- const size_t input_dim = input_shape[num_dims - 1 - i];
-
- const bool is_current_dim_padded = (pre_padding | post_padding) != 0;
- if (is_current_dim_padded || is_previous_dim_padded) {
- normalized_pre_paddings[XNN_MAX_TENSOR_DIMS - 1 - num_squeezed_dims] = pre_padding;
- normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1 - num_squeezed_dims] = input_dim;
- normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1 - num_squeezed_dims] = pre_padding + input_dim + post_padding;
-
- num_squeezed_dims += 1;
- is_previous_dim_padded = is_current_dim_padded;
- } else {
- assert(!is_previous_dim_padded);
- assert(pre_padding == 0);
- assert(post_padding == 0);
- assert(i != 0);
-
- normalized_input_shape[XNN_MAX_TENSOR_DIMS - num_squeezed_dims] *= input_dim;
- normalized_output_shape[XNN_MAX_TENSOR_DIMS - num_squeezed_dims] *= input_dim;
- }
- }
-
- pad_op->context.pad = (struct pad_context) {
- .input = input,
- .output = output,
- .padding_value = pad_op->pad_value,
- .fill_ukernel = xnn_params.x32.fill.ukernel,
- .pad_ukernel = xnn_params.x32.pad.ukernel,
- };
-
- for (size_t i = 0; i < XNN_MAX_TENSOR_DIMS; i++) {
- pad_op->context.pad.pre_paddings[i] = normalized_pre_paddings[XNN_MAX_TENSOR_DIMS - 1 - i];
- pad_op->context.pad.input_size[i] = normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1 - i];
- }
- size_t input_stride = normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1];
- size_t output_stride = normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1];
- for (size_t i = 1; i < XNN_MAX_TENSOR_DIMS; i++) {
- pad_op->context.pad.input = (const void*)
- ((uintptr_t) pad_op->context.pad.input - pad_op->context.pad.pre_paddings[i] * input_stride * sizeof(float));
- pad_op->context.pad.input_stride[i - 1] = input_stride * sizeof(float);
- pad_op->context.pad.output_stride[i - 1] = output_stride * sizeof(float);
- input_stride *= normalized_input_shape[XNN_MAX_TENSOR_DIMS - 1 - i];
- output_stride *= normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1 - i];
- }
- pad_op->context.pad.input_size[0] *= sizeof(float);
- pad_op->context.pad.output_size[0] = normalized_output_shape[XNN_MAX_TENSOR_DIMS - 1] * sizeof(float);
- pad_op->context.pad.pre_paddings[0] *= sizeof(float);
- pad_op->context.pad.post_paddings[0] =
- pad_op->context.pad.output_size[0] - pad_op->context.pad.pre_paddings[0] - pad_op->context.pad.input_size[0];
-
- pad_op->compute.type = xnn_parallelization_type_5d_tile_2d;
- pad_op->compute.task_5d_tile_2d = (pthreadpool_task_5d_tile_2d_t) xnn_compute_pad_5d;
- pad_op->compute.range[0] = normalized_output_shape[0];
- pad_op->compute.range[1] = normalized_output_shape[1];
- pad_op->compute.range[2] = normalized_output_shape[2];
- pad_op->compute.range[3] = normalized_output_shape[3];
- pad_op->compute.range[4] = normalized_output_shape[4];
- pad_op->compute.tile[0] = 1;
- pad_op->compute.tile[1] = 1;
- pad_op->state = xnn_run_state_ready;
-
- return xnn_status_success;
-}
-
-enum xnn_status xnn_setup_pad_nd_x32(
- xnn_operator_t pad_op,
- size_t num_dims,
- const size_t* input_shape,
- const size_t* pre_padding,
- const size_t* post_padding,
- const void* input,
- void* output,
- pthreadpool_t threadpool)
-{
- return setup_pad_nd(
- pad_op, xnn_operator_type_pad_nd_x32,
- num_dims, input_shape, pre_padding, post_padding,
- input, output,
- pthreadpool_get_threads_count(threadpool));
-}
diff --git a/src/runtime.c b/src/runtime.c
index 8d58740..a4d10c7 100644
--- a/src/runtime.c
+++ b/src/runtime.c
@@ -151,7 +151,7 @@
runtime->opdata[i].outputs[0] = node->outputs[0];
break;
case xnn_node_type_constant_pad:
- status = xnn_create_pad_nd_x32(
+ status = xnn_create_constant_pad_nd_x32(
&node->params.static_pad.padding_value,
node->flags,
&runtime->opdata[i].operator_object);
@@ -568,6 +568,19 @@
runtime->blobs[opdata->outputs[0]].data,
runtime->threadpool);
break;
+ case xnn_operator_type_constant_pad_nd_x32:
+ assert(runtime->blobs[opdata->inputs[0]].data != NULL);
+ assert(runtime->blobs[opdata->outputs[0]].data != NULL);
+ status = xnn_setup_constant_pad_nd_x32(
+ opdata->operator_object,
+ opdata->shape1.num_dims,
+ opdata->shape1.dim,
+ opdata->pre_paddings,
+ opdata->post_paddings,
+ runtime->blobs[opdata->inputs[0]].data,
+ runtime->blobs[opdata->outputs[0]].data,
+ runtime->threadpool);
+ break;
case xnn_operator_type_convolution_nhwc_f32:
assert(runtime->blobs[opdata->inputs[0]].data != NULL);
assert(runtime->blobs[opdata->outputs[0]].data != NULL);
@@ -651,19 +664,6 @@
runtime->blobs[opdata->outputs[0]].data,
runtime->threadpool);
break;
- case xnn_operator_type_pad_nd_x32:
- assert(runtime->blobs[opdata->inputs[0]].data != NULL);
- assert(runtime->blobs[opdata->outputs[0]].data != NULL);
- status = xnn_setup_pad_nd_x32(
- opdata->operator_object,
- opdata->shape1.num_dims,
- opdata->shape1.dim,
- opdata->pre_paddings,
- opdata->post_paddings,
- runtime->blobs[opdata->inputs[0]].data,
- runtime->blobs[opdata->outputs[0]].data,
- runtime->threadpool);
- break;
case xnn_operator_type_prelu_nc_f32:
assert(runtime->blobs[opdata->inputs[0]].data != NULL);
assert(runtime->blobs[opdata->outputs[0]].data != NULL);
diff --git a/src/xnnpack/operator.h b/src/xnnpack/operator.h
index e32a4b6..1cfc3b1 100644
--- a/src/xnnpack/operator.h
+++ b/src/xnnpack/operator.h
@@ -57,6 +57,7 @@
xnn_operator_type_channel_shuffle_nc_x8,
xnn_operator_type_clamp_nc_f32,
xnn_operator_type_clamp_nc_u8,
+ xnn_operator_type_constant_pad_nd_x32,
xnn_operator_type_convolution_nhwc_f32,
xnn_operator_type_convolution_nhwc_q8,
xnn_operator_type_convolution_nchw_f32,
@@ -75,7 +76,6 @@
xnn_operator_type_maximum_nd_f32,
xnn_operator_type_minimum_nd_f32,
xnn_operator_type_multiply_nd_f32,
- xnn_operator_type_pad_nd_x32,
xnn_operator_type_prelu_nc_f32,
xnn_operator_type_resize_bilinear_nhwc_f32,
xnn_operator_type_sigmoid_nc_f32,
diff --git a/test/pad-nd.cc b/test/constant-pad-nd.cc
similarity index 92%
rename from test/pad-nd.cc
rename to test/constant-pad-nd.cc
index 034327a..c4e12b3 100644
--- a/test/pad-nd.cc
+++ b/test/constant-pad-nd.cc
@@ -5,7 +5,7 @@
#include <gtest/gtest.h>
-#include "pad-operator-tester.h"
+#include "constant-pad-operator-tester.h"
constexpr size_t kDim1 = 2;
constexpr size_t kDim2 = 3;
@@ -27,15 +27,15 @@
constexpr size_t kDim6PostPad = kDim6 / 2 + 1;
-TEST(PAD_ND_X32, 0d) {
- PadOperatorTester()
+TEST(CONSTANT_PAD_ND_X32, 0d) {
+ ConstantPadOperatorTester()
.TestX32();
}
-TEST(PAD_ND_X32, 1d) {
+TEST(CONSTANT_PAD_ND_X32, 1d) {
for (size_t dim1_pre_pad = 0; dim1_pre_pad <= kDim1PrePad; dim1_pre_pad += kDim1PrePad) {
for (size_t dim1_post_pad = 0; dim1_post_pad <= kDim1PostPad; dim1_post_pad += kDim1PostPad) {
- PadOperatorTester()
+ ConstantPadOperatorTester()
.input_shape({kDim1})
.pre_paddings({dim1_pre_pad})
.post_paddings({dim1_post_pad})
@@ -44,12 +44,12 @@
}
}
-TEST(PAD_ND_X32, 2d) {
+TEST(CONSTANT_PAD_ND_X32, 2d) {
for (size_t dim1_pre_pad = 0; dim1_pre_pad <= kDim1PrePad; dim1_pre_pad += kDim1PrePad) {
for (size_t dim1_post_pad = 0; dim1_post_pad <= kDim1PostPad; dim1_post_pad += kDim1PostPad) {
for (size_t dim2_pre_pad = 0; dim2_pre_pad <= kDim2PrePad; dim2_pre_pad += kDim2PrePad) {
for (size_t dim2_post_pad = 0; dim2_post_pad <= kDim2PostPad; dim2_post_pad += kDim2PostPad) {
- PadOperatorTester()
+ ConstantPadOperatorTester()
.input_shape({kDim1, kDim2})
.pre_paddings({dim1_pre_pad, dim2_pre_pad})
.post_paddings({dim1_post_pad, dim2_post_pad})
@@ -60,14 +60,14 @@
}
}
-TEST(PAD_ND_X32, 3d) {
+TEST(CONSTANT_PAD_ND_X32, 3d) {
for (size_t dim1_pre_pad = 0; dim1_pre_pad <= kDim1PrePad; dim1_pre_pad += kDim1PrePad) {
for (size_t dim1_post_pad = 0; dim1_post_pad <= kDim1PostPad; dim1_post_pad += kDim1PostPad) {
for (size_t dim2_pre_pad = 0; dim2_pre_pad <= kDim2PrePad; dim2_pre_pad += kDim2PrePad) {
for (size_t dim2_post_pad = 0; dim2_post_pad <= kDim2PostPad; dim2_post_pad += kDim2PostPad) {
for (size_t dim3_pre_pad = 0; dim3_pre_pad <= kDim3PrePad; dim3_pre_pad += kDim3PrePad) {
for (size_t dim3_post_pad = 0; dim3_post_pad <= kDim3PostPad; dim3_post_pad += kDim3PostPad) {
- PadOperatorTester()
+ ConstantPadOperatorTester()
.input_shape({kDim1, kDim2, kDim3})
.pre_paddings({dim1_pre_pad, dim2_pre_pad, dim3_pre_pad})
.post_paddings({dim1_post_pad, dim2_post_pad, dim3_post_pad})
@@ -80,7 +80,7 @@
}
}
-TEST(PAD_ND_X32, 4d) {
+TEST(CONSTANT_PAD_ND_X32, 4d) {
for (size_t dim1_pre_pad = 0; dim1_pre_pad <= kDim1PrePad; dim1_pre_pad += kDim1PrePad) {
for (size_t dim1_post_pad = 0; dim1_post_pad <= kDim1PostPad; dim1_post_pad += kDim1PostPad) {
for (size_t dim2_pre_pad = 0; dim2_pre_pad <= kDim2PrePad; dim2_pre_pad += kDim2PrePad) {
@@ -89,7 +89,7 @@
for (size_t dim3_post_pad = 0; dim3_post_pad <= kDim3PostPad; dim3_post_pad += kDim3PostPad) {
for (size_t dim4_pre_pad = 0; dim4_pre_pad <= kDim4PrePad; dim4_pre_pad += kDim4PrePad) {
for (size_t dim4_post_pad = 0; dim4_post_pad <= kDim4PostPad; dim4_post_pad += kDim4PostPad) {
- PadOperatorTester()
+ ConstantPadOperatorTester()
.input_shape({kDim1, kDim2, kDim3, kDim4})
.pre_paddings({dim1_pre_pad, dim2_pre_pad, dim3_pre_pad, dim4_pre_pad})
.post_paddings({dim1_post_pad, dim2_post_pad, dim3_post_pad, dim4_post_pad})
@@ -104,7 +104,7 @@
}
}
-TEST(PAD_ND_X32, 5d) {
+TEST(CONSTANT_PAD_ND_X32, 5d) {
for (size_t dim1_pre_pad = 0; dim1_pre_pad <= kDim1PrePad; dim1_pre_pad += kDim1PrePad) {
for (size_t dim1_post_pad = 0; dim1_post_pad <= kDim1PostPad; dim1_post_pad += kDim1PostPad) {
for (size_t dim2_pre_pad = 0; dim2_pre_pad <= kDim2PrePad; dim2_pre_pad += kDim2PrePad) {
@@ -115,7 +115,7 @@
for (size_t dim4_post_pad = 0; dim4_post_pad <= kDim4PostPad; dim4_post_pad += kDim4PostPad) {
for (size_t dim5_pre_pad = 0; dim5_pre_pad <= kDim5PrePad; dim5_pre_pad += kDim5PrePad) {
for (size_t dim5_post_pad = 0; dim5_post_pad <= kDim5PostPad; dim5_post_pad += kDim5PostPad) {
- PadOperatorTester()
+ ConstantPadOperatorTester()
.input_shape({kDim1, kDim2, kDim3, kDim4, kDim5})
.pre_paddings({dim1_pre_pad, dim2_pre_pad, dim3_pre_pad, dim4_pre_pad, dim5_pre_pad})
.post_paddings({dim1_post_pad, dim2_post_pad, dim3_post_pad, dim4_post_pad, dim5_post_pad})
@@ -132,7 +132,7 @@
}
}
-TEST(PAD_ND_X32, 6d) {
+TEST(CONSTANT_PAD_ND_X32, 6d) {
for (size_t dim1_pre_pad = 0; dim1_pre_pad <= kDim1PrePad; dim1_pre_pad += kDim1PrePad) {
for (size_t dim1_post_pad = 0; dim1_post_pad <= kDim1PostPad; dim1_post_pad += kDim1PostPad) {
for (size_t dim2_pre_pad = 0; dim2_pre_pad <= kDim2PrePad; dim2_pre_pad += kDim2PrePad) {
@@ -145,7 +145,7 @@
for (size_t dim5_post_pad = 0; dim5_post_pad <= kDim5PostPad; dim5_post_pad += kDim5PostPad) {
for (size_t dim6_pre_pad = 0; dim6_pre_pad <= kDim6PrePad; dim6_pre_pad += kDim6PrePad) {
for (size_t dim6_post_pad = 0; dim6_post_pad <= kDim6PostPad; dim6_post_pad += kDim6PostPad) {
- PadOperatorTester()
+ ConstantPadOperatorTester()
.input_shape({kDim1, kDim2, kDim3, kDim4, kDim5, kDim6})
.pre_paddings({dim1_pre_pad, dim2_pre_pad, dim3_pre_pad, dim4_pre_pad, dim5_pre_pad, dim6_pre_pad})
.post_paddings({dim1_post_pad, dim2_post_pad, dim3_post_pad, dim4_post_pad, dim5_post_pad, dim6_post_pad})
diff --git a/test/pad-operator-tester.h b/test/constant-pad-operator-tester.h
similarity index 94%
rename from test/pad-operator-tester.h
rename to test/constant-pad-operator-tester.h
index dbe2754..b3e6d04 100644
--- a/test/pad-operator-tester.h
+++ b/test/constant-pad-operator-tester.h
@@ -20,9 +20,9 @@
#include <xnnpack.h>
-class PadOperatorTester {
+class ConstantPadOperatorTester {
public:
- inline PadOperatorTester& input_shape(std::initializer_list<size_t> input_shape) {
+ inline ConstantPadOperatorTester& input_shape(std::initializer_list<size_t> input_shape) {
assert(input_shape.size() <= XNN_MAX_TENSOR_DIMS);
input_shape_ = std::vector<size_t>(input_shape);
return *this;
@@ -45,7 +45,7 @@
input_shape_.cbegin(), input_shape_.cend(), size_t(1), std::multiplies<size_t>());
}
- inline PadOperatorTester& pre_paddings(std::initializer_list<size_t> pre_paddings) {
+ inline ConstantPadOperatorTester& pre_paddings(std::initializer_list<size_t> pre_paddings) {
assert(pre_paddings.size() <= XNN_MAX_TENSOR_DIMS);
pre_paddings_ = std::vector<size_t>(pre_paddings);
return *this;
@@ -63,7 +63,7 @@
return pre_paddings_.size();
}
- inline PadOperatorTester& post_paddings(std::initializer_list<size_t> post_paddings) {
+ inline ConstantPadOperatorTester& post_paddings(std::initializer_list<size_t> post_paddings) {
assert(post_paddings.size() <= XNN_MAX_TENSOR_DIMS);
post_paddings_ = std::vector<size_t>(post_paddings);
return *this;
@@ -93,7 +93,7 @@
return elements;
}
- inline PadOperatorTester& iterations(size_t iterations) {
+ inline ConstantPadOperatorTester& iterations(size_t iterations) {
this->iterations_ = iterations;
return *this;
}
@@ -176,7 +176,7 @@
xnn_operator_t pad_op = nullptr;
ASSERT_EQ(xnn_status_success,
- xnn_create_pad_nd_x32(
+ xnn_create_constant_pad_nd_x32(
&padding_value, 0, &pad_op));
ASSERT_NE(nullptr, pad_op);
@@ -184,7 +184,7 @@
std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_pad_op(pad_op, xnn_delete_operator);
ASSERT_EQ(xnn_status_success,
- xnn_setup_pad_nd_x32(
+ xnn_setup_constant_pad_nd_x32(
pad_op,
num_dims(),
input_shape().data(), pre_paddings().data(), post_paddings().data(),