mirror of
https://github.com/saymrwulf/onnxruntime.git
synced 2026-05-21 21:52:11 +00:00
18d5cfdb85
### Fix build - redefinition of default argument for ‘long unsigned int
Extent’
One of the training customer env, building ORT, there is such a build
error. The GCC version are
```
aiscuser@node-0:/tmp/onnxruntime$ gcc --version
gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0
aiscuser@node-0:/tmp/onnxruntime$ g++ --version
g++ (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0
```
But on our dev node using same GCC/G++, we don't have build issue., not
sure what's the difference but giving an explict type when creating
`gsl::span` fixed the problem.
```
/tmp/onnxruntime/build/Linux/RelWithDebInfo/_deps/gsl-src/include/gsl/span:394:7: error: redefinition of default argument for ‘long unsigned int Extent’
394 | class span
| ^~~~
/tmp/onnxruntime/build/Linux/RelWithDebInfo/_deps/gsl-src/include/gsl/span_ext:46:51: note: original definition appeared here
46 | template <class ElementType, std::size_t Extent = dynamic_extent>
| ^~~~~~~~~~~~~~~
/tmp/onnxruntime/include/onnxruntime/core/common/span_utils.h:82:93: error: return type ‘class gsl::span<const std::byte>’ is incomplete
82 | [[nodiscard]] inline gsl::span<const std::byte> AsByteSpan(const void* data, size_t length) {
| ^
/tmp/onnxruntime/include/onnxruntime/core/common/span_utils.h: In function ‘void onnxruntime::AsByteSpan(const void*, size_t)’:
/tmp/onnxruntime/include/onnxruntime/core/common/span_utils.h:83:68: error: class template argument deduction failed:
83 | return gsl::span(reinterpret_cast<const std::byte*>(data), length);
| ^
/tmp/onnxruntime/include/onnxruntime/core/common/span_utils.h:83:68: error: no matching function for call to ‘span(const std::byte*, size_t&)’
/tmp/onnxruntime/build/Linux/RelWithDebInfo/_deps/gsl-src/include/gsl/span:740:1: note: candidate: ‘template<class Type, long unsigned int Extent> gsl::span(Type (&)[Extent])-> gsl::span<ElementType, FirstExtent>’
740 | span(Type (&)[Extent]) -> span<Type, Extent>;
| ^~~~
/tmp/onnxruntime/build/Linux/RelWithDebInfo/_deps/gsl-src/include/gsl/span:740:1: note: template argument deduction/substitution failed:
/tmp/onnxruntime/include/onnxruntime/core/common/span_utils.h:83:68: note: mismatched types ‘Type [Extent]’ and ‘const std::byte*’
83 | return gsl::span(reinterpret_cast<const std::byte*>(data), length);
| ^
/tmp/onnxruntime/build/Linux/RelWithDebInfo/_deps/gsl-src/include/gsl/span:743:1: note: candidate: ‘template<class Type, long unsigned int Size> gsl::span(std::array<_Tp, _Nm>&)-> gsl::span<ElementType, FirstExtent>’
743 | span(std::array<Type, Size>&) -> span<Type, Size>;
| ^~~~
/tmp/onnxruntime/build/Linux/RelWithDebInfo/_deps/gsl-src/include/gsl/span:743:1: note: template argument deduction/substitution failed:
/tmp/onnxruntime/include/onnxruntime/core/common/span_utils.h:83:68: note: mismatched types ‘std::array<_Tp, _Nm>’ and ‘const std::byte*’
83 | return gsl::span(reinterpret_cast<const std::byte*>(data), length);
| ^
```
### Motivation and Context
<!-- - Why is this change required? What problem does it solve?
- If it fixes an open issue, please link to the issue here. -->
93 lines
3 KiB
C++
93 lines
3 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
|
|
#include "core/common/gsl.h"
|
|
|
|
namespace onnxruntime {
|
|
|
|
// AsSpan inspired by Fekir's Blog https://fekir.info/post/span-the-missing-constructor/
|
|
// Used under MIT license
|
|
|
|
// Use AsSpan for less typing on any container including initializer list to create a span
|
|
// (unnamed, untyped initializer list does not automatically convert to gsl::span).
|
|
// {1, 2, 3} as such does not have a type
|
|
// (see https://scottmeyers.blogspot.com/2014/03/if-braced-initializers-have-no-type-why.html)
|
|
//
|
|
// Example: AsSpan({1, 2, 3}) results in gsl::span<const int>
|
|
//
|
|
// The above would deduce to std::initializer_list<int> and the result is gsl::span<const int>
|
|
//
|
|
// AsSpan<int64_t>({1, 2, 3}) produces gsl::span<const int64_t>
|
|
//
|
|
// We can also do std::array<int64_t, 3>{1, 2, 3} that can be automatically converted to span
|
|
// without memory allocation.
|
|
//
|
|
// If type conversion is not required, then for C++17 std::array template parameters are
|
|
// auto-deduced. Example: std::array{1, 2, 3}.
|
|
// We are aiming at not allocating memory dynamically.
|
|
|
|
namespace details {
|
|
template <class P>
|
|
constexpr auto AsSpanImpl(P* p, size_t s) {
|
|
return gsl::span<P>(p, s);
|
|
}
|
|
} // namespace details
|
|
|
|
template <class C>
|
|
constexpr auto AsSpan(C& c) {
|
|
return details::AsSpanImpl(c.data(), c.size());
|
|
}
|
|
|
|
template <class C>
|
|
constexpr auto AsSpan(const C& c) {
|
|
return details::AsSpanImpl(c.data(), c.size());
|
|
}
|
|
|
|
template <class C>
|
|
constexpr auto AsSpan(C&& c) {
|
|
return details::AsSpanImpl(c.data(), c.size());
|
|
}
|
|
|
|
template <class T>
|
|
constexpr auto AsSpan(std::initializer_list<T> c) {
|
|
return details::AsSpanImpl(c.begin(), c.size());
|
|
}
|
|
|
|
template <class T, size_t N>
|
|
constexpr auto AsSpan(T (&arr)[N]) {
|
|
return details::AsSpanImpl(arr, N);
|
|
}
|
|
|
|
template <class T, size_t N>
|
|
constexpr auto AsSpan(const T (&arr)[N]) {
|
|
return details::AsSpanImpl(arr, N);
|
|
}
|
|
|
|
template <class T>
|
|
inline gsl::span<const T> EmptySpan() { return gsl::span<const T>(); }
|
|
|
|
template <class U, class T>
|
|
[[nodiscard]] inline gsl::span<U> ReinterpretAsSpan(gsl::span<T> src) {
|
|
// adapted from gsl-lite span::as_span():
|
|
// https://github.com/gsl-lite/gsl-lite/blob/4720a2980a30da085b4ddb4a0ea2a71af7351a48/include/gsl/gsl-lite.hpp#L4102-L4108
|
|
Expects(src.size_bytes() % sizeof(U) == 0);
|
|
return gsl::span<U>(reinterpret_cast<U*>(src.data()), src.size_bytes() / sizeof(U));
|
|
}
|
|
|
|
[[nodiscard]] inline gsl::span<const std::byte> AsByteSpan(const void* data, size_t length) {
|
|
return gsl::span<const std::byte>(reinterpret_cast<const std::byte*>(data), length);
|
|
}
|
|
|
|
template <class T1, size_t Extent1, class T2, size_t Extent2>
|
|
[[nodiscard]] inline bool SpanEq(gsl::span<T1, Extent1> a, gsl::span<T2, Extent2> b) {
|
|
static_assert(std::is_same_v<std::remove_const_t<T1>, std::remove_const_t<T2>>,
|
|
"T1 and T2 should be the same type except for const qualification");
|
|
return std::equal(a.begin(), a.end(), b.begin(), b.end());
|
|
}
|
|
|
|
} // namespace onnxruntime
|