Skip to content

N
ngraph
Commit 6ffbd254 authored by Adam Procter's avatar Adam Procter Committed by Robert Kimball
Browse files
Options

New macros for faster node validation checks (#2537) 

* Skeleton for faster validation asserts

* Switch to __VA_ARGS__ for compatibility, remove -Wno-variadic-macros

* Add benchmarks for constructing Add and Convolution

* Quick hack to avoid shadowing inside the CHECK macro

* Quick hack to avoid inadvertent capture inside the macro

* Update convolution, and change a bunch of tests to anticipate the new error class
parent eb34c884
Hide whitespace changes
Inline Side-by-side
Showing with 535 additions and 265 deletions
src/ngraph/check.hpp 0 → 100644
View file @ 6ffbd254
//*****************************************************************************
// Copyright 2017-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************
#pragma once
#include <exception>
#include <sstream>
#include <vector>
#include "ngraph/except.hpp"
namespace ngraph
{
static inline std::ostream& write_all_to_stream(std::ostream& str) { return str; }
template <typename T, typename... TS>
static inline std::ostream& write_all_to_stream(std::ostream& str, const T& arg, TS... args)
{
return write_all_to_stream(str << arg, args...);
}
struct CheckLocInfo
{
const char* file;
int line;
const char* check_string;
};
/// Base class for check failure exceptions.
class CheckFailure : public ngraph_error
{
public:
CheckFailure(const CheckLocInfo& check_loc_info,
const std::string& context_info,
const std::string& explanation)
: ngraph_error(make_what(check_loc_info, context_info, explanation))
{
}
private:
static std::string make_what(const CheckLocInfo& check_loc_info,
const std::string& context_info,
const std::string& explanation)
{
std::stringstream ss;
ss << "Check '" << check_loc_info.check_string << "' failed at " << check_loc_info.file
<< ":" << check_loc_info.line << ":" << std::endl;
ss << context_info << ":" << std::endl;
ss << explanation << std::endl;
return ss.str();
}
};
}
// TODO(amprocte): refactor so we don't have to introduce a locally-scoped variable and risk
// shadowing here.
#define CHECK(exc_class, ctx, check, ...) \
do \
{ \
if (!(check)) \
{ \
::std::stringstream ss___; \
::ngraph::write_all_to_stream(ss___, __VA_ARGS__); \
throw exc_class( \
(::ngraph::CheckLocInfo{__FILE__, __LINE__, #check}), (ctx), ss___.str()); \
} \
} while (0)
src/ngraph/node.cpp
View file @ 6ffbd254
......@@ -422,15 +422,20 @@ NodeVector Node::get_users(bool check_is_used) const
std::string ngraph::node_validation_assertion_string(const Node* node)
{
std::stringstream ss;
ss << "While validating node '" << *node << "' of type '" << node->description() << "'";
ss << "While validating node '" << *node << "'";
return ss.str();
}
void ngraph::check_new_args_count(const Node* node, const NodeVector& new_args)
{
NODE_VALIDATION_ASSERT(node, new_args.size() == node->get_arguments().size())
<< "copy_with_new_args() expected " << node->get_arguments().size() << " argument"
<< (node->get_arguments().size() == 1 ? "" : "s") << " but got " << new_args.size();
NODE_VALIDATION_CHECK(node,
new_args.size() == node->get_arguments().size(),
"copy_with_new_args() expected ",
node->get_arguments().size(),
" argument",
(node->get_arguments().size() == 1 ? "" : "s"),
" but got ",
new_args.size());
}
const std::shared_ptr<Node>& ngraph::check_single_output_arg(const std::shared_ptr<Node>& node,
......@@ -459,13 +464,14 @@ std::tuple<element::Type, PartialShape> Node::validate_and_infer_elementwise_arg
{
for (size_t i = 1; i < get_input_size(); ++i)
{
NODE_VALIDATION_ASSERT(
this, element::Type::merge(element_type, element_type, get_input_element_type(i)))
<< "Argument element types are inconsistent.";
NODE_VALIDATION_ASSERT(this,
PartialShape::merge_into(pshape, get_input_partial_shape(i)))
<< "Argument shapes are inconsistent.";
NODE_VALIDATION_CHECK(
this,
element::Type::merge(element_type, element_type, get_input_element_type(i)),
"Argument element types are inconsistent.");
NODE_VALIDATION_CHECK(this,
PartialShape::merge_into(pshape, get_input_partial_shape(i)),
"Argument shapes are inconsistent.");
}
}
......@@ -478,8 +484,11 @@ void Node::validate_and_infer_elementwise_arithmetic()
element::Type& args_et = std::get<0>(args_et_pshape);
PartialShape& args_pshape = std::get<1>(args_et_pshape);
NODE_VALIDATION_ASSERT(this, args_et.is_dynamic() || args_et != element::boolean)
<< "Arguments cannot have boolean element type (argument element type: " << args_et << ").";
NODE_VALIDATION_CHECK(this,
args_et.is_dynamic() || args_et != element::boolean,
"Arguments cannot have boolean element type (argument element type: ",
args_et,
").");
set_output_type(0, args_et, args_pshape);
}
......@@ -490,9 +499,12 @@ void Node::validate_and_infer_elementwise_logical()
element::Type& args_et = std::get<0>(args_et_pshape);
PartialShape& args_pshape = std::get<1>(args_et_pshape);
NODE_VALIDATION_ASSERT(this, args_et.is_dynamic() || args_et == element::boolean)
<< "Operands for logical operators must have boolean element type but have element type "
<< args_et << ".";
NODE_VALIDATION_CHECK(
this,
args_et.is_dynamic() || args_et == element::boolean,
"Operands for logical operators must have boolean element type but have element type ",
args_et,
".");
set_output_type(0, element::boolean, args_pshape);
}
src/ngraph/node.hpp
View file @ 6ffbd254
......@@ -30,6 +30,7 @@
#include "ngraph/assertion.hpp"
#include "ngraph/autodiff/adjoints.hpp"
#include "ngraph/check.hpp"
#include "ngraph/descriptor/input.hpp"
#include "ngraph/descriptor/output.hpp"
#include "ngraph/descriptor/tensor.hpp"
......@@ -287,6 +288,17 @@ namespace ngraph
}
};
class NodeValidationFailure : public CheckFailure
{
public:
NodeValidationFailure(const CheckLocInfo& check_loc_info,
const Node* node,
const std::string& explanation)
: CheckFailure(check_loc_info, node_validation_assertion_string(node), explanation)
{
}
};
class NodeDescription
{
public:
......@@ -315,3 +327,6 @@ namespace ngraph
#define NODE_VALIDATION_FAIL(node) \
NGRAPH_FAIL_STREAM_WITH_LOC(::ngraph::NodeValidationError, \
::ngraph::node_validation_assertion_string(node))
#define NODE_VALIDATION_CHECK(node, cond, ...) \
CHECK(::NodeValidationFailure, (node), (cond), __VA_ARGS__)
src/ngraph/op/convolution.cpp
View file @ 6ffbd254
......@@ -297,9 +297,14 @@ void op::ConvolutionBackpropData::validate_and_infer_types()
m_window_movement_strides_forward,
m_window_dilation_strides_forward);
NODE_VALIDATION_ASSERT(this, forward_result_shape.compatible(delta_shape))
<< "Inferred forward output shape (" << forward_result_shape << ") does not match shape of "
<< "delta (" << delta_shape << ").";
NODE_VALIDATION_CHECK(this,
forward_result_shape.compatible(delta_shape),
"Inferred forward output shape (",
forward_result_shape,
") does not match shape of ",
"delta (",
delta_shape,
").");
set_output_type(0, forward_result_et, m_data_batch_shape);
......@@ -494,9 +499,14 @@ void op::ConvolutionBackpropFilters::validate_and_infer_types()
m_window_movement_strides_forward,
m_window_dilation_strides_forward);
NODE_VALIDATION_ASSERT(this, forward_result_shape.compatible(delta_shape))
<< "Inferred forward output shape (" << forward_result_shape << ") does not match shape of "
<< "delta (" << delta_shape << ").";
NODE_VALIDATION_CHECK(this,
forward_result_shape.compatible(delta_shape),
"Inferred forward output shape (",
forward_result_shape,
") does not match shape of ",
"delta (",
delta_shape,
").");
set_output_type(0, forward_result_et, m_filters_shape);
......
src/ngraph/validation_util.cpp
View file @ 6ffbd254
......@@ -39,18 +39,29 @@ PartialShape ngraph::infer_windowed_reduction_output_shape(const Node* node,
{
PartialShape data_shape_merged{PartialShape::dynamic()};
NODE_VALIDATION_ASSERT(node,
data_shape_merged.merge_rank(data_shape.rank()) &&
data_shape_merged.merge_rank(data_dilation.size()) &&
data_shape_merged.merge_rank(data_padding_below.size()) &&
data_shape_merged.merge_rank(data_padding_above.size()) &&
data_shape_merged.merge_rank(window_shape.rank()) &&
data_shape_merged.merge_rank(window_strides.size()) &&
data_shape_merged.merge_rank(window_dilation.size()))
<< "Ranks for data shape (" << data_shape << "), data dilation (" << data_dilation
<< "), padding below (" << data_padding_below << "), padding above (" << data_padding_above
<< "), window shape (" << window_shape << "), window strides (" << window_strides
<< "), and window dilation (" << window_dilation << ") do not match.";
NODE_VALIDATION_CHECK(node,
data_shape_merged.merge_rank(data_shape.rank()) &&
data_shape_merged.merge_rank(data_dilation.size()) &&
data_shape_merged.merge_rank(data_padding_below.size()) &&
data_shape_merged.merge_rank(data_padding_above.size()) &&
data_shape_merged.merge_rank(window_shape.rank()) &&
data_shape_merged.merge_rank(window_strides.size()) &&
data_shape_merged.merge_rank(window_dilation.size()),
"Ranks for data shape (",
data_shape,
"), data dilation (",
data_dilation,
"), padding below (",
data_padding_below,
"), padding above (",
data_padding_above,
"), window shape (",
window_shape,
"), window strides (",
window_strides,
"), and window dilation (",
window_dilation,
") do not match.");
PartialShape output_shape = PartialShape::dynamic(data_shape_merged.rank());
......@@ -58,15 +69,27 @@ PartialShape ngraph::infer_windowed_reduction_output_shape(const Node* node,
{
for (size_t i = 0; i < static_cast<size_t>(output_shape.rank()); i++)
{
NODE_VALIDATION_ASSERT(node, data_dilation[i] > 0)
<< "Data dilation (" << data_dilation << ") has zero dimension at axis " << i
<< ".";
NODE_VALIDATION_ASSERT(node, window_strides[i] > 0)
<< "Window strides (" << window_strides << ") has zero dimension at axis " << i
<< ".";
NODE_VALIDATION_ASSERT(node, window_dilation[i] > 0)
<< "Window dilation (" << window_dilation << ") has zero dimension at axis " << i
<< ".";
NODE_VALIDATION_CHECK(node,
data_dilation[i] > 0,
"Data dilation (",
data_dilation,
") has zero dimension at axis ",
i,
".");
NODE_VALIDATION_CHECK(node,
window_strides[i] > 0,
"Window strides (",
window_strides,
") has zero dimension at axis ",
i,
".");
NODE_VALIDATION_CHECK(node,
window_dilation[i] > 0,
"Window dilation (",
window_dilation,
") has zero dimension at axis ",
i,
".");
bool data_dim_static = data_shape.rank().is_static() && data_shape[i].is_static();
bool window_dim_static = window_shape.rank().is_static() && window_shape[i].is_static();
......@@ -77,9 +100,14 @@ PartialShape ngraph::infer_windowed_reduction_output_shape(const Node* node,
data_padded_dilated_dim = (static_cast<ptrdiff_t>(data_dilation[i]) *
(static_cast<ptrdiff_t>(data_shape[i]) - 1)) +
1 + data_padding_below[i] + data_padding_above[i];
NODE_VALIDATION_ASSERT(node, data_padded_dilated_dim > 0)
<< "Data shape after padding and dilation has dimension less than 1 (dim: "
<< data_padded_dilated_dim << ") at axis " << i << ".";
NODE_VALIDATION_CHECK(
node,
data_padded_dilated_dim > 0,
"Data shape after padding and dilation has dimension less than 1 (dim: ",
data_padded_dilated_dim,
") at axis ",
i,
".");
}
ptrdiff_t window_dilated_dim = -1;
......@@ -89,28 +117,42 @@ PartialShape ngraph::infer_windowed_reduction_output_shape(const Node* node,
(static_cast<ptrdiff_t>(window_shape[i]) - 1) +
1;
NODE_VALIDATION_ASSERT(node, window_dilated_dim > 0)
<< "Window after dilation has dimension less than 1 (dim: "
<< window_dilated_dim << ") at axis " << i << ".";
NODE_VALIDATION_ASSERT(node,
is_window_all_in_padding_allowed ||
(window_dilated_dim > data_padding_below[i] &&
window_dilated_dim > data_padding_above[i]))
<< "Window after dilation is sometimes entirely in the padding area for axis "
<< i << " (dilated window dimension: " << window_dilated_dim
<< ", padding below dimension: " << data_padding_below[i]
<< ", padding above dimension: " << data_padding_above[i]
<< ") and this is not "
<< "allowed.";
NODE_VALIDATION_CHECK(node,
window_dilated_dim > 0,
"Window after dilation has dimension less than 1 (dim: ",
window_dilated_dim,
") at axis ",
i,
".");
NODE_VALIDATION_CHECK(
node,
is_window_all_in_padding_allowed ||
(window_dilated_dim > data_padding_below[i] &&
window_dilated_dim > data_padding_above[i]),
"Window after dilation is sometimes entirely in the padding area for axis ",
i,
" (dilated window dimension: ",
window_dilated_dim,
", padding below dimension: ",
data_padding_below[i],
", padding above dimension: ",
data_padding_above[i],
") and this is not ",
"allowed.");
}
if (data_dim_static && window_dim_static)
{
NODE_VALIDATION_ASSERT(node, window_dilated_dim <= data_padded_dilated_dim)
<< "Window after dilation has dimension (dim: " << window_dilated_dim
<< ") larger than the data shape after padding (dim: "
<< data_padded_dilated_dim << ") at axis " << i << ".";
NODE_VALIDATION_CHECK(node,
window_dilated_dim <= data_padded_dilated_dim,
"Window after dilation has dimension (dim: ",
window_dilated_dim,
") larger than the data shape after padding (dim: ",
data_padded_dilated_dim,
") at axis ",
i,
".");
output_shape[i] = ceil_div(static_cast<size_t>(data_padded_dilated_dim) -
static_cast<size_t>(window_dilated_dim) + 1,
......@@ -139,39 +181,64 @@ std::tuple<element::Type, PartialShape>
{
element::Type et_result;
NODE_VALIDATION_ASSERT(node, element::Type::merge(et_result, et_batch, et_filters))
<< "Element types for data batch and filters do not match (data batch element type: "
<< et_batch << ", filters element type: " << et_filters << ").";
NODE_VALIDATION_CHECK(
node,
element::Type::merge(et_result, et_batch, et_filters),
"Element types for data batch and filters do not match (data batch element type: ",
et_batch,
", filters element type: ",
et_filters,
").");
Rank data_batch_filters_rank{Rank::dynamic()};
NODE_VALIDATION_ASSERT(
node, Rank::merge(data_batch_filters_rank, data_batch_shape.rank(), filters_shape.rank()))
<< "Data batch and filters rank do not match (data batch shape: " << data_batch_shape
<< ", filters shape: " << filters_shape << ").";
NODE_VALIDATION_ASSERT(node,
data_batch_filters_rank.is_dynamic() ||
static_cast<size_t>(data_batch_filters_rank) >= 3)
<< "Data batch and filters must have rank of at least 3 (one batch axis, "
<< "one input-channel axis, and at least one spatial dimension) "
<< "(data batch shape: " << data_batch_shape << ", filters shape: " << filters_shape
<< ").";
NODE_VALIDATION_CHECK(
node,
Rank::merge(data_batch_filters_rank, data_batch_shape.rank(), filters_shape.rank()),
"Data batch and filters rank do not match (data batch shape: ",
data_batch_shape,
", filters shape: ",
filters_shape,
").");
NODE_VALIDATION_CHECK(node,
data_batch_filters_rank.is_dynamic() ||
static_cast<size_t>(data_batch_filters_rank) >= 3,
"Data batch and filters must have rank of at least 3 (one batch axis, ",
"one input-channel axis, and at least one spatial dimension) ",
"(data batch shape: ",
data_batch_shape,
", filters shape: ",
filters_shape,
").");
Rank spatial_rank{Rank::dynamic()};
NODE_VALIDATION_ASSERT(node,
Rank::merge(spatial_rank, spatial_rank, data_batch_filters_rank - 2) &&
Rank::merge(spatial_rank, spatial_rank, data_dilation.size()) &&
Rank::merge(spatial_rank, spatial_rank, data_padding_below.size()) &&
Rank::merge(spatial_rank, spatial_rank, data_padding_above.size()) &&
Rank::merge(spatial_rank, spatial_rank, filter_strides.size()) &&
Rank::merge(spatial_rank, spatial_rank, filter_dilation.size()))
<< "Ranks for data item shape/filters shape (data batch has shape " << data_batch_shape
<< ", so data item rank is " << (data_batch_shape.rank() - 2) << " and filters have shape "
<< filters_shape << ", so filters spatial rank is " << (filters_shape.rank() - 2)
<< "), data dilation (" << data_dilation << "), padding below (" << data_padding_below
<< "), padding above (" << data_padding_above << "), filter strides (" << filter_strides
<< "), and filter dilation (" << filter_dilation << ") do not match.";
NODE_VALIDATION_CHECK(node,
Rank::merge(spatial_rank, spatial_rank, data_batch_filters_rank - 2) &&
Rank::merge(spatial_rank, spatial_rank, data_dilation.size()) &&
Rank::merge(spatial_rank, spatial_rank, data_padding_below.size()) &&
Rank::merge(spatial_rank, spatial_rank, data_padding_above.size()) &&
Rank::merge(spatial_rank, spatial_rank, filter_strides.size()) &&
Rank::merge(spatial_rank, spatial_rank, filter_dilation.size()),
"Ranks for data item shape/filters shape (data batch has shape ",
data_batch_shape,
", so data item rank is ",
(data_batch_shape.rank() - 2),
" and filters have shape ",
filters_shape,
", so filters spatial rank is ",
(filters_shape.rank() - 2),
"), data dilation (",
data_dilation,
"), padding below (",
data_padding_below,
"), padding above (",
data_padding_above,
"), filter strides (",
filter_strides,
"), and filter dilation (",
filter_dilation,
") do not match.");
Dimension batch_size =
(data_batch_shape.rank().is_static() ? data_batch_shape[0] : Dimension::dynamic());
......@@ -202,25 +269,31 @@ std::tuple<element::Type, PartialShape>
}
}
NODE_VALIDATION_ASSERT(node, batch_size.is_dynamic() || static_cast<size_t>(batch_size) > 0)
<< "Batch size is zero.";
NODE_VALIDATION_CHECK(node,
batch_size.is_dynamic() || static_cast<size_t>(batch_size) > 0,
"Batch size is zero.");
Dimension merged_channel_count;
NODE_VALIDATION_ASSERT(
NODE_VALIDATION_CHECK(
node,
Dimension::merge(merged_channel_count, data_channel_count, filter_input_channel_count))
<< "Data batch channel count (" << data_channel_count << ") does not match filter input "
<< "channel count (" << filter_input_channel_count << ").";
NODE_VALIDATION_ASSERT(
node, merged_channel_count.is_dynamic() || static_cast<size_t>(merged_channel_count) > 0)
<< "Data batch channel count and/or filter input channel count is zero.";
NODE_VALIDATION_ASSERT(node,
filter_output_channel_count.is_dynamic() ||
static_cast<size_t>(filter_output_channel_count) > 0)
<< "Filter output channel count is zero.";
Dimension::merge(merged_channel_count, data_channel_count, filter_input_channel_count),
"Data batch channel count (",
data_channel_count,
") does not match filter input ",
"channel count (",
filter_input_channel_count,
").");
NODE_VALIDATION_CHECK(node,
merged_channel_count.is_dynamic() ||
static_cast<size_t>(merged_channel_count) > 0,
"Data batch channel count and/or filter input channel count is zero.");
NODE_VALIDATION_CHECK(node,
filter_output_channel_count.is_dynamic() ||
static_cast<size_t>(filter_output_channel_count) > 0,
"Filter output channel count is zero.");
PartialShape data_output_shape = infer_windowed_reduction_output_shape(node,
data_spatial_shape,
......@@ -255,25 +328,36 @@ PartialShape ngraph::infer_batched_pooling_forward(const Node* node,
const Strides& window_strides,
bool is_window_all_in_padding_allowed)
{
NODE_VALIDATION_ASSERT(node,
data_batch_shape.rank().is_dynamic() ||
static_cast<size_t>(data_batch_shape.rank()) >= 3)
<< "Data batch must have rank of at least 3 (one batch axis, "
<< "one input-channel axis, and at least one spatial dimension) "
<< "(data batch shape: " << data_batch_shape << ").";
NODE_VALIDATION_CHECK(node,
data_batch_shape.rank().is_dynamic() ||
static_cast<size_t>(data_batch_shape.rank()) >= 3,
"Data batch must have rank of at least 3 (one batch axis, ",
"one input-channel axis, and at least one spatial dimension) ",
"(data batch shape: ",
data_batch_shape,
").");
PartialShape data_spatial_shape{PartialShape::dynamic()};
NODE_VALIDATION_ASSERT(node,
data_spatial_shape.merge_rank(data_batch_shape.rank() - 2) &&
data_spatial_shape.merge_rank(data_padding_below.size()) &&
data_spatial_shape.merge_rank(data_padding_above.size()) &&
data_spatial_shape.merge_rank(window_shape.rank()) &&
data_spatial_shape.merge_rank(window_strides.size()))
<< "Ranks for data item shape (data batch has shape " << data_batch_shape
<< ", so data item rank is " << (data_batch_shape.rank() - 2) << "), padding below ("
<< data_padding_below << "), padding above (" << data_padding_above << "), window shape ("
<< window_shape << "), and window strides (" << window_strides << ") do not match.";
NODE_VALIDATION_CHECK(node,
data_spatial_shape.merge_rank(data_batch_shape.rank() - 2) &&
data_spatial_shape.merge_rank(data_padding_below.size()) &&
data_spatial_shape.merge_rank(data_padding_above.size()) &&
data_spatial_shape.merge_rank(window_shape.rank()) &&
data_spatial_shape.merge_rank(window_strides.size()),
"Ranks for data item shape (data batch has shape ",
data_batch_shape,
", so data item rank is ",
(data_batch_shape.rank() - 2),
"), padding below (",
data_padding_below,
"), padding above (",
data_padding_above,
"), window shape (",
window_shape,
"), and window strides (",
window_strides,
") do not match.");
Dimension batch_size{Dimension::dynamic()};
Dimension channel_count{Dimension::dynamic()};
......@@ -289,12 +373,13 @@ PartialShape ngraph::infer_batched_pooling_forward(const Node* node,
data_spatial_shape[i] = data_batch_shape[i + 2];
}
NODE_VALIDATION_ASSERT(node, batch_size.is_dynamic() || static_cast<size_t>(batch_size) > 0)
<< "Batch size is zero.";
NODE_VALIDATION_CHECK(node,
batch_size.is_dynamic() || static_cast<size_t>(batch_size) > 0,
"Batch size is zero.");
NODE_VALIDATION_ASSERT(node,
channel_count.is_dynamic() || static_cast<size_t>(channel_count) > 0)
<< "Channel count is zero.";
NODE_VALIDATION_CHECK(node,
channel_count.is_dynamic() || static_cast<size_t>(channel_count) > 0,
"Channel count is zero.");
// For pooling ops we don't need dilation, so we fill in the identity value (all 1).
Strides data_dilation(static_cast<size_t>(data_spatial_shape.rank()), 1);
......@@ -358,17 +443,19 @@ static std::tuple<element::Type, PartialShape, PartialShape> infer_batch_norm_fo
for (auto& inp : channel_shaped_inputs)
{
NODE_VALIDATION_ASSERT(node, element::Type::merge(et_result, et_result, inp.m_element_type))
<< "Input element types do not match.";
NODE_VALIDATION_CHECK(node,
element::Type::merge(et_result, et_result, inp.m_element_type),
"Input element types do not match.");
}
// Extract channel dimension from input shape.
Dimension channel_dim{Dimension::dynamic()};
NODE_VALIDATION_ASSERT(node,
input_shape.is_dynamic() || static_cast<size_t>(input_shape.rank()) >= 2)
<< "Input argument must have rank of at least 2 (input argument shape: " << input_shape
<< ").";
NODE_VALIDATION_CHECK(node,
input_shape.is_dynamic() || static_cast<size_t>(input_shape.rank()) >= 2,
"Input argument must have rank of at least 2 (input argument shape: ",
input_shape,
").");
if (input_shape.rank().is_static())
{
......@@ -380,20 +467,34 @@ static std::tuple<element::Type, PartialShape, PartialShape> infer_batch_norm_fo
for (auto& inp : channel_shaped_inputs)
{
NODE_VALIDATION_ASSERT(node, PartialShape::merge_into(channel_shape, inp.m_shape))
<< "Shapes for " << channel_input_names << " do not match.";
NODE_VALIDATION_CHECK(node,
PartialShape::merge_into(channel_shape, inp.m_shape),
"Shapes for ",
channel_input_names,
" do not match.");
}
NODE_VALIDATION_ASSERT(node, channel_shape.merge_rank(1)) << "Shape for " << channel_input_names
<< " (" << channel_shape
<< ") does not have rank 1.";
NODE_VALIDATION_ASSERT(node, Dimension::merge(channel_dim, channel_dim, channel_shape[0]))
<< "Input channel dimension (" << channel_dim << ") does not match shape for "
<< channel_input_names << " (" << channel_shape << ").";
NODE_VALIDATION_ASSERT(node, channel_dim.is_dynamic() || static_cast<size_t>(channel_dim) >= 1)
<< "Channel count must be at least 1.";
NODE_VALIDATION_CHECK(node,
channel_shape.merge_rank(1),
"Shape for ",
channel_input_names,
" (",
channel_shape,
") does not have rank 1.");
NODE_VALIDATION_CHECK(node,
Dimension::merge(channel_dim, channel_dim, channel_shape[0]),
"Input channel dimension (",
channel_dim,
") does not match shape for ",
channel_input_names,
" (",
channel_shape,
").");
NODE_VALIDATION_CHECK(node,
channel_dim.is_dynamic() || static_cast<size_t>(channel_dim) >= 1,
"Channel count must be at least 1.");
// Batch result shape is same as the input shape, except we may possibly have inferred more
// information from the channel count via gamma/beta/etc.
......
test/partial_shape.cpp
View file @ 6ffbd254
......@@ -884,7 +884,7 @@ TEST(partial_shape, infer_windowed_reduction_rank_dynamic_rank_dynamic_zero_data
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape, infer_windowed_reduction_rank_dynamic_rank_dynamic_zero_window_dilation)
......@@ -911,7 +911,7 @@ TEST(partial_shape, infer_windowed_reduction_rank_dynamic_rank_dynamic_zero_wind
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape, infer_windowed_reduction_rank_dynamic_rank_dynamic_zero_window_strides)
......@@ -938,7 +938,7 @@ TEST(partial_shape, infer_windowed_reduction_rank_dynamic_rank_dynamic_zero_wind
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape, infer_windowed_reduction_rank_static_dynamic_rank_dynamic_ok)
......@@ -992,7 +992,7 @@ TEST(partial_shape,
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape, infer_windowed_reduction_rank_static_dynamic_rank_dynamic_neg_padding_ok)
......@@ -1071,7 +1071,7 @@ TEST(partial_shape, infer_windowed_reduction_rank_dynamic_rank_static_dynamic_wi
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape,
......@@ -1100,7 +1100,7 @@ TEST(partial_shape,
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape,
......@@ -1156,7 +1156,7 @@ TEST(partial_shape,
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape,
......@@ -1294,7 +1294,7 @@ TEST(partial_shape, infer_windowed_reduction_rank_static_dynamic_rank_static_dyn
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
TEST(partial_shape,
......@@ -1351,5 +1351,5 @@ TEST(partial_shape,
window_dilation,
is_window_all_in_padding_allowed);
},
NodeValidationError);
NodeValidationFailure);
}
test/type_prop.cpp
View file @ 6ffbd254
......@@ -212,7 +212,7 @@ TEST(type_prop, batchnorm_training_rank_less_than_2)
auto bc = make_shared<op::BatchNormTraining>(dummy, dummy, dummy, 0.001);
FAIL() << "BatchNorm c-tor should throw for tensors whose rank is less than 2";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Input argument must have rank of at least 2"));
......@@ -233,7 +233,7 @@ TEST(type_prop, batchnorm_training_zero_channel_check)
auto bc = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, 0.001);
FAIL() << "BatchNorm c-tor should throw for tensors w/ zero-dimension channels";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Channel count must be at least 1"));
}
......@@ -254,7 +254,7 @@ TEST(type_prop, batchnorm_training_et_check)
auto bc = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, 0.001);
FAIL() << "BatchNorm c-tor should throw for different element types";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Input element types do not match"));
}
......@@ -275,7 +275,7 @@ TEST(type_prop, batchnorm_training_shape_check)
auto bc = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, 0.001);
FAIL() << "BatchNorm c-tor should throw if gamma and beta shapes don't match";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Shapes for gamma/beta do not match"));
}
......@@ -300,7 +300,7 @@ TEST(type_prop, batchnorm_training_backprop_et_check)
data_batch, gamma, beta, mean, variance, delta, 0.001);
FAIL() << "Deduced type should disagree with c-tor arguments";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Input element types do not match"));
}
......@@ -325,7 +325,7 @@ TEST(type_prop, batchnorm_training_backprop_shape_check)
data_batch, gamma, beta, mean, variance, delta, 0.001);
FAIL() << "Deduced type should disagree with c-tor arguments";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Shapes for gamma/beta/mean/variance do not match"));
......@@ -443,7 +443,7 @@ TEST(type_prop, batchnorm_inference_partial_input_rank_static_dynamic_zero_chann
make_shared<op::BatchNormInference>(data_batch, gamma, beta, mean, variance, epsilon);
FAIL() << "Zero channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Channel count must be at least 1"));
}
......@@ -506,7 +506,7 @@ TEST(type_prop, batchnorm_inference_partial_input_rank_dynamic_some_rank_static_
make_shared<op::BatchNormInference>(data_batch, gamma, beta, mean, variance, epsilon);
FAIL() << "Wrong gamma/beta/mean/variance shape not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -545,7 +545,7 @@ TEST(type_prop,
make_shared<op::BatchNormInference>(data_batch, gamma, beta, mean, variance, epsilon);
FAIL() << "Inconsistent gamma/beta/mean/variance shape not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Shapes for gamma/beta/mean/variance do not match"));
......@@ -583,7 +583,7 @@ TEST(type_prop,
make_shared<op::BatchNormInference>(data_batch, gamma, beta, mean, variance, epsilon);
FAIL() << "Inconsistent gamma/beta/mean/variance channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Shapes for gamma/beta/mean/variance do not match"));
......@@ -649,7 +649,7 @@ TEST(type_prop,
make_shared<op::BatchNormInference>(data_batch, gamma, beta, mean, variance, epsilon);
FAIL() << "Inconsistent input/gamma/beta/mean/variance channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Input channel dimension (4) does not match "
......@@ -759,7 +759,7 @@ TEST(type_prop, batchnorm_training_partial_input_rank_static_dynamic_zero_channe
auto bn = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, epsilon);
FAIL() << "Zero channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Channel count must be at least 1"));
}
......@@ -813,7 +813,7 @@ TEST(type_prop, batchnorm_training_partial_input_rank_dynamic_some_rank_static_d
auto bn = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, epsilon);
FAIL() << "Wrong gamma/beta shape not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Shape for gamma/beta ({?,?}) does not have rank 1"));
......@@ -844,7 +844,7 @@ TEST(type_prop,
auto bn = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, epsilon);
FAIL() << "Inconsistent gamma/beta shape not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Shapes for gamma/beta do not match"));
}
......@@ -874,7 +874,7 @@ TEST(type_prop,
auto bn = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, epsilon);
FAIL() << "Inconsistent gamma/beta channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Shapes for gamma/beta do not match"));
}
......@@ -930,7 +930,7 @@ TEST(type_prop,
auto bn = make_shared<op::BatchNormTraining>(data_batch, gamma, beta, epsilon);
FAIL() << "Inconsistent input/gamma/beta channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -1049,7 +1049,7 @@ TEST(type_prop, batchnorm_training_backprop_partial_input_rank_static_dynamic_ze
data_batch, gamma, beta, mean, variance, delta, epsilon);
FAIL() << "Zero channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Channel count must be at least 1"));
}
......@@ -1160,7 +1160,7 @@ TEST(type_prop, batchnorm_training_backprop_partial_delta_rank_static_dynamic_ze
data_batch, gamma, beta, mean, variance, delta, epsilon);
FAIL() << "Zero channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Channel count must be at least 1"));
}
......@@ -1237,7 +1237,7 @@ TEST(
data_batch, gamma, beta, mean, variance, delta, epsilon);
FAIL() << "Wrong gamma/beta/mean/variance shape not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -1280,7 +1280,7 @@ TEST(
data_batch, gamma, beta, mean, variance, delta, epsilon);
FAIL() << "Wrong gamma/beta/mean/variance shape not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Shapes for gamma/beta/mean/variance do not match"));
......@@ -1322,7 +1322,7 @@ TEST(
data_batch, gamma, beta, mean, variance, delta, epsilon);
FAIL() << "nconsistent gamma/beta/mean/variance channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Shapes for gamma/beta/mean/variance do not match"));
......@@ -1400,7 +1400,7 @@ TEST(
data_batch, gamma, beta, mean, variance, delta, epsilon);
FAIL() << "Inconsistent delta/gamma/beta/mean/variance channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Input channel dimension (4) does not match "
......@@ -2218,7 +2218,7 @@ void test_binary(std::string node_type,
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible view arguments not detected.";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent"));
}
......@@ -2237,7 +2237,7 @@ void test_binary(std::string node_type,
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible view arguments not detected.";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument element types are inconsistent"));
......@@ -2310,7 +2310,7 @@ void test_binary_logical(std::string node_type,
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible view arguments not detected.";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent"));
}
......@@ -2329,7 +2329,7 @@ void test_binary_logical(std::string node_type,
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible view arguments not detected.";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument element types are inconsistent"));
......@@ -2463,7 +2463,7 @@ TEST(type_prop, binary_arithmetic_bad_argument_element_types)
// Should have thrown, so fail if it didn't
FAIL() << "Did not detect incorrect element types for arithmetic operator";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Arguments cannot have boolean element type"));
......@@ -2483,7 +2483,7 @@ TEST(type_prop, unary_arithmetic_bad_argument_element_types)
// Should have thrown, so fail if it didn't
FAIL() << "Did not detect incorrect element types for arithmetic operator";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Arguments cannot have boolean element type"));
......@@ -5420,7 +5420,7 @@ TEST(type_prop, conv_invalid_element_type_mismatch)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with element type mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Element types for data batch and filters do not match"));
......@@ -5443,7 +5443,7 @@ TEST(type_prop, conv_invalid_0d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 0D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data batch and filters must have rank of at least 3 "
......@@ -5468,7 +5468,7 @@ TEST(type_prop, conv_invalid_1d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 1D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data batch and filters must have rank of at least 3 "
......@@ -5493,7 +5493,7 @@ TEST(type_prop, conv_invalid_2d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 2D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data batch and filters must have rank of at least 3 "
......@@ -5518,7 +5518,7 @@ TEST(type_prop, conv_invalid_0_batch_size)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 batch size not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Batch size is zero"));
}
......@@ -5540,7 +5540,7 @@ TEST(type_prop, conv_invalid_0_input_channels)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 input channels not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5564,7 +5564,7 @@ TEST(type_prop, conv_invalid_wrong_number_of_filter_dimensions_too_many)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with too many filter dimensions not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Data batch and filters rank do not match"));
}
......@@ -5586,7 +5586,7 @@ TEST(type_prop, conv_invalid_wrong_number_of_filter_dimensions_too_few)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with too few filter dimensions not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Data batch and filters rank do not match"));
}
......@@ -5608,7 +5608,7 @@ TEST(type_prop, conv_invalid_0_output_channels)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 output channels not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Filter output channel count is zero"));
}
......@@ -5630,7 +5630,7 @@ TEST(type_prop, conv_invalid_input_channel_mismatch)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with channel count mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5655,7 +5655,7 @@ TEST(type_prop, conv_invalid_movement_stride_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong movement stride rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5684,7 +5684,7 @@ TEST(type_prop, conv_invalid_window_dilation_stride_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong window dilation stride rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5719,7 +5719,7 @@ TEST(type_prop, conv_invalid_data_dilation_stride_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong data dilation stride rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5753,7 +5753,7 @@ TEST(type_prop, conv_invalid_padding_below_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong padding-below rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5787,7 +5787,7 @@ TEST(type_prop, conv_invalid_padding_above_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong padding-above rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5821,7 +5821,7 @@ TEST(type_prop, conv_invalid_input_spatial_size_negative_after_padding)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with negative-length post-padding spatial axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has dimension less "
......@@ -5850,7 +5850,7 @@ TEST(type_prop, conv_invalid_input_spatial_size_zero_after_padding)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length post-padding spatial axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has dimension less "
......@@ -5874,7 +5874,7 @@ TEST(type_prop, conv_invalid_input_spatial_size_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length spatial axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has "
......@@ -5898,7 +5898,7 @@ TEST(type_prop, conv_invalid_window_size_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length window axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5922,7 +5922,7 @@ TEST(type_prop, conv_invalid_window_dilation_stride_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong 0-length window dilation stride axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5952,7 +5952,7 @@ TEST(type_prop, conv_invalid_data_dilation_stride_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong 0-length data dilation stride axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -5976,7 +5976,7 @@ TEST(type_prop, conv_invalid_dilated_window_too_large)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with oversized dilated window not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 9) larger than "
......@@ -6000,7 +6000,7 @@ TEST(type_prop, conv_invalid_movement_stride_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong 0-length movement stride axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6062,7 +6062,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_window_strides_rank_wrong
FAIL() << "Window stride rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6103,7 +6103,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_window_strides_dim_zero)
FAIL() << "Window stride with dimension zero not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6140,7 +6140,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_window_dilation_rank_wron
FAIL() << "Window dilation rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6181,7 +6181,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_window_dilation_dim_zero)
FAIL() << "Window dilation with dimension zero not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6218,7 +6218,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_padding_below_rank_wrong)
FAIL() << "Padding below rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6259,7 +6259,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_padding_above_rank_wrong)
FAIL() << "Padding above rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6300,7 +6300,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_data_dilation_rank_wrong)
FAIL() << "Data dilation rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6341,7 +6341,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_dynamic_data_dilation_dim_zero)
FAIL() << "Data dilation with dimension zero not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6403,7 +6403,7 @@ TEST(type_prop, conv_partial_rank_static_dynamic_rank_dynamic_data_batch_rank_wr
FAIL() << "Data batch rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6473,7 +6473,7 @@ TEST(type_prop, conv_partial_rank_static_dynamic_rank_dynamic_batch_size_known_z
FAIL() << "Zero batch size not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Batch size is zero"));
}
......@@ -6535,7 +6535,7 @@ TEST(type_prop, conv_partial_rank_static_dynamic_rank_dynamic_input_channel_coun
FAIL() << "Zero input channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6599,7 +6599,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_static_dynamic_output_channel_cou
FAIL() << "Zero output channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Filter output channel count is zero"));
}
......@@ -6659,7 +6659,7 @@ TEST(type_prop, conv_partial_rank_dynamic_rank_static_dynamic_input_channel_coun
FAIL() << "Zero input channel count not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6721,7 +6721,7 @@ TEST(type_prop, conv_partial_rank_static_dynamic_rank_static_dynamic_arg_ranks_m
FAIL() << "Argument rank mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data batch and filters rank do not match (data batch "
......@@ -6786,7 +6786,7 @@ TEST(type_prop, conv_partial_rank_static_dynamic_rank_static_dynamic_input_chann
FAIL() << "Input channel count mismatch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -6879,7 +6879,7 @@ TEST(
FAIL() << "Oversize filter not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 201) larger "
......@@ -7002,7 +7002,7 @@ TEST(
FAIL() << "Oversize filter after window dilation not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 201) larger "
......@@ -7041,7 +7041,7 @@ TEST(
FAIL() << "Zero dimension in data batch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has "
......@@ -7108,7 +7108,7 @@ TEST(
FAIL() << "Zero padded dimension in data batch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has "
......@@ -7147,7 +7147,7 @@ TEST(
FAIL() << "Negative padded dimension in data batch not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has dimension less "
......@@ -7302,7 +7302,7 @@ TEST(type_prop, max_pool_invalid_0d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 0D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Data batch must have rank of at least 3"));
}
......@@ -7324,7 +7324,7 @@ TEST(type_prop, max_pool_invalid_1d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 1D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Data batch must have rank of at least 3"));
}
......@@ -7346,7 +7346,7 @@ TEST(type_prop, max_pool_invalid_2d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 2D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Data batch must have rank of at least 3"));
}
......@@ -7368,7 +7368,7 @@ TEST(type_prop, max_pool_invalid_0_batch_size)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 batch size not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Batch size is zero"));
}
......@@ -7390,7 +7390,7 @@ TEST(type_prop, max_pool_invalid_0_channels)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 channels not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Channel count is zero"));
}
......@@ -7412,7 +7412,7 @@ TEST(type_prop, max_pool_invalid_wrong_number_of_window_dimensions_too_many)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with too many window dimensions not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7439,7 +7439,7 @@ TEST(type_prop, max_pool_invalid_wrong_number_of_window_dimensions_too_few)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with too few window dimensions not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7467,7 +7467,7 @@ TEST(type_prop, max_pool_invalid_movement_stride_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong movement stride rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7494,7 +7494,7 @@ TEST(type_prop, max_pool_invalid_input_data_size_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length spatial axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Data shape after padding and dilation has "
......@@ -7518,7 +7518,7 @@ TEST(type_prop, max_pool_invalid_window_size_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length window axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7542,7 +7542,7 @@ TEST(type_prop, max_pool_invalid_dilated_too_large)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with oversized window not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 9) larger than "
......@@ -7567,7 +7567,7 @@ TEST(type_prop, max_pool_invalid_movement_stride_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0-length movement stride axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7611,7 +7611,7 @@ TEST(type_prop, max_pool_partial_rank_dynamic_attrib_rank_mismatch)
param, window_shape, window_movement_strides, padding_below, padding_above);
FAIL() << "Mismatch of attribute ranks not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7675,7 +7675,7 @@ TEST(type_prop, max_pool_partial_rank_static_dynamic_attrib_rank_mismatch)
param, window_shape, window_movement_strides, padding_below, padding_above);
FAIL() << "Mismatch of attribute ranks not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -7706,7 +7706,7 @@ TEST(type_prop, max_pool_partial_rank_static_dynamic_window_not_too_big)
param, window_shape, window_movement_strides, padding_below, padding_above);
FAIL() << "Oversized window not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 9) larger than "
......@@ -8371,7 +8371,7 @@ TEST(type_prop, avg_pool_invalid_0d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 0D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Data batch must have rank of at least 3 (one batch axis, one "
......@@ -8395,7 +8395,7 @@ TEST(type_prop, avg_pool_invalid_1d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 1D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Data batch must have rank of at least 3 (one batch axis, one "
......@@ -8419,7 +8419,7 @@ TEST(type_prop, avg_pool_invalid_2d_input)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid 2D input not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Data batch must have rank of at least 3 (one batch axis, one "
......@@ -8443,7 +8443,7 @@ TEST(type_prop, avg_pool_invalid_0_batch_size)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 batch size not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Batch size is zero");
}
......@@ -8465,7 +8465,7 @@ TEST(type_prop, avg_pool_invalid_0_channels)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0 channels not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Channel count is zero");
}
......@@ -8487,7 +8487,7 @@ TEST(type_prop, avg_pool_invalid_wrong_number_of_window_dimensions_too_many)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with too many window dimensions not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Ranks for data item shape (data batch has shape {6,2,10,10}, so data "
......@@ -8513,7 +8513,7 @@ TEST(type_prop, avg_pool_invalid_wrong_number_of_window_dimensions_too_few)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with too few window dimensions not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Ranks for data item shape (data batch has shape {6,2,10,10}, so data "
......@@ -8540,7 +8540,7 @@ TEST(type_prop, avg_pool_invalid_movement_stride_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong movement stride rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Ranks for data item shape (data batch has shape {6,2,10,10}, so data "
......@@ -8570,7 +8570,7 @@ TEST(type_prop, avg_pool_invalid_padding_below_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong below-padding rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Ranks for data item shape (data batch has shape {6,2,10,10}, so data "
......@@ -8600,7 +8600,7 @@ TEST(type_prop, avg_pool_invalid_padding_above_rank)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with wrong above-padding rank not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Ranks for data item shape (data batch has shape {6,2,10,10}, so data "
......@@ -8626,7 +8626,7 @@ TEST(type_prop, avg_pool_invalid_input_item_size_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length spatial axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -8650,7 +8650,7 @@ TEST(type_prop, avg_pool_invalid_window_size_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with zero-length window axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Window after dilation has dimension less than 1 (dim: 0) at axis 1");
......@@ -8673,7 +8673,7 @@ TEST(type_prop, avg_pool_invalid_dilated_too_large)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with oversized window not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Window after dilation has dimension (dim: 9) larger than the data "
......@@ -8712,7 +8712,7 @@ TEST(type_prop, avg_pool_invalid_movement_stride_0)
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input with 0-length movement stride axis not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
"Window strides (Strides{0, 1}) has zero dimension at axis 0");
......@@ -8765,7 +8765,7 @@ TEST(type_prop, avg_pool_partial_rank_dynamic_attrib_rank_mismatch)
include_padding_in_average);
FAIL() << "Mismatch of attribute ranks not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -8844,7 +8844,7 @@ TEST(type_prop, avg_pool_partial_rank_static_dynamic_attrib_rank_mismatch)
include_padding_in_average);
FAIL() << "Mismatch of attribute ranks not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
......@@ -8880,7 +8880,7 @@ TEST(type_prop, avg_pool_partial_rank_static_dynamic_window_not_too_big)
include_padding_in_average);
FAIL() << "Oversized window not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 9) larger than "
......@@ -8935,7 +8935,7 @@ TEST(type_prop, avg_pool_partial_rank_static_dynamic_window_in_padding)
include_padding_in_average);
FAIL() << "Window in padding not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Window after dilation has dimension (dim: 9) larger than "
......@@ -10030,7 +10030,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_rank_static_dynamic_inconsist
auto add = make_shared<op::Add>(a, b);
FAIL() << "Inconsistent partial shapes not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Argument shapes are inconsistent");
}
......@@ -10050,7 +10050,7 @@ TEST(type_prop, binary_elementwise_arithmetic_right_rank_static_dynamic_inconsis
auto add = make_shared<op::Add>(a, b);
FAIL() << "Inconsistent partial shapes not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Argument shapes are inconsistent");
}
......@@ -10070,7 +10070,7 @@ TEST(type_prop, binary_elementwise_arithmetic_both_rank_static_dynamic_inconsist
auto add = make_shared<op::Add>(a, b);
FAIL() << "Inconsistent partial shapes not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Argument shapes are inconsistent");
}
......@@ -10090,7 +10090,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_rank_static_dynamic_different
auto add = make_shared<op::Add>(a, b);
FAIL() << "Inconsistent partial shapes not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Argument shapes are inconsistent");
}
......@@ -10110,7 +10110,7 @@ TEST(type_prop, binary_elementwise_arithmetic_right_rank_static_dynamic_differen
auto add = make_shared<op::Add>(a, b);
FAIL() << "Inconsistent partial shapes not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Argument shapes are inconsistent");
}
......@@ -10130,7 +10130,7 @@ TEST(type_prop, binary_elementwise_arithmetic_both_rank_static_dynamic_different
auto add = make_shared<op::Add>(a, b);
FAIL() << "Inconsistent partial shapes not detected";
}
catch (const NodeValidationError& error)
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), "Argument shapes are inconsistent");
}
......@@ -12095,3 +12095,56 @@ TEST(type_prop, all_partial_rank_static_dynamic_axes_oob)
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, DISABLED_benchmark_type_prop_add)
{
auto p1 = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto p2 = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
constexpr size_t num_iterations = 1000000;
size_t total_nanosec = 0;
stopwatch sw;
for (size_t i = 0; i < num_iterations; i++)
{
sw.start();
auto n = make_shared<op::Add>(p1, p2);
sw.stop();
total_nanosec += sw.get_nanoseconds();
}
std::cout.imbue(std::locale(""));
std::cout << "Constructed " << std::fixed << num_iterations << " Add ops in " << std::fixed
<< total_nanosec << " ns" << std::endl;
}
TEST(type_prop, DISABLED_benchmark_type_prop_convolution)
{
auto d = make_shared<op::Parameter>(element::f32, Shape{64, 3, 224, 224});
auto f = make_shared<op::Parameter>(element::f32, Shape{64, 3, 7, 7});
auto strides = Strides{1, 1};
auto dilation = Strides{1, 1};
auto padding_below = CoordinateDiff{1, 1};
auto padding_above = CoordinateDiff{1, 1};
constexpr size_t num_iterations = 1000000;
size_t total_nanosec = 0;
stopwatch sw;
for (size_t i = 0; i < num_iterations; i++)
{
sw.start();
auto n =
make_shared<op::Convolution>(d, f, strides, dilation, padding_below, padding_above);
sw.stop();
total_nanosec += sw.get_nanoseconds();
}
std::cout.imbue(std::locale(""));
std::cout << "Constructed " << std::fixed << num_iterations << " Convolution ops in "
<< std::fixed << total_nanosec << " ns" << std::endl;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment