Skip to content

Commit

Permalink
Fixing review comments in PR 7567
Browse files Browse the repository at this point in the history
  • Loading branch information
@dijopaul
dijopaul committed Jan 23, 2025
1 parent 4923b83 commit 224aaf4
Show file tree
Hide file tree
Showing 4 changed files with 18 additions and 177 deletions.
3 changes: 2 additions & 1 deletion backends/cadence/hifi/operators/op_atan2.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,11 +6,12 @@
* LICENSE file in the root directory of this source tree.
*/

#include <cmath>
#include <executorch/backends/cadence/hifi/kernels/kernels.h>
#include <executorch/kernels/portable/cpu/util/broadcast_util.h>
#include <executorch/kernels/portable/cpu/util/elementwise_util.h>
#include <executorch/runtime/kernel/kernel_includes.h>
#include <cmath>


using executorch::aten::ScalarType;
using executorch::aten::Tensor;
Expand Down
131 changes: 0 additions & 131 deletions backends/cadence/hifi/operators/op_clamp.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,137 +48,6 @@ namespace impl {
namespace HiFi {
namespace native {

namespace {

template <typename CTYPE_VAL, typename CTYPE_OUT, typename CTYPE_CAST>
/** Check if val, when cast to CTYPE_CAST, is not in the range of CTYPE_OUT */
bool is_out_of_bounds(CTYPE_VAL val) {
const CTYPE_CAST val_cast = static_cast<CTYPE_CAST>(val);
return val_cast < std::numeric_limits<CTYPE_OUT>::lowest() ||
val_cast > std::numeric_limits<CTYPE_OUT>::max();
}

ET_NODISCARD bool check_bounds(
const Scalar& val_scalar,
const ScalarType& val_type,
const ScalarType& out_type,
const char* val_name) {
auto is_valid = true;

ET_SWITCH_SCALAR_OBJ_TYPES(val_type, ctx, "clamp.out", CTYPE_VAL, [&]() {
CTYPE_VAL val = 0;
extract_scalar(val_scalar, &val);
if (isIntegralType(out_type, /*includeBool=*/false)) {
ET_SWITCH_INT_TYPES(out_type, ctx, "clamp.out", CTYPE_OUT, [&]() {
if (is_out_of_bounds<CTYPE_VAL, CTYPE_OUT, long>(val)) {
ET_LOG(Error, "%s value out of bounds", val_name);
is_valid = false;
}
});
} else if (isFloatingType(out_type)) {
ET_SWITCH_FLOATH_TYPES(out_type, ctx, "clamp", CTYPE_OUT, [&]() {
if (std::isfinite(val) &&
is_out_of_bounds<CTYPE_VAL, CTYPE_OUT, double>(val)) {
ET_LOG(Error, "%s value out of bounds", val_name);
is_valid = false;
}
});
}
});

return is_valid;
}

} // namespace

Tensor& clamp_out(
KernelRuntimeContext& ctx,
const Tensor& in,
const exec_aten::optional<Scalar>& min_opt,
const exec_aten::optional<Scalar>& max_opt,
Tensor& out) {
bool has_min = min_opt.has_value();
bool has_max = max_opt.has_value();

ET_KERNEL_CHECK_MSG(
ctx,
has_min || has_max,
InvalidArgument,
out,
"At least one of 'min' or 'max' must not be None");

// Input Dtypes
ScalarType in_type = in.scalar_type();
ScalarType min_type = has_min ? get_scalar_dtype(min_opt.value()) : in_type;
ScalarType max_type = has_max ? get_scalar_dtype(max_opt.value()) : in_type;
ScalarType out_type = out.scalar_type();

// Common Dtype
ScalarType common_type = in_type;
if (has_min) {
common_type = promote_type_with_scalar(common_type, min_opt.value());
}
if (has_max) {
common_type = promote_type_with_scalar(common_type, max_opt.value());
}

// Check Common Dtype
ET_KERNEL_CHECK(ctx, common_type == out_type, InvalidArgument, out);

// Check Scalar Bounds
if (has_min) {
ET_KERNEL_CHECK(
ctx,
check_bounds(min_opt.value(), min_type, out_type, "minimum"),
InvalidArgument,
out);
}
if (has_max) {
ET_KERNEL_CHECK(
ctx,
check_bounds(max_opt.value(), max_type, out_type, "maximum"),
InvalidArgument,
out);
}

// Check Dim Order
ET_KERNEL_CHECK(
ctx, tensors_have_same_dim_order(in, out), InvalidArgument, out);

// Resize
ET_KERNEL_CHECK(
ctx, resize_tensor(out, in.sizes()) == Error::Ok, InvalidArgument, out);

// Compute Dtype
ScalarType compute_type = get_compute_type(common_type);

// @lint-ignore CLANGTIDY facebook-hte-CArray
static constexpr const char op_name[] = "clamp.out";

ET_SWITCH_REALB_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
[has_min, min_opt, has_max, max_opt](const CTYPE_COMPUTE val_in) {
CTYPE_COMPUTE val_out = val_in;
if (has_min) {
val_out = max_override(
val_out, scalar_to<CTYPE_COMPUTE>(min_opt.value()));
}
if (has_max) {
val_out = min_override(
val_out, scalar_to<CTYPE_COMPUTE>(max_opt.value()));
}
return val_out;
},
ctx,
in,
SupportedTensorDtypes::REALHBBF16,
out,
SupportedTensorDtypes::SAME_AS_COMMON);
});

return out;
}

Tensor& clamp_tensor_out(
RuntimeContext& ctx,
const Tensor& in,
Expand Down
52 changes: 13 additions & 39 deletions backends/cadence/hifi/operators/op_permute_copy.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -85,22 +85,22 @@ Tensor& permute_copy_out(
optimized = false;

if (optimized) {
if (in_type == ScalarType::Float) {
WORD32* p_inp = (WORD32*)in.const_data_ptr<float>();
WORD32* p_out = (WORD32*)out.mutable_data_ptr<float>();
WORD32 num_inp_dims = in.dim();
WORD32 num_out_dims = num_inp_dims;

WORD32 num_inp_dims = in.dim();
WORD32 num_out_dims = num_inp_dims;
WORD32 p_inp_shape[kNnlibMaxDim];
WORD32 p_out_shape[kNnlibMaxDim];
WORD32 p_permute_vec[kNnlibMaxDim];

WORD32 p_inp_shape[kNnlibMaxDim];
WORD32 p_out_shape[kNnlibMaxDim];
WORD32 p_permute_vec[kNnlibMaxDim];
for (int i = 0; i < num_inp_dims; i++) {
p_inp_shape[i] = in.size(i);
p_out_shape[i] = in.size(dims[i]);
p_permute_vec[i] = dims[i];
}

for (int i = 0; i < num_inp_dims; i++) {
p_inp_shape[i] = in.size(i);
p_out_shape[i] = in.size(dims[i]);
p_permute_vec[i] = dims[i];
}
if (in_type == ScalarType::Float) {
WORD32* p_inp = (WORD32*)in.const_data_ptr<float>();
WORD32* p_out = (WORD32*)out.mutable_data_ptr<float>();

WORD32 ret_val = xa_nn_transpose_32_32(
p_out,
Expand All @@ -117,19 +117,6 @@ Tensor& permute_copy_out(
WORD8* p_inp = (WORD8*)in.const_data_ptr<char>();
WORD8* p_out = (WORD8*)out.mutable_data_ptr<char>();

WORD32 num_inp_dims = in.dim();
WORD32 num_out_dims = num_inp_dims;

WORD32 p_inp_shape[kNnlibMaxDim];
WORD32 p_out_shape[kNnlibMaxDim];
WORD32 p_permute_vec[kNnlibMaxDim];

for (int i = 0; i < num_inp_dims; i++) {
p_inp_shape[i] = in.size(i);
p_out_shape[i] = in.size(dims[i]);
p_permute_vec[i] = dims[i];
}

WORD32 val = xa_nn_transpose_8_8(
p_out,
p_out_shape,
Expand All @@ -145,19 +132,6 @@ Tensor& permute_copy_out(
WORD8* p_inp = (WORD8*)in.const_data_ptr<uint8_t>();
WORD8* p_out = (WORD8*)out.mutable_data_ptr<uint8_t>();

WORD32 num_inp_dims = in.dim();
WORD32 num_out_dims = num_inp_dims;

WORD32 p_inp_shape[kNnlibMaxDim];
WORD32 p_out_shape[kNnlibMaxDim];
WORD32 p_permute_vec[kNnlibMaxDim];

for (int i = 0; i < num_inp_dims; i++) {
p_inp_shape[i] = in.size(i);
p_out_shape[i] = in.size(dims[i]);
p_permute_vec[i] = dims[i];
}

WORD32 val = xa_nn_transpose_8_8(
p_out,
p_out_shape,
Expand Down
9 changes: 3 additions & 6 deletions backends/cadence/hifi/third-party/nnlib/xa_nn_elm_minimum_maximum_f32.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,12 +19,9 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
******************************************************************************/
#include "nnlib-hifi4/xa_nnlib/include/xa_type_def.h"
#include "nnlib-hifi4/xa_nnlib/algo/common/include/xa_nnlib_common_fpu.h"
#include "nnlib-hifi4/xa_nnlib/algo/common/include/xa_nn_common.h"
#include "nnlib-hifi4/xa_nnlib/algo/common/include/xa_nnlib_err_chk.h"
#include "nnlib-hifi4/xa_nnlib/algo/kernels/basic/hifi4/xa_nn_basic_state.h"
#include "nnlib-hifi4/xa_nnlib/include/nnlib/xa_nnlib_kernels_api.h"
#include "xa_type_def.h"
#include "xa_nnlib_common_fpu.h"
#include "xa_nnlib_err_chk.h"

#if !HAVE_VFPU
DISCARD_FUN_FOR_NONVOID_RETURN(
Expand Down

0 comments on commit 224aaf4

Please sign in to comment.